Como usar o OpenTSDB para monitorar dados de série temporal

Neste tutorial, descrevemos como coletar, registrar e monitorar dados de série temporal no Google Cloud usando o OpenTSDB em execução no Google Kubernetes Engine (GKE) e Bigtable.

Os dados de série temporal são um recurso altamente valioso que pode ser usado para vários aplicativos, incluindo tendências, monitoramento e machine learning. É possível gerar esses dados da infraestrutura do servidor, do código do aplicativo e de outras fontes. O OpenTSDB coleta e retém grandes quantidades de dados de série temporal com um alto grau de granularidade.

Neste tutorial, detalhamos como criar uma camada de coleta de dados escalonável usando o GKE e trabalhar com os dados coletados usando o Bigtable. O diagrama a seguir ilustra a arquitetura geral da solução:

Diagrama de arquitetura geral da solução deste tutorial para usar o TSDB no Google Cloud.

Objetivos

  • Criar uma nova instância do Bigtable.
  • Criar um cluster no GKE.
  • Implantar o OpenTSDB no cluster do GKE.
  • Enviar métricas de série temporal para o OpenTSDB.
  • Visualizar métricas usando o OpenTSDB e o Grafana.

Custos

Neste tutorial, há componentes faturáveis do Google Cloud, entre eles:

  • Compute Engine
  • GKE
  • Bigtable
  • Cloud Storage

Use a calculadora de preços para gerar uma estimativa de custo com base no uso previsto.

Novos usuários do Google Cloud podem estar 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 Google Cloud, na página do seletor de projetos, selecione ou crie um projeto do Google Cloud.

    Acessar a página do seletor de projetos

  3. Verifique se o faturamento está ativado para seu projeto na nuvem. Saiba como confirmar se o faturamento está ativado para o projeto.

  4. Ative as APIs Cloud Bigtable, Cloud Bigtable Admin, Compute Engine, and Google Kubernetes Engine.

    Ative as APIs

Anote o ID do projeto para usar em uma etapa posterior.

Como preparar o ambiente

Neste tutorial, você usará o Cloud Shell para inserir comandos. Ele fornece acesso à linha de comando no Console do Cloud e inclui o SDK do Cloud, além de outras ferramentas necessárias para o desenvolvimento do Google Cloud. O Cloud Shell 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. Defina a zona padrão do Compute Engine como a zona em que você criará o cluster do Bigtable, por exemplo, us-central1-f.

    gcloud config set compute/zone us-central1-f
    
  3. Clone o repositório git que contém o código de amostra.

    git clone https://github.com/GoogleCloudPlatform/opentsdb-bigtable.git
    
  4. Navegue até o diretório do código de amostra.

    cd opentsdb-bigtable
    

Como criar uma instância do Bigtable

Este tutorial usa o Bigtable para armazenar os dados de série temporal coletados. Você precisa criar uma instância do Bigtable para fazer isso.

O Bigtable é um armazenamento de colunas largas/chave que funciona especialmente para dados de série temporal, conforme explicado em Projeto de esquema do Bigtable para dados de série temporal. O Bigtable é compatível com a API HBase, que facilita o uso de software desenvolvido para trabalhar com o Apache HBase, como o OpenTSDB. Saiba mais sobre o esquema do HBase usado pelo OpenTSDB na documentação do OpenTSDB.

O principal componente do OpenTSDB é o cliente AsyncHBase, que permite gravar em massa para HBase de maneira totalmente assíncrona, sem bloqueios e thread-safe. Quando você usa o OpenTSDB com o Bigtable, o AsyncHBase é implementado como cliente AsyncBigtable.

A capacidade de escalonar facilmente para atender às suas necessidades é um recurso fundamental do Bigtable. Neste tutorial, um cluster de desenvolvimento de nó único é usado porque é suficiente para a tarefa, além de ser econômico. Inicie seus projetos em um cluster de desenvolvimento e mude 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.

Siga estas etapas para criar uma instância do Bigtable:

  1. Acesse a página Criar instância no Console do Cloud.

    ACESSAR A PÁGINA "CRIAR INSTÂNCIA"

  2. Digite um nome para sua instância na caixa Nome da instância. Você pode usar OpenTSDB instance ou outro nome de sua escolha. Na página, ID da instância e 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ê executará o OpenTSDB.

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

Anote os valores do Código da instância e Zona. Eles serão usados em uma etapa posterior.

Como criar um cluster do GKE

O GKE fornece um ambiente gerenciado do Kubernetes. Depois de criar um cluster do GKE, é possível implantar os pods do Kubernetes nele. Neste tutorial, usamos o GKE e os pods do Kubernetes para executar o OpenTSDB.

O armazenamento do OpenTSDB fica separado da camada de aplicação, o que permite a implantação simultânea em diversas instâncias. Durante a execução em paralelo, uma grande quantidade de dados de série temporal é processada pelo OpenTSDB. O empacotamento dele em um contêiner do Docker facilita a implantação em escala usando o GKE.

Execute o comando abaixo para criar um cluster do Kubernetes. Esta operação leva alguns minutos para ser concluída:

gcloud container clusters create opentsdb-cluster --scopes \
"https://www.googleapis.com/auth/bigtable.admin",\
"https://www.googleapis.com/auth/bigtable.data"

Adicionar os dois escopos extras ao cluster do GKE permite que o contêiner do OpenTSDB interaja com o Bigtable. É possível receber imagens do Google Container Registry sem adicionar um escopo para o Cloud Storage, já que o cluster lê no Cloud Storage por padrão. Escopos adicionais podem ser necessários em outras implantações.

O restante deste tutorial usa um contêiner predefinido, gcr.io/cloud-solutions-images/opentsdb-bigtable:v1, localizado no Container Registry. Os scripts Dockerfile e ENTRYPOINT usados para criar o contêiner estão localizados na pasta build do repositório do tutorial.

Como criar um ConfigMap com detalhes de configuração

O Kubernetes inclui um mecanismo chamado ConfigMap para separar os detalhes da configuração da imagem do contêiner, o que torna os aplicativos mais portáteis. A configuração do OpenTSDB é especificada em opentsdb.conf. Um ConfigMap contendo opentsdb.conf está incluído no código de amostra. É preciso editá-lo para refletir os detalhes da sua instância.

Criar o ConfigMap

Edite a configuração do OpenTSDB para usar o nome do projeto, o identificador da instância e a zona utilizada na criação da instância.

  1. Para abrir o editor de código integrado ao Cloud Shell, clique no ícone de lápis na barra de ferramentas, na parte superior da janela do Cloud Shell.

  2. Selecione opentsdb-config.yaml em opentsdb/configmaps para abri-lo no editor.

  3. Substitua o texto do marcador pelo nome do projeto, identificador de instância e zona definidos anteriormente no tutorial.

  4. No prompt do Cloud Shell, crie um ConfigMap a partir do opentsdb-config.yaml atualizado:

    kubectl create -f configmaps/opentsdb-config.yaml
    

Como criar tabelas do OpenTSDB no Bigtable

Antes de ler ou gravar dados usando o OpenTSDB, você precisa criar as tabelas necessárias no Bigtable para armazenar esses dados. Siga estas etapas para criar um job do Kubernetes que crie essas tabelas.

  1. Inicie o job:

    kubectl create -f jobs/opentsdb-init.yaml
    
  2. Este job leva alguns minutos para ser concluído. Para verificar se ele foi finalizado com sucesso, execute este comando periodicamente:

    kubectl describe jobs
    

    A saída indica que um job foi bem-sucedido sob o título Pods Statuses.

  3. Receba os registros dos jobs de criação da tabela executando os seguintes comandos:

    pods=$(kubectl get pods  --show-all --selector=job-name=opentsdb-init \
    --output=jsonpath={.items..metadata.name})
    
    kubectl logs $pods
    

Ao receber os registros, examine a parte inferior da saída, que indica cada tabela criada. Esse job executa vários comandos de criação de tabela, cada um assumindo a forma de create 'TABLE_NAME'. Procure uma linha no formato 0 row(s) in 0.0000 seconds, em que a duração real do comando esteja listada em vez de 0.0000.

Sua saída precisa incluir uma seção com aparência semelhante a esta:

create 'tsdb-uid',
  {NAME => 'id', COMPRESSION => 'NONE', BLOOMFILTER => 'ROW'},
  {NAME => 'name', COMPRESSION => 'NONE', BLOOMFILTER => 'ROW'}
0 row(s) in 1.3680 seconds

Hbase::Table - tsdb-uid

create 'tsdb',
  {NAME => 't', VERSIONS => 1, COMPRESSION => 'NONE', BLOOMFILTER => 'ROW'}
0 row(s) in 0.6570 seconds

Hbase::Table - tsdb

create 'tsdb-tree',
  {NAME => 't', VERSIONS => 1, COMPRESSION => 'NONE', BLOOMFILTER => 'ROW'}
0 row(s) in 0.2670 seconds

Hbase::Table - tsdb-tree

create 'tsdb-meta',
  {NAME => 'name', COMPRESSION => 'NONE', BLOOMFILTER => 'ROW'}
0 row(s) in 0.5850 seconds

Hbase::Table - tsdb-meta

Basta executar esse job uma vez. Ele retorna uma mensagem de erro caso já existam as tabelas. Continue o tutorial usando as tabelas existentes, se houver.

Modelo de dados

As tabelas que você acabou de criar armazenarão pontos de dados do OpenTSDB. Em uma etapa posterior, você gravará dados de série temporal nessas tabelas. Os pontos de dados de série temporal são organizados e armazenados da seguinte forma:

Campo Obrigatório Descrição Exemplo
metric Obrigatório Item a ser avaliado - a chave padrão sys.cpu.user
timestamp Obrigatório Tempo de época da avaliação 1497561091
value Obrigatório Valor de avaliação 89,3
Tags Adicione pelo menos uma tag Qualifica a avaliação para fins de consulta

hostname=www

cpu=0

env=prod

Como implantar o OpenTSDB

No restante deste tutorial, você recebe instruções para fazer com que o cenário de amostra funcione. O diagrama a seguir mostra a arquitetura a ser utilizada:

Diagrama da arquitetura usada neste tutorial para gravar, ler e visualizar dados de série temporal.

Este tutorial usa duas implantações do Kubernetes. Uma envia métricas para o OpenTSDB e a outra lê a partir dela. O uso de duas implantações evita que as leituras e gravações longas bloqueiem uma à outra. O mesmo contêiner é usado pelos pods em cada implantação. O OpenTSDB fornece um daemon chamado tsd que é executado em cada contêiner.

Um único processo tsd pode processar uma alta capacidade de eventos a cada segundo. Para distribuir a carga, cada implantação neste tutorial cria 3 réplicas de pods de leitura e gravação.

Criar uma implantação para métricas de gravação

As informações de configuração da implantação do gravador estão em opentsdb-write.yaml na pasta deployments do repositório do tutorial. Use o comando abaixo para criá-lo:

kubectl create -f deployments/opentsdb-write.yaml

Criar uma implantação para métricas de leitura

As informações de configuração da implantação do leitor estão em opentsdb-read.yaml na pasta deployments do repositório do tutorial. Use o comando abaixo para criá-lo:

kubectl create -f deployments/opentsdb-read.yaml

Em uma implantação de produção, é possível aumentar o número de pods tsd em execução manualmente ou usando o escalonamento automático no Kubernetes. Da mesma forma, é possível aumentar o número de instâncias no cluster do GKE manualmente ou usando o Escalonador automático de cluster.

Como criar serviços do OpenTSDB

Para fornecer conectividade de rede consistente às implantações, crie dois serviços do Kubernetes. Um serviço grava métricas no OpenTSDB e o outro faz a leitura delas.

Criar o serviço para gravar métricas

As informações de configuração do serviço de gravação de métricas estão contidas em opentsdb-write.yaml na pasta services do repositório do tutorial. Use o comando a seguir para criar o serviço:

kubectl create -f services/opentsdb-write.yaml

Esse serviço é criado no cluster do GKE e está acessível a outros serviços em execução no cluster. Na próxima seção, você gravará métricas neste serviço.

Criar o serviço para ler métricas

As informações de configuração do serviço de leitura de métricas estão contidas em opentsdb-read.yaml na pasta services do repositório do tutorial. Use o comando a seguir para criar o serviço:

kubectl create -f services/opentsdb-read.yaml

Como gravar dados de série temporal no OpenTSDB

Há vários mecanismos para gravar dados no OpenTSDB. Depois de definir os pontos de extremidade do serviço, você pode direcionar os processos para começar a gravar dados neles. Este tutorial usa o Heapster para mostrar os dados de gravação. Na implantação do Heapster, dados sobre o GKE são coletados, e métricas do cluster do GKE em que você estiver executando o OpenTSDB são publicadas.

Use o comando a seguir para implantar o Heapster no cluster:

kubectl create -f deployments/heapster.yaml

Como examinar dados de série temporal com o OpenTSDB

É possível consultar métricas de série temporal usando o ponto de extremidade do serviço opentsdb-read implantado anteriormente no tutorial. É possível usar os dados de diversas maneiras. Uma opção comum é visualizar. O OpenTSDB inclui uma interface básica para visualizar as métricas coletadas. Neste tutorial, você aprende a usar o Grafana, uma alternativa conhecida para visualização de métricas que inclui funcionalidades complementares.

Configurar o Grafana

A execução do Grafana no cluster requer um processo semelhante ao usado para configurar o OpenTSDB. Além de criar um ConfigMap e uma implantação, você precisa configurar o encaminhamento de portas para poder acessar o Grafana enquanto ele estiver em execução no seu cluster do GKE.

Use as etapas abaixo para configurar o Grafana

  1. Crie o ConfigMap do Grafana usando as informações de configuração em grafana.yaml na pasta configmaps do repositório do tutorial.

    kubectl create -f configmaps/grafana.yaml
    
  2. Crie a implantação do Grafana usando as informações de configuração em grafana.yaml na pasta deployments do repositório do tutorial.

    kubectl create -f deployments/grafana.yaml
    
  3. Receba o nome do pod do Grafana no cluster e use-o para configurar o encaminhamento de portas.

    grafana=$(kubectl get pods --show-all --selector=app=grafana \
      --output=jsonpath={.items..metadata.name})
    
    kubectl port-forward $grafana 8080:3000
    
  4. Verifique se o encaminhamento foi bem-sucedido. A saída deve corresponder ao seguinte:

    Forwarding from 127.0.0.1:8080 -> 3000
    Forwarding from [::1]:8080 -> 3000
    

Conectar-se à interface da Web do Grafana

No Cloud Shell, clique em Visualização da Web e selecione Visualizar na porta 8080.

Uma nova guia do navegador é aberta e conectada à interface da Web do Grafana. Depois de alguns instantes, o navegador exibe gráficos semelhantes a este:

Exemplo de visualização Grafana

Esta implantação do Grafana foi personalizada para este tutorial. Os arquivos configmaps/grafana.yaml e deployments/grafana.yaml configuram o Grafana para se conectar ao serviço opentsdb-read, permitir autenticação anônima e exibir algumas métricas básicas do cluster. Com a implantação do Grafana na produção, são implementados mecanismos de autenticação apropriados e são utilizados gráficos de série temporal mais avançados.

Como fazer limpeza

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

  1. Exclua o cluster do GKE para encerrar todos os artefatos criados anteriormente com o comando kubectl create:

    gcloud container clusters delete opentsdb-cluster
    

    Para excluir o cluster do GKE, confirme digitando Y ou pressionando Enter.

  2. Para excluir o cluster do Bigtable, clique em Produtos e serviços no Console do Google Cloud. Clique em Bigtable, selecione o cluster criado anteriormente e clique em Excluir.

A seguir