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

Use la versión estable más reciente de 1.x SDK de Azure para las versiones de crate de Rust para el nuevo desarrollo. Cada versión de crate es independiente, por lo que debe usar la versión estable más reciente de 1.x para cada caja de crate de la que depende la aplicación.

Requisitos previos para desarrollar con crates

Sugerencia

Para obtener la mejor experiencia de desarrollo, asegúrese de que tiene instalada la versión estable más reciente de Rust.

Proporcionar credenciales de autenticación

Las bibliotecas de Azure necesitan credenciales para autenticarse en Microsoft Entra ID. Azure servicios proporcionan diferentes métodos de autenticación para la conexión. Se recomienda usar la caja para la azure_identity 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 Azure Key Vault secretos. 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, use el método into_pages() sobre 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