Início Rápido: Usar o Azure Cosmos DB for NoSQL com o SDK do Azure para Rust

Aplica-se a: ✅ NoSQL

Neste início rápido, você implantará 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 em Rust para Azure Cosmos DB está em visualização pública. Essa versão prévia é fornecida sem um contrato de nível de serviço e não recomendamos isso para cargas de trabalho de produção. Determinados recursos não têm suporte ou têm suporte limitado com capacidades restritas.

Para obter mais informações, consulte Termos de Uso Complementares para Versões Prévias do Microsoft Azure.

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

Pré-requisitos

Área de Trabalho do Docker
Rust 1.80 ou posterior

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

Instalar a biblioteca de clientes

A biblioteca de clientes está disponível por meio do Rust, como o crate azure_data_cosmos.

Se ainda não estiver instalado, instale o crate azure_data_cosmos usando cargo install.
```
cargo add azure_data_cosmos
```
Instale também o crate azure_identity, se ainda não estiver instalado.
```
cargo add azure_identity
```

Importar bibliotecas

Importe o DefaultAzureCredential, CosmosClient, PartitionKey e Query tipos para o código do seu aplicativo.

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

Modelo de objeto

Nome	Description
`CosmosClient`	Esse tipo é o cliente principal e é usado para gerenciar metadados ou bancos de dados na conta inteira.
`DatabaseClient`	Esse tipo representa um banco de dados dentro da conta.
`ContainerClient`	Esse tipo é usado principalmente para realizar operações de leitura, atualização e exclusão no contêiner ou nos itens armazenados dentro do contêiner.

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

Autenticar o cliente

Esta amostra cria uma instância de CosmosClient usando CosmosClient::new e faz a autenticação com uma instância de DefaultAzureCredential.

let credential = DefaultAzureCredential::new()?;

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

Obter um banco de dados

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

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

Obter um contêiner

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

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

Criar um item

Crie um tipo novo com todos os membros que você quiser serializar para JSON. Neste exemplo, o tipo tem um identificador exclusivo, além de campos para categoria, nome, quantidade, preço e venda. Derivar a característica serde::Serialize nesse tipo, de modo 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. Esse método executa upsert no item, substituindo o item efetivamente caso ele já exista.

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

Realize uma operação de leitura de ponto usando o identificador exclusivo (id) e os campos de chave de partição. Use container.ReadItem para recuperar com eficiência 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

Realize uma consulta em vários itens de um contêiner usando container.NewQueryItemsPager. Localize todos os itens 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 do Visual Studio Code para o Azure Cosmos DB para explorar seus dados NoSQL. Você pode executar operações de banco de dados principais, incluindo, mas não se limitando a:

Executar consultas usando um scrapbook ou o editor de consultas
Modificar, atualizar, criar e excluir itens
Importar dados em massa de outras fontes
Gerenciando bancos de dados e contêineres

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

Próxima etapa

Amostras do SDK do Azure para Rust para o Azure Cosmos DB for NoSQL

Comentários

Esta página foi útil?

Last updated on 2025-12-19