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
  • Utilizar una tabla Helm para implementar JanusGraph y Elasticsearch
  • Utilizar 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 Cloud. Si eres nuevo en Google Cloud, crea una cuenta para evaluar el rendimiento de nuestros productos en situaciones reales. Los clientes nuevos también obtienen $300 en créditos gratuitos para ejecutar, probar y, además, implementar cargas de trabajo.
  2. En la página del selector de proyectos de Google Cloud Console, selecciona o crea un proyecto de Google Cloud.

    Ir al selector de proyectos

  3. Asegúrate de que la facturación esté habilitada para tu proyecto de Cloud. Descubre cómo confirmar que tienes habilitada la facturación en un 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.

Preparar 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 \
        --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. Instala Helm en tu entorno de 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
    

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 instancia de forma automática. Haz clic en Continuar.

  3. En Selecciona tu tipo de almacenamiento, selecciona HDD. Haz clic en Continuar.

  4. El ID de clúster y los Nodos se configuran automáticamente. En Región, selecciona us-central1. En Zona, selecciona us-central1-f o la zona en la que creaste el clúster de GKE.

  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 tu clúster, inicializa un repositorio de gráficos de Helm.

  1. Pega el siguiente comando en Cloud Shell:

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

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 upgrade --install --wait --timeout 600s 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
    

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

Limpia

Para evitar que se apliquen cargos a tu cuenta de Google Cloud por los recursos usados en este instructivo, borra el proyecto que contiene los recursos o conserva el proyecto y borra los recursos individuales.

  1. En Cloud Console, ve a la página Administrar recursos.

    Ir a Administrar recursos

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

Próximos pasos