Mecanismos de autenticación empresarial

Ejemplo

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

• username:Su 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:Su 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 TOKEN_RESOURCE en el valor del parámetro de audiencia configurado en su implementación de MongoDB.

El siguiente ejemplo de código muestra cómo configurar 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 configurar 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 utilizando la compatibilidad con Kubernetes integrada del controlador Rust.

Puede configurar OIDC para Kubernetes estableciendo el campo mechanism de su estructura Credential en AuthMechanism::MongoDbOidc. Luego, especifique el mecanismo de autenticación estableciendo la propiedad ENVIRONMENT en k8s en el campo mechanism_properties.

El siguiente ejemplo de código muestra cómo configurar 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?;

Devolución de llamada personalizada

El controlador de Rust no ofrece compatibilidad integrada con todas las plataformas, incluido AWS Elastic Kubernetes Service (EKS). Para usar OIDC para la autenticación en plataformas no compatibles, debe definir una función de devolución de llamada 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 devolución de llamada personalizada para gestionar la identidad del personal. Para adaptar este ejemplo a su caso de uso, reemplace <human flow> con su propio flujo personalizado. Consulte Flujo de código de autorización con OIDC para obtener más información.

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, consulte la siguiente documentación de API:

• Credencial

• Opciones del cliente

• Cliente

• con_opciones()

• CallbackContext

• Respuesta del servidor Idp

• IdpServerInfo