Uso de SDK de Azure para contenedores de Rust para acceder a los servicios de Azure

Los SDK de Azure para las cajas de Rust le ayudan a acceder a los servicios de Azure desde aplicaciones de Rust. En este artículo se explica cómo usar estas cajas, incluida la autenticación, los servicios admitidos y los procedimientos recomendados.

Crates | documentación de referencia de la API | código fuente

Importante

Utiliza las últimas versiones estables del SDK de Azure para Rust para nuevos desarrollos. Cada crate se versiona de forma independiente, por lo que debe utilizar la versión estable más reciente de cada crate de la que depende su aplicación.

Requisitos previos para desarrollar con crates

Proporcionar credenciales de autenticación

Los crates de Azure necesitan credenciales para autenticarse en Microsoft Entra ID. Azure servicios proporcionan diferentes métodos de autenticación para la conexión. Recomendamos utilizar el crate azure_identity para la autenticación. Obtenga más información sobre la autenticación para SDK de Azure para crates de Rust.

Objetos de cliente

Use objetos de cliente para interactuar con los servicios de Azure. Cada objeto de cliente, desde el contenedor de un servicio, corresponde a un servicio de Azure específico y proporciona métodos para realizar operaciones en ese servicio. Por ejemplo, use azure_security_keyvault_secrets::SecretClient para interactuar con los secretos de Azure Key Vault. También puede usar QueueClient, KeyClienty CertificateClient para Azure Queue Storage, claves de Azure Key Vault y certificados Azure Key Vault.

Al crear los objetos de cliente, puede proporcionar un ClientOptions parámetro para personalizar las interacciones con el servicio. Use ClientOptions para establecer elementos como tiempos de espera, directivas de reintento y otras configuraciones.

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

Control de errores

Cuando se produce un error en una llamada de servicio, la respuesta devuelta contiene .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(())
}

Resultados de página

Si una llamada de servicio devuelve varios valores en páginas, devuelve Result<Pager<T>> como un 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(())
}

Paginación para procesar cada página de ítems

Para recorrer todos los elementos de una respuesta paginada, utilice el método into_pages() en el Pager devuelto. Este método devuelve una secuencia asincrónica de páginas como PageIterator, por lo que puede procesar cada página a medida que esté 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(())
}

Código de ejemplo

El código que se muestra en este artículo está disponible en https://github.com/azure-samples/azure-sdk-for-rust-docs/.

Pasos siguientes

  • Last updated on