Démarrage rapide : Générer une application console .NET pour gérer les ressources de l’API SQL Azure Cosmos DBQuickstart: Build a .NET console app to manage Azure Cosmos DB SQL API resources

Commencez à utiliser la bibliothèque de client de l’API SQL Azure Cosmos DB pour .NET.Get started with the Azure Cosmos DB SQL API client library for .NET. Suivez les étapes décrites dans ce document pour installer le package .NET, générer une application et essayer l’exemple de code pour les opérations CRUD de base sur les données stockées dans 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 est le service de base de données multi-modèle de Microsoft distribué à l’échelle mondiale.Azure Cosmos DB is Microsoft’s globally distributed multi-model database service. Vous pouvez utiliser Azure Cosmos DB pour créer et interroger rapidement des bases de données de clés/valeurs, de documents et de graphiques.You can use Azure Cosmos DB to quickly create and query key/value, document, and graph databases. Utilisez la bibliothèque de client de l’API SQL Azure Cosmos DB pour .NET afin d’effectuer les opérations suivantes :Use the Azure Cosmos DB SQL API client library for .NET to:

  • Créer une base de données et un conteneur Azure CosmosCreate an Azure Cosmos database and a container
  • Ajouter des exemples de données au conteneurAdd sample data to the container
  • Interroger les donnéesQuery the data
  • Supprimer la base de donnéesDelete the database

Documentation de référence sur l’API | Code source de la bibliothèque | Package (NuGet)API reference documentation | Library source code | Package (NuGet)

PrérequisPrerequisites

ConfigurationSetting up

Cette section vous guide dans la création d’un compte Azure Cosmos et la configuration d’un projet qui utilise la bibliothèque de client de l’API SQL Azure Cosmos DB pour .NET afin de gérer les ressources.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. L’exemple de code décrit dans cet article crée une base de données FamilyDatabase et des membres de la famille (chacun d’eux est un élément) au sein de cette base de données.The example code described in this article creates a FamilyDatabase database and family members (each family member is an item) within that database. Chaque membre de la famille possède des propriétés telles que Id, FamilyName, FirstName, LastName, Parents, Children, Address,.Each family member has properties such as Id, FamilyName, FirstName, LastName, Parents, Children, Address,. La propriété LastName est utilisée en tant que clé de partition pour le conteneur.The LastName property is used as the partition key for the container.

Créer un compte Azure CosmosCreate an Azure Cosmos account

Si vous utilisez l’option Essayer gratuitement Azure Cosmos DB pour créer un compte Azure Cosmos, vous devez créer un compte Azure Cosmos DB de type API SQL.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. Un compte de test Azure Cosmos DB est déjà créé pour vous.An Azure Cosmos DB test account is already created for you. Vous n’avez pas besoin de créer le compte explicitement. Vous pouvez donc ignorer cette section et passer à la section suivante.You don't have to create the account explicitly, so you can skip this section and move to the next section.

Si vous disposez de votre propre abonnement Azure ou si vous avez créé un abonnement gratuitement, vous devez créer un compte Azure Cosmos de manière explicite.If you have your own Azure subscription or created a subscription for free, you should create an Azure Cosmos account explicitly. Le code suivant crée un compte Azure Cosmos avec une cohérence de session.The following code will create an Azure Cosmos account with session consistency. Le compte est répliqué dans South Central US et North Central US.The account is replicated in South Central US and North Central US.

Vous pouvez utiliser Azure Cloud Shell pour créer le compte Azure Cosmos.You can use Azure Cloud Shell to create the Azure Cosmos account. Azure Cloud Shell est un interpréteur de commandes interactif, authentifié et accessible par navigateur qui permet de gérer les ressources Azure.Azure Cloud Shell is an interactive, authenticated, browser-accessible shell for managing Azure resources. Il vous donne la possibilité de choisir l'expérience d'interpréteur de commandes la plus adaptée à votre façon de travailler, qu'il s'agisse de Bash ou de PowerShell.It provides the flexibility of choosing the shell experience that best suits the way you work, either Bash or PowerShell. Pour ce guide de démarrage rapide, choisissez le mode Bash.For this quickstart, choose Bash mode. Azure Cloud Shell nécessite également un compte de stockage. Vous pouvez en créer un quand vous y êtes invité.Azure Cloud Shell also requires a storage account, you can create one when prompted.

Sélectionnez le bouton Essayer en regard du code suivant, choisissez le mode Bash, sélectionnez Créer un compte de stockage, puis connectez-vous à 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. Ensuite, copiez et collez le code suivant dans Azure Cloud Shell, puis exécutez-le.Next copy and paste the following code to Azure cloud shell and run it. Le nom du compte Azure Cosmos doit être globalement unique. Veillez à mettre à jour la valeur mysqlapicosmosdb avant d’exécuter la commande.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 création du compte Azure Cosmos prend un certain temps. Une fois l’opération réussie, la sortie de confirmation s’affiche.The creation of the Azure Cosmos account takes a while, once the operation is successful, you can see the confirmation output. Une fois la commande correctement exécutée, connectez-vous au portail Azure et vérifiez que le compte Azure Cosmos portant le nom spécifié existe.After the command completes successfully, sign into the Azure portal and verify that the Azure Cosmos account with the specified name exists. Vous pouvez fermer la fenêtre Azure Cloud Shell une fois la ressource créée.You can close the Azure Cloud Shell window after the resource is created.

Créer une application .NETCreate a new .NET app

Créez une application .NET dans votre éditeur ou IDE favori.Create a new .NET application in your preferred editor or IDE. Ouvrez l’invite de commandes Windows ou une fenêtre de terminal à partir de votre ordinateur local.Open the Windows command prompt or a Terminal window from your local computer. Vous allez exécuter toutes les commandes des sections suivantes à partir de l’invite de commandes ou du terminal.You will run all the commands in the next sections from the command prompt or terminal. Exécutez la commande dotnet new suivante pour créer une application nommée todo.Run the following dotnet new command to create a new app with the name todo. Le paramètre --langVersion définit la propriété LangVersion dans le fichier projet créé.The --langVersion parameter sets the LangVersion property in the created project file.

dotnet new console --langVersion 7.1 -n todo

Déplacez vos répertoires vers le dossier d’application nouvellement créé.Change your directory to the newly created app folder. Vous pouvez générer l’application avec :You can build the application with:

cd todo
dotnet build

La sortie attendue de la build doit ressembler à ceci :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

Installer le package Azure Cosmos DBInstall the Azure Cosmos DB package

Tout en restant dans le répertoire de l’application, installez la bibliothèque de client Azure Cosmos DB pour .NET Core à l’aide de la commande 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

Copiez les informations d’identification de votre compte Azure Cosmos à partir du portail AzureCopy your Azure Cosmos account credentials from the Azure portal

L’exemple d’application doit s’authentifier auprès de votre compte Azure Cosmos.The sample application needs to authenticate to your Azure Cosmos account. Pour vous authentifier, vous devez transmettre les informations d’identification du compte Azure Cosmos à l’application.To authenticate, you should pass the Azure Cosmos account credentials to the application. Pour obtenir les informations d’identification de votre compte Azure Cosmos, procédez comme suit :Get your Azure Cosmos account credentials by following these steps:

  1. Connectez-vous au Portail Azure.Sign in to the Azure portal.

  2. Accédez à votre compte Azure Cosmos.Navigate to your Azure Cosmos account.

  3. Ouvrez le volet Clés et copiez l’URI et la CLÉ PRIMAIRE de votre compte.Open the Keys pane and copy the URI and PRIMARY KEY of your account. Vous allez ajouter les valeur d’URI et de clés à une variable d’environnement à l’étape suivante.You will add the URI and keys values to an environment variable in the next step.

Définir les variables d’environnementSet the environment variables

Après avoir copié l’URI et la CLÉ PRIMAIRE de votre compte, enregistrez-les dans une nouvelle variable d’environnement sur la machine locale exécutant l’application.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. Pour définir la variable d’environnement, ouvrez une fenêtre de console, puis exécutez la commande suivante.To set the environment variable, open a console window, and run the following command. Veillez à remplacer les valeurs <Your_Azure_Cosmos_account_URI> et <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>"

Modèle objetObject model

Avant de commencer à générer l’application, examinons la hiérarchie des ressources dans Azure Cosmos DB et le modèle objet utilisé pour créer ces ressources et y accéder.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 crée des ressources dans l’ordre suivant :The Azure Cosmos DB creates resources in the following order:

  • Compte Azure CosmosAzure Cosmos account
  • Bases de donnéesDatabases
  • ContainersContainers
  • ÉlémentsItems

Pour en savoir plus sur la hiérarchie des différentes entités, voir Utilisation de bases de données, conteneurs et éléments dans 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. Vous allez utiliser les classes .NET suivantes pour interagir avec ces ressources :You will use the following .NET classes to interact with these resources:

  • CosmosClient : cette classe fournit une représentation logique côté client pour le service Azure Cosmos DB.CosmosClient - This class provides a client-side logical representation for the Azure Cosmos DB service. Ce client est utilisé pour configurer et exécuter des requêtes sur le service.The client object is used to configure and execute requests against the service.

  • CreateDatabaseIfNotExistsAsync : cette méthode obtient ou, si nécessaire, crée une ressource de base de données en tant qu’opération asynchrone.CreateDatabaseIfNotExistsAsync - This method creates (if doesn't exist) or gets (if already exists) a database resource as an asynchronous operation.

  • CreateContainerIfNotExistsAsync : cette méthode obtient ou, si nécessaire, crée un conteneur en tant qu’opération asynchrone.CreateContainerIfNotExistsAsync- - This method creates (if it doesn't exist) or gets (if it already exists) a container as an asynchronous operation. Vous pouvez vérifier le code d’état de la réponse pour déterminer si le conteneur vient d’être créé (201) ou si un conteneur existant a été retourné (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 : cette méthode crée un élément dans le conteneur.CreateItemAsync - This method creates an item within the container.

  • UpsertItemAsync : cette méthode crée un élément dans le conteneur s’il n’existe pas déjà ou remplace l’élément s’il existe déjà.UpsertItemAsync - This method creates an item within the container if it doesn't already exist or replaces the item if it already exists.

  • GetItemQueryIterator : cette méthode crée une requête pour les éléments sous un conteneur dans une base de données Azure Cosmos à l’aide d’une instruction SQL avec des valeurs paramétrables.GetItemQueryIterator - This method creates a query for items under a container in an Azure Cosmos database using a SQL statement with parameterized values.

  • DeleteAsync : supprime la base de données spécifiée de votre compte Azure Cosmos.DeleteAsync - Deletes the specified database from your Azure Cosmos account. Le méthode DeleteAsync supprime uniquement les base de données.DeleteAsync method only deletes the database. La suppression de l’instance Cosmosclient doit se produire séparément (ce qu’elle fait dans la méthode DeleteDatabaseAndCleanupAsync.Disposing of the Cosmosclient instance should happen separately (which it does in the DeleteDatabaseAndCleanupAsync method.

Exemples de codesCode examples

L’exemple de code décrit dans cet article crée une base de données de famille dans Azure Cosmos DB.The sample code described in this article creates a family database in Azure Cosmos DB. La base de données de famille contient des détails sur la famille, tels que le nom, l’adresse, l’emplacement, ainsi que les parents, enfants et animaux associés.The family database contains family details such as name, address, location, the associated parents, children, and pets. Avant de renseigner les données dans votre compte Azure Cosmos, définissez les propriétés d’un élément de famille.Before populating the data to your Azure Cosmos account, define the properties of a family item. Créez une classe nommée Family.cs au niveau racine de votre exemple d’application, puis ajoutez-y le code suivant :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; }
    }
}

Ajoutez les directives d’utilisation et définir l’objet clientAdd the using directives & define the client object

Dans le répertoire du projet, ouvrez le fichier Program.cs dans votre éditeur et ajoutez les directives d’utilisation suivantes en haut de votre application :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;

Pour le fichier Program.cs, ajoutez du code pour lire les variables d’environnement que vous avez définies à l’étape précédente.To the Program.cs file, add code to read the environment variables that you have set in the previous step. Définissez les valeurs CosmosClient, Database et les objets Container.Define the CosmosClient, Database, and the Container objects. Ensuite, ajoutez du code à la méthode principale qui appelle la méthode GetStartedDemoAsync dans laquelle vous gérez les ressources de compte 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();
        }
    }
}
}

Créer une base de donnéesCreate a database

Définissez la méthode CreateDatabaseAsync dans la classe program.cs.Define the CreateDatabaseAsync method within the program.cs class. Cette méthode crée la FamilyDatabase si elle n’existe pas.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);
}

Créez un conteneur.Create a container

Définissez la méthode CreateContainerAsync dans la classe program.cs.Define the CreateContainerAsync method within the program.cs class. Cette méthode crée le FamilyContainer s’il n’existe pas.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);
}

Créer un élémentCreate an item

Créez un élément de famille en ajoutant la méthode AddItemsToContainerAsync avec le code suivant.Create a family item by adding the AddItemsToContainerAsync method with the following code. Vous pouvez utiliser les méthodes UpsertItemAsync ou CreateItemAsync pour créer un élément :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
{
    // Read the item to see if it exists. ReadItemAsync will throw an exception if the item does not exist and return status code 404 (Not found).
    ItemResponse<Family> andersenFamilyResponse = await this.container.ReadItemAsync<Family>(andersenFamily.Id, new PartitionKey(andersenFamily.LastName));
    Console.WriteLine("Item in database with id: {0} already exists\n", andersenFamilyResponse.Resource.Id);
}
catch(CosmosException ex) when (ex.StatusCode == HttpStatusCode.NotFound)
{
    // 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 off 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);
}
}

Interroger les élémentsQuery the items

Après avoir inséré un élément, vous pouvez exécuter une requête pour obtenir les détails de la famille « Anderson ».After inserting an item, you can run a query to get the details of "Andersen" family. Le code suivant montre comment procéder directement à l’aide de la requête SQL.The following code shows how to execute the query using the SQL query directly. La requête SQL pour obtenir les détails de la famille « Anderson » est la suivante : SELECT * FROM c WHERE c.LastName = 'Andersen'.The SQL query to get the "Anderson" family details is: SELECT * FROM c WHERE c.LastName = 'Andersen'. Définissez la méthode QueryItemsAsync dans la classe program.cs et ajoutez-y le code suivant :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);
        }
    }
}

Supprimer la base de donnéesDelete the database

Enfin, vous pouvez supprimer la base de données en ajoutant la méthode DeleteDatabaseAndCleanupAsync avec le code suivant :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();
}

Exécuter les opérations CRUDExecute the CRUD operations

Après avoir défini toutes les méthodes requises, exécutez-les avec la méthode GetStartedDemoAsync.After you have defined all the required methods, execute them with in the GetStartedDemoAsync method. La méthode DeleteDatabaseAndCleanupAsync est commentée dans ce code parce que vous ne verrez aucune ressource si elle est exécutée.The DeleteDatabaseAndCleanupAsync method commented out in this code because you will not see any resources if that method is executed. Vous pouvez supprimer les marques de commentaire après avoir vérifié que vos ressources Azure Cosmos DB ont été créées dans le portail 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();
}

Après avoir ajouté toutes les méthodes requises, enregistrez le fichier Program.cs.After you add all the required methods, save the Program.cs file.

Exécuter le codeRun the code

Ensuite, générez et exécutez l’application pour créer les ressources Azure Cosmos DB.Next build and run the application to create the Azure Cosmos DB resources. Veillez à ouvrir une nouvelle fenêtre d’invite de commandes, et n’utilisez pas la même instance que celle que vous avez utilisée pour définir les variables d’environnement.Make sure to open a new command prompt window, don't use the same instance that you have used to set the environment variables. En effet, les variables d’environnement ne sont pas définies dans la fenêtre ouverte active.Because the environment variables are not set in the current open window. Vous devrez ouvrir une nouvelle invite de commandes pour afficher les mises à jour.You will need to open a new command prompt to see the updates.

dotnet build
dotnet run

La sortie suivante est générée lorsque vous exécutez l’application.The following output is generated when you run the application. Vous pouvez également vous connecter au portail Azure et vérifier que les ressources ont été créées :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.

Vous pouvez vérifier que les données ont été créées en vous connectant au portail Azure et en affichant les éléments requis dans votre compte 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.

Supprimer des ressourcesClean up resources

Quand vous n’avez plus besoin du compte Azure Cosmos, vous pouvez utiliser Azure CLI ou Azure PowerShell pour le supprimer ainsi que le groupe de ressources correspondant.When no longer needed, you can use the Azure CLI or Azure PowerShell to remove the Azure Cosmos account and the corresponding resource group. La commande suivante montre comment supprimer le groupe de ressources à l’aide d’Azure CLI :The following command shows how to delete the resource group by using the Azure CLI:

az group delete -g "myResourceGroup"

Étapes suivantesNext steps

Dans ce guide de démarrage rapide, vous avez appris à créer un compte Azure Cosmos, ainsi qu’une base de données et un conteneur à l’aide d’une application .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. Vous pouvez désormais importer des données supplémentaires dans votre compte Azure Cosmos en procédant de la manière décrite dans l’article suivant.You can now import additional data to your Azure Cosmos account with the instructions int the following article.