Snabbstart: Azure Cosmos DB för Apache Cassandra-klientbiblioteket för Python

2025-07-21
Gäller för: ✅ Apache Cassanda

Kom igång med klientbiblioteket för Azure Cosmos DB för Apache Cassandra för Python 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 Python-klientbibliotek, ansluta till kontot, utföra vanliga åtgärder och köra frågor mot dina slutliga exempeldata.

API-referensdokumentation | Källkod | för bibliotekPaket (PyPI)

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 .

Python 3.12 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.

Börja i en tom katalog.
cassandra-driver Importera paketet från Python Package Index (PyPI).
```
pip install cassandra-driver
```
Skapa filen app.py .

Objektmodell

	Beskrivning
`Cluster`	Representerar en specifik anslutning till ett kluster

Autentisera klient

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

Öppna filen app.py i din integrerade utvecklingsmiljö (IDE).
Importera följande typer från modulen cassandra-driver :
- cassandra.cluster.Cluster
- cassandra.auth.PlainTextAuthProvider
```
from cassandra.cluster import Cluster
from cassandra.auth import PlainTextAuthProvider
```
Importera följande typer från modulen ssl :
- ssl.PROTOCOL_TLS_CLIENT
- ssl.SSLContext
- ssl.CERT_NONE
```
from ssl import PROTOCOL_TLS_CLIENT, SSLContext, CERT_NONE
```
Skapa strängvariabler för de autentiseringsuppgifter som samlats in tidigare i den här guiden. Ge variablerna username, password och contactPoint namn.
```
username = "<username>"
password = "<password>"
contactPoint = "<contact-point>"
```
SSLContext Konfigurera genom att skapa en ny variabel med namnet ssl_context, ställa in protokollet på PROTOCOL_TLS_CLIENT, inaktivera värdnamnskontrollen och ställa in verifieringsläget på CERT_NONE.
```
ssl_context = SSLContext(PROTOCOL_TLS_CLIENT)
ssl_context.check_hostname = False
ssl_context.verify_mode = CERT_NONE
```
Skapa ett nytt PlainTextAuthProvider objekt med de autentiseringsuppgifter som angavs i föregående steg. Lagra resultatet i en variabel med namnet auth_provider.
```
auth_provider = PlainTextAuthProvider(username=username, password=password)
```
Skapa ett Cluster objekt med hjälp av variablerna för autentiseringsuppgifter och konfiguration som skapades i föregående steg. Lagra resultatet i en variabel med namnet cluster.
```
cluster = Cluster([contactPoint], port=10350, auth_provider=auth_provider, ssl_context=ssl_context)
```

Anslut till klustret.

session = cluster.connect("cosmicworks")

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 en ny strängvariabel med namnet insertQuery med frågan Cassandra Query Language (CQL) för att infoga en ny rad.

insertQuery = """
INSERT INTO
    product (id, name, category, quantity, price, clearance)
VALUES
    (%(id)s, %(name)s, %(category)s, %(quantity)s, %(price)s, %(clearance)s)
"""

Skapa ett nytt objekt med olika egenskaper för en ny produkt och lagra det i en variabel med namnet params.

params = {
    "id": "aaaaaaaa-0000-1111-2222-bbbbbbbbbbbb",
    "name": "Yamba Surfboard",
    "category": "gear-surf-surfboards",
    "quantity": 12,
    "price": 850.00,
    "clearance": False
}

execute Använd funktionen för att köra frågan med de angivna parametrarna.
```
session.execute(insertQuery, params)
```

Läs data

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

Skapa en ny strängvariabel med namnet readQuery med en CQL-fråga som matchar objekt med samma id fält.
```
readQuery = "SELECT * FROM product WHERE id = %s LIMIT 1"
```
Skapa en strängvariabel id med namnet med samma värde som den produkt som skapades tidigare i den här guiden.
```
id = "aaaaaaaa-0000-1111-2222-bbbbbbbbbbbb"
```
Använd execute-funktionen för att köra frågan som är lagrad i readQuery genom att använda variabeln id som ett argument. Lagra resultatet i en variabel med namnet readResults.
```
readResults = session.execute(readQuery, (id,))
```
one Använd funktionen för att hämta det förväntade enskilda resultatet. Lagra det här enskilda resultatet i en variabel med namnet matchedProduct.
```
matchedProduct = readResults.one()
```

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 strängvariabler med namnet findQuery och category med CQL-frågan och den obligatoriska parametern.

findQuery = "SELECT * FROM product WHERE category = %s ALLOW FILTERING"
category = "gear-surf-surfboards"

Använd de två strängvariablerna och execute funktionen för att köra frågor mot flera resultat. Lagra resultatet av den här frågan i en variabel med namnet findResults.
```
findResults = session.execute(findQuery, (category,))
```

Använd en for loop för att iterera över frågeresultaten.

for row in findResults:
    # Do something here with each result

Kör koden

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

python app.py

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?