Ejecución de JanusGraph con Cloud Bigtable

En este instructivo se muestra cómo ejecutar JanusGraph en Google Cloud (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 los grafos, las entidades se conocen como nodos o vértices y las relaciones 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

Al crear bases de datos de grafos, a veces se generan millones o incluso miles de millones de vértices y aristas. Cuando usas JanusGraph con Bigtable como capa de almacenamiento subyacente, puedes ejecutar consultas rápidas y escalar tu capa de almacenamiento de forma independiente según el tamaño y la capacidad de procesamiento que necesites. Usa este instructivo a fin de implementar una infraestructura de JanusGraph escalable con Bigtable, que podrás usar para recorrer las relaciones que existen en cualquier base de datos de grafos.

Implementación de JanusGraph con Bigtable en GKE

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

Objetivos

  • Crear una instancia de Bigtable.
  • Crear un clúster de GKE.
  • Instalar Helm, un administrador de paquetes de Kubernetes.
  • Usar un gráfico Helm para implementar JanusGraph y Elasticsearch.
  • Usar Gremlin y conectarse con JanusGraph.
  • Cargar y luego consultar datos.

Costos

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

  • Compute Engine, usado por GKE
  • Bigtable

Para generar una estimación de costos en función del uso previsto, usa la calculadora de precios. Es posible que los usuarios nuevos de Google Cloud sean aptos para obtener 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. En la página de selección de proyectos de Cloud Console, selecciona o crea un proyecto de Cloud.

    Ir a la página Selector de proyectos

  3. Asegúrate de que la facturación esté habilitada para tu proyecto de Google Cloud. Obtén información sobre cómo confirmar que tienes habilitada la facturación para tu proyecto.

  4. Habilita las API de Bigtable, Bigtable Admin, Compute Engine, and GKE.

    Habilita las API

Cuando completes el instructivo puedes borrar los recursos que hayas creado para evitar que se te sigan facturando. Para obtener más detalles consulta la sección Limpieza.

Prepara tu entorno

En este instructivo usarás Cloud Shell para ingresar comandos. Cloud Shell te brinda acceso a la línea de comandos en Cloud Console y también incluye el SDK de Cloud y otras herramientas que necesitas para el desarrollo en GCP. Cloud Shell se abre en una ventana en la parte inferior de Cloud Console. Es posible que la inicialización tome unos minutos, pero la ventana aparecerá de inmediato.

  1. Activa Cloud Shell.

    ACTIVAR Cloud Shell

  2. En Cloud Shell, configura la zona predeterminada de Compute Engine como la zona en la que crearás los clústeres de Bigtable y GKE. En este instructivo se usa 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
    

Crea una instancia de Bigtable

Para el backend de almacenamiento de JanusGraph, en este instructivo se usa Bigtable, que puede escalar con rapidez para adaptarse a tus necesidades. En el instructivo se usa un clúster de desarrollo de nodo único, una opción rentable y suficiente para este caso. 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 Bigtable incluye un análisis detallado sobre el rendimiento y el escalamiento que te ayudará a elegir el tamaño de clúster para tu trabajo.

Sigue estos pasos para crear una instancia de Bigtable.

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

    IR A LA PÁGINA CREAR INSTANCIA

  2. En el cuadro Nombre de la instancia, ingresa un nombre para tu instancia. Puedes usar janusgraph o cualquier otro nombre en minúscula que elijas. La página establece el ID de la instancia y el ID del clúster de forma automática 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 que creaste el clúster de GKE antes.

  5. Haz clic en Crear para crear la instancia.

Toma nota del ID de la instancia, ya que lo usarás en otro paso.

Configuración de Helm

Helm se utiliza para implementar aplicaciones en tu clúster de Kubernetes. Después de crear el clúster, configura Helm para que interactúe con él.

  1. Pega los siguientes comandos 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 deje de aparecer, podrás usar Helm con el clúster de Kubernetes.

Uso de Helm para instalar JanusGraph y Elasticsearch

Además de usar Bigtable como backend de almacenamiento, JanusGraph empleará Elasticsearch como backend de indexación.

En esta sección usas un gráfico de Helm para implementar JanusGraph y Elasticsearch en el clúster de Kubernetes. Cuando instalas el gráfico de JanusGraph, Elasticsearch se incluye como dependencia, lo que simplifica el proceso.

  1. En Cloud Shell configura una variable de entorno para alojar el valor del ID de la instancia de Bigtable que anotaste antes. Reemplaza [YOUR_INSTANCE_ID] por el ID de la instancia que especificaste antes.

    export INSTANCE_ID=[YOUR_INSTANCE_ID]

    Por ejemplo, si usaste la sugerencia predeterminada de janusgraph para el ID de la instancia de Bigtable, deberías ejecutar la siguiente instrucción:

    export INSTANCE_ID=janusgraph
  2. Crea un archivo values.yaml que proporcione a Helm la configuración específica para usar cuando se 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 el gráfico de Helm de JanusGraph 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.

Verificación de la implementación de JanusGraph

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

  1. Establece una variable de 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 es similar al siguiente:

    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 de Gremlin para crear dos vértices y una arista:

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

    El resultado es similar al siguiente:

    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. Genera una consulta de Gremlin para ver cuál es la etiqueta del vértice que sigue a 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
    

Carga y consulta de un conjunto de datos de muestra

Ahora que implementaste JanusGraph y puedes conectarte a él mediante Gremlin, es momento de comenzar a cargar y consultar tus propios datos. Para saber mejor cómo se ve ese proceso, carga el conjunto de datos de muestra que viene incluido en JanusGraph: Graph of the Gods (Gráfico de los dioses), que representa las deidades mitológicas y las propiedades de su ubicación.

  1. Sin salir del shell de Gremlin de la última sección, ingresa el siguiente comando:

    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 que tenga la propiedad name con el valor jupiter.
    out('brother') Desde allí sigue cualquier arista etiquetada como brother.
    values('name') Para los vértices a los que conducen esas 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 el conjunto de datos del grafo de los dioses, prueba otras consultas de muestra incluidas en 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 Cloud Console, ve a la página Administrar recursos.

    Ir a la página Administrar recursos

  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 haz clic en Cerrar para borrar el proyecto.

Próximos pasos