Übung: Erstellen von Ressourcen mit Microsoft .NET SDK v3

15 Minuten

In dieser Übung erstellen Sie eine Konsolen-App, um die folgenden Vorgänge in Azure Cosmos DB durchzuführen:

Herstellen einer Verbindung mit einem Azure Cosmos DB-Konto
Erstellen einer Datenbank
Erstellen eines Containers

Voraussetzungen

Ein Azure-Konto mit einem aktiven Abonnement. Wenn Sie noch keines haben, können Sie sich unter https://azure.com/free für eine kostenlose Testversion registrieren.
Visual Studio Code auf einer der unterstützten Plattformen
.NET 8 ist das Zielframework für diese Übung.
C#-Erweiterung für Visual Studio Code
Lokale Installation der neuesten Azure CLI-Tools.

Einrichten

Führen Sie die folgenden Aktionen aus, um Azure und Ihre lokale Umgebung für die Übung vorzubereiten.

Verbindungsherstellung mit Azure

Starten Sie Visual Studio Code, und öffnen Sie ein Terminalfenster, indem Sie in der oberen Anwendungsleiste zunächst auf Terminal und dann auf Neues Terminal klicken.
Melden Sie sich mithilfe des folgenden Befehls bei Azure an. Es sollte ein Browserfenster geöffnet werden, in dem Sie auswählen können, mit welchem Konto Sie sich anmelden möchten.
```
az login
```

Erstellen von Ressourcen in Azure

Erstellen Sie eine Ressourcengruppe für die Ressourcen, die für diese Übung benötigt werden. Ersetzen Sie <myLocation> durch eine Region in Ihrer Nähe.
```
az group create --location <myLocation> --name az204-cosmos-rg
```
Erstellen Sie das Azure Cosmos DB-Konto. Ersetzen Sie <myCosmosDBacct> durch einen eindeutigen Namen, um Ihr Azure Cosmos DB-Konto zu identifizieren. Der Name darf nur Kleinbuchstaben, Zahlen und den Bindestrich (-) enthalten. Sie muss zwischen drei und 31 Zeichen lang sein. Die Ausführung dieses Befehls dauert einige Minuten.
```
az cosmosdb create --name <myCosmosDBacct> --resource-group az204-cosmos-rg
```
Notieren Sie sich den in der JSON-Antwort angezeigten documentEndpoint für die spätere Verwendung in der Übung.
Rufen Sie mithilfe des folgenden Befehls den Primärschlüssel für das Konto ab. Notieren Sie sich den primaryMasterKey aus den Befehlsergebnissen für die Verwendung im Code.
```
# Retrieve the primary key
az cosmosdb keys list --name <myCosmosDBacct> --resource-group az204-cosmos-rg
```

Einrichten der Konsolenanwendung

Nachdem die erforderlichen Ressourcen nun in Azure bereitgestellt wurden, besteht der nächste Schritt im Einrichten der Konsolenanwendung mithilfe desselben Terminalfensters in Visual Studio Code.

Erstellen Sie einen Ordner für das Projekt, und öffnen Sie diesen.
```
md az204-cosmos
cd az204-cosmos
```
Erstellen Sie die .NET-Konsolen-App.
```
dotnet new console
```
Öffnen Sie den aktuellen Ordner in Visual Studio Code mit dem folgenden Befehl. Mit der Option -r wird der Ordner geöffnet, ohne ein neues Visual Studio Code-Fenster zu öffnen.
```
code . -r
```
Klicken Sie auf die Datei Program.cs im Bereich Explorer, um die Datei im Editor zu öffnen.

Erstellen der Konsolen-App

Nun ist es an der Zeit, die Pakete und den Code zum Projekt hinzuzufügen.

Hinzufügen von Paketen und using-Anweisungen

Öffnen Sie das Terminal in Visual Studio Code, und verwenden Sie den folgenden Befehl, um das Microsoft.Azure.Cosmos-Paket zum Projekt hinzuzufügen.
```
dotnet add package Microsoft.Azure.Cosmos
```
Löschen Sie den bestehenden Code in der Datei Program.cs, und fügen Sie die Anweisung using Microsoft.Azure.Cosmos hinzu.
```
using Microsoft.Azure.Cosmos;
```

Hinzufügen von Code zum Herstellen einer Verbindung mit einem Azure Cosmos DB-Konto

Fügen Sie nach der Anweisung using das folgende Codeschnipsel hinzu. Der Codeausschnitt fügt der Klasse Konstanten und Variablen hinzu. Zudem werden Fehlerüberprüfungen hinzugefügt. Achten Sie darauf, dass Sie die Platzhalterwerte für EndpointUri und PrimaryKey gemäß den Anweisungen in den Codekommentaren ersetzen.

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
}

Fügen Sie unter der Methode Main einen neuen asynchronen Task namens CosmosAsync hinzu, der den neuen CosmosClient instanziiert und Code zum Aufrufen der Methoden hinzufügt, die Sie später hinzufügen, um eine Datenbank und einen Container zu erstellen.

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

Erstellen einer Datenbank

Kopieren Sie die CreateDatabaseAsync-Methode, und fügen Sie sie nach der CosmosAsync-Methode ein. CreateDatabaseAsync erstellt eine neue Datenbank mit der ID az204Database, wenn diese noch nicht existiert.

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

Erstellen eines Containers

Kopieren Sie die CreateContainerAsync-Methode, und fügen Sie sie unterhalb der CreateDatabaseAsync-Methode ein.

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

Ausführen der Anwendung

Speichern Sie Ihre Arbeit, und überprüfen Sie in einem Terminal in Visual Studio Code, ob Fehler vorliegen, indem Sie den Befehl dotnet build ausführen. Wenn der Build erfolgreich ist, führen Sie den Befehl dotnet run aus. In der Konsole werden folgende Meldungen ausgegeben.
```
Beginning operations...

Created Database: az204Database

Created Container: az204Container

End of program, press any key to exit.
```
Überprüfen Sie die Ergebnisse, indem Sie das Azure-Portal öffnen, zu Ihrer Azure Cosmos DB-Ressource navigieren und den Daten-Explorer zum Anzeigen der Datenbank und des Containers verwenden.

Bereinigen von Azure-Ressourcen

Sie können jetzt den folgenden Befehl ausführen, um die Ressourcengruppe az204-cosmos-rg auf sichere Weise aus Ihrem Konto zu löschen.

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