Snabbstart: Azure Cosmos DB för Apache Gremlin-biblioteket för Node.js

Artikel
01/10/2024

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 gremlin använder du biblioteket för att ansluta till ett nyligen skapat Azure Cosmos DB för Gremlin-konto.

Paket för bibliotekskällans källkod | (npm)

Förutsättningar

Ett Azure-konto med en aktiv prenumeration.
- Ingen Azure-prenumeration? Registrera dig för ett kostnadsfritt Azure-konto.
- Vill du inte ha en Azure-prenumeration? Du kan prova Azure Cosmos DB kostnadsfritt utan att någon prenumeration krävs.
Node.js (LTS)
- Har du inte Node.js installerat? Prova den här snabbstarten i GitHub Codespaces.codespaces.new/github/codespaces-blank?quickstart=1)
Kommandoradsgränssnitt för Azure (CLI)

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.
Gå till https://shell.azure.com eller Välj knappen Starta Cloud Shell för att öppna Cloud Shell i webbläsaren.
Välj knappen Cloud Shell på menyn längst upp till höger i Azure-portalen.

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

Starta Cloud Shell.
Välj knappen Kopiera i ett kodblock (eller kommandoblock) för att kopiera koden eller kommandot.
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.
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 Node.js 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 Node.js-biblioteket. Dessutom hjälper det att även ha databasen och grafen på plats.

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"

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

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

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

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.

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"

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"

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

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"

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 Node.js-konsolprogram

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

Öppna terminalen i en tom mapp.
Initiera en ny modul
```
npm init es6 --yes
```
Skapa app.js-filen
```
touch app.js
```

Installera npm-paketet

gremlin Lägg till npm-paketet i Node.js-projektet.

Öppna filen package.json och ersätt innehållet med den här JSON-konfigurationen.

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

npm install Använd kommandot för att installera alla paket som anges i filen package.json.
```
npm install
```

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.

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

Kontrollera att miljövariablerna har angetts korrekt.

printenv COSMOS_GREMLIN_ENDPOINT
printenv COSMOS_GREMLIN_KEY

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.

Öppna filen app.js .
Importera modulen gremlin .
```
import gremlin from 'gremlin'
```
Skapa accountName och accountKey variabler. COSMOS_GREMLIN_ENDPOINT Lagra miljövariablerna och COSMOS_GREMLIN_KEY som värden för varje variabel.
```
const accountName = process.env.COSMOS_GREMLIN_ENDPOINT
const accountKey = process.env.COSMOS_GREMLIN_KEY
```

Använd PlainTextSaslAuthenticator för att skapa ett nytt objekt för kontots autentiseringsuppgifter.

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

Använd Client för att ansluta med autentiseringsuppgifterna för fjärrservern och GraphSON 2.0-serialiseraren. Open Använd sedan för att skapa en ny anslutning till servern.

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

Skapa hörn

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

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`

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'
  }
)

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

	Värde
Etikett	`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'
  }
)

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

	Värde
Etikett	`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'
  }
)

Skapa kanter

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

Skapa en kant från produkten Montau Turtle Surfboard med namnet ersätter produkten Kiama classic 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: '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>').

Skapa en annan ersätter gränsen från samma produkt till 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'
  }
)

Frågehörn och kanter

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

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

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'
  }
)

Skriv till konsolen resultatet av denna bläddering.
```
console.dir(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.

Öppna terminalen i mappen Node.js projekt.
Använd npm <script> för att köra programmet. Observera utdata från programmet.
```
npm start
```

Rensa resurser

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

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

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

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