Schnellstart: Erstellen einer .NET-Konsolen-App zum Verwalten von Ressourcen der Azure Cosmos DB-SQL-APIQuickstart: Build a .NET console app to manage Azure Cosmos DB SQL API resources

Erste Schritte mit der Azure Cosmos DB-SQL-API-Clientbibliothek für .NET.Get started with the Azure Cosmos DB SQL API client library for .NET. Führen Sie die in diesem Dokument aufgeführten Schritte aus, um das .NET-Paket zu installieren, eine App zu erstellen und den Beispielcode für grundlegende CRUD-Vorgänge für die in Azure Cosmos DB gespeicherten Daten zu testen.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 ist der global verteilte Microsoft-Datenbankdienst mit mehreren Modellen.Azure Cosmos DB is Microsoft’s globally distributed multi-model database service. Mit Azure Cosmos DB können Sie Schlüssel-Werte-, Dokument- und Graphdatenbanken schnell erstellen und abfragen.You can use Azure Cosmos DB to quickly create and query key/value, document, and graph databases. Verwenden Sie die Azure Cosmos DB-SQL-API-Clientbibliothek für .NET zum Ausführen der folgenden Aufgaben:Use the Azure Cosmos DB SQL API client library for .NET to:

  • Erstellen einer Azure Cosmos-Datenbank und eines ContainersCreate an Azure Cosmos database and a container
  • Hinzufügen von Beispieldaten zum ContainerAdd sample data to the container
  • Abfragen von DatenQuery the data
  • Löschen der DatenbankDelete the database

API-Referenzdokumentation | Quellcode der Bibliothek | Paket (NuGet)API reference documentation | Library source code | Package (NuGet)

VoraussetzungenPrerequisites

EinrichtenSetting up

Dieser Abschnitt führt Sie durch das Erstellen eines Azure Cosmos-Kontos und durch das Einrichten eines Projekts, das die Azure Cosmos DB-SQL-API-Clientbibliothek für .NET zum Verwalten von Ressourcen verwendet.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. Mit dem in diesem Artikel beschriebenen Beispielcode erstellen Sie eine Datenbank mit dem Namen FamilyDatabase und Familienmitglieder (jedes Familienmitglieder ist ein Element) in dieser Datenbank.The example code described in this article creates a FamilyDatabase database and family members (each family member is an item) within that database. Jedes Familienmitglied weist Eigenschaften auf, wie z. B. Id, FamilyName, FirstName, LastName, Parents, Children, Address,.Each family member has properties such as Id, FamilyName, FirstName, LastName, Parents, Children, Address,. Die Eigenschaft LastName wird als Partitionsschlüssel für den Container verwendet.The LastName property is used as the partition key for the container.

Erstellen eines Azure Cosmos-KontosCreate an Azure Cosmos account

Mit dem folgenden Code wird ein Azure Cosmos-Konto mit Sitzungskonsistenz erstellt.The following code will create an Azure Cosmos account with session consistency. Das Konto wird in South Central US und North Central US repliziert.The account is replicated in South Central US and North Central US. Wählen Sie die Schaltfläche Ausprobieren aus, und fügen Sie den Code ein, um ihn in der Azure Cloud Shell auszuführen.Select the Try It button and paste the code to run it in the Azure cloud shell.


# Set variables for the new SQL API account, database, and container
resourceGroupName='myResourceGroup'
location='southcentralus'
accountName='mysqlapicosmosdb' 
databaseName='FamilyDatabase'
containerName='FamilyContainer'

# 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

Erstellen einer neuen .NET-AppCreate a new .NET app

Erstellen Sie eine neue .NET-Anwendung in Ihrem bevorzugten Editor oder Ihrer bevorzugten IDE.Create a new .NET application in your preferred editor or IDE. Führen Sie in einem Konsolenfenster den folgenden „dotnet new“-Befehl aus, um eine neue App mit dem Namen todo zu erstellen.In a console window, run the following dotnet new command to create a new app with the name todo.

dotnet new console --langVersion 7.1 -n todo

Wechseln Sie zum Ordner der neu erstellten App.Change your directory to the newly created app folder. Sie können die Anwendung mit folgendem Befehl erstellen:You can build the application with:

cd todo
dotnet build

Die erwartete Ausgabe aus dem Build sollte etwa wie folgt aussehen: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

Installieren des Azure Cosmos DB-PaketsInstall the Azure Cosmos DB package

Installieren Sie im Anwendungsverzeichnis mit dem Befehl „dotnet add package“ die Azure Cosmos DB-Clientbibliothek für .NET Core.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

Kopieren der Anmeldeinformationen für Ihr Azure Cosmos-Konto aus dem Azure-PortalCopy your Azure Cosmos account credentials from the Azure portal

Die Beispielanwendung muss sich bei Ihrem Azure Cosmos-Konto authentifizieren.The sample application needs to authenticate to your Azure Cosmos account. Für die Authentifizierung müssen Sie die Anmeldeinformationen für das Azure Cosmos-Konto an die Anwendung übergeben.To authenticate, you should pass the Azure Cosmos account credentials to the application. Führen Sie zum Abrufen der Anmeldeinformationen für Ihr Azure Cosmos-Konto die folgenden Schritte aus:Get your Azure Cosmos account credentials by following these steps:

  1. Melden Sie sich beim Azure-Portal an.Sign in to the Azure portal.

  2. Navigieren Sie zu Ihrem Azure Cosmos-Konto.Navigate to your Azure Cosmos account.

  3. Öffnen Sie den Bereich Schlüssel, und kopieren Sie den URI und den PRIMÄRSCHLÜSSEL Ihres Kontos.Open the Keys pane and copy the URI and PRIMARY KEY of your account. Den URI- und den Schlüsselwert fügen Sie im nächsten Schritt zu einer Umgebungsvariablen hinzu.You will add the URI and keys values to an environment variable in the next step.

Festlegen der UmgebungsvariablenSet the environment variables

Nachdem Sie den URI und den PRIMÄRSCHLÜSSEL Ihres Kontos kopiert haben, können Sie diese Werte in einer neuen Umgebungsvariablen auf dem lokalen Computer speichern, auf dem die Anwendung ausgeführt wird.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. Um die Umgebungsvariable festzulegen, öffnen Sie ein Konsolenfenster, und führen Sie den folgenden Befehl aus.To set the environment variable, open a console window, and run the following command. Ersetzen Sie unbedingt die Werte <Your_Azure_Cosmos_account_URI> und <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>"

ObjektmodellObject model

Bevor Sie mit dem Erstellen der Anwendung beginnen, befassen wir uns noch mit der Hierarchie der Ressourcen in Azure Cosmos DB und dem Objektmodell, das verwendet wird, um diese Ressourcen zu erstellen und darauf zuzugreifen.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 erstellt Ressourcen in der folgenden Reihenfolge:The Azure Cosmos DB creates resources in the following order:

  • Azure Cosmos-KontoAzure Cosmos account
  • DatenbankenDatabases
  • ContainerContainers
  • ItemsItems

Weitere Informationen zur Hierarchie der verschiedenen Entitäten finden Sie im Artikel Arbeiten mit Datenbanken, Containern und Elementen in 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. Für die Interaktion mit diesen Ressourcen verwenden Sie die folgenden .NET-Klassen:You will use the following .NET classes to interact with these resources:

  • CosmosClient: Diese Klasse bietet eine clientseitige logische Darstellung für den Azure Cosmos DB-Dienst.CosmosClient - This class provides a client-side logical representation for the Azure Cosmos DB service. Das Clientobjekt wird zum Konfigurieren und Ausführen von Anforderungen für den Dienst verwendet.The client object is used to configure and execute requests against the service.

  • CreateDatabaseIfNotExistsAsync: Mit dieser Methode wird eine Datenbankressource als asynchroner Vorgang erstellt (falls nicht vorhanden) oder abgerufen (wenn bereits vorhanden).CreateDatabaseIfNotExistsAsync - This method creates (if doesn't exist) or gets (if already exists) a database resource as an asynchronous operation.

  • CreateContainerIfNotExistsAsync: Mit dieser Methode wird ein Container als asynchroner Vorgang erstellt (falls er nicht vorhanden ist) oder abgerufen (wenn er bereits vorhanden ist).CreateContainerIfNotExistsAsync- - This method creates (if it doesn't exist) or gets (if it already exists) a container as an asynchronous operation. Sie können den Statuscode in der Antwort überprüfen, um zu ermitteln, ob der Container neu erstellt wurde (201) oder ein vorhandener Container zurückgegeben wurde (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: Diese Methode erstellt ein Element im Container.CreateItemAsync - This method creates an item within the container.

  • GetItemQueryIterator: Diese Methode erstellt eine Abfrage nach Elementen unter einem Container in einer Azure Cosmos-Datenbank unter Verwendung einer SQL-Anweisung mit parametrisierten Werten.GetItemQueryIterator - This method creates a query for items under a container in an Azure Cosmos database using a SQL statement with parameterized values.

  • DeleteAsync: Löscht die angegebene Datenbank aus Ihrem Azure Cosmos-Konto.DeleteAsync - Deletes the specified database from your Azure Cosmos account. Die DeleteAsync-Methode löscht nur die Datenbank.DeleteAsync method only deletes the database. Das Löschen der Cosmosclient-Instanz sollte separat erfolgen (und zwar in der „DeleteDatabaseAndCleanupAsync“-Methode).Disposing of the Cosmosclient instance should happen separately (which it does in the DeleteDatabaseAndCleanupAsync method.

CodebeispieleCode examples

Mit dem in diesem Artikel beschriebenen Beispielcode wird in Azure Cosmos DB eine Familiendatenbank („FamilyDatabase“) erstellt.The sample code described in this article creates a family database in Azure Cosmos DB. Die Familiendatenbank enthält Familiendetails wie Name, Adresse, Standort, die zugehörigen Eltern, Kinder und Haustiere.The family database contains family details such as name, address, location, the associated parents, children, and pets. Definieren Sie die Eigenschaften eines Familienelements, bevor Sie Ihr Azure Cosmos-Konto mit den Daten auffüllen.Before populating the data to your Azure Cosmos account, define the properties of a family item. Erstellen Sie eine neue Klasse mit dem Namen Family.cs auf der Stammebene Ihrer Beispielanwendung, und fügen Sie ihr den folgenden Code hinzu: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; }
        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; }
    }
}

Hinzufügen der using-Direktiven und Definieren des ClientobjektsAdd the using directives & define the client object

Öffnen Sie im Projektverzeichnis die Datei Program.cs im Editor, und fügen Sie die folgenden using-Direktiven am Anfang der Anwendung hinzu: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;

Fügen Sie der program.cs file Code zum Lesen der im vorherigen Schritt festgelegten Umgebungsvariablen hinzu.To the program.cs file, add code to read the environment variables that you have set in the previous step. Definieren Sie die CosmosClient-, Database- und Container-Objekte.Define the CosmosClient, Database, and the Container objects. Fügen Sie als Nächstes Code zur Main-Methode hinzu, die die GetStartedDemoAsync-Methode aufruft, mit der Sie Azure Cosmos-Kontoressourcen verwalten.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();
        }
    }
}
}

Erstellen einer DatenbankCreate a database

Definieren Sie die CreateDatabaseAsync-Methode in der program.cs-Klasse.Define the CreateDatabaseAsync method within the program.cs class. Diese Methode erstellt die FamilyDatabase, falls sie noch nicht vorhanden ist.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);
}

Erstellen eines ContainersCreate a container

Definieren Sie die CreateContainerAsync-Methode in der program.cs-Klasse.Define the CreateContainerAsync method within the program.cs class. Diese Methode erstellt den FamilyContainer, falls er noch nicht vorhanden ist.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);
}

Erstellen eines ElementsCreate an item

Erstellen Sie ein Familienelement, indem Sie die AddItemsToContainerAsync-Methode mit dem folgenden Code hinzufügen:Create a family item by adding the AddItemsToContainerAsync method with the following code:

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

Abfragen der ElementeQuery the items

Nachdem Sie ein Element eingefügt haben, können Sie eine Abfrage zum Abrufen der Details der Familie „Andersen“ ausführen.After inserting an item, you can run a query to get the details of "Andersen" family. Im folgenden Codebeispiel wird gezeigt, wie die Abfrage direkt mithilfe der SQL-Abfrage ausgeführt wird.The following code shows how to execute the query using the SQL query directly. Die SQL-Abfrage zum Abrufen der Details der Familie „Anderson“ lautet SELECT * FROM c WHERE c.LastName = 'Andersen'.The SQL query to get the "Anderson" family details is: SELECT * FROM c WHERE c.LastName = 'Andersen'. Definieren Sie die QueryItemsAsync-Methode in der program.cs-Klasse, und fügen Sie ihr den folgenden Code hinzu: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);
        }
    }
}

Löschen der DatenbankDelete the database

Schließlich können Sie die Datenbank löschen, indem Sie die DeleteDatabaseAndCleanupAsync-Methode mit dem folgenden Code hinzufügen: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();
}

Ausführen der CRUD-VorgängeExecute the CRUD operations

Nachdem Sie alle erforderlichen Methoden definiert haben, können Sie diese in der GetStartedDemoAsync-Methode ausführen.After you have defined all the required methods, execute them with in the GetStartedDemoAsync method. Die DeleteDatabaseAndCleanupAsync-Methode ist in diesem Code auskommentiert, weil keine Ressourcen angezeigt werden, wenn diese Methode ausgeführt wird.The DeleteDatabaseAndCleanupAsync method commented out in this code because you will not see any resources if that method is executed. Sie können die Auskommentierung aufheben, nachdem Sie überprüft haben, ob Ihre Azure Cosmos DB-Ressourcen im Azure-Portal erstellt wurden.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(EndpointUri, PrimaryKey);
    await this.CreateDatabaseAsync();
    await this.CreateContainerAsync();
    await this.AddItemsToContainerAsync();
    await this.QueryItemsAsync();
    await this.ReplaceFamilyItemAsync();
    await this.DeleteFamilyItemAsync();
    //await this.DeleteDatabaseAndCleanupAsync();
}

Speichern Sie die Datei Program.cs, nachdem Sie alle erforderlichen Methoden hinzugefügt haben.After you add all the required methods, save the Program.cs file.

Ausführen des CodesRun the code

Als Nächstes können Sie die Anwendung zum Erstellen der Azure Cosmos DB-Ressourcen erstellen und ausführen.Next build and run the application to create the Azure Cosmos DB resources. Stellen Sie sicher, dass Sie ein neues Eingabeaufforderungsfenster öffnen und nicht dieselbe Instanz verwenden, mit der Sie die Umgebungsvariablen festgelegt haben.Make sure to open a new command prompt window, don't use the same instance that you have used to set the environment variables. Die Umgebungsvariablen sind nämlich im aktuellen geöffneten Fenster nicht festgelegt.Because the environment variables are not set in the current open window. Sie müssen eine neue Eingabeaufforderung öffnen, um die Aktualisierungen anzeigen zu können.You will need to open a new command prompt to see the updates.

dotnet build
dotnet run

Die folgende Ausgabe wird generiert, wenn Sie die Anwendung ausführen.The following output is generated when you run the application. Sie können sich auch beim Azure-Portal anmelden und überprüfen, ob die Ressourcen erstellt wurden: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.

Sie können überprüfen, ob die Daten erstellt wurden, indem Sie sich beim Azure-Portal anmelden und die erforderlichen Elemente in Ihrem Azure Cosmos-Konto anzeigen.You can validate that the data is created by signing into the Azure portal and see the required items in your Azure Cosmos account.

Bereinigen von RessourcenClean up resources

Wenn Sie die Ressourcen nicht mehr benötigen, können Sie die Azure-Befehlszeilenschnittstelle (Azure CLI) oder Azure PowerShell verwenden, um das Azure Cosmos-Konto und die zugehörige Ressourcengruppe zu entfernen.When no longer needed, you can use the Azure CLI or Azure PowerShell to remove the Azure Cosmos account and the corresponding resource group. Der folgende Befehl zeigt, wie die Ressourcengruppe mit der Azure CLI gelöscht wird:The following command shows how to delete the resource group by using the Azure CLI:

az group delete -g "myResourceGroup" -l "southcentralus"

Nächste SchritteNext steps

In diesem Schnellstart haben Sie gelernt, wie Sie ein Azure Cosmos-Konto erstellen und eine Datenbank und einen Container mithilfe einer .NET Core-App erstellen.In this quickstart, you learned how to create an Azure Cosmos account, create a database and a container using a .NET Core app. Sie können jetzt zusätzliche Daten in Ihr Azure Cosmos-Konto importieren. Die entsprechenden Anweisungen finden Sie im folgenden Artikel.You can now import additional data to your Azure Cosmos account with the instructions int the following article.