Mecanismos de autenticação empresarial

Exemplo

Para especificar o PLAIN mecanismo de autenticação , defina o mechanism campo da estrutura Credential como AuthMechanism::Plain. Este exemplo especifica o mecanismo de autenticação usando os seguintes placeholders:

• username: Seu nome de usuário LDAP

• password: Sua senha 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, você pode autenticar usando um URI de string de conexão definindo o valor da opção string de conexão authMechanism como PLAIN. Este exemplo mostra como especificar o mecanismo de autenticação PLAIN em um URI de string de conexão usando os seguintes placeholders:

• username: Seu nome de usuário LDAP

• password: Sua senha LDAP

• hostname: O endereço de rede do seu servidor MongoDB

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

IMDS do Azure

Se o seu aplicação for executado em uma VM do Azure ou de outra forma usar o Azure Instance Metadata Service (IMDS), você poderá autenticar no MongoDB usando o suporte integrado do Azure driver do Rust.

Você pode configurar o OIDC para o Azure IMDS definindo o campo mechanism da estrutura Credential como AuthMechanism::MongoDbOidc. Este exemplo especifica o mecanismo de autenticação usando os seguintes placeholders:

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

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

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 .

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": "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.

O código a seguir é um exemplo de implementação de um chamada de resposta personalizado para um cluster EKS. Primeiro, defina o campo oidc_callback da sua estrutura Credential como oidc::Callback::machine. Em seguida, leia o token de acesso de um caminho definido na variável de ambiente AWS_WEB_IDENTITY_TOKEN_FILE. Finalmente, defina o valor do campo access_token da estrutura IdpServerResponse. Opcionalmente, configure os valores dos campos expires e 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?;

Quando o processo de autenticação da identidade da força de trabalho envolver interação humana, você deve configurar o cliente definindo o campo oidc_callback de sua estrutura Credential como oidc::Callback::human em vez de oidc::Callback::machine. O driver do Rust usa o chamada de resposta no seguinte processo:

1. O driver recupera as informações do fornecedor de identidade (IDPInfo) para o nome de usuário fornecido.

2. O chamada de resposta negociações com o IDP para obter um access_token e quaisquer valores de tempo limite e refresh_token possíveis, se configurado. A chamada de resposta retorna um Result<IdpServerInfo>.

O exemplo a seguir define um chamada de resposta personalizado para lidar com a identidade da força de trabalho. Para personalizar este exemplo para seu caso de uso, substitua <human flow> por seu próprio fluxo personalizado. Consulte Fluxo de código de autorização com OIDC para obter mais detalhes.

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

Documentação da API

Para saber mais sobre os métodos e tipos mencionados neste guia, consulte a documentação da API abaixo:

• Credenciais

• ClientOptions

• Cliente

• with_options()

• CallbackContext

• IdpServerResponse

• IdpServerInfo