Exercice : Créer des ressources en utilisant le SDK Microsoft .NET v3

15 minutes

Dans cet exercice, vous créez une application console pour effectuer les opérations suivantes dans Azure Cosmos DB :

Se connecter à un compte Azure Cosmos DB
Création d'une base de données
Créez un conteneur.

Prérequis

Compte Azure avec un abonnement actif. Si vous n’en avez pas, vous pouvez vous inscrire à une évaluation gratuite dans la page https://azure.com/free.
Visual Studio Code sur l’une des plateformes prises en charge.
.NET 6 est l’infrastructure cible pour cet exercice.
Extension C# pour Visual Studio Code.
Derniers outils Azure CLI installés localement.

Configuration

Effectuez les actions suivantes afin de préparer Azure et votre environnement local pour l’exercice.

Connexion à Azure

Démarrez Visual Studio Code et ouvrez une fenêtre de terminal en sélectionnant Terminal dans la barre d’application supérieure, puis en choisissant Nouveau terminal.
Connectez-vous à Azure en utilisant la commande suivante. Une fenêtre de navigateur doit s’ouvrir pour vous permettre de choisir le compte avec lequel vous connecter.
```
az login
```

Créer des ressources dans Azure

Créez un groupe de ressources pour les ressources nécessaires à cet exercice. Remplacez <myLocation> par une région près de vous.
```
az group create --location <myLocation> --name az204-cosmos-rg
```
Créez le compte Azure Cosmos DB. Remplacez <myCosmosDBacct> par un nom unique pour identifier votre compte Azure Cosmos DB. Le nom peut uniquement contenir des lettres minuscules, des chiffres et le caractère de trait d’union (-). Sa longueur doit être comprise entre 3 et 31 caractères. L’exécution de cette commande prend quelques minutes.
```
az cosmosdb create --name <myCosmosDBacct> --resource-group az204-cosmos-rg
```
Enregistrez le documentEndpoint affiché dans la réponse JSON. Il est utilisé plus loin dans l’exercice.
Récupérez la clé primaire du compte avec la commande suivante. Enregistrez la primaryMasterKey à partir des résultats de la commande parce qu’elle sera utilisée dans le code.
```
# Retrieve the primary key
az cosmosdb keys list --name <myCosmosDBacct> --resource-group az204-cosmos-rg
```

Configurer l’application console

Maintenant que les ressources nécessaires sont déployées sur Azure, l’étape suivante consiste à configurer l’application console en utilisant la même fenêtre de terminal dans Visual Studio Code.

Créez un dossier pour le projet et accédez à ce dossier.
```
md az204-cosmos
cd az204-cosmos
```
Créez l’application console .NET.
```
dotnet new console
```
Ouvrez le dossier actif dans Visual Studio Code avec la commande suivante. L’option -r permet d’ouvrir le dossier sans lancer de nouvelle fenêtre de Visual Studio Code.
```
code . -r
```
Sélectionnez le fichier Program.cs dans le volet Explorateur pour l’ouvrir dans l’éditeur.

Créer l’application console

Il est temps de commencer à ajouter les packages et le code au projet.

Ajouter des packages et des instructions using

Ouvrez le terminal dans Visual Studio Code, puis utilisez la commande suivante pour ajouter le package Microsoft.Azure.Cosmos au projet.
```
dotnet add package Microsoft.Azure.Cosmos
```
Supprimez tout code existant dans le fichier Program.cs et ajoutez l’instruction using Microsoft.Azure.Cosmos.
```
using Microsoft.Azure.Cosmos;
```

Ajouter du code pour se connecter à un compte Azure Cosmos DB

Ajoutez l’extrait de code suivant après l’instruction using. L’extrait de code ajoute des constantes et des variables à la classe, ainsi qu’une vérification des erreurs. Veillez à remplacer les valeurs des espaces réservés pour EndpointUri et PrimaryKey en suivant les consignes dans les commentaires de code.

public class Program
{
    // Replace <documentEndpoint> with the information created earlier
    private static readonly string EndpointUri = "<documentEndpoint>";

    // Set variable to the Primary Key from earlier.
    private static readonly string PrimaryKey = "<your primary key>";

    // The Cosmos client instance
    private CosmosClient cosmosClient;

    // The database we will create
    private Database database;

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

    // The names of the database and container we will create
    private string databaseId = "az204Database";
    private string containerId = "az204Container";

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

        }
        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 program, press any key to exit.");
            Console.ReadKey();
        }
    }
    //The sample code below gets added below this line
}

Sous la méthode Main, ajoutez une nouvelle tâche asynchrone nommée CosmosAsync, qui instancie notre nouveau CosmosClient et ajoute du code afin d’appeler les méthodes que vous ajouterez pour créer une base de données et un conteneur.

public async Task CosmosAsync()
{
    // Create a new instance of the Cosmos Client
    this.cosmosClient = new CosmosClient(EndpointUri, PrimaryKey);

    // Runs the CreateDatabaseAsync method
    await this.CreateDatabaseAsync();

    // Run the CreateContainerAsync method
    await this.CreateContainerAsync();
}

Création d'une base de données

Copiez et collez la méthode CreateDatabaseAsync après la méthode CosmosAsync. CreateDatabaseAsync crée une base de données avec l’ID az204Database si elle n’existe pas déjà.

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

Créez un conteneur.

Copiez et collez la méthode CreateContainerAsync sous la méthode CreateDatabaseAsync.

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);
}

Exécution de l'application

Enregistrez votre travail, puis, dans un terminal Visual Studio Code, exécutez la commande dotnet build pour vérifier s’il y a des erreurs. Si la génération réussit, exécutez la commande dotnet run. La console affiche les messages suivants.
```
Beginning operations...

Created Database: az204Database

Created Container: az204Container

End of program, press any key to exit.
```
Vérifiez les résultats en ouvrant le portail Azure, en accédant à votre ressource Azure Cosmos DB et en utilisant l’Explorateur de données pour afficher la base de données et le conteneur.

Nettoyage des ressources Azure

Vous pouvez maintenant supprimer de manière sécurisée le groupe de ressources az204-cosmos-rg de votre compte en exécutant la commande suivante.

az group delete --name az204-cosmos-rg --no-wait

Continuer