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

Nesse início rápido, você vai implantar 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 aplicativos armazenem dados de tabela estruturados na nuvem. Você vai aprender a criar tabelas, linhas e executar tarefas básicas dentro do seu recurso do Azure Cosmos DB usando o Azure SDK para Rust.

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

Pré-requisitos

• Docker Desktop
• 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.

1. Se ainda não estiver instalado, instale o crate azure_data_cosmos usando cargo install.

   cargo install azure_data_cosmos
   

2. Instale também o crate azure_identity, se ainda não estiver instalado.

   cargo install azure_identity
   

Modelo de objeto

Exemplos de código

• Autenticar o cliente
• Obter um banco de dados
• Obter um contêiner
• Criar um item
• Obter um item
• Itens de consulta

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
    }

}

Explorar seus dados

Use a extensão do Visual Studio Code para o Azure Cosmos DB para explorar seus dados do SQL. 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.

Conteúdo relacionado

• Início Rápido do .NET
• Início rápido do Node.js
• Início Rápido do Java
• Início Rápido do Python
• Início Rápido do Go

Próxima etapa