Freigeben über

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

Voraussetzungen für die Entwicklung mit Kisten

Tipp

Um eine optimale Entwicklungserfahrung zu erzielen, stellen Sie sicher, dass Sie die neueste stabile Version von Rust installiert haben.

Authentifizierungsanmeldedaten bereitstellen

Die Azure Kisten 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

Sie verwenden 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. Beispielsweise wird azure_security_keyvault_secrets::SecretClient verwendet, um mit Azure Key Vault Geheimnissen zu interagieren.

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 in Seiten zurückgibt, gibt er Result<Pager<T>> in Form 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 auf dem 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