Como executar o JanusGraph com o Cloud Bigtable

Neste tutorial, mostramos como executar o JanusGraph no Google Cloud (GCP). O JanusGraph é um banco de dados de gráficos compatível com grandes quantidades de dados. Os bancos de dados de gráficos ajudam você a descobrir insights modelando suas entidades de dados e os relacionamentos entre elas. Na terminologia de gráficos, as entidades são chamadas de nós ou vértices e as relações são chamadas de arestas. Tanto vértices quanto arestas podem ter propriedades associadas.

Exemplo de um gráfico de property

Figura 1. Exemplo de um gráfico de property

Os bancos de dados de gráficos ajudam a modelar vários domínios e atividades:

  • redes sociais
  • análise de fraude
  • redes físicas

Ao criar bancos de dados gráficos, às vezes, você gera milhões ou até bilhões de vértices e arestas. Quando você usa o JanusGraph com o Bigtable como camada de armazenamento subjacente, é possível executar consultas rápidas e escalonar sua camada de armazenamento de forma independente para o tamanho e a capacidade necessários. Use este tutorial para implantar uma infraestrutura escalonável do JanusGraph com o Bigtable, que pode ser usada para analisar as relações atuais em qualquer banco de dados de gráficos.

Implantação do JanusGraph com o Bigtable no GKE

Figura 2. Implantação do JanusGraph com o Bigtable no GKE

Objetivos

  • Criar uma instância do Bigtable.
  • Criar um cluster do GKE.
  • Instalar o Helm (em inglês), um gerenciador de pacotes do Kubernetes.
  • Usar um gráfico do Helm para implantar o JanusGraph e o ElasticSearch (em inglês).
  • Usar o Gremlin (em inglês) e conectar-se ao JanusGraph.
  • Carregar e consultar dados.

Custos

Neste tutorial, usamos os seguintes componentes faturáveis do Google Cloud:

  • Compute Engine, que é usado pelo GKE
  • Bigtable

Para gerar uma estimativa de custo baseada na projeção de uso deste tutorial, use a calculadora de preços. Novos usuários do Google Cloud podem ser qualificados para uma avaliação gratuita.

Antes de começar

  1. Faça login na sua conta do Google.

    Se você ainda não tiver uma, inscreva-se.

  2. No Console do Cloud, na página do seletor de projetos, selecione ou crie um projeto do Cloud.

    Acessar a página do seletor de projetos

  3. Verifique se a cobrança está ativada para o seu projeto do Google Cloud. Saiba como confirmar se a cobrança está ativada para o seu projeto.

  4. Ative as APIs Bigtable, Bigtable Admin, Compute Engine, and GKE.

    Ative as APIs

Ao concluir o tutorial, exclua os recursos criados para evitar a continuidade do faturamento. Veja mais detalhes em Como fazer a limpeza.

Como preparar o ambiente

Neste tutorial, use o Cloud Shell para inserir comandos. O Cloud Shell fornece acesso à linha de comando no Console do Cloud e inclui o SDK do Cloud e outras ferramentas que você precisa desenvolver no GCP. Ele aparece como uma janela na parte inferior do Console do Cloud. A inicialização leva alguns minutos, mas a janela aparece imediatamente.

  1. Ative o Cloud Shell.

    ATIVAR o Cloud Shell

  2. No Cloud Shell, defina a zona padrão do Compute Engine como a zona em que você criará o cluster do Bigtable e o cluster do GKE. Neste tutorial, usamos us-central1-f.

    gcloud config set compute/zone us-central1-f
  3. Crie um cluster do GKE para implantar o 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. Instale o Helm no ambiente do Cloud Shell:

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

Como criar uma instância do Bigtable

Como back-end de armazenamento do JanusGraph, este tutorial usa o Bigtable, que pode ser escalonado rapidamente para atender às suas necessidades. Neste tutorial, usamos um cluster de desenvolvimento de nó único, que é econômico e suficiente para o este propósito. É possível iniciar seus projetos com um cluster de desenvolvimento e, em seguida, migrar para um cluster de produção maior quando estiver pronto para trabalhar com dados de produção. A documentação do Bigtable inclui uma abordagem detalhada sobre desempenho e escalonamento para ajudar você a escolher um tamanho de cluster para seu próprio trabalho.

Crie sua instância do Bigtable seguindo estas etapas.

  1. No Console do Cloud, acesse a página Criar instância:

    ACESSAR A PÁGINA "CRIAR INSTÂNCIA"

  2. Na caixa Nome da instância, insira um nome para a instância. É possível usar janusgraph ou outro nome de letra minúscula de sua escolha. Na página, ID da instância e o ID do cluster são definidos automaticamente após a inserção do nome da instância.

  3. Configure Tipo de instância como Desenvolvimento.

  4. Em Zona, selecione us-central1-f ou a zona em que você criou seu cluster do GKE anteriormente.

  5. Clique em Criar para criar a instância.

Anote o ID da instância, porque você o usará em uma etapa futura.

Como configurar o Helm

Você usa o Helm para implantar aplicativos em seu cluster do Kubernetes. Depois de criar seu cluster, configure o Helm para trabalhar com ele.

  1. Cole os comandos a seguir no 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
    

    A saída Waiting for tiller install... aparecerá algumas vezes e, quando ela parar, o Helm poderá ser usado com seu cluster do Kubernetes.

Como usar o Helm para instalar o JanusGraph e o Elasticsearch

Além de usar o Bigtable como back-end de armazenamento, o JanusGraph utilizará o Elasticsearch como back-end de indexação (em inglês).

Nesta seção, você usa um gráfico do Helm (em inglês) para implantar o JanusGraph e o Elasticsearch (links em inglês) no cluster do Kubernetes. Quando você instala o gráfico JanusGraph, o ElasticSearch é incluído como dependência, o que simplifica o processo.

  1. No Cloud Shell, defina uma variável de ambiente para manter o valor do código da instância do Bigtable que você anotou anteriormente. Substitua [YOUR_INSTANCE_ID] pelo código da instância especificado anteriormente.

    export INSTANCE_ID=[YOUR_INSTANCE_ID]

    Por exemplo, se você usou a sugestão padrão janusgraph como código da instância do Bigtable, execute:

    export INSTANCE_ID=janusgraph
  2. Crie um arquivo values.yaml que forneça ao Helm a configuração específica a ser usada na instalação do 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. Implante o gráfico JanusGraph do Helm usando o arquivo values.yaml que você criou:

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

    A instalação aguarda todos os recursos ficarem prontos para ser concluída. Esse processo pode levar vários minutos.

Como verificar sua implantação do JanusGraph

Quando o comando helm install é concluído, gera uma seção NOTES que descreve uma experiência de primeiros passos. No Cloud Shell, siga as etapas descritas na seção NOTES para testar o funcionamento do ambiente do JanusGraph.

  1. Defina uma variável de ambiente com o nome de um pod do Kubernetes que esteja executando o JanusGraph:

    export POD_NAME=$(kubectl get pods --namespace default -l "app=janusgraph,release=janusgraph" -o jsonpath="{.items[0].metadata.name}")
    
  2. Conecte-se ao pod e execute o shell do Gremlin:

    kubectl exec -it $POD_NAME -- /janusgraph-0.2.0-hadoop2/bin/gremlin.sh
    
  3. No console do Gremlin, conecte-se ao servidor Apache TinkerPop:

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

    A saída será assim:

    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. Execute os comandos do Gremlin a seguir para criar dois vértices e uma aresta:

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

    A saída será assim:

    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. Emita uma consulta do Gremlin para ver qual é o rótulo do vértice que segue uma aresta out partindo do vértice com o rótulo hello:

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

    A sintaxe da consulta é explicada na próxima seção. Por enquanto, você verá a palavra "world" como a saída da consulta:

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

Como carregar e consultar um conjunto de dados de exemplo

Agora que você implantou o JanusGraph e pode se conectar a ele usando o Gremlin, comece a carregar e consultar seus próprios dados. Para demonstrar como é esse processo, carregue o conjunto de dados de amostra que acompanha o JanusGraph: o Gráfico dos Deuses, que mostra divindades mitológicas e as propriedades de local delas.

  1. Enquanto você ainda estiver no shell do Gremlin da última seção, insira o comando a seguir:

    GraphOfTheGodsFactory.load(graph)
    

    Quando o comando for concluído, ele retornará null:

    gremlin> GraphOfTheGodsFactory.load(graph)
    ==>null
    
  2. Com o gráfico de amostra carregado, é possível emitir consultas de análise de gráfico. Por exemplo, para encontrar todos os irmãos de Júpiter, digite a consulta abaixo:

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

    Você pode detalhar essa consulta observando as etapas que ela percorre:

    Etapa do percurso Explicação
    g.V() Comece com a coleção de vértices.
    has('name', 'jupiter') Encontrar um que tenha a propriedade name com o valor jupiter.
    out('brother') Deste ponto, seguir as arestas com o rótulo brother.
    values('name') Para os vértices de destino dessas arestas, usar a propriedade name.

    Esta é a saída da consulta:

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

Para se familiarizar mais com as consultas de percurso que são possíveis no conjunto de dados "Gráfico dos Deuses", teste outras consultas de amostra dos documentos do JanusGraph (em inglês).

Como fazer a limpeza

Para evitar cobranças na conta do Google Cloud Platform, referentes aos recursos usados neste tutorial:

  1. No Console do Cloud, acesse a página Gerenciar recursos:

    Acessar a página "Gerenciar recursos"

  2. Na lista de projetos, selecione o projeto que você quer excluir e clique em Excluir .
  3. Na caixa de diálogo, digite o ID do projeto e clique em Encerrar para excluí-lo.

A seguir