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

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

Los objetos de cliente se usan 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, azure_security_keyvault_secrets::SecretClient se usa para interactuar con secretos de 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