Usar SDK do Azure para crates do Rust para acessar os serviços do Azure

O SDK do Azure para crates em Rust ajuda você a acessar os serviços da Azure a partir de aplicativos Rust. Este artigo explica como usar esses crates, incluindo autenticação, serviços com suporte e práticas recomendadas.

Crates | documentação de referência da API | Código-fonte

Importante

Use as versões estáveis mais recentes dos crates do SDK do Azure para Rust em novos desenvolvimentos. Cada crate tem versionamento independente, portanto use a versão estável mais recente de cada crate da qual sua aplicação depende.

Pré-requisitos para desenvolver com crates

Fornecer credenciais de autenticação

Os crates do Azure precisam de credenciais para se autenticar no Microsoft Entra ID. Azure serviços fornecem métodos de autenticação diferentes para conexão. É recomendável usar o azure_identity crate para autenticação. Saiba mais sobre autenticação no SDK do Azure para crates Rust.

Objetos de cliente

Use objetos cliente para interagir com serviços de Azure. Cada objeto cliente, do crate de um serviço, corresponde a um serviço Azure específico e fornece métodos para executar operações nesse serviço. Por exemplo, use azure_security_keyvault_secrets::SecretClient para interagir com segredos do Azure Key Vault. Você também pode usar QueueClient, KeyClient e CertificateClient para Armazenamento de Filas do Azure, chaves do Azure Key Vault e certificados do Azure Key Vault.

Ao criar os objetos do cliente, você pode fornecer um ClientOptions parâmetro para personalizar as interações com o serviço. Use ClientOptions para definir coisas como tempos limite, políticas de repetição e outras configurações.

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

Tratamento de erros

Quando uma chamada de serviço falha, a resposta retornada contém o 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 da página

Se uma chamada de serviço retornar vários valores em páginas, ela retornará Result<Pager<T>> como um 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(())
}

Paginação para processar cada página de itens

Para iterar por todos os itens em uma resposta paginada, use o método into_pages() no Pager retornado. Esse método retorna um fluxo assíncrono de páginas como um PageIterator, para que você possa processar cada página conforme ela se torna disponível.

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 exemplo

O código mostrado neste artigo está disponível em https://github.com/azure-samples/azure-sdk-for-rust-docs/.

Próximas etapas

  • Last updated on