Ejecutar JanusGraph con Cloud Bigtable

En este instructivo se muestra cómo ejecutar JanusGraph en Google Cloud Platform (GCP). JanusGraph es una base de datos de grafos que permite trabajar con grandes cantidades de datos. Las bases de datos de grafos te ayudan a descubrir información valiosa mediante el modelado de tus entidades de datos y las relaciones entre ellas. En la terminología de grafos, las entidades se conocen como nodos o vértices, y a las relaciones se las conoce como aristas. Tanto los vértices como las aristas pueden tener propiedades asociadas.

Ejemplo de un grafo de propiedad

Figura 1. Ejemplo de un grafo de propiedad

Las bases de datos de grafos te ayudan a modelar diferentes dominios y actividades.

  • Redes sociales
  • Análisis de fraude
  • Redes físicas

Cuando se crean bases de datos de grafos, a veces creas millones o incluso miles de millones de vértices y aristas. Cuando utilizas JanusGraph con Cloud Bigtable como la capa de almacenamiento subyacente, puedes ejecutar consultas rápidas y escalar tus capas de almacenamiento independientemente del tamaño y el rendimiento que necesites. Utiliza este instructivo para implementar una infraestructura JanusGraph escalable con Cloud Bigtable, que podrás utilizar para recorrer las relaciones que existen en cualquier base de datos de grafos.

Implementación de JanusGraph con Cloud Bigtable en GKE

Figura 2. Implementación de JanusGraph con Cloud Bigtable en GKE

Objetivos

Costos

En este instructivo se usan los siguientes componentes facturables de Google Cloud Platform:

  • Compute Engine, utilizado por GKE
  • Cloud Bigtable

Usa la calculadora de precios a fin de generar una estimación de los costos según el uso previsto. Los usuarios nuevos de GCP pueden optar a una prueba gratuita.

Antes de comenzar

  1. Accede a tu Cuenta de Google.

    Si todavía no tienes una cuenta, regístrate para obtener una nueva.

  2. Selecciona o crea un proyecto de GCP.

    Ir a la página Administrar recursos

  3. Asegúrate de tener habilitada la facturación para tu proyecto.

    Aprende a habilitar la facturación

  4. Habilita las Cloud Bigtable, Cloud Bigtable Admin, Compute Engine y GKE API necesarias.

    Habilita las API

Cuando finalices este instructivo, puedes borrar los recursos que has creado para evitar que se te sigan facturando. Consulta la sección Limpiar para obtener más detalles.

Preparar tu entorno

En este instructivo, usarás Cloud Shell para ingresar comandos. Cloud Shell te da acceso a la línea de comandos en GCP Console; incluye el SDK de Cloud y otras herramientas que necesitas desarrollar en GCP. Cloud Shell aparece como una ventana en la parte inferior de GCP Console. Es posible que la inicialización tarde unos minutos, pero la ventana aparecerá de inmediato.

  1. Activa Cloud Shell.

    ACTIVAR Cloud Shell

  2. En Cloud Shell, establece la zona predeterminada de Compute Engine como la zona donde crearás tu clúster de Cloud Bigtable y de GKE. Este instructivo utiliza us-central1-f.

    gcloud config set compute/zone us-central1-f
  3. Crea un clúster de GKE para implementar JanusGraph:

    gcloud container clusters create janusgraph-tutorial --machine-type n1-standard-4 \
        --scopes "https://www.googleapis.com/auth/bigtable.admin","https://www.googleapis.com/auth/bigtable.data"
    
  4. Instala Helm en tu entorno de Cloud Shell:

    curl https://raw.githubusercontent.com/kubernetes/helm/master/scripts/get | bash
    

Crear una instancia de Cloud Bigtable

Para el backend de almacenamiento de JanusGraph, este instructivo utiliza Cloud Bigtable, que puede escalar rápidamente para adaptarse a tus necesidades. Este instructivo utiliza un clúster de desarrollo de un solo nodo, que es rentable y suficiente para el instructivo. Puedes comenzar tus proyectos con un clúster de desarrollo y luego pasar a un clúster de producción más grande cuando estés listo para trabajar con datos de producción. La documentación de Cloud Bigtable incluye un análisis detallado del rendimiento y el escalamiento para ayudarte a elegir un tamaño de clúster para tu propio trabajo.

Crea tu propia instancia de Cloud Bigtable; para ello, sigue los pasos siguientes:

  1. En GCP Console, ve a la página Crear instancia:

    IR A LA PÁGINA CREAR INSTANCIA

  2. En la casilla Nombre de la instancia, ingresa un nombre para tu instancia. Puedes utilizar janusgraph o cualquier otro nombre en minúscula. La página establece automáticamente el ID de la instancia y el ID del clúster cuando ingresas el nombre de la instancia.

  3. Establece el Tipo de instancia como Desarrollo.

  4. En Zona, selecciona us-central1-f o la zona en la cual creaste tu clúster de GKE anteriormente.

  5. Haz clic en Crear para crear la instancia.

Toma nota del ID de la instancia, ya que lo usarás en un próximo paso.

Configurar Helm

Helm se utiliza para implementar aplicaciones en tu clúster de Kubernetes. Después de crear tu clúster, configura Helm para que funcione con este.

  1. Pega el siguiente comando en Cloud Shell:

    kubectl create serviceaccount tiller --namespace kube-system
    kubectl create clusterrolebinding tiller-cluster-rule --clusterrole=cluster-admin \
        --serviceaccount=kube-system:tiller
    helm init --service-account=tiller
    until (timeout 7 helm version > /dev/null 2>&1); do echo "Waiting for tiller install..."; done
    

    Es posible que veas el resultado Waiting for tiller install... varias veces, pero, cuando se detenga, podrás usar Helm con tu clúster de Kubernetes.

Utilizar Helm para instalar JanusGraph y Elasticsearch

Además de utilizar Cloud Bigtable como el backend de almacenamiento, JanusGraph usará Elasticsearch como el backend de indexado. En esta sección, utilizas una tabla de Helm para implementar JanusGraph y Elasticsearch en tu clúster de Kubernetes. Cuando instalas la tabla de JanusGraph, Elasticsearch se incluye como una dependencia, que especifica el proceso.

  1. En Cloud Shell, establece una variable del entorno para mantener el valor del ID de la instancia de Cloud Bigtable que anotaste anteriormente. Reemplaza [YOUR_INSTANCE_ID] con el ID de la instancia que especificaste antes.

    export INSTANCE_ID=[YOUR_INSTANCE_ID]

    Por ejemplo, si utilizaste la sugerencia predeterminada de janusgraph para tu ID de la instancia de Cloud Bigtable, podrías ejecutar:

    export INSTANCE_ID=janusgraph
  2. Crea un archivo values.yaml, que proporcione a Helm la configuración específica que debe usar cuando instale 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. Implementa la tabla de JanusGraph Helm mediante el archivo values.yaml que creaste:

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

    La instalación espera hasta que todos los recursos estén listos antes de finalizar. Este proceso puede tardar varios minutos en completarse.

Verificar la implementación de JanusGraph

Cuando el comando helm install finaliza, da como resultado una sección NOTES que describe una experiencia del inicio. Desde Cloud Shell, sigue los pasos detallados en la sección NOTES para probar si tu entorno JanusGraph está funcionando.

  1. Establece una variante del entorno con el nombre de un pod de Kubernetes que ejecute JanusGraph:

    export POD_NAME=$(kubectl get pods --namespace default -l "app=janusgraph,release=janusgraph" -o jsonpath="{.items[0].metadata.name}")
    
  2. Conecta el pod y ejecuta el shell Gremlin:

    kubectl exec -it $POD_NAME -- /janusgraph-0.2.0-hadoop2/bin/gremlin.sh
    
  3. En la consola Gremlin, conéctate al servidor Apache TinkerPop:

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

    El resultado presenta el siguiente aspecto:

    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. Ejecuta los siguientes comandos Gremlin para crear dos vértices y una arista:

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

    El resultado presenta el siguiente aspecto:

    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. Emite una consulta Gremlin a fin de ver cuál es la etiqueta del vértice que sigue una arista out desde el vértice con la etiqueta hello:

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

    La sintaxis de la consulta se explica en la siguiente sección. Por ahora, ves la palabra "world" como el resultado de la consulta:

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

Cargar y consultar un conjunto de datos de muestra

Ahora que has implementado JanusGraph y puedes conectarte a él mediante Gremlin, puedes comenzar a cargar y consultar tus propios datos. Para ayudarte a demostrar cómo se ve ese proceso, carga el conjunto de datos de muestra que viene incluido en JanusGraph: el Grafo de los dioses, que representa las deidades mitológicas y las propiedades de su ubicación.

  1. Mientras sigues en el shell Gremlin de la última sección, ingresa el comando a continuación:

    GraphOfTheGodsFactory.load(graph)
    

    Cuando se completa el comando, se muestra null:

    gremlin> GraphOfTheGodsFactory.load(graph)
    ==>null
    
  2. Con el grafo de muestra cargado, puedes emitir consultas de recorrido del grafo. Por ejemplo, para encontrar todos los hermanos de Júpiter, ingresa la siguiente consulta:

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

    Para desglosar esta consulta puedes observar los pasos que recorre:

    Paso de recorrido Explicación
    g.V() Comienza con la recolección de vértices.
    has('name', 'jupiter') Encuentra uno con la propiedad name con el valor jupiter.
    out('brother') Luego, sigue cualquier arista etiquetada como brother.
    values('name') Para los vértices a donde conducen las aristas, obtén la propiedad name.

    Este es el resultado de la consulta:

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

Para familiarizarte con las consultas de recorrido que son posibles en este conjunto de datos Grafo de los dioses, prueba otras consultas de muestra de los documentos de JanusGraph.

Limpieza

Sigue estos pasos para evitar que se apliquen cargos a tu cuenta de Google Cloud Platform por los recursos que usaste en este instructivo:

  1. En la GCP Console, dirígete a la página Proyectos.

    Ir a la página Proyectos

  2. En la lista de proyectos, selecciona el proyecto que deseas borrar y haz clic en Borrar.
  3. En el cuadro de diálogo, escribe el ID del proyecto y, luego, haz clic en Cerrar para borrar el proyecto.

Pasos siguientes

¿Te sirvió esta página? Envíanos tu opinión:

Enviar comentarios sobre…