Compartir vía

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

Los contenedores de Azure SDK para 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.

Cajones | Documentación | Código fuente

Requisitos previos para desarrollar con cajas

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 cajas de Azure necesitan credenciales para autenticarse en el identificador de Microsoft Entra. Los servicios de Azure 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 Azure SDK para contenedores 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_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(())
}

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_body()?;
        println!("items_in_page: {}", page.value.len());
    }

    Ok(())
}

Paginación para procesar cada página de elementos

Para recorrer en iteración todos los elementos de una respuesta paginada, use el into_pages() método en el devuelto Pager. 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