Partager via

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

Les caisses du Kit de développement logiciel (SDK) Azure pour 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.

Caisses | Documentation de | Code source

Conditions préalables au développement avec des caisses

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 d’authentification

Les caisses Azure ont besoin d’informations d’identification pour s’authentifier auprès de Microsoft Entra ID. Les services Azure fournissent différentes méthodes d’authentification pour la connexion. Nous vous recommandons d’utiliser la caisse pour l’authentification azure_identity . En savoir plus sur l’authentification pour les caisses du Kit de développement logiciel (SDK) Azure pour 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 il est utilisé pour interagir avec les secrets Azure Key Vault.

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

Paginer des résultats

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

Pagination pour traiter chaque page d’éléments

Pour effectuer une itération dans tous les éléments d’une réponse paginé, utilisez la into_pages() méthode sur le retour 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