Condividi tramite

Usare Azure SDK per le casse Rust per accedere ai servizi di Azure

Le Azure SDK per le casse Rust consentono di accedere ai servizi Azure dalle applicazioni Rust. Questo articolo illustra come usare questi crate, tra cui l'autenticazione, i servizi supportati e le procedure consigliate.

Crates | Documentazione di riferimento API | Codice sorgente

Prerequisiti per lo sviluppo con crate

Suggerimento

Per un'esperienza di sviluppo ottimale, assicurarsi di avere installato la versione stabile più recente di Rust.

Specificare le credenziali di autenticazione

I moduli di Azure necessitano di credenziali per autenticarsi a Microsoft Entra ID. Azure servizi forniscono metodi di autenticazione diversi per la connessione. È consigliabile usare il azure_identity modulo per l'autenticazione. Altre informazioni su l'autenticazione per Azure SDK per i crate Rust.

Oggetti client

Gli oggetti client vengono usati per interagire con i servizi di Azure. Ogni oggetto client, dal crate di un servizio, corrisponde a un servizio Azure specifico e fornisce metodi per eseguire operazioni su tale servizio. Ad esempio, azure_security_keyvault_secrets::SecretClient viene usato per interagire con i segreti di Azure Key Vault.

Quando si creano gli oggetti client, è possibile specificare un ClientOptions parametro per personalizzare le interazioni con il servizio. Usare ClientOptions per impostare elementi come timeout, criteri di ripetizione dei tentativi e altre configurazioni.

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

Gestione degli errori

Quando una chiamata al servizio ha esito negativo, la risposta restituita contiene l'oggetto 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(())
}

Risultati della pagina

Se una chiamata al servizio restituisce più valori in pagine, li restituisce Result<Pager<T>> come Result di Pager.

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

Paginazione per elaborare ciascun elemento di ogni pagina

Per scorrere tutti gli elementi in una risposta impaginata, usare il metodo into_pages() sull'oggetto Pager restituito. Questo metodo restituisce un flusso asincrono di pagine come PageIterator, in modo da poter elaborare ogni pagina quando diventa disponibile.

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

Esempio di codice

Il codice illustrato in questo articolo è disponibile in https://github.com/azure-samples/azure-sdk-for-rust-docs/.

Passaggi successivi

  • Last updated on