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

Importante

Usare l'ultima versione stabile 1.x Azure SDK per le versioni crate rust per il nuovo sviluppo. Ogni versione crate dipende in modo indipendente, quindi usare la versione stabile 1.x più recente per ogni crate da cui dipende l'applicazione.

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

Usare gli oggetti client 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, usare azure_security_keyvault_secrets::SecretClient per interagire con Azure Key Vault segreti. È anche possibile usare QueueClient, KeyCliente CertificateClient per archiviazione code di Azure, chiavi di Azure Key Vault e certificati 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