Snabbstart: Azure Cosmos DB för Apache Cassandra-klientbiblioteket för Node.js

Gäller för: ✅ Apache Cassanda

Kom igång med Azure Cosmos DB för Apache Cassandra-klientbiblioteket för Node.js för att lagra, hantera och fråga ostrukturerade data. Följ stegen i den här guiden för att skapa ett nytt konto, installera ett Node.js klientbibliotek, ansluta till kontot, utföra vanliga åtgärder och köra frågor mot dina slutliga exempeldata.

Förutsättningar

En prenumeration på Azure
- Om du inte har en Azure-prenumeration, skapa ett gratis konto innan du börjar.

Den senaste versionen av Azure CLI i Azure Cloud Shell.
- Om du föredrar att köra CLI-referenskommandon lokalt loggar du in på Azure CLI med hjälp az login av kommandot .

Node.js 22 eller senare

Förbereda

Konfigurera först konto- och utvecklingsmiljön för den här guiden. Det här avsnittet beskriver hur du skapar ett konto, hämtar dess autentiseringsuppgifter och sedan förbereder utvecklingsmiljön.

Skapa ett konto

Börja med att skapa ett API för Apache Cassandra-konto. När kontot har skapats skapar du nyckelområdet och tabellresurserna.

Azure CLI
Azure Portal

Om du inte redan har en målresursgrupp använder du az group create kommandot för att skapa en ny resursgrupp i din prenumeration.
```
az group create \
    --name "<resource-group-name>" \
    --location "<location>"
```

az cosmosdb create Använd kommandot för att skapa ett nytt Azure Cosmos DB för Apache Cassandra-konto med standardinställningar.

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

Skapa ett nytt keyspace med az cosmosdb cassandra keyspace create namnet cosmicworks.

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

Skapa ett nytt JSON-objekt som representerar schemat med hjälp av ett Bash-kommando med flera rader. az cosmosdb cassandra table create Använd sedan kommandot för att skapa en ny tabell med namnet products.

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"

Logga in på Azure Portal (https://portal.azure.com).
Ange Azure Cosmos DB i fältet global sökning.
I Tjänster väljer du Azure Cosmos DB.
I fönstret Azure Cosmos DB väljer du Skapa och sedan Azure Cosmos DB för Apache Cassandra på fliken Andra .
Välj RU-databaskonto (Request unit) för kontotypen.

I fönstret Grundläggande konfigurerar du följande alternativ och väljer sedan Granska + skapa:

	Värde
Arbetsbelastningstyp	Lärande
Prenumeration	Välj din Azure-prenumeration
Resursgrupp	Skapa en ny resursgrupp eller välj en befintlig resursgrupp
Kontonamn	Ange ett globalt unikt namn
Tillgänglighetszoner	Inaktivera
Läge	Välj en Azure-region som stöds för din prenumeration

Tips/Råd

Du kan lämna alla ospecificerade alternativ till deras standardvärden. Du kan också konfigurera kontot för att begränsa det totala dataflödet till 1 000 enheter för begäranden per sekund (RU/s) eller aktivera den kostnadsfria nivån för att minimera dina kostnader.

I fönstret Granska + skapa väntar du på att verifieringen av ditt konto ska slutföras och väljer sedan Skapa.
Portalen navigerar automatiskt till fönstret Distribution . Vänta tills distributionen har slutförts.
När distributionen är klar väljer du Gå till resurs för att navigera till det nya API:et för Apache Cassandra-kontot.
I resursmenyn väljer du alternativet Datautforskaren .
I Datautforskaren väljer du + Ny tabell.

I dialogrutan Lägg till tabell konfigurerar du följande alternativ och väljer sedan OK:

	Värde
Nyckelutrymme	Skapa ny
Namn på nyckelområde	`cosmicworks`
Tabellnamn	`product`
Tabellschema	`(id text, name text, category text, quantity int, price decimal, clearance boolean, PRIMARY KEY (id))`

Tips/Råd

Du kan lämna alla ospecificerade alternativ till deras standardvärden.

Hämta autentiseringsuppgifter

Hämta nu lösenordet för klientbiblioteket som ska användas för att skapa en anslutning till det nyligen skapade kontot.

Azure CLI
Azure Portal

Använd az cosmosdb show för att hämta kontaktpunkten och användarnamnet för kontot.

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

Registrera värdet för contactPoint egenskaperna och username från föregående kommandons utdata. Dessa egenskapers värden är kontaktpunkten och användarnamnet som du använder senare i den här guiden för att ansluta till kontot med biblioteket.

Använd az cosmosdb keys list för att hämta nycklarna för kontot.

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

Registrera värdet för primaryMasterKey egenskapen från föregående kommandons utdata. Den här egenskapens värde är det lösenord som du använder senare i den här guiden för att ansluta till kontot med biblioteket.

Förbereda utvecklingsmiljön

Konfigurera sedan utvecklingsmiljön med ett nytt projekt och klientbiblioteket. Det här steget är det sista nödvändiga kravet innan du går vidare till resten av den här guiden.

Starta i en tom mapp.
Initiera en ny modul.
```
npm init es6 --yes
```
cassandra-driver Installera paketet från Node Package Manager (npm).
```
npm install --save cassandra-driver
```
Skapa filenindex.js .

Börja i en tom katalog.
Initiera en ny modul.
```
npm init es6 --yes
```
typescript Installera paketet från Node Package Manager (npm).
```
npm install --save-dev typescript
```
tsx Installera paketet från npm.
```
npm install --save-dev tsx
```
cassandra-driver Installera paketet från npm.
```
npm install --save cassandra-driver
```

Initiera TypeScript-projektet med hjälp av kompilatorn (tsc).

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

Skapa filen index.ts .

Objektmodell

	Beskrivning
`Client`	Representerar en specifik anslutning till ett kluster
`Mapper`	Cassandra Query Language-klienten (CQL) som används för att köra frågor

Autentisera klient

Börja med att autentisera klienten med de autentiseringsuppgifter som samlats in tidigare i den här guiden.

Öppna filenindex.js i din integrerade utvecklingsmiljö (IDE).

Importera följande typer från modulen cassandra-driver :

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;

Skapa konstanta strängvariabler för de autentiseringsuppgifter som samlats in tidigare i den här guiden. Ge variablerna username, password och contactPoint namn.
```
const username = '<username>';
const password = '<password>';
const contactPoint = '<contact-point>';
```
Skapa en annan strängvariabel för den region där du skapade ditt Azure Cosmos DB för Apache Cassandra-kontot. Ge variabeln region namnet.
```
const region = '<azure-region>';
```
Skapa ett nytt PlainTextAuthProvider objekt med de autentiseringsuppgifter som angavs i föregående steg.
```
let authProvider = new PlainTextAuthProvider(
    username,
    password
);
```

Skapa ett Client objekt med hjälp av variablerna för autentiseringsuppgifter och konfiguration som skapades i föregående steg.

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

Anslut asynkront till klustret.
```
await client.connect();
```

Skapa en ny mappning som riktar sig till cosmicworks nyckelområdet och product tabellen. Namnge mapparen Product.

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

Generera en mappningsinstans med hjälp av forModel funktionen och mappningsnamnet Product .
```
const productMapper = mapper.forModel('Product');
```

Öppna filen index.ts i din integrerade utvecklingsmiljö (IDE).
Importera följande typer från modulen cassandra-driver :
- 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;
```
Skapa konstanta strängvariabler för de autentiseringsuppgifter som samlats in tidigare i den här guiden. Ge variablerna username, password och contactPoint namn.
```
const username: string = '<username>';
const password: string = '<password>';
const contactPoint: string = '<contact-point>';
```
Skapa en annan strängvariabel för den region där du skapade ditt Azure Cosmos DB för Apache Cassandra-kontot. Ge variabeln region namnet.
```
const region: string = '<azure-region>';
```
Skapa ett nytt PlainTextAuthProvider objekt med de autentiseringsuppgifter som angavs i föregående steg.
```
let authProvider = new PlainTextAuthProvider(
    username,
    password
);
```
Skapa ett anonymt objekt med alternativ som säkerställer att du använder TLS-protokollet (Transport Layer Security) 1.2.
```
let sslOptions = {
    secureProtocol: 'TLSv1_2_method'
};
```

Skapa ett ClientOptions objekt med hjälp av variablerna för autentiseringsuppgifter och konfiguration som skapades i föregående steg.

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

Skapa ett Client objekt med variabeln clientOptions i konstruktorn.
```
let client = new Client(clientOptions);
```
Anslut asynkront till klustret.
```
await client.connect();
```

Skapa en ny mappning som riktar sig till cosmicworks nyckelområdet och product tabellen. Namnge mapparen Product.

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

Generera en mappningsinstans med hjälp av forModel funktionen och mappningsnamnet Product .
```
const productMapper = mapper.forModel('Product');
```

Varning

Fullständig TLS-validering (Transport Layer Security) är inaktiverad i den här guiden för att förenkla autentiseringen. Aktivera validering fullt ut för produktionsdistributioner.

Infoga eller uppdatera data

Därefter ökar du nya data till en tabell. Upserting säkerställer att data skapas eller ersätts på lämpligt sätt beroende på om samma data redan finns i tabellen.

Skapa ett nytt objekt i en variabel med namnet product.

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

Asynkront anropa funktionen insert som skickar variabeln product som skapades i föregående steg.
```
await productMapper.insert(product);
```

Definiera ett nytt gränssnitt med namnet Product med fält som motsvarar tabellen som skapades tidigare i den här guiden.

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;
}
```
Tips/Råd

I Node.jskan du skapa den här typen i en annan fil eller skapa den i slutet av den befintliga filen.

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

Skapa ett nytt objekt av typen Product. Lagra objektet i en variabel med namnet product.

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

Asynkront anropa funktionen insert som skickar variabeln product som skapades i föregående steg.
```
await productMapper.insert(product);
```

Läs data

Läs sedan data som tidigare har laddats upp i tabellen.

Skapa ett anonymt objekt med namnet filter. I det här objektet inkluderar du en egenskap id med namnet med samma värde som den produkt som skapades tidigare i den här guiden.
```
const filter = {
    id: 'aaaaaaaa-0000-1111-2222-bbbbbbbbbbbb'
};
```
Anropa get-funktionen på mapparen genom att skicka variabeln filter. Lagra resultatet i en variabel med namnet matchedProduct.
```
let matchedProduct = await productMapper.get(filter);
```

Skapa ett anonymt objekt med namnet filter. I det här objektet inkluderar du en egenskap id med namnet med samma värde som den produkt som skapades tidigare i den här guiden.
```
const filter = {
    id: 'aaaaaaaa-0000-1111-2222-bbbbbbbbbbbb'
};
```
Anropa get-funktionen på mapparen genom att skicka variabeln filter. Lagra resultatet i en variabel med namnet matchedProduct av typen Product.
```
let matchedProduct: Product = await productMapper.get(filter);
```

Fråga efter data

Slutligen använder du en fråga för att hitta alla data som matchar ett specifikt filter i tabellen.

Skapa en ny strängvariabel med namnet query med en CQL-fråga som matchar objekt med samma category fält.

const query = `
SELECT
    *
FROM
    cosmicworks.product
WHERE
    category = :category
ALLOW FILTERING
`;

Skapa ett anonymt objekt med namnet params. I det här objektet inkluderar du en egenskap category med namnet med samma värde som den produkt som skapades tidigare i den här guiden.
```
const params = {
    category: 'gear-surf-surfboards'
};
```
Anropa funktionen asynkront execute och skicka både variablerna query och params som argument. Lagra resultatets rows egenskap som en variabel med namnet matchedProducts.
```
let { rows: matchedProducts } = await client.execute(query, params);
```
Iterera över frågeresultaten genom att foreach anropa metoden i matrisen med produkter.
```
matchedProducts.forEach(product => {
    // Do something here with each result
});
```

Skapa en ny strängvariabel med namnet query med en CQL-fråga som matchar objekt med samma category fält.

const query: string = `
SELECT
    *
FROM
    cosmicworks.product
WHERE
    category = :category
ALLOW FILTERING
`;

Skapa ett anonymt objekt med namnet params. I det här objektet inkluderar du en egenskap category med namnet med samma värde som den produkt som skapades tidigare i den här guiden.
```
const params = {
    category: 'gear-surf-surfboards'
};
```
Anropa funktionen asynkront execute och skicka både variablerna query och params som argument. Lagra resultatet i en variabel med namnet result av typen types.ResultSet.
```
let result: types.ResultSet = await client.execute(query, params);
```
Lagra resultatets rows egenskap som en variabel med namnet matchedProducts av typen Product[].
```
let matchedProducts: Product[] = result.rows;
```

Iterera över frågeresultaten genom att foreach anropa metoden i matrisen med produkter.

matchedProducts.forEach((product: Product) => {
    // Do something here with each result
});

Kör koden

Kör det nyligen skapade programmet med hjälp av en terminal i programkatalogen.

node index.js

npx tsx index.ts

Rensa resurser

När du inte längre behöver kontot tar du bort kontot från din Azure-prenumeration genom att ta bort resursen.

Azure CLI
Azure Portal

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

Nästa steg

Översikt över Azure Cosmos DB för Apache Cassandra

Feedback

Var den här sidan till hjälp?

Last updated on 2025-07-21