Avvio rapido: attraversare vertici e archi con la console Gremlin e Azure Cosmos DB for Apache Gremlin

Si applica a: ✅ Apache Gremlin

Importante

Si sta cercando una soluzione di database per scenari su larga scala con un contratto di servizio di disponibilità 99.999%, scalabilità automatica immediata e failover automatico in più aree? Prendere in considerazione Azure Cosmos DB per NoSQL.

Si vuole implementare un grafico OLAP (Online Analytical Processing) o eseguire la migrazione di un'applicazione Apache Gremlin esistente? Prendere in considerazione Graph in Microsoft Fabric.

Azure Cosmos DB per Apache Gremlin è un servizio di database a grafo completamente gestito che implementa il diffuso Apache Tinkerpop, un framework di calcolo a grafo usando il linguaggio di query Gremlin. L'API per Gremlin offre un modo senza attriti per iniziare a utilizzare Gremlin con un servizio che può espandersi e scalare quanto necessario con una gestione minima.

In questa guida introduttiva, si usa la console Gremlin per connettersi a un nuovo account Azure Cosmos DB per Gremlin appena creato.

Prerequisiti

Un account Azure con una sottoscrizione attiva.
- Nessuna sottoscrizione Azure? Sottoscrivere un account Azure gratuito.
Host Docker
- Docker non è installato? Provare questo avvio rapido in GitHub Codespaces.
Interfaccia della riga di comando di Azure

Azure Cloud Shell

Azure ospita Azure Cloud Shell, un ambiente shell interattivo che è possibile usare tramite il browser. È possibile usare Bash o PowerShell con Cloud Shell per usare i servizi di Azure. È possibile usare i comandi preinstallati di Cloud Shell per eseguire il codice contenuto in questo articolo senza dover installare strumenti nell'ambiente locale.

Per avviare Azure Cloud Shell:

Opzione	Esempio/collegamento
Selezionare Prova nell'angolo superiore destro di un codice o di un blocco di comandi. Quando si seleziona Prova, il codice o il comando non viene copiato automaticamente in Cloud Shell.
Passare a https://shell.azure.com o selezionare il pulsante Avvia Cloud Shell per aprire Cloud Shell nel browser.
Selezionare il pulsante Cloud Shell nella barra dei menu in alto a destra nel portale di Azure.

Per usare Azure Cloud Shell:

Avviare Cloud Shell.
Selezionare il pulsante Copia in un blocco di codice (o blocco di comandi) per copiare il codice o il comando.
Incollare il codice o il comando nella sessione di Cloud Shell selezionando Ctrl+Shift+V in Windows e Linux oppure selezionando Cmd+Shift+V in macOS.
Premere INVIO per eseguire il codice o il comando.

Creare un'API per l'account Gremlin e le risorse pertinenti

L'API per l'account Gremlin deve essere creata prima di usare la console Gremlin. Inoltre, è utile disporre anche del database e del grafo.

Creare variabili della shell per accountName, resourceGroupName e 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"

Se non l'hai già fatto, accedi all'interfaccia della riga di comando di Azure usando az login.
Usare az group create per creare un nuovo gruppo di risorse nella propria sottoscrizione.
```
az group create \
    --name $resourceGroupName \
    --location $location
```
Usare az cosmosdb create per creare una nuova API per l'account Gremlin con le impostazioni predefinite.
```
az cosmosdb create \
    --resource-group $resourceGroupName \
    --name $accountName \
    --capabilities "EnableGremlin" \
    --locations regionName=$location \
    --enable-free-tier true
```
Annotazioni

È possibile avere fino a un account Azure Cosmos DB del livello gratuito per ogni sottoscrizione di Azure ed è necessario acconsentire esplicitamente durante la creazione dell'account. Se questo comando non riesce ad applicare lo sconto per il livello gratuito, significa che un altro account nella sottoscrizione è già stato abilitato per il livello gratuito.

Ottenere l’API dell’endpoint Gremlin per l’account NOME usando az cosmosdb show.

az cosmosdb show \
    --resource-group $resourceGroupName \
    --name $accountName \
    --query "name"

Trova la CHIAVE dall'elenco di chiavi per l'account con az-cosmosdb-keys-list.

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

Registrare i valori NOME e CHIAVE. Potrai utilizzare queste credenziali più avanti.

Creare un database denominato cosmicworks usando az cosmosdb gremlin database create.

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

Creare un grafo usando az cosmosdb gremlin graph create. Assegnare al grafo il nome products, quindi impostare la velocità effettiva su 400 e infine impostare il percorso della chiave di partizione su /category.

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

Avviare e configurare la console Gremlin usando Docker

Per la console gremlin, questo avvio rapido utilizza l'immagine del contenitore tinkerpop/gremlin-console da Docker Hub. Questa immagine garantisce che si sta usando la versione appropriata della console (3.4) per la connessione con l'API per Gremlin. Dopo avere avviato la console, collegarsi dall'host Docker locale all'API remota dell'account Gremlin.

Recupera la versione 3.4 dell'immagine del contenitore tinkerpop/gremlin-console.
```
docker pull tinkerpop/gremlin-console:3.4
```

Creare una cartella di lavoro vuota. Nella cartella vuota creare un file remote-secure.yaml. Aggiungere questa configurazione YAML al file.

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

Annotazioni

Sostituire i segnaposto <account-name> e <account-key> con i valori NAME e KEY ottenuti in precedenza in questa esercitazione rapida.

Aprire un nuovo terminale nel contesto della cartella di lavoro che include il file remote-secure.yaml.
Eseguire l'immagine del contenitore Docker in modalità interattiva (--interactive --tty). Assicurarsi di montare la cartella di lavoro corrente nel percorso di /opt/gremlin-console/conf/ all'interno del contenitore.
```
docker run -it --mount type=bind,source=.,target=/opt/gremlin-console/conf/ tinkerpop/gremlin-console:3.4
```
All'interno del contenitore della console Gremlin connettersi all'account remoto (API per Gremlin) usando il file di configurazione remote-secure.yaml.
```
:remote connect tinkerpop.server conf/remote-secure.yaml
```

Creare e traversare vertici e archi

Ora che la console è connessa all'account, usare la sintassi standard di Gremlin per creare e percorrere sia i vertici sia gli archi.

Aggiungere un vertice per un prodotto con le proprietà seguenti:

Value

Etichetta 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')
```
Importante

Non dimenticare il :> prefisso. Il prefisso è necessario per eseguire il comando in modalità remota.

Aggiungere un altro prodotto vertice con queste proprietà:

	Value
Etichetta	`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')

Creare un arco denominato replaces per definire una relazione tra i due prodotti.

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

Contare tutti i vertici all'interno del grafico.
```
:> g.V().count()
```

Attraversare il grafico per trovare tutti i vertici che sostituiscono il Kiama classic surfboard.

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

Attraversare il grafico per trovare tutti i vertici che Montau Turtle Surfboard sostituisce.

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

Pulire le risorse

Quando l'API per l'account Gremlin non è più necessaria, eliminare il gruppo di risorse corrispondente.

Creare una variabile shell per resourceGroupName, se non esiste già.

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

Usare az group delete per eliminare il gruppo di risorse.
```
az group delete \
    --name $resourceGroupName
```

Come è stato risolto il problema?

Azure Cosmos DB for Apache Gremlin ha risolto il problema offrendo Gremlin come servizio. Con questa offerta, non è necessario creare istanze del server Gremlin o gestire la propria infrastruttura. Ancora di più, è possibile ridimensionare la soluzione man mano che le esigenze aumentano nel tempo.

Per connettersi all'API per l'account Gremlin, è stata usata l'immagine del contenitore tinkerpop/gremlin-console per eseguire la console gremlin in modo da non richiedere un'installazione locale. È stata quindi utilizzata la configurazione archiviata nel file remote-secure.yaml per connettersi all'API per l'account Gremlin dal contenitore in esecuzione. A partire da lì, hai eseguito più comandi Gremlin comuni.

Commenti e suggerimenti

Questa pagina è stata utile?

Last updated on 2026-04-27