Dela via

Snabbstart: Azure Cosmos DB för Apache Gremlin-biblioteket för Python

  • Artikel

GÄLLER FÖR: Gremlin

Azure Cosmos DB för Apache Gremlin är en fullständigt hanterad grafdatabastjänst som implementerar det populära Apache Tinkerpop, ett diagramberäkningsramverk med hjälp av Gremlin-frågespråket. API:et för Gremlin ger dig ett sätt att komma igång med gremlin med en tjänst som kan växa och skalas ut så mycket du behöver med minimal hantering.

I den här snabbstarten gremlinpython använder du biblioteket för att ansluta till ett nyligen skapat Azure Cosmos DB för Gremlin-konto.

Paket för bibliotekskällkod | (PyPi)

Förutsättningar

Azure Cloud Shell

Azure är värd för Azure Cloud Shell, en interaktiv gränssnittsmiljö som du kan använda via webbläsaren. Du kan använda antingen Bash eller PowerShell med Cloud Shell för att arbeta med Azure-tjänster. Du kan använda förinstallerade Cloud Shell-kommandon för att köra koden i den här artikeln, utan att behöva installera något i din lokala miljö.

Så här startar du Azure Cloud Shell:

Alternativ Exempel/länk
Välj Prova i det övre högra hörnet i en kod eller ett kommandoblock. Om du väljer Prova kopieras inte koden eller kommandot automatiskt till Cloud Shell. Skärmbild som visar ett exempel på Try It for Azure Cloud Shell.
Gå till https://shell.azure.com eller Välj knappen Starta Cloud Shell för att öppna Cloud Shell i webbläsaren. Knapp för att starta Azure Cloud Shell.
Välj knappen Cloud Shell på menyn längst upp till höger i Azure-portalen. Skärmbild som visar Cloud Shell-knappen i Azure-portalen

Så här använder du Azure Cloud Shell:

  1. Starta Cloud Shell.

  2. Välj knappen Kopiera i ett kodblock (eller kommandoblock) för att kopiera koden eller kommandot.

  3. Klistra in koden eller kommandot i Cloud Shell-sessionen genom att välja Ctrl+Skift+V i Windows och Linux, eller genom att välja Cmd+Shift+V på macOS.

  4. Välj Retur för att köra koden eller kommandot.

Konfigurera

Det här avsnittet beskriver hur du skapar ett API för Gremlin-konto och konfigurerar ett Python-projekt för att använda biblioteket för att ansluta till kontot.

Skapa ett API för Gremlin-konto

API:et för Gremlin-kontot bör skapas innan du använder Python-biblioteket. Dessutom hjälper det att även ha databasen och grafen på plats.

  1. Skapa gränssnittsvariabler för accountName, resourceGroupName och plats.

    # Variable for resource group name
resourceGroupName="msdocs-cosmos-gremlin-quickstart"
location="westus"

# Variable for account name with a randomly generated suffix

let suffix=$RANDOM*$RANDOM
accountName="msdocs-gremlin-$suffix"

  2. Om du inte redan har gjort det loggar du in på Azure CLI med .az login

  3. Använd az group create för att skapa en ny resursgrupp i din prenumeration.

    az group create \
    --name $resourceGroupName \
    --location $location

  4. Använd az cosmosdb create för att skapa ett nytt API för Gremlin-konto med standardinställningar.

    az cosmosdb create \
    --resource-group $resourceGroupName \
    --name $accountName \
    --capabilities "EnableGremlin" \
    --locations regionName=$location \
    --enable-free-tier true

    Kommentar

    Du kan högst ha ett Azure Cosmos DB-konto med kostnadsfri nivå per Azure-prenumeration och du måste välja det när du skapar kontot. Om det här kommandot inte kan tillämpa rabatten på den kostnadsfria nivån innebär det att ett annat konto i prenumerationen redan har aktiverats med den kostnadsfria nivån.

  5. Hämta API:et för Gremlin-slutpunktens NAMN för kontot med hjälp av az cosmosdb show.

    az cosmosdb show \
    --resource-group $resourceGroupName \
    --name $accountName \
    --query "name"

  6. Hitta nyckeln i listan med nycklar för kontot med az-cosmosdb-keys-list.

    az cosmosdb keys list \
    --resource-group $resourceGroupName \
    --name $accountName \
    --type "keys" \
    --query "primaryMasterKey"

  7. Registrera värdena NAME och KEY. Du använder dessa autentiseringsuppgifter senare.

  8. Skapa en databas med namnet cosmicworks med .az cosmosdb gremlin database create

    az cosmosdb gremlin database create \
    --resource-group $resourceGroupName \
    --account-name $accountName \
    --name "cosmicworks"

  9. Skapa en graf med hjälp av az cosmosdb gremlin graph create. Namnge grafen productsoch ange sedan dataflödet till 400och ställ slutligen in partitionsnyckelsökvägen till /category.

    az cosmosdb gremlin graph create \
    --resource-group $resourceGroupName \
    --account-name $accountName \
    --database-name "cosmicworks" \
    --name "products" \
    --partition-key-path "/category" \
    --throughput 400

Skapa ett nytt Python-konsolprogram

Skapa ett Python-konsolprogram i en tom mapp med hjälp av önskad terminal.

  1. Öppna terminalen i en tom mapp.

  2. Skapa filen app.py .

    touch app.py

Installera PyPI-paketet

gremlinpython Lägg till PyPI-paketet i Python-projektet.

  1. Skapa filen requirements.txt .

    touch requirements.txt

  2. gremlinpython Lägg till paketet från Python Package Index i kravfilen.

    gremlinpython==3.7.0

  3. Installera alla krav i projektet.

    python install -r requirements.txt

Konfigurera miljövariabler

Om du vill använda de NAMN- och URI-värden som hämtades tidigare i den här snabbstarten sparar du dem i nya miljövariabler på den lokala dator som kör programmet.

  1. Om du vill ange miljövariabeln använder du terminalen för att spara värdena som COSMOS_ENDPOINT respektive COSMOS_KEY .

    export COSMOS_GREMLIN_ENDPOINT="<account-name>"
export COSMOS_GREMLIN_KEY="<account-key>"

  2. Kontrollera att miljövariablerna har angetts korrekt.

    printenv COSMOS_GREMLIN_ENDPOINT
printenv COSMOS_GREMLIN_KEY

Kodexempel

Koden i den här artikeln ansluter till en databas med namnet cosmicworks och ett diagram med namnet products. Koden lägger sedan till hörn och kanter i diagrammet innan du går igenom de tillagda objekten.

Autentisera klienten

Programbegäranden till de flesta Azure-tjänster måste auktoriseras. För API:et för Gremlin använder du de NAME- och URI-värden som hämtades tidigare i den här snabbstarten.

  1. Öppna filen app.py .

  2. Importera client och serializer från modulen gremlin_python.driver .

    import os
from gremlin_python.driver import client, serializer

    Varning

    Beroende på din version av Python kan du också behöva importera asyncio och åsidosätta händelseloopprincipen:

    import asyncio
import sys

if sys.platform == "win32":
    asyncio.set_event_loop_policy(asyncio.WindowsSelectorEventLoopPolicy())

  3. Skapa ACCOUNT_NAME och ACCOUNT_KEY variabler. COSMOS_GREMLIN_ENDPOINT Lagra miljövariablerna och COSMOS_GREMLIN_KEY som värden för varje variabel.

    ACCOUNT_NAME = os.environ["COSMOS_GREMLIN_ENDPOINT"]
ACCOUNT_KEY = os.environ["COSMOS_GREMLIN_KEY"]

  4. Använd Client för att ansluta med kontots autentiseringsuppgifter och GraphSON 2.0-serialiseraren.

    client = client.Client(
    url=f"wss://{ACCOUNT_NAME}.gremlin.cosmos.azure.com:443/",
    traversal_source="g",
    username="/dbs/cosmicworks/colls/products",
    password=f"{ACCOUNT_KEY}",
    message_serializer=serializer.GraphSONSerializersV2d0(),
)

Skapa hörn

Nu när programmet är anslutet till kontot använder du Gremlin-standardsyntaxen för att skapa hörn.

  1. Använd submit för att köra en kommandoserversida på API:et för Gremlin-kontot. Skapa ett produkthörn med följande egenskaper:

    Värde
    etikett product
    id 68719518371
    name Kiama classic surfboard
    price 285.55
    category surfboards 
    client.submit(
    message=(
        "g.addV('product')"
        ".property('id', prop_id)"
        ".property('name', prop_name)"
        ".property('price', prop_price)"
        ".property('category', prop_partition_key)"
    ),
    bindings={
        "prop_id": "68719518371",
        "prop_name": "Kiama classic surfboard",
        "prop_price": 285.55,
        "prop_partition_key": "surfboards",
    },
)

  2. Skapa ett andra produkthörn med följande egenskaper:

    Värde
    etikett product
    id 68719518403
    name Montau Turtle Surfboard
    price 600.00
    category surfboards 
    client.submit(
    message=(
        "g.addV('product')"
        ".property('id', prop_id)"
        ".property('name', prop_name)"
        ".property('price', prop_price)"
        ".property('category', prop_partition_key)"
    ),
    bindings={
        "prop_id": "68719518403",
        "prop_name": "Montau Turtle Surfboard",
        "prop_price": 600.00,
        "prop_partition_key": "surfboards",
    },
)

  3. Skapa ett tredje produkthörn med följande egenskaper:

    Värde
    etikett product
    id 68719518409
    name Bondi Twin Surfboard
    price 585.50
    category surfboards 
    client.submit(
    message=(
        "g.addV('product')"
        ".property('id', prop_id)"
        ".property('name', prop_name)"
        ".property('price', prop_price)"
        ".property('category', prop_partition_key)"
    ),
    bindings={
        "prop_id": "68719518409",
        "prop_name": "Bondi Twin Surfboard",
        "prop_price": 585.50,
        "prop_partition_key": "surfboards",
    },
)

Skapa kanter

Skapa kanter med Gremlin-syntaxen för att definiera relationer mellan hörn.

  1. Skapa en kant från produkten Montau Turtle Surfboard med namnet ersätter produkten Kiama classic surfboard .

    client.submit(
    message=(
        "g.V([prop_partition_key, prop_source_id])"
        ".addE('replaces')"
        ".to(g.V([prop_partition_key, prop_target_id]))"
    ),
    bindings={
        "prop_partition_key": "surfboards",
        "prop_source_id": "68719518403",
        "prop_target_id": "68719518371",
    },
)

    Dricks

    Den här gränsdefiniering använder syntaxen g.V(['<partition-key>', '<id>']) . Du kan också använda g.V('<id>').has('category', '<partition-key>').

  2. Skapa en annan ersätter gränsen från samma produkt till Bondi Twin Surfboard.

    client.submit(
    message=(
        "g.V([prop_partition_key, prop_source_id])"
        ".addE('replaces')"
        ".to(g.V([prop_partition_key, prop_target_id]))"
    ),
    bindings={
        "prop_partition_key": "surfboards",
        "prop_source_id": "68719518403",
        "prop_target_id": "68719518409",
    },
)

Frågehörn och kanter

Använd Gremlin-syntaxen för att bläddra i diagrammet och identifiera relationer mellan hörn.

  1. Bläddra i grafen och leta reda på alla hörn som Montau Turtle Surfboard ersätter.

    result = client.submit(
    message=(
        "g.V().hasLabel('product')"
        ".has('category', prop_partition_key)"
        ".has('name', prop_name)"
        ".outE('replaces').inV()"
    ),
    bindings={
        "prop_partition_key": "surfboards",
        "prop_name": "Montau Turtle Surfboard",
    },
)

  2. Skriv till konsolen resultatet av denna bläddering.

    print(result)

Kör koden

Kontrollera att programmet fungerar som förväntat genom att köra programmet. Programmet ska köras utan fel eller varningar. Programmets utdata innehåller data om de skapade och efterfrågade objekten.

  1. Öppna terminalen i Python-projektmappen.

  2. Använd python <filename> för att köra programmet. Observera utdata från programmet.

    python app.py

Rensa resurser

När du inte längre behöver API:et för Gremlin-kontot tar du bort motsvarande resursgrupp.

  1. Skapa en gränssnittsvariabel för resourceGroupName om den inte redan finns.

    # Variable for resource group name
resourceGroupName="msdocs-cosmos-gremlin-quickstart"

  2. Använd az group delete för att ta bort resursgruppen.

    az group delete \
    --name $resourceGroupName

Gå vidare

Skapa och fråga efter data med Hjälp av Azure Cosmos DB för Apache Gremlin