Autenticação

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.

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:

1. O cliente usa credenciais do Amazon Web Services IAM para criar uma assinatura que é enviada ao MongoDB Server.

2. O servidor envia uma solicitação ao Amazon Web Services STS usando a assinatura do cliente.

3. 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.

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.

As credenciais temporárias são usadas com:

• STS Assumir Função pedidos.

• Roles da instância EC2 .

• Roles de tarefa do ECS.

• Ambiente do Amazon Web Services Lambda .

• Funções de IAM para contas de serviço.

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.

client = Mongo::Client.new(['mongodb.example.com'],
  auth_mech: :aws,
  user: '<AWS-ACCESS-KEY-ID>',
  password: '<AWS-SECRET-ACCESS-KEY>',
  database: 'mydb',
)

client = Mongo::Client.new(
  'mongodb://<AWS-ACCESS-KEY-ID>:<AWS-SECRET-ACCESS-KEY>@mongodb.example.com/mydb?authMechanism=MONGODB-AWS')

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',
)

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>')

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')

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.

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.

# 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 )