Como executar o JanusGraph com o Cloud Bigtable

Veja neste tutorial como executar o JanusGraph no Google Cloud Platform (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 conhecidas como nodes ou vértices e as relações são conhecidas como arestas. Tanto vértices quanto arestas podem ter propriedades associadas.

Exemplo de um gráfico de propriedade

Figura 1. Exemplo de um gráfico de propriedade

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 de gráficos, às vezes você cria milhões ou até bilhões de vértices e arestas. Ao usar o JanusGraph com o Cloud Bigtable como camada de armazenamento subjacente, você pode executar consultas rápidas e escalonar sua camada de armazenamento independentemente do tamanho e da capacidade necessários. Use este tutorial para implantar uma infraestrutura escalonável do JanusGraph com o Cloud Bigtable, que você pode usar para percorrer os relacionamentos existentes em qualquer banco de dados de gráficos.

Implantação do JanusGraph com o Cloud Bigtable no GKE

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

Objetivos

Custos

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

  • Compute Engine, que é usado pelo GKE
  • Cloud Bigtable

Use a calculadora de preços para gerar uma estimativa de custo com base no uso do projeto. Novos usuários do GCP são 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. Selecione ou crie um projeto do Google Cloud Platform.

    Acessar a página Gerenciar recursos

  3. Verifique se o faturamento foi ativado no projeto do Google Cloud Platform.

    Saiba como ativar o faturamento

  4. Ativar Cloud Bigtable, Cloud Bigtable Admin, Compute Engine e GKE APIs.

    Ativar as APIs

Quando você concluir este tutorial, poderá evitar o faturamento contínuo excluindo os recursos criados. Veja mais detalhes em Como fazer a limpeza.

Como preparar o ambiente

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

  1. Ative o Cloud Shell.

    Ative 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 Cloud Bigtable e o 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 Cloud Bigtable

Para o back-end de armazenamento do JanusGraph, este tutorial usa o Cloud Bigtable, que pode escalonar rapidamente para atender às suas necessidades. Este tutorial usa um cluster de desenvolvimento de node único, que é econômico e suficiente para o tutorial. Você pode 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 Cloud Bigtable inclui uma discussão detalhada sobre desempenho e escalonamento, o que o ajuda a escolher um tamanho de cluster para o trabalho.

Crie sua instância do Cloud Bigtable seguindo estas etapas:

  1. No console do GCP, 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 que você quiser em letras minúsculas. O Código da instância e o Código do cluster são definidos automaticamente pela página após a inserção do nome da instância.

  3. Configure o Tipo de instância como Desenvolvimento.

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

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

Anote o código 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
    

    Você poderá ver a saída Waiting for tiller install... algumas vezes. Quando ela parar, será possível usar o Helm com seu cluster do Kubernetes.

Como usar o Helm para instalar o JanusGraph e o Elasticsearch

Além de usar o Cloud Bigtable como back-end de armazenamento, o JanusGraph usará o Elasticsearch como o back-end de indexação. Nesta seção, você usará um gráfico do Helm para implantar o JanusGraph e o Elasticsearch em seu cluster do Kubernetes. Quando você instala o gráfico JanusGraph, o ElasticSearch é incluído como uma 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 Cloud 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 do janusgraph no código da instância do Cloud Bigtable, execute:

    export INSTANCE_ID=janusgraph
  2. Crie um arquivo values.yaml, que fornece ao Helm a configuração específica a ser usada ao instalar o 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 Helm do JanusGraph usando o arquivo values.yaml que você criou:

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

    A instalação aguarda até que todos os recursos estejam prontos antes de ser concluída. Esse processo pode levar vários minutos.

Como verificar sua implantação do JanusGraph

Quando o comando helm install termina, ele 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á semelhante a:

    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 rótulo é para o vértice que segue uma aresta out 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 amostra

Agora que você implantou o JanusGraph e pode se conectar a ele usando o Gremlin, é possível começar 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, digite 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, você pode emitir consultas de percurso 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') Encontre um que tenha o name da propriedade com o valor de jupiter.
    out('brother') Deste ponto, siga as arestas rotuladas como brother.
    values('name') Para os vértices de destino dessas arestas, pegue 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.

Como fazer a limpeza

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

  1. No Console do GCP, acesse a página "Projetos".

    Acessar a página Projetos

  2. Na lista de projetos, selecione um e clique em Excluir projeto.
  3. Na caixa de diálogo, digite o código do projeto e clique em Encerrar para excluí-lo.

A seguir

Esta página foi útil? Conte sua opinião sobre:

Enviar comentários sobre…