OIDC (Federación de identidad de carga de trabajo)

Overview

El controlador Rust admite la autenticación OpenID Connect(OIDC) para identidades de carga de trabajo. Una identidad de carga de trabajo es una identidad que se asigna a una carga de trabajo de software, como una aplicación, un servicio, un script o un 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 de OpenID Connect y parámetros del servidor MongoDB en el manual del servidor MongoDB.

Las siguientes secciones describen cómo utilizar el mecanismo de autenticación MONGODB-OIDC para autenticarse en varias plataformas.

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 utilizando la compatibilidad con Azure integrada en el controlador de Rust.

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

• 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.

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.

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 obtener más información sobre los conceptos de esta guía, consulte la siguiente documentación:

• Guía para especificar lasopciones de conexión

• Cadenas de conexión en el Manual del servidor