Utilisez Kit de développement logiciel (SDK) Azure pour les caisses Rust pour accéder aux services Azure

Les Kit de développement logiciel (SDK) Azure pour les caisses Rust vous aident à accéder aux services Azure à partir d’applications Rust. Cet article explique comment utiliser ces caisses, notamment l’authentification, les services pris en charge et les meilleures pratiques.

Crates | documentation de référence API | code source

Important

Utilisez les dernières versions stables du SDK Azure pour Rust pour tout nouveau développement. Chaque crate est versionnée indépendamment, utilisez donc la dernière version stable de chaque crate dont dépend votre application.

Conditions préalables au développement avec des crates

Fournir des informations d’identification

Les crates Azure ont besoin des identifiants pour s’authentifier auprès de Microsoft Entra ID. Azure services fournissent différentes méthodes d’authentification pour la connexion. Nous vous recommandons d’utiliser le module azure_identity pour l’authentification. En savoir plus sur l'authentification pour Kit de développement logiciel (SDK) Azure pour les bibliothèques Rust.

Objets clients

Utilisez des objets clients pour interagir avec les services Azure. Chaque objet client, à partir de la caisse d'un service, correspond à un service Azure spécifique et fournit des méthodes pour effectuer des opérations sur ce service. Par exemple, utilisez cette méthode azure_security_keyvault_secrets::SecretClient pour interagir avec Azure Key Vault secrets. Vous pouvez également utiliserQueueClient, KeyClientet CertificateClient pour Stockage File d'attente Azure, Azure Key Vault clés et Azure Key Vault certificats.

Lorsque vous créez les objets clients, vous pouvez fournir un ClientOptions paramètre pour personnaliser les interactions avec le service. Permet ClientOptions de définir des éléments tels que les délais d’expiration, les stratégies de nouvelle tentative et d’autres configurations.

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

Gestion des erreurs

En cas d’échec d’un appel de service, la réponse retournée contient le 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(())
}

Résultats de la page

Si un appel de service retourne plusieurs valeurs dans les pages, il retourne Result<Pager<T>> en tant que Result de 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(())
}

Pagination pour traiter chaque page d’éléments

Pour effectuer une itération sur tous les éléments d’une réponse paginée, utilisez la méthode into_pages() sur la Pager renvoyée. Cette méthode retourne un flux asynchrone de pages en tant que PageIterator, afin de pouvoir traiter chaque page au fur et à mesure qu’elle devient disponible.

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

Exemple de code

Le code présenté dans cet article est disponible sur https://github.com/azure-samples/azure-sdk-for-rust-docs/.

Étapes suivantes

  • Last updated on