Szybki start: biblioteka klienta Azure Cosmos DB dla Apache Gremlin dla Pythona

Dotyczy: ✅ Apache Gremlin

Ważne

Szukasz rozwiązania bazy danych dla scenariuszy o dużej skali z umową SLA gwarantującą poziom dostępności na poziomie 99,999%, natychmiastowym skalowaniem automatycznym i automatycznym przełączaniem awaryjnym między wieloma regionami? Rozważmy usługę Azure Cosmos DB dla noSQL.

Czy chcesz zaimplementować graf przetwarzania analitycznego online (OLAP) lub przeprowadzić migrację istniejącej aplikacji Apache Gremlin? Rozważ użycie programu Graph w usłudze Microsoft Fabric.

Rozpocznij pracę z biblioteką klienta usługi Azure Cosmos DB dla języka Apache Gremlin dla języka Python, aby przechowywać dane bez struktury i zarządzać nimi. Wykonaj kroki opisane w tym przewodniku, aby utworzyć nowe konto, zainstalować bibliotekę klienta języka Python, nawiązać połączenie z kontem, wykonać typowe operacje i wykonać zapytania dotyczące końcowych danych przykładowych.

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

Wymagania wstępne

Subskrypcja platformy Azure
- Jeśli nie masz subskrypcji Azure, przed rozpoczęciem utwórz darmowe konto.

Najnowsza wersja interfejsu wiersza polecenia platformy Azure w usłudze Azure Cloud Shell.
- Jeśli wolisz uruchamiać polecenia referencyjne CLI lokalnie, zaloguj się do Azure CLI przy użyciu polecenia az login.

Środowisko Python w wersji 3.12 lub nowszej

Konfigurowanie

Najpierw skonfiguruj konto i środowisko programistyczne dla tego przewodnika. W tej sekcji przedstawiono proces tworzenia konta, uzyskiwania poświadczeń, a następnie przygotowywania środowiska deweloperskiego.

Tworzenie konta

Zacznij od utworzenia interfejsu API dla konta apache Gremlin. Po utworzeniu konta utwórz bazę danych i zasoby grafu.

Interfejs wiersza polecenia platformy Azure
Portal Azure

Jeśli nie masz jeszcze docelowej grupy zasobów, użyj az group create polecenia , aby utworzyć nową grupę zasobów w ramach subskrypcji.
```
az group create \
    --name "<resource-group-name>" \
    --location "<location>"
```

Użyj polecenia az cosmosdb create aby utworzyć nowe konto usługi Azure Cosmos DB dla Apache Gremlin z ustawieniami domyślnymi.

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

Utwórz nową bazę danych przy użyciu az cosmosdb gremlin database create nazwy cosmicworks.

az cosmosdb gremlin database create \
    --resource-group "<resource-group-name>" \
    --account-name "<account-name>" \
    --name "cosmicworks"

Użyj polecenia , az cosmosdb gremlin graph create aby utworzyć nowy graf o nazwie products.

az cosmosdb gremlin graph create \
    --resource-group "<resource-group-name>" \
    --account-name "<account-name>" \
    --database-name "cosmicworks" \
    --name "products" \
    --partition-key-path "/category"

Zaloguj się do witryny Azure Portal (https://portal.azure.com).
Wprowadź wartość Azure Cosmos DB na pasku wyszukiwania globalnego.
W obszarze Usługi wybierz pozycję Azure Cosmos DB.
W okienku Azure Cosmos DB wybierz pozycję Utwórz, a następnie pozycję Azure Cosmos DB for Apache Gremlin na karcie Inne .

W okienku Podstawowe skonfiguruj następujące opcje, a następnie wybierz pozycję Przejrzyj i utwórz:

	Wartość
Typ obciążenia	Szkolenie
Subskrypcja	Wybierz subskrypcję platformy Azure
Grupa zasobów	Utwórz nową grupę zasobów lub wybierz istniejącą grupę zasobów
Nazwa konta	Podaj globalnie unikatową nazwę
Strefy dostępności	Wyłącz
Lokalizacja	Wybieranie obsługiwanego regionu platformy Azure dla subskrypcji

Napiwek

Możesz pozostawić wszystkie nieokreślone opcje do ich wartości domyślnych. Możesz również skonfigurować konto, aby ograniczyć łączną przepływność konta do 1000 jednostek żądań na sekundę (RU/s) lub włączyć warstwę Bezpłatna, aby zminimalizować koszty.

W okienku Przeglądanie i tworzenie poczekaj na pomyślne zakończenie walidacji konta, a następnie wybierz pozycję Utwórz.
Portal automatycznie przechodzi do okienka Wdrażanie. Poczekaj na zakończenie wdrożenia.
Po zakończeniu wdrażania wybierz pozycję Przejdź do zasobu, aby przejść do nowego API konta Apache Gremlin.
W menu zasobów wybierz opcję Eksplorator danych .
W Eksploratorze danych wybierz pozycję + Nowy wykres.

W oknie dialogowym Dodawanie grafu skonfiguruj następujące opcje, a następnie wybierz przycisk OK:

	Wartość
Baza danych	Utwórz nową
Nazwa bazy danych	`cosmicworks`
Nazwa grafu	`products`
klucz partycji	`/category`

Napiwek

Możesz pozostawić wszystkie nieokreślone opcje do ich wartości domyślnych.

Pobieranie poświadczeń

Teraz pobierz hasło biblioteki klienta do utworzenia połączenia z niedawno utworzonym kontem.

Interfejs wiersza polecenia platformy Azure
Portal Azure

Użyj az cosmosdb show, aby pobrać hosta dla konta.

az cosmosdb show \
    --resource-group "<resource-group-name>" \
    --name "<account-name>" \
    --query "{host:name}"

Zapisz wartość właściwości host z wyników wcześniejszych poleceń. Wartość tej właściwości jest hostem używanym w dalszej części tego przewodnika w celu nawiązania połączenia z kontem z biblioteką.

Użyj az cosmosdb keys list, aby uzyskać klucze dla konta.

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

Zapisz wartość właściwości primaryMasterKey z wyników wcześniejszych poleceń. Wartość tej właściwości jest kluczem używanym w dalszej części tego przewodnika w celu nawiązania połączenia z kontem z biblioteką.

Przygotowywanie środowiska projektowego

Następnie skonfiguruj środowisko deweloperskie przy użyciu nowego projektu i biblioteki klienta. Ten krok jest ostatnim wymaganiem wstępnym przed przejściem do pozostałej części tego przewodnika.

Rozpocznij w pustym folderze.
Zaimportuj pakiet z indeksu gremlinpython pakietów języka Python (PyPI).
```
pip install gremlinpython
```
Utwórz plik app.py.

Model obiektów

	Opis
`GremlinClient`	Reprezentuje klienta używanego do nawiązywania połączenia z serwerem Gremlin i interakcji z nim
`GraphTraversalSource`	Służy do konstruowania i wykonywania trawersowania w Gremlin

Uwierzytelnianie klienta

Zacznij od uwierzytelnienia klienta przy użyciu poświadczeń zebranych wcześniej w tym przewodniku.

Otwórz plik app.py w zintegrowanym środowisku projektowym (IDE).
Z biblioteki gremlin_python.driver zaimportuj następujące typy:
- gremlin_python.driver.client
- gremlin_python.driver.serializer
```
from gremlin_python.driver import client, serializer
```
Utwórz zmienne tekstowe dla poświadczeń zebranych wcześniej w tym przewodniku. Nazwij zmienne hostname i primary_key.
```
hostname = "<host>"
primary_key = "<key>"
```

Client Utwórz obiekt przy użyciu poświadczeń i zmiennych konfiguracji utworzonych w poprzednich krokach. Nadaj zmiennej clientnazwę .

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

Wstawianie danych

Następnie wstaw nowe dane wierzchołka i krawędzi do grafu. Przed utworzeniem nowych danych wyczyść graf wszystkich istniejących danych.

Uruchom zapytanie, g.V().drop() aby wyczyścić wszystkie wierzchołki i krawędzie z grafu.
```
client.submit("g.V().drop()").all().result()
```

Utwórz zapytanie Gremlin, które dodaje wierzchołek.

insert_vertex_query = (
    "g.addV('product')"
    ".property('id', prop_id)"
    ".property('name', prop_name)"
    ".property('category', prop_category)"
    ".property('quantity', prop_quantity)"
    ".property('price', prop_price)"
    ".property('clearance', prop_clearance)"
)

Dodaj wierzchołek dla pojedynczego produktu.

client.submit(
    message=insert_vertex_query,
    bindings={
        "prop_id": "aaaaaaaa-0000-1111-2222-bbbbbbbbbbbb",
        "prop_name": "Yamba Surfboard",
        "prop_category": "gear-surf-surfboards",
        "prop_quantity": 12,
        "prop_price": 850.00,
        "prop_clearance": False,
    },
).all().result()

Dodaj dwa kolejne wierzchołki dla dwóch dodatkowych produktów.

client.submit(
    message=insert_vertex_query,
    bindings={
        "prop_id": "bbbbbbbb-1111-2222-3333-cccccccccccc",
        "prop_name": "Montau Turtle Surfboard",
        "prop_category": "gear-surf-surfboards",
        "prop_quantity": 5,
        "prop_price": 600.00,
        "prop_clearance": True,
    },
).all().result()

client.submit(
    message=insert_vertex_query,
    bindings={
        "prop_id": "cccccccc-2222-3333-4444-dddddddddddd",
        "prop_name": "Noosa Surfboard",
        "prop_category": "gear-surf-surfboards",
        "prop_quantity": 31,
        "prop_price": 1100.00,
        "prop_clearance": False,
    },
).all().result()

Utwórz kolejne zapytanie Języka Gremlin, które dodaje krawędź.

insert_edge_query = (
    "g.V([prop_partition_key, prop_source_id])"
    ".addE('replaces')"
    ".to(g.V([prop_partition_key, prop_target_id]))"
)

Dodaj dwie krawędzie.

client.submit(
    message=insert_edge_query,
    bindings={
        "prop_partition_key": "gear-surf-surfboards",
        "prop_source_id": "bbbbbbbb-1111-2222-3333-cccccccccccc",
        "prop_target_id": "aaaaaaaa-0000-1111-2222-bbbbbbbbbbbb",
    },
).all().result()

client.submit(
    message=insert_edge_query,
    bindings={
        "prop_partition_key": "gear-surf-surfboards",
        "prop_source_id": "bbbbbbbb-1111-2222-3333-cccccccccccc",
        "prop_target_id": "cccccccc-2222-3333-4444-dddddddddddd",
    },
).all().result()

Odczyt danych

Następnie odczytaj dane, które zostały wcześniej wstawione do grafu.

Utwórz zapytanie, które odczytuje wierzchołek przy użyciu unikatowego identyfikatora i wartości klucza partycji.
```
read_vertex_query = "g.V([prop_partition_key, prop_id])"
```

Następnie odczytaj wierzchołek, podając wymagane parametry.

matched_item = client.submit(
    message=read_vertex_query,
    bindings={
        "prop_partition_key": "gear-surf-surfboards",
        "prop_id": "aaaaaaaa-0000-1111-2222-bbbbbbbbbbbb"
    }
).one()

Wykonywanie zapytań o dane

Na koniec użyj zapytania, aby znaleźć wszystkie dane zgodne z określonym przechodzeniem lub filtrem na grafie.

Utwórz zapytanie, które znajduje wszystkie wierzchołki wychodzące z określonego wierzchołka.

find_vertices_query = (
    "g.V().hasLabel('product')"
    ".has('category', prop_partition_key)"
    ".has('name', prop_name)"
    ".outE('replaces').inV()"
)

Wykonaj zapytanie określające Montau Turtle Surfboard produkt.

find_results = client.submit(
    message=find_vertices_query,
    bindings={
        "prop_partition_key": "gear-surf-surfboards",
        "prop_name": "Montau Turtle Surfboard",
    },
).all().result()

Iterowanie wyników zapytania.

for result in find_results:
    # Do something here with each result

Uruchamianie kodu

Uruchom nowo utworzoną aplikację przy użyciu terminalu w katalogu aplikacji.

python app.py

Czyszczenie zasobów

Jeśli konto nie jest już potrzebne, usuń konto z subskrypcji platformy Azure, usuwając zasób.

Interfejs wiersza polecenia platformy Azure
Portal Azure

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

Sprzężenie zwrotne

Czy ta strona była pomocna?

Last updated on 2025-10-30