Ein häufiger Anwendungsfall für den Emulator besteht darin, als Entwicklungsdatenbank zu dienen, während Sie Ihre Anwendungen erstellen. Die Verwendung des Emulators für die Entwicklung kann Ihnen helfen, die Merkmale des Erstellens und Modellierens von Daten für eine Datenbank wie Azure Cosmos DB zu erlernen, ohne dass Dienstkosten anfallen. Darüber hinaus kann die Verwendung des Emulators als Teil eines Automatisierungsworkflows sicherstellen, dass Sie dieselbe Suite von Integrationstests ausführen können. Sie können sicherstellen, dass dieselben Tests sowohl lokal auf Ihrem Entwicklungscomputer als auch remote in einem Continuous Integration-Auftrag ausgeführt werden.
Voraussetzungen
- .NET 6 oder höher, Node.js v20 oder höher oder Python 3.7 oder höher
- Stellen Sie sicher, dass alle erforderlichen ausführbaren Dateien in Ihrer
PATH
verfügbar sind.
- Windows-Emulator
- 64-Bit-Windows Server 2016, 2019, Windows 10 oder Windows 11.
- Mindestanforderungen für Hardware:
- 2 GB RAM
- 10 GB verfügbarer Speicherplatz
- Docker-Emulator
Installieren des Emulators
Es gibt mehrere Varianten des Emulators, und jede Variante hat einen relativ reibungslosen Installationsprozess.
Rufen Sie zunächst die Linux-Variante des Containerimages aus dem Microsoft Container Registry (MCR) ab.
Pullen Sie das mcr.microsoft.com/cosmosdb/linux/azure-cosmos-emulator
Linux-Containerimage aus der Containerregistrierung auf den lokalen Docker-Host.
docker pull mcr.microsoft.com/cosmosdb/linux/azure-cosmos-emulator:latest
Stellen Sie sicher, dass das Emulatorimage auf Ihrem lokalen Docker-Host verfügbar ist.
docker images
Rufen Sie zunächst die Windows-Variante des Containerimages aus dem Microsoft Container Registry (MCR) ab.
Pullen Sie das mcr.microsoft.com/cosmosdb/windows/azure-cosmos-emulator
Windows-Containerimage aus der Containerregistrierung auf den lokalen Docker-Host.
docker pull mcr.microsoft.com/cosmosdb/windows/azure-cosmos-emulator
Stellen Sie sicher, dass das Emulatorimage auf Ihrem lokalen Docker-Host verfügbar ist.
docker images
Laden Sie zunächst die neueste Version des Azure Cosmos DB-Emulators auf Ihren lokalen Computer herunter, und installieren Sie sie.
Tipp
Im Artikel Emulator: Versionshinweise sind alle verfügbaren Versionen und die Funktionsupdates in denen einzelnen Versionen aufgeführt.
Laden Sie den Azure Cosmos DB-Emulator herunter.
Führen Sie das Installationsprogramm auf Ihrem lokalen Computer mit Administratorrechten aus.
Der Emulator installiert automatisch die entsprechenden Entwicklerzertifikate und konfiguriert Firewallregeln auf Ihrem lokalen Computer.
Rufen Sie zunächst die Linux-Variante des Containerimages aus dem Microsoft Container Registry (MCR) ab.
Pullen Sie das mcr.microsoft.com/cosmosdb/linux/azure-cosmos-emulator
Linux-Containerimage mit dem mongodb
-Tag aus der Containerregistrierung auf den lokalen Docker-Host.
docker pull mcr.microsoft.com/cosmosdb/linux/azure-cosmos-emulator:mongodb
Stellen Sie sicher, dass das Emulatorimage auf Ihrem lokalen Docker-Host verfügbar ist.
docker images
Das Docker (Windows)-Containerimage unterstützt die API für MongoDB nicht.
Laden Sie zunächst die neueste Version des Azure Cosmos DB-Emulators auf Ihren lokalen Computer herunter, und installieren Sie sie.
Tipp
Im Artikel Emulator: Versionshinweise sind alle verfügbaren Versionen und die Funktionsupdates in denen einzelnen Versionen aufgeführt.
Laden Sie den Azure Cosmos DB-Emulator herunter.
Führen Sie das Installationsprogramm auf Ihrem lokalen Computer mit Administratorrechten aus.
Der Emulator installiert automatisch die entsprechenden Entwicklerzertifikate und konfiguriert Firewallregeln auf Ihrem lokalen Computer.
Die Docker-Containervariante (Linux oder Windows) des Emulators unterstützt die API für Apache Cassandra, API für Apache Gremlin oder API für Table nicht.
Laden Sie zunächst die neueste Version des Azure Cosmos DB-Emulators auf Ihren lokalen Computer herunter, und installieren Sie sie.
Tipp
Im Artikel Emulator: Versionshinweise sind alle verfügbaren Versionen und die Funktionsupdates in denen einzelnen Versionen aufgeführt.
Laden Sie den Azure Cosmos DB-Emulator herunter.
Führen Sie das Installationsprogramm auf Ihrem lokalen Computer mit Administratorrechten aus.
Der Emulator installiert automatisch die entsprechenden Entwicklerzertifikate und konfiguriert Firewallregeln auf Ihrem lokalen Computer.
Starten des Emulators
Starten Sie nach dem Herunterladen den Emulator mit aktivierter angegebener API.
Die Docker-Containervariante des Emulators unterstützt die API für Apache Cassandra nicht.
Starten Sie die ausführbare Datei (Microsoft.Azure.Cosmos.Emulator.exe
) des Emulators unter dem %ProgramFiles%\Azure Cosmos DB Emulator
-Pfad. Verwenden Sie die folgenden Parameter, um den Emulator zu konfigurieren:
|
Beschreibung |
EnableCassandraEndpoint |
Aktiviert den Endpunkt der API für Apache Cassandra. |
CassandraPort |
Die für den Endpunkt zu verwendende Portnummer. |
Microsoft.Azure.Cosmos.Emulator.exe /EnableCassandraEndpoint /CassandraPort=65200
Der Emulator öffnet den Daten-Explorer automatisch mithilfe der URL https://localhost:8081/_explorer/index.html
.
Die Docker-Containervariante des Emulators unterstützt die API für Apache Gremlin nicht.
Starten Sie die ausführbare Datei (Microsoft.Azure.Cosmos.Emulator.exe
) des Emulators unter dem %ProgramFiles%\Azure Cosmos DB Emulator
-Pfad. Verwenden Sie die folgenden Parameter, um den Emulator zu konfigurieren:
|
Beschreibung |
EnableGremlinEndpoint |
Aktiviert die API für den Apache Gremlin-Endpunkt. |
GremlinPort |
Die für den Endpunkt zu verwendende Portnummer. |
Microsoft.Azure.Cosmos.Emulator.exe /EnableGremlinEndpoint /GremlinPort=65400
Der Emulator öffnet den Daten-Explorer automatisch mithilfe der URL https://localhost:8081/_explorer/index.html
.
Die Docker-Containervariante des Emulators unterstützt die API für Table nicht.
Starten Sie die ausführbare Datei (Microsoft.Azure.Cosmos.Emulator.exe
) des Emulators unter dem %ProgramFiles%\Azure Cosmos DB Emulator
-Pfad. Verwenden Sie die folgenden Parameter, um den Emulator zu konfigurieren:
|
Beschreibung |
EnableTableEndpoint |
Aktiviert die API für den Table-Endpunkt. |
TablePort |
Die für den Endpunkt zu verwendende Portnummer. |
Microsoft.Azure.Cosmos.Emulator.exe /EnableTableEndpoint /TablePort=65500
Der Emulator öffnet den Daten-Explorer automatisch mithilfe der URL https://localhost:8081/_explorer/index.html
.
Führen Sie einen neuen Container mit dem Containerimage und der folgenden Konfiguration aus:
|
Beschreibung |
AZURE_COSMOS_EMULATOR_PARTITION_COUNT (Optional) |
Geben Sie die Anzahl der zu verwendenden Partitionen an. |
AZURE_COSMOS_EMULATOR_ENABLE_DATA_PERSISTENCE (Optional) |
Aktivieren Sie die Datenpersistenz zwischen Emulatorausführungen. |
AZURE_COSMOS_EMULATOR_IP_ADDRESS_OVERRIDE (Optional) |
Überschreiben Sie die Standard-IP-Adresse des Emulators. |
Verwenden Sie für Linux-Systeme Folgendes:
docker run \
--publish 8081:8081 \
--publish 10250-10255:10250-10255 \
--name linux-emulator \
--detach \
mcr.microsoft.com/cosmosdb/linux/azure-cosmos-emulator:latest
Verwenden Sie für Windows-Systeme Folgendes:
$parameters = @(
"--publish", "8081:8081"
"--publish", "10250-10255:10250-10255"
"--name", "windows-emulator"
"--detach"
)
docker run @parameters mcr.microsoft.com/cosmosdb/linux/azure-cosmos-emulator:latest
Navigieren Sie zu https://localhost:8081/_explorer/index.html
, um auf den Daten-Explorer zuzugreifen.
Erstellen eines neuen Verzeichnisses für die Bindungsbereitstellung
Führen Sie einen neuen Container mithilfe des Containerimages aus.
$parameters = @(
"--publish", "8081:8081"
"--publish", "10250-10255:10250-10255"
"--name", "windows-emulator"
"--detach"
)
docker run @parameters mcr.microsoft.com/cosmosdb/windows/azure-cosmos-emulator
Navigieren Sie zu https://localhost:8081/_explorer/index.html
, um auf den Daten-Explorer zuzugreifen.
Starten Sie den Emulator, indem Sie die Anwendung im Windows-Startmenü auswählen.
Alternativ können Sie die ausführbare Datei (Microsoft.Azure.Cosmos.Emulator.exe
) des Emulators am %ProgramFiles%\Azure Cosmos DB Emulator
-Pfad starten.
Außerdem können Sie den Emulator über die Befehlszeile starten. Verwenden Sie die folgenden Parameter, um den Emulator zu konfigurieren:
|
Beschreibung |
Port |
Portnummer, die für die API für NoSQL verwendet werden soll. |
Microsoft.Azure.Cosmos.Emulator.exe /Port=65000
Der Emulator öffnet den Daten-Explorer automatisch mithilfe der URL https://localhost:8081/_explorer/index.html
.
Führen Sie einen neuen Container mit dem Containerimage und der folgenden Konfiguration aus:
|
Beschreibung |
AZURE_COSMOS_EMULATOR_ENABLE_MONGODB_ENDPOINT |
Geben Sie die Version des zu verwendenden MongoDB-Endpunkts an. Zu den unterstützten Endpunkten gehören: 3.2 , 3.6 oder 4.0 . |
AZURE_COSMOS_EMULATOR_PARTITION_COUNT (Optional) |
Geben Sie die Anzahl der zu verwendenden Partitionen an. |
AZURE_COSMOS_EMULATOR_ENABLE_DATA_PERSISTENCE (Optional) |
Aktivieren Sie die Datenpersistenz zwischen Emulatorausführungen. |
AZURE_COSMOS_EMULATOR_IP_ADDRESS_OVERRIDE (Optional) |
Überschreiben Sie die Standard-IP-Adresse des Emulators. |
Verwenden Sie für Linux-Systeme Folgendes:
docker run \
--publish 8081:8081 \
--publish 10250:10250 \
--env AZURE_COSMOS_EMULATOR_ENABLE_MONGODB_ENDPOINT=4.0 \
--name linux-emulator \
--detach \
mcr.microsoft.com/cosmosdb/linux/azure-cosmos-emulator:mongodb
Verwenden Sie für Windows-Systeme Folgendes:
$parameters = @(
"--publish", "8081:8081"
"--publish", "10250:10250"
"--env", "AZURE_COSMOS_EMULATOR_ENABLE_MONGODB_ENDPOINT=4.0"
"--name", "windows-emulator"
"--detach"
)
docker run @parameters mcr.microsoft.com/cosmosdb/linux/azure-cosmos-emulator:mongodb
Navigieren Sie zu https://localhost:8081/_explorer/index.html
, um auf den Daten-Explorer zuzugreifen.
Das Docker (Windows)-Containerimage unterstützt die API für MongoDB nicht.
Starten Sie die ausführbare Datei (Microsoft.Azure.Cosmos.Emulator.exe
) des Emulators unter dem %ProgramFiles%\Azure Cosmos DB Emulator
-Pfad. Verwenden Sie die folgenden Parameter, um den Emulator zu konfigurieren:
|
Beschreibung |
EnableMongoDbEndpoint |
Aktiviert den Endpunkt der API für MongoDB bei der angegebenen MongoDB-Version. |
MongoPort |
Die für den Endpunkt zu verwendende Portnummer. |
Microsoft.Azure.Cosmos.Emulator.exe /EnableMongoDbEndpoint=4.0 /MongoPort=65200
Hinweis
Weitere Informationen zu Befehlszeilenargumenten und MongoDB-Versionen, die vom Emulator unterstützt werden, finden Sie unter Befehlszeilenparameter.
Der Emulator öffnet den Daten-Explorer automatisch mithilfe der URL https://localhost:8081/_explorer/index.html
.
Importieren des TLS-/SSL-Zertifikats des Emulators
Importieren Sie das TLS-/SSL Zertifikat des Emulators, um den Emulator mit Ihrem bevorzugten Entwickler-SDK zu verwenden, ohne TLS/SSL auf dem Client zu deaktivieren.
Die Docker-Containervariante (Linux oder Windows) des Emulators unterstützt die API für Apache Cassandra, API für Apache Gremlin oder API für Table nicht.
Die lokale Windows-Installation des Emulators importiert automatisch die TLS/SSL-Zertifikate. Weitere Schritte sind nicht erforderlich.
Das Zertifikat für den Emulator ist unter dem Pfad _explorer/emulator.pem
des laufenden Containers verfügbar. Verwenden Sie curl
, um das Zertifikat aus dem laufenden Container auf Ihren lokalen Computer herunterzuladen.
Rufen Sie das Zertifikat aus dem Container, der gerade ausgeführt wird, ab.
Verwenden Sie für Linux-Systeme Folgendes:
curl --insecure https://localhost:8081/_explorer/emulator.pem > ~/emulatorcert.crt
Verwenden Sie für Windows-Systeme Folgendes:
$parameters = @{
Uri = 'https://localhost:8081/_explorer/emulator.pem'
Method = 'GET'
OutFile = 'emulatorcert.crt'
SkipCertificateCheck = $True
}
Invoke-WebRequest @parameters
Generieren Sie das Zertifikatpaket mit dem entsprechenden Befehl für Ihr Betriebssystem neu.
Verwenden Sie für Debian-basierte Linux-Systeme (z. B. Ubuntu) Folgendes:
sudo update-ca-certificates
Verwenden Sie für Red Hat-basierte Linux-Systeme (z. B. CentOS, Fedora) Folgendes:
sudo update-ca-trust
Verwenden Sie für Windows-Systeme Folgendes:
certutil -f -addstore "Root" ~/emulatorcert.crt
Ausführlichere Anweisungen finden Sie in der Dokumentation zu Ihrem Linux-Betriebssystem.
Das Docker (Windows)-Containerimage unterstützt die API für MongoDB nicht.
Die lokale Windows-Installation des Emulators importiert automatisch die TLS/SSL-Zertifikate. Weitere Schritte sind nicht erforderlich.
Das Zertifikat für den Emulator ist unter dem Pfad /_explorer/emulator.pem
des laufenden Containers verfügbar.
Laden Sie das Zertifikat aus dem laufenden Container auf Ihren lokalen Computer herunter.
Verwenden Sie für Linux-Systeme Folgendes:
curl --insecure https://localhost:8081/_explorer/emulator.pem > ~/emulatorcert.crt
Verwenden Sie für Windows-Systeme Folgendes:
$parameters = @{
Uri = 'https://localhost:8081/_explorer/emulator.pem'
Method = 'GET'
OutFile = 'emulatorcert.crt'
SkipCertificateCheck = $True
}
Invoke-WebRequest @parameters
Hinweis
Möglicherweise müssen Sie den Host (oder die IP-Adresse) und die Portnummer ändern, wenn Sie diese Werte zuvor geändert haben.
Installieren Sie das Zertifikat gemäß dem Prozess, der normalerweise für Ihr Betriebssystem verwendet wird. Unter Linux würden Sie das Zertifikat beispielsweise in den /usr/local/share/ca-certificates/
-Pfad kopieren.
Verwenden Sie für Linux-Systeme Folgendes:
cp ~/emulatorcert.crt /usr/local/share/ca-certificates/
Verwenden Sie für Windows-Systeme Folgendes:
$parameters = @{
FilePath = 'emulatorcert.crt'
CertStoreLocation = 'Cert:\CurrentUser\Root'
}
Import-Certificate @parameters
Für Linux-Systeme generieren Sie das Zertifikatpaket mithilfe des entsprechenden Befehls für Ihre Linux-Distribution neu.
Verwenden Sie für Debian-basierte Linux-Systeme (z. B. Ubuntu) Folgendes:
sudo update-ca-certificates
Verwenden Sie für Red Hat-basierte Linux-Systeme (z. B. CentOS, Fedora) Folgendes:
sudo update-ca-trust
Ausführlichere Anweisungen finden Sie in der Dokumentation zu Ihrem Linux-Betriebssystem.
Das Zertifikat für den Emulator ist im Ordner C:\CosmosDB.Emulator\bind-mount
des laufenden Containers verfügbar. Der Ordner enthält auch ein Skript zum automatischen Installieren des Zertifikats.
Verwenden Sie docker cp
, um den gesamten Ordner auf Ihren lokalen Computer zu kopieren.
docker cp windows-emulator:C:\CosmosDB.Emulator\bind-mount .
Führen Sie das Skript importcert.ps1 im Ordner aus.
.\bind-mount\importcert.ps1
Die lokale Windows-Installation des Emulators importiert automatisch die TLS/SSL-Zertifikate. Weitere Schritte sind nicht erforderlich.
Herstellen einer Verbindung mit dem Emulator über das SDK
Jedes SDK enthält eine Clientklasse, die normalerweise verwendet wird, um das SDK mit Ihrem Azure Cosmos DB-Konto zu verbinden. Mithilfe der Anmeldeinformationen des Emulators können Sie stattdessen das SDK mit der Emulatorinstanz verbinden.
Verwenden Sie die Azure Cosmos DB-API für NoSQL .NET SDK, um über eine .NET-Anwendung eine Verbindung mit dem Emulator herzustellen.
Starten Sie in einem leeren Ordner.
Erstellen einer neuen .NET-Konsolenanwendung
dotnet new console
Fügen Sie das Microsoft.Azure.Cosmos
-Paket aus NuGet hinzu.
dotnet add package Microsoft.Azure.Cosmos
Öffnen Sie die Datei Program.cs.
Löschen Sie alle vorhandenen Inhalte in der Datei.
Fügen Sie einen using-Block für den Microsoft.Azure.Cosmos
-Namespace hinzu.
using Microsoft.Azure.Cosmos;
Erstellen Sie unter Verwendung der Anmeldeinformationen des Emulators eine neue Instanz von CosmosClient.
using CosmosClient client = new(
accountEndpoint: "https://localhost:8081/",
authKeyOrResourceToken: "C2y6yDjf5/R+ob0N8A7Cgv30VRDJIWEHLM+4QDU5DE2nQ9nDuVTqobD4b8mGGyPMbIZnqyMsEcaGQy67XIw/Jw=="
);
Erstellen Sie eine neue Datenbank und einen Container mithilfe von CreateDatabaseIfNotExistsAsync und CreateContainerIfNotExistsAsync.
Database database = await client.CreateDatabaseIfNotExistsAsync(
id: "cosmicworks",
throughput: 400
);
Container container = await database.CreateContainerIfNotExistsAsync(
id: "products",
partitionKeyPath: "/id"
);
Erstellen Sie mithilfe von UpsertItemAsync ein neues Element im Container.
var item = new
{
id = "68719518371",
name = "Kiama classic surfboard"
};
await container.UpsertItemAsync(item);
Führen Sie die .NET-Anwendung aus.
dotnet run
Warnung
Wenn sie einen SSL-Fehler erhalten, müssen Sie möglicherweise TLS/SSL für Ihre Anwendung deaktivieren. Dies tritt häufig auf, wenn Sie auf Ihrem lokalen Computer entwickeln, den Azure Cosmos DB-Emulator in einem Container verwenden und das SSL-Zertifikat des Containers nicht importiert haben. Um dies zu beheben, konfigurieren Sie die Optionen des Clients zum Deaktivieren der TLS/SSL-Validierung, bevor Sie den Client erstellen:
CosmosClientOptions options = new ()
{
HttpClientFactory = () => new HttpClient(new HttpClientHandler()
{
ServerCertificateCustomValidationCallback = HttpClientHandler.DangerousAcceptAnyServerCertificateValidator
}),
ConnectionMode = ConnectionMode.Gateway,
};
using CosmosClient client = new(
...,
...,
clientOptions: options
);
Verwenden Sie die Azure Cosmos DB-API für NoSQL Python SDK, um über eine Python-Anwendung eine Verbindung mit dem Emulator herzustellen.
Starten Sie in einem leeren Ordner.
Importieren Sie das azure-cosmos
-Paket aus dem Python-Paketindex.
pip install azure-cosmos
Erstellen Sie die Datei app.py.
Importieren Sie CosmosClient
und PartitionKey
aus dem Modul azure.cosmos
.
from azure.cosmos import CosmosClient, PartitionKey
Erstellen Sie einen neuen CosmosClient mit den Anmeldeinformationen des Emulators.
client = CosmosClient(
url="<https://localhost:8081>",
credential=(
"C2y6yDjf5/R+ob0N8A7Cgv30VRDJIWEHLM+4QDU5DE2nQ9nDuVTqobD4b8mGG"
"yPMbIZnqyMsEcaGQy67XIw/Jw=="
),
)
Erstellen Sie eine neue Datenbank und einen Container mithilfe von create_database_if_not_exists und create_container_if_not_exists.
database = client.create_database_if_not_exists(
id="cosmicworks",
offer_throughput=400,
)
container = database.create_container_if_not_exists(
id="products",
partition_key=PartitionKey(
path="/id",
),
)
Erstellen Sie mithilfe von upsert_item ein neues Element im Container.
item = {"id": "68719518371", "name": "Kiama classic surfboard"}
container.upsert_item(item)
Führen Sie die Python-Anwendung aus.
python app.py
Warnung
Wenn ein SSL-Fehler gemeldet wird, müssen Sie möglicherweise TLS/SSL für Ihre Anwendung deaktivieren. Dies tritt häufig auf, wenn Sie auf Ihrem lokalen Computer entwickeln, den Azure Cosmos DB-Emulator in einem Container verwenden und das SSL-Zertifikat des Containers nicht importiert haben. Um dies zu beheben, konfigurieren Sie die Anwendung so, dass die TLS/SSL-Validierung deaktiviert wird, bevor Sie den Client erstellen:
import urllib3
urllib3.disable_warnings()
Wenn weiterhin SSL-Fehler auftreten, ist es möglich, dass Python die Zertifikate aus einem anderen Zertifikatspeicher abruft. Führen Sie die folgenden Schritte aus, um den Pfad zu ermitteln, in dem Python nach den Zertifikaten sucht:
Wichtig
Wenn Sie eine virtuelle Umgebung (venv) von Python verwenden, stellen Sie sicher, dass sie aktiviert ist, bevor Sie die Befehle ausführen!
Öffnen Sie ein Terminal.
Starten Sie den Python-Interpreter, indem Sie python oder python3 eingeben, je nach Python-Version.
Führen Sie im Python-Interpreter die folgenden Befehle aus:
from requests.utils import DEFAULT_CA_BUNDLE_PATH
print(DEFAULT_CA_BUNDLE_PATH)
Innerhalb einer virtuellen Umgebung kann der Pfad (zumindest in Ubuntu) wie folgt lauten:
path/to/venv/lib/pythonX.XX/site-packages/certifi/cacert.pem
Außerhalb einer virtuellen Umgebung kann der Pfad (zumindest in Ubuntu) wie folgt lauten:
/etc/ssl/certs/ca-certificates.crt
Nachdem Sie DEFAULT_CA_BUNDLE_PATH identifiziert haben, öffnen Sie ein neues Terminal, und führen Sie die folgenden Befehle aus, um das Emulatorzertifikat an das Zertifikatpaket anzufügen:
Wichtig
Wenn die Variable DEFAULT_CA_BUNDLE_PATH auf ein Systemverzeichnis verweist, tritt möglicherweise der Fehler „Berechtigung verweigert“ auf. In diesem Fall müssen Sie die Befehle mit erhöhten Rechten (als Stamm) ausführen. Außerdem müssen Sie nach dem Ausführen der bereitgestellten Befehle das Zertifikatpaket aktualisieren und neu generieren.
# Add a new line to the certificate bundle
echo >> /path/to/ca_bundle
# Append the emulator certificate to the certificate bundle
cat /path/to/emulatorcert.crt >> /path/to/ca_bundle
Verwenden Sie die Azure Cosmos DB-API für NoSQL Node.js SDK, um eine Verbindung mit dem Emulator über eine Node.js/JavaScript-Anwendung herzustellen.
Starten Sie in einem leeren Ordner.
Initialisieren Sie ein neues Modul.
npm init es6 --yes
Installieren Sie das @azure/cosmos
-Paket über den Node-Paket-Manager.
npm install --save @azure/cosmos
Erstellen Sie die Datei app.js.
Importieren Sie den CosmosClient
-Typ aus dem @azure/cosmos
-Modul.
import { CosmosClient } from '@azure/cosmos'
Verwenden Sie CosmosClient
, um eine neue Clientinstanz mit den Anmeldeinformationen des Emulators zu erstellen.
const cosmosClient = new CosmosClient({
endpoint: 'https://localhost:8081/',
key: 'C2y6yDjf5/R+ob0N8A7Cgv30VRDJIWEHLM+4QDU5DE2nQ9nDuVTqobD4b8mGGyPMbIZnqyMsEcaGQy67XIw/Jw=='
})
Verwenden Sie Databases.createIfNotExists
und Containers.createIfNotExists
, um eine Datenbank und einen Container zu erstellen.
const { database } = await cosmosClient.databases.createIfNotExists({
id: 'cosmicworks',
throughput: 400
})
const { container } = await database.containers.createIfNotExists({
id: 'products',
partitionKey: {
paths: [
'/id'
]
}
})
Führen Sie einen Upsert eines neuen Elements mithilfe von Items.upsert
aus.
const item = {
id: '68719518371',
name: 'Kiama classic surfboard'
}
container.items.upsert(item)
Führen Sie die Node.js-Anwendung aus.
node app.js
Warnung
Wenn sie einen SSL-Fehler erhalten, müssen Sie möglicherweise TLS/SSL für Ihre Anwendung deaktivieren. Dies tritt häufig auf, wenn Sie auf Ihrem lokalen Computer entwickeln, den Azure Cosmos DB-Emulator in einem Container verwenden und das SSL-Zertifikat des Containers nicht importiert haben. Um dies zu beheben, konfigurieren Sie die Anwendung so, dass die TLS/SSL-Validierung deaktiviert wird, bevor Sie den Client erstellen:
process.env.NODE_TLS_REJECT_UNAUTHORIZED = 0
Verwenden Sie den MongoDB .NET-Treiber, um eine Verbindung mit dem Emulator über eine .NET-Anwendung herzustellen.
Starten Sie in einem leeren Ordner.
Erstellen einer neuen .NET-Konsolenanwendung
dotnet new console
Fügen Sie das MongoDB.Driver
-Paket aus NuGet hinzu.
dotnet add package MongoDB.Driver
Öffnen Sie die Datei Program.cs.
Löschen Sie alle vorhandenen Inhalte in der Datei.
Fügen Sie einen using-Block für den MongoDB.Driver
-Namespace hinzu.
using MongoDB.Driver;
Erstellen Sie unter Verwendung der Anmeldeinformationen des Emulators eine neue Instanz von MongoClient
.
var client = new MongoClient(
"mongodb://localhost:C2y6yDjf5%2FR%2Bob0N8A7Cgv30VRDJIWEHLM%2B4QDU5DE2nQ9nDuVTqobD4b8mGGyPMbIZnqyMsEcaGQy67XIw%2FJw%3D%3D@localhost:10255/admin?ssl=true&retrywrites=false"
);
Rufen Sie die Datenbank und den Container mit GetDatabase
und GetCollection<>
ab.
var database = client.GetDatabase("cosmicworks");
var collection = database.GetCollection<dynamic>("products");
Erstellen Sie ein neues Element in XXX mit InsertOneAsync
.
var item = new
{
name = "Kiama classic surfboard"
};
await collection.InsertOneAsync(item);
Führen Sie die .NET-Anwendung aus.
dotnet run
Verwenden Sie den MongoDB Python-Treiber, um eine Verbindung mit dem Emulator über eine Python-Anwendung herzustellen.
Starten Sie in einem leeren Ordner.
Importieren Sie das pymongo
-Paket aus dem Python-Paketindex.
pip install pymongo
Erstellen Sie die Datei app.py.
Importieren Sie die Module os
, sys
und pymongo
.
import pymongo
Erstellen Sie einen neuen MongoClient
mit den Anmeldeinformationen des Emulators.
client = pymongo.MongoClient(
host=(
"mongodb://localhost:C2y6yDjf5%2FR%2Bob0N8A7Cgv30VRDJIWEHLM%2B4QDU5DE2"
"nQ9nDuVTqobD4b8mGGyPMbIZnqyMsEcaGQy67XIw%2FJw%3D%3D@localhost:10255/a"
"dmin?ssl=true"
),
tls=True,
)
Erstellen Sie mithilfe von list_database_names
und list_collection_names
zusammen mit den benutzerdefinierten Befehlen CreateDatabase
und CreateCollection
eine neue Datenbank und einen neuen Container.
db = client["cosmicworks"]
if "cosmicworks" not in client.list_database_names():
db.command(
{
"customAction": "CreateDatabase",
"offerThroughput": 400,
}
)
collection = db["products"]
if "products" not in db.list_collection_names():
db.command({"customAction": "CreateCollection", "collection": "products"})
Erstellen Sie mithilfe von update_one
ein neues Element im Container.
item = {"id": "68719518371", "name": "Kiama classic surfboard"}
collection.update_one(
filter={"id": item["id"]}, update={"$set": item}, upsert=True
)
Führen Sie die Python-Anwendung aus.
python app.py
Verwenden Sie den MongoDB Node.js-Treiber, um eine Verbindung mit dem Emulator über eine Node.js/JavaScript-Anwendung herzustellen.
Starten Sie in einem leeren Ordner.
Initialisieren Sie ein neues Modul.
npm init es6 --yes
Installieren Sie das mongodb
-Paket über den Node-Paket-Manager.
npm install --save mongodb
Erstellen Sie die Datei app.js.
Importieren Sie den MongoClient
-Typ aus dem mongodb
-Modul.
import { MongoClient } from 'mongodb'
Verwenden Sie MongoClient
, um eine neue Clientinstanz mit den Anmeldeinformationen des Emulators zu erstellen. Stellen Sie mit connect
eine Verbindung mit dem Emulator her.
const client = new MongoClient(
'mongodb://localhost:C2y6yDjf5%2FR%2Bob0N8A7Cgv30VRDJIWEHLM%2B4QDU5DE2nQ9nDuVTqobD4b8mGGyPMbIZnqyMsEcaGQy67XIw%2FJw%3D%3D@localhost:10255/admin?ssl=true&retrywrites=false'
)
await client.connect()
Verwenden Sie db
und collection
, um eine Datenbank und einen Container zu erstellen.
const database = client.db('cosmicworks')
const collection = database.collection('products')
Erstellen Sie mithilfe von insertOne
ein neues Element.
const item = {
name: 'Kiama classic surfboard'
}
await collection.insertOne(item)
Führen Sie die Node.js-Anwendung aus.
node app.js
Warnung
Wenn sie einen SSL-Fehler erhalten, müssen Sie möglicherweise TLS/SSL für Ihre Anwendung deaktivieren. Dies tritt häufig auf, wenn Sie auf Ihrem lokalen Computer entwickeln, den Azure Cosmos DB-Emulator in einem Container verwenden und das SSL-Zertifikat des Containers nicht importiert haben. Um dies zu beheben, konfigurieren Sie die Anwendung so, dass die TLS/SSL-Validierung deaktiviert wird, bevor Sie den Client erstellen:
const client = new MongoClient(
...,
{ tlsAllowInvalidCertificates: true }
)
Verwenden Sie den Apache Cassandra .NET-Treiber, um eine Verbindung mit dem Emulator über eine .NET-Anwendung herzustellen.
Starten Sie in einem leeren Ordner.
Erstellen einer neuen .NET-Konsolenanwendung
dotnet new console
Fügen Sie das CassandraCSharpDriver
-Paket aus NuGet hinzu.
dotnet add package CassandraCSharpDriver
Öffnen Sie die Datei Program.cs.
Löschen Sie alle vorhandenen Inhalte in der Datei.
Fügen Sie einen using-Block für den Cassandra
-Namespace hinzu.
using Cassandra;
Erstellen Sie unter Verwendung der Anmeldeinformationen des Emulators eine neue Instanz von Cluster
. Erstellen Sie mithilfe von Connect
eine neue Sitzung.
var options = new SSLOptions(
sslProtocol: System.Security.Authentication.SslProtocols.Tls12,
checkCertificateRevocation: true,
remoteCertValidationCallback: (_, _, _, policyErrors) => policyErrors == System.Net.Security.SslPolicyErrors.None);
using var cluster = Cluster.Builder()
.WithCredentials(
username: "localhost",
password: "C2y6yDjf5/R+ob0N8A7Cgv30VRDJIWEHLM+4QDU5DE2nQ9nDuVTqobD4b8mGGyPMbIZnqyMsEcaGQy67XIw/Jw=="
)
.WithPort(
port: 10350
)
.AddContactPoint(
address: "localhost"
)
.WithSSL(
sslOptions: options
)
.Build();
using var session = cluster.Connect();
Erstellen Sie eine neue Datenbank und einen Container mithilfe von PrepareAsync
und ExecuteAsync
.
var createKeyspace = await session.PrepareAsync("CREATE KEYSPACE IF NOT EXISTS cosmicworks WITH replication = {'class':'basicclass', 'replication_factor': 1};");
await session.ExecuteAsync(createKeyspace.Bind());
var createTable = await session.PrepareAsync("CREATE TABLE IF NOT EXISTS cosmicworks.products (id text PRIMARY KEY, name text)");
await session.ExecuteAsync(createTable.Bind());
Erstellen Sie mithilfe von ExecuteAsync
ein neues Element in der Tabelle. Verwenden Sie Bind
, um dem Element Eigenschaften zuzuweisen.
var item = new
{
id = "68719518371",
name = "Kiama classic surfboard"
};
var createItem = await session.PrepareAsync("INSERT INTO cosmicworks.products (id, name) VALUES (?, ?)");
var createItemStatement = createItem.Bind(item.id, item.name);
await session.ExecuteAsync(createItemStatement);
Führen Sie die .NET-Anwendung aus.
dotnet run
Verwenden Sie den Apache Cassandra Python-Treiber, um eine Verbindung mit dem Emulator über eine Python-Anwendung herzustellen.
Starten Sie in einem leeren Ordner.
Importieren Sie das cassandra-driver
-Paket aus dem Python-Paketindex.
pip install cassandra-driver
Erstellen Sie die Datei app.py.
Importieren Sie PROTOCOL_TLS_CLIENT
, SSLContext
und CERT_NONE
aus dem Modul ssl
. Importieren Sie dann Cluster
aus dem Modul cassandra.cluster
. Importieren Sie schließlich PlainTextAuthProvider
aus dem Modul cassandra.auth
.
from ssl import PROTOCOL_TLS_CLIENT, SSLContext, CERT_NONE
from cassandra.cluster import Cluster
from cassandra.auth import PlainTextAuthProvider
Erstellen Sie mithilfe von SSLContext
eine neue TLS/SSL-Kontextvariable. Konfigurieren Sie den Kontext so, dass das selbstsignierte Zertifikat des Emulators nicht überprüft wird.
ssl_context = SSLContext(PROTOCOL_TLS_CLIENT)
ssl_context.check_hostname = False
ssl_context.verify_mode = CERT_NONE
Erstellen Sie einen neuen session
mit den Anmeldeinformationen des Emulators, PlainTextAuthProvider
, Cluster
und cluster.connect()
.
auth_provider = PlainTextAuthProvider(
username="localhost",
password=(
"C2y6yDjf5/R+ob0N8A7Cgv30VRDJIWEHLM+4QDU5DE2nQ9nDuVTqobD4b8mGGyPMbIZnq"
"yMsEcaGQy67XIw/Jw=="
),
)
cluster = Cluster(
["localhost"],
port="10350",
auth_provider=auth_provider,
ssl_context=ssl_context,
)
session = cluster.connect()
Erstellen Sie einen neuen Keyspace und eine neue Tabelle mit session.execute
.
session.execute(
"CREATE KEYSPACE IF NOT EXISTS cosmicworks WITH replication = {'class':'ba"
"sicclass', 'replication_factor': 1};"
)
session.execute(
"CREATE TABLE IF NOT EXISTS cosmicworks.products (id text PRIMARY KEY, nam"
"e text)"
)
Erstellen Sie mithilfe von session.execute
ein neues Element in der Tabelle.
item = {"id": "68719518371", "name": "Kiama classic surfboard"}
session.execute(
"INSERT INTO cosmicworks.products (id, name) VALUES (%s, %s)",
[item["id"], item["name"]],
)
Führen Sie die Python-Anwendung aus.
python app.py
Verwenden Sie den Apache Cassandra Node.js-Treiber, um den Emulator aus einer Node.js/JavaScript-Anwendung zu verwenden.
Starten Sie in einem leeren Ordner.
Initialisieren Sie ein neues Modul.
npm init es6 --yes
Installieren Sie das cassandra-driver
-Paket über den Node-Paket-Manager.
npm install --save cassandra-driver
Erstellen Sie die Datei app.js.
Importieren Sie den Client
-Typ und den auth
-Namespace aus dem cassandra-driver
-Modul.
import { Client, auth } from 'cassandra-driver'
Verwenden Sie PlainTextAuthProvider
, um ein neues Objekt für die Anmeldeinformationen des Emulators zu erstellen. Verwenden Sie Client
, um mithilfe der Anmeldeinformationen eine Verbindung mit dem Emulator herzustellen.
const credentials = new auth.PlainTextAuthProvider(
'localhost',
'C2y6yDjf5/R+ob0N8A7Cgv30VRDJIWEHLM+4QDU5DE2nQ9nDuVTqobD4b8mGGyPMbIZnqyMsEcaGQy67XIw/Jw=='
)
const client = new Client({
contactPoints: [
'localhost:10350'
],
authProvider: credentials,
localDataCenter: 'South Central US'
})
Verwenden Sie execute
, um einen Befehl serverseitig auszuführen, um einen Keyspace und eine Tabelle zu erstellen.
await client.execute(
'CREATE KEYSPACE IF NOT EXISTS cosmicworks WITH replication = {\'class\':\'basicclass\', \'replication_factor\': 1};'
)
await client.execute(
'CREATE TABLE IF NOT EXISTS cosmicworks.products (id text PRIMARY KEY, name text)'
)
Verwenden Sie execute
erneut, um ein neues Element mit Parametern zu erstellen.
const item = {
id: '68719518371',
name: 'Kiama classic surfboard'
}
await client.execute(
'INSERT INTO cosmicworks.products (id, name) VALUES (?, ?)',
[
item.id,
item.name
]
)
Führen Sie die Node.js-Anwendung aus.
node app.js
Warnung
Wenn sie einen SSL-Fehler erhalten, müssen Sie möglicherweise TLS/SSL für Ihre Anwendung deaktivieren. Dies tritt häufig auf, wenn Sie auf Ihrem lokalen Computer entwickeln, den Azure Cosmos DB-Emulator in einem Container verwenden und das SSL-Zertifikat des Containers nicht importiert haben. Um dies zu beheben, konfigurieren Sie den Client so, dass die TLS/SSL-Validierung deaktiviert wird:
const client = new Client({
...,
...,
...,
sslOptions: {
rejectUnauthorized: false
}
})
Wichtig
Vor dem Start erfordert die API für Apache Gremlin, dass Sie Ihre Ressourcen im Emulator erstellen. Erstellen Sie eine Datenbank namens db1
und einen Container mit dem Namen coll1
. Die Durchsatzeinstellungen sind für diese Anleitung irrelevant und können so niedrig festgelegt werden, wie Sie möchten.
Verwenden Sie den Apache Cassandra .NET-Treiber, um eine Verbindung mit dem Emulator über eine .NET-Anwendung herzustellen.
Starten Sie in einem leeren Ordner.
Erstellen einer neuen .NET-Konsolenanwendung
dotnet new console
Fügen Sie das Gremlin.Net
-Paket aus NuGet hinzu.
dotnet add package Gremlin.Net
Öffnen Sie die Datei Program.cs.
Löschen Sie alle vorhandenen Inhalte in der Datei.
Fügen Sie einen using-Block für den Gremlin.Net.Driver
-Namespace hinzu.
using Gremlin.Net.Driver;
Erstellen Sie unter Verwendung der Anmeldeinformationen des Emulators eine neue Instanz von GremlinServer
und GremlinClient
.
var server = new GremlinServer(
hostname: "localhost",
port: 65400,
username: "/dbs/db1/colls/coll1",
password: "C2y6yDjf5/R+ob0N8A7Cgv30VRDJIWEHLM+4QDU5DE2nQ9nDuVTqobD4b8mGGyPMbIZnqyMsEcaGQy67XIw/Jw=="
);
using var client = new GremlinClient(
gremlinServer: server,
messageSerializer: new Gremlin.Net.Structure.IO.GraphSON.GraphSON2MessageSerializer()
);
Bereinigen Sie den Graphen mit SubmitAsync
.
await client.SubmitAsync(
requestScript: "g.V().drop()"
);
Verwenden Sie SubmitAsync
erneut, um dem Graphen mit den angegebenen Parametern ein neues Element hinzuzufügen.
await client.SubmitAsync(
requestScript: "g.addV('product').property('id', prop_id).property('name', prop_name)",
bindings: new Dictionary<string, object>
{
{ "prop_id", "68719518371" },
{ "prop_name", "Kiama classic surfboard" }
}
);
Führen Sie die .NET-Anwendung aus.
dotnet run
Verwenden Sie den Apache Gremlin Python-Treiber, um eine Verbindung mit dem Emulator über eine Python-Anwendung herzustellen.
Starten Sie in einem leeren Ordner.
Importieren Sie das gremlinpython
-Paket aus dem Python-Paketindex.
pip install gremlinpython
Erstellen Sie die Datei app.py.
Importieren Sie dann client
aus dem Modul gremlin_python.driver
.
from gremlin_python.driver import client
Erstellen Sie einen neuen Client
mit den Anmeldeinformationen des Emulators.
client = client.Client(
url="ws://localhost:8901/",
traversal_source="g",
username="/dbs/db1/colls/coll1",
password=(
"C2y6yDjf5/R+ob0N8A7Cgv30VRDJIWEHLM+4QDU5DE2nQ9nDuVTqobD4b8mGGyPMbIZnq"
"yMsEcaGQy67XIw/Jw=="
),
)
Bereinigen Sie den Graphen mit client.submit
.
client.submit(message="g.V().drop()")
Verwenden Sie client.submit
erneut, um dem Graphen mit den angegebenen Parametern ein neues Element hinzuzufügen.
client.submit(
message=(
"g.addV('product').property('id', prop_id).property('name', prop_name)"
),
bindings={
"prop_id": "68719518371",
"prop_name": "Kiama classic surfboard",
},
)
Führen Sie die Python-Anwendung aus.
python app.py
Verwenden Sie den Apache Gremlin Node.js-Treiber, um den Emulator aus einer Node.js/JavaScript-Anwendung zu verwenden.
Starten Sie in einem leeren Ordner.
Initialisieren Sie ein neues Modul.
npm init es6 --yes
Installieren Sie das gremlin
-Paket über den Node-Paket-Manager.
npm install --save gremlin
Erstellen Sie die Datei app.js.
Importieren Sie das gremlin
Modul.
import gremlin from 'gremlin'
Verwenden Sie PlainTextSaslAuthenticator
, um ein neues Objekt für die Anmeldeinformationen des Emulators zu erstellen. Verwenden Sie Client
, um mithilfe der Anmeldeinformationen eine Verbindung mit dem Emulator herzustellen.
const credentials = new gremlin.driver.auth.PlainTextSaslAuthenticator(
'/dbs/db1/colls/coll1',
'C2y6yDjf5/R+ob0N8A7Cgv30VRDJIWEHLM+4QDU5DE2nQ9nDuVTqobD4b8mGGyPMbIZnqyMsEcaGQy67XIw/Jw=='
)
const client = new gremlin.driver.Client(
'ws://localhost:8901/',
{
credentials,
traversalsource: 'g',
rejectUnauthorized: false,
mimeType: 'application/vnd.gremlin-v2.0+json'
}
)
client.open()
Verwenden Sie submit
, um einen Befehl serverseitig auszuführen, um den Graphen zu löschen, wenn er bereits Daten enthält.
await client.submit('g.V().drop()')
Verwenden Sie submit
erneut, um dem Graphen mit den angegebenen Parametern ein neues Element hinzuzufügen.
await client.submit(
'g.addV(\'product\').property(\'id\', prop_id).property(\'name\', prop_name)', {
prop_id: '68719518371',
prop_name: 'Kiama classic surfboard'
}
)
Führen Sie die Node.js-Anwendung aus.
node app.js
Verwenden Sie das Azure Tables SDK für .NET , um über eine .NET-Anwendung eine Verbindung mit dem Emulator herzustellen.
Starten Sie in einem leeren Ordner.
Erstellen einer neuen .NET-Konsolenanwendung
dotnet new console
Fügen Sie das Azure.Data.Tables
-Paket aus NuGet hinzu.
dotnet add package Azure.Data.Tables
Öffnen Sie die Datei Program.cs.
Löschen Sie alle vorhandenen Inhalte in der Datei.
Fügen Sie einen using-Block für den Azure.Data.Tables
-Namespace hinzu.
using Azure.Data.Tables;
Erstellen Sie unter Verwendung der Anmeldeinformationen des Emulators eine neue Instanz von TableServiceClient
.
var serviceClient = new TableServiceClient(
connectionString: "DefaultEndpointsProtocol=http;AccountName=localhost;AccountKey=C2y6yDjf5/R+ob0N8A7Cgv30VRDJIWEHLM+4QDU5DE2nQ9nDuVTqobD4b8mGGyPMbIZnqyMsEcaGQy67XIw/Jw==;TableEndpoint=http://localhost:8902/;"
);
Verwenden Sie GetTableClient
, um eine neue Instanz von TableClient
mit dem Namen der Tabelle zu erstellen. Stellen Sie dann mithilfe von CreateIfNotExistsAsync
sicher, dass die Tabelle vorhanden ist.
var client = serviceClient.GetTableClient(
tableName: "cosmicworksproducts"
);
await client.CreateIfNotExistsAsync();
Erstellen Sie einen neuen record
-Typ für Elemente.
public record Product : Azure.Data.Tables.ITableEntity
{
public required string RowKey { get; set; }
public required string PartitionKey { get; set; }
public required string Name { get; init; }
public Azure.ETag ETag { get; set; }
public DateTimeOffset? Timestamp { get; set; }
}
Erstellen Sie mithilfe von UpsertEntityAsync
und dem Replace
-Modus ein neues Element in der Tabelle.
var item = new Product
{
RowKey = "68719518371",
PartitionKey = "Surfboards",
Name = "Kiama classic surfboard",
Timestamp = DateTimeOffset.Now
};
await client.UpsertEntityAsync(
entity: item,
mode: TableUpdateMode.Replace
);
Führen Sie die .NET-Anwendung aus.
dotnet run
Verwenden Sie das Azure Tables Python SDK, um über eine Python-Anwendung eine Verbindung mit dem Emulator herzustellen.
Starten Sie in einem leeren Ordner.
Importieren Sie das azure-data-tables
-Paket aus dem Python-Paketindex.
pip install azure-data-tables
Erstellen Sie die Datei app.py.
Importieren Sie TableServiceClient
und UpdateMode
aus dem Modul azure.data.tables
.
from azure.data.tables import TableServiceClient, UpdateMode
Verwenden Sie TableServiceClient.from_connection_string
, um einen neuen Client auf Dienstebene zu erstellen.
service = TableServiceClient.from_connection_string(
conn_str=(
"DefaultEndpointsProtocol=http;AccountName=localhost;AccountKey=C2y6yD"
"jf5/R+ob0N8A7Cgv30VRDJIWEHLM+4QDU5DE2nQ9nDuVTqobD4b8mGGyPMbIZnqyMsEca"
"GQy67XIw/Jw==;TableEndpoint=http://localhost:8902/;"
)
)
Erstellen Sie mit create_table_if_not_exists
einen neuen Client auf Tabellenebene.
client = service.create_table_if_not_exists(table_name="cosmicworksproducts")
Erstellen Sie mithilfe von upsert_entity
ein neues Element im Container.
item = {
"PartitionKey": "68719518371",
"RowKey": "Surfboards",
"name": "Kiama classic surfboard",
}
client.upsert_entity(entity=item, mode=UpdateMode.REPLACE)
Führen Sie die Python-Anwendung aus.
python app.py
Verwenden Sie das Azure Tables JavaScript SDK, um den Emulator aus einer Node.js/JavaScript-Anwendung zu verwenden.
Starten Sie in einem leeren Ordner.
Initialisieren Sie ein neues Modul.
npm init es6 --yes
Installieren Sie das @azure/data-tables
-Paket über den Node-Paket-Manager.
npm install --save @azure/data-tables
Erstellen Sie die Datei app.js.
Importieren Sie den TableClient
-Typ aus dem @azure/data-tables
-Modul.
import { TableClient } from '@azure/data-tables'
Verwenden Sie TableClient.fromConnectionString
, um eine neue Clientinstanz mit den Anmeldeinformationen des Emulators zu erstellen.
const client = TableClient.fromConnectionString(
'DefaultEndpointsProtocol=http;AccountName=localhost;AccountKey=C2y6yDjf5/R+ob0N8A7Cgv30VRDJIWEHLM+4QDU5DE2nQ9nDuVTqobD4b8mGGyPMbIZnqyMsEcaGQy67XIw/Jw==;TableEndpoint=http://localhost:8902/;',
'cosmicworksproducts'
)
Verwenden Sie createTable
zum Erstellen einer neuen Tabelle, wenn noch keine vorhanden ist.
await client.createTable()
Verwenden Sie upsertEntity
, um das Element zu erstellen oder zu ersetzen.
const item = {
partitionKey: '68719518371',
rowKey: 'Surfboards',
name: 'Kiama classic surfboard'
}
await client.upsertEntity(
item,
'Replace'
)
Führen Sie die Node.js-Anwendung aus.
node app.js
Warnung
Wenn sie einen SSL-Fehler erhalten, müssen Sie möglicherweise TLS/SSL für Ihre Anwendung deaktivieren. Dies tritt häufig auf, wenn Sie auf Ihrem lokalen Computer entwickeln, den Azure Cosmos DB-Emulator in einem Container verwenden und das SSL-Zertifikat des Containers nicht importiert haben. Um dies zu beheben, konfigurieren Sie den Client so, dass die TLS/SSL-Validierung deaktiviert wird:
const client = TableClient.fromConnectionString(
...,
...,
{
allowInsecureConnection: true
}
)
Verwenden des Emulators in einem GitHub Actions CI-Workflow
Um eine Continuous Integration-Workload auszuführen, die Ihre Anwendung automatisch validiert, verwenden Sie den Azure Cosmos DB-Emulator mit einer Testsammlung aus dem Framework Ihrer Wahl. Der Azure Cosmos DB-Emulator ist in der windows-latest
-Variante der gehosteten Runner von GitHub Action vorinstalliert.
Führen Sie eine Testsammlung mit dem integrierten Testtreiber für .NET und einem Testframework wie MSTest, NUnit oder XUnit aus.
Überprüfen Sie, ob die Komponententestsammlung für Ihre Anwendung wie erwartet funktioniert.
dotnet test
Erstellen Sie einen neuen Workflow in Ihrem GitHub-Repository in einer Datei mit dem Namen .github/workflows/ci.yml
.
Fügen Sie Ihrem Workflow einen Auftrag hinzu, um den Azure Cosmos DB-Emulator mithilfe von PowerShell zu starten und Ihre Komponententestsammlung auszuführen.
name: Continuous Integration
on:
push:
branches:
- main
jobs:
unit_tests:
name: Run .NET unit tests
runs-on: windows-latest
steps:
- name: Checkout (GitHub)
uses: actions/checkout@v3
- name: Start Azure Cosmos DB emulator
run: |
Write-Host "Launching Cosmos DB Emulator"
Import-Module "$env:ProgramFiles\Azure Cosmos DB Emulator\PSModules\Microsoft.Azure.CosmosDB.Emulator"
Start-CosmosDbEmulator
- name: Run .NET tests
run: dotnet test
Hinweis
Starten Sie den Emulator über die Befehlszeile mit verschiedenen Argumenten oder PowerShell-Befehlen. Weitere Informationen finden Sie unter Emulator-Befehlszeilenargumente.
Testen Sie Ihre Python-Anwendungs- und Datenbankvorgänge mit pytest
.
Überprüfen Sie, ob die Komponententestsammlung für Ihre Anwendung wie erwartet funktioniert.
pip install -U pytest
pytest
Erstellen Sie einen neuen Workflow in Ihrem GitHub-Repository in einer Datei mit dem Namen .github/workflows/ci.yml
.
Fügen Sie Ihrem Workflow einen Auftrag hinzu, um den Azure Cosmos DB-Emulator mithilfe von PowerShell zu starten und Ihre Komponententestsammlung auszuführen.
name: Continuous Integration
on:
push:
branches:
- main
jobs:
unit_tests:
name: Run Python unit tests
runs-on: windows-latest
steps:
- name: Checkout (GitHub)
uses: actions/checkout@v3
- name: Start Azure Cosmos DB emulator
run: |
Write-Host "Launching Cosmos DB Emulator"
Import-Module "$env:ProgramFiles\Azure Cosmos DB Emulator\PSModules\Microsoft.Azure.CosmosDB.Emulator"
Start-CosmosDbEmulator
- name: Install test runner
run: pip install pytest
- name: Run Python tests
run: pytest
Hinweis
Starten Sie den Emulator über die Befehlszeile mit verschiedenen Argumenten oder PowerShell-Befehlen. Weitere Informationen finden Sie unter Emulator-Befehlszeilenargumente.
Verwenden Sie mocha
, um Ihre Node.js-Anwendung und deren Datenbankänderungen zu testen.
Überprüfen Sie, ob die Komponententestsammlung für Ihre Anwendung wie erwartet funktioniert.
npm install --global mocha
mocha
Erstellen Sie einen neuen Workflow in Ihrem GitHub-Repository in einer Datei mit dem Namen .github/workflows/ci.yml
.
Fügen Sie Ihrem Workflow einen Auftrag hinzu, um den Azure Cosmos DB-Emulator mithilfe von PowerShell zu starten und Ihre Komponententestsammlung auszuführen.
name: Continuous Integration
on:
push:
branches:
- main
jobs:
unit_tests:
name: Run Node.js unit tests
runs-on: windows-latest
steps:
- name: Checkout (GitHub)
uses: actions/checkout@v3
- name: Start Azure Cosmos DB emulator
run: |
Write-Host "Launching Cosmos DB Emulator"
Import-Module "$env:ProgramFiles\Azure Cosmos DB Emulator\PSModules\Microsoft.Azure.CosmosDB.Emulator"
Start-CosmosDbEmulator
- name: Install test runner
run: npm install --global mocha
- name: Run Node.js tests
run: mocha
Hinweis
Starten Sie den Emulator über die Befehlszeile mit verschiedenen Argumenten oder PowerShell-Befehlen. Weitere Informationen finden Sie unter Emulator-Befehlszeilenargumente.
Nächster Schritt