Condividi tramite

Guida introduttiva: Usare Azure Cosmos DB per NoSQL con Azure SDK per Rust

  • Si applica a: ✅ NoSQL

In questa guida introduttiva si distribuisce un'applicazione Azure Cosmos DB per NoSQL di base usando Azure SDK per Rust. Azure Cosmos DB per NoSQL è un archivio dati senza schema che consente alle applicazioni di archiviare dati non strutturati nel cloud. Eseguire query sui dati nei contenitori ed eseguire operazioni comuni su singoli elementi usando Azure SDK per Rust.

Importante

Rust SDK per Azure Cosmos DB è attualmente disponibile in anteprima pubblica. Questa anteprima viene fornita senza un contratto di servizio e non è consigliabile per i carichi di lavoro di produzione. Alcune funzionalità non sono supportate o hanno un supporto limitato con funzionalità vincolate.

Per altre informazioni, vedere le Condizioni supplementari per l'uso delle anteprime di Microsoft Azure.

Documentazione di riferimento API | Codice sorgente della libreria | Crate (Rust) della libreria | CLI per sviluppatori Azure

Prerequisiti

  • Docker Desktop
  • Rust 1.80 o versione successiva

Se non si ha un account Azure, creare un account gratuito prima di iniziare.

Installare la libreria client

La libreria client è disponibile tramite Rust, come CRATE azure_data_cosmos.

  1. Se non è già installato, installare la creazione azure_data_cosmosusando cargo install.

    cargo add azure_data_cosmos

  2. Installare anche il CRATE azure_identity se non è già installato.

    cargo add azure_identity

Importare le librerie

Importa i DefaultAzureCredential, CosmosClient, PartitionKey e Query nel codice dell'applicazione.

use azure_data_cosmos::{CosmosClient, PartitionKey, Query};
use azure_identity::DefaultAzureCredential;

Modello a oggetti

Nome Descrizione
CosmosClient Questo tipo è il client primario e viene usato per gestire i metadati o i database a livello di account.
DatabaseClient Questo tipo rappresenta un database all'interno dell'account.
ContainerClient Questo tipo viene usato principalmente per eseguire operazioni di lettura, aggiornamento ed eliminazione sul contenitore o sugli elementi archiviati all'interno del contenitore.

Esempi di codice

Il codice di esempio nel modello usa un database denominato cosmicworks e un contenitore denominato products. Il contenitore products contiene dettagli quali nome, categoria, quantità, identificatore univoco e flag di vendita per ogni prodotto. Il contenitore usa la proprietà /category come chiave di partizione logica.

Autenticare il client

Questo esempio crea una nuova istanza di CosmosClient usando CosmosClient::new ed esegue l'autenticazione usando un'istanza di DefaultAzureCredential.

let credential = DefaultAzureCredential::new()?;

let client = CosmosClient::new(&endpoint, credential, None)?;

Ottenere un database

Usare client.database per recuperare il database esistente denominato cosmicworks.

let database = client.database_client("cosmicworks");

Ottenere un contenitore

Recuperare il contenitore products esistente usando database.container.

let container = database.container_client("products");

Creare un elemento

Creare un nuovo tipo con tutti i membri da serializzare in JSON. In questo esempio il tipo ha un identificatore univoco e i campi per categoria, nome, quantità, prezzo e vendita. Derivare il tratto serde::Serialize su questo tipo, in modo che possa essere serializzato in JSON.

use serde::{Deserialize, Serialize};

#[derive(Serialize, Deserialize)]
pub struct Item {
    pub id: String,
    pub category: String,
    pub name: String,
    pub quantity: i32,
    pub price: f64,
    pub clearance: bool,
}

Creare un elemento nel contenitore usando container.upsert_item. Questo metodo esegue l'upsert dell'elemento, in pratica sostituendolo, se esiste già.

let item = Item {
    id: "aaaaaaaa-0000-1111-2222-bbbbbbbbbbbb".to_string(),
    category: "gear-surf-surfboards".to_string(),
    name: "Yamba Surfboard".to_string(),
    quantity: 12,
    price: 850.00,
    clearance: false,
};

let partition_key = PartitionKey::from(item.category.clone());
        
let partition_key = PartitionKey::from(item.category.clone());

container.upsert_item(partition_key, item.clone(), None).await?;

Leggere un elemento

Eseguire un'operazione di lettura dei punti usando sia l'identificatore univoco (id) che i campi chiave di partizione. Usare container.ReadItem per recuperare in modo efficiente l'elemento specifico.

let item_id = "aaaaaaaa-0000-1111-2222-bbbbbbbbbbbb";
let item_partition_key = "gear-surf-surfboards";

let response = container.read_item(item_partition_key, item_id, None).await?;

let item: Item = response.into_json_body().await?;

Eseguire query sugli elementi

Eseguire una query su più elementi in un contenitore usando container.NewQueryItemsPager. Trovare tutti gli elementi all'interno di una categoria specificata usando questa query con parametri:

SELECT * FROM products p WHERE p.category = @category

let item_partition_key = "gear-surf-surfboards";

let query = Query::from("SELECT * FROM c WHERE c.category = @category")
    .with_parameter("@category", item_partition_key)?;

let mut pager = container.query_items::<Item>(query, item_partition_key, None)?;

while let Some(page_response) = pager.next().await {

    let page = page_response?.into_body().await?;

    for item in page.items {
        // Do something
    }

}

Esplorare i dati

Usare l'estensione Di Visual Studio Code per Azure Cosmos DB per esplorare i dati NoSQL. È possibile eseguire operazioni di database di base, tra cui:

  • Esecuzione di query tramite un raccoglitore o l'editor di query
  • Modifica, aggiornamento, creazione ed eliminazione di elementi
  • Importazione di dati in blocco da altre origini
  • Gestione di database e contenitori

Per altre informazioni, vedere How-to use Visual Studio Code extension to explore Azure Cosmos DB for NoSQL data (Come usare l'estensione Visual Studio Code per esplorare i dati di Azure Cosmos DB per NoSQL).

Contenuto correlato

Passaggio successivo

Esempi di Azure SDK per Rust per Azure Cosmos DB per NoSQL

  • Last updated on