Udostępnij za pomocą

Tworzenie aplikacji konsolowej Rust za pomocą usługi Azure DocumentDB

W tym przewodniku utworzysz aplikację konsolową Rust w celu nawiązania połączenia z klastrem usługi Azure DocumentDB. W przewodniku opisano konfigurowanie środowiska programistycznego, korzystanie z pakietu azure_identity z Azure SDK dla Rust do uwierzytelniania oraz zarządzanie dokumentami w bazie danych.

Wymagania wstępne

  • Subskrypcja platformy Azure

  • Istniejący klaster usługi Azure DocumentDB

  • Uwierzytelnianie Microsoft Entra zostało skonfigurowane dla klastra z przypisaną rolą dla Twojej tożsamości root.

  • Najnowsza wersja języka Python.

Konfigurowanie aplikacji konsolowej

Następnie utwórz nowy projekt aplikacji konsolowej i zaimportuj niezbędne biblioteki do uwierzytelniania w klastrze.

  1. Utwórz nowy projekt Rust przy użyciu polecenia cargo new.

    cargo new mongodb-app
cd mongodb-app

  2. Dodaj skrzynię azure_core do zależności.

    cargo add azure_core

  3. Dodaj skrzynię azure_identity do uwierzytelniania.

    cargo add azure_identity

  4. Dodaj moduł sterowników mongodb do interakcji z klastrem.

    cargo add mongodb

  5. W przypadku operacji asynchronicznych dodaj również pomocnicze pakiety tokio, futures i serde.

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

Połącz się z klastrem

Teraz użyj biblioteki Azure.Identity, aby uzyskać TokenCredential, którego możesz użyć do połączenia się z klastrem. Oficjalny sterownik bazy danych MongoDB ma specjalny interfejs, który należy zaimplementować w celu uzyskania tokenów z firmy Microsoft Entra do użycia podczas nawiązywania połączenia z klastrem.

  1. Otwórz plik main.rs i zaimportuj niezbędne crates i moduły.

    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. Utwórz główną funkcję asynchroniczną z wymaganą obsługą błędów.

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

    Ok(())
}

  3. Utwórz nowe wystąpienie struktury azure_identity::DefaultAzureCredential.

    let credential = DefaultAzureCredential::new()?;

  4. Utwórz mechanizm obsługi poświadczeń do obsługi żądań tokenu od klienta 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. Zdefiniuj jednolity wskaźnik zasobów (URI) z klastra przy użyciu jego nazwy, schematu i globalnego punktu końcowego.

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

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

  6. Skonstruuj mongodb::ClientOptions wystąpienie przy użyciu konfiguracji zgodnie z najlepszymi praktykami, identyfikatora URI i funkcji zwrotnej uwierzytelniania.

    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. Utwórz nowe wystąpienie mongodb::Client przy użyciu skonstruowanych ustawień.

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

println!("Client created");

Wykonywanie typowych operacji

Na koniec użyj oficjalnej biblioteki do wykonywania typowych zadań z bazami danych, kolekcjami i dokumentami. W tym miejscu użyjesz tych samych klas i metod, których należy użyć do interakcji z bazą danych MongoDB lub DocumentDB w celu zarządzania kolekcjami i elementami.

  1. Utwórz strukturę Rust do reprezentowania Product dokumentów z obsługą serde serializacji.

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

  2. Uzyskaj odwołanie do bazy danych według nazwy.

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

println!("Database pointer created");

  3. Uzyskaj referencję do swojej kolekcji.

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

println!("Collection pointer created");

  4. Utwórz dokument przy użyciu collection.update_one metody i dodaj go do kolekcji.

    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. Odczytaj konkretny dokument z kolekcji, korzystając z collection.find_one oraz filtra.

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

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

  6. Wykonaj zapytanie o wiele dokumentów pasujących do filtru przy użyciu polecenia 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);
}

Treści powiązane

  • Last updated on