Övning: Skapa resurser med hjälp av Microsoft .NET SDK v3

15 minuter

I den här övningen skapar du en konsolapp för att utföra följande åtgärder i Azure Cosmos DB:

Ansluta till ett Azure Cosmos DB-konto
Skapa en -databas
Skapa en container

Förutsättningar

Ett Azure-konto med en aktiv prenumeration. Om du inte redan har en sådan kan du registrera dig för en kostnadsfri utvärderingsversion på https://azure.com/free.
Visual Studio Code på någon av plattformarna som stöds.
.NET 8 är målramverket för övningen.
C#-tillägget för Visual Studio Code.
De senaste Azure CLI-verktygen, installerade lokalt.

Konfigurera

Utför följande åtgärder för att förbereda Azure och din lokala miljö för övningen.

Ansluta till Azure

Starta Visual Studio Code och öppna ett terminalfönster genom att välja Terminal i det övre programfältet och sedan välja Ny terminal.
Logga in på Azure med hjälp av följande kommando. Ett webbläsarfönster bör öppnas så att du kan välja vilket konto du vill logga in med.
```
az login
```

Skapa resurser i Azure

Skapa en resursgrupp för de resurser som behövs för den här övningen. Ersätt <myLocation> med en region nära dig.
```
az group create --location <myLocation> --name az204-cosmos-rg
```
Skapa Azure Cosmos DB-kontot. Ersätt <myCosmosDBacct> med ett unikt namn för att identifiera ditt Azure Cosmos DB-konto. Namnet får endast innehålla gemener, siffror och bindestreck (-). Det måste innehålla 3–31 tecken. Det tar några minuter att slutföra det här kommandot.
```
az cosmosdb create --name <myCosmosDBacct> --resource-group az204-cosmos-rg
```
Registrera det documentEndpoint som visas i JSON-svaret för användning senare i övningen.
Hämta primärnyckeln för kontot med hjälp av följande kommando. primaryMasterKey Registrera från kommandoresultatet för användning i koden.
```
# Retrieve the primary key
az cosmosdb keys list --name <myCosmosDBacct> --resource-group az204-cosmos-rg
```

Konfigurera konsolprogrammet

Nu när de nödvändiga resurserna har distribuerats till Azure är nästa steg att konfigurera konsolprogrammet med samma terminalfönster i Visual Studio Code.

Skapa en mapp för projektet och ändra till mappen.
```
md az204-cosmos
cd az204-cosmos
```
Skapa .NET-konsolappen.
```
dotnet new console
```
Öppna den aktuella mappen i Visual Studio Code med hjälp av följande kommando. Alternativet -r öppnar mappen utan att starta ett nytt Visual Studio Code-fönster.
```
code . -r
```
Välj filen Program.cs i explorer-fönstret för att öppna filen i redigeraren.

Skapa konsolappen

Det är dags att börja lägga till paketen och koden i projektet.

Lägga till paket och använda instruktioner

Öppna terminalen i Visual Studio Code och använd följande kommando för att lägga Microsoft.Azure.Cosmos till paketet i projektet.
```
dotnet add package Microsoft.Azure.Cosmos
```
Ta bort befintlig kod i Program.cs filen och lägg till -instruktionen using Microsoft.Azure.Cosmos .
```
using Microsoft.Azure.Cosmos;
```

Lägga till kod för att ansluta till ett Azure Cosmos DB-konto

Lägg till följande kodfragment efter -instruktionen using . Kodfragmentet lägger till konstanter och variabler i klassen och lägger till en del felkontroll. Se till att ersätta platshållarvärdena för EndpointUri och PrimaryKey följa anvisningarna i kodkommentarna.

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
}

Main Under metoden lägger du till en ny asynkron uppgift med namnet CosmosAsync, som instansierar vår nya CosmosClient och lägger till kod för att anropa de metoder som du lägger till senare för att skapa en databas och en container.

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

Skapa en -databas

Kopiera och klistra in CreateDatabaseAsync metoden efter CosmosAsync metoden. CreateDatabaseAsync skapar en ny databas med ID az204Database om den inte redan finns.

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

Skapa en container

Kopiera och klistra in CreateContainerAsync metoden under CreateDatabaseAsync metoden.

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

Kör appen

Spara ditt arbete och kontrollera eventuella fel i en terminal i Visual Studio Code genom att dotnet build köra kommandot . dotnet run Kör kommandot om bygget lyckas. Konsolen visar följande meddelanden.
```
Beginning operations...

Created Database: az204Database

Created Container: az204Container

End of program, press any key to exit.
```
Kontrollera resultatet genom att öppna Azure Portal, navigera till din Azure Cosmos DB-resurs och använda Datautforskaren för att visa databasen och containern.

Rensa Azure-resurser

Nu kan du ta bort resursgruppen az204-cosmos-rg från ditt konto på ett säkert sätt genom att köra följande kommando.

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