Szybki start: biblioteka Azure Cosmos DB dla języka Apache Gremlin dla Node.js

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 gremlin 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 (npm)

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.
Node.js (LTS)
- Nie masz zainstalowanego Node.js? Wypróbuj ten przewodnik Szybki start w witrynie GitHub Codespaces.codespaces.new/github/codespaces-blank?quickstart=1)
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 Node.js w celu używania biblioteki do nawiązywania połączenia z kontem.

Tworzenie interfejsu API dla konta języka Gremlin

Przed użyciem biblioteki Node.js należy utworzyć interfejs API dla konta języka 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

Tworzenie nowej aplikacji konsolowej Node.js

Utwórz aplikację konsolową Node.js w pustym folderze przy użyciu preferowanego terminalu.

Otwórz terminal w pustym folderze.
Inicjowanie nowego modułu
```
npm init es6 --yes
```
Tworzenie pliku app.js
```
touch app.js
```

Instalowanie pakietu npm

gremlin Dodaj pakiet npm do projektu Node.js.

Otwórz plik package.json i zastąp zawartość tą konfiguracją JSON.

{
  "main": "app.js",
  "type": "module",
  "scripts": {
    "start": "node app.js"
  },
  "dependencies": {
    "gremlin": "^3.*"
  }
}

Użyj polecenia , npm install aby zainstalować wszystkie pakiety określone w pliku package.json .
```
npm install
```

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.js.
Zaimportuj gremlin moduł.
```
import gremlin from 'gremlin'
```
Tworzenie accountName zmiennych i accountKey . COSMOS_GREMLIN_ENDPOINT Zapisz zmienne środowiskowe i COSMOS_GREMLIN_KEY jako wartości dla każdej odpowiedniej zmiennej.
```
const accountName = process.env.COSMOS_GREMLIN_ENDPOINT
const accountKey = process.env.COSMOS_GREMLIN_KEY
```

Użyj PlainTextSaslAuthenticator polecenia , aby utworzyć nowy obiekt dla poświadczeń konta.

const credentials = new gremlin.driver.auth.PlainTextSaslAuthenticator(
  '/dbs/cosmicworks/colls/products',
  `${accountKey}`
)

Użyj Client polecenia , aby nawiązać połączenie przy użyciu poświadczeń serwera zdalnego i serializatora GraphSON 2.0 . Następnie użyj polecenia Open , aby utworzyć nowe połączenie z serwerem.

const client = new gremlin.driver.Client(
  `wss://${accountName}.gremlin.cosmos.azure.com:443/`,
  {
    credentials,
    traversalsource: 'g',
    rejectUnauthorized: true,
    mimeType: 'application/vnd.gremlin-v2.0+json'
  }
)

client.open()

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`

await client.submit(
  'g.addV(\'product\').property(\'id\', prop_id).property(\'name\', prop_name).property(\'price\', prop_price).property(\'category\', prop_partition_key)', {
    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`

await client.submit(
  'g.addV(\'product\').property(\'id\', prop_id).property(\'name\', prop_name).property(\'price\', prop_price).property(\'category\', prop_partition_key)', {
    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`

await client.submit(
  'g.addV(\'product\').property(\'id\', prop_id).property(\'name\', prop_name).property(\'price\', prop_price).property(\'category\', prop_partition_key)', {
    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.
```
await client.submit(
  'g.V([prop_partition_key, prop_source_id]).addE(\'replaces\').to(g.V([prop_partition_key, prop_target_id]))', {
    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.

await client.submit(
  'g.V([prop_partition_key, prop_source_id]).addE(\'replaces\').to(g.V([prop_partition_key, prop_target_id]))', {
    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ą.

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

Zapisz w konsoli wynik tego przechodzenia.
```
console.dir(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 Node.js.
Użyj polecenia npm <script> , aby uruchomić aplikację. Obserwuj dane wyjściowe z aplikacji.
```
npm start
```

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