Bibliothèque Azure Blob Storage pour Rust

Bibliothèque client pour Azure Blob Storage — télécharger, charger et gérer les blobs et conteneurs.

Utilisez cette skill quand :

• Une application a besoin de charger ou télécharger des blobs depuis Azure Storage en Rust
• Vous devez créer ou gérer des conteneurs de blobs
• Vous avez besoin de lister les blobs avec pagination
• Vous avez besoin d'une authentification basée sur RBAC pour les opérations blob

IMPORTANT : Utilisez uniquement le crate officiel azure_storage_blob publié par l'utilisateur azure-sdk sur crates.io. N'utilisez PAS les crates communautaires non officiels azure_storage, azure_storage_blobs ou azure_sdk_for_rust. Les crates officiels utilisent des traits de soulignement dans les noms et aucun n'a la version 0.21.0.

Installation

cargo add azure_storage_blob azure_identity tokio

Ne pas ajouter azure_core directement à Cargo.toml. Il est ré-exporté par azure_storage_blob.

Variables d'environnement

AZURE_STORAGE_ENDPOINT=https://<account>.blob.core.windows.net/ # Requis pour toutes les opérations

Authentification

use azure_identity::DeveloperToolsCredential;
use azure_storage_blob::BlobClient;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Dev local : DeveloperToolsCredential. Production : utilisez ManagedIdentityCredential.
    let credential = DeveloperToolsCredential::new(None)?;
    let blob_client = BlobClient::new(
        "https://<account>.blob.core.windows.net/",
        "container-name",
        "blob-name",
        Some(credential),
        None,
    )?;
    Ok(())
}

Types de clients

Flux de travail principal

Charger un blob

use azure_core::http::RequestContent;
use azure_identity::DeveloperToolsCredential;
use azure_storage_blob::BlobClient;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Dev local : DeveloperToolsCredential. Production : utilisez ManagedIdentityCredential.
    let credential = DeveloperToolsCredential::new(None)?;
    let blob_client = BlobClient::new(
        "https://<account>.blob.core.windows.net/",
        "container-name",
        "blob-name",
        Some(credential),
        None,
    )?;

    let data = b"hello world";
    blob_client
        .upload(RequestContent::from(data.to_vec()), None)
        .await?;
    Ok(())
}

Télécharger un blob / Obtenir les propriétés

// Obtenir les propriétés du blob
let props = blob_client.get_properties(None).await?;

// Télécharger le contenu du blob
let response = blob_client.download(None).await?;
let content = response.into_body().collect_bytes().await?;

Supprimer un blob

blob_client.delete(None).await?;

Opérations sur les conteneurs

use azure_identity::DeveloperToolsCredential;
use azure_storage_blob::BlobContainerClient;
use futures::TryStreamExt as _;

let credential = DeveloperToolsCredential::new(None)?;
let container_client = BlobContainerClient::new(
    "https://<account>.blob.core.windows.net/",
    "container-name",
    Some(credential),
    None,
)?;

// Créer un conteneur
container_client.create(None).await?;

// Lister les blobs (Pager<T> — itérer directement les éléments)
let mut pager = container_client.list_blobs(None)?;
while let Some(blob) = pager.try_next().await? {
    println!("Blob: {}", blob.name);
}

Gestion des erreurs

Utilisez StorageError pour accéder programmatiquement aux codes d'erreur spécifiques au storage :

use azure_core::error::ErrorKind;
use azure_storage_blob::{StorageError, StorageErrorCode};

let result = blob_client.download(None).await;

match result {
    Ok(response) => {
        let content = response.into_body().collect_bytes().await?;
        println!("Downloaded {} bytes", content.len());
    }
    Err(error) => {
        if matches!(error.kind(), ErrorKind::HttpResponse { .. }) {
            // Convertir en StorageError pour accès programmatique
            let storage_error: StorageError = error.try_into()?;
            println!("HTTP Status: {}", storage_error.status_code);

            if let Some(error_code) = &storage_error.error_code {
                match error_code {
                    StorageErrorCode::BlobNotFound => {
                        println!("The blob does not exist.");
                    }
                    StorageErrorCode::ContainerNotFound => {
                        println!("The container does not exist.");
                    }
                    StorageErrorCode::AuthorizationFailure => {
                        println!("Authorization failed. Check RBAC roles.");
                    }
                    _ => println!("Storage error: {error_code}"),
                }
            }

            if let Some(request_id) = &storage_error.request_id {
                println!("Request ID (for Azure support): {request_id}");
            }
        } else {
            println!("Non-HTTP error: {:?}", error);
        }
    }
}

Rôles RBAC

Pour l'authentification Entra ID, attribuez l'un de ces rôles à l'identité :

Bonnes pratiques

1. Utilisez DeveloperToolsCredential pour le dev local, ManagedIdentityCredential pour la production — le SDK Rust n'a pas DefaultAzureCredential
2. Ne codez jamais les credentials en dur — utilisez des variables d'environnement ou une identité gérée
3. Utilisez RequestContent::from() pour envelopper les données de chargement (bytes, chaînes ou streams)
4. Attribuez des rôles RBAC — assurez-vous que « Storage Blob Data Contributor » est attribué pour l'accès en écriture
5. Réutilisez les clients — les clients sont thread-safe ; créez-les une fois, partagez-les entre les tâches

Liens de référence