Snabbstart: Använda Azure Cosmos DB för MongoDB vCore med MongoDB-drivrutin för Python

I den här snabbstarten distribuerar du ett grundläggande Azure Cosmos DB for MongoDB-program med hjälp av Python. Azure Cosmos DB for MongoDB vCore är ett schemalöst datalager som gör att program kan lagra ostrukturerade dokument i molnet med MongoDB-bibliotek. Du lär dig hur du skapar dokument och utför grundläggande uppgifter i din Azure Cosmos DB-resurs med hjälp av Python.

Bibliotekets källkod | Paket (PyPI) | Azure Developer CLI

Förutsättningar

• Azure Developer CLI

• Docker Desktop

• En prenumeration på Azure

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

• Python 3.12

Initiera projektet

Använd Azure Developer CLI (azd) för att skapa ett Azure Cosmos DB for MongoDB vCore-kluster och distribuera ett containerbaserat exempelprogram. Exempelprogrammet använder klientbiblioteket för att hantera, skapa, läsa och fråga efter exempeldata.

1. Öppna en terminal i en tom katalog.

2. Om du inte redan är autentiserad autentiserar du till Azure Developer CLI med hjälp av azd auth login. Följ stegen som anges av verktyget för att autentisera till CLI med dina önskade Azure-autentiseringsuppgifter.

   azd auth login
   

3. Använd azd init för att initiera projektet.

   azd init --template cosmos-db-mongodb-vcore-python-quickstart
   

4. Under initieringen konfigurerar du ett unikt miljönamn.

5. Distribuera klustret med .azd up Bicep-mallarna distribuerar också en exempel webbapplikation.

   azd up
   

6. Under etableringsprocessen väljer du din prenumeration, önskad plats och målresursgrupp. Vänta tills tilldelningsprocessen har slutförts. Processen kan ta cirka tio minuter.

7. När etableringen av dina Azure-resurser är klar inkluderas en URL till det webbprogram som körs i utdata.

   Deploying services (azd deploy)
   
     (✓) Done: Deploying service web
   - Endpoint: <https://[container-app-sub-domain].azurecontainerapps.io>
   
   SUCCESS: Your application was provisioned and deployed to Azure in 5 minutes 0 seconds.
   

8. Använd URL:en i konsolen för att navigera till webbprogrammet i webbläsaren. Observera utdata från appen som körs.

Installera klientbiblioteket

Klientbiblioteket är tillgängligt via PyPi som pymongo paket.

1. Öppna en terminal och navigera till /src mappen.

   cd ./src
   

2. Om det inte redan är installerat, installerar du pymongo-paketet med pip install.

   pip install pymongo
   

3. Om det inte redan är installerat, installerar du azure.identity-paketet med pip install.

   pip install azure.identity
   

4. Öppna och granska filen src/requirements.txt för att verifiera att båda paketposterna finns.

Importera bibliotek

Importera följande namnområden till programkoden:

from azure.identity import DefaultAzureCredential

from pymongo import MongoClient
from pymongo.auth_oidc import OIDCCallback, OIDCCallbackContext, OIDCCallbackResult

Objektmodell

Kodexempel

• Autentisera klienten
• Hämta en databas
• Hämta en samling
• Skapa ett dokument
• Hämta ett dokument
• Förfrågningsdokument

Exempelkoden i mallen använder en databas med namnet cosmicworks och samlingen med namnet products. Samlingen products innehåller information som namn, kategori, kvantitet och en unik identifierare för varje produkt. Samlingen använder egenskapen /category som en fragmentnyckel.

Autentisera klienten

Microsoft Entra-autentisering för Azure Cosmos DB for MongoDB vCore kan använda välkända TokenCredential typer, men du måste implementera en anpassad tokenhanterare. Den här exempelimplementeringen kan användas för att skapa en MongoClient med stöd för Microsoft Entra-standardautentisering av många identitetstyper.

1. Definiera först en klass med namnet AzureIdentityTokenCallback som definierar en fetch funktion som tar in parametern OIDCCallbackContext och returnerar en OIDCCallbackResult.

   class AzureIdentityTokenCallback(OIDCCallback):
       def __init__(self, credential):
           self.credential = credential
   
       def fetch(self, context: OIDCCallbackContext) -> OIDCCallbackResult:
           token = self.credential.get_token(
               "https://ossrdbms-aad.database.windows.net/.default").token
           return OIDCCallbackResult(access_token=token)
   

2. Använd din anpassade hanteringsklass som skickar in en ny instans av typen DefaultAzureCredential

   credential = DefaultAzureCredential()
   
   authProperties = {"OIDC_CALLBACK": AzureIdentityTokenCallback(credential)}
   

3. Skapa en instans av MongoClient med ditt klusternamn och de kända bästa praxis konfigurationsalternativen för Azure Cosmos DB för MongoDB vCore. Konfigurera även din anpassade autentiseringsmekanism.

   clusterName = "<azure-cosmos-db-mongodb-vcore-cluster-name>"
   
   client = MongoClient(
       f"mongodb+srv://{clusterName}.global.mongocluster.cosmos.azure.com/",
       connectTimeoutMS=120000,
       tls=True,
       retryWrites=True,
       authMechanism="MONGODB-OIDC",
       authMechanismProperties=authProperties
   )
   

Hämta en databas

Det här exemplet skapar en instans av typen Database med hjälp av funktionen get_database av typen MongoClient.

database = client.get_database("<database-name>")

Hämta en samling

Det här exemplet skapar en instans av typen Collection med hjälp av funktionen get_collection av typen Database.

collection = database.get_collection("<collection-name>")

Skapa ett dokument

Skapa ett dokument i samlingen med .collection.update_one Den här metoden "uppdaterar eller lägger till" objektet och ersätter det effektivt om det redan finns.

new_document = {
    "_id": "aaaaaaaa-0000-1111-2222-bbbbbbbbbbbb",
    "category": "gear-surf-surfboards",
    "name": "Yamba Surfboard",
    "quantity": 12,
    "sale": False,
}

filter = {
    "_id": "aaaaaaaa-0000-1111-2222-bbbbbbbbbbbb",
    "category": "gear-surf-surfboards"
}

payload = {
    "$set": new_document
}

result = collection.update_one(filter, payload, upsert=True);

Läsa ett dokument

Utför en punktläsningsåtgärd med hjälp av både den unika identifieraren (id) och shardnyckelfältet. Använd collection.find_one för att effektivt hämta det specifika objektet.

filter = {
    "_id": "bbbbbbbb-1111-2222-3333-cccccccccccc",
    "category": "gear-surf-surfboards"
}

existing_document = collection.find_one(filter)

Sök dokument

Utför en fråga över flera objekt i en container med hjälp av collection.find. Den här sökfrågan hittar alla objekt inom en angiven kategori (shardnyckel).

filter = {
    "category": "gear-surf-surfboards"
}

matched_documents = collection.find(filter)

for document in matched_documents:
    # Do something with each item

Ta bort ett dokument

Ta bort ett dokument genom att skicka ett filter för dokumentets unika identifierare. Använd delete_one för att ta bort dokumentet från samlingen.

filter = {
    '_id': id
}

result = collection.delete_one(filter)

Utforska dina data

Använd Visual Studio Code-tillägget för Azure Cosmos DB för att utforska dina MongoDB vCore-data. Du kan utföra grundläggande databasåtgärder, inklusive, men inte begränsat till:

• Utföra sökningar med hjälp av ett skrivblock eller frågeredigeraren
• Ändra, uppdatera, skapa och ta bort dokument
• Importera massdata från andra källor
• Hantera databaser och samlingar

Mer information finns i Använda Visual Studio Code-tillägget för att utforska Azure Cosmos DB for MongoDB vCore-data.

Rensa resurser

När du inte längre behöver exempelprogrammet eller resurserna tar du bort motsvarande distribution och alla resurser.

azd down --force

Relaterat innehåll

• .NET-snabbstart
• Node.js snabbstart