Schnellstart: Azure Cosmos DB für Apache Cassandra-Clientbibliothek für Node.js

Gilt für:: ✅ Apache Cassanda

Erste Schritte mit der Azure Cosmos DB-für-Apache-Cassandra-Client-Bibliothek für Node.js, um unstrukturierte Daten zu speichern, zu verwalten und abzufragen. Führen Sie die Schritte in diesem Handbuch aus, um ein neues Konto zu erstellen, eine Node.js Clientbibliothek zu installieren, eine Verbindung mit dem Konto herzustellen, allgemeine Vorgänge auszuführen und Ihre endgültigen Beispieldaten abzufragen.

API-Referenzdokumentation | Quellcode der Bibliothek | Paket (npm)

Voraussetzungen

Ein Azure-Abonnement
- Wenn Sie noch kein Azure-Abonnement haben, erstellen Sie ein kostenloses Konto, bevor Sie beginnen.

Die neueste Version der Azure CLI in Azure Cloud Shell.
- Wenn Sie CLI-Referenzbefehle lieber lokal ausführen möchten, melden Sie sich mit dem az login Befehl bei der Azure CLI an.

Node.js 22 oder höher

Einrichten

Richten Sie zunächst die Konto- und Entwicklungsumgebung für diesen Leitfaden ein. In diesem Abschnitt erfahren Sie, wie Sie ein Konto erstellen, die Anmeldeinformationen des Kontos abrufen und Ihre Entwicklungsumgebung vorbereiten.

Erstellen eines Kontos

Erstellen Sie zunächst eine API für Apache Cassandra-Konto. Nachdem das Konto erstellt wurde, erstellen Sie die Keyspace- und Tabellen-Ressourcen.

Azure CLI
Azure-Portal

Wenn Sie noch keine Zielressourcengruppe haben, verwenden Sie den az group create Befehl, um eine neue Ressourcengruppe in Ihrem Abonnement zu erstellen.
```
az group create \
    --name "<resource-group-name>" \
    --location "<location>"
```

Verwenden Sie den az cosmosdb create Befehl, um ein neues Azure Cosmos DB für Apache Cassandra-Konto mit Standardeinstellungen zu erstellen.

az cosmosdb create \
    --resource-group "<resource-group-name>" \
    --name "<account-name>" \
    --locations "regionName=<location>" \
    --capabilities "EnableCassandra"

Erstellen Sie einen neuen Keyspace mit az cosmosdb cassandra keyspace create namens cosmicworks.

az cosmosdb cassandra keyspace create \
    --resource-group "<resource-group-name>" \
    --account-name "<account-name>" \
    --name "cosmicworks"

Erstellen Sie ein neues JSON-Objekt, um Ihr Schema mithilfe eines mehrzeiligen Bash-Befehls darzustellen. Verwenden Sie dann den az cosmosdb cassandra table create Befehl, um eine neue Tabelle mit dem Namen productszu erstellen.

schemaJson=$(cat <<EOF
{
  "columns": [
    {
      "name": "id",
      "type": "text"
    },
    {
      "name": "name",
      "type": "text"
    },
    {
      "name": "category",
      "type": "text"
    },
    {
      "name": "quantity",
      "type": "int"
    },
    {
      "name": "price",
      "type": "decimal"
    },
    {
      "name": "clearance",
      "type": "boolean"
    }
  ],
  "partitionKeys": [
    {
      "name": "id"
    }
  ]
}
EOF
)

az cosmosdb cassandra table create \
    --resource-group "<resource-group-name>" \
    --account-name "<account-name>" \
    --keyspace-name "cosmicworks" \
    --name "product" \
    --schema "$schemaJson"

Melden Sie sich beim Azure-Portal (https://portal.azure.com) an.
Geben Sie Azure Cosmos DB in die globale Suchleiste ein.
Wählen Sie in DienstenAzure Cosmos DB aus.
Wählen Sie im Bereich "Azure Cosmos DB " die Option "Erstellen" und dann "Azure Cosmos DB" für Apache Cassandra auf der Registerkarte "Andere " aus.
Wählen Sie das Anforderungseinheitsdatenbankkonto (RU) für den Kontotyp aus.

Konfigurieren Sie im Bereich Allgemeine Informationen die folgenden Optionen, und wählen Sie dann Bewertung + Create:

	Wert
Workloadtyp	Lernen
Abonnement	Wählen Sie Ihr Azure-Abonnement aus.
Ressourcengruppe	Erstellen Sie eine neue Ressourcengruppe, oder wählen Sie eine vorhandene Ressourcengruppe aus
Kontoname	Geben Sie einen global eindeutigen Namen an.
Verfügbarkeitszonen	Deaktivieren
Ort	Wählen Sie eine unterstützte Azure-Region für Ihre Subscription

Tipp

Sie können alle nicht spezifizierten Optionen auf ihren Standardwerten belassen. Sie können das Konto auch so konfigurieren, dass der Gesamtkontodurchsatz auf 1.000 Anforderungseinheiten pro Sekunde (RU/s) beschränkt oder die kostenlose Stufe aktiviert wird, um Ihre Kosten zu minimieren.

Warten Sie im Bereich Bewertung + Create, bis die Validierung Ihres Kontos erfolgreich abgeschlossen ist, und wählen Sie dann Create.
Das Portal navigiert automatisch zum Bereitstellungsbereich. Warten Sie, bis die Bereitstellung abgeschlossen ist.
Nachdem die Bereitstellung abgeschlossen ist, wählen Sie "Zur Ressource wechseln " aus, um zur neuen API für Apache Cassandra-Konto zu navigieren.
Wählen Sie im Ressourcenmenü die Option "Daten-Explorer " aus.
Wählen Sie im Daten-Explorer +Neue Tabelle aus.

Konfigurieren Sie im Dialogfeld "Tabelle hinzufügen " die folgenden Optionen, und wählen Sie dann "OK" aus:

	Wert
Keyspace	Neu erstellen
Schlüsselraumname	`cosmicworks`
Tabellenname	`product`
Tabellenschema	`(id text, name text, category text, quantity int, price decimal, clearance boolean, PRIMARY KEY (id))`

Tipp

Sie können alle nicht spezifizierten Optionen auf ihren Standardwerten belassen.

Abrufen von Anmeldeinformationen

Rufen Sie nun das Kennwort für die Clientbibliothek ab, um eine Verbindung mit dem vor Kurzem erstellten Konto herzustellen.

Azure CLI
Azure-Portal

Verwenden Sie az cosmosdb show, um den Kontaktpunkt und den Benutzernamen für das Konto abzurufen.

az cosmosdb show \
    --resource-group "<resource-group-name>" \
    --name "<account-name>" \
    --query "{username:name,contactPoint:documentEndpoint}"

Notieren Sie den Wert der contactPoint Und username Eigenschaften aus der Ausgabe der vorherigen Befehle. Die Werte dieser Eigenschaften sind der Kontaktpunkt und der Benutzername , den Sie später in diesem Handbuch verwenden, um eine Verbindung mit dem Konto mit der Bibliothek herzustellen.

Verwenden Sie az cosmosdb keys list, um die Schlüssel für das Konto zu erhalten.

az cosmosdb keys list \
    --resource-group "<resource-group-name>" \
    --name "<account-name>" \
    --type "keys"

Notieren Sie den Wert der Eigenschaft primaryMasterKey aus der Ausgabe des vorherigen Befehls. Der Wert dieser Eigenschaft ist das Kennwort , das Sie später in diesem Handbuch zum Herstellen einer Verbindung mit dem Konto mit der Bibliothek verwenden.

Vorbereiten der Entwicklungsumgebung

Konfigurieren Sie dann Ihre Entwicklungsumgebung mit einem neuen Projekt und der Clientbibliothek. Dieser Schritt ist die letzte erforderliche Voraussetzung, bevor Sie mit dem Rest dieses Handbuchs fortfahren.

Starten Sie in einem leeren Ordner.
Initialisieren Sie ein neues Modul.
```
npm init es6 --yes
```
Installieren Sie das cassandra-driver Paket vom Node Package Manager (npm).
```
npm install --save cassandra-driver
```
Erstellen Sie die index.js Datei.

Beginnen Sie in einem leeren Verzeichnis.
Initialisieren Sie ein neues Modul.
```
npm init es6 --yes
```
Installieren Sie das typescript Paket vom Node Package Manager (npm).
```
npm install --save-dev typescript
```
Installieren Sie das tsx Paket von npm.
```
npm install --save-dev tsx
```
Installieren Sie das cassandra-driver Paket von npm.
```
npm install --save cassandra-driver
```

Initialisieren Sie das TypeScript-Projekt mit dem Compiler (tsc).

npx tsc --init --target es2017 --module es2022 --moduleResolution nodenext

Erstellen Sie die index.ts Datei.

Objektmodell

	BESCHREIBUNG
`Client`	Stellt eine bestimmte Verbindung zu einem Cluster dar.
`Mapper`	Cassandra Query Language (CQL)-Client zum Ausführen von Abfragen

Authentifizieren des Clients

Beginnen Sie damit, den Client mithilfe der Anmeldeinformationen zu authentifizieren, die zuvor in diesem Handbuch gesammelt wurden.

Öffnen Sie die index.js Datei in Ihrer integrierten Entwicklungsumgebung (IDE).

Importieren Sie die folgenden Typen aus dem cassandra-driver Modul:

cassandra
cassandra.Client
cassandra.mapping.Mapper
cassandra.auth.PlainTextAuthProvider

import cassandra from 'cassandra-driver';

const { Client } = cassandra;
const { Mapper } = cassandra.mapping;
const { PlainTextAuthProvider } = cassandra.auth;

Erstellen Sie String-Konstanten für die zuvor in diesem Handbuch gesammelten Anmeldeinformationen. Benennen Sie die Variablen username, passwordund contactPoint.
```
const username = '<username>';
const password = '<password>';
const contactPoint = '<contact-point>';
```
Erstellen Sie eine weitere Zeichenfolgenvariable für die Region, in der Sie Ihr Azure Cosmos DB für Apache Cassandra-Konto erstellt haben. Benennen Sie diese Variable region.
```
const region = '<azure-region>';
```
Erstellen Sie ein neues PlainTextAuthProvider Objekt mit den in den vorherigen Schritten angegebenen Anmeldeinformationen.
```
let authProvider = new PlainTextAuthProvider(
    username,
    password
);
```

Erstellen Sie ein Client Objekt mithilfe der Anmeldeinformationen und Konfigurationsvariablen, die in den vorherigen Schritten erstellt wurden.

let client = new Client({
    contactPoints: [`${contactPoint}:10350`],
    authProvider: authProvider,
    localDataCenter: region,
    sslOptions: {
        secureProtocol: 'TLSv1_2_method'
    },
});

Stellen Sie asynchron eine Verbindung mit dem Cluster her.
```
await client.connect();
```

Erstellen Sie einen neuen Mapper, der auf den cosmicworks Schlüsselbereich und die product Tabelle ausgerichtet ist. Nennen Sie den Mapper Product.

const mapper = new Mapper(client, {
    models: {
        'Product': {
            tables: ['product'],
            keyspace: 'cosmicworks'
        }
    }
});

Generieren Sie eine Mapperinstanz mithilfe der forModel Funktion und des Product Mappernamens.
```
const productMapper = mapper.forModel('Product');
```

Öffnen Sie die datei index.ts in Ihrer integrierten Entwicklungsumgebung (IDE).
Importieren Sie die folgenden Typen aus dem cassandra-driver Modul:
- cassandra.auth
- cassandra.mapping
- cassandra.types
- cassandra.Client
- cassandra.ClientOptions
- cassandra.mapping.Mapper
- cassandra.auth.PlainTextAuthProvider
```
import { auth, mapping, types, Client, ClientOptions } from 'cassandra-driver';

const { Mapper } = mapping;
const { PlainTextAuthProvider } = auth;
```
Erstellen Sie String-Konstanten für die zuvor in diesem Handbuch gesammelten Anmeldeinformationen. Benennen Sie die Variablen username, passwordund contactPoint.
```
const username: string = '<username>';
const password: string = '<password>';
const contactPoint: string = '<contact-point>';
```
Erstellen Sie eine weitere Zeichenfolgenvariable für die Region, in der Sie Ihr Azure Cosmos DB für Apache Cassandra-Konto erstellt haben. Benennen Sie diese Variable region.
```
const region: string = '<azure-region>';
```
Erstellen Sie ein neues PlainTextAuthProvider Objekt mit den in den vorherigen Schritten angegebenen Anmeldeinformationen.
```
let authProvider = new PlainTextAuthProvider(
    username,
    password
);
```
Erstellen Sie ein anonymes Objekt mit Optionen, die sicherstellen, dass Sie das TLS-Protokoll (Transport Layer Security) 1.2 verwenden.
```
let sslOptions = {
    secureProtocol: 'TLSv1_2_method'
};
```

Erstellen Sie ein ClientOptions Objekt mithilfe der Anmeldeinformationen und Konfigurationsvariablen, die in den vorherigen Schritten erstellt wurden.

let clientOptions: ClientOptions = {
    contactPoints: [`${contactPoint}:10350`],
    authProvider: authProvider,
    localDataCenter: region,
    sslOptions: sslOptions
};

Erstellen Sie ein Client Objekt mithilfe der clientOptions Variablen im Konstruktor.
```
let client = new Client(clientOptions);
```
Stellen Sie asynchron eine Verbindung mit dem Cluster her.
```
await client.connect();
```

Erstellen Sie einen neuen Mapper, der auf den cosmicworks Schlüsselbereich und die product Tabelle ausgerichtet ist. Nennen Sie den Mapper Product.

const mapper = new Mapper( client, {
    models: {
        'Product': {
            tables: ['product'],
            keyspace: 'cosmicworks'
        }
    }
});

Generieren Sie eine Mapperinstanz mithilfe der forModel Funktion und des Product Mappernamens.
```
const productMapper = mapper.forModel('Product');
```

Warnung

Die vollständige TLS-Überprüfung (Transport Layer Security) ist in diesem Handbuch deaktiviert, um die Authentifizierung zu vereinfachen. Aktivieren Sie die Validierung vollständig für Produktionsbereitstellungen.

Daten-Update durchführen

Als Nächstes fügen Sie neue Daten in eine Tabelle ein. Upserting stellt sicher, dass die Daten erstellt oder entsprechend ersetzt werden, je nachdem, ob die gleichen Daten bereits in der Tabelle vorhanden sind.

Erstellen Sie ein neues Objekt in einer Variablen mit dem Namen product.

const product = {
    id: 'aaaaaaaa-0000-1111-2222-bbbbbbbbbbbb',
    name: 'Yamba Surfboard',
    category: 'gear-surf-surfboards',
    quantity: 12,
    price: 850.00,
    clearance: false
};

Rufen Sie asynchron die insert Funktion auf, die die product im vorherigen Schritt erstellte Variable übergibt.
```
await productMapper.insert(product);
```

Definieren Sie eine neue Schnittstelle mit dem Namen Product, deren Felder der früher in diesem Leitfaden erstellten Tabelle entsprechen.

Typ

Id string

Name string

Category string

Quantity int

Price decimal

Clearance bool
```
interface Product {
    id: string;
    name: string;
    category: string;
    quantity: number;
    price: number;
    clearance: boolean;
}
```
Tipp

In Node.jskönnen Sie diesen Typ in einer anderen Datei erstellen oder am Ende der vorhandenen Datei erstellen.

	Typ
`Id`	`string`
`Name`	`string`
`Category`	`string`
`Quantity`	`int`
`Price`	`decimal`
`Clearance`	`bool`

Erstellen Sie ein neues Objekt vom Typ Product. Speichern Sie das Objekt in einer Variablen mit dem Namen product.

const product: Product = {
    id: 'aaaaaaaa-0000-1111-2222-bbbbbbbbbbbb',
    name: 'Yamba Surfboard',
    category: 'gear-surf-surfboards',
    quantity: 12,
    price: 850.00,
    clearance: false
};

Rufen Sie asynchron die insert Funktion auf, die die product im vorherigen Schritt erstellte Variable übergibt.
```
await productMapper.insert(product);
```

Daten lesen

Lesen Sie dann Daten, die zuvor in die Tabelle eingefügt wurden.

Erstellen Sie ein anonymes Objekt mit dem Namen filter. Fügen Sie in diesem Objekt eine Eigenschaft id mit demselben Wert wie das zuvor in diesem Handbuch erstellte Produkt hinzu.
```
const filter = {
    id: 'aaaaaaaa-0000-1111-2222-bbbbbbbbbbbb'
};
```
Rufen Sie die get-Funktion des Mappers auf und übergeben Sie die filter-Variable. Speichern Sie das Ergebnis in einer Variable namens matchedProduct.
```
let matchedProduct = await productMapper.get(filter);
```

Erstellen Sie ein anonymes Objekt mit dem Namen filter. Fügen Sie in diesem Objekt eine Eigenschaft id mit demselben Wert wie das zuvor in diesem Handbuch erstellte Produkt hinzu.
```
const filter = {
    id: 'aaaaaaaa-0000-1111-2222-bbbbbbbbbbbb'
};
```
Rufen Sie die get-Funktion des Mappers auf und übergeben Sie die filter-Variable. Speichern Sie das Ergebnis in einer Variablen mit dem Namen matchedProduct des Typs Product.
```
let matchedProduct: Product = await productMapper.get(filter);
```

Abfragedaten

Verwenden Sie schließlich eine Abfrage, um alle Daten zu finden, die einem bestimmten Filter in der Tabelle entsprechen.

Erstellen Sie eine neue Zeichenfolgenvariable mit dem Namen query, die eine CQL-Abfrage enthält, die Elemente mit demselben category Feld abgleicht.
```
const query = `
SELECT
    *
FROM
    cosmicworks.product
WHERE
    category = :category
ALLOW FILTERING
`;
```
Erstellen Sie ein anonymes Objekt mit dem Namen params. Fügen Sie in diesem Objekt eine Eigenschaft category mit demselben Wert wie das zuvor in diesem Handbuch erstellte Produkt hinzu.
```
const params = {
    category: 'gear-surf-surfboards'
};
```
Rufen Sie asynchron die execute Funktion auf und übergeben Sie dabei die Variablen query und params als Argumente. Speichern Sie die Eigenschaft des Ergebnisses rows als Variable mit dem Namen matchedProducts.
```
let { rows: matchedProducts } = await client.execute(query, params);
```
Durchlaufen Sie die Abfrageergebnisse, indem Sie die foreach-Methode für das Array von Produkten aufrufen.
```
matchedProducts.forEach(product => {
    // Do something here with each result
});
```

Erstellen Sie eine neue Zeichenfolgenvariable mit dem Namen query, die eine CQL-Abfrage enthält, die Elemente mit demselben category Feld abgleicht.
```
const query: string = `
SELECT
    *
FROM
    cosmicworks.product
WHERE
    category = :category
ALLOW FILTERING
`;
```
Erstellen Sie ein anonymes Objekt mit dem Namen params. Fügen Sie in diesem Objekt eine Eigenschaft category mit demselben Wert wie das zuvor in diesem Handbuch erstellte Produkt hinzu.
```
const params = {
    category: 'gear-surf-surfboards'
};
```
Rufen Sie asynchron die execute Funktion auf und übergeben Sie dabei die Variablen query und params als Argumente. Speichern Sie das Ergebnis in einer Variablen mit dem Namen result des Typs types.ResultSet.
```
let result: types.ResultSet = await client.execute(query, params);
```
Speichern Sie die rows-Eigenschaft des Ergebnisses als Variable mit dem Namen matchedProducts vom Typ Product[].
```
let matchedProducts: Product[] = result.rows;
```
Durchlaufen Sie die Abfrageergebnisse, indem Sie die foreach-Methode für das Array von Produkten aufrufen.
```
matchedProducts.forEach((product: Product) => {
    // Do something here with each result
});
```

Ausführen des Codes

Führen Sie die neu erstellte Anwendung mit einem Terminal in Ihrem Anwendungsverzeichnis aus.

node index.js

npx tsx index.ts

Bereinigen von Ressourcen

Wenn Sie das Konto nicht mehr benötigen, entfernen Sie das Konto aus Ihrem Azure-Abonnement, indem Sie die Ressource löschen .

Azure CLI
Azure-Portal

az cosmosdb delete \
    --resource-group "<resource-group-name>" \
    --name "<account-name>"

Nächster Schritt

Übersicht über Azure Cosmos DB für Apache Cassandra

Feedback

War diese Seite hilfreich?

Last updated on 2025-07-25