Como analisar registros em tempo real usando o Fluentd e o BigQuery

Neste tutorial, mostramos como registrar o tráfego do navegador e analisá-lo em tempo real. Isso é útil quando você tem registros de várias origens, em quantidade significativa e quer depurar problemas ou gerar estatísticas atualizadas usando esses registros.

Neste tutorial, descrevemos como enviar informações de registro geradas por um servidor da Web NGINX para o BigQuery por meio do Fluentd e depois usar o BigQuery para analisar as informações de registro. Pressupomos que você tenha conhecimento básico do Google Cloud Platform (GCP), de linhas de comando, coleta de registros de aplicativos e análise de registros do Linux.

Introdução

Os registros são uma ferramenta poderosa para fornecer uma visão de como os sistemas e aplicativos de grande escala estão sendo executados. No entanto, como a escala e a complexidade desses sistemas aumenta, torna-se um desafio gerenciar vários registros distribuídos em uma frota de recursos computacionais.

O Fluentd é um conhecido coletor de registros de código aberto, usado para unificar a coleta de registros de várias origens de dados e diversos sistemas em uma camada de registros unificada. É difícil saber antecipadamente que dados podem ser úteis para análise, por isso, é comum fazer o registro de todos e depois classificá-los. No entanto, a coleta e o armazenamento desses dados pode ser uma tarefa pesada, que dificulta e atrasa o recebimento das respostas que você está procurando.

Aqui os pontos fortes do BigQuery se tornam úteis para receber insights dos registros. O BigQuery é o mecanismo de armazenamento de dados do Google, totalmente gerenciado, altamente escalonável e analítico. Com ele, é possível executar consultas em terabytes de registros, em dezenas de segundos. Esse desempenho permite que você consiga as respostas de que precisa com mais rapidez e possa corrigir ou aprimorar seus sistemas.

Por padrão, é possível fazer streaming de 100.000 linhas de dados de registro por segundo no BigQuery e esse limite pode ser aumentado, basta você solicitar aumento da cota.

O Fluentd tem um plug-in de saída que pode usar o BigQuery como destino para armazenar os registros coletados. Com esse plug-in, é possível carregar registros de vários servidores diretamente no BigQuery, quase em tempo real. Com isso, é possível visualizar facilmente esses dados com a criação de um painel que é atualizado com frequência no Planilhas Google ou no Google Data Studio.

Objetivos

  • Executar um servidor da Web NGINX em uma instância do Compute Engine.
  • Instalar um agente de coleta de registros do Fluentd.
  • Configurar o Fluentd para efetuar o seguinte:
    • Coletar registros de tráfego do NGINX.
    • Encaminhar os registros para o BigQuery.
  • Consultar as mensagens de registro usando a IU da Web do BigQuery.
  • Executar uma consulta analítica nos registros usando o BigQuery.

Custos

Neste tutorial, há componentes do Google Cloud Platform passíveis de cobrança, entre eles:

  • Compute Engine
  • BigQuery

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

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

Ao concluir este tutorial, exclua os recursos criados para evitar o faturamento contínuo. Veja mais detalhes em Limpeza.

Como criar uma VM de servidor da Web NGINX

Neste tutorial, você usará o GCP Marketplace para criar uma instância do Compute Engine, pré-configurada para executar o servidor da Web NGINX.

  1. No Console do GCP, acesse a página de detalhes do Marketplace com a imagem do Nginx (Google Click-to-Deploy):

    Acessar a página de detalhes do NGINX

  2. Clique em Iniciar no Compute Engine.

  3. Se for solicitado, selecione o projeto do GCP a ser usado.

  4. Aguarde a ativação das APIs necessárias.

  5. Nomeie a implantação nginx.

  6. Selecione a zona em uma região dos EUA ou da Europa.

  7. Em Firewall, na seção Rede, certifique-se de que a opção Permitir tráfego HTTP esteja selecionada.

  8. Leia os termos listados em Termos de serviço.

  9. Se você aceita os termos, clique em Implantar

    A tela de detalhes da implantação mostra a criação de uma nova VM na zona que você especificou e a instalação do servidor da Web NGINX.

  10. Aguarde a conclusão da implantação antes de continuar.

Como adicionar permissões

É preciso que a máquina virtual tenha outras permissões para gravar no BigQuery. A modificação das permissões da VM exige que você primeiro a encerre.

  1. No Console do GCP, acesse a página Instâncias da VM do Compute Engine.

    Acessar a página Instâncias de VM

    Você vê uma nova instância de VM chamada nginx-vm.

  2. Para abrir a página de detalhes de VM, clique no nome da VM.

  3. Na parte superior da página, clique no botão Interromper.

    O encerramento da VM pode levar alguns instantes.

  4. Clique em Editar, no topo da página.

  5. Role a tela para baixo e altere o acesso ao BigQuery para Ativado.

  6. Clique em Salvar, na parte inferior da página.

  7. Clique em click em Iniciar, na parte superior da página para reiniciar a VM com as novas permissões.

Não fecha essa página ainda, você continuará trabalhando nela na próxima seção.

Como instalar o conector do Fluentd com o BigQuery

Nesta seção do tutorial, você instalará o coletor de registros do Fluentd e o plug-in de saída para o BigQuery na VM.

  1. Na página de detalhes da instância de VM, clique no botão SSH para abrir a conexão com a instância.
  2. Na janela do shell na VM, verifique a versão do Debian:

    lsb_release -rdc
    

    O resultado mostra que a versão do Debian que está em execução na VM e seu codinome.

    Description:    Debian GNU/Linux 9.6 (stretch)
    Release:        9.6
    Codename:       stretch
    
  3. Acesse a página de download do Fluentd para Debian e encontre a linha de comando da instalação para a versão do codinome do Debian.

    Por exemplo, para o Debian Stretch, você encontrará o seguinte comando:

    curl -L
       https://toolbelt.treasuredata.com/sh/install-debian-stretch-td-agent3.sh
       | sh
    
  4. Copie o comando na janela do shell na VM.

    O pacote td-agent, contendo a distribuição do Fluentd, é instalado na VM com esse comando.

  5. Instale o plug-in Fluentd-to-BigQuery:

    sudo /usr/sbin/td-agent-gem install fluent-plugin-bigquery
    

Como criar um conjunto de dados e uma tabela do BigQuery como um destino de registros

O Fluentd trabalha com o uso de plug-ins de entrada para coletar registros gerados por outros aplicativos e serviços. Ele analisa esses dados em registros JSON estruturados, que são encaminhados para qualquer um dos plug-ins de saída configurados.

O analisador de registros de acesso do Fluentd NGINX lê os arquivos NGINX access.log. Na lista a seguir, você encontra um registro com campos e valores de exemplo.

time: 1362020400
record:
{
  "remote"              : "127.0.0.1",
  "host"                : "192.168.0.1",
  "user"                : "-",
  "method"              : "GET",
  "path"                : "/",
  "code"                : "200",
  "size"                : "777",
  "referer"             : "-",
  "agent"               : "Opera/12.0",
  "http_x_forwarded_for": "-"
}

Quando você cria uma tabela de destino de registro no BigQuery, a correspondência dos nomes das colunas e dos nomes dos campos no registro precisa ser exata. No procedimento seguinte, certifique-se de usar os nomes que são sugeridos, para que os nomes das colunas da tabela estejam corretos.

  1. Abra a IU da Web do BigQuery:

    Acessar a IU da Web do BigQuery

  2. No painel de navegação, em Recursos, clique no nome do seu projeto.

  3. No painel de detalhes, abaixo do "Editor de consultas", clique em Criar conjunto de dados.

  4. Em Código do conjunto de dados, insira fluentd.

  5. Em Local dos dados, selecione o local multirregional (USA ou Europa) em que você criou a instância do NGINX.

  6. Clique em Criar conjunto de dados.

  7. No painel de navegação, em Recursos, clique no conjunto de dados do fluentd.

  8. No painel de detalhes, abaixo do "Editor de consultas", clique em Criar tabela.

  9. No nome da tabela, insira nginx_access.

  10. Selecione a opção Editar como texto.

  11. Copie a seguinte definição de coluna JSON na caixa de texto.

    [  { "type": "TIMESTAMP", "name": "time" },
       { "type": "STRING",    "name": "remote" },
       { "type": "STRING",    "name": "host" },
       { "type": "STRING",    "name": "user" },
       { "type": "STRING",    "name": "method" },
       { "type": "STRING",    "name": "path" },
       { "type": "STRING",    "name": "code" },
       { "type": "INTEGER",   "name": "size" },
       { "type": "STRING",    "name": "referer" },
       { "type": "STRING",    "name": "agent" },
       { "type": "STRING",    "name": "http_x_forwarded_for" } ]
    

    Observe que os nomes das colunas correspondem exatamente aos nomes dos campos no registro do Fluentd. O valor da coluna time é adicionado ao registro por meio da conversão do registro do carimbo de data/hora em uma string de carimbo de data/hora compatível com o BigQuery.

  12. Na lista Particionamento, selecione Partição por campo: tempo.

    As tabelas particionadas dividem tabelas grandes em segmentos menores para melhorar o desempenho da consulta e controlar os custos por meio da redução da quantidade de dados que é lida em uma consulta. Para saber mais informações, consulte Introdução às tabelas particionadas, na documentação do BigQuery.

  13. Clique em Criar tabela, na parte inferior.

    A tabela do BigQuery chamada fluentd.nginx_access agora está disponível para receber registros

  14. Para visualizar os detalhes da tabela, em Recursos > Detalhes, clique no nome da tabela.

    Os detalhes permitem que você veja informações, como a quantidade de linhas da tabela e quanto armazenamento a tabela usa.

Como configurar a coleta de registros e encaminhá-la ao BigQuery

As fontes de onde os dados de registro são coletados, as saídas dos registros coletados e quaisquer filtros são definidos pelo arquivo de configuração /etc/td-agent/td-agent.conf do Fluentd. Esse arquivo também permite a aplicação de tags aos registros coletados para definição de como eles são processados e para qual plug-in de saída eles devem ser enviados.

No procedimento a seguir, você configura o Fluentd para fazer o seguinte:

Para configurar a coleta e o encaminhamento de registros:

  1. Use o SSH para se conectar à VM em que o NGINX está instalado.
  2. Na janela do shell, abra um editor de texto como usuário raiz, por exemplo, abra o Vim ou o Nano e edite o arquivo de configuração do agente Fluentd /etc/td-agent/td-agent.conf. Por exemplo, use o seguinte comando para abrir o arquivo no Vim:

    sudo vim /etc/td-agent/td-agent.conf
    
  3. Na parte inferior do arquivo, anexe as seguintes linhas para configurar o plug-in de entrada tail para ler os registros do NGINX, analisá-los com o analisador NGINX e identificá-los com nginx.access:

    <source>
      @type tail
      @id input_tail
      <parse>
        @type nginx
      </parse>
      path /var/log/nginx/access.log
      pos_file /var/log/td-agent/httpd-access.log.pos
      tag nginx.access
    </source>
    
  4. Anexe as seguintes linhas para configurar o plug-in de saída do BigQuery. Substitua [MY_PROJECT_NAME] pelo nome do projeto do GCP.

    <match nginx.access>
      @type bigquery_insert
    
      # Authenticate with BigQuery using the VM's service account.
      auth_method compute_engine
      project [MY_PROJECT_NAME]
      dataset fluentd
      table nginx_access
      fetch_schema true
    
      <inject>
        # Convert fluentd timestamp into TIMESTAMP string
        time_key time
        time_type string
        time_format %Y-%m-%dT%H:%M:%S.%NZ
      </inject>
    </match>
    

    Isso configura o Fluentd para fazer o seguinte:

    • Para cada entrada de registro com a tag nginx.access, o Fluentd deve usar o plug-in bigquery_insert para gravar o registro na tabela do BigQuery.
    • A autenticação é efetuada usando a conta de serviço da VM.
    • O carimbo de data e hora original é adicionado ao registro como uma string, formatada de maneira que o BigQuery possa convertê-la em um carimbo de data e hora.
  5. Salve o arquivo e saia do editor.

  6. Reinicie o agente do Fluentd para aplicar a nova configuração.

    sudo systemctl restart td-agent
    

Para saber mais informações sobre esses parâmetros do arquivo de configuração, incluindo métodos alternativos para autenticação, consulte o site do plug-in do Fluentd para BigQuery e a documentação do plug-in do Fluentd.

Como visualizar registros no BigQuery

Agora que você configurou o Fluentd, é possível gerar alguns dados de registro do NGINX e visualizá-los usando o BigQuery.

  1. No Console do GCP, acesse a página "Instâncias de VM" do Compute Engine:

    Acessar a página Instâncias de VM

  2. Copie o endereço IP externo da instância da VM nginx-vm.

  3. Em uma guia separada do navegador, cole o endereço IP na caixa de endereço.

    A página padrão Bem-vindo ao nginx! é exibida.

  4. No Console do GCP, acesse a página do BigQuery.

  5. Copie a seguinte consulta no painel Editor de consultas e clique em Executar:

    SELECT * FROM `fluentd.nginx_access`
    

    Você vê uma linha no painel Resultados da Consulta que mostra o registro do acesso do seu navegador. Uma vez que sua VM pode ser acessada pela Internet, talvez você também veja linhas de registros de acesso efetuados em outros hosts remotos.

Como simular a carga e calcular estatísticas dos registros

Nesta seção, você executa cargas de amostra e exibe as métricas para essas cargas usando o BigQuery. A execução dessas etapas mostra que o BigQuery pode ser usado não apenas para ler os registros, mas também para analisá-los.

  1. No Console do GCP, inicie o Cloud Shell.
  2. Instale a ferramenta de benchmarking do servidor da Web ApacheBench ab e as ferramentas relacionadas:

     sudo apt install -y apache2-utils
    
  3. No Cloud Shell, gere uma carga de teste para executar no servidor NGINX. Substitua [IP_ADDRESS] pelo endereço IP da sua VM.

    ab -t 20 -c 1 http://[IP_ADDRESS]/
    

    Esse comando usa a ferramenta ApacheBench para gerar 20 segundos de carga no servidor NGINX.

  4. No Console do GCP, acesse a página do BigQuery:

    Acessar a página do BigQuery

  5. Receba uma lista de solicitações do ApacheBench usando a seguinte consulta no painel Editor de consultas:

    SELECT * FROM `fluentd.nginx_access` limit 100
    
  6. Execute o seguinte comando SQL para calcular o número de solicitações para cada código de resposta e cada segundo:

    SELECT
      time_sec, code, COUNT(*) as count
    FROM (
      SELECT
        TIMESTAMP_TRUNC(time, SECOND)AS time_sec, code
      FROM
        `fluentd.nginx_access`)
    GROUP BY
      time_sec, code
    ORDER BY
      time_sec DESC
    

    Os valores para cada segundo devem ser aproximadamente iguais à linha Solicitações por segundo, exibida na saída do ApacheBench que você viu anteriormente.

Opcional: como usar o carregamento em lote de grande volume de registros

Como já foi mencionado, as inserções de streaming do BigQuery (conforme usadas neste tutorial) disponibilizam os dados para consulta em alguns segundos. Há uma pequena taxa para esse método e são aplicados limites ao tamanho e à frequência das inserções.

Para volumes de registros mais altos, convém usar o carregamento em lote do BigQuery. Como o nome sugere, isso carrega os dados usando um job em lote de prioridade mais baixa. Com o carregamento em lote, a carga e disponibilização dos dados leva mais tempo do que com as inserções de streaming. No entanto, não há cobrança pelo carregamento em lote.

Assim como ocorre com as inserções de streaming, há limites para a frequência do uso de jobs de carregamento em lote e, o mais importante: 1.000 jobs de carregamento por tabela por dia e 50.000 jobs de carregamento por projeto por dia.

Para implementar o carregamento em lote, use o plug-in Fluentd bigquery_load. Esse plug-in usa um buffer do Fluentd para coletar um conjunto de registros em arquivos, até um limite especificado de tempo ou tamanho, antes de enviá-los como um lote para o BigQuery.

Para usar o carregamento em lote, faça o seguinte:

  1. Edite o arquivo de configuração do Fluentd /etc/td-agent/td-agent.conf como um usuário raiz.
  2. Substitua a configuração do plug-in de saída do BigQuery que você especificou anteriormente pelas linhas a seguir. Substitua [MY_PROJECT_NAME] pelo nome do projeto do GCP.

    <match nginx.access>
      @type bigquery_load
    
      <buffer>
        @type file
        path /var/log/bigquery_nginx_access.*.buffer
        flush_at_shutdown true
        timekey_use_utc
        total_limit_size 1g
        flush_interval 3600
      </buffer>
    
      # Authenticate with BigQuery using the VM's service account.
      auth_method compute_engine
      project [MY_PROJECT_NAME]
      dataset fluentd
      table nginx_access
      fetch_schema true
    
      <inject>
        # Convert fluentd timestamp into TIMESTAMP string
        time_key time
        time_type string
        time_format %Y-%m-%dT%H:%M:%S.%NZ
      </inject>
    </match>
    

    Essa configuração especifica que o plug-in de saída bigquery_load deve ser usado em vez do plug-in bigquery_insert.

    A seção buffer especifica que os dados de registro sejam armazenados em buffer na VM, até que a coleta de registros atinja 1 GB ou até que tenha se passado uma hora. Os dados em buffer são carregados no BigQuery. Para saber mais informações sobre os parâmetros de configuração, consulte a documentação do plug-in.

Resolver problemas

Se você suspeitar, a qualquer momento, que o agente não está coletando ou entregando registros, verifique o estado do agente executando o seguinte comando na janela do shell da VM do Fluentd:

sudo systemctl status td-agent

A saída mostra o estado ativo do serviço e as últimas linhas de registro do serviço:

Active: active (running) since [DATE]

Se o agente não iniciar, a causa mais provável é um erro no arquivo de configuração do Fluentd. Isso é relatado no arquivo de registro do Fluentd, que pode ser visualizado na janela do shell da VM, com o seguinte comando:

sudo less /var/log/td-agent/td-agent.log

Por exemplo, a seguinte saída mostra um erro quando o nome de um plug-in não está correto:

[info]: parsing config file is succeeded path="/etc/td-agent/td-agent.conf"
[error]: config error file="/etc/td-agent/td-agent.conf" error_class=Fluent::ConfigError error="Unknown output plugin 'bad_plugin'. Run 'gem search -rd fluent-plugin' to find plugins"

Limpar

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

  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…