Mecanismos de autenticación

Overview

En esta guía, puede aprender a utilizar los mecanismos de autenticación disponibles en MongoDB Community Edition. Cuando te conectas a MongoDB, puedes utilizar 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 struct.

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 tu nombre de usuario y contraseña de la base de datos, cifrado con el algoritmo SHA-256

• SCRAM-SHA-1: un mecanismo de autenticación que utiliza tu nombre de usuario y contraseña de la base de datos, cifrado con el algoritmo SHA-1

let uri = "<connection string>";
let mut client_options = ClientOptions::parse_async(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_async(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_async(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 utilizar este mecanismo de autenticación, debe añadir la bandera de funcionalidad 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 tu lista de funcionalidades de dependencias de mongodb para habilitar el mecanismo de autenticación MONGODB-AWS:

[dependencies.mongodb]
version = "2.8.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 final de AWS EC2. Para obtener más información, consulte Roles 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_async(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_async(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_async(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 tu usuario, identificado por los nombres distinguidos relativos (RDNs) de tu certificado de cliente.

Cuando se especifica este mecanismo de autenticación, el servidor autentifica la conexión leyendo los siguientes archivos:

• Un archivo de autoridad certificadora (CA), que contiene una o más autoridades certificadoras en las que confiar al establecer una conexión TLS

• Un archivo de clave del certificado que hace referencia a la llave privada del certificado de 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

• 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}",
    tlsCAFile = "<path to CA certificate>",
    tlsCertificateKeyFile = "<path to private client key>"
);
let mut client_options = ClientOptions::parse_async(uri).await?;
let x509_cred = Credential::builder().mechanism(AuthMechanism::MongoDbAws).build();
client_options.credential = Some(x509_cred);
let client = Client::with_options(client_options)?;

Información Adicional

Para aprender más sobre la autenticación en MongoDB, consulta 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.