Partilhar via

Utilize o SDK da Azure para Caixas Rust para aceder aos serviços da Azure

O SDK do Azure para crates Rust ajuda a aceder aos serviços da Azure a partir de aplicações Rust. Este artigo explica como usar essas caixas, incluindo autenticação, serviços suportados e práticas recomendadas.

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

Requisitos prévios para desenvolver com crates

Sugestão

Para obter a melhor experiência de desenvolvimento, certifique-se de ter a versão estável mais recente do Rust instalada.

Fornecer credenciais de autenticação

Os contentores do Azure precisam de credenciais para autenticar com o Microsoft Entra ID. Os serviços do Azure fornecem diferentes métodos de autenticação para a ligação. Recomendamos o uso da azure_identity caixa para autenticação. Saiba mais sobre autenticação do SDK do Azure para pacotes Rust.

Objetos de cliente

Usas objetos cliente para interagir com os serviços do Azure. Cada objeto cliente, a partir da caixa de um serviço, corresponde a um serviço Azure específico e fornece métodos para realizar operações nesse serviço. Por exemplo, azure_security_keyvault_secrets::SecretClient é usado para interagir com segredos do Azure Key Vault.

Ao criar os objetos cliente, você pode fornecer um ClientOptions parâmetro para personalizar as interações com o serviço. Use ClientOptions para definir coisas como tempos limites, 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 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 à medida que 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óximos passos

  • Last updated on