Mecanismos de autenticação

Visão geral

Neste guia, você aprenderá a usar os mecanismos de autenticação disponíveis no MongoDB Community Edition. Ao se conectar ao MongoDB, você pode usar um mecanismo de autenticação para estabelecer confiança entre o driver e o servidor.

Este guia descreve os seguintes mecanismos de autenticação:

• Mecanismos baseados em SCRAM

• Mecanismo MONGODB-AWS

• Mecanismo MONGODB-X509

Para selecionar um mecanismo de autenticação específico, você pode especificar o mecanismo, suas credenciais e outras informações necessárias nas opções de sua connection string ou em uma estrutura Credential .

Neste guia, os exemplos demonstram como configurar a autenticação em uma estrutura Credential .

Para saber mais sobre as opções de string de conexão para autenticação, consulte a seção Opções de autenticação do guia Formato de URI da string de conexão no manual do Servidor MongoDB.

Mecanismos baseados em SCRAM

Mecanismo de autenticação de resposta de desafio salgado (SCRAM) refere-se a um grupo de mecanismos de autenticação que usam um nome de usuário e senha para autenticar em um servidor.

O MongoDB suporta os seguintes mecanismos de autenticação baseados em SCRAM:

• SCRAM-SHA-256: um mecanismo de autenticação que utiliza seu nome de usuário e senha do banco de dados de dados, codificado com o algoritmo SHA-256

• SCRAM-SHA-1: um mecanismo de autenticação que utiliza seu nome de usuário e senha do banco de dados de dados, codificado com o algoritmo SHA-1

let uri = "<connection string>";
let mut client_options = ClientOptions::parse(uri).await?;
let default_cred = Credential::builder()
    .username("<db_username>".to_string())
    .password("<db_password>".to_string())
    .source("<db>".to_string())
    .build();
client_options.credential = Some(default_cred);
let client = Client::with_options(client_options)?;

let uri = "<connection string>";
let mut client_options = ClientOptions::parse(uri).await?;
let scram_sha_256_cred = Credential::builder()
    .username("<db_username>".to_string())
    .password("<db_password>".to_string())
    .mechanism(AuthMechanism::ScramSha256)
    .source("<db>".to_string())
    .build();
client_options.credential = Some(scram_sha_256_cred);
let client = Client::with_options(client_options)?;

let uri = "<connection string>";
let mut client_options = ClientOptions::parse(uri).await?;
let scram_sha_1_cred = Credential::builder()
    .username("<db_username>".to_string())
    .password("<db_password>".to_string())
    .mechanism(AuthMechanism::ScramSha1)
    .source("<db>".to_string())
    .build();
client_options.credential = Some(scram_sha_1_cred);
let client = Client::with_options(client_options)?;

Mecanismo MONGODB-AWS

O mecanismo de autenticação do MONGODB-AWS utiliza suas credenciais do Amazon Web Services Identity and Access Management (AWS IAM) para autenticar o usuário.

Para usar esse mecanismo de autenticação, você deve adicionar o sinalizador de recurso aws-auth à sua dependência mongodb no arquivo Cargo.toml do seu projeto. A seguir, um exemplo do que sua lista de recursos de dependência mongodb deve incluir para habilitar o mecanismo de autenticação MONGODB-AWS:

[dependencies.mongodb]
version = "3.1.0"
features = [ "aws-auth", ... ]

O driver obtém as credenciais somente da primeira fonte na qual elas são encontradas. O driver verifica suas credenciais das seguintes fontes na seguinte ordem:

1. Credential struct ou connection string.

2. Variáveis de ambiente.

3. Arquivo de token de identidade da Web.

4. Amazon Web Services ECS endpoint especificado na variável de ambiente do AWS_CONTAINER_CREDENTIALS_RELATIVE_URI .

5. Desfecho AWS EC2 . Para obter mais informações, consulte Funções de IAM para Tarefas na documentação da AWS.

Por exemplo, se você especificar suas credenciais do Amazon Web Services em sua connection string, o driver usará essas credenciais e ignorará as que você tiver especificado nas variáveis de ambiente.

Selecione nas abas Credential Struct, Environment Variables e Web Identity Token File abaixo para obter amostras de código que demonstram como definir suas credenciais do Amazon Web Services IAM das maneiras correspondentes.

1
let uri = "<connection string>";
2
let mut client_options = ClientOptions::parse(uri).await?;
3
4
let aws_cred = Credential::builder()
5
    .username("<access key ID>".to_string())
6
    .password("<secret access key>".to_string())
7
    .source("<db>".to_string())
8
    .mechanism(AuthMechanism::MongoDbAws)
9
    .mechanism_properties(doc!("AWS_SESSION_TOKEN": "<session token>"))
10
    .build();
11
12
client_options.credential = Some(aws_cred);
13
let client = Client::with_options(client_options)?;

export AWS_ACCESS_KEY_ID=<access key ID>
export AWS_SECRET_ACCESS_KEY=<secret access key>
export AWS_SESSION_TOKEN=<session token>

let uri = "<connection string>";
let mut client_options = ClientOptions::parse(uri).await?;
let aws_cred = Credential::builder().mechanism(AuthMechanism::MongoDbAws).build();
client_options.credential = Some(aws_cred);
let client = Client::with_options(client_options)?;

export AWS_WEB_IDENTITY_TOKEN_FILE=<absolute path to OIDC token file>

let uri = "<connection string>";
let mut client_options = ClientOptions::parse(uri).await?;
let aws_cred = Credential::builder().mechanism(AuthMechanism::MongoDbAws).build();
client_options.credential = Some(aws_cred);
let client = Client::with_options(client_options)?;

Mecanismo MONGODB-X509

O mecanismo de autenticação do MONGODB-X509 usa o TLS (Transport Level Security) com certificados X.509 para autenticar o usuário, que é identificado pelos nomes distintos relativos (RDNs) do certificado do cliente.

Quando você especifica esse mecanismo de autenticação, o servidor autentica a conexão lendo os seguintes arquivos:

• Um arquivo de autoridade de certificação (CA), que contém uma ou mais autoridades de certificação nas quais confiar ao fazer uma conexão TLS

• Um arquivo de chave de certificado, que faz referência à chave privada de certificado do cliente

Para especificar o MONGODB-X509 mecanismo de autenticação , defina o mechanism campo da estrutura Credential como AuthMechanism::MongoDbX509. Este exemplo especifica o mecanismo de autenticação usando os seguintes placeholders:

• path to CA certificate: O caminho de arquivo para seu arquivo CA

• path to private client key: O caminho de arquivo para seu arquivo de chave de certificado

• db: O banco de dados de autenticação associado ao usuário

O código a seguir mostra como fazer referência a seus certificados em sua connection string, especificar o mecanismo de autenticação MONGODB-X509 e conectar-se ao MongoDB:

let uri = format!(
    "mongodb://<hostname>:<port>/?tlsCAFile={tlsCAFile}&tlsCertificateKeyFile={tlsCertificateKeyFile}",
    tlsCAFile = "<path to CA certificate>",
    tlsCertificateKeyFile = "<path to private client key>"
);
let mut client_options = ClientOptions::parse(uri).await?;
let x509_cred = Credential::builder().mechanism(AuthMechanism::MongoDbAws).build();
client_options.credential = Some(x509_cred);
let client = Client::with_options(client_options)?;

Informações adicionais

Para saber mais sobre autenticação no MongoDB, consulte Autenticação no manual do servidor MongoDB.

Para saber mais sobre como gerenciar usuários da sua MongoDB deployment, consulte Usuários no manual do Servidor MongoDB.