Compartilhar via

Criar um aplicativo de console do Rust com o Azure DocumentDB

Neste guia, você criará um aplicativo de console do Rust para se conectar a um cluster do Azure DocumentDB. O guia aborda a configuração do ambiente de desenvolvimento, usando o crate azure_identity do SDK do Azure para Rust para autenticação e gerenciamento de documentos no banco de dados.

Pré-requisitos

  • Uma assinatura do Azure

    • Se você não tiver uma assinatura do Azure, crie uma conta gratuita

  • Um cluster existente do Azure DocumentDB

  • Autenticação do Microsoft Entra configurada para o cluster com sua identidade concedida à função root.

  • Versão mais recente do Python.

Configurar seu aplicativo de console

Em seguida, crie um novo projeto de aplicativo de console e importe as bibliotecas necessárias para autenticar no cluster.

  1. Criar um novo projeto do Rust usando cargo new.

    cargo new mongodb-app
cd mongodb-app

  2. Adicione o crate azure_core às suas dependências.

    cargo add azure_core

  3. Adicione o crate azure_identity para autenticação.

    cargo add azure_identity

  4. Adicione o crate do driver mongodb para interagir com o cluster.

    cargo add mongodb

  5. Para operações assíncronas, adicione também os crates de suporte tokio, futures e serde.

    cargo add tokio --features full
cargo add futures
cargo add serde --features derive

Conectar-se ao cluster

Agora, use a biblioteca Azure.Identity para obter uma TokenCredential a ser usada para conectar-se ao cluster. O driver oficial do MongoDB tem uma interface especial que deve ser implementada para obter tokens do Microsoft Entra para uso ao se conectar ao cluster.

  1. Abra o arquivo main.rs e importe os crates e módulos necessários.

    use azure_core::credentials::TokenCredential;
use azure_identity::DefaultAzureCredential;
use futures::{FutureExt, TryStreamExt};
use mongodb::{
    Client,
    bson::doc,
    options::{
        AuthMechanism, ClientOptions, Credential,
        oidc::{self, IdpServerResponse},
    },
};
use serde::{Deserialize, Serialize};

  2. Crie a função assíncrona principal com o tratamento de erro necessário.

    #[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {

    Ok(())
}

  3. Criar uma nova instância do struct azure_identity::DefaultAzureCredential.

    let credential = DefaultAzureCredential::new()?;

  4. Crie um retorno de chamada de credencial para lidar com as solicitações de token do cliente MongoDB.

    let azure_identity_token_credential = Credential::builder()
    .mechanism(AuthMechanism::MongoDbOidc)
    .oidc_callback(oidc::Callback::machine(move |_| {
        let azure_credential = credential.clone();
        async move {
            let access_token = azure_credential
                .get_token(&["https://ossrdbms-aad.database.windows.net/.default"])
                .await
                .map_err(|e| {
                    mongodb::error::Error::custom(format!("Azure token error: {}", e))
                })?;
            Ok(IdpServerResponse::builder()
                .access_token(access_token.token.secret().to_owned())
                .build())
        }
        .boxed()
    }))
    .build()
    .into();

  5. Defina um indicador de recurso uniforme (URI) do cluster usando seu nome, esquema e ponto de extremidade global.

    let cluster_name = "<azure-documentdb-cluster-name>";

let uri = format!(
    "mongodb+srv://{}.global.mongocluster.cosmos.azure.com/",
    cluster_name
);

  6. Construa uma mongodb::ClientOptions instância usando a configuração de práticas recomendadas, seu URI e o callback de credenciais.

    let mut client_options = ClientOptions::parse(uri).await?;

client_options.connect_timeout = Some(std::time::Duration::from_secs(120));
client_options.tls = Some(mongodb::options::Tls::Enabled(Default::default()));
client_options.retry_writes = Some(true);

client_options.credential = Some(azure_identity_token_credential);

  7. Crie uma nova instância de mongodb::Client usando as configurações construídas.

    let client = Client::with_options(client_options)?;

println!("Client created");

Executar operações comuns

Por fim, use a biblioteca oficial para executar tarefas comuns com bancos de dados, coleções e documentos. Aqui, você usa as mesmas classes e métodos que usaria para interagir com MongoDB ou DocumentDB para gerenciar suas coleções e itens.

  1. Crie um struct do Rust para representar seus documentos Product com suporte de serialização para serde.

    #[derive(Serialize, Deserialize, Debug)]
struct Product {
    _id: String,
    category: String,
    name: String,
    quantity: i32,
    price: f64,
    clearance: bool,
}

  2. Obtenha uma referência ao banco de dados pelo nome.

    let database = client.database("<database-name>");

println!("Database pointer created");

  3. Obtenha uma referência à sua coleção.

    let collection = database.collection::<Product>("<collection-name>");

println!("Collection pointer created");

  4. Crie um documento usando collection.update_one e insira-o na coleção.

    let document = Product {
    _id: "aaaaaaaa-0000-1111-2222-bbbbbbbbbbbb".to_string(),
    category: "gear-surf-surfboards".to_string(),
    name: "Yamba Surfboard".to_string(),
    quantity: 12,
    price: 850.00,
    clearance: false,
};

let response = collection
    .update_one(
        doc! { "_id": "aaaaaaaa-0000-1111-2222-bbbbbbbbbbbb" },
        doc! { "$set": mongodb::bson::to_document(&document)? },
    )
    .upsert(true)
    .await?;

println!("Documents upserted count:\t{}", response.modified_count);

  5. Leia um documento específico da coleção usando collection.find_one e um filtro.

    let document = collection
    .find_one(doc! { "_id": "aaaaaaaa-0000-1111-2222-bbbbbbbbbbbb" })
    .await?;

println!("Read document _id:\t{:#?}", document.unwrap()._id);

  6. Consultar vários documentos correspondentes a um filtro usando collection.find.

    let filter = doc! { "category": "gear-surf-surfboards" };

let mut cursor = collection.find(filter).await?;

while let Some(document) = cursor.try_next().await? {
    println!("Found document:\t{:#?}", document);
}

Conteúdo relacionado

  • Last updated on