Erstellen eines Kontos, einer Datenbank und einer Sammlung mithilfe von Azure Cosmos DB for MongoDB

8 Minuten

Azure Cosmos DB ist ein vollständig verwalteter PaaS-Dienst (Platform-as-a-Service, PaaS). Um diesen Dienst zu verwenden, müssen Sie zunächst ein Azure Cosmos DB-Konto in Ihrem Abonnement erstellen. Nachdem das Konto erstellt wurde, können Sie darin Datenbanken, Sammlungen und Dokumente hinzufügen.

Im Folgenden werden einige Möglichkeiten vorgestellt, um die verschiedenen Elemente des Azure Cosmos DB for MongoDB-Modells zu erstellen.

Erstellen eines Kontos, einer Datenbank und eines Containers für Azure Cosmos DB for MongoDB über das Azure-Portal

Eine Möglichkeit zum Erstellen des Azure Cosmos DB-Kontos und seiner Elemente ist die Verwendung des Azure-Portals. In diesem Beispiel verwenden Sie das Azure-Portal, um ein Azure Cosmos DB-Konto mit Azure Cosmos DB for MongoDB zu erstellen. Anschließend fügen Sie eine Datenbank und eine Sammlung hinzu. Im Moment sind die erweiterten Einstellungen nicht relevant. Diese werden in späteren Modulen ausführlicher behandelt. In diesem Beispiel überprüfen Sie einfach die Registerkarte „Grundlagen“. Erstellen Sie nun das Konto und seine Elemente.

Erstellen Sie ein Konto für Azure Cosmos DB for MongoDB

Wählen Sie im Azure-Portal die Option + Ressource erstellen, anschließend Azure Cosmos DB und dann Erstellen aus.
Wählen Sie Azure Cosmos DB für MongoDB aus.
Geben Sie die folgenden Parameter ein.
- Abonnement: Ihr aktuelles Azure-Abonnement
- Ressourcengruppe: Eine neue oder vorhandene Azure-Ressourcengruppe, in der das Azure Cosmos DB-Konto erstellt werden soll
- Kontoname: Ein eindeutiger Name für Ihr Azure Cosmos DB-Konto. Dieser Name muss innerhalb von Azure eindeutig sein. Der Konto-URI lautet mongo.cosmos.azure.com und wird an Ihren Kontonamen angefügt.
- Standort: Dies ist der geografische Standort, an dem Ihr Azure Cosmos DB-Konto gehostet wird. Es wird empfohlen, einen Standort in der Nähe Ihrer Benutzer*innen oder Anwendungen auswählen.
- Kapazitätsmodus: Wie in einer vorherigen Einheit beschrieben wurde, können Sie Bereitgestellter Durchsatz oder Serverlos für Ihr Konto auswählen. Wählen Sie für dieses Beispiel Bereitgestellter Durchsatz aus.
- Rabatt für Free-Tarif anwenden: Wählen Sie für dieses Beispiel Nicht anwenden aus.
- Gesamtdurchsatz des Kontos beschränken: Deaktivieren Sie diese Option für dieses Beispiel.
- Version: Wählen Sie 4.0 aus.
Hinweis

Um die unterstützten Features besser nutzen zu können, wird empfohlen, nach Möglichkeit Versionen ab 3.6 zu verwenden.
Wählen Sie Überprüfen und erstellen aus, und wählen Sie bei einer erfolgreichen Überprüfung dann Erstellen aus.

Hinweis

Es dauert einige Minuten, das Azure Cosmos DB-Konto zu erstellen.

Erstellen einer Datenbank und eines Containers für die Azure Cosmos DB für MongoDB

Das Erstellen einer Datenbank und eines Containers im Azure-Portal ist unkompliziert. Erstellen Sie zunächst eine Datenbank.

Wählen Sie links im Menü des Kontos für die Azure Cosmos DB für MongoDB die Option Daten-Explorer aus.
Wählen Sie im Dropdownmenü rechts neben dem Symbol Neue Sammlung die Option Neue Datenbank aus.
Geben Sie Ihrer Datenbank über das Textfeld Datenbank-ID einen neuen Namen.
Obwohl Sie den Bereitstellungsdurchsatz im Dialogfeld Neue Datenbank definieren könnten, würden Sie diesen in den meisten Fällen auf Containerebene auswählen. Deaktivieren Sie das Kontrollkästchen Durchsatz bereitstellen für dieses Beispiel, und wählen Sie OK aus.

Die neue Datenbank sollte jetzt im Abschnitt MONGO-API vorhanden sein. Erstellen Sie jetzt eine neue Sammlung.
Wählen Sie das Symbol Neue Sammlung aus.
Geben Sie die folgenden Parameter im Dialogfeld Neue Sammlung ein.
- Datenbankname: Hier gibt es zwei Optionen, Neu erstellen und Vorhandene verwenden. Mit dieser Option können Sie während der Erstellung der neuen Sammlung auch eine neue Datenbank erstellen. Da Sie in den vorherigen Schritten bereits eine neue Datenbank erstellt haben, wählen Sie Vorhandene verwenden und dann den Datenbanknamen aus dem Dropdownmenü aus.
- Sammlungs-ID: Dieser Parameter ist der Name, den Sie Ihrer Sammlung zuweisen.
- Sharding: In der Regel sollten Sie Mit Sharding auswählen. Diese Option ermöglicht Azure Cosmos DB das Erstellen von Containern, für die ein Sharding in mehrere Mandanten auf Grundlage des Shardschlüssels erfolgt. Bei großen Containern verteilt Azure Cosmos DB Ihre Mandanten auf mehrere physische Knoten, um ein hohes Maß an Skalierung zu erreichen. Im Modul zum Design wird das Sharding ausführlicher erläutert. Wählen Sie Mit Sharding aus.
  - Shardschlüssel: Wenn Sie Mit Sharding auswählen, müssen Sie einen Shardschlüssel hinzufügen. Dieser Schlüssel ist der Partitionsschlüssel, der Ihre Partitionsstrategie definiert. In einer IoT -Sammlung (Internet der Dinge) kann eine Sammlung je nach ausgewählter Partitionierungsstrategie z. B. /deviceid oder vielleicht /region sein. Im Modul zum Design wird die Partitionierungsstrategie ausführlicher erläutert.
  - Dedizierten Durchsatz für diese Sammlung bereitstellen: Der Durchsatz für Ihre Sammlung sollte üblicherweise mit der Option Automatisch skalieren oder Manuell bereitgestellt werden. Diese Einstellung ermöglicht Ihnen die bessere Kontrolle über die Kosten Ihrer einzelnen Sammlungen. Im Modul zum Design wird der Durchsatz ausführlicher erläutert. Aktivieren Sie für den Moment das Kontrollkästchen, und wählen Sie Automatisch skalieren aus.
  - Sammlungsdurchsatz oder Maximale RU/s der Sammlung: Je nachdem, ob Sie Manuell oder Automatisch skalieren ausgewählt haben, müssen Sie einen Wert für Sammlungsdurchsatz oder Maximale RU/s der Sammlung angeben, also den Durchsatzmodus. Der Hauptunterschied besteht darin, dass im Modus Manuell die Menge der ausgewählten RU/s in Rechnung gestellt wird, unabhängig davon, ob Sie sie verwenden. Bei Automatisch skalieren fallen nur Gebühren für den tatsächlichen Verbrauch an, bis die ausgewählten maximalen RU/s erreicht sind. In beiden Fällen beginnt Ihre Sammlung mit der Drosselung, sobald der Durchsatz den ausgewählten Wert erreicht. Übernehmen Sie den vordefinierten Wert für dieses Beispiel.
  - Analysespeicher: Der Azure Cosmos DB-Analysespeicher wird in diesen Lektionen nicht behandelt. Im Artikel Was ist der Azure Cosmos DB-Analysespeicher? finden Sie weitere Informationen zu diesem Thema.
  - Erweitert/Indizierung: Im Modul zum Design werden Indizes ausführlicher erläutert. Lassen Sie das Kontrollkästchen aktiviert.

Jetzt sollten eine Datenbank und eine Sammlung vorhanden sein, mit der eine Verbindung hergestellt werden soll. In der nächsten Einheit wird die Verknüpfung mit einem Konto für die Azure Cosmos DB für MongoDB ausführlicher behandelt. Vorher lernen Sie noch eine weitere Möglichkeit kennen, um Datenbanken und Sammlungen für die Azure Cosmos DB für MongoDB zu erstellen.

Erstellen von oder Verbinden mit einer Datenbank und Sammlung für die Azure Cosmos DB für MongoDB

Sie sollten Ihr Konto für Azure Cosmos DB for MongoDB mit Java, Python, Node.js, .NET oder einer anderen Programmiersprache und einem MongoDB-Treiber erstellen oder verbinden können. Wir stellen einige Funktionen vor, die Sie verwenden würden, um diese Elemente mithilfe verschiedener Sprachen zu erstellen. Zu Beginn dieses Moduls haben Sie angegeben, dass für die Entwicklung weiterhin vertraute MongoDB-Treiber, SDKs und Tools verwendet werden können, um eine Verbindung mit Azure Cosmos DB herzustellen und Apps zu erstellen. Sie nutzen diese Treiber und ihre Eigenschaften und Methoden, um den Zugriff auf und die Vorgänge für das Azure Cosmos DB for MongoDB-Konto zu programmieren.

Erstellen von oder Verbinden mit einer Datenbank für die Azure Cosmos DB für MongoDB

Sie können Ihr bevorzugtes Entwicklungstool verwenden, um Ihre Anwendung für die Azure Cosmos DB für MongoDB zu erstellen. Der MongoDB-Treiber wird in jeder Programmiersprache verwendet, um die Datenbanken und Sammlungen zu erstellen. Mit dem folgenden Code verknüpfen Sie die Konten für die Azure Cosmos DB für MongoDB und stellen eine Verbindung mit der Datenbank products her.

Node.js

import { DefaultAzureCredential, ClientSecretCredential } from "@azure/identity";
const { MongoClient, ObjectId } = require('mongodb');
import axios from "axios";

async function main() {
  // Environment variables
  const endpoint = process.env.AZURE_COSMOS_RESOURCEENDPOINT;
  const listConnectionStringUrl = process.env.AZURE_COSMOS_LISTCONNECTIONSTRINGURL;
  const scope = process.env.AZURE_COSMOS_SCOPE;

  // Uncomment the corresponding lines for the authentication type you want to use.
  // For system-assigned managed identity.
  // const credential = new DefaultAzureCredential();

  // For user-assigned managed identity.
  // const clientId = process.env.AZURE_COSMOS_CLIENTID;
  // const credential = new DefaultAzureCredential({
  //     managedIdentityClientId: clientId
  // });

  // For service principal.
  // const tenantId = process.env.AZURE_COSMOS_TENANTID;
  // const clientId = process.env.AZURE_COSMOS_CLIENTID;
  // const clientSecret = process.env.AZURE_COSMOS_CLIENTSECRET;
  // const credential = new ClientSecretCredential(tenantId, clientId, clientSecret);

  // Acquire the access token
  const accessToken = await credential.getToken(scope);

  // Get the connection string
  const config = {
    method: 'post',
    url: listConnectionStringUrl,
    headers: {
        'Authorization': 'Bearer ${accessToken.token}'
    }
  };
  const response = await axios(config);
  const keysDict = response.data;
  const connectionString = keysDict['connectionStrings'][0]['connectionString'];

  // Connect to Azure Cosmos DB for MongoDB
  const client = new MongoClient(connectionString);

  try {
    // Open the connection
    await client.connect();

    // Connect to the database "products"
    const ProductDatabase = client.db('products');

    // Add code to connect to a collection and add an entry here
  } catch (err) {
    console.error("An error occurred:", err);
  } finally {
    // Close the connection
    await client.close();
  }
}

main().catch((err) => console.error("Unhandled error:", err));

Java

package com.fabrikam;

import com.mongodb.MongoClient;
import com.mongodb.MongoClientURI;
import com.mongodb.client.MongoCollection;
import com.mongodb.client.MongoDatabase;
import com.mongodb.client.model.Filters;
import javax.net.ssl.*;
import java.net.InetSocketAddress;
import com.azure.identity.*;
import com.azure.core.credential.*;
import java.net.http.*;
import java.net.URI;

public class App {
  public static void main(String[] args) {
    // Environment variables
    String endpoint = System.getenv("AZURE_COSMOS_RESOURCEENDPOINT");
    String listConnectionStringUrl = System.getenv("AZURE_COSMOS_LISTCONNECTIONSTRINGURL");
    String scope = System.getenv("AZURE_COSMOS_SCOPE");

    // Uncomment the corresponding lines for the authentication type you want to use.
    // For system-assigned managed identity.
    // DefaultAzureCredential defaultCredential = new DefaultAzureCredentialBuilder().build();

    // For user-assigned managed identity.
    // DefaultAzureCredential defaultCredential = new DefaultAzureCredentialBuilder()
    //     .managedIdentityClientId(System.getenv("AZURE_COSMOS_CLIENTID"))
    //     .build();

    // For service principal.
    // ClientSecretCredential defaultCredential = new ClientSecretCredentialBuilder()
    //     .clientId(System.getenv("AZURE_COSMOS_CLIENTID"))
    //     .clientSecret(System.getenv("AZURE_COSMOS_CLIENTSECRET"))
    //     .tenantId(System.getenv("AZURE_COSMOS_TENANTID"))
    //     .build();

    MongoClient mongoClient = null;

    try {
      // Acquire the access token
      AccessToken accessToken = defaultCredential
          .getToken(new TokenRequestContext().addScopes(scope))
          .block();
      String token = accessToken.getToken();

      // Retrieve the connection string
      HttpClient client = HttpClient.newBuilder().build();
      HttpRequest request = HttpRequest.newBuilder()
          .uri(new URI(listConnectionStringUrl))
          .header("Authorization", "Bearer " + token)
          .POST(HttpRequest.BodyPublishers.noBody())
          .build();
      HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());

      JSONParser parser = new JSONParser();
      JSONObject responseBody = parser.parse(response.body());
      List<Map<String, String>> connectionStrings = responseBody.get("connectionStrings");
      String connectionString = connectionStrings.get(0).get("connectionString");

      // Connect to Azure Cosmos DB for MongoDB
      MongoClientURI uri = new MongoClientURI(connectionString);
      mongoClient = new MongoClient(uri);

      // Connect to the database
      MongoDatabase ProductDatabase = mongoClient.getDatabase("products");

      // Add code to connect to a collection and add an entry here

    } catch (Exception e) {
      e.printStackTrace();
    } finally {
      if (mongoClient != null) {
        mongoClient.close();
      }
    }
  }
}

Python

import os
import pymongo
import requests
from azure.identity import ManagedIdentityCredential, ClientSecretCredential

# Environment variables
endpoint = os.getenv('AZURE_COSMOS_RESOURCEENDPOINT')
listConnectionStringUrl = os.getenv('AZURE_COSMOS_LISTCONNECTIONSTRINGURL')
scope = os.getenv('AZURE_COSMOS_SCOPE')

# Uncomment the following lines corresponding to the authentication type you want to use.
# For system-assigned managed identity
# cred = ManagedIdentityCredential()

# For user-assigned managed identity
# managed_identity_client_id = os.getenv('AZURE_COSMOS_CLIENTID')
# cred = ManagedIdentityCredential(client_id=managed_identity_client_id)

# For service principal
# tenant_id = os.getenv('AZURE_COSMOS_TENANTID')
# client_id = os.getenv('AZURE_COSMOS_CLIENTID')
# client_secret = os.getenv('AZURE_COSMOS_CLIENTSECRET')
# cred = ClientSecretCredential(tenant_id=tenant_id, client_id=client_id, client_secret=client_secret)

# Get the connection string
session = requests.Session()
token = cred.get_token(scope)
response = session.post(listConnectionStringUrl, headers={"Authorization": "Bearer {}".format(token.token)})
keys_dict = response.json()
conn_str = keys_dict["connectionStrings"][0]["connectionString"]

# Connect to Azure Cosmos DB for MongoDB
client = pymongo.MongoClient(conn_str)

# To connect to the database, use the connection variable ("client" in this case), and the database name
ProductDatabase = client["products"]

# Add code to connect to a collection and add an entry here

using MongoDB.Driver;
using Azure.Identity;
using Azure.Core;
using System;
using System.Net.Http;
using System.Text.Json;
using System.Collections.Generic;
using System.Threading.Tasks;

public class Products
{
  public int ProductId { get; set; }
  public string name { get; set; }
}

class test
{
  public static async Task Main(string[] args)
  {
      // Environment variables
      var endpoint = Environment.GetEnvironmentVariable("AZURE_COSMOS_RESOURCEENDPOINT");
      var listConnectionStringUrl = Environment.GetEnvironmentVariable("AZURE_COSMOS_LISTCONNECTIONSTRINGURL");
      var scope = Environment.GetEnvironmentVariable("AZURE_COSMOS_SCOPE");

      // Uncomment the corresponding lines for the authentication type you want to use.
      // For system-assigned identity.
      // var tokenProvider = new DefaultAzureCredential();

      // For user-assigned identity.
      // var tokenProvider = new DefaultAzureCredential(
      //     new DefaultAzureCredentialOptions
      //     {
      //         ManagedIdentityClientId = Environment.GetEnvironmentVariable("AZURE_COSMOS_CLIENTID")
      //     });

      // For service principal.
      // var tenantId = Environment.GetEnvironmentVariable("AZURE_COSMOS_TENANTID");
      // var clientId = Environment.GetEnvironmentVariable("AZURE_COSMOS_CLIENTID");
      // var clientSecret = Environment.GetEnvironmentVariable("AZURE_COSMOS_CLIENTSECRET");
      // var tokenProvider = new ClientSecretCredential(tenantId, clientId, clientSecret);

      // Acquire the access token.
      AccessToken accessToken = await tokenProvider.GetTokenAsync(
          new TokenRequestContext(scopes: new[] { scope }));

      // Get the connection string.
      using var httpClient = new HttpClient();
      httpClient.DefaultRequestHeaders.Add("Authorization", $"Bearer {accessToken.Token}");
      var response = await httpClient.PostAsync(listConnectionStringUrl, null);
      response.EnsureSuccessStatusCode();
      var responseBody = await response.Content.ReadAsStringAsync();

      // Parse the connection string.
      var connectionStrings = JsonSerializer.Deserialize<Dictionary<string, List<Dictionary<string, string>>>>(responseBody);
      string connectionString = connectionStrings["connectionStrings"][0]["connectionString"];

      // Initialize the MongoClient with the connection string.
      var mongoClient = new MongoClient(connectionString);

      // Connect to the "products" database.
      var ProductDatabase = mongoClient.GetDatabase("products");

      // Add code to connect to a collection and add an entry here.
  }
}

Das ist also ganz einfach. Nachdem die Verbindung über den Treiber hergestellt wurde, können Sie eine neue Datenbank erstellen oder mit GetDatabase oder einer ähnlichen Methode (je nach Sprache) auf eine vorhandene verweisen. Die Anwendung kann jetzt die Variable ProductDatabase verwenden, um auf die gewünschte Datenbank zu verweisen. Das Erstellen oder Herstellen einer Verbindung mit einer Sammlung ist so einfach wie das Erstellen einer neuen Datenbank.

Erstellen einer Sammlung für die Azure Cosmos DB für MongoDB

Um eine Sammlung zu erstellen oder auf eine vorhandene zuzugreifen, verwenden Sie je nach Programmiersprache eine Methode für den Sammlungsabruf oder einen Verweis. Fügen Sie nun Code zum vorherigen Beispiel hinzu, um eine Sammlung zu erstellen oder eine Verbindung mit einer Sammlung herzustellen und dieser Sammlung einen Eintrag hinzuzufügen.

Node.js

          // Add code to connect to a collection and add and find an entry here 
          var collection = ProductDatabase.collection('documents');
          var insertResult = await collection.insertOne({ ProductId: 1, name: "bread" });

          // return data where ProductId = 1
          const findProduct = await collection.find({ProductId: 1});
          await findProduct.forEach(console.log);

Java

          // Add code to connect to a collection and add and find an entry here 
          MongoCollection collection = ProductDatabase.getCollection("products");

          collection.insertOne(new Document()
                      .append("ProductId", 1)
                      .append("name", "bread"));

          // return data where ProductId = 1
          Document findProduct = (Document) collection.find(eq("ProductId", 1)).first();
          System.out.println(findProduct.toJson());

Python

# Add code to connect to a collection and add an entry here 
collection = ProductDatabase["products"]
collection.insert_one({ "ProductId": 1, "name": "bread" })

    // Add code to connect to a collection and add an entry here 
    var ProductCollection = ProductDatabase.GetCollection<Products>("products");

    Products Product = new Products {ProductId=1,name="bread"};
    ProductCollection.InsertOne (Product);

In der nächsten Einheit erfahren Sie, wie genau unsere Verbindungszeichenfolge erstellt wurde.

Verwenden von MongoDB-Erweiterungsbefehlen zum Verwalten von Daten in der API für MongoDB von Azure Cosmos DB

Wie bereits erwähnt wurde, ermöglicht es die Azure Cosmos DB für MongoDB, dieselben Treiber und denselben Code zu verwenden, die Sie verwendet haben, um Objekte für das Azure Cosmos DB-Konto auf einem MongoDB-Server zu erstellen und auf diese zuzugreifen. Bei diesem Code zum Erstellen der Datenbanken und Sammlungen werden jedoch die Standarderstellungsparameter von Azure Cosmos DB verwendet. Um Azure Cosmos DB-Features nutzen zu können, müssen Sie die Erstellungsparameter für Datenbanken und Sammlungen wie den Durchsatz, die automatische Skalierung und die Zuweisung von Shardschlüsseln kontrollieren und Indizes definieren können. Die Azure Cosmos DB für MongoDB ermöglicht das über Erweiterungsbefehle zur Definition dieser Parameter. Mithilfe dieser Befehle können Sie präzisere Anweisungen zur Erstellung oder Bearbeitung von Datenbanken und Sammlungen programmieren, die speziell für Azure Cosmos DB gelten.

Die Azure Cosmos DB für MongoDB enthält Erweiterungsbefehle für die folgenden Anforderungstypen:

Erstellen einer Datenbank
Aktualisieren der Datenbank
Abrufen der Datenbank
Erstellen der Sammlung
Aktualisieren der Sammlung
Abrufen der Sammlung

Die MongoDB-Treiber bieten eine Funktion zum Ausführen eines Befehls für eine Datenbank. Mit dieser Funktion senden Sie die Erweiterungsbefehle an Azure Cosmos DB. Sehen Sie sich nun den Code für die Erstellung einer Sammlung für IoT-Geräte mit einem Durchsatz von 2.000 RUs (Request Unit, Anforderungseinheit) und dem Shardschlüssel „DeviceId“ an.

Node.js

    // create the Devices collection with a throughput of 2000 RUs and with DeviceId as the sharding key
    var result = IOTDatabase.command({customAction: "CreateCollection", collection: "Devices", offerThroughput: 2000, shardKey: "DeviceId"});

Java

      // create the Devices collection with a throughput of 2000 RUs and with DeviceId as the sharding key
      Document DevCollectionDef = new Document();
      DevCollectionDef.append("customAction", "CreateCollection");
      DevCollectionDef.append("collection", "Devices");
      DevCollectionDef.append("offerThroughput", 2000);
      DevCollectionDef.append("shardKey", "DeviceId");

      Document result = IOTDatabase.runCommand(DevCollectionDef);

Python

      # create the Devices collection with a throughput of 2000 RUs and with DeviceId as the sharding key
      IOTDatabase.command({'customAction': "CreateCollection", 'collection': "Devices", 'offerThroughput': 2000, 'shardKey': "DeviceId"})

      // create the Devices collection with a throughput of 1000 RUs and with EmployeeId as the sharding key
      var result = IOTDatabase.RunCommand<BsonDocument>(@"{customAction: ""CreateCollection"", collection: ""Devices"", offerThroughput: 2000, shardKey: ""DeviceId""}");

Auf ähnliche Weise können Sie eine Sammlung bearbeiten oder eine Datenbank erstellen oder bearbeiten. Im Artikel Verwenden von MongoDB-Erweiterungsbefehlen zum Verwalten von gespeicherten Daten in der Azure Cosmos DB-API für MongoDB finden Sie weitere Informationen.

Erstellen eines Kontos, einer Datenbank und einer Sammlung mithilfe von Azure Cosmos DB for MongoDB

Erstellen eines Kontos, einer Datenbank und eines Containers für Azure Cosmos DB for MongoDB über das Azure-Portal

Erstellen Sie ein Konto für Azure Cosmos DB for MongoDB

Erstellen einer Datenbank und eines Containers für die Azure Cosmos DB für MongoDB

Erstellen von oder Verbinden mit einer Datenbank und Sammlung für die Azure Cosmos DB für MongoDB

Erstellen von oder Verbinden mit einer Datenbank für die Azure Cosmos DB für MongoDB

Erstellen einer Sammlung für die Azure Cosmos DB für MongoDB

Verwenden von MongoDB-Erweiterungsbefehlen zum Verwalten von Daten in der API für MongoDB von Azure Cosmos DB

Feedback