Szybki start: biblioteka Azure Cosmos DB dla języka Apache Gremlin dla języka Python

Artykuł
08/15/2024

DOTYCZY: Gremlin

Azure Cosmos DB for Apache Gremlin to w pełni zarządzana usługa bazy danych grafów, która implementuje popularną Apache Tinkerpopplatformę obliczeniową grafu przy użyciu języka zapytań Gremlin. Interfejs API dla języka Gremlin umożliwia rozpoczęcie pracy z językiem Gremlin z usługą, która może rozwijać się i skalować w poziomie tak samo, jak w przypadku minimalnego zarządzania.

W tym przewodniku gremlinpython Szybki start użyjesz biblioteki do nawiązania połączenia z nowo utworzonym kontem usługi Azure Cosmos DB dla języka Gremlin.

Pakiet kodu | źródłowego biblioteki (PyPi)

Wymagania wstępne

Konto platformy Azure z aktywną subskrypcją.
- Brak subskrypcji platformy Azure? Utwórz bezpłatne konto platformy Azure.
- Nie chcesz subskrypcji platformy Azure? Możesz wypróbować usługę Azure Cosmos DB bezpłatnie bez konieczności korzystania z subskrypcji.
Python (najnowsza wersja)
- Nie masz zainstalowanego języka Python? Wypróbuj ten przewodnik Szybki start w usłudze GitHub Codespaces.
Interfejs wiersza polecenia platformy Azure

Azure Cloud Shell

Na platforma Azure hostowane jest Azure Cloud Shell, interaktywne środowisko powłoki, z którego można korzystać w przeglądarce. Do pracy z usługami platformy Azure można używać programu Bash lub PowerShell w środowisku Cloud Shell. Aby uruchomić kod w tym artykule, możesz użyć wstępnie zainstalowanych poleceń usługi Cloud Shell bez konieczności instalowania niczego w środowisku lokalnym.

Aby uruchomić środowisko Azure Cloud Shell:

Opcja	Przykład/link
Wybierz pozycję Wypróbuj w prawym górnym rogu bloku kodu lub polecenia. Wybranie pozycji Wypróbuj nie powoduje automatycznego skopiowania kodu lub polecenia do usługi Cloud Shell.
Przejdź do witryny https://shell.azure.com lub wybierz przycisk Uruchom Cloud Shell, aby otworzyć środowisko Cloud Shell w przeglądarce.
Wybierz przycisk Cloud Shell na pasku menu w prawym górnym rogu witryny Azure Portal.

Aby użyć usługi Azure Cloud Shell:

Uruchom usługę Cloud Shell.
Wybierz przycisk Kopiuj w bloku kodu (lub bloku poleceń), aby skopiować kod lub polecenie.
Wklej kod lub polecenie do sesji usługi Cloud Shell, wybierając Ctrl+Shift V w systemach Windows i Linux lub wybierając pozycję Cmd+Shift++V w systemie macOS.
Wybierz Enter, aby uruchomić kod lub polecenie.

Konfigurowanie

W tej sekcji opisano proces tworzenia interfejsu API dla konta języka Gremlin i konfigurowania projektu języka Python w celu używania biblioteki do nawiązywania połączenia z kontem.

Tworzenie interfejsu API dla konta języka Gremlin

Interfejs API dla konta języka Gremlin należy utworzyć przed użyciem biblioteki języka Python. Ponadto ułatwia także umieszczenie bazy danych i grafu.

Utwórz zmienne powłoki dla parametrów accountName, resourceGroupName i location.

# 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"

Jeśli jeszcze tego nie zrobiono, zaloguj się do interfejsu wiersza polecenia platformy Azure przy użyciu polecenia az login.
Użyj az group create polecenia , aby utworzyć nową grupę zasobów w ramach subskrypcji.
```
az group create \
    --name $resourceGroupName \
    --location $location
```
Użyj az cosmosdb create polecenia , aby utworzyć nowy interfejs API dla konta języka Gremlin z ustawieniami domyślnymi.
```
az cosmosdb create \
    --resource-group $resourceGroupName \
    --name $accountName \
    --capabilities "EnableGremlin" \
    --locations regionName=$location \
    --enable-free-tier true
```
Uwaga

W ramach jednej subskrypcji platformy Azure można korzystać z maksymalnie jednego konta usługi Azure Cosmos DB w warstwie Bezpłatna. Tę opcję należy wybrać podczas tworzenia konta. Jeśli to polecenie nie zastosuje rabatu w warstwie Bezpłatna, oznacza to, że inne konto w subskrypcji zostało już włączone z warstwą Bezpłatna.
Pobierz interfejs API dla nazwy punktu końcowego języka Gremlin dla konta przy użyciu polecenia az cosmosdb show.
```
az cosmosdb show \
    --resource-group $resourceGroupName \
    --name $accountName \
    --query "name"
```

Znajdź klucz z listy kluczy dla konta za pomocą polecenia az-cosmosdb-keys-list.

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

Zapisz wartości NAME i KEY. Te poświadczenia będą używane później.

Utwórz bazę danych o nazwie cosmicworks przy użyciu polecenia az cosmosdb gremlin database create.

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

Utwórz graf przy użyciu polecenia az cosmosdb gremlin graph create. Nadaj grafowi productsnazwę , a następnie ustaw przepływność na 400, a na koniec ustaw ścieżkę klucza partycji na /category.

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

Tworzenie nowej aplikacji konsolowej języka Python

Utwórz aplikację konsolową języka Python w pustym folderze przy użyciu preferowanego terminalu.

Otwórz terminal w pustym folderze.
Utwórz plik app.py.
```
touch app.py
```

Instalowanie pakietu PyPI

gremlinpython Dodaj pakiet PyPI do projektu języka Python.

Utwórz plik requirements.txt.
```
touch requirements.txt
```
gremlinpython Dodaj pakiet z indeksu pakietów języka Python do pliku wymagań.
```
gremlinpython==3.7.0
```
Zainstaluj wszystkie wymagania dotyczące projektu.
```
python install -r requirements.txt
```

Skonfiguruj zmienne środowiskowe

Aby użyć wartości NAME i URI uzyskanych wcześniej w tym przewodniku Szybki start, utrwali je w nowych zmiennych środowiskowych na komputerze lokalnym z uruchomioną aplikacją.

Aby ustawić zmienną środowiskową, użyj terminalu, aby utrwał wartości odpowiednio jako COSMOS_ENDPOINT i COSMOS_KEY .
```
export COSMOS_GREMLIN_ENDPOINT="<account-name>"
export COSMOS_GREMLIN_KEY="<account-key>"
```
Sprawdź, czy zmienne środowiskowe zostały poprawnie ustawione.
```
printenv COSMOS_GREMLIN_ENDPOINT
printenv COSMOS_GREMLIN_KEY
```

Kod w tym artykule łączy się z bazą danych o nazwie cosmicworks i grafem o nazwie products. Następnie kod dodaje wierzchołki i krawędzie do grafu przed przejściem przez dodane elementy.

Uwierzytelnianie użytkownika

Żądania aplikacji do większości usług platformy Azure muszą być autoryzowane. W przypadku interfejsu API dla języka Gremlin użyj wartości NAME i URI uzyskanych wcześniej w tym przewodniku Szybki start.

Otwórz plik app.py.
Zaimportuj client i serializer z modułu gremlin_python.driver .
```
import os
from gremlin_python.driver import client, serializer
```
Ostrzeżenie

W zależności od wersji języka Python może być również konieczne zaimportowanie asyncio i zastąpienie zasad pętli zdarzeń:
```
import asyncio
import sys

if sys.platform == "win32":
    asyncio.set_event_loop_policy(asyncio.WindowsSelectorEventLoopPolicy())
```
Tworzenie ACCOUNT_NAME zmiennych i ACCOUNT_KEY . COSMOS_GREMLIN_ENDPOINT Zapisz zmienne środowiskowe i COSMOS_GREMLIN_KEY jako wartości dla każdej odpowiedniej zmiennej.
```
ACCOUNT_NAME = os.environ["COSMOS_GREMLIN_ENDPOINT"]
ACCOUNT_KEY = os.environ["COSMOS_GREMLIN_KEY"]
```

Użyj Client polecenia , aby nawiązać połączenie przy użyciu poświadczeń konta i serializatora GraphSON 2.0 .

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(),
)

Tworzenie wierzchołków

Teraz, gdy aplikacja jest połączona z kontem, użyj standardowej składni języka Gremlin do tworzenia wierzchołków.

Użyj submit polecenia , aby uruchomić polecenie po stronie serwera w interfejsie API dla konta gremlin. Utwórz wierzchołek produktu z następującymi właściwościami:

	Wartość
etykieta	`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",
    },
)

Utwórz drugi wierzchołek produktu z następującymi właściwościami:

	Wartość
etykieta	`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",
    },
)

Utwórz trzeci wierzchołek produktu z następującymi właściwościami:

	Wartość
etykieta	`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",
    },
)

Tworzenie krawędzi

Tworzenie krawędzi przy użyciu składni języka Gremlin w celu zdefiniowania relacji między wierzchołkami.

Utwórz krawędź z Montau Turtle Surfboard produktu o nazwie replaces do Kiama classic surfboard produktu.

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",
    },
)

Napiwek

Ta defincja krawędzi używa g.V(['<partition-key>', '<id>']) składni . Alternatywnie możesz użyć polecenia g.V('<id>').has('category', '<partition-key>').

Utwórz inny element zastępujący krawędź z tego samego produktu do elementu 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",
    },
)

Wierzchołki i krawędzie zapytań

Składnia języka Gremlin umożliwia przechodzenie przez graf i odnajdywanie relacji między wierzchołkami.

Przechodzenie przez graf i znajdowanie wszystkich wierzchołków, które Montau Turtle Surfboard zastępują.

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",
    },
)

Zapisz w konsoli wynik tego przechodzenia.
```
print(result)
```

Uruchamianie kodu

Sprawdź, czy aplikacja działa zgodnie z oczekiwaniami, uruchamiając aplikację. Aplikacja powinna być wykonywana bez błędów ani ostrzeżeń. Dane wyjściowe aplikacji zawierają dane dotyczące utworzonych i zapytanych elementów.

Otwórz terminal w folderze projektu języka Python.
Użyj polecenia python <filename> , aby uruchomić aplikację. Obserwuj dane wyjściowe z aplikacji.
```
python app.py
```

Czyszczenie zasobów

Jeśli nie potrzebujesz już interfejsu API dla konta gremlin, usuń odpowiednią grupę zasobów.

Utwórz zmienną powłoki dla właściwości resourceGroupName , jeśli jeszcze nie istnieje.
```
# Variable for resource group name
resourceGroupName="msdocs-cosmos-gremlin-quickstart"
```
Użyj polecenia az group delete , aby usunąć grupę zasobów.
```
az group delete \
    --name $resourceGroupName
```

Następny krok

Tworzenie i wykonywanie zapytań dotyczących danych przy użyciu usługi Azure Cosmos DB dla języka Apache Gremlin

Udostępnij za pośrednictwem