Quickstart: Construa uma aplicação de consola .NET para gerir os recursos API API da Azure Cosmos DB SQLQuickstart: Build a .NET console app to manage Azure Cosmos DB SQL API resources

Começa com a biblioteca de clientes Azure Cosmos DB SQL API para .NET.Get started with the Azure Cosmos DB SQL API client library for .NET. Siga os passos neste doc para instalar o pacote .NET, construir uma aplicação e experimentar o código de exemplo para operações básicas da CRUD nos dados armazenados no Azure Cosmos DB.Follow the steps in this doc to install the .NET package, build an app, and try out the example code for basic CRUD operations on the data stored in Azure Cosmos DB.

O Azure Cosmos DB é um serviço de bases de dados com vários modelos e distribuído globalmente.Azure Cosmos DB is Microsoft’s globally distributed multi-model database service. Pode utilizar a Azure Cosmos DB para criar e consultar rapidamente bases de dados de chaves/valor, documentos e gráficos.You can use Azure Cosmos DB to quickly create and query key/value, document, and graph databases. Utilize a biblioteca de clientes Azure Cosmos DB SQL API para .NET para:Use the Azure Cosmos DB SQL API client library for .NET to:

  • Criar uma base de dados Azure Cosmos e um recipienteCreate an Azure Cosmos database and a container
  • Adicione dados de amostra ao recipienteAdd sample data to the container
  • Consultar os dadosQuery the data
  • Eliminar a base de dadosDelete the database

Documentação de | referência da API Código fonte da biblioteca | Pacote (NuGet)API reference documentation | Library source code | Package (NuGet)

Pré-requisitosPrerequisites

ConfiguraçãoSetting up

Esta secção acompanha-o através da criação de uma conta Azure Cosmos e da criação de um projeto que utiliza a biblioteca de clientes API API AZure Cosmos DB SQL para .NET para gerir recursos.This section walks you through creating an Azure Cosmos account and setting up a project that uses Azure Cosmos DB SQL API client library for .NET to manage resources. O código de exemplo descrito neste artigo cria uma FamilyDatabase base de dados e membros da família (cada membro da família é um item) dentro dessa base de dados.The example code described in this article creates a FamilyDatabase database and family members (each family member is an item) within that database. Cada membro da família tem propriedades Id, FamilyName, FirstName, LastName, Parents, Children, Address, como.Each family member has properties such as Id, FamilyName, FirstName, LastName, Parents, Children, Address,. A LastName propriedade é usada como chave de partição para o recipiente.The LastName property is used as the partition key for the container.

Criar uma conta do Azure CosmosCreate an Azure Cosmos account

Se utilizar o Try Azure Cosmos DB para opção gratuita para criar uma conta Azure Cosmos, deve criar uma conta DB Azure Cosmos do tipo SQL API.If you use the Try Azure Cosmos DB for free option to create an Azure Cosmos account, you must create an Azure Cosmos DB account of type SQL API. Uma conta de teste DB da Azure Cosmos já foi criada para si.An Azure Cosmos DB test account is already created for you. Não precisa de criar a conta explicitamente, para que possa saltar esta secção e passar para a secção seguinte.You don't have to create the account explicitly, so you can skip this section and move to the next section.

Se tiver a sua própria subscrição Azure ou tiver uma subscrição gratuita, deverá criar uma conta Azure Cosmos explicitamente.If you have your own Azure subscription or created a subscription for free, you should create an Azure Cosmos account explicitly. O seguinte código criará uma conta Azure Cosmos com consistência da sessão.The following code will create an Azure Cosmos account with session consistency. A conta é replicada em South Central US e North Central US .The account is replicated in South Central US and North Central US.

Pode utilizar a Azure Cloud Shell para criar a conta Azure Cosmos.You can use Azure Cloud Shell to create the Azure Cosmos account. O Azure Cloud Shell é uma shell interativa, autenticada e compatível com browsers para gerir recursos do Azure.Azure Cloud Shell is an interactive, authenticated, browser-accessible shell for managing Azure resources. Dá a flexibilidade de escolher a experiência de shell mais adequada ao seu método de trabalho, quer seja baseada em Bash ou no PowerShell.It provides the flexibility of choosing the shell experience that best suits the way you work, either Bash or PowerShell. Para este arranque rápido, escolha o modo Bash.For this quickstart, choose Bash mode. AZure Cloud Shell também requer uma conta de armazenamento, pode criar uma quando solicitada.Azure Cloud Shell also requires a storage account, you can create one when prompted.

Selecione o botão Try It ao lado do seguinte código, escolha o modo Bash selecione criar uma conta de armazenamento e iniciar sessão na Cloud Shell.Select the Try It button next to the following code, choose Bash mode select create a storage account and login to Cloud Shell. Em seguida, copie e cole o seguinte código para Azure Cloud Shell e execute-o.Next copy and paste the following code to Azure Cloud Shell and run it. O nome da conta Azure Cosmos deve ser globalmente único, certifique-se de atualizar o mysqlapicosmosdb valor antes de executar o comando.The Azure Cosmos account name must be globally unique, make sure to update the mysqlapicosmosdb value before you run the command.


# Set variables for the new SQL API account, database, and container
resourceGroupName='myResourceGroup'
location='southcentralus'

# The Azure Cosmos account name must be globally unique, make sure to update the `mysqlapicosmosdb` value before you run the command
accountName='mysqlapicosmosdb'

# Create a resource group
az group create \
    --name $resourceGroupName \
    --location $location

# Create a SQL API Cosmos DB account with session consistency and multi-master enabled
az cosmosdb create \
    --resource-group $resourceGroupName \
    --name $accountName \
    --kind GlobalDocumentDB \
    --locations regionName="South Central US" failoverPriority=0 --locations regionName="North Central US" failoverPriority=1 \
    --default-consistency-level "Session" \
    --enable-multiple-write-locations true

A criação da conta Azure Cosmos demora algum tempo, uma vez que a operação é bem sucedida, você pode ver a saída de confirmação.The creation of the Azure Cosmos account takes a while, once the operation is successful, you can see the confirmation output. Após o comando ter concluído com sucesso, inscreva-se no portal Azure e verifique se existe a conta Azure Cosmos com o nome especificado.After the command completes successfully, sign into the Azure portal and verify that the Azure Cosmos account with the specified name exists. Pode fechar a janela Azure Cloud Shell após a criação do recurso.You can close the Azure Cloud Shell window after the resource is created.

Criar uma nova aplicação .NETCreate a new .NET app

Crie uma nova aplicação .NET no seu editor preferido ou IDE.Create a new .NET application in your preferred editor or IDE. Abra o pedido de comando do Windows ou uma janela do terminal a partir do computador local.Open the Windows command prompt or a Terminal window from your local computer. Executará todos os comandos nas próximas secções a partir do comando ou terminal.You will run all the commands in the next sections from the command prompt or terminal. Executar o seguinte comando dotnet novo para criar uma nova app com o nome todo .Run the following dotnet new command to create a new app with the name todo. O parâmetro langVersion define a propriedade LangVersion no ficheiro do projeto criado.The --langVersion parameter sets the LangVersion property in the created project file.

dotnet new console --langVersion 7.1 -n todo

Mude o seu diretório para a pasta de aplicações recém-criada.Change your directory to the newly created app folder. Pode construir a aplicação com:You can build the application with:

cd todo
dotnet build

A produção esperada da construção deve ser algo assim:The expected output from the build should look something like this:

  Restore completed in 100.37 ms for C:\Users\user1\Downloads\CosmosDB_Samples\todo\todo.csproj.
  todo -> C:\Users\user1\Downloads\CosmosDB_Samples\todo\bin\Debug\netcoreapp2.2\todo.dll
  todo -> C:\Users\user1\Downloads\CosmosDB_Samples\todo\bin\Debug\netcoreapp2.2\todo.Views.dll

Build succeeded.
    0 Warning(s)
    0 Error(s)

Time Elapsed 00:00:34.17

Instale o pacote DB Azure CosmosInstall the Azure Cosmos DB package

Enquanto ainda está no diretório de aplicações, instale a biblioteca de clientes Azure Cosmos DB para .NET Core utilizando o comando do pacote de adicionar dotnet.While still in the application directory, install the Azure Cosmos DB client library for .NET Core by using the dotnet add package command.

dotnet add package Microsoft.Azure.Cosmos

Copie as suas credenciais de conta Azure Cosmos do portal AzureCopy your Azure Cosmos account credentials from the Azure portal

A aplicação da amostra precisa de autenticar na sua conta Azure Cosmos.The sample application needs to authenticate to your Azure Cosmos account. Para autenticar, deve passar as credenciais de conta Azure Cosmos para a aplicação.To authenticate, you should pass the Azure Cosmos account credentials to the application. Obtenha as suas credenciais de conta Azure Cosmos seguindo estes passos:Get your Azure Cosmos account credentials by following these steps:

  1. Inicie sessão no portal do Azure.Sign in to the Azure portal.

  2. Navegue para a sua conta Azure Cosmos.Navigate to your Azure Cosmos account.

  3. Abra o painel de chaves e copie o URI e a CHAVE PRINCIPAL da sua conta.Open the Keys pane and copy the URI and PRIMARY KEY of your account. Irá adicionar o URI e os valores das teclas a uma variável ambiental no passo seguinte.You will add the URI and keys values to an environment variable in the next step.

Definir as variáveis ambientaisSet the environment variables

Depois de copiar o URI e a CHAVE PRIMÁRIA da sua conta, guarde-os para uma nova variável ambiental na máquina local que executa a aplicação.After you have copied the URI and PRIMARY KEY of your account, save them to a new environment variable on the local machine running the application. Para definir a variável ambiente, abra uma janela da consola e execute o seguinte comando.To set the environment variable, open a console window, and run the following command. Certifique-se de que substitui <Your_Azure_Cosmos_account_URI> e <Your_Azure_Cosmos_account_PRIMARY_KEY> valoriza.Make sure to replace <Your_Azure_Cosmos_account_URI> and <Your_Azure_Cosmos_account_PRIMARY_KEY> values.

WindowsWindows

setx EndpointUrl "<Your_Azure_Cosmos_account_URI>"
setx PrimaryKey "<Your_Azure_Cosmos_account_PRIMARY_KEY>"

LinuxLinux

export EndpointUrl = "<Your_Azure_Cosmos_account_URI>"
export PrimaryKey = "<Your_Azure_Cosmos_account_PRIMARY_KEY>"

macOSmacOS

export EndpointUrl = "<Your_Azure_Cosmos_account_URI>"
export PrimaryKey = "<Your_Azure_Cosmos_account_PRIMARY_KEY>"

Modelo de objetoObject model

Antes de começar a construir a aplicação, vamos olhar para a hierarquia de recursos em Azure Cosmos DB e o modelo de objeto usado para criar e aceder a estes recursos.Before you start building the application, let's look into the hierarchy of resources in Azure Cosmos DB and the object model used to create and access these resources. O Azure Cosmos DB cria recursos na seguinte ordem:The Azure Cosmos DB creates resources in the following order:

  • Conta Azure CosmosAzure Cosmos account
  • Bases de DadosDatabases
  • ContentoresContainers
  • ItensItems

Para saber mais sobre a hierarquia de diferentes entidades, consulte o trabalho com bases de dados, contentores e itens no artigo da Azure Cosmos DB.To learn in more about the hierarchy of different entities, see the working with databases, containers, and items in Azure Cosmos DB article. Utilizará as seguintes classes .NET para interagir com estes recursos:You will use the following .NET classes to interact with these resources:

  • CosmosClient - Esta classe proporciona uma representação lógica do lado do cliente para o serviço DB Azure Cosmos.CosmosClient - This class provides a client-side logical representation for the Azure Cosmos DB service. O objeto cliente é usado para configurar e executar pedidos contra o serviço.The client object is used to configure and execute requests against the service.

  • CreateDatabaseIfNotExistsAsync - Este método cria (se não existir) ou obtém (se já existe) um recurso de base de dados como uma operação assíncrono.CreateDatabaseIfNotExistsAsync - This method creates (if doesn't exist) or gets (if already exists) a database resource as an asynchronous operation.

  • CreateContainerIfNotExistsAsync- - Este método cria (se não existir) ou obtém (se já existe) um recipiente como uma operação assíncrona.CreateContainerIfNotExistsAsync- - This method creates (if it doesn't exist) or gets (if it already exists) a container as an asynchronous operation. Pode verificar o código de estado da resposta para determinar se o recipiente foi recém-criado (201) ou se foi devolvido um contentor existente (200).You can check the status code from the response to determine whether the container was newly created (201) or an existing container was returned (200).

  • CreateItemAsync - Este método cria um item dentro do recipiente.CreateItemAsync - This method creates an item within the container.

  • UpsertItemAsync - Este método cria um item dentro do recipiente se já não existir ou substituir o item se já existir.UpsertItemAsync - This method creates an item within the container if it doesn't already exist or replaces the item if it already exists.

  • GetItemQueryIterator - Este método cria uma consulta para itens debaixo de um recipiente numa base de dados do Azure Cosmos utilizando uma declaração SQL com valores parametrizados.GetItemQueryIterator - This method creates a query for items under a container in an Azure Cosmos database using a SQL statement with parameterized values.

  • DeleteAsync - Elimina a base de dados especificada da sua conta Azure Cosmos.DeleteAsync - Deletes the specified database from your Azure Cosmos account. DeleteAsync método apenas elimina a base de dados.DeleteAsync method only deletes the database. A eliminação do Cosmosclient caso deve ocorrer separadamente (o que acontece no método DeleteDatabaseAndCleanUpAsync.Disposing of the Cosmosclient instance should happen separately (which it does in the DeleteDatabaseAndCleanupAsync method.

Exemplos de códigoCode examples

O código de amostra descrito neste artigo cria uma base de dados familiar em Azure Cosmos DB.The sample code described in this article creates a family database in Azure Cosmos DB. A base de dados da família contém detalhes familiares como nome, endereço, localização, pais, crianças e animais de estimação associados.The family database contains family details such as name, address, location, the associated parents, children, and pets. Antes de povoar os dados para a sua conta Azure Cosmos, defina as propriedades de um item familiar.Before populating the data to your Azure Cosmos account, define the properties of a family item. Crie uma nova classe nomeada Family.cs ao nível da raiz da sua aplicação de amostra e adicione-lhe o seguinte código:Create a new class named Family.cs at the root level of your sample application and add the following code to it:

using Newtonsoft.Json;

namespace todo
{
    public class Family
    {
        [JsonProperty(PropertyName = "id")]
        public string Id { get; set; }
        public string LastName { get; set; }
        public Parent[] Parents { get; set; }
        public Child[] Children { get; set; }
        public Address Address { get; set; }
        public bool IsRegistered { get; set; }
        // The ToString() method is used to format the output, it's used for demo purpose only. It's not required by Azure Cosmos DB
        public override string ToString()
        {
            return JsonConvert.SerializeObject(this);
        }
    }

    public class Parent
    {
        public string FamilyName { get; set; }
        public string FirstName { get; set; }
    }

    public class Child
    {
        public string FamilyName { get; set; }
        public string FirstName { get; set; }
        public string Gender { get; set; }
        public int Grade { get; set; }
        public Pet[] Pets { get; set; }
    }

    public class Pet
    {
        public string GivenName { get; set; }
    }

    public class Address
    {
        public string State { get; set; }
        public string County { get; set; }
        public string City { get; set; }
    }
}

Adicione as diretivas de utilização & definir o objeto clienteAdd the using directives & define the client object

A partir do diretório do projeto, abra o Program.cs ficheiro no seu editor e adicione as seguintes diretivas no topo da sua aplicação:From the project directory, open the Program.cs file in your editor and add the following using directives at the top of your application:


using System;
using System.Threading.Tasks;
using System.Configuration;
using System.Collections.Generic;
using System.Net;
using Microsoft.Azure.Cosmos;

Ao Program.cs ficheiro, adicione código para ler as variáveis ambientais que definiu no passo anterior.To the Program.cs file, add code to read the environment variables that you have set in the previous step. Defina CosmosClient Database o, e os Container objetos.Define the CosmosClient, Database, and the Container objects. Em seguida, adicione código ao método principal que chama o GetStartedDemoAsync método onde gere os recursos da conta Azure Cosmos.Next add code to the main method that calls the GetStartedDemoAsync method where you manage Azure Cosmos account resources.

namespace todo
{
public class Program
{

    /// The Azure Cosmos DB endpoint for running this GetStarted sample.
    private string EndpointUrl = Environment.GetEnvironmentVariable("EndpointUrl");

    /// The primary key for the Azure DocumentDB account.
    private string PrimaryKey = Environment.GetEnvironmentVariable("PrimaryKey");

    // The Cosmos client instance
    private CosmosClient cosmosClient;

    // The database we will create
    private Database database;

    // The container we will create.
    private Container container;

    // The name of the database and container we will create
    private string databaseId = "FamilyDatabase";
    private string containerId = "FamilyContainer";

    public static async Task Main(string[] args)
    {
       try
       {
           Console.WriteLine("Beginning operations...\n");
           Program p = new Program();
           await p.GetStartedDemoAsync();

        }
        catch (CosmosException de)
        {
           Exception baseException = de.GetBaseException();
           Console.WriteLine("{0} error occurred: {1}", de.StatusCode, de);
        }
        catch (Exception e)
        {
            Console.WriteLine("Error: {0}", e);
        }
        finally
        {
            Console.WriteLine("End of demo, press any key to exit.");
            Console.ReadKey();
        }
    }
}
}

Criar uma base de dadosCreate a database

Defina o CreateDatabaseAsync método dentro da program.cs classe.Define the CreateDatabaseAsync method within the program.cs class. Este método cria o FamilyDatabase se já não existe.This method creates the FamilyDatabase if it doesn't already exist.

private async Task CreateDatabaseAsync()
{
    // Create a new database
    this.database = await this.cosmosClient.CreateDatabaseIfNotExistsAsync(databaseId);
    Console.WriteLine("Created Database: {0}\n", this.database.Id);
}

Criar um contentorCreate a container

Defina o CreateContainerAsync método dentro da program.cs classe.Define the CreateContainerAsync method within the program.cs class. Este método cria o FamilyContainer se já não existe.This method creates the FamilyContainer if it doesn't already exist.

/// Create the container if it does not exist. 
/// Specifiy "/LastName" as the partition key since we're storing family information, to ensure good distribution of requests and storage.
private async Task CreateContainerAsync()
{
    // Create a new container
    this.container = await this.database.CreateContainerIfNotExistsAsync(containerId, "/LastName");
    Console.WriteLine("Created Container: {0}\n", this.container.Id);
}

Criar um itemCreate an item

Crie um item familiar adicionando o AddItemsToContainerAsync método com o seguinte código.Create a family item by adding the AddItemsToContainerAsync method with the following code. Pode utilizar os CreateItemAsync métodos ou UpsertItemAsync métodos para criar um item:You can use the CreateItemAsync or UpsertItemAsync methods to create an item:

private async Task AddItemsToContainerAsync()
{
    // Create a family object for the Andersen family
    Family andersenFamily = new Family
    {
        Id = "Andersen.1",
        LastName = "Andersen",
        Parents = new Parent[]
        {
           new Parent { FirstName = "Thomas" },
           new Parent { FirstName = "Mary Kay" }
        },
        Children = new Child[]
        {
           new Child
            {
                FirstName = "Henriette Thaulow",
                Gender = "female",
                Grade = 5,
                Pets = new Pet[]
                {
                    new Pet { GivenName = "Fluffy" }
                }
            }
        },
        Address = new Address { State = "WA", County = "King", City = "Seattle" },
        IsRegistered = false
    };

    try
    {
        // Create an item in the container representing the Andersen family. Note we provide the value of the partition key for this item, which is "Andersen".
        ItemResponse<Family> andersenFamilyResponse = await this.container.CreateItemAsync<Family>(andersenFamily, new PartitionKey(andersenFamily.LastName));
        // Note that after creating the item, we can access the body of the item with the Resource property of the ItemResponse. We can also access the RequestCharge property to see the amount of RUs consumed on this request.
        Console.WriteLine("Created item in database with id: {0} Operation consumed {1} RUs.\n", andersenFamilyResponse.Resource.Id, andersenFamilyResponse.RequestCharge);
    }
    catch (CosmosException ex) when (ex.StatusCode == HttpStatusCode.Conflict)
    {
        Console.WriteLine("Item in database with id: {0} already exists\n", andersenFamily.Id);                
    }
}

Consultar os itensQuery the items

Depois de inserir um item, você pode executar uma consulta para obter os detalhes da família "Andersen".After inserting an item, you can run a query to get the details of "Andersen" family. O código que se segue mostra como executar a consulta utilizando a consulta SQL diretamente.The following code shows how to execute the query using the SQL query directly. A consulta do SQL para obter os detalhes da família "Anderson" é: SELECT * FROM c WHERE c.LastName = 'Andersen' .The SQL query to get the "Anderson" family details is: SELECT * FROM c WHERE c.LastName = 'Andersen'. Defina o QueryItemsAsync método dentro da classe e program.cs adicione-lhe o seguinte código:Define the QueryItemsAsync method within the program.cs class and add the following code to it:

private async Task QueryItemsAsync()
{
    var sqlQueryText = "SELECT * FROM c WHERE c.LastName = 'Andersen'";

    Console.WriteLine("Running query: {0}\n", sqlQueryText);

    QueryDefinition queryDefinition = new QueryDefinition(sqlQueryText);
    FeedIterator<Family> queryResultSetIterator = this.container.GetItemQueryIterator<Family>(queryDefinition);

    List<Family> families = new List<Family>();

    while (queryResultSetIterator.HasMoreResults)
    {
        FeedResponse<Family> currentResultSet = await queryResultSetIterator.ReadNextAsync();
        foreach (Family family in currentResultSet)
        {
            families.Add(family);
            Console.WriteLine("\tRead {0}\n", family);
        }
    }
}

Eliminar a base de dadosDelete the database

Finalmente pode eliminar a base de dados adicionando o DeleteDatabaseAndCleanupAsync método com o seguinte código:Finally you can delete the database adding the DeleteDatabaseAndCleanupAsync method with the following code:

private async Task DeleteDatabaseAndCleanupAsync()
{
   DatabaseResponse databaseResourceResponse = await this.database.DeleteAsync();
   // Also valid: await this.cosmosClient.Databases["FamilyDatabase"].DeleteAsync();

   Console.WriteLine("Deleted Database: {0}\n", this.databaseId);

   //Dispose of CosmosClient
    this.cosmosClient.Dispose();
}

Executar as operações CRUDExecute the CRUD operations

Depois de definir todos os métodos necessários, execute-os com o GetStartedDemoAsync método.After you have defined all the required methods, execute them with in the GetStartedDemoAsync method. O DeleteDatabaseAndCleanupAsync método comentado neste código porque não verá quaisquer recursos se esse método for executado.The DeleteDatabaseAndCleanupAsync method commented out in this code because you will not see any resources if that method is executed. Pode descomprê-lo depois de validar que os seus recursos DB Azure Cosmos foram criados no portal Azure.You can uncomment it after validating that your Azure Cosmos DB resources were created in the Azure portal.

public async Task GetStartedDemoAsync()
{
    // Create a new instance of the Cosmos Client
    this.cosmosClient = new CosmosClient(EndpointUrl, PrimaryKey);
    await this.CreateDatabaseAsync();
    await this.CreateContainerAsync();
    await this.AddItemsToContainerAsync();
    await this.QueryItemsAsync();
}

Depois de adicionar todos os métodos necessários, guarde o Program.cs ficheiro.After you add all the required methods, save the Program.cs file.

Executar o códigoRun the code

Em seguida, construa e execute a aplicação para criar os recursos DB Azure Cosmos.Next build and run the application to create the Azure Cosmos DB resources. Certifique-se de abrir uma nova janela de pedido de comando, não utilize a mesma instância que usou para definir as variáveis ambientais.Make sure to open a new command prompt window, don't use the same instance that you have used to set the environment variables. Porque as variáveis ambientais não estão definidas na janela aberta atual.Because the environment variables are not set in the current open window. Terá de abrir um novo pedido de comando para ver as atualizações.You will need to open a new command prompt to see the updates.

dotnet build
dotnet run

A seguinte saída é gerada quando executar a aplicação.The following output is generated when you run the application. Também pode entrar no portal Azure e validar que os recursos são criados:You can also sign into the Azure portal and validate that the resources are created:

Created Database: FamilyDatabase

Created Container: FamilyContainer

Created item in database with id: Andersen.1 Operation consumed 11.62 RUs.

Running query: SELECT * FROM c WHERE c.LastName = 'Andersen'

        Read {"id":"Andersen.1","LastName":"Andersen","Parents":[{"FamilyName":null,"FirstName":"Thomas"},{"FamilyName":null,"FirstName":"Mary Kay"}],"Children":[{"FamilyName":null,"FirstName":"Henriette Thaulow","Gender":"female","Grade":5,"Pets":[{"GivenName":"Fluffy"}]}],"Address":{"State":"WA","County":"King","City":"Seattle"},"IsRegistered":false}

End of demo, press any key to exit.

Pode validar que os dados são criados assinando no portal Azure e ver os itens necessários na sua conta Azure Cosmos.You can validate that the data is created by signing into the Azure portal and see the required items in your Azure Cosmos account.

Limpar os recursosClean up resources

Quando já não é necessário, pode utilizar o Azure CLI ou o Azure PowerShell para remover a conta Azure Cosmos e o grupo de recursos correspondente.When no longer needed, you can use the Azure CLI or Azure PowerShell to remove the Azure Cosmos account and the corresponding resource group. O seguinte comando mostra como eliminar o grupo de recursos utilizando o Azure CLI:The following command shows how to delete the resource group by using the Azure CLI:

az group delete -g "myResourceGroup"

Passos seguintesNext steps

Neste quickstart, aprendeu a criar uma conta Azure Cosmos, criar uma base de dados e um contentor utilizando uma aplicação .NET Core.In this quickstart, you learned how to create an Azure Cosmos account, create a database and a container using a .NET Core app. Pode agora importar dados adicionais para a sua conta Azure Cosmos com as instruções int o seguinte artigo.You can now import additional data to your Azure Cosmos account with the instructions int the following article.

Import data into Azure Cosmos DB (Importar dados para o Azure Cosmos DB).Import data into Azure Cosmos DB