Szybki start: przechodzenie wierzchołków i krawędzi za pomocą konsoli Języka Gremlin i usługi Azure Cosmos DB dla języka Apache Gremlin

Artykuł
10/18/2023

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 Szybki start użyjesz konsoli języka Gremlin do nawiązania połączenia z nowo utworzonym kontem usługi Azure Cosmos DB dla języka Gremlin.

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.
Host platformy Docker
- Nie masz zainstalowanej platformy Docker? 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 klawisze Ctrl+Shift V w systemach Windows i Linux lub wybierając pozycję Cmd+Shift++V w systemie macOS.
Wybierz klawisz Enter, aby uruchomić kod lub polecenie.

Tworzenie interfejsu API dla konta gremlin i odpowiednich zasobów

Interfejs API dla konta języka Gremlin należy utworzyć przed użyciem konsoli gremlin. 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

Uruchamianie i konfigurowanie konsoli języka Gremlin przy użyciu platformy Docker

W przypadku konsoli gremlin ten przewodnik Szybki start używa obrazu kontenera tinkerpop/gremlin-console z usługi Docker Hub. Ten obraz gwarantuje, że używasz odpowiedniej wersji konsoli (3.4) na potrzeby połączenia z interfejsem API dla języka Gremlin. Po uruchomieniu konsoli nawiąż połączenie z lokalnego hosta platformy Docker z zdalnym interfejsem API dla konta języka Gremlin.

3.4 Pobierz wersję obrazu konteneratinkerpop/gremlin-console.
```
docker pull tinkerpop/gremlin-console:3.4
```

Utwórz pusty folder roboczy. W pustym folderze utwórz plik remote-secure.yaml . Dodaj tę konfigurację YAML do pliku.

hosts: [<account-name>.gremlin.cosmos.azure.com]
port: 443
username: /dbs/cosmicworks/colls/products
password: <account-key>
connectionPool: {
  enableSsl: true,
  sslEnabledProtocols: [TLSv1.2]
}
serializer: {
  className: org.apache.tinkerpop.gremlin.driver.ser.GraphSONMessageSerializerV2d0,
  config: {
    serializeResultToString: true
  }
}

Uwaga

<account-name> Zastąp symbole zastępcze i <account-key> wartościami NAME i KEY uzyskanymi wcześniej w tym przewodniku Szybki start.

Otwórz nowy terminal w kontekście folderu roboczego, który zawiera plik remote-secure.yaml .
Uruchom obraz kontenera platformy Docker w trybie interaktywnym (--interactive --tty). Upewnij się, że bieżący folder roboczy został zamontowany w /opt/gremlin-console/conf/ ścieżce w kontenerze.
```
docker run -it --mount type=bind,source=.,target=/opt/gremlin-console/conf/ tinkerpop/gremlin-console:3.4
```
W kontenerze konsoli języka Gremlin połącz się ze zdalnym kontem (interfejs API dla języka Gremlin) przy użyciu pliku konfiguracji remote-secure.yaml .
```
:remote connect tinkerpop.server conf/remote-secure.yaml
```

Tworzenie i przechodzenie wierzchołków i krawędzi

Teraz, gdy konsola jest połączona z kontem, użyj standardowej składni języka Gremlin, aby utworzyć i przejść zarówno wierzchołki, jak i krawędzie.

Dodaj wierzchołek produktu z następującymi właściwościami:

Wartość

Etykiety product

id 68719518371

name Kiama classic surfboard

price 285.55

category surfboards
```
:> g.addV('product').property('id', '68719518371').property('name', 'Kiama classic surfboard').property('price', 285.55).property('category', 'surfboards')
```
Ważne

Nie foget prefiksu :> . Prefiks THis jest wymagany do zdalnego uruchamiania polecenia.
Dodaj kolejny wierzchołek produktu z następującymi właściwościami:

Wartość

Etykiety product

id 68719518403

name Montau Turtle Surfboard

price 600

category surfboards
```
:> g.addV('product').property('id', '68719518403').property('name', 'Montau Turtle Surfboard').property('price', 600).property('category', 'surfboards')
```

	Wartość
Etykiety	`product`
id	`68719518371`
`name`	`Kiama classic surfboard`
`price`	`285.55`
`category`	`surfboards`

	Wartość
Etykiety	`product`
id	`68719518403`
`name`	`Montau Turtle Surfboard`
`price`	`600`
`category`	`surfboards`

Utwórz krawędź o nazwie replaces , aby zdefiniować relację między dwoma produktami.

:> g.V(['surfboards', '68719518403']).addE('replaces').to(g.V(['surfboards', '68719518371']))

Zlicz wszystkie wierzchołki w obrębie grafu.
```
:> g.V().count()
```

Przejdź przez graf, aby znaleźć wszystkie wierzchołki, które zastępują element Kiama classic surfboard.

:> g.V().hasLabel('product').has('category', 'surfboards').has('name', 'Kiama classic surfboard').inE('replaces').outV()

Przejdź przez graf, aby znaleźć wszystkie wierzchołki, które Montau Turtle Surfboard zastępują.

:> g.V().hasLabel('product').has('category', 'surfboards').has('name', 'Montau Turtle Surfboard').outE('replaces').inV()

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
```

Jak rozwiązaliśmy ten problem?

Usługa Azure Cosmos DB dla języka Apache Gremlin rozwiązała nasz problem, oferując język Gremlin jako usługę. Dzięki tej ofercie nie musisz wstać własnych wystąpień serwera Gremlin ani zarządzać własną infrastrukturą. Co więcej, możesz skalować rozwiązanie w miarę wzrostu potrzeb w miarę upływu czasu.

Aby nawiązać połączenie z interfejsem API dla konta języka Gremlin, użyto tinkerpop/gremlin-console obrazu kontenera do uruchomienia konsoli gremlin w sposób, który nie wymagał instalacji lokalnej. Następnie użyto konfiguracji przechowywanej w pliku remote-secure.yaml , aby nawiązać połączenie z uruchomionego kontenera interfejsu API dla konta gremlin. W tym miejscu uruchomiono wiele typowych poleceń języka Gremlin.

Następny krok

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