Partilhar via

Guia de início rápido: usar o Azure Cosmos DB para NoSQL com o SDK do Azure para Rust

  • Artigo
  • Aplica-se a:
    ✅ NoSQL

Neste início rápido, você implanta um aplicativo básico do Azure Cosmos DB for Table usando o SDK do Azure para Rust. O Azure Cosmos DB for Table é um armazenamento de dados sem esquema que permite que os aplicativos armazenem dados de tabela estruturada na nuvem. Você aprende a criar tabelas, linhas e executar tarefas básicas em seu recurso do Azure Cosmos DB usando o SDK do Azure para Rust.

Importante

O SDK do Rust para Azure Cosmos DB está atualmente em visualização pública. Essa visualização é fornecida sem um contrato de nível de serviço e não a recomendamos para cargas de trabalho de produção. Algumas funcionalidades poderão não ser suportadas ou poderão ter capacidades limitadas.

Para obter mais informações, veja Termos Suplementares de Utilização para Pré-visualizações do Microsoft Azure.

Documentação | de referência da API Código fonte | da biblioteca Crate (Rust) | Azure Developer CLI

Pré-requisitos

  • Área de trabalho do Docker
  • Ferrugem 1.80 ou posterior

Se não tiver uma conta do Azure, crie uma conta gratuita antes de começar.

Instalar a biblioteca de cliente

A biblioteca do cliente está disponível através do Rust, como a azure_data_cosmos caixa.

  1. Se ainda não estiver instalado, instale o create usando cargo installo azure_data_cosmos .

    cargo install azure_data_cosmos

  2. Além disso, instale a azure_identity caixa se ainda não estiver instalada.

    cargo install azure_identity

Modelo de objeto

Nome Descrição
CosmosClient Esse tipo é o cliente principal e é usado para gerenciar metadados ou bancos de dados em toda a conta.
DatabaseClient Esse tipo representa um banco de dados dentro da conta.
CollectionClient Esse tipo é usado principalmente para executar operações de leitura, atualização e exclusão no contêiner ou nos itens armazenados no contêiner.

Exemplos de código

O código de exemplo no modelo usa um banco de dados chamado cosmicworks e um contêiner chamado products. O products recipiente contém detalhes como nome, categoria, quantidade, um identificador exclusivo e um sinalizador de venda para cada produto. O contêiner usa a /category propriedade como uma chave de partição lógica.

Autenticar o cliente

Este exemplo cria uma nova instância de CosmosClient uso CosmosClient::new e autentica usando uma DefaultAzureCredential instância.

let credential = DefaultAzureCredential::new()?;

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

Obter uma base de dados

Use client.database para recuperar o banco de dados existente chamado cosmicworks.

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

Obter um contentor

Recupere o contêiner existente products usando database.containero .

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

Criar um item

Crie um novo tipo com todos os membros que você deseja serializar em JSON. Neste exemplo, o tipo tem um identificador exclusivo e campos para categoria, nome, quantidade, preço e venda. Derive o serde::Serialize traço nesse tipo, para que ele possa ser serializado para 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,
}

Crie um item no contêiner usando container.upsert_itemo . Este método "upserts" o item efetivamente substituindo o item se ele já 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?;

Ler um item

Execute uma operação de leitura pontual usando os campos identificador exclusivo (id) e chave de partição. Use container.ReadItem para recuperar eficientemente o item 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?;

Itens de consulta

Execute uma consulta sobre vários itens em um contêiner usando container.NewQueryItemsPagero . Encontre todos os itens dentro de uma categoria especificada usando esta consulta parametrizada:

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
    }

}

Explore os seus dados

Use a extensão Visual Studio Code para Azure Cosmos DB para explorar seus dados NoSQL. Você pode executar operações principais do banco de dados, incluindo, mas não limitado a:

  • Executando consultas usando um álbum de recortes ou o editor de consultas
  • Modificando, atualizando, criando e excluindo itens
  • Importando dados em massa de outras fontes
  • Gerenciando bancos de dados e contêineres

Para obter mais informações, consulte Como usar a extensão de código do Visual Studio para explorar o Azure Cosmos DB para dados NoSQL.

Conteúdos relacionados

Próximo passo

Exemplos do SDK do Azure para Rust para o Azure Cosmos DB para NoSQL