OIDC (Federación de Identidad de Carga de Trabajo)

Overview

El controlador de Rust admite la autenticación OpenID Connect (OIDC) para identidades de carga de trabajo. Una identidad de carga de trabajo es una identidad que asignas a una carga de trabajo de software, como una aplicación, servicio, script o contenedor, para autenticar y acceder a otros servicios y recursos.

se puede utilizar este mecanismo solo al autenticarse en MongoDB Atlas o MongoDB Enterprise Advanced.

Para obtener más información sobre el mecanismo de autenticación MONGODB-OIDC, consulta Autenticación OpenID Connect y MongoDB Server Parameters en el manual de MongoDB Server.

Las siguientes secciones describen cómo utilizar el mecanismo de autenticación MONGODB-OIDC para autenticar diferentes plataformas.

Azure IMDS

Si tu aplicación se ejecuta en una Máquina Virtual (VM) de Azure o de alguna otra manera utiliza el Servicio de Metadatos de Instancia de Azure (IMDS), puede autenticarse en MongoDB utilizando la funcionalidad incorporada de Azure del controlador Rust.

Puede configurar OIDC para Azure IMDS estableciendo el mechanism campo de la estructura Credential a AuthMechanism::MongoDbOidc. También debes especificar los siguientes valores en la estructura Credential:

• usernameSi estás utilizando una identidad administrada de Azure, configura esto con el ID de cliente de la identidad administrada. Si está utilizando un principal de servicio para representar una aplicación empresarial, configure este parámetro con el ID de la aplicación del principal 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.

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 tu aplicación se ejecuta en una VM de Google Compute Engine, o utiliza de otro modo el Servicio de Metadatos de Instancias de GCP, puedes autenticarte en MongoDB utilizando el soporte de funcionalidad incorporada de GCP del driver 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: Configure 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.

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.

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?;

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?;

Información Adicional

Para aprender más sobre los conceptos de esta guía, consulte la siguiente documentación:

• Guía Especificar opciones de conexión

• Cadenas de conexión en el Manual del servidor