Verwenden Sie das Azure SDK für Rust Crates, um auf Azure-Dienste zuzugreifen.

Das Azure SDK für Rust-Crates hilft Ihnen, auf die Azure-Dienste von Rust-Anwendungen zuzugreifen. In diesem Artikel wird erläutert, wie Sie diese Kisten verwenden, einschließlich Authentifizierung, unterstützter Dienste und bewährter Methoden.

Crates | API-Referenzdokumentation | Source-Code

Important

Verwenden Sie für Neuentwicklungen die neuesten stabilen Releases des Azure SDK für Rust. Jede Crate wird unabhängig versioniert, verwenden Sie also für jede Crate, von der Ihre Anwendung abhängt, die aktuellste stabile Version.

Voraussetzungen für die Entwicklung mit Crates

Authentifizierungsanmeldedaten bereitstellen

Die Azure Crates benötigen Anmeldeinformationen, um sich bei Microsoft Entra ID zu authentifizieren. Azure Dienste bieten unterschiedliche Authentifizierungsmethoden für die Verbindung. Es wird empfohlen, das azure_identity Crate für die Authentifizierung zu verwenden. Erfahren Sie mehr über die Authentifizierung für das Azure SDK für Rust-Crates.

Clientobjekte

Verwenden Sie Clientobjekte, um mit Azure Diensten zu interagieren. Jedes Clientobjekt aus der Krate eines Diensts entspricht einem bestimmten Azure Dienst und stellt Methoden zum Ausführen von Vorgängen für diesen Dienst bereit. Verwenden Sie beispielsweise azure_security_keyvault_secrets::SecretClient, um mit Geheimnissen in Azure Key Vault zu interagieren. Sie können auch QueueClient, KeyClient und CertificateClient für Azure Queue Storage, Azure Key Vault-Schlüssel und Azure Key Vault-Zertifikate verwenden.

Wenn Sie die Clientobjekte erstellen, können Sie einen ClientOptions Parameter zum Anpassen der Interaktionen mit dem Dienst bereitstellen. ClientOptions verwenden, um Timeouts, Wiederholungsrichtlinien und andere Konfigurationen festzulegen.

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

Fehlerbehandlung

Wenn ein Dienstaufruf fehlschlägt, enthält die zurückgegebene Antwort die 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(())
}

Seitenergebnisse

Wenn ein Dienstaufruf mehrere Werte auf Seiten zurückgibt, gibt er Result<Pager<T>> als Result von Pager zurück.

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

Paginierung zum Verarbeiten jeder Seite von Elementen

Verwenden Sie die into_pages()-Methode für den zurückgegebenen Pager, um alle Elemente in einer paginierten Antwort zu iterieren. Diese Methode gibt einen asynchronen Seitenstrom als zurück, sodass Sie jede Seite verarbeiten können, sobald sie verfügbar wird.

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

Beispielcode

Der in diesem Artikel gezeigte Code ist verfügbar auf https://github.com/azure-samples/azure-sdk-for-rust-docs/.

Nächste Schritte

  • Last updated on