Udostępnij przez

Uzyskiwanie dostępu do usług platformy Azure za pomocą zestawu Azure SDK for Rust

Skrzynie z zestawem Azure SDK for Rust ułatwiają dostęp do usług platformy Azure z poziomu aplikacji Rust. W tym artykule wyjaśniono, jak używać tych skrzynek, w tym uwierzytelniania, obsługiwanych usług i najlepszych rozwiązań.

Skrzynie | Dokumentacja referencyjna interfejsu | APIKod źródłowy

Wymagania wstępne dotyczące opracowywania z skrzyniami

Wskazówka

Aby uzyskać najlepsze środowisko programistyczne, upewnij się, że masz zainstalowaną najnowszą stabilną wersję oprogramowania Rust.

Podawanie poświadczeń uwierzytelniania

Skrzynie platformy Azure wymagają poświadczeń, aby uwierzytelnić się w identyfikatorze Entra firmy Microsoft. Usługi platformy Azure zapewniają różne metody uwierzytelniania dla połączenia. Zalecamy użycie azure_identity skrzyni do uwierzytelniania. Dowiedz się więcej o uwierzytelnianiu dla zestawu Azure SDK for Rust.

Obiekty klienta

Obiekty klienta służą do interakcji z usługami platformy Azure. Każdy obiekt klienta, z skrzyni usługi, odpowiada określonej usłudze platformy Azure i udostępnia metody wykonywania operacji na tej usłudze. Na przykład azure_security_keyvault_secrets::SecretClient służy do interakcji z wpisami tajnymi usługi Azure Key Vault.

Podczas tworzenia obiektów klienta można podać ClientOptions parametr do dostosowywania interakcji z usługą. Służy ClientOptions do ustawiania elementów, takich jak limity czasu, zasady ponawiania prób i inne konfiguracje.

use azure_identity::AzureCliCredential;
use azure_security_keyvault_secrets::SecretClient;

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

    let vault_url = std::env::var("AZURE_KEYVAULT_URL")
        .map_err(|_| "AZURE_KEYVAULT_URL environment variable is required")?;

    let credential = AzureCliCredential::new(None)?;

    let client = SecretClient::new(&vault_url, credential.clone(), None)?;

    Ok(())
}

Obsługa błędów

Gdy wywołanie usługi zakończy się niepowodzeniem, zwrócona Response zawiera status.

use azure_core::{error::ErrorKind, http::StatusCode};
use azure_identity::AzureCliCredential;
use azure_security_keyvault_secrets::SecretClient;

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

    let credential = AzureCliCredential::new(None)?;

    let vault_url = std::env::var("AZURE_KEYVAULT_URL")
        .map_err(|_| "AZURE_KEYVAULT_URL environment variable is required")?;

    let client = SecretClient::new(&vault_url, credential.clone(), None)?;

    match client.get_secret("secret-0", None).await {
        Ok(secret) => println!(
            "Secret value: {}",
            secret.into_model()?.value.unwrap_or_default()
        ),
        Err(e) => match e.kind() {
            ErrorKind::HttpResponse {
                status, error_code, ..
            } if *status == StatusCode::NotFound => {
                if let Some(code) = error_code {
                    println!("ErrorCode: {}", code);
                } else {
                    println!("Secret not found, but no error code provided.");
                }
            }
            _ => println!("An error occurred: {e:?}"),
        },
    }

    Ok(())
}

Wyniki strony

Jeśli wywołanie usługi zwraca wiele wartości na stronach, zwraca Result<Pager<T>> wartość jako ResultPagerwartość .

use azure_identity::AzureCliCredential;
use azure_security_keyvault_secrets::SecretClient;
use futures::TryStreamExt;

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

    let credential = AzureCliCredential::new(None)?;

    let vault_url = std::env::var("AZURE_KEYVAULT_URL")
        .map_err(|_| "AZURE_KEYVAULT_URL environment variable is required")?;

    let client = SecretClient::new(&vault_url, credential.clone(), None)?;

    let mut pager = client.list_secret_properties(None)?.into_pages();

    while let Some(page) = pager.try_next().await? {
        let page = page.into_model()?;
        println!("items_in_page: {}", page.value.len());
    }

    Ok(())
}

Stronicowanie w celu przetworzenia każdej strony elementów

Aby iterować wszystkie elementy w odpowiedzi podzielonej na strony, użyj into_pages() metody zwróconej Pagerprzez element . Ta metoda zwraca asynchroniczny strumień stron jako PageIteratorelement , dzięki czemu można przetworzyć każdą stronę, gdy stanie się ona dostępna.

use azure_identity::AzureDeveloperCliCredential;
use azure_security_keyvault_secrets::{ResourceExt, SecretClient};
use futures::TryStreamExt;

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

    let credential = AzureDeveloperCliCredential::new(None)?;

    let vault_url = std::env::var("AZURE_KEYVAULT_URL")
        .map_err(|_| "AZURE_KEYVAULT_URL environment variable is required")?;

    let client = SecretClient::new(vault_url.as_str(), credential.clone(), None)?;

    let mut pager = client.list_secret_properties(None)?;

    while let Some(secret) = pager.try_next().await? {
        let name = secret.resource_id()?.name;
        println!("Found secret with name: {}", name);
    }

    Ok(())
}

Przykładowy kod

Kod przedstawiony w tym artykule jest dostępny w witrynie https://github.com/azure-samples/azure-sdk-for-rust-docs/.

Dalsze kroki

  • Last updated on