Esegui JanusGraph su GKE con Bigtable

I database di grafici possono aiutarti a scoprire insight modellando i tuoi dati e le relazioni tra loro. JanusGraph è un database di grafici che supporta l'uso di grandi quantità di dati. Questo il tutorial mostra come eseguire JanusGraph su Google Cloud con Google Kubernetes Engine come piattaforma di orchestrazione e Bigtable come piattaforma di un backend cloud. Il tutorial è rivolto a architetti di sistema, amministratori di database e DevOps professionisti interessati a eseguire il database di grafici JanusGraph su Google Cloud usando un database gestito come backend di archiviazione. Presuppone con cui hai familiarità Google Kubernetes Engine (GKE) Kubernetes, Helm grafici, Bigtable e Elasticsearch. Conoscenza TinkerPop di Apache il framework di calcolo dei grafi e Gremlin macchina e linguaggio dell'attraversamento dei grafi non sono obbligatori, ma questa conoscenza è necessaria per usa Janusgraph oltre agli esempi forniti in questo tutorial.

Panoramica

Nella terminologia dei grafici, le entità sono note come nodi o vertici e delle relazioni sono note come bordi. In JanusGraph, sia vertici che bordi associati ad altri dati resi disponibili tramite le proprietà.

Esempio di grafico delle proprietà.

L'illustrazione precedente è un esempio di grafico delle proprietà.

I database di grafici consentono di modellare una varietà di domini e attività:

  • Social network
  • Transazioni finanziarie (per l'analisi delle frodi)
  • Reti di sistema fisiche o virtuali

Quando crei database di grafici, a volte ne crei milioni o addirittura miliardi di vertici e lati. Quando utilizzi JanusGraph con Bigtable come livello di archiviazione sottostante, potete eseguire query veloci (note come attraversamenti grafici) e scala il livello di archiviazione in modo indipendente in base al e la velocità effettiva di cui hai bisogno. JanusGraph usa anche un'indicizzazione modulare per fornire l'indicizzazione di testo completo per le proprietà di vertice e perimetro. In questo tutorial eseguirai il deployment di un'infrastruttura JanusGraph scalabile con GKE. Utilizzi Elasticsearch come backend di indicizzazione in esecuzione in uno StatefulSet e puoi usare Bigtable come spazio di archiviazione di un backend cloud. Quando hai finito, puoi attraversare le relazioni esistenti del grafico. Il seguente diagramma mostra come questi elementi si integrano fra loro.

Deployment di JanusGraph con Bigtable su GKE.

Il diagramma di avanzamento mostra il deployment JanusGraph su GKE con Elasticsearch e Bigtable.

Dati JanusGraph in Bigtable

I dati dei grafici vengono archiviati da JanusGraph come elenco adiacente. Ogni riga rappresenta un vertici, tutti i vertici adiacenti e metadati delle proprietà relativi ai vertici e i bordi. La chiave di riga è l'identificatore univoco del vertice. Ciascuna relazione tra il vertice e un altro vertice e qualsiasi proprietà che definire ulteriormente la relazione archiviata come colonna perimetrale o proprietà perimetrale. Sia il qualificatore di colonna che il valore colonna memorizzano i dati che definiscono l'estremità, in in conformità con Best practice per Bigtable. Ogni proprietà del vertice viene archiviata in una colonna separata, utilizzando sempre qualificatore di colonna e il valore della colonna per definire la proprietà.

Il seguente diagramma mostra questa struttura di archiviazione.

Struttura di archiviazione dell'elenco di adjancency JanusGraph.

Il diagramma mostra la struttura di archiviazione logica per un piccolo frammento di grafico con dettagli logici di due righe ai vertici. Nel diagramma, le due righe di esempio che rappresentano due vertici. Il primo vertice è etichettato con un singolo vertice ed è correlato ad altri due vertici da due bordi separati. Il secondo vertice contiene colonne contenenti due proprietà e un bordo.

L'illustrazione seguente del modello dei dati logici di bordo del vertice fornisce alcune dettaglio sui qualificatori di colonna e sui valori per una proprietà edge o edge colonna.

Colonna della proprietà bordo e bordo JanusGraph.

Per ogni vertice adiacente, una colonna archivia i metadati relativi a quel bordo. La il qualificatore di colonna contiene i metadati sulla relazione perimetrale e direzione del bordo e un puntatore al vertice adiacente. Il valore della colonna contiene l'etichetta del bordo ed eventuali altre proprietà degli spigoli. Poiché gli attraversamenti possono essere seguiti in entrambe le direzioni, gli archi vengono memorizzati due volte, una per ciascuna estremità relazione perimetrale. Lo spazio di archiviazione perimetrale bidirezionale aumenta significativamente l'attraversamento ma comporta alcuni compromessi dovuti alla ridondanza di spazio di archiviazione e mutazioni dei bordi non atomici.

Il seguente diagramma è il modello dei dati logici di una colonna di proprietà dei vertici.

Valori della colonna JanusGraph per una colonna di proprietà.

L'illustrazione precedente fornisce dettagli sui qualificatori di colonna e per una colonna perimetrale.

Ogni proprietà del vertice viene archiviata in una colonna separata. Il qualificatore di colonna è un identificatore univoco per la chiave della proprietà. Il valore della colonna contiene un parametro l'identificatore della proprietà e il valore della proprietà.

JanusGraph si basa anche sul modello lessicografico di Bigtable l'ordinamento di righe e qualificatori di colonna per migliorare le prestazioni delle query.

Obiettivi

  • Crea un Istanza Bigtable.
  • Crea un GKE in un cluster Kubernetes.
  • Installa Helm.
  • usa un grafico Helm per eseguire il deployment di JanusGraph Elasticsearch.
  • Utilizza la Gremlin e connetterti a JanusGraph.
  • Carica ed esegui una query sui dati di esempio.

Costi

In questo documento utilizzi i seguenti componenti fatturabili di Google Cloud:

Per generare una stima dei costi basata sull'utilizzo previsto, utilizza il Calcolatore prezzi. I nuovi utenti di Google Cloud potrebbero essere idonei per una prova gratuita.

Una volta completate le attività descritte in questo documento, puoi evitare la fatturazione continua eliminando le risorse che hai creato. Per ulteriori informazioni, consulta la pagina Pulizia.

Prerequisiti

  1. Sign in to your Google Cloud account. If you're new to Google Cloud, create an account to evaluate how our products perform in real-world scenarios. New customers also get $300 in free credits to run, test, and deploy workloads.

  2. In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

    Go to project selector

  3. Make sure that billing is enabled for your Google Cloud project.

  4. Enable the Bigtable, Compute Engine, and GKE APIs.

    Enable the APIs

    5.

  5. In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

    Go to project selector

  6. Make sure that billing is enabled for your Google Cloud project.

  7. Enable the Bigtable, Compute Engine, and GKE APIs.

    Enable the APIs

    8.

prepara l'ambiente

In questo tutorial utilizzi Cloud Shell per inserire comandi. Cloud Shell ti dà accesso alla riga di comando nel Console Google Cloud e include Google Cloud CLI e altri strumenti necessari per lo sviluppo in Google Cloud. Cloud Shell viene visualizzato come una finestra in fondo alla console Google Cloud. L'inizializzazione può richiedere diversi minuti, ma la finestra si apre immediatamente.

  1. In the Google Cloud console, activate Cloud Shell.

    Activate Cloud Shell

  2. In Cloud Shell, imposta le variabili di ambiente per Zona Compute Engine in cui creerai la tua Bigtable cluster e cluster GKE e il nome, il tipo di nodo e la versione per il tuo cluster GKE:

    export PROJECT_ID=PROJECT_ID
export GCP_ZONE=REGION
export GKE_CLUSTER_NAME=GKE_CLUSTER_NAME
export GKE_NODE_TYPE=n1-standard-4
export GKE_VERSION=1.20

    Sostituisci quanto segue:

    • PROJECT_ID con l'identificatore del progetto.
    • REGION con la zona in cui Il cluster Bigtable e il cluster GKE è stato creato.
    • GKE_CLUSTER_NAME con il nome del tuo cluster GKE.

    Il comando dovrebbe essere simile all'esempio seguente:

    export PROJECT_ID=bt-janusgraph-project-id
export GCP_ZONE=us-central1-f
export GKE_CLUSTER_NAME=janusgraph-gke
export GKE_NODE_TYPE=n1-standard-4
export GKE_VERSION=1.20

  3. Crea un cluster GKE in cui verrà eseguito il deployment di JanusGraph:

    gcloud container clusters create ${GKE_CLUSTER_NAME} \
    --zone=${GCP_ZONE} \
    --cluster-version=${GKE_VERSION} \
    --machine-type ${GKE_NODE_TYPE} \
    --scopes "https://www.googleapis.com/auth/cloud-platform"

crea un'istanza Bigtable

Per il backend di archiviazione JanusGraph, questo tutorial utilizza Bigtable, che può scalare rapidamente per soddisfare le tue esigenze. Questo tutorial utilizza un nodo singolo ed è economico e sufficiente per il tutorial. Puoi iniziare dei tuoi progetti con un cluster più piccolo, per poi passare a un cluster più grande puoi iniziare a lavorare con i dati di produzione. Bigtable documentazione include una discussione dettagliata su prestazioni e scalabilità per aiutarti devi scegliere una dimensione del cluster per il tuo lavoro.

  1. In Cloud Shell, imposta la variabile di ambiente Identificatore di istanza Bigtable:

    export BIGTABLE_INSTANCE_ID=BIGTABLE_INSTANCE_ID

    Sostituisci BIGTABLE_INSTANCE_ID con l'identificatore per la tua istanza Bigtable.

  2. Crea l'istanza Bigtable:

    gcloud bigtable instances create ${BIGTABLE_INSTANCE_ID} \
    --cluster-config=id=${BIGTABLE_INSTANCE_ID}-${GCP_ZONE},zone=${GCP_ZONE},nodes=1 \
    --display-name=${BIGTABLE_INSTANCE_ID}-${GCP_ZONE}

Installa e configura Helm

Puoi utilizzare Helm per eseguire il deployment di applicazioni nel tuo cluster Kubernetes. In questo tutorial: utilizzerai Helm per eseguire il deployment dei servizi JanusGraph ed Elasticsearch sul tuo cluster GKE.

  1. In Cloud Shell, installa Helm:

    curl -fsSL -o get_helm.sh \
    https://raw.githubusercontent.com/helm/helm/master/scripts/get-helm-3
chmod 700 get_helm.sh
DESIRED_VERSION=v3.5.0 ./get_helm.sh

  2. Aggiungi il repository di grafici elastic, in modo che il grafico Elasticsearch durante il deployment del grafico JanusGraph:

    helm repo add elastic https://helm.elastic.co

    Questo repository di grafici è ospitato da Elastic, i creatori di Elasticsearch.

Usa Helm per installare JanusGraph ed Elasticsearch

In questa sezione viene utilizzato un Grafico Helm per eseguire il deployment JanusGraph e Elasticsearch al tuo cluster Kubernetes.

Il grafico Helm viene estratto da GitHub. Il deployment incluso nel repository del grafico Helm esegue il deployment di un insieme di Pod JanusGraph dietro un servizio che avviano un bilanciatore del carico delle applicazioni interno. Quando i pod sono in esecuzione, i probe di avvio e di attività effettuano richieste HTTP per di eseguire controlli di integrità sul server JanusGraph su ciascun pod. Inoltre, include un grafico delle dipendenze fornito da Elastic che esegue il deployment di tre pod Elasticsearch in uno StatefulSet.

  1. In Cloud Shell, imposta le variabili di ambiente per Helm e Nomi JanusGraph:

    export HELM_REPO=bigtable-janusgraph-helm
export JANUSGRAPH_VERSION=0.5.3
export HELM_CHART_RELEASE_VERSION=1
export HELM_CHART_RELEASE_TAG=${JANUSGRAPH_VERSION}-${HELM_CHART_RELEASE_VERSION}
export HELM_CHART_RELEASE_TAG_HASH=f8b271a4854d4a553dd5e9ba014d077fb098d9ab
export HELM_CHART_NAME=janusgraph-bigtable

  2. Esegui il pull del grafico Helm da GitHub:

    git clone https://github.com/GoogleCloudPlatform/${HELM_REPO} \
   --branch ${HELM_CHART_RELEASE_TAG}

  3. Vai alla directory del grafico Helm:

    cd ${HELM_REPO}

  4. Per motivi di sicurezza, esegui la verifica utilizzando l'hash di commit:

    HEAD_COMMIT_HASH=$(git rev-parse --verify HEAD)
if [ _${HEAD_COMMIT_HASH} == _${HELM_CHART_RELEASE_TAG_HASH} ]
then
    echo "Commit hash verified"
fi

    Se l'output non è simile al seguente, non procedere poiché l'integrità del tag clonato non è stata verificata.

    Commit hash verified

  5. Aggiorna le dipendenze del grafico:

    helm dep update

  6. Vai alla directory superiore:

    cd ..

  7. Imposta le variabili di ambiente per i nomi delle entità Helm e JanusGraph:

    export HELM_RELEASE_NAME=janusgraph-bigtable-elastic
export ELASTICSEARCH_CLUSTER_NAME=${HELM_RELEASE_NAME}-elasticsearch
export BIGTABLE_JANUSGRAPH_TABLE=janusgraph-table

  8. Crea un file values.yaml, che fornisce a Helm la configurazione da utilizzare durante il deployment del grafico JanusGraph:

    cat > values.yaml << EOF

image:
  repository: docker.io/janusgraph/janusgraph
  tag: 0.5.3
  pullPolicy: IfNotPresent

replicaCount: 3

service:
  type: LoadBalancer
  port: 8182
  serviceAnnotations:
    networking.gke.io/load-balancer-type: "Internal"

elasticsearch:
  deploy: true
  clusterName: ${ELASTICSEARCH_CLUSTER_NAME}

properties:
  storage.backend: hbase
  storage.directory: null
  storage.hbase.ext.google.bigtable.instance.id: ${BIGTABLE_INSTANCE_ID}
  storage.hbase.ext.google.bigtable.project.id: ${PROJECT_ID}
  storage.hbase.ext.hbase.client.connection.impl: com.google.cloud.bigtable.hbase2_x.BigtableConnection
  storage.hbase.short-cf-names: true
  storage.hbase.table: ${BIGTABLE_JANUSGRAPH_TABLE}
  index.search.backend: elasticsearch
  index.search.hostname: ${ELASTICSEARCH_CLUSTER_NAME}-master
  index.search.directory: null
  index.search.elasticsearch.health-request-timeout: 90s
  cache.db-cache: true
  cache.db-cache-clean-wait: 20
  cache.db-cache-time: 180000
  cache.db-cache-size: 0.5
  cluster.max-partitions: 1024
  graph.replace-instance-if-exists: true

persistence:
  enabled: false

debugLevel: INFO
EOF

  9. Esegui il deployment del grafico Helm JanusGraph utilizzando il file values.yaml che creato da te:

    helm upgrade --install \
             --wait \
              --timeout 600s \
              ${HELM_RELEASE_NAME} \
              ./${HELM_REPO} \
              -f values.yaml

    Il processo di installazione attende che tutte le risorse siano pronte prima completa. Questa procedura potrebbe richiedere diversi minuti.

Verifica il deployment JanusGraph

Al termine del processo di installazione di Helm, viene visualizzata una sezione NOTES che descrive un'esperienza per iniziare. Puoi seguire i passaggi indicati Struttura della sezione NOTES per verificare che l'ambiente JanusGraph sia funziona.

  1. In Cloud Shell, verifica che sia stato eseguito il deployment dei componenti del grafico Helm a GKE:

    1. Controlla il deployment di JanusGraph:

      kubectl get deployments

      Se il deployment ha esito positivo, l'output è il seguente:

      NAME                          READY   UP-TO-DATE   AVAILABLE   AGE
janusgraph-bigtable-elastic   3/3     3            3           3m28s

    2. Controlla lo StatefulSet Elasticsearch:

      kubectl get statefulsets

      Se tutto funziona correttamente, l'output è il seguente:

      NAME                                               READY   AGE
janusgraph-bigtable-elastic-elasticsearch-master   3/3     4m13s

  2. Imposta una variabile di ambiente sul nome di un pod Kubernetes che esegue il server JanusGraph Gremlin. L'etichetta app per il pod, che esegue il server Gremlin deriva dal nome del grafico Helm, definita nel file Chart.yaml.

    export APP_LABEL_FROM_CHART_NAME=${HELM_CHART_NAME}
export POD_NAME=$(kubectl get pods \
                     --namespace default \
                     -l "app=${APP_LABEL_FROM_CHART_NAME}, \
                         release=${HELM_RELEASE_NAME}" \
                     -o jsonpath="{.items[0].metadata.name}")

  3. Connettiti al pod ed esegui la console Gremlin, un loop di stampa della valutazione di lettura shell (REPL). Il nome del container deriva anche dal grafico Helm nome in Chart.yaml.

    export GREMLIN_CONTAINER=${HELM_CHART_NAME}
kubectl exec \
        -c ${GREMLIN_CONTAINER} \
        -it $POD_NAME \
        -- /opt/janusgraph/bin/gremlin.sh

  4. Nella console Gremlin, connettiti al server Apache TinkerPop:

    1. Avvia la sessione:

      :remote connect tinkerpop.server conf/remote.yaml session

      L'output è simile al seguente:

      ==>Configured localhost/127.0.0.1:8182-[b08972f2-a2aa-4312-8018-bcd11bc9812c]

    2. Connettiti al server:

      :remote console

      L'output è simile al seguente:

      ==>All scripts will now be sent to Gremlin Server - [localhost/127.0.0.1:8182]-[b08972f2-a2aa-4312-8018-bcd11bc9812c] - type ':remote console' to return to local mode>

  5. Nella console Gremlin, verifica che il server Gremlin sia in esecuzione correttamente ispezionando la variabile graph che rappresenta il grafico istanza:

    graph

    L'output indica che il server JanusGraph è in esecuzione con un compatibile con HBase, in questo caso Bigtable, backend di archiviazione.

    ==>standardjanusgraph[hbase:[127.0.0.1]]

  6. In Gremlin, crea due vertici

    v1 = graph.addVertex(label, 'hello')
v2 = graph.addVertex(label, 'world')

    Se l'output della console è simile al seguente, indica che i due vertici sono stati aggiunti:

    ==>v[4344]
==>v[4152]

  7. Crea un bordo che collega i due vertici:

    v1.addEdge('followedBy', v2)

    Se l'output della console è simile al seguente, indica che è stato aggiunto un bordo tra i due vertici:

    ==>e[17j-3co-4fmd-oe054][4344-followedBy->4152]

  8. Esegui il commit della transazione:

    graph.tx().commit()

    Se l'output della console è null, significa che le operazioni sono state commit:

    ==>null

    Il seguente diagramma illustra il grafico creato dai comandi.

    Bordo e vertici di esempio di JanusGraph.

    Il vertice denominato hello è collegato da un bordo diretto etichettato followedBy al vertice con l'etichetta world.

  9. Esegui una query Gremlin per vedere qual è l'etichetta per il vertice che segue un bordo denominato followedBy dal vertice denominato hello:

    g.V().has(label, 'hello').out('followedBy').label()

    La sintassi della query è spiegata nella sezione successiva. Per ora, puoi vedere parola world come output della query:

    ==>world

Carica ed esegui query su un set di dati di esempio

Ora che hai eseguito il deployment di JanusGraph e puoi connetterti a questo progetto utilizzando Gremlin, iniziare a caricare ed eseguire query sui tuoi dati. Per vedere come funziona come, carica il set di dati di esempio fornito in bundle con JanusGraph, Graph of the Gods, che raffigura le divinità mitologiche del pantheon romano e la loro posizione proprietà.

  1. In Gremlin, carica il grafico che hai creato in precedenza:

    GraphOfTheGodsFactory.load(graph)

    L'output è il seguente:

    ==>null

  2. Esegui una query di attraversamento grafico per trovare tutti i fratelli di Giove:

    g.V().has('name', 'jupiter').out('brother').values('name')

    La seguente tabella spiega i passaggi della query.

    Passaggio di attraversamento Spiegazione
    g.V() Inizia con la raccolta di vertici.
    has('name', 'jupiter') Trovane una con la proprietà name con il valore di jupiter.
    out('brother') Da qui, segui tutti i bordi con l'etichetta brother.
    values('name') Per i vertici in cui portano questi lati, ottieni name proprietà.
    L'output è il seguente:

    ==>neptune
==>pluto

    Per acquisire familiarità con le query di attraversamento possibili in questo grafico del set di dati Gods, prova altre query di esempio dal Documenti di JanusGraph.

Verificare che i dati siano archiviati in Bigtable

Ora che hai creato alcuni dati di esempio nel cluster JanusGraph, puoi per verificare che Bigtable sia stato utilizzato come backend di archiviazione.

  1. Chiudi la console Gremlin:

    :q

  2. In Cloud Shell, verifica che i dati siano stati resi persistenti Tabella janusgraph in Bigtable:

    cbt -project=${PROJECT_ID} \
    -instance=${BIGTABLE_INSTANCE_ID} \
     count ${BIGTABLE_JANUSGRAPH_TABLE}

    L'output è simile al seguente.

    2021/03/02 02:32:19 -creds flag unset, will use gcloud credential
101

    Il valore 101 nell'output rappresenta il numero di righe nella janusgraph table e potrebbe essere diverso per te.

Verifica la creazione dell'indice di ricerca in Elasticsearch

  1. In Cloud Shell, imposta le variabili per l'indice del pod Elasticsearch e nome:

    export ELASTICSEARCH_POD_ORDINAL=0
export ELASTICSEARCH_POD_NAME_ROOT=${ELASTICSEARCH_CLUSTER_NAME}-master
export ELASTICSEARCH_POD=${ELASTICSEARCH_POD_NAME_ROOT}-0

    I nomi dei pod Elasticsearch sono definiti dal motore Dipendenze Helm. I nomi dei pod sono composti dal nome del cluster fornito il file values.yaml che hai creato, la parola master e un numero ordinale con indice zero, tutti separati da trattini. In questo passaggio, scegli il primo pod, rappresentato da zero (0).

  2. Usa l'API REST Elasticsearch Aliases per ispezionare gli indici:

    kubectl exec \
        -c elasticsearch \
        -it ${ELASTICSEARCH_POD} \
        --  \
        curl -XGET "127.0.0.1:9200/_aliases?pretty=true";

    L'output mostra due indici, janusgraph_vertices e janusgraph_edges, create da JanusGraph per fornire ricerche efficienti utilizzando e le proprietà degli spigoli:

    {
  "janusgraph_vertices" : {
    "aliases" : {
      "janusgraph" : { }
    }
  },
  "janusgraph_edges" : {
    "aliases" : {
      "janusgraph" : { }
    }
  }
}

  3. Esegui una query sui valori da uno degli indici utilizzando il REST di Elasticsearch Search API:

    kubectl exec \
       -c elasticsearch \
       -it ${ELASTICSEARCH_POD} \
       --  \
       curl -XGET "127.0.0.1:9200/janusgraph_edges/_search?pretty=true&q=*";

    I risultati di ricerca mostrano che sono presenti voci negli indici creati da JanusGraph. L'output che vedi è simile al seguente risultati, che mostrano la presenza di voci nell'indice janusgraph_edges.

    {
 "took" : 94,
 "timed_out" : false,
 "_shards" : {
   "total" : 1,
   "successful" : 1,
   "skipped" : 0,
   "failed" : 0
 },
 "hits" : {
   "total" : {
     "value" : 6,
     "relation" : "eq"
   },
   "max_score" : 1.0,
   "hits" : [
     {
       "_index" : "janusgraph_edges",
       "_type" : "_doc",
       "_id" : "6bvp-5ovc-b2t-2yko",
       "_score" : 1.0,
       "_source" : {
         "reason" : "loves waves"
       }
     },
     {
…

Elimina il progetto

Per evitare che al tuo account Google Cloud vengano addebitati costi relativi alle risorse utilizzate in questo tutorial, elimina il progetto che contiene le risorse oppure mantieni il progetto ed elimina le singole risorse.

  1. In the Google Cloud console, go to the Manage resources page.

    Go to Manage resources

  2. In the project list, select the project that you want to delete, and then click Delete.
  3. In the dialog, type the project ID, and then click Shut down to delete the project.

Passaggi successivi