Freigeben über

Erstellen einer Rost-Konsolen-App mit Azure DocumentDB

In diesem Leitfaden erstellen Sie eine Rust-Konsolenanwendung, um eine Verbindung mit einem Azure DocumentDB-Cluster herzustellen. Der Leitfaden befasst sich mit dem Einrichten Ihrer Entwicklungsumgebung, der Verwendung der azure_identity Kiste aus dem Azure SDK für Rust zum Authentifizieren und Verwalten von Dokumenten innerhalb der Datenbank.

Voraussetzungen

  • Ein Azure-Abonnement

    • Wenn Sie nicht über ein Azure-Abonnement verfügen, erstellen Sie ein kostenloses Konto

  • Ein vorhandener Azure DocumentDB-Cluster

    • Wenn Sie keinen Cluster haben, erstellen Sie einen neuen Cluster.

  • Microsoft Entra-Authentifizierung ist für den Cluster konfiguriert, wobei Ihrer Identität die root Rolle zugewiesen wurde.

  • Neueste Version von Python.

Konfigurieren der Konsolenanwendung

Erstellen Sie als Nächstes ein neues Konsolenanwendungsprojekt, und importieren Sie die erforderlichen Bibliotheken, um sich bei Ihrem Cluster zu authentifizieren.

  1. Erstellen Sie ein neues Rust-Projekt mithilfe von cargo new.

    cargo new mongodb-app
cd mongodb-app

  2. Fügen Sie das Paket azure_core zu Ihren Abhängigkeiten hinzu.

    cargo add azure_core

  3. Fügen Sie das Paket azure_identity für die Authentifizierung hinzu.

    cargo add azure_identity

  4. Fügen Sie das Treiberpaket mongodb hinzu, um mit Ihrem Cluster zu interagieren.

    cargo add mongodb

  5. Fügen Sie für asynchrone Vorgänge auch die unterstützenden tokio, futures und serde Crates hinzu.

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

Herstellen einer Verbindung mit dem Cluster

Verwenden Sie nun die Azure.Identity Bibliothek, um ein TokenCredential zu erhalten, das Sie verwenden können, um sich mit Ihrem Cluster zu verbinden. Der offizielle MongoDB-Treiber verfügt über eine spezielle Schnittstelle, die implementiert werden muss, um Token von Microsoft Entra für die Verwendung beim Herstellen einer Verbindung mit dem Cluster abzurufen.

  1. Öffnen Sie ihre main.rs Datei, und importieren Sie die erforderlichen Kasten und Module.

    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. Erstellen Sie die asynchrone main-Funktion mit der erforderlichen Fehlerbehandlung.

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

    Ok(())
}

  3. Erstellen Sie eine neue Instanz der Struktur azure_identity::DefaultAzureCredential.

    let credential = DefaultAzureCredential::new()?;

  4. Erstellen Sie einen Rückruf für Anmeldeinformationen zum Verarbeiten von Tokenanforderungen vom MongoDB-Client.

    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. Definieren Sie einen URI (Uniform Resource Indicator) aus Ihrem Cluster mithilfe des Namens, des Schemas und des globalen Endpunkts.

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

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

  6. Erstellen Sie eine mongodb::ClientOptions-Instanz unter Verwendung der Best-Practices-Konfiguration, Ihres URI und des Rückrufs von Anmeldeinformationen.

    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. Erstellen Sie eine neue Instanz von mongodb::Client unter Verwendung der erstellten Einstellungen.

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

println!("Client created");

Ausführen gängiger Vorgänge

Verwenden Sie schließlich die offizielle Bibliothek, um allgemeine Aufgaben mit Datenbanken, Sammlungen und Dokumenten auszuführen. Hier verwenden Sie die gleichen Klassen und Methoden, mit denen Sie mit MongoDB oder DocumentDB interagieren würden, um Ihre Sammlungen und Elemente zu verwalten.

  1. Erstellen Sie eine Rust-Struktur, um Ihre Product Dokumente mit serde Serialisierungsunterstützung darzustellen.

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

  2. Rufen Sie einen Verweis auf Ihre Datenbank nach Namen ab.

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

println!("Database pointer created");

  3. Rufen Sie einen Verweis auf Ihre Sammlung ab.

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

println!("Collection pointer created");

  4. Erstellen Sie ein Dokument mithilfe von collection.update_one und fügen Sie es in die Sammlung ein.

    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. Lesen Sie ein bestimmtes Dokument aus der Auflistung mithilfe von collection.find_one und einem Filter.

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

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

  6. Mit collection.find Abfragen nach mehreren Dokumenten durchführen, die einem Filter entsprechen.

    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);
}

Verwandte Inhalte

  • Last updated on