Constrói uma aplicação de consola Rust com o Azure DocumentDB

Neste guia, cria uma aplicação de consola Rust para se ligar a um cluster Azure DocumentDB. O guia aborda a configuração do seu ambiente de desenvolvimento, o uso do crate da Azure SDK para Rust para autenticar e gerir documentos no sistema de base de dados.

Pré-requisitos

• Uma assinatura do Azure

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

• Um cluster do Azure DocumentDB existente

  • Se não tiver um cluster, crie um novo cluster

• Utilize o ambiente Bash no Azure Cloud Shell. Para mais informações, veja Get started with Azure Cloud Shell.

  

• Se preferir executar comandos de referência da CLI localmente, instale o CLI do Azure. Se estiver a usar Windows ou macOS, considere executar o Azure CLI num contentor Docker. Para obter mais informações, consulte Como executar a CLI do Azure em um contêiner do Docker.

  • Se você estiver usando uma instalação local, entre na CLI do Azure usando o comando az login . Para concluir o processo de autenticação, siga os passos exibidos no seu terminal. Para outras opções de entrada, consulte Autenticar no Azure usando a CLI do Azure.

  • Quando solicitado, instale a extensão do Azure CLI na primeira utilização. Para obter mais informações sobre extensões, consulte Usar e gerenciar extensões com a CLI do Azure.

  • Execute az version para descobrir a versão e as bibliotecas dependentes que estão instaladas. Para atualizar para a versão mais recente, execute az upgrade.

• Autenticação do Microsoft Entra configurada para o cluster com o papel atribuído à sua identidade root.

  • Para habilitar a autenticação do Microsoft Entra, consulte o guia de configuração.

• Última versão 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. Crie um novo projeto Rust usando cargo new.

   cargo new mongodb-app
   cd mongodb-app
   

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

   cargo add azure_core
   

3. Adicione a azure_identity caixa para autenticação.

   cargo add azure_identity
   

4. Adicione o módulo do mongodb driver a fim de interagir com o seu cluster.

   cargo add mongodb
   

5. Para operações assíncronas, adicione também as bibliotecas tokio, futures e serde.

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

Ligar ao cluster

Agora, use a Azure.Identity biblioteca para obter um TokenCredential para usar para se conectar ao seu 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 ficheiro 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 erros necessário.

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

3. Crie uma nova instância de struct azure_identity::DefaultAzureCredential.

   let credential = DefaultAzureCredential::new()?;
   

4. Crie um callback de credenciais para lidar com pedidos 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 Identificador Uniforme de Recurso (URI) do seu cluster usando o seu nome, esquema e o 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 retorno de chamada de credencial.

   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

Finalmente, 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 o MongoDB ou o Banco de Dados de Documentos para gerenciar suas coleções e itens.

1. Crie uma estrutura Rust para representar seus Product documentos com serde suporte à serialização.

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

2. Obtenha uma referência ao seu banco de dados através do nome.

   let database = client.database("<database-name>");
   
   println!("Database pointer created");
   

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

   let collection = database.collection::<Product>("<collection-name>");
   
   println!("Collection pointer created");
   

4. Crie um documento usando collection.update_one e atualize-o para a 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. Consulta de 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

• Visão geral da autenticação do Microsoft Entra
• Configuração do Microsoft Entra para o cluster