Compartir a través de

Inicio rápido: Uso de Azure Cosmos DB for NoSQL con Azure SDK para Rust

  • Artículo
  • Se aplica a:
    ✅ NoSQL

En este inicio rápido, implementará una aplicación básica de Azure Cosmos DB for Table mediante el SDK de Azure para Rust. Azure Cosmos DB for Table es un almacén de datos sin esquema que permite a las aplicaciones almacenar datos de tabla estructurados en la nube. Aprenderá a crear tablas, filas y realizar tareas básicas en el recurso de Azure Cosmos DB mediante el SDK de Azure para Rust.

Importante

El SDK de Rust para Azure Cosmos DB está actualmente en versión preliminar pública. Esta versión preliminar se ofrece sin acuerdo de nivel de servicio y no se recomienda para las cargas de trabajo de producción. Es posible que algunas características no sean compatibles o que tengan sus funcionalidades limitadas.

Para más información, consulte Términos de uso complementarios de las Versiones Preliminares de Microsoft Azure.

Documentación de referencia de la API | Código fuente de la biblioteca | Formato .CR8 (Rust) | Azure Developer CLI

Requisitos previos

  • Docker Desktop
  • Rust 1.80 o posterior

Antes de comenzar, si no tiene una cuenta de Azure, cree una gratuita.

Instalación de la biblioteca cliente

La biblioteca cliente está disponible a través de Rust, ya que el azure_data_cosmos formato .CR8.

  1. Si aún no está instalado, instale el azure_data_cosmos crear mediante cargo install.

    cargo install azure_data_cosmos

  2. Además, instale el azure_identity formato .CR8 si aún no está instalado.

    cargo install azure_identity

Modelo de objetos

Nombre Descripción
CosmosClient Este tipo es el cliente principal y se usa para administrar bases de datos o metadatos de toda la cuenta.
DatabaseClient Este tipo representa una base de datos dentro de la cuenta.
CollectionClient Este tipo se usa principalmente para realizar operaciones de lectura, actualización y eliminación en el contenedor o en los elementos almacenados en el contenedor.

Ejemplos de código

El código de ejemplo de la plantilla usa una base de datos denominada cosmicworks y un contenedor denominado products. El contenedor products contiene detalles como el nombre, la categoría, la cantidad, un identificador único y una marca de venta para cada producto. El contenedor usa la propiedad /category como clave de partición lógica.

Autenticar el cliente

En este ejemplo se crea una nueva instancia de CosmosClient mediante CosmosClient::new y se autentica mediante una instancia DefaultAzureCredential.

let credential = DefaultAzureCredential::new()?;

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

Obtención de una base de datos

Use client.database para recuperar la base de datos existente denominada cosmicworks.

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

Obtención de un contenedor

Recupere el contenedor existente products mediante database.container.

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

Crear un elemento

Cree un nuevo tipo con todos los miembros que quiera serializar en JSON. En este ejemplo, el tipo tiene un identificador único y campos para categoría, nombre, cantidad, precio y venta. Derive el rasgo serde::Serialize en este tipo para que se pueda serializar en 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,
}

Cree un elemento en el contenedor mediante container.upsert_item. Este método "actualiza" eficazmente el elemento si ya existe.

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

Lectura de un elemento

Se puede realizar una operación de lectura de punto mediante el identificador único (id) y los campos de clave de partición. Use container.ReadItem para recuperar de forma eficaz el elemento específico.

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

Elementos de consulta

Realice una consulta en varios elementos de un contenedor mediante container.NewQueryItemsPager. Busque todos los elementos de una categoría especificada mediante esta consulta con parámetros:

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
    }

}

Exploración de los datos

Use la extensión de Visual Studio Code para Azure Cosmos DB para explorar los datos de NoSQL. Puede realizar operaciones básicas de base de datos, entre las que se incluyen, entre otras:

  • Realizar consultas mediante un libro de recortes o el editor de consultas
  • Modificar, actualizar, crear y eliminar elementos
  • Importar datos masivos desde otros orígenes
  • Administrar bases de datos y contenedores

Para más información, consulte Cómo usar la extensión de Visual Studio Code para explorar datos de Azure Cosmos DB for NoSQL.

Contenido relacionado

Paso siguiente

Ejemplos de Azure SDK para Rust para Azure Cosmos DB for NoSQL