Partilhar via

Usar o SDK do Azure para caixas Rust para acessar os serviços do Azure

O SDK do Azure para caixas Rust ajuda você a acessar os serviços do Azure a partir de aplicativos Rust. Este artigo explica como usar essas caixas, incluindo autenticação, serviços suportados e práticas recomendadas.

Caixas | Documentação | Código fonte

Pré-requisitos para desenvolver com caixas

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

As caixas do Azure precisam de credenciais para se autenticarem no Microsoft Entra ID. Os serviços do Azure fornecem diferentes métodos de autenticação para conexão. Recomendamos o uso da azure_identity caixa para autenticação. Saiba mais sobre a autenticação para caixas do SDK do Azure para Rust.

Objetos de cliente

Você usa objetos de cliente para interagir com os serviços do Azure. Cada objeto de cliente, da caixa de um serviço, corresponde a um serviço específico do Azure e fornece métodos para executar operações nesse serviço. Por exemplo, azure_security_keyvault_secrets::SecretClient é usado para interagir com segredos do Cofre de Chaves do Azure.

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_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 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_body()?;
        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 into_pages() método no .Pager 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