Condividi tramite

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

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

Casse | Documentazione | 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

Le casse di Azure necessitano di credenziali per l'autenticazione all'ID Microsoft Entra. I servizi di Azure forniscono metodi di autenticazione diversi per la connessione. È consigliabile usare la azure_identity cassa per l'autenticazione. Altre informazioni sull'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 di 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_body()?.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 pagina

Se una chiamata al servizio restituisce più valori nelle pagine, restituisce Result<Pager<T>> come .ResultPager

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_body()?;
        println!("items_in_page: {}", page.value.len());
    }

    Ok(())
}

Paginazione per elaborare ogni pagina di elementi

Per scorrere tutti gli elementi in una risposta impaginata, usare il into_pages() metodo sull'oggetto restituito Pager. 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