Mecanismos de autenticación de empresa

Ejemplo

Para especificar el mecanismo de autenticación PLAIN, establece el campo mechanism de tu estructura Credential como AuthMechanism::Plain. Este ejemplo especifica el mecanismo de autenticación utilizando los siguientes marcadores de posición:

• username: Tu nombre de usuario LDAP

• password: Tu contraseña LDAP

let plain_cred = Credential::builder()
    .username("<username>".to_string())
    .password("<password>".to_string())
    .mechanism(AuthMechanism::Plain)
    .source("$external".to_string())
    .build();
client_options.credential = Some(plain_cred);
let client = Client::with_options(client_options)?;

Como alternativa, puede autenticarse mediante un URI de cadena de conexión estableciendo el valor de la opción de cadena de conexión authMechanism en PLAIN. Este ejemplo muestra cómo especificar el mecanismo de autenticación PLAIN en un URI de cadena de conexión mediante los siguientes marcadores de posición:

• username: Tu nombre de usuario LDAP

• password: Tu contraseña LDAP

• hostname: La dirección de red de su servidor MongoDB

let uri = "mongodb://<username>:<password>@<hostname>/?authSource=$external&authMechanism=PLAIN";

IMDS de Azure

Si su aplicación se ejecuta en una máquina virtual de Azure o utiliza el Servicio de metadatos de instancia de Azure (IMDS), puede autenticarse en MongoDB mediante la compatibilidad integrada con Azure del controlador Rust.

Puedes configurar OIDC para Azure IMDS estableciendo el campo mechanism de tu estructura Credential a AuthMechanism::MongoDbOidc. Este ejemplo especifica el mecanismo de autenticación utilizando los siguientes marcadores de posición:

• usernameSi usa una identidad administrada de Azure, configúrela con el identificador de cliente de dicha identidad. Si usa una entidad de servicio para representar una aplicación empresarial, configúrela con el identificador de aplicación de la entidad de servicio.

• mechanism_properties: Establezca la propiedad ENVIRONMENT en azure y el TOKEN_RESOURCE al valor del parámetro de audiencia configurado en su implementación de MongoDB.

El siguiente ejemplo de código muestra cómo establecer estas opciones al crear un Client:

let credential = Credential::builder()
    .username("<username>".to_owned())
    .mechanism(AuthMechanism::MongoDbOidc)
    .mechanism_properties(
        doc! { "ENVIRONMENT": "azure", "TOKEN_RESOURCE": "<audience>" }
    )
    .build();
client_options.credential = Some(credential);
let client = Client::with_options(client_options)?;
let res = client
    .database("test")
    .collection::<Document>("test")
    .find_one(doc! {})
    .await?;

GCP IMDS

Si su aplicación se ejecuta en una máquina virtual de Google Compute Engine o utiliza el servicio de metadatos de instancia de GCP, puede autenticarse en MongoDB mediante la compatibilidad con GCP integrada del controlador Rust.

Puede configurar OIDC para GCP IMDS estableciendo el campo mechanism de la estructura Credential en AuthMechanism::MongoDbOidc. Luego, especifique el mecanismo de autenticación configurando los siguientes valores en el campo mechanism_properties:

• ENVIRONMENT:Establezca esta propiedad en gcp.

• TOKEN_RESOURCE: Establece este parámetro en el valor del parámetro de audiencia configurado en tu implementación de MongoDB.

El siguiente ejemplo de código muestra cómo establecer estas opciones al crear un Client:

let credential = Credential::builder()
    .mechanism(AuthMechanism::MongoDbOidc)
    .mechanism_properties(
        doc! { "ENVIRONMENT": "gcp", "TOKEN_RESOURCE": "<audience>" }
    )
    .build();
client_options.credential = Some(credential);
let client = Client::with_options(client_options)?;
let res = client
    .database("test")
    .collection::<Document>("test")
    .find_one(doc! {})
    .await?;

Kubernetes

Si su aplicación se ejecuta en un clúster de Kubernetes, puede autenticarse en MongoDB usando la compatibilidad integrada con Kubernetes del controlador de Rust.

Puedes configurar OIDC para Kubernetes configurando el campo mechanism de tu estructura Credential en AuthMechanism::MongoDbOidc. Luego, se debe especificar el mecanismo de autenticación configurando la propiedad ENVIRONMENT a k8s en el campo mechanism_properties.

El siguiente ejemplo de código muestra cómo establecer estas opciones al crear un Client:

let credential = Credential::builder()
.mechanism(AuthMechanism::MongoDbOidc)
.mechanism_properties(
    doc! { "ENVIRONMENT": "k8s" }
)
.build();
client_options.credential = Some(credential);
let client = Client::with_options(client_options)?;
let res = client
    .database("test")
    .collection::<Document>("test")
    .find_one(doc! {})
    .await?;

Función de retorno personalizado

El controlador de Rust no ofrece funcionalidad incorporada para todas las plataformas, incluido el AWS Elastic Kubernetes Service (EKS). Para usar OIDC para autenticarse en plataformas no compatibles, debe definir una función de retorno personalizada.

El siguiente código es un ejemplo de implementación de una devolución de llamada personalizada para un clúster EKS. Primero, establezca el campo oidc_callback de su estructura Credential en oidc::Callback::machine. Luego, lea el token de acceso desde una ruta definida en la variable de entorno AWS_WEB_IDENTITY_TOKEN_FILE. Finalmente, establezca el valor del campo access_token de la estructura IdpServerResponse. Opcionalmente, establezca los valores de los campos expires y refresh_token.

let credential = Credential::builder()
.mechanism(AuthMechanism::MongoDbOidc)
.oidc_callback(oidc::Callback::machine(move |_| {
    async move {
        let token_file_path = std::env::var("AWS_WEB_IDENTITY_TOKEN_FILE").map_err(mongodb::error::Error::custom)?;
        let access_token = tokio::fs::read_to_string(token_file_path).await?;
        Ok(IdpServerResponse::builder().access_token(access_token).build())
    }
    .boxed()
}))
.build()
.into();
client_options.credential = Some(credential);
let client = Client::with_options(client_options)?;
let res = client
    .database("test")
    .collection::<Document>("test")
    .find_one(doc! {})
    .await?;

Cuando el proceso de autenticación de la identidad de la fuerza laboral implique interacción humana, debes configurar el cliente estableciendo el campo oidc_callback de tu struct Credential en oidc::Callback::human en vez de oidc::Callback::machine. El driver Rust utiliza la función de retorno en el siguiente proceso:

1. El controlador recupera la información del proveedor de identidad (IDPInfo) para el nombre de usuario proporcionado.

2. La función de retorno negocia con el proveedor de identidad para obtener un access_token, así como cualquier posible refresh_token y valores de tiempo de espera, si están configurados. La función de retorno retorna un Result<IdpServerInfo>.

El siguiente ejemplo define una función de retorno personalizada para gestionar la identidad de la fuerza laboral. Para personalizar este ejemplo para tu caso de uso, reemplaza <human flow> con tu propio flujo personalizado. Consulta el Flujo de código de autorización con OIDC para obtener más detalles.

let callback = Callback::human(move |context| {
    async move {
        "<human flow>";
        todo!("human flow")
    }
    .boxed()
});
let credential = Credential::builder()
    .mechanism(AuthMechanism::MongoDbOidc)
    .oidc_callback(callback)
    .build();
client_options.credential = Some(credential);
let client = Client::with_options(client_options)?;
let res = client
    .database("test")
    .collection::<Document>("test")
    .find_one(doc! {})
    .await?;

Documentación de la API

Para obtener más información sobre los métodos y tipos mencionados en esta guía, vea la siguiente documentación de la API:

• Credencial

• ClientOptions

• Cliente

• con_opciones()

• CallbackContext

• IdpServerResponse

• IdpServerInfo