Inicio rápido: Compilar una aplicación de consola .NET para administrar recursos de API de SQL de Azure Cosmos DBQuickstart: Build a .NET console app to manage Azure Cosmos DB SQL API resources

Introducción a la biblioteca cliente de API de SQL de Azure Cosmos DB para .NET.Get started with the Azure Cosmos DB SQL API client library for .NET. Siga los pasos de este documento para instalar el paquete .NET, compilar una aplicación y probar el código de ejemplo para las operaciones CRUD básicas en los datos almacenados en 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.

Azure Cosmos DB es un servicio de base de datos con varios modelos y de distribución global de Microsoft.Azure Cosmos DB is Microsoft’s globally distributed multi-model database service. Puede usar Azure Cosmos DB para crear y consultar rápidamente las bases de datos de gráficos, documentos, claves y valores.You can use Azure Cosmos DB to quickly create and query key/value, document, and graph databases. Use la biblioteca cliente de API de SQL de Azure Cosmos DB para .NET para:Use the Azure Cosmos DB SQL API client library for .NET to:

  • Crear una base de datos y un contenedor de Azure CosmosCreate an Azure Cosmos database and a container
  • Agregar datos de ejemplo al contenedorAdd sample data to the container
  • Consulta de los datosQuery the data
  • Eliminación de la base de datosDelete the database

Documentación de referencia de la API | Código fuente de la biblioteca | Paquete (NuGet)API reference documentation | Library source code | Package (NuGet)

Requisitos previosPrerequisites

InstalaciónSetting up

En esta sección se le guía por el proceso de creación de una cuenta de Azure Cosmos y de configuración de un proyecto que usa una biblioteca cliente de API de SQL de Azure Cosmos DB para .NET para administrar 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. El código de ejemplo descrito en este artículo crea una base de datos de FamilyDatabase y miembros de la familia (cada miembro de la familia es un elemento) en la base de datos.The example code described in this article creates a FamilyDatabase database and family members (each family member is an item) within that database. Cada miembro de la familia tiene propiedades como Id, FamilyName, FirstName, LastName, Parents, Children, Address,.Each family member has properties such as Id, FamilyName, FirstName, LastName, Parents, Children, Address,. La propiedad LastName se usa como clave de partición para el contenedor.The LastName property is used as the partition key for the container.

Crear una cuenta de Azure CosmosCreate an Azure Cosmos account

Si usa la opción Prueba gratuita del emulador de Azure Cosmos DB para crear una cuenta de Azure Cosmos, debe crear una cuenta de Azure Cosmos DB del tipo de 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. Ya se ha creado una cuenta de prueba de Azure Cosmos DB.An Azure Cosmos DB test account is already created for you. No tiene que crear la cuenta explícitamente, por lo que puede omitir esta sección y pasar a la siguiente.You don't have to create the account explicitly, so you can skip this section and move to the next section.

Si tiene su propia suscripción de Azure o creó una suscripción gratuita, debe crear una cuenta de Azure Cosmos explícitamente.If you have your own Azure subscription or created a subscription for free, you should create an Azure Cosmos account explicitly. El código siguiente creará una cuenta de Azure Cosmos con coherencia de sesión.The following code will create an Azure Cosmos account with session consistency. La cuenta se replica en South Central US y North Central US.The account is replicated in South Central US and North Central US.

Puede usar Azure Cloud Shell para crear la cuenta de Azure Cosmos.You can use Azure Cloud Shell to create the Azure Cosmos account. Azure Cloud Shell es un shell interactivo, autenticado y al que se puede acceder desde un explorador para administrar recursos de Azure.Azure Cloud Shell is an interactive, authenticated, browser-accessible shell for managing Azure resources. Ofrece la flexibilidad de poder elegir la experiencia de shell que mejor se adapte a la forma de trabajar de cada uno, Bash o PowerShell.It provides the flexibility of choosing the shell experience that best suits the way you work, either Bash or PowerShell. En esta guía de inicio rápido, elija el modo Bash.For this quickstart, choose Bash mode. Azure Cloud Shell también requiere una cuenta de almacenamiento; puede crear una cuando se le solicite.Azure Cloud Shell also requires a storage account, you can create one when prompted.

Seleccione el botón Pruébelo junto al siguiente código, elija el modo Bash, seleccione Crear una cuenta de almacenamiento e inicie sesión en 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. Después, copie y pegue el código siguiente en Azure Cloud Shell y ejecútelo.Next copy and paste the following code to Azure cloud shell and run it. El nombre de la cuenta de Azure Cosmos debe ser único globalmente; asegúrese de actualizar el valor de mysqlapicosmosdb antes de ejecutar el 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

La creación de la cuenta de Azure Cosmos tarda un rato;, una vez que la operación se realiza correctamente, puede ver la salida de confirmación.The creation of the Azure Cosmos account takes a while, once the operation is successful, you can see the confirmation output. Una vez que el comando se complete correctamente, inicie sesión en Azure Portal y compruebe que existe la cuenta de Azure Cosmos con el nombre especificado.After the command completes successfully, sign into the Azure portal and verify that the Azure Cosmos account with the specified name exists. Puede cerrar la ventana de Azure Cloud Shell una vez creado el recurso.You can close the Azure Cloud Shell window after the resource is created.

Crear una nueva aplicación .NETCreate a new .NET app

Cree una nueva aplicación .NET en el IDE o editor que prefiera.Create a new .NET application in your preferred editor or IDE. Abra el símbolo del sistema de Windows o una ventana de Terminal desde el equipo local.Open the Windows command prompt or a Terminal window from your local computer. Ejecutará todos los comandos de las secciones siguientes desde el símbolo del sistema o desde el terminal.You will run all the commands in the next sections from the command prompt or terminal. Ejecute el comando dotnet new para crear una nueva aplicación llamada todo.Run the following dotnet new command to create a new app with the name todo. El parámetro --langVersion establece la propiedad LangVersion en el archivo de proyecto creado.The --langVersion parameter sets the LangVersion property in the created project file.

dotnet new console --langVersion 7.1 -n todo

Cambie el directorio a la carpeta de aplicaciones recién creada.Change your directory to the newly created app folder. Para compilar la aplicación:You can build the application with:

cd todo
dotnet build

El resultado esperado de la compilación debe parecerse a lo siguiente: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

Instalar el paquete de Azure Cosmos DBInstall the Azure Cosmos DB package

Mientras sigue en el directorio de aplicaciones, instale el paquete de la biblioteca cliente de Azure Cosmos DB para .NET Core con el comando dotnet add package.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

Copiar las credenciales de la cuenta de Azure Cosmos desde Azure PortalCopy your Azure Cosmos account credentials from the Azure portal

La aplicación de ejemplo debe autenticarse para la cuenta de Azure Cosmos.The sample application needs to authenticate to your Azure Cosmos account. Para realizar la autenticación, debe pasar las credenciales de cuenta de Azure Cosmos a la aplicación.To authenticate, you should pass the Azure Cosmos account credentials to the application. Para obtener las credenciales de cuenta de Azure Cosmos, siga estos pasos:Get your Azure Cosmos account credentials by following these steps:

  1. Inicie sesión en el Azure Portal.Sign in to the Azure portal.

  2. Vaya a la cuenta de Azure Cosmos.Navigate to your Azure Cosmos account.

  3. Abra el panel Claves y copia el URI y la CLAVE PRINCIPAL de la cuenta.Open the Keys pane and copy the URI and PRIMARY KEY of your account. En el paso siguiente, agregará los valores de URI y claves a una variable de entorno.You will add the URI and keys values to an environment variable in the next step.

Establecer las variables de entornoSet the environment variables

Una vez que haya copiado el URI y la CLAVE PRINCIPAL de la cuenta, guárdelos en una variable de entorno nueva en la máquina local que ejecuta la aplicación.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 establecer la variable de entorno, abra una ventana de consola y ejecute el siguiente comando.To set the environment variable, open a console window, and run the following command. Asegúrese de reemplazar los valores <Your_Azure_Cosmos_account_URI> y <Your_Azure_Cosmos_account_PRIMARY_KEY>.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 objetosObject model

Antes de empezar a compilar la aplicación, consulte la jerarquía de recursos de Azure Cosmos DB y el modelo de objetos usado para crear estos recursos y obtener acceso a ellos.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. Azure Cosmos DB crea recursos en el orden siguiente:The Azure Cosmos DB creates resources in the following order:

  • Cuenta de Azure CosmosAzure Cosmos account
  • Bases de datosDatabases
  • ContenedoresContainers
  • ElementosItems

Para obtener más información acerca de la jerarquía de diferentes entidades, consulte el artículo sobre cómo trabajar con bases de datos, contenedores y elementos en 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. Usará las siguientes clases de .NET para interactuar con estos recursos:You will use the following .NET classes to interact with these resources:

  • CosmosClient: esta clase proporciona una representación lógica del lado cliente para el servicio Azure Cosmos DB.CosmosClient - This class provides a client-side logical representation for the Azure Cosmos DB service. El objeto de cliente se usa para configurar y ejecutar solicitudes en el servicio.The client object is used to configure and execute requests against the service.

  • CreateDatabaseIfNotExistsAsync: este método crea (si no existe) u obtiene (si ya existe) un recurso de base de datos como operación asincrónica.CreateDatabaseIfNotExistsAsync - This method creates (if doesn't exist) or gets (if already exists) a database resource as an asynchronous operation.

  • CreateContainerIfNotExistsAsync: este método crea (si no existe) u obtiene (si ya existe) un contenedor como operación asincrónica.CreateContainerIfNotExistsAsync- - This method creates (if it doesn't exist) or gets (if it already exists) a container as an asynchronous operation. Puede comprobar el código de estado de la respuesta para determinar si el contenedor se creó recientemente (201) o si se devolvió un contenedor 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 crea un elemento en el contenedor.CreateItemAsync - This method creates an item within the container.

  • UpsertItemAsync: este método crea un elemento en el contenedor si aún no existe o lo reemplaza si ya existe.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 crea una consulta para los elementos de un contenedor en una base de datos de Azure Cosmos mediante una instrucción SQL con valores con parámetros.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 la base de datos especificada de la cuenta de Azure Cosmos.DeleteAsync - Deletes the specified database from your Azure Cosmos account. El método DeleteAsync solo elimina la base de datos.DeleteAsync method only deletes the database. La eliminación de la instancia Cosmosclient debe producirse por separado (lo que ocurre en el método DeleteDatabaseAndCleanupAsync).Disposing of the Cosmosclient instance should happen separately (which it does in the DeleteDatabaseAndCleanupAsync method.

Ejemplos de códigoCode examples

En el código de ejemplo que se describe en este artículo, se crea una base de datos de familia en Azure Cosmos DB.The sample code described in this article creates a family database in Azure Cosmos DB. La base de datos de la familia contiene detalles de la familia como el nombre, la dirección, la ubicación, los padres, los hijos y las mascotas.The family database contains family details such as name, address, location, the associated parents, children, and pets. Antes de rellenar los datos en su cuenta de Azure Cosmos, defina las propiedades de un elemento de familia.Before populating the data to your Azure Cosmos account, define the properties of a family item. Cree una nueva clase denominada Family.cs en el nivel raíz de la aplicación de ejemplo y agréguele el código siguiente: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; }
    }
}

Agregar las directivas de uso y definir el objeto de clienteAdd the using directives & define the client object

Desde el directorio del proyecto, abra el archivo Program.cs en el editor y agregue lo siguiente con directivas en la parte superior de la aplicación: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;

Para el archivo Program.cs, agregue código para leer las variables de entorno que ha establecido en el paso anterior.To the Program.cs file, add code to read the environment variables that you have set in the previous step. Defina los objetos CosmosClient, Database, y Container.Define the CosmosClient, Database, and the Container objects. A continuación, agregue código al método principal que llama al método GetStartedDemoAsync en el que administra los recursos de cuenta de 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();
        }
    }
}
}

Crear una base de datosCreate a database

Defina el método CreateDatabaseAsync dentro de la clase program.cs.Define the CreateDatabaseAsync method within the program.cs class. Este método crea FamilyDatabase si todavía no 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);
}

Crear un contenedorCreate a container

Defina el método CreateContainerAsync dentro de la clase program.cs.Define the CreateContainerAsync method within the program.cs class. Este método crea FamilyContainer si todavía no 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);
}

Crear un elementoCreate an item

Para crear un elemento de familia, agregue el método AddItemsToContainerAsync con el código siguiente.Create a family item by adding the AddItemsToContainerAsync method with the following code. Puede usar los métodos CreateItemAsync o UpsertItemAsync para crear un elemento: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 elementosQuery the items

Después de insertar un elemento, puede ejecutar una consulta para obtener los detalles de la familia "Andersen".After inserting an item, you can run a query to get the details of "Andersen" family. En el código siguiente se muestra cómo ejecutar la consulta directamente con la consulta SQL.The following code shows how to execute the query using the SQL query directly. La consulta SQL para obtener los detalles de la familia "Anderson" es: 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 el método QueryItemsAsync en la clase program.cs y agréguele el código siguiente: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);
        }
    }
}

Eliminación de la base de datosDelete the database

Por último, para eliminar la base de datos, agregue el método DeleteDatabaseAndCleanupAsync con el código siguiente: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();
}

Ejecutar operaciones CRUDExecute the CRUD operations

Después de definir todos los métodos necesarios, ejecútelos en el método GetStartedDemoAsync.After you have defined all the required methods, execute them with in the GetStartedDemoAsync method. El método DeleteDatabaseAndCleanupAsync se marcó como comentado en este código porque no verá ningún recurso si se ejecuta ese método.The DeleteDatabaseAndCleanupAsync method commented out in this code because you will not see any resources if that method is executed. Puede quitar la marca de comentario después de validar que los recursos de Azure Cosmos DB se crearon en Azure Portal.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();
}

Después de agregar todos los métodos necesarios, guarde el archivo Program.cs.After you add all the required methods, save the Program.cs file.

Ejecución del códigoRun the code

A continuación, compile y ejecute la aplicación para crear los recursos de Azure Cosmos DB.Next build and run the application to create the Azure Cosmos DB resources. Asegúrese de abrir una nueva ventana del símbolo del sistema, no use la misma instancia que ha usado para establecer las variables de entorno.Make sure to open a new command prompt window, don't use the same instance that you have used to set the environment variables. Puesto que las variables de entorno no se establecen en la ventana abierta actual.Because the environment variables are not set in the current open window. Tendrá que abrir un nuevo símbolo del sistema para ver las actualizaciones.You will need to open a new command prompt to see the updates.

dotnet build
dotnet run

Al ejecutar la aplicación, se genera el siguiente resultado.The following output is generated when you run the application. También puede iniciar sesión en Azure Portal y validar la creación de los recursos: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.

Para validar la creación de los datos, inicie sesión en Azure Portal y vea los elementos necesarios en su cuenta de 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.

Limpieza de recursosClean up resources

Cuando ya no lo necesite, puede usar el CLI de Azure o Azure PowerShell para quitar la cuenta de Azure Cosmos y el grupo de recursos correspondiente.When no longer needed, you can use the Azure CLI or Azure PowerShell to remove the Azure Cosmos account and the corresponding resource group. El siguiente comando muestra cómo eliminar el grupo de recursos con el CLI de Azure:The following command shows how to delete the resource group by using the Azure CLI:

az group delete -g "myResourceGroup"

Pasos siguientesNext steps

En este inicio rápido, ha creado una base de datos y un contenedor en Azure Portal, y agregado datos de ejemplo mediante el ejemplo de .NET.In this quickstart, you learned how to create an Azure Cosmos account, create a database and a container using a .NET Core app. Ahora puede importar datos adicionales a su cuenta de Azure Cosmos con las instrucciones del siguiente artículo.You can now import additional data to your Azure Cosmos account with the instructions int the following article.