Exécuter JanusGraph avec Cloud Bigtable

Ce tutoriel explique comment exécuter JanusGraph sur Google Cloud (GCP). JanusGraph est une base de données orientée graphe qui permet de travailler sur de grands volumes de données. Les bases de données orientées graphe vous aident à découvrir des informations en modélisant vos entités de données et leurs relations. Dans la terminologie des graphes, les entités sont appelées nœuds ou sommets, et les relations sont appelées arêtes. Les sommets et les arêtes peuvent posséder des propriétés.

Exemple de graphe de propriétés

Figure 1. Exemple de graphe de propriétés

Les bases de données orientées graphe vous aident à modéliser divers domaines et activités :

  • Réseaux sociaux
  • Analyse de fraude
  • Réseaux physiques

La création de bases de données orientées graphe conduit parfois à créer des millions, voire des milliards de sommets et d'arêtes. Lorsque vous utilisez JanusGraph avec Bigtable comme couche de stockage sous-jacente, vous pouvez à la fois exécuter des requêtes rapides et assurer le scaling de votre couche de stockage indépendamment de la taille et du débit dont vous avez besoin. Utilisez ce tutoriel pour déployer une infrastructure JanusGraph évolutive avec Bigtable, que vous pouvez ensuite exploiter pour parcourir les relations existant dans toute base de données orientée graphe.

Déploiement de JanusGraph avec Bigtable sur GKE

Figure 2. Déploiement de JanusGraph avec Bigtable sur GKE

Objectifs

  • Créer une instance Bigtable
  • Créer un cluster GKE
  • Installer Helm, un gestionnaire de paquets Kubernetes
  • Utiliser un graphique Helm pour déployer Janusgraph et Elasticsearch
  • Utiliser Gremlin et se connecter à JanusGraph
  • Charger puis interroger les données

Coûts

Ce tutoriel utilise les composants facturables suivants de Google Cloud :

  • Compute Engine, utilisé par GKE
  • Bigtable

Obtenez une estimation des coûts en fonction de votre utilisation prévue à l'aide du simulateur de coût. Les nouveaux utilisateurs de Google Cloud peuvent bénéficier d'un essai gratuit.

Avant de commencer

  1. Connectez-vous à votre compte Google Cloud. Si vous débutez sur Google Cloud, créez un compte pour évaluer les performances de nos produits en conditions réelles. Les nouveaux clients bénéficient également de 300 $ de crédits gratuits pour exécuter, tester et déployer des charges de travail.
  2. Dans Google Cloud Console, sur la page de sélection du projet, sélectionnez ou créez un projet Google Cloud.

    Accéder au sélecteur de projet

  3. Assurez-vous que la facturation est activée pour votre projet Cloud. Découvrez comment vérifier que la facturation est activée pour votre projet.

  4. Activer les API Bigtable, Bigtable Admin, Compute Engine, and GKE.

    Activer les API

Une fois que vous avez terminé ce dernier, vous pouvez éviter de continuer à payer des frais en supprimant les ressources que vous avez créées. Pour en savoir plus, consultez la section Effectuer un nettoyage.

Préparer votre environnement

Dans ce tutoriel, vous utilisez Cloud Shell pour saisir des commandes. Cloud Shell vous permet d'accéder à la ligne de commande dans Cloud Console, et comprend le SDK Cloud et d'autres outils dont vous avez besoin pour développer dans GCP. Cloud Shell apparaît sous la forme d'une fenêtre au bas de Cloud Console. L'initialisation peut prendre quelques minutes, mais la fenêtre apparaît immédiatement.

  1. Activez Cloud Shell.

    Activer Cloud Shell

  2. Dans Cloud Shell, définissez la zone Compute Engine par défaut sur la zone dans laquelle vous allez créer votre cluster Bigtable et votre cluster GKE. Ce tutoriel utilise la zone us-central1-f.

    gcloud config set compute/zone us-central1-f
  3. Créez un cluster GKE pour déployer JanusGraph :

    gcloud container clusters create janusgraph-tutorial \
        --cluster-version=1.15 \
        --machine-type n1-standard-4 \
        --scopes "https://www.googleapis.com/auth/bigtable.admin","https://www.googleapis.com/auth/bigtable.data"
    
  4. Installez Helm dans votre environnement Cloud Shell :

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

Créer une instance Bigtable

Ce tutoriel utilise Bigtable comme backend de stockage pour JanusGraph, car Cloud Bigtable peut évoluer rapidement pour répondre à vos besoins. Nous utilisons ici un cluster de développement à un seul nœud, ce qui est à la fois économique et suffisant pour ce tutoriel. Vous pouvez démarrer vos projets avec un cluster de développement, puis passer à un cluster de production plus conséquent lorsque vous êtes prêt à utiliser les données de production. Dans la documentation de Bigtable, vous trouverez des informations détaillées sur les performances et le scaling, qui vous aideront à choisir une taille de cluster adaptée à votre propre travail.

Pour créer votre instance Bigtable, procédez comme suit :

  1. Dans Cloud Console, accédez à la page Créer une instance :

    ACCÉDER À LA PAGE "CRÉER UNE INSTANCE"

  2. Dans le champ Nom de l'instance, saisissez un nom pour votre instance. Vous pouvez utiliser janusgraph ou tout autre nom de votre choix, écrit en minuscules. Le champ ID d'instance est automatiquement renseigné sur la page. Cliquez sur Continuer.

  3. Dans le champ Sélectionner le type de stockage, choisissez HDD. Cliquez sur Continuer.

  4. L'ID du cluster et les nœuds sont définis automatiquement. Dans le champ Région, sélectionnez us-central1. Dans le champ Zone, sélectionnez us-central1-f ou la zone dans laquelle vous avez précédemment créé votre cluster GKE.

  5. Cliquez sur Create (Créer) pour créer l'instance.

Prenez note de l'ID d'instance, car vous l'utiliserez dans l'une des étapes suivantes.

Configurer Helm

Helm sert à déployer des applications sur votre cluster Kubernetes. Après avoir créé votre cluster, initialisez un dépôt de graphiques Helm.

  1. Collez les commandes suivantes dans Cloud Shell :

    helm repo add stable https://charts.helm.sh/stable
    

Utiliser Helm pour installer JanusGraph et Elasticsearch

En plus d'utiliser Bigtable comme backend de stockage, JanusGraph utilisera Elasticsearch comme backend d'indexation.

Dans cette section, vous utilisez un graphique Helm pour déployer JanusGraph et Elasticsearch sur votre cluster Kubernetes. Lorsque vous installez le graphique JanusGraph, Elasticsearch est inclus en tant que dépendance, ce qui simplifie le processus global.

  1. Dans Cloud Shell, définissez une variable d'environnement qui stockera la valeur de l'ID d'instance Bigtable que vous avez notée précédemment. Remplacez [YOUR_INSTANCE_ID] avec l'ID d'instance que vous avez spécifiée précédemment.

    export INSTANCE_ID=[YOUR_INSTANCE_ID]

    Par exemple, si vous avez utilisé la suggestion par défaut de janusgraph pour votre ID d'instance Bigtable, exécutez la commande suivante :

    export INSTANCE_ID=janusgraph
  2. Créez un fichier values.yaml, qui fournit à Helm la configuration spécifique à utiliser pour l'installation de Janusgraph :

    cat > values.yaml << EOF
    replicaCount: 3
    service: type: LoadBalancer serviceAnnotations: cloud.google.com/load-balancer-type: "Internal"
    elasticsearch: deploy: true
    properties: storage.backend: hbase storage.directory: null storage.hbase.ext.google.bigtable.instance.id: $INSTANCE_ID storage.hbase.ext.google.bigtable.project.id: $GOOGLE_CLOUD_PROJECT storage.hbase.ext.hbase.client.connection.impl: com.google.cloud.bigtable.hbase1_x.BigtableConnection index.search.backend: elasticsearch index.search.directory: null cache.db-cache: true cache.db-cache-clean-wait: 20 cache.db-cache-time: 180000 cache.db-cache-size: 0.5
    persistence: enabled: false EOF
  3. Déployez le chart Helm de JanusGraph à l'aide du fichier values.yaml que vous avez créé :

    helm upgrade --install --wait --timeout 600s janusgraph stable/janusgraph -f values.yaml
    

    L'installation attend que toutes les ressources soient prêtes avant de se terminer. Ce processus peut prendre plusieurs minutes.

Vérifier votre déploiement JanusGraph

Lorsque la commande helm install se termine, elle génère une section NOTES décrivant les premiers pas de l'utilisateur dans l'environnement. Dans Cloud Shell, suivez les étapes décrites dans la section NOTES pour vérifier que votre environnement JanusGraph fonctionne correctement.

  1. Définissez une variable d'environnement avec le nom d'un pod Kubernetes exécutant JanusGraph :

    export POD_NAME=$(kubectl get pods --namespace default -l "app=janusgraph,release=janusgraph" -o jsonpath="{.items[0].metadata.name}")
    
  2. Connectez-vous au pod et lancez l'interface système Gremlin :

    kubectl exec -it $POD_NAME -- /janusgraph-0.2.0-hadoop2/bin/gremlin.sh
    
  3. Dans la console Gremlin, connectez-vous au serveur Apache TinkerPop :

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

    La sortie doit ressembler à ce qui suit :

    gremlin> :remote connect tinkerpop.server conf/remote.yaml session
    ==>Configured localhost/127.0.0.1:8182-[b08972f2-a2aa-4312-8018-bcd11bc9812c]
    gremlin> :remote console
    ==>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
    gremlin>
    
  4. Exécutez les commandes Gremlin suivantes pour créer deux sommets et une arête :

    v1 = graph.addVertex(label, 'hello')
    v2 = graph.addVertex(label, 'world')
    v1.addEdge('followedBy', v2)
    graph.tx().commit()
    

    La sortie ressemble à ceci :

    gremlin> v1 = graph.addVertex(label, 'hello')
    ==>v[4344]
    gremlin>  v2 = graph.addVertex(label, 'world')
    ==>v[40964152]
    gremlin>  v1.addEdge('followedBy', v2)
    ==>e[17j-3co-4fmd-oe054][4344-followedBy->40964152]
    gremlin>
    
  5. Envoyez une requête Gremlin pour voir quel libellé porte le sommet qui suit l'arête out en partant du sommet libellé hello :

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

    La syntaxe de la requête est expliquée dans la section suivante. Pour l'instant, vous voyez apparaître le mot "world" comme résultat de la requête :

    gremlin> g.V().has(label, 'hello').out('followedBy').label()
    ==>world
    

Charger et interroger un échantillon de données

Maintenant que vous avez déployé JanusGraph et que vous pouvez vous y connecter au moyen de Gremlin, vous pouvez commencer à charger et interroger vos propres données. Pour illustrer et mieux comprendre ce processus, chargez l'ensemble de données d'exemple fourni avec JanusGraph : le Graph of the Gods (graphe des dieux) qui décrit les divinités mythologiques et leurs propriétés de localisation.

  1. Pendant que vous êtes dans l'interface système Gremlin de la section précédente, saisissez la commande suivante :

    GraphOfTheGodsFactory.load(graph)
    

    Lorsque la commande se termine, elle renvoie null :

    gremlin> GraphOfTheGodsFactory.load(graph)
    ==>null
    
  2. Une fois que le graphe d'exemple est chargé, vous pouvez envoyer des requêtes de balayage de graphe. Par exemple, pour rechercher tous les frères de Jupiter, saisissez la requête suivante :

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

    Vous pouvez décomposer cette requête en observant les étapes du balayage :

    Étape du balayage Explication
    g.V() Commencer avec la collection de sommets.
    has('name', 'jupiter') Identifier un sommet dont la propriété name possède la valeur jupiter.
    out('brother') Ensuite, suivre toutes les arêtes portant le libellé brother.
    values('name') Récupérer la propriété name de chaque sommet auquel ces arêtes conduisent.

    Voici le résultat de la requête :

    gremlin> g.V().has('name', 'jupiter').out('brother').values('name')
    ==>neptune
    ==>pluto
    

Pour vous familiariser avec les requêtes de balayage de graphe que vous pouvez réaliser sur cet ensemble de données "Graph of the Gods", essayez d'autres exemples de requêtes issues de la documentation JanusGraph.

Nettoyer

Pour éviter que les ressources utilisées lors de ce tutoriel soient facturées sur votre compte Google Cloud, supprimez le projet contenant les ressources, ou conservez le projet et supprimez les ressources individuelles.

  1. Dans Cloud Console, accédez à la page Gérer les ressources.

    Accéder à la page Gérer les ressources

  2. Dans la liste des projets, sélectionnez le projet que vous souhaitez supprimer, puis cliquez sur Supprimer.
  3. Dans la boîte de dialogue, saisissez l'ID du projet, puis cliquez sur Arrêter pour supprimer le projet.

Étape suivante