Créer une application console Rust avec Azure DocumentDB

Dans ce guide, vous allez créer une application console Rust pour vous connecter à un cluster Azure DocumentDB. Le guide explique comment configurer votre environnement de développement, utiliser le package azure_identity du Kit de développement logiciel (SDK) Azure pour Rust afin de s’authentifier et de gérer des documents dans la base de données.

Prerequisites

• Un abonnement Azure

  • Si vous n’avez pas d’abonnement Azure, créez un compte gratuit

• Un cluster Azure DocumentDB existant

  • Si vous n’avez pas de cluster, créez un cluster

• Utilisez l’environnement Bash dans Azure Cloud Shell. Pour obtenir plus d’informations, consultez Démarrage d’Azure Cloud Shell.

  

• Si vous préférez exécuter des commandes de référence CLI localement, installez Azure CLI. Si vous exécutez sur Windows ou macOS, envisagez d’exécuter Azure CLI dans un conteneur Docker. Pour plus d’informations, consultez Comment exécuter Azure CLI dans un conteneur Docker.

  • Si vous utilisez une installation locale, connectez-vous à Azure CLI à l’aide de la commande az login. Pour terminer le processus d’authentification, suivez les étapes affichées dans votre terminal. Pour obtenir d’autres options de connexion, consultez S’authentifier auprès d’Azure à l’aide d’Azure CLI.

  • Lorsque vous y êtes invité, installez l’extension Azure CLI lors de la première utilisation. Pour plus d’informations sur les extensions, consultez Utiliser et gérer des extensions avec Azure CLI.

  • Exécutez az version pour rechercher la version et les bibliothèques dépendantes installées. Pour effectuer une mise à niveau vers la dernière version, exécutez az upgrade.

• Authentification Microsoft Entra configurée pour le cluster avec votre identité bénéficiant d’un rôle root.

  • Pour activer l’authentification Microsoft Entra, consultez le guide de configuration.

• Dernière version de Python.

Configurer votre application console

Ensuite, créez un projet d’application console et importez les bibliothèques nécessaires pour vous authentifier auprès de votre cluster.

1. Créez un nouveau projet Rust à l’aide de cargo new.

   cargo new mongodb-app
   cd mongodb-app
   

2. Ajoutez la crate azure_core à vos dépendances.

   cargo add azure_core
   

3. Ajoutez la crate azure_identity pour l’authentification.

   cargo add azure_identity
   

4. Ajoutez la bibliothèque de pilotes mongodb pour interagir avec votre cluster.

   cargo add mongodb
   

5. Pour les opérations asynchrones, ajoutez également les caisses de prise en charge tokio, futures et serde.

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

Se connecter au cluster

À présent, utilisez la bibliothèque Azure.Identity pour obtenir un TokenCredential à utiliser afin de vous connecter à votre cluster. Le pilote MongoDB officiel a une interface spéciale qui doit être implémentée pour obtenir des jetons de Microsoft Entra à utiliser lors de la connexion au cluster.

1. Ouvrez votre fichier main.rs et importez les caisses et modules nécessaires.

   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. Créez la fonction asynchrone principale avec la gestion des erreurs nécessaire.

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

3. Créez une instance de struct azure_identity::DefaultAzureCredential.

   let credential = DefaultAzureCredential::new()?;
   

4. Créez une fonction de rappel d'authentification pour gérer les demandes de jeton du 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. Définissez un URI (Uniform Resource Indicator) à partir de votre cluster à l’aide de son nom, de son schéma et du point de terminaison global.

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

6. Construisez une instance mongodb::ClientOptions en utilisant la configuration des bonnes pratiques, votre URI et le rappel des identifiants.

   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. Créez une nouvelle instance de mongodb::Client en utilisant les paramètres construits.

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

Effectuer des opérations courantes

Enfin, utilisez la bibliothèque officielle pour effectuer des tâches courantes avec des bases de données, des collections et des documents. Ici, vous utilisez les mêmes classes et méthodes que celles que vous utiliseriez pour interagir avec MongoDB ou DocumentDB pour gérer vos collections et éléments.

1. Créez un struct Rust pour représenter vos documents Product avec prise en charge de la sérialisation serde.

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

2. Obtenez une référence à votre base de données par nom.

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

3. Obtenez une référence à votre collection.

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

4. Créez un document en utilisant collection.update_one et upsert dans la collection.

   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. Lisez un document spécifique de la collection à l’aide de collection.find_one et d'un filtre.

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

6. Rechercher plusieurs documents correspondant à un filtre en utilisant 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);
   }
   

Contenu connexe

• Vue d’ensemble de l’authentification Microsoft Entra
• Configuration de Microsoft Entra pour le cluster