Creare un'app console Rust con Azure DocumentDB

• .NET
• Python
• Node.js
• Java
• Go
• Rust

In questa guida viene creata un'applicazione console Rust per connettersi a un cluster Di Azure DocumentDB. La guida illustra la configurazione dell'ambiente di sviluppo, usando il azure_identity crate di Azure SDK per Rust per l'autenticazione e la gestione dei documenti all'interno del database.

Prerequisiti

• Una sottoscrizione di Azure

  • Se non hai un abbonamento Azure, crea un account gratuito

• Un cluster Di Azure DocumentDB esistente

  • Se non si ha un cluster, creare un nuovo cluster

• È possibile utilizzare l'ambiente Bash in Azure Cloud Shell. Per altre informazioni, vedere Introduzione ad Azure Cloud Shell.

  

• Se preferisci eseguire localmente i comandi di riferimento della CLI, installa l'Azure CLI. Per l'esecuzione in Windows o macOS, è consigliabile eseguire l'interfaccia della riga di comando di Azure in un contenitore Docker. Per altre informazioni, vedere Come eseguire l'interfaccia della riga di comando di Azure in un contenitore Docker.

  • Se usi un'installazione locale, accedi all'interfaccia della riga di comando di Azure usando il comando az login. Per completare il processo di autenticazione, seguire la procedura visualizzata nel terminale. Per altre opzioni di accesso, vedere Eseguire l'autenticazione ad Azure con l'interfaccia della riga di comando di Azure.

  • Quando ti viene richiesto, installa l'estensione Azure CLI al primo utilizzo. Per altre informazioni sulle estensioni, vedere Usare e gestire le estensioni con l'interfaccia della riga di comando di Azure.

  • Esegui az version per trovare la versione e le librerie dipendenti installate. Per eseguire l'aggiornamento alla versione più recente, avviare az upgrade.

• Autenticazione di Microsoft Entra configurata per il cluster con il ruolo root assegnato alla tua identità.

  • Per abilitare l'autenticazione di Microsoft Entra, vedere la guida alla configurazione.

• Versione più recente di Python.

Configurare l'applicazione console

Creare quindi un nuovo progetto di applicazione console e importare le librerie necessarie per l'autenticazione nel cluster.

1. Creare un nuovo progetto Rust usando cargo new.

   cargo new mongodb-app
   cd mongodb-app
   

2. Aggiungere il crate azure_core alle dipendenze.

   cargo add azure_core
   

3. Aggiungere il crate azure_identity per l'autenticazione.

   cargo add azure_identity
   

4. Aggiungere il crate del driver mongodb per interagire con il cluster.

   cargo add mongodb
   

5. Per le operazioni asincrone, aggiungere anche i crate di supporto tokio, futures e serde.

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

Connettersi al cluster

Ora, utilizza la libreria Azure.Identity per ottenere un TokenCredential da utilizzare per connetterti al cluster. Il driver Ufficiale di MongoDB ha un'interfaccia speciale che deve essere implementata per ottenere i token da Microsoft Entra per l'uso durante la connessione al cluster.

1. Aprire il file main.rs e importare i crate e i moduli necessari.

   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. Creare la funzione asincrona principale con la gestione degli errori necessaria.

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

3. Creare una nuova istanza di struct azure_identity::DefaultAzureCredential.

   let credential = DefaultAzureCredential::new()?;
   

4. Creare un callback delle credenziali per gestire le richieste di token dal client 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. Definire un URI (Uniform Resource Indicator) del cluster usando il nome, lo schema e l'endpoint globale.

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

6. Costruire un'istanza mongodb::ClientOptions utilizzando la configurazione delle migliori pratiche, il tuo URI e la funzione di callback delle credenziali.

   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. Creare una nuova istanza di mongodb::Client usando le impostazioni costruite.

   let client = Client::with_options(client_options)?;
   
   println!("Client created");
   

Eseguire operazioni comuni

Infine, usare la libreria ufficiale per eseguire attività comuni con database, raccolte e documenti. In questo caso si usano le stesse classi e metodi usati per interagire con MongoDB o DocumentDB per gestire le raccolte e gli elementi.

1. Creare una struttura Rust per rappresentare i documenti Product con supporto per la serializzazione serde.

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

2. Ottieni un riferimento al tuo database per nome.

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

3. Ottieni un riferimento alla tua raccolta.

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

4. Crea un documento usando collection.update_one e upsertalo nella raccolta.

   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. Leggere un documento specifico dalla raccolta usando collection.find_one e un filtro.

   let document = collection
       .find_one(doc! { "_id": "aaaaaaaa-0000-1111-2222-bbbbbbbbbbbb" })
       .await?;
   
   println!("Read document _id:\t{:#?}", document.unwrap()._id);
   

6. Eseguire una query per più documenti corrispondenti a un 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);
   }
   

Contenuti correlati

• Panoramica dell'autenticazione di Microsoft Entra
• Configurazione di Microsoft Entra per il cluster