Partager via

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

Conditions préalables au développement avec des crates

Conseil / Astuce

Pour une expérience de développement optimale, vérifiez que vous disposez de la dernière version stable de Rust installée.

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

Vous 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, azure_security_keyvault_secrets::SecretClient est utilisé pour interagir avec Azure Key Vault secrets.

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. 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