Bibliothèque Azure Cosmos DB pour Rust

Bibliothèque client pour l'API NoSQL d'Azure Cosmos DB — opérations CRUD sur documents, conteneurs et données distribuées mondialement.

Utilisez cette skill quand :

• Une app doit stocker ou interroger des documents dans Cosmos DB à partir de Rust
• Vous avez besoin d'opérations CRUD sur des éléments avec des clés de partition
• Vous avez besoin d'un routage multi-région avec RoutingStrategy
• Vous avez besoin d'une authentification par clé comme alternative à Entra ID

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

Installation

cargo add azure_data_cosmos azure_identity tokio

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

Variables d'environnement

COSMOS_ENDPOINT=https://<account>.documents.azure.com/ # Requis pour toutes les opérations

Authentification

use azure_identity::DeveloperToolsCredential;
use azure_data_cosmos::{
    CosmosClient, CosmosAccountReference, CosmosAccountEndpoint, RoutingStrategy,
};

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Dev local : DeveloperToolsCredential. Production : utilisez ManagedIdentityCredential.
    let credential: std::sync::Arc<dyn azure_core::credentials::TokenCredential> =
        DeveloperToolsCredential::new(None)?;
    let endpoint: CosmosAccountEndpoint = "https://<account>.documents.azure.com/"
        .parse()?;
    let account = CosmosAccountReference::with_credential(endpoint, credential);
    let client = CosmosClient::builder()
        .build(account, RoutingStrategy::ProximityTo("East US".into()))
        .await?;
    Ok(())
}

Hiérarchie des clients

Flux de travail principal

use serde::{Serialize, Deserialize};
use azure_data_cosmos::CosmosClient;

#[derive(Serialize, Deserialize)]
struct Item {
    pub id: String,
    pub partition_key: String,
    pub value: String,
}

async fn crud(client: CosmosClient) -> Result<(), Box<dyn std::error::Error>> {
    let container = client
        .database_client("myDatabase")
        .container_client("myContainer")
        .await?;

    let item = Item {
        id: "1".into(),
        partition_key: "pk1".into(),
        value: "hello".into(),
    };

    // Create
    container.create_item("pk1", item, None).await?;

    // Read
    let resp = container.read_item("pk1", "1", None).await?;
    let mut item: Item = resp.into_model()?;

    // Update
    item.value = "updated".into();
    container.replace_item("pk1", "1", item, None).await?;

    // Delete
    container.delete_item("pk1", "1", None).await?;
    Ok(())
}

Authentification par clé (Optionnel)

Activez l'authentification par clé de compte avec le flag de feature :

cargo add azure_data_cosmos --features key_auth

Rôles RBAC

Pour l'authentification Entra ID, assignez l'un de ces rôles Cosmos DB intégrés :

Bonnes pratiques

1. Utilisez DeveloperToolsCredential pour le dev local, ManagedIdentityCredential pour la production — le SDK Rust n'a pas DefaultAzureCredential
2. Ne codez jamais en dur les credentials — utilisez des variables d'environnement ou une identité gérée
3. Réutilisez CosmosClient — les clients sont thread-safe ; créez une fois, partagez entre les tâches
4. Utilisez RoutingStrategy::ProximityTo — routez vers la région la plus proche pour la latence la plus faible
5. Spécifiez toujours la clé de partition pour les opérations sur éléments — Cosmos DB l'exige pour tous les CRUD

Liens de référence