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, puedes especificar el mecanismo, tus credenciales y otra información necesaria en las opciones de tu 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 por respuesta de desafío salado (SCRAM) se refiere a un grupo de mecanismos de autenticación que utilizan nombre de usuario y contraseña para autenticar a 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 contraseña de tu base de datos, cifrados con el algoritmo SHA-256. Este es el mecanismo de autenticación por defecto.

• 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 tus credenciales de Amazon Web Services Identity and Access Gestión (AWS IAM) para autenticar a tu 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.2"
features = [ "aws-auth", ... ]

El controlador obtiene las credenciales únicamente de la primera fuente en la que se encuentran. El controlador verifica tus credenciales en las siguientes fuentes y en el siguiente orden:

1. Credential estructura o cadena de conexión.

2. Variables de entorno.

3. Archivo de token de identidad web.

4. Endpoint 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 especificas tus credenciales de AWS en tu cadena de conexión, el controlador usará esas credenciales e ignorará cualquier otra que puedas haber especificado en las variables de entorno.

Seleccionar de la Credential Struct. Environment Variables y Web Identity Token File pestañas a continuación para ver muestras de código que demostrarán cómo establecer tus credenciales de AWS IAM de las formas 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, establece el campo mechanism de tu estructura Credential como AuthMechanism::MongoDbX509. Este ejemplo especifica el mecanismo de autenticación utilizando los siguientes marcadores de posición:

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

• path to private client keyRuta del archivo de la clave de tu certificado

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

• dbLa base de datos de autenticación asociada con el usuario

El siguiente código muestra cómo hacer referencia a tus certificados en tu cadena de conexión, especificar el mecanismo de autenticación MONGODB-X509 y conectarte 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.