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

Aplica-se a: ✅ NoSQL

Neste início rápido, você implanta um aplicativo básico do Azure Cosmos DB para NoSQL usando o SDK do Azure para Rust. O Azure Cosmos DB para NoSQL é um armazenamento de dados sem esquema que permite que os aplicativos armazenem dados não estruturados na nuvem. Consulte dados em seus contêineres e execute operações comuns em itens individuais usando o SDK do Azure para Rust.

Importante

O SDK do Rust para Azure Cosmos DB está atualmente em visualização pública. Esta pré-visualização é fornecida sem um acordo de nível de serviço, e não a recomendamos para trabalhos em produção. Certas funcionalidades não são suportadas ou têm compatibilidade limitada com capacidades restritas.

Para mais informações, consulte Termos Suplementares de Utilização para Microsoft Azure Previews.

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

Pré-requisitos

Área de trabalho do Docker
Rust 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 em Rust, como o azure_data_cosmos crate.

Se ainda não estiver instalado, instale o azure_data_cosmos create usando cargo install.
```
cargo add azure_data_cosmos
```
Além disso, instale o azure_identity pacote se ainda não estiver instalado.
```
cargo add azure_identity
```

Importar bibliotecas

Importe os tipos , DefaultAzureCredential, CosmosCliente para PartitionKey o Querycódigo do aplicativo.

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

Modelo de objeto

Name	Description
`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.
`ContainerClient`	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.

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 usando CosmosClient::new e autentica usando uma instância DefaultAzureCredential.

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");

Obtenha um contentor

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

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_item. Este método insere ou atualiza o item, substituindo efetivamente o item se ele já existir.

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());

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

Leia o item

Execute uma operação de leitura pontual usando os campos identificador exclusivo (id) e chave de partição. Use container.read_item 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 num recipiente usando container.query_items. 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

Utilize a extensão do Visual Studio Code para o Azure Cosmos DB para explorar os 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.

Próximo passo

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

Comentários

Esta página foi útil?

Last updated on 2026-04-27