Compilación de una aplicación de consola de Rust con Azure DocumentDB

En esta guía, creará una aplicación de consola de Rust para conectarse a un clúster de Azure DocumentDB. En la guía se explica cómo configurar el entorno de desarrollo, utilizar el formato azure_identity del SDK de Azure para Rust para autenticarse y administrar documentos dentro de la base de datos.

Prerrequisitos

• Una suscripción de Azure

  • Si no tiene ninguna suscripción a Azure, cree una cuenta gratuita

• Un clúster de Azure DocumentDB existente

  • Si no tiene un clúster, cree un nuevo clúster.

• Use el entorno de Bash en Azure Cloud Shell. Para más información, consulte Introducción a Azure Cloud Shell.

  

• Si prefieres ejecutar comandos de referencia CLI localmente, instala la CLI de Azure. Si estás utilizando Windows o macOS, considera ejecutar Azure CLI en un contenedor Docker. Para obtener más información, consulte Cómo ejecutar el Azure CLI en un contenedor de Docker.

  • Si estás utilizando una instalación local, inicia sesión en Azure CLI utilizando el comando az login. Siga los pasos que se muestran en el terminal para completar el proceso de autenticación. Para ver otras opciones de inicio de sesión, consulte Autenticación en Azure mediante la CLI de Azure.

  • En caso de que se le solicite, instale las extensiones de la CLI de Azure la primera vez que la use. Para obtener más información sobre las extensiones, consulte Uso y administración de extensiones con la CLI de Azure.

  • Ejecute az version para ver la versión y las bibliotecas dependientes que están instaladas. Para actualizar a la versión más reciente, ejecute az upgrade.

• La autenticación de Microsoft Entra está configurada para el clúster con el rol root concedido a la identidad.

  • Para habilitar la autenticación de Microsoft Entra, revise la guía de configuración.

• Versión más reciente de Python.

Configuración de la aplicación de consola

A continuación, cree un nuevo proyecto de aplicación de consola e importe las bibliotecas necesarias para autenticarse en el clúster.

1. Cree un nuevo proyecto de Rust mediante cargo new.

   cargo new mongodb-app
   cd mongodb-app
   

2. Agregue el formato .CR8 azure_core a las dependencias.

   cargo add azure_core
   

3. Agregue la caja para la autenticación azure_identity.

   cargo add azure_identity
   

4. Agregue el paquete de controladores mongodb para interactuar con tu clúster.

   cargo add mongodb
   

5. Para las operaciones asincrónicas, agregue también los crates auxiliares tokio, futures y serde.

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

Conectarse al clúster

Ahora, utilice la Azure.Identity biblioteca para obtener un TokenCredential que usará para conectarse a su clúster. El controlador oficial de MongoDB tiene una interfaz especial que se debe implementar para obtener tokens de Microsoft Entra para su uso al conectarse al clúster.

1. Abra el archivo main.rs e importe las cajas y módulos necesarios.

   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. Cree la función asincrónica principal con el control de errores necesario.

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

3. Cree una nueva instancia de struct azure_identity::DefaultAzureCredential.

   let credential = DefaultAzureCredential::new()?;
   

4. Cree una devolución de llamada de credenciales para controlar las solicitudes de token desde el cliente de 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 un indicador uniforme de recursos (URI) del clúster con su nombre, esquema y el punto de conexión global.

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

6. Construya una instancia de mongodb::ClientOptions mediante la configuración de procedimientos recomendados, el URI y la devolución de llamada de credenciales.

   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. Cree una nueva instancia de mongodb::Client mediante la configuración construida.

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

Realización de operaciones comunes

Por último, use la biblioteca oficial para realizar tareas comunes con bases de datos, colecciones y documentos. Aquí, usará las mismas clases y métodos que usaría para interactuar con MongoDB o DocumentDB para administrar las colecciones y los elementos.

1. Cree una estructura de Rust para representar los documentos de Product compatibles con la serialización de serde.

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

2. Obtenga una referencia a su base de datos por nombre.

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

3. Obtenga una referencia a tu colección.

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

4. Cree un documento con collection.update_one y reertelo en la colección.

   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. Lea un documento específico de la colección mediante collection.find_one y un filtro.

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

6. Consulte varios documentos que coincidan con un filtro mediante 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);
   }
   

Contenido relacionado

• Información general sobre la autenticación de Microsoft Entra
• Configuración de Microsoft Entra para el clúster