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

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:

  • Compute Engine, utilizado por GKE
  • Cloud 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 proyecto

  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 Cloud Bigtable, Cloud 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, establece la zona predeterminada de Compute Engine como la zona donde crearás tu clúster de Cloud Bigtable y de 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
    

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 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 automáticamente el ID de instancia. 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 utilizar Cloud Bigtable como el backend de almacenamiento, JanusGraph usará Elasticsearch como el backend de indexado.

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, establece una variable del entorno para mantener el valor del ID de la instancia de Cloud Bigtable que anotaste anteriormente. 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 tu ID de instancia de Cloud Bigtable, podrías ejecutar el siguiente código:

    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 este conjunto de datos Grafo de los dioses, prueba otras consultas de muestra de los documentos de JanusGraph.

Realiza una limpieza

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