Autenticação
Nesta página
O MongoDB oferece suporte a uma variedade demecanismos de autenticação .
Para obter mais informações sobre como configurar seu servidor MongoDB para cada um desses mecanismos de autenticação, consulte a documentação online do MongoDB.
Para obter mais informações sobre os usuários e os ajudantes do driver Ruby para gerenciamento de usuários, consulte otutorial Gerenciamento de usuários.
Fornecendo credenciais
Se a autenticação estiver habilitada, forneça as credenciais ao criar um novo cliente:
client = Mongo::Client.new([ '127.0.0.1:27017' ], user: 'test', password: '123', database: 'mydb' ) # If using a URI: client = Mongo::Client.new("mongodb://test:123@127.0.0.1:27017/mydb")
As credenciais de autenticação podem ser alteradas em uma instância do cliente para obter um novo cliente utilizando o método Client#with :
authenticated_client = client.with( user: 'another-user', password: '123' )
Também é possível alterar o reconhecimento de data center e as credenciais do cliente em uma etapa:
authenticated_music_client = client.with( database: 'music', user:'test', password:'123' )
Fonte de autenticação
A fonte de autenticação de um usuário é o reconhecimento de data center onde as credenciais de autenticação desse usuário são armazenadas.
A origem de autenticação do usuário pode ser especificada sempre que as credenciais forem especificadas:
client = Mongo::Client.new([ '127.0.0.1:27017' ], database: 'mydb', user: 'test', password: '123', auth_source: 'admin' ) # If using a URI: client = Mongo::Client.new("mongodb://test:123@127.0.0.1:27017/mydb?authSource=admin")
Se nenhuma fonte de autenticação for especificada, um padrão será assumido pelo cliente. A fonte de autenticação padrão depende do mecanismo de autenticação que está sendo usado para se conectar.
Para o mecanismo de autenticação MONGODB-CR, SCRAM-SHA-1 e SCRAM-SHA-256, a origem de autenticação padrão é o reconhecimento de data center ao qual o cliente está se conectando; se nenhum reconhecimento de data center for especificado, o reconhecimento de data center admin será o reconhecimento de data center padrão e, portanto, a fonte de autenticação padrão. Para o mecanismo PLAIN (LDAP), a fonte de autenticação padrão é o reconhecimento de data center ao qual o cliente está se conectando; se nenhum reconhecimento de data center for especificado, o reconhecimento de data center $external será usado como fonte de autenticação. Para os mecanismos AWS, GSSAPI e MONGODB_X509 , a fonte de autenticação é sempre $external.
Quando um cliente é construído usando um URI SRV, o driver procurará opções de URI em um registro DNS TXT que corresponde ao registro SRV. Assim, por exemplo, o MongoDB Atlas geralmente usa o banco de dados admin como sua fonte de autenticação, mas isso não é especificado nos URIs do SRV porque o banco de dados é fornecido como uma opção de URI nos registros TXT.
Observe que, ao usar URIs SRV, a query SRV e a query TXT são realizadas separadamente. Em sistemas em que a resolução de DNS não é 100% confiável, a falha na pesquisa de registros TXT pode causar erros de autenticação, pois o driver pode acabar usando uma fonte de autenticação incorreta. Se a resolução de DNS confiável não puder ser garantida, a fonte de autenticação poderá ser especificada explicitamente nos URIs SRV como uma opção de URI:
Mongo::Client.new("mongodb+srv://username:myRealPassword@cluster0.mongodb.net/test?w=majority&authSource=admin")
Observação
Ao alterar o banco de dados utilizando o método with , a origem de autenticação é determinada na nova instância do Client utilizando o conjunto completo de opções que se aplicam a ela. Por exemplo, se o cliente original tivesse uma fonte de autenticação especificada, essa fonte de autenticação teria precedência sobre o banco de dados fornecido na chamada with . Se o cliente original não tivesse uma fonte de autenticação especificada, o novo banco de dados seria a nova fonte de autenticação, sujeita às regras do mecanismo de autenticação usado.
Mecanismos de autenticação
O MongoDB suporta vários mecanismos de autenticação, conforme detalhado nesta seção. O mecanismo de autenticação a ser usado pode ser explicitamente especificado quando um cliente é criado; se o mecanismo de autenticação não for fornecido pelo aplicativo, ele será selecionado da seguinte forma:
Para o MongoDB 4.0 e superior, o cliente realiza a negociação do mecanismo SCRAM com o servidor. Se o usuário especificado na configuração do cliente permitir a autenticação com SCRAM-SHA-256, o SCRAM-SHA-256 será usado para autenticação. Caso contrário, o SCRAM-SHA-1 será usado.
Para MongoDB 3.0 a 3.6, SCRAM-SHA-1 é usado.
Para o MongoDB 2.6, o MONGODB-CR é usado.
Observe que:
Os mecanismo de autenticação X.509, Amazon Web Services, LDAP e Kerberos devem sempre ser explicitamente solicitados.
Se o MongoDB Server ao qual o cliente está se conectando suportar SCRAM, o cliente tentará autenticar usando SCRAM se nenhum mecanismo de autenticação for explicitamente especificado. Para autenticar no MongoDB 3.0 e em servidores superiores usando o MONGODB-CR, o mecanismo MONGODB-CR deve ser explicitamente solicitado.
SCRAM
A autenticação SCRAM é o mecanismo de autenticação padrão para MongoDB. Existem dois mecanismos SCRAM no MongoDB: SCRAM-SHA-1 (disponível a partir do MongoDB 3.0) e SCRAM-SHA-256 (disponível a partir do MongoDB 4.0). Se um mecanismo de autenticação não for especificado, mas as credenciais do usuário forem, o driver tentará usar a autenticação SCRAM no servidor 3.0 ou mais recente e negociará o mecanismo a ser usado com base na versão do servidor e nos mecanismos definidos para um usuário específico (é possível configurar um usuário no servidor para permitir apenas SCRAM-SHA-1 mecanismo , somente SCRAM -SHA-256 mecanismo ou ambos).
Para especificar explicitamente SCRAM-SHA-1 como o mecanismo de autenticação, utilize a opção auth_mech: :scram do cliente Ruby ou o SCRAM-SHA-1 como o valor para a opção authMechanism URI, como segue:
client = Mongo::Client.new([ '127.0.0.1:27017' ], database: 'mydb', user: 'test', password: '123', auth_mech: :scram ) client = Mongo::Client.new("mongodb://test:123@127.0.0.1:27017/mydb?authMechanism=SCRAM-SHA-1")
Para especificar explicitamente o SCRAM-SHA-256 como o mecanismo de autenticação, use a opção auth_mech: :scram256 do cliente Ruby ou o SCRAM-SHA-256 como o valor da opção authMechanism URI, da seguinte forma:
client = Mongo::Client.new([ '127.0.0.1:27017' ], database: 'mydb', user: 'test', password: '123', auth_mech: :scram256 ) client = Mongo::Client.new("mongodb://test:123@127.0.0.1:27017/mydb?authMechanism=SCRAM-SHA-256")
Certificado de cliente (X.509)
O driver apresenta um certificado X.509 durante a negociação TLS. O mecanismo de autenticação MongoDB-X509 autentica um nome de usuário recuperado do nome de assunto distinto deste certificado.
Observação
Como o nome de usuário é recuperado do certificado, um nome de usuário não precisa ser especificado. Se um nome de usuário for especificado, ele será enviado ao servidor integralmente. Se uma senha for fornecida, um erro será gerado.
Esse método de autenticação requer o uso de conexões TLS com validação de certificado.
Para autenticar o cliente, você precisará de um certificado TLS válido e de uma chave de criptografia privada. Eles podem ser armazenados em arquivos separados ou juntos em um arquivo (no formato PEM). Mesmo que o certificado e a chave privada estejam armazenados no mesmo arquivo, você deve especificar o caminho para esse arquivo passando as opções ssl_cert e ssl_key para o cliente.
Para obter mais informações sobre como configurar a autenticação X.509 no MongoDB, consulte o tutorial X.509 no Manual do MongoDB.
client = Mongo::Client.new([ '127.0.0.1:27017' ], auth_mech: :mongodb_x509, ssl: true, ssl_cert: '/path/to/client.pem', ssl_key: '/path/to/client.pem', ssl_ca_cert: '/path/to/ca.pem' )
AWS
Requer MongoDB Enterprise Edition e versão 4.4 ou posterior do servidor.
O mecanismo de autenticação do Amazon Web Services utiliza o Amazon Web Services Identity e Access Management (IAM) e Amazon Web Services Security Token Service (STS) para provar a identidade do cliente para um MongoDB servidor . Resumindo, a autenticação do Amazon Web Services funciona da seguinte forma:
O cliente usa credenciais do Amazon Web Services IAM para criar uma assinatura que é enviada ao MongoDB Server.
O servidor envia uma solicitação ao Amazon Web Services STS usando a assinatura do cliente.
Uma solicitação STS bem-sucedida retorna o nome de usuário (criptograficamente, o ARN do usuário ou função do IAM) correspondente às credenciais que o cliente usou. O ARN de usuário do IAM é usado pelo servidor para procurar um usuário definido, e considera-se que o cliente foi autenticado como esse usuário.
Observação
Ao contrário de outros mecanismo de autenticação, o nome de usuário que a aplicação fornece ao criar um cliente e o nome de usuário do servidor são diferentes: o nome de usuário do cliente é o ID da chave de acesso Amazon Web Services, mas o nome de usuário no servidor é o ARN do usuário do IAM ou role correspondente ao ID da chave de acesso.
As credenciais Amazon Web Services são compostas por:
O ID da chave de acesso.
A chave de acesso secreta.
O token de sessão opcional.
Autenticação com credenciais do Amazon Web Services IAM, usa a da chave de acesso ID e a chave de acesso secreta. Autenticação com credenciais temporárias do Amazon Web Services IAM usa todos os três componentes.
Observação
O driver nunca envia a chave de acesso secreta ou o token de sessão pela rede.
As credenciais temporárias são usadas com:
STS Assumir Função pedidos.
O driver Ruby permite fornecer credenciais regulares e temporárias explicitamente como opções Ruby ou opções URI. Se as credenciais não forem explicitamente fornecidas, o driver tentará recuperá-las das variáveis de ambiente descritas abaixo e dos endpoints de metadados de tarefas do ECS e de instância do EC2.
Fornecendo credenciais explicitamente
Credenciais IAM regulares (não temporárias) podem ser fornecidas como opções Ruby, da seguinte forma:
client = Mongo::Client.new(['mongodb.example.com'], auth_mech: :aws, user: '<AWS-ACCESS-KEY-ID>', password: '<AWS-SECRET-ACCESS-KEY>', database: 'mydb', )
Eles também podem ser fornecidos por meio de um URI:
client = Mongo::Client.new( 'mongodb://<AWS-ACCESS-KEY-ID>:<AWS-SECRET-ACCESS-KEY>@mongodb.example.com/mydb?authMechanism=MONGODB-AWS')
Observação
Quando as credenciais são fornecidas por meio de um URI, elas devem ter uma porcentagem de escape.
Para fornecer credenciais temporárias, especifique o token de sessão nas propriedades do mecanismo de autenticação da seguinte forma:
client = Mongo::Client.new(['mongodb.example.com'], auth_mech: :aws, user: '<AWS-ACCESS-KEY-ID>', password: '<AWS-SECRET-ACCESS-KEY>', auth_mech_properties: { aws_session_token: '<AWS-SESSION-TOKEN>', }, database: 'mydb', )
As credenciais temporárias também podem ser fornecidas por meio de um URI:
client = Mongo::Client.new( 'mongodb://<AWS-ACCESS-KEY-ID>:<AWS-SECRET-ACCESS-KEY>@mongodb.example.com/mydb?authMechanism=MONGODB-AWS&authMechanismProperties=AWS_SESSION_TOKEN:<AWS-SESSION-TOKEN>')
Recuperando credenciais automaticamente
O cliente pode recuperar credenciais do ambiente ou dos endpoints de metadados EC2 ou ECS. Para recuperar credenciais automaticamente, especifique o mecanismo de autenticação Amazon Web Services, mas não especifique um nome de usuário nem uma senha:
client = Mongo::Client.new(['mongodb.example.com'], auth_mech: :aws, database: 'mydb', ) # Using a URI: client = Mongo::Client.new( 'mongodb://mongodb.example.com/mydb?authMechanism=MONGODB-AWS')
O driver tentará obter credenciais das seguintes fontes, na ordem especificada:
AWS_ACCESS_KEY_ID,AWS_SECRET_ACCESS_KEYeAWS_SESSION_TOKENvariáveis de ambiente. Essas variáveis de ambiente são reconhecidas por uma variedade de bibliotecas e ferramentas relacionadas à AWS, como o AWS Ruby SDK oficial e a AWS CLI. Eles também são definidos durante a execução em um ambiente do Amazon Web Services Lambda.A ação AssumeRoleWithWebIdentity do STS do Amazon Web Services . Isso retorna credenciais associadas ao token da conta de serviço. Esse mecanismo requer a definição das seguintes variáveis de ambiente:
AWS_WEB_IDENTITY_TOKEN_FILE- caminho para um arquivo que contém o token da conta de serviço.AWS_ROLE_ARN- o nome do recurso da Amazon (ARN) da função que o chamador está assumindo.AWS_ROLE_SESSION_NAME(opcional) - Um identificador para a sessão de função presumida. Se omitido, um nome aleatório será gerado pelo driver.
O endpoint de metadados de tarefa do Amazon Web Services ECS . Isso retorna credenciais associadas à função de tarefa ECS atribuída ao container.
O2 endpoint de metadados da instância do Amazon Web Services EC . Retorna as credenciais associadas à função de instância do EC2 atribuída à instância.
Observação
Uma fonte de credenciais que fornece quaisquer credenciais deve fornecer um conjunto completo de credenciais. Por exemplo, o driver gerará um erro se somente uma das variáveis de ambiente AWS_ACCESS_KEY_ID ou AWS_SECRET_ACCESS_KEY for preenchida, mas não a outra.
Observação
Se um aplicativo estiver em execução em um container ECS em uma2 instância do EC e o container tiver acesso permitido aos metadados da instância, o driver tentará recuperar as credenciais do mecanismo de autenticação da Amazon Web Services do2 endpoint de metadados da instância do EC, potencialmente autenticando como a função IAM atribuída à2 instância do EC, se ela não tiver sido capaz de recuperar a tarefa do ECS credenciais de função do endpoint de tarefa ECS.
LDAP (SASL PLAIN)
Exige a edição MongoDB Enterprise.
A edição MongoDB Enterprise oferece suporte ao mecanismo de autenticação LDAP, que permite delegar autenticação usando um LDAP servidor.
Aviso
Ao usar o LDAP, as senhas são enviadas ao servidor em texto simples. Por esse motivo, é altamente recomendável habilitar o TLS ao usar o LDAP como mecanismo de autenticação.
Para obter mais informações sobre como configurar a autenticação LDAP no MongoDB, consulte o tutorial SASL/LDAP no Manual do MongoDB.
client = Mongo::Client.new([ '127.0.0.1:27017' ], auth_mech: :plain, ssl: true, ssl_verify: true, ssl_cert: '/path/to/client.pem', ssl_ca_cert: '/path/to/ca.pem' )
Kerberos (GSSAPI)
Exige a edição MongoDB Enterprise.
Para configurar o servidor MongoDB para usar o Kerberos, consulte a documentação do Kerberos do servidor.
Para usar o mecanismo de autenticação Kerberos com o driver Ruby MongoDB, uma biblioteca adicional que implemente o autenticador Kerberos - mongo_kerberos - deve ser instalado e carregado. Para fazer isso, adicione ao seu Gemfile:
gem 'mongo', '~> 2' gem 'mongo_kerberos', '~> 2'
... e adicione ao código do seu aplicativo:
require 'mongo' require 'mongo_kerberos'
Se estiver usando a autenticação Kerberos com MRI, a senha não será especificada na configuração do driver e não será enviada ao servidor MongoDB pelo driver. Em vez disso, uma sessão Kerberos deve ser estabelecida externamente ao driver e essa sessão é usada pelo driver para provar a identidade do usuário ao servidor. O estabelecimento desta sessão requer que o sistema host esteja configurado para autenticação Kerberos; consulte a documentação do Kerberos ou a documentação do seu sistema operacional para obter detalhes. Use o utilitário kinit para estabelecer uma sessão Kerberos.
Se estiver usando a autenticação Kerberos com JRuby, a sessão Kerberos poderá ser estabelecida externamente ao driver usando o processo descrito acima para MRI; como alternativa, a senha pode ser fornecida diretamente ao driver por meio da configuração do cliente ou o caminho para um arquivo keytab pode ser fornecido por meio da configuração armazenada na propriedade do sistema java.security.auth.login.config . Além disso, o ambiente de tempo de execução Java deve ser configurado para Kerberos; consulte a documentação do MongoDB Java Driver Kerberos para mais informações.
Observação
De acordo com a documentação Kerberos do servidor, o FQDN do host que executa o MongoDB deve ser especificado ao usar a autenticação Kerberos.
Observação
Se estiver usando URIs do MongoDB, certifique-se de evitar a porcentagem de caracteres especiais como / e @ quando eles aparecerem no nome de usuário.
# Authenticate as appuser@MYREALM: client = Mongo::Client.new("mongodb://appuser%40MYREALM@myserver.mycompany.com:27017/mydb?authMechanism=GSSAPI") # Authenticate as myapp/appuser@MYREALM: client = Mongo::Client.new("mongodb://myapp%2Fappuser%40MYREALM@myserver.mycompany.com:27017/mydb?authMechanism=GSSAPI") # Authenticate using Ruby options: client = Mongo::Client.new(['myserver.mycompany.com:27017'], auth_mech: :gssapi, user: 'myapp/appuser@MYREALM')
MONGODB-CR
Obsoleto : o mecanismo MONGODB-CR está obsoleto a partir do MongoDB 3.6 e removido a partir do MongoDB 4.0. Em vez disso, use a autenticação SCRAM .
O MONGODB-CR era o mecanismo de autenticação padrão para o MongoDB até a versão 2.6.
O mecanismo pode ser explicitamente definido com as credenciais:
client = Mongo::Client.new([ '127.0.0.1:27017' ], database: 'mydb', user: 'test', password: '123', auth_mech: :mongodb_cr )
Observação
Se o MongoDB Server ao qual o cliente está se conectando suportar SCRAM, o cliente tentará autenticar usando SCRAM se nenhum mecanismo de autenticação for explicitamente especificado. Para autenticar no MongoDB 3.0 e em servidores superiores usando o MONGODB-CR, o mecanismo MONGODB-CR deve ser explicitamente solicitado.