OIDC (Federação de Identidade do Volume de Trabalho)

Visão geral

O driver Rust suporta autenticação OpenID Connect (OIDC) para identidades de volume de trabalho. Uma identidade de carga de trabalho é uma identidade que você atribui a uma carga de trabalho de software, como um aplicação, serviço, script ou contêiner, para autenticar e acessar outros serviços e recursos.

Você pode usar esse mecanismo somente ao autenticar no MongoDB Atlas ou Enterprise Advanced.

Para saber mais sobre o mecanismo de autenticação MONGODB-OIDC, consulte Autenticação do OpenID Connect e Parâmetros do MongoDB Server no manual do MongoDB Server.

As seções a seguir descrevem como usar o mecanismo de autenticação MONGODB-OIDC para autenticar em várias plataformas.

IMDS do Azure

Se o seu aplicativo for executado em uma VM do Azure ou de outra forma usar o Serviço de Metadados de Instância do Azure (IMDS), você poderá autenticar no MongoDB usando o suporte integrado do Azure do driver Rust.

Você pode configurar o OIDC para o Azure IMDS definindo o campo mechanism da sua estrutura Credential como AuthMechanism::MongoDbOidc. Você também deve especificar os seguintes valores para a estrutura Credential:

• username: Se você estiver usando uma identidade gerenciada pelo Azure, defina para a ID do cliente da identidade gerenciada. Se você estiver usando um principal de serviço para representar um aplicativo empresarial, defina para o ID do aplicativo do principal de serviço.

• mechanism_properties: Configure a propriedade ENVIRONMENT para azure e o TOKEN_RESOURCE para o valor do parâmetro de público configurado na sua implantação do 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

Se seu aplicação é executado em uma VM do Google Compute Engine ou usa o GCP Instance Metadata Service, você pode autenticar no MongoDB usando o suporte integrado ao GCP do driver Rust.

Você pode configurar o OIDC para o GCP IMDS definindo o campo mechanism da estrutura Credential como AuthMechanism::MongoDbOidc. Em seguida, especifique o mecanismo de autenticação definindo os seguintes valores no campo mechanism_properties :

• ENVIRONMENT: define esta propriedade como gcp.

• TOKEN_RESOURCE: Defina essa propriedade como o valor do parâmetro de público configurado na implementação do 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

Se seu aplicação for executado em um cluster do Kubernetes, você poderá autenticar no MongoDB usando o suporte de Kubernetes integrado do driver Rust.

Você pode configurar o OIDC para Kubernetes definindo o campo mechanism da sua estrutura Credential como AuthMechanism::MongoDbOidc. Em seguida, especifique o mecanismo de autenticação configurando a propriedade ENVIRONMENT como k8s no campo mechanism_properties.

O seguinte exemplo de código mostra como definir estas opções ao criar um 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?;

Chamada de resposta personalizada

O driver do Rust não oferece suporte integrado para todas as plataformas, incluindo o Amazon Web Services Elastic Kubernetes Service (EKS). Para usar o OIDC para autenticar em plataformas não compatíveis, você deve definir uma função de chamada de resposta 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?;

Informações adicionais

Para saber mais sobre os conceitos deste guia, consulte a seguinte documentação:

• Guia Especificar opções de conexão

• Connection strings no manual do servidor MongoDB