Mecanismos de autenticación

Overview

En esta guía, aprenderá a usar los mecanismos de autenticación disponibles en MongoDB Community Edition. Al conectarse a MongoDB, puede usar un mecanismo de autenticación para establecer la confianza entre el controlador y el servidor.

Esta guía describe los siguientes mecanismos de autenticación:

• Mecanismos basados ​​en SCRAM

• Mecanismo MONGODB-AWS

• Mecanismo MONGODB-X509

Para seleccionar un mecanismo de autenticación específico, puede especificar el mecanismo, sus credenciales y otra información necesaria en las opciones de su cadena de conexión o en un Credential estructura.

En esta guía, los ejemplos demuestran cómo configurar la autenticación en una estructura Credential.

Para obtener más información sobre las opciones de cadena de conexión para la autenticación, consulta la sección Opciones de autenticación en la guía del Formato URI de Cadena de Conexión en el manual del servidor.

Mecanismos basados ​​en SCRAM

El mecanismo de autenticación de respuesta al desafío con sal (SCRAM) se refiere a un grupo de mecanismos de autenticación que utilizan un nombre de usuario y una contraseña para autenticarse en un servidor.

MongoDB admite los siguientes mecanismos de autenticación basados en SCRAM:

• SCRAM-SHA-:256 Un mecanismo de autenticación que utiliza el nombre de usuario y la contraseña de su base de datos, cifrados con el SHA-256 algoritmo. Este es el mecanismo de autenticación predeterminado.

• SCRAM-SHA-:1 Un mecanismo de autenticación que utiliza su nombre de usuario y contraseña de la base de datos, encriptados con el SHA-1 algoritmo.

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

El mecanismo de autenticación MONGODB-AWS utiliza sus credenciales de Amazon Web Services Identity and Access Management (AWS IAM) para autenticar a su usuario.

Para usar este mecanismo de autenticación, debe agregar la marca de función aws-auth a su dependencia mongodb en el archivo Cargo.toml de su proyecto. A continuación, se muestra un ejemplo de lo que debe incluir la lista de funciones de su dependencia mongodb para habilitar el mecanismo de autenticación MONGODB-AWS:

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

El controlador obtiene las credenciales solo de la primera fuente donde las encuentra. El controlador busca sus credenciales en las siguientes fuentes en el siguiente orden:

1. Credential estructura o cadena de conexión.

2. Variables de entorno.

3. Archivo de token de identidad web.

4. Punto final de AWS ECS especificado en la variable de entorno AWS_CONTAINER_CREDENTIALS_RELATIVE_URI.

5. Punto de conexión de AWS EC. Para obtener2 más información, consulte Roles de IAM para tareas. en la documentación de AWS.

Por ejemplo, si especifica sus credenciales de AWS en su cadena de conexión, el controlador utiliza esas credenciales e ignora cualquiera que haya especificado en las variables de entorno.

Seleccione de la Credential Struct, Environment Variables y Web Identity Token File a continuación para obtener ejemplos de código que demuestran cómo configurar sus credenciales de AWS IAM de las maneras correspondientes.

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

El mecanismo de autenticación MONGODB-X509 utiliza seguridad de nivel de transporte (TLS) con certificados X.509 para autenticar a su usuario, que se identifica mediante los nombres distinguidos relativos (RDN) de su certificado de cliente.

Al especificar este mecanismo de autenticación, debe proporcionar los siguientes archivos:

• Un archivo de autoridad de certificación (CA) que contiene una o más autoridades de certificación en las que se puede confiar al establecer una conexión TLS. Antes de conectarse al servidor, el controlador utiliza este archivo para verificar que el certificado del servidor provenga de una de las autoridades de certificación especificadas.

• Un archivo de clave de certificado que contiene el certificado del cliente y la clave privada. El controlador presenta este archivo al servidor para verificar al cliente.

Para especificar el mecanismo de autenticación MONGODB-X509, establezca el campo mechanism de su estructura Credential en AuthMechanism::MongoDbX509. Este ejemplo especifica el mecanismo de autenticación mediante los siguientes marcadores de posición:

• path to CA certificate:La ruta del archivo de su CA

• path to private client key:La ruta del archivo de clave de su certificado

• password for client key: La contraseña utilizada para descifrar la clave del cliente

• db:La base de datos de autenticación asociada con el usuario

El siguiente código muestra cómo hacer referencia a sus certificados en su cadena de conexión, especificar el mecanismo de autenticación MONGODB-X509 y conectarse a MongoDB:

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

Información Adicional

Para obtener más información sobre la autenticación en MongoDB, consulte Autenticación en el manual del servidor.

Para aprender más sobre cómo gestionar usuarios en tu implementación de MongoDB, consulta Usuarios en el manual del servidor.