Azure DocumentDB ile Rust konsol uygulaması oluşturma

Bu kılavuzda, Azure DocumentDB kümesine bağlanmak için bir Rust konsol uygulaması oluşturacaksınız. Kılavuz, geliştirme ortamınızı ayarlamayı, Rust için Azure SDK'dan gelen azure_identity crate'i kimlik doğrulamak için kullanmayı ve veritabanındaki belgeleri yönetmeyi kapsar.

Prerequisites

  • Mevcut bir Azure DocumentDB kümesi

Konsol uygulamanızı yapılandırma

Ardından, yeni bir konsol uygulaması projesi oluşturun ve kümenizde kimlik doğrulaması yapmak için gerekli kitaplıkları içeri aktarın.

  1. kullanarak cargo newyeni bir Rust projesi oluşturun.

    cargo new mongodb-app
cd mongodb-app

  2. azure_core paketini bağımlılıklarınıza ekleyin.

    cargo add azure_core

  3. Kimlik doğrulaması için azure_identity crate'i ekleyin.

    cargo add azure_identity

  4. mongodb Kümenizle etkileşime geçmek için sürücü kasasını ekleyin.

    cargo add mongodb

  5. Eşzamanlı olmayan işlemler için destekleyici tokio, futures, ve serde kasalarını da ekleyin.

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

Kümeye bağlanma

Şimdi kitaplığını Azure.IdentityTokenCredential kullanarak kümenize bağlanmak için bir kullanın. Resmi MongoDB sürücüsünün, kümeye bağlanırken kullanılmak üzere Microsoft Entra'dan belirteçleri almak için uygulanması gereken özel bir arabirimi vardır.

  1. main.rs dosyanızı açın ve gerekli kasaları ve modülleri içeri aktarın.

    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. Gerekli hata işlemesini içeren ana asenkron işlevi oluşturun.

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

    Ok(())
}

  3. Yapısının yeni bir örneğini azure_identity::DefaultAzureCredentialoluşturun.

    let credential = DefaultAzureCredential::new()?;

  4. MongoDB istemcisinden gelen belirteç isteklerini işlemek için bir kimlik bilgisi geri çağırması oluşturun.

    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. Adını, düzenini ve genel uç noktasını kullanarak kümenizden tekdüzen bir kaynak göstergesi (URI) tanımlayın.

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

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

  6. En iyi yöntemler yapılandırmasını, URI'nizi ve kimlik bilgisi geri çağırmasını kullanarak bir mongodb::ClientOptions örnek oluşturun.

    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. Oluşturduğunuz ayarları kullanarak yeni bir örneği mongodb::Client oluşturun.

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

println!("Client created");

Yaygın işlemler gerçekleştirme

Son olarak veritabanları, koleksiyonlar ve belgelerle ortak görevleri gerçekleştirmek için resmi kitaplığı kullanın. Burada, koleksiyonlarınızı ve öğelerinizi yönetmek için MongoDB veya DocumentDB ile etkileşimde bulunurken kullandığınız sınıfları ve yöntemleri kullanırsınız.

  1. Belgelerinizi Product serileştirme desteğiyle serde temsil eden bir Rust yapısı oluşturun.

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

  2. Adına göre veritabanınızın referansını alın.

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

println!("Database pointer created");

  3. Koleksiyonunuza bir referans alın.

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

println!("Collection pointer created");

  4. kullanarak collection.update_one bir belge oluşturun ve koleksiyona ekleyin.

    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. ve filtresini kullanarak collection.find_one koleksiyondaki belirli bir belgeyi okuyun.

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

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

  6. kullanarak collection.findbir filtreyle eşleşen birden çok belgeyi sorgulama.

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

İlgili içerik

  • Last updated on