Oefening: Resources maken met behulp van de Microsoft .NET SDK v3

15 minuten

In deze oefening maakt u een console-app om de volgende bewerkingen uit te voeren in Azure Cosmos DB:

Verbinding maken met een Azure Cosmos DB-account
Een -database maken
Een container maken

Vereisten

Een Azure-account met een actief abonnement. Als nog geen abonnement hebt, kunt u zich registreren voor een gratis abonnement op https://azure.com/free.
Visual Studio Code op een van de ondersteunde platforms.
.NET 8 is het doelframework voor de oefening.
De C#-extensie voor Visual Studio Code.
De nieuwste Azure CLI-hulpprogramma's die lokaal zijn geïnstalleerd.

Instellen

Voer de volgende acties uit om Azure en uw lokale omgeving voor te bereiden voor de oefening.

Verbinding maken met Azure

Start Visual Studio Code en open een terminalvenster door Terminal te selecteren in de bovenste toepassingsbalk en vervolgens Nieuwe terminal te kiezen.
Meld u aan bij Azure met behulp van de volgende opdracht. Er moet een browservenster worden geopend waarin u kunt kiezen met welk account u zich wilt aanmelden.
```
az login
```

Resources maken in Azure

Maak een resourcegroep voor de resources die nodig zijn voor deze oefening. Vervang door <myLocation> een regio bij u in de buurt.
```
az group create --location <myLocation> --name az204-cosmos-rg
```
Maak het Azure Cosmos DB-account. Vervang door <myCosmosDBacct> een unieke naam om uw Azure Cosmos DB-account te identificeren. De naam mag alleen kleine letters, cijfers en het koppelteken (-) bevatten. De naam moet tussen de 3 en 31 tekens lang zijn. Het voltooien van deze opdracht duurt enkele minuten.
```
az cosmosdb create --name <myCosmosDBacct> --resource-group az204-cosmos-rg
```
Noteer de documentEndpoint weergegeven in het JSON-antwoord voor gebruik verderop in de oefening.
Haal de primaire sleutel voor het account op met behulp van de volgende opdracht. Noteer de primaryMasterKey resultaten van de opdracht voor gebruik in de code.
```
# Retrieve the primary key
az cosmosdb keys list --name <myCosmosDBacct> --resource-group az204-cosmos-rg
```

De consoletoepassing instellen

Nu de benodigde resources in Azure zijn geïmplementeerd, is de volgende stap het instellen van de consoletoepassing met hetzelfde terminalvenster in Visual Studio Code.

Maak een map voor het project en ga naar de map.
```
md az204-cosmos
cd az204-cosmos
```
Maak de .NET-console-app.
```
dotnet new console
```
Open de huidige map in Visual Studio Code met behulp van de volgende opdracht. Met -r de optie wordt de map geopend zonder een nieuw Visual Studio Code-venster te starten.
```
code . -r
```
Selecteer het Program.cs bestand in het deelvenster Explorer om het bestand in de editor te openen.

De console-app bouwen

Het is tijd om de pakketten en code toe te voegen aan het project.

Pakketten en instructies toevoegen

Open de terminal in Visual Studio Code en gebruik de volgende opdracht om het Microsoft.Azure.Cosmos pakket toe te voegen aan het project.
```
dotnet add package Microsoft.Azure.Cosmos
```
Verwijder alle bestaande code in het Program.cs bestand en voeg de using Microsoft.Azure.Cosmos instructie toe.
```
using Microsoft.Azure.Cosmos;
```

Code toevoegen om verbinding te maken met een Azure Cosmos DB-account

Voeg het volgende codefragment toe na de using instructie. Het codefragment voegt constanten en variabelen toe aan de klasse en voegt een foutcontrole toe. Vervang de waarden van de tijdelijke aanduidingen voor EndpointUri en PrimaryKey volg de aanwijzingen in de codeopmerkingen.

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
}

Voeg onder de methode een nieuwe asynchrone taak toe met de Main naam CosmosAsync, waarmee de nieuwe CosmosClient wordt geïnstitueert en code wordt toegevoegd om de methoden aan te roepen die u later toevoegt om een database en een container te maken.

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

Een -database maken

Kopieer en plak de CreateDatabaseAsync methode na de CosmosAsync methode. CreateDatabaseAsync maakt een nieuwe database met id az204Database als deze nog niet bestaat.

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

Een container maken

Kopieer en plak de CreateContainerAsync methode onder de CreateDatabaseAsync methode.

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

De toepassing uitvoeren

Sla uw werk op en controleer in een terminal in Visual Studio Code op eventuele fouten door de opdracht uit te dotnet build voeren. Voer de dotnet run opdracht uit als de build is geslaagd. In de console worden de volgende berichten weergegeven.
```
Beginning operations...

Created Database: az204Database

Created Container: az204Container

End of program, press any key to exit.
```
Controleer de resultaten door Azure Portal te openen, naar uw Azure Cosmos DB-resource te navigeren en Data Explorer te gebruiken om de database en container weer te geven.

Azure-resources opschonen

U kunt nu de resourcegroep az204-cosmos-rg veilig verwijderen uit uw account door de volgende opdracht uit te voeren.

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