Dela via

Snabbstart: Använda Azure Cosmos DB för NoSQL med Azure SDK för Rust

  • Artikel
  • Gäller för:
    ✅ NoSQL

I den här snabbstarten distribuerar du ett grundläggande Azure Cosmos DB for Table-program med hjälp av Azure SDK för Rust. Azure Cosmos DB for Table är ett schemalöst datalager som gör att program kan lagra strukturerade tabelldata i molnet. Du lär dig hur du skapar tabeller, rader och utför grundläggande uppgifter i din Azure Cosmos DB-resurs med hjälp av Azure SDK för Rust.

Viktigt!

Rust SDK för Azure Cosmos DB finns för närvarande i offentlig förhandsversion. Den här förhandsversionen tillhandahålls utan ett serviceavtal och vi rekommenderar det inte för produktionsarbetsbelastningar. Vissa funktioner kanske inte stöds eller kan vara begränsade.

Mer information finns i Kompletterande villkor för användning av Microsoft Azure-förhandsversioner.

API-referensdokumentation Bibliotek källkodSlåda | (Rust) | Azure Developer CLI |

Förutsättningar

  • Docker Desktop
  • Rost 1.80 eller senare

Om du inte har något Azure-konto skapar du ett kostnadsfritt konto innan du börjar.

Installera klientbiblioteket

Klientbiblioteket är tillgängligt via Rust som azure_data_cosmos låda.

  1. Om du inte redan har installerat installerar du azure_data_cosmos skapa med .cargo install

    cargo install azure_data_cosmos

  2. Installera även lådan om den azure_identity inte redan är installerad.

    cargo install azure_identity

Objektmodell

Name beskrivning
CosmosClient Den här typen är den primära klienten och används för att hantera kontoomfattande metadata eller databaser.
DatabaseClient Den här typen representerar en databas i kontot.
CollectionClient Den här typen används främst för att utföra läs-, uppdaterings- och borttagningsåtgärder på antingen containern eller de objekt som lagras i containern.

Kodexempel

Exempelkoden i mallen använder en databas med namnet cosmicworks och containern med namnet products. Containern products innehåller information som namn, kategori, kvantitet, en unik identifierare och en försäljningsflagga för varje produkt. Containern använder egenskapen /category som en logisk partitionsnyckel.

Autentisera klienten

Det här exemplet skapar en ny instans av användning CosmosClient::new och autentiserar med hjälp av CosmosClient en DefaultAzureCredential instans.

let credential = DefaultAzureCredential::new()?;

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

Hämta en databas

Använd client.database för att hämta den befintliga databasen med namnet cosmicworks.

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

Hämta en container

Hämta den befintliga products containern med .database.container

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

Skapa ett objekt

Skapa en ny typ med alla medlemmar som du vill serialisera till JSON. I det här exemplet har typen en unik identifierare och fält för kategori, namn, kvantitet, pris och försäljning. Härled egenskapen för den serde::Serialize här typen så att den kan serialiseras till 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,
}

Skapa ett objekt i containern med .container.upsert_item Den här metoden "upserts" objektet ersätter objektet effektivt om det redan finns.

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?;

Läsa ett objekt

Utför en punktläsningsåtgärd med hjälp av både de unika identifierarna (id) och partitionsnyckelfälten. Använd container.ReadItem för att effektivt hämta det specifika objektet.

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?;

Frågeobjekt

Utför en fråga över flera objekt i en container med hjälp av container.NewQueryItemsPager. Hitta alla objekt i en angiven kategori med den här parameteriserade frågan:

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
    }

}

Utforska dina data

Använd Visual Studio Code-tillägget för Azure Cosmos DB för att utforska dina NoSQL-data. Du kan utföra grundläggande databasåtgärder, inklusive, men inte begränsat till:

  • Köra frågor med hjälp av en klippbok eller frågeredigeraren
  • Ändra, uppdatera, skapa och ta bort objekt
  • Importera massdata från andra källor
  • Hantera databaser och containrar

Mer information finns i Använda Visual Studio Code-tillägget för att utforska Azure Cosmos DB för NoSQL-data.

Relaterat innehåll

Gå vidare

Azure SDK för Rust-exempel för Azure Cosmos DB för NoSQL