Como executar o JanusGraph com o Cloud Bigtable

Neste tutorial, você verá como executar o JanusGraph no Google Cloud Platform (GCP). O JanusGraph é um banco de dados gráfico compatível com grandes volumes de dados. Com esses bancos de dados, você descobre insights ao modelar as 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 gráficos, às vezes, você gera milhões ou até bilhões de vértices e arestas. Quando você usa o JanusGraph com o Cloud Bigtable como camada de armazenamento subjacente, é possível executar consultas rápidas e escalonar a camada de armazenamento independentemente para o tamanho e a capacidade necessários. Siga este tutorial para implantar uma infraestrutura escalonável do JanusGraph com o Cloud Bigtable, que pode ser usado para percorrer 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, que é um gerenciador de pacotes do Kubernetes.
  • Usar um gráfico do Helm para implantar o JanusGraph e o ElasticSearch.
  • Usar o Gremlin e conectar-se ao JanusGraph.
  • Carregar e consultar dados.

Custos

Neste tutorial, os seguintes componentes faturáveis do Google Cloud Platform são usados:

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

    Acessar a página Gerenciar recursos

  3. Verifique se o faturamento foi ativado para o projeto.

    Saiba como ativar o faturamento

  4. {% dynamic if "no_credentials" in setvar.task_params %}{% dynamic setvar credential_type %}NO_AUTH{% dynamic endsetvar %}{% dynamic if not setvar.redirect_url %}{% dynamic setvar redirect_url %}https://console.cloud.google.com{% dynamic endsetvar %}{% dynamic endif %}{% dynamic endif %}{% dynamic if setvar.in_henhouse_no_auth_whitelist %}{% dynamic if not setvar.credential_type %}{% dynamic setvar credential_type %}NO_AUTH{% dynamic endsetvar %}{% dynamic endif %}{% dynamic elif setvar.in_henhouse_service_account_whitelist %}{% dynamic if not setvar.credential_type %}{% dynamic setvar credential_type %}SERVICE_ACCOUNT{% dynamic endsetvar %}{% dynamic endif %}{% dynamic endif %}{% dynamic if not setvar.service_account_roles and setvar.credential_type == "SERVICE_ACCOUNT" %}{% dynamic setvar service_account_roles %}{% dynamic endsetvar %}{% dynamic endif %}{% dynamic setvar console %}{% dynamic if "no_steps" not in setvar.task_params %}
  5. {% dynamic endif %}{% dynamic if setvar.api_list %}{% dynamic if setvar.in_henhouse_no_auth_whitelist or setvar.in_henhouse_service_account_whitelist %} Configure um projeto do Console do GCP.

    Configurar um projeto

    Clique para:

    • criar ou selecionar um projeto;
    • ativar {% dynamic if setvar.api_names %}{% dynamic print setvar.api_names %}{% dynamic else %}obrigatória{% dynamic endif %}{% dynamic if "," in setvar.api_list %} APIs{% dynamic elif "API" in setvar.api_names %}{% dynamic else %} API{% dynamic endif %} para o projeto;
    • {% dynamic if setvar.credential_type == 'SERVICE_ACCOUNT' %}
    • criar uma conta de serviço;
    • fazer o download de uma chave privada como JSON.
    • {% dynamic endif %}

    É possível ver e gerenciar esses recursos a qualquer momento no Console do GCP.

    {% dynamic else %}{% dynamic if "no_text" not in setvar.task_params %} Ativar {% dynamic if setvar.api_names %}{% dynamic print setvar.api_names %}{% dynamic else %}obrigatória{% dynamic endif %}{% dynamic if "," in setvar.api_list %} APIs{% dynamic elif "API" in setvar.api_names %}{% dynamic else %} API{% dynamic endif %}. {% dynamic endif %}

    Ativar {% dynamic if "," in setvar.api_list %} as APIs{% dynamic else %} a API{% dynamic endif %}

    {% dynamic endif %}{% dynamic endif %}{% dynamic if "no_steps" not in setvar.task_params %}
  6. {% dynamic endif %}{% dynamic endsetvar %}{% dynamic print setvar.console %}

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, você usa o Cloud Shell para inserir comandos. Ele fornece acesso à linha de comando no Console do GCP e inclui o SDK do Cloud e outras ferramentas que você precisa desenvolver na plataforma. O Cloud Shell é exibido 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 utiliza o ElasticSearch como o back-end de indexação. Nesta seção, você usa um gráfico do Helm para implantar o JanusGraph e o ElasticSearch no 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)
    

    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…