Teilen über

Verwenden des Azure SDK für Rostkrates für den Zugriff auf Azure-Dienste

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

Lattenkisten | API-Referenzdokumentation | Quellcode

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.

Bereitstellen von Authentifizierungsanmeldeinformationen

Die Azure-Kisten benötigen Anmeldeinformationen, um sich bei Microsoft Entra-ID zu authentifizieren. Azure-Dienste stellen unterschiedliche Authentifizierungsmethoden für die Verbindung bereit. Es wird empfohlen, die Kiste für die azure_identity Authentifizierung zu verwenden. Erfahren Sie mehr über die Authentifizierung für Azure SDK für Rostkrates.

Clientobjekte

Sie verwenden Clientobjekte, um mit Azure-Diensten zu interagieren. Jedes Clientobjekt aus der Kiste eines Diensts entspricht einem bestimmten Azure-Dienst und stellt Methoden zum Ausführen von Vorgängen für diesen Dienst bereit. Beispielsweise wird verwendet, azure_security_keyvault_secrets::SecretClient um mit geheimen Azure Key Vault-Schlüsseln zu interagieren.

Wenn Sie die Clientobjekte erstellen, können Sie einen ClientOptions Parameter zum Anpassen der Interaktionen mit dem Dienst bereitstellen. Hier können ClientOptions Sie Elemente wie Timeouts, Wiederholungsrichtlinien und andere Konfigurationen festlegen.

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

Seitenergebnisse

Wenn ein Dienstaufruf mehrere Werte in Seiten zurückgibt, wird Result<Pager<T>> er als eine Result von 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(())
}

Paginierung zum Verarbeiten jeder Seite von Elementen

Verwenden Sie die into_pages() Methode für die zurückgegebene PagerMethode, um alle Elemente in einer paginierten Antwort zu durchlaufen. Diese Methode gibt einen asynchronen Seitenstrom als Eine PageIteratorzurü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