Condividi tramite

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

  • Articolo
  • Si applica a:
    ✅ NoSQL

In questa guida introduttiva si distribuisce un'applicazione Azure Cosmos DB per tabelle di base usando Azure SDK per Rust. Azure Cosmos DB per tabella è un archivio dati senza schema che consente alle applicazioni di archiviare dati strutturati della tabella nel cloud. Si apprenderà come creare tabelle, righe ed eseguire attività di base all'interno della risorsa di Azure Cosmos DB 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à potrebbero non essere supportate o potrebbero presentare funzionalità limitate.

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

Documentazione | di riferimento api Codice | sorgente libreria Crate (Rust) | Interfaccia della riga di comando per sviluppatori di 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 azure_data_cosmos crate.

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

    cargo install azure_data_cosmos

  2. Installare anche la azure_identity cassa se non è già installata.

    cargo install azure_identity

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.
CollectionClient 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 serde::Serialize tratto 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 scrapbook 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