Como executar o JanusGraph com o Cloud Bigtable

Neste tutorial, veja 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 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 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 gráficos, às vezes, você gera 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. Siga este tutorial para implantar uma infraestrutura escalonável do JanusGraph com o Cloud Bigtable, que pode ser usada para analisar os relacionamentos atuais em qualquer banco de dados gráfico.

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

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

Objetivos

  • Criar uma instância do Cloud 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 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

Ao concluir o tutorial, exclua os recursos criados para evitar a continuidade do faturamento. Consulte mais detalhes em 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 GCP e inclui o SDK do Cloud 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.

    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 Cloud 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 (em inglês) 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 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 o 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 Cloud Bigtable como back-end de armazenamento, o JanusGraph utiliza 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 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 ID da instância do Cloud Bigtable que você anotou anteriormente. Substitua [YOUR_INSTANCE_ID] pelo ID da instância especificado anteriormente.

    export INSTANCE_ID=[YOUR_INSTANCE_ID]

    Por exemplo, se você usou a sugestão padrão de janusgraph como ID da instância do Cloud 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 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, 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 (em inglês), que mostra divindades mitológicas e as respectivas propriedades de local.

  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')
    

    É possível detalhar essa consulta observando as etapas que ela analisa:

    Etapa de análise Explicação
    g.V() Começar 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 análise que são possíveis no conjunto de dados "Gráfico dos Deuses", teste outras consultas de amostra mostradas dos documentos do JanusGraph (em inglês).

Limpar

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 o projeto que você quer excluir e clique em Excluir delete.
  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…