// Tutorial //

Como Instalar Elasticsearch, Logstash e Kibana (Elastic Stack) no Ubuntu 18.04

Published on March 1, 2019
Default avatar
Português
Como Instalar Elasticsearch, Logstash e Kibana (Elastic Stack) no Ubuntu 18.04

O autor selecionou o Internet Archive para receber uma doação como parte do programa Write for DOnations

Introdução

O Elastic Stack — anteriormente conhecido como ELK Stack — é uma coleção de software open-source produzido pela Elastic que lhe permite pesquisar, analisar e visualizar logs gerados a partir de qualquer fonte, em qualquer formato, em uma prática conhecida como centralização de logs. A centralização de logs pode ser muito útil ao tentar identificar problemas com seus servidores ou aplicativos, pois permite que você pesquise todos os seus logs em um único local. Ela é útil também porque permite identificar problemas que envolvem vários servidores, correlacionando seus logs durante um período de tempo específico.

O Elastic Stack possui quatro componentes principais:

  • Elasticsearch: um mecanismo de pesquisa RESTful distribuído que armazena todos os dados coletados.

  • Logstash: o componente de processamento de dados do Elastic Stack que envia dados de entrada para o Elasticsearch.

  • Kibana: uma interface web para a pesquisa e a visualização de logs.

  • Beats: carregadores de dados leves e de propósito único que podem enviar dados de centenas ou milhares de máquinas para o Logstash ou para o Elasticsearch.

Neste tutorial você irá instalar o Elastic Stack em um servidor Ubuntu 18.04. Você irá aprender como instalar todos os componentes do Elastic Stack — incluindo o Filebeat, um Beat usado para encaminhar e centralizar logs e arquivos — e configurá-los para reunir e visualizar os logs do sistema. Além disso, como o Kibana normalmente está disponível apenas no localhost, usaremos o Nginx para fazer proxy dele, de modo que ele seja acessível em um navegador web. Instalaremos todos esses componentes em um único servidor, o qual nos referiremos como nosso servidor Elastic Stack.

Nota: Ao instalar o Elastic Stack, você deve usar a mesma versão em toda a pilha ou stack. Neste tutorial vamos instalar as versões mais recentes de toda a stack, que são, no momento desta publicação, Elasticsearch 6.4.3, Kibana 6.4.3, Logstash 6.4.3 e Filebeat 6.4.3.

Pré-requisitos

Para completar este tutorial, você irá precisar do seguinte:

  • Um servidor Ubuntu configurado seguindo nosso Guia de Configuração Inicial de servidor com Ubuntu 18.04, incluindo um usuário não-root com privilégios sudo e um firewall configurado com ufw. A quantidade de CPU, RAM e armazenamento que o seu servidor Elastic Stack exigirá depende do volume de logs que você pretende reunir. Para este tutorial, usaremos um VPS com as seguintes especificações para o nosso servidor Elastic Stack:

    • SO: Ubuntu 18.04
    • RAM: 4GB
    • CPU: 2
  • Java 8 — que é exigido pelo Elasticsearch e pelo Logstash — instalado em seu servidor. Observe que o Java 9 não é suportado. Para istalar isso, siga a seção “Installing the Oracle JDK” do nosso guia sobre como instalar o Java 8 no Ubuntu 18.04.

  • Nginx instalado em seu servidor, que vamos configurar mais tarde neste guia como um proxy reverso para o Kibana. Siga nosso guia sobre Como Instalar o Nginx no Ubuntu 18.04 para configurar isso.

Além disso, como o Elastic Stack é usado para acessar informações valiosas sobre seu servidor, as quais você não deseja que usuários não autorizados acessem, é importante manter seu servidor seguro instalando um certificado TLS/SSL. Isso é opcional mas é fortemente recomendado.

No entanto, como você acabará fazendo alterações no bloco do servidor Nginx ao longo deste guia, provavelmente faria mais sentido para você concluir o guia Como Proteger o Nginx com o Let’s Encrypt no Ubuntu 18.04 no final do segundo passo deste tutorial. Com isso em mente, se você planeja configurar o Let’s Encrypt no seu servidor, você precisará do seguinte, antes de fazer isso:

  • Um domínio completamente qualificado (FQDN). Este tutorial irá utilizar example.com durante todo o processo. Você pode comprar um nome de domínio em Namecheap, obter um gratuitamente em Freenom, ou utilizar o registrador de domínio de sua escolha.

  • Ambos os registros DNS a seguir configurados para o seu servidor. Você pode seguir esta introdução ao DigitalOcean DNS para detalhes sobre como adicioná-los.

    • Um registro A com example.com apontando para o endereço IP público do seu servidor.
    • Um registro A com www.example.com apontando para o endereço IP público do seu servidor.

Passo 1 — Instalando e Configurando o Elasticsearch

Os componentes do Elastic Stack não estão disponíveis nos repositórios de pacotes padrão do Ubuntu. Eles podem, no entanto, ser instalados com o APT após adicionar a lista de origens de pacotes da Elastic.

Todos os pacotes do Elastic Stack são assinados com a chave de assinatura do Elasticsearch para proteger seu sistema contra falsificação de pacotes. Os pacotes que foram autenticados usando a chave serão considerados confiáveis pelo seu gerenciador de pacotes. Nesta etapa, você importará a chave GPG pública do Elasticsearch e adicionará a lista de origens de pacotes da Elastic para instalar o Elasticsearch.

Para começar, execute o seguinte comando para importar a chave GPG pública do Elasticsearch para o APT:

  1. wget -qO - https://artifacts.elastic.co/GPG-KEY-elasticsearch | sudo apt-key add -

Em seguida, adicione a lista de origens da Elastic ao diretório sources.list.d, onde o APT irá procurar por novas origens:

  1. echo "deb https://artifacts.elastic.co/packages/6.x/apt stable main" | sudo tee -a /etc/apt/sources.list.d/elastic-6.x.list

Em seguida, atualize suas listas de pacotes para que o APT leia a nova origem da Elastic:

  1. sudo apt update

Em seguida, instale o Elasticsearch com este comando:

  1. sudo apt install elasticsearch

Quando o Elasticsearch terminar a instalação, use seu editor de texto preferido para editar o arquivo de configuração principal do Elasticsearch, elasticsearch.yml. Aqui, usaremos o nano:

  1. sudo nano /etc/elasticsearch/elasticsearch.yml

Nota: O arquivo de configuração do Elasticsearch está no formato YAML, o que significa que a identação é muito importante! Certifique-se de não adicionar espaços extras ao editar esse arquivo.

O Elasticsearch escuta o tráfego vindo de qualquer lugar na porta 9200. Você vai querer restringir o acesso externo à sua instância do Elasticsearch para impedir que pessoas de fora leiam seus dados ou desliguem o cluster do Elasticsearch por meio da API REST. Encontre a linha que especifica network.host, descomente-a e substitua seu valor por localhost para que fique assim:

/etc/elasticsearch/elasticsearch.yml
. . .
network.host: localhost
. . .

Salve e feche o elasticsearch.yml pressionando CTRL+X, seguido de Y e depoisENTER se você estiver usando o nano. Em seguida, inicie o serviço Elasticsearch com o systemctl:

  1. sudo systemctl start elasticsearch

Depois, execute o seguinte comando para permitir que o Elasticsearch seja iniciado toda vez que o servidor for inicializado:

  1. sudo systemctl enable elasticsearch

Você pode testar se o serviço do Elasticsearch está sendo executado enviando uma solicitação HTTP:

  1. curl -X GET "localhost:9200"

Você verá uma resposta mostrando algumas informações básicas sobre o seu nó local, semelhante a esta:

Output
{ "name" : "ZlJ0k2h", "cluster_name" : "elasticsearch", "cluster_uuid" : "beJf9oPSTbecP7_i8pRVCw", "version" : { "number" : "6.4.2", "build_flavor" : "default", "build_type" : "deb", "build_hash" : "04711c2", "build_date" : "2018-09-26T13:34:09.098244Z", "build_snapshot" : false, "lucene_version" : "7.4.0", "minimum_wire_compatibility_version" : "5.6.0", "minimum_index_compatibility_version" : "5.0.0" }, "tagline" : "You Know, for Search" }

Agora que o Elasticsearch está instalado e funcionando, vamos instalar o Kibana, o próximo componente do Elastic Stack.

Passo 2 — Instalando e Configurando o Painel do Kibana

De acordo com a documentação oficial, você deve instalar o Kibana somente após instalar o Elasticsearch. A instalação nesta ordem garante que os componentes dos quais cada produto depende estão corretamente posicionados.

Como você já adicionou a origem de pacotes do Elastic no passo anterior, você pode simplesmente instalar os componentes restantes do Elastic Stack usando o apt:

  1. sudo apt install kibana

Em seguida, ative e inicie o serviço Kibana:

  1. sudo systemctl enable kibana
  2. sudo systemctl start kibana

Como o Kibana está configurado para escutar somente no localhost, devemos configurar um proxy reverso para permitir acesso externo a ele. Utilizaremos o Nginx para esse propósito, que já deve estar instalado no seu servidor.

Primeiro, use o comando openssl para criar um usuário administrativo do Kibana que será usado para acessar a interface web do mesmo. Como exemplo, nomearemos essa conta como kibanaadmin, mas para garantir maior segurança, recomendamos que você escolha um nome que não seja óbvio para seu usuário e que seja difícil de adivinhar.

O comando a seguir criará o usuário e a senha do usuário administrativo do Kibana e os armazenará no arquivo htpasswd.users. Você irá configurar o Nginx para requerer este nome de usuário e senha e ler este arquivo momentaneamente:

  1. echo "kibanaadmin:`openssl passwd -apr1`" | sudo tee -a /etc/nginx/htpasswd.users

Digite e confirme uma senha no prompt. Lembre-se ou anote este login, pois você precisará dele para acessar a interface web do Kibana.

Em seguida, criaremos um arquivo de bloco do servidor Nginx. Como exemplo, vamos nos referir a este arquivo como example.com, embora você possa achar útil dar um nome mais descritivo ao seu. Por exemplo, se você tiver um FQDN e registros DNS configurados para este servidor, poderá nomear esse arquivo após seu FQDN:

  1. sudo nano /etc/nginx/sites-available/example.com

Adicione o seguinte bloco de código ao arquivo, certificando-se de atualizar example.com para corresponder ao FQDN do seu servidor ou ao seu endereço IP público. Este código configura o Nginx para direcionar o tráfego HTTP do seu servidor para o aplicativo Kibana, que está escutando em localhost:5601. Além disso, configura o Nginx para ler o arquivo htpasswd.users e requerer autenticação básica.

Observe que, se você seguiu o o tutorial de pré-requisitos do Nginx até o final, você já deve ter criado esse arquivo e preenchido com algum conteúdo. Nesse caso, exclua todo o conteúdo existente no arquivo antes de adicionar o seguinte:

/etc/nginx/sites-available/example.com

server {
    listen 80;

    server_name example.com;

    auth_basic "Restricted Access";
    auth_basic_user_file /etc/nginx/htpasswd.users;

    location / {
        proxy_pass http://localhost:5601;
        proxy_http_version 1.1;
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection 'upgrade';
        proxy_set_header Host $host;
        proxy_cache_bypass $http_upgrade;
    }
}

Quando terminar, salve e feche o arquivo.

Em seguida, ative a nova configuração criando um link simbólico para o diretório sites-enabled. Se você já criou um arquivo de bloco do servidor com o mesmo nome no pré-requisito do Nginx, não será necessário executar este comando:

  1. sudo ln -s /etc/nginx/sites-available/example.com /etc/nginx/sites-enabled/example.com

Em seguida, verifique a configuração para erros de sintaxe:

  1. sudo nginx -t

Se algum erro for relatado em sua saída, volte e verifique se o conteúdo que você colocou no seu arquivo de configuração foi adicionado corretamente. Uma vez que você veja syntax is ok na saída, vá em frente e reinicie o serviço Nginx:

  1. sudo systemctl restart nginx

Se você seguiu o guia de configuração inicial do servidor, você deverá ter um firewall UFW ativado. Para permitir conexões ao Nginx, podemos ajustar as regras digitando:

  1. sudo ufw allow 'Nginx Full'

Nota: Se você seguiu o tutorial de pré-requisitos do Nginx, você pode ter criado uma regra UFW permitindo o perfil Nginx HTTP através do firewall. Como o perfil Nginx Full permite o tráfego HTTP e HTTPS através do firewall, você pode excluir com segurança a regra criada no tutorial de pré-requisitos. Faça isso com o seguinte comando:

  1. sudo ufw delete allow 'Nginx HTTP'

O Kibana agora pode ser acessado pelo seu FQDN ou pelo endereço IP público do seu servidor Elastic Stack. Você pode verificar a página de status do servidor Kibana, navegando até o seguinte endereço e digitando suas credenciais de login quando solicitado:

  1. http://ip_do_seu_servidor/status

Essa página de status exibe informações sobre o uso de recursos do servidor e lista os plug-ins instalados.

Note: Conforme mencionado na seção de Pré-requisitos, é recomendável ativar o SSL/TLS em seu servidor. Você pode seguir este tutorial agora para obter um certificado SSL grátis para o Nginx no Ubuntu 18.04. Depois de obter seus certificados SSL/TLS, você pode voltar e concluir este tutorial.

Agora que o painel do Kibana está configurado, vamos instalar o próximo componente: Logstash.

Passo 3 — Instalando e Configurando o Logstash

Embora seja possível que o Beats envie dados diretamente para o banco de dados do Elasticsearch, recomendamos o uso do Logstash para processar os dados. Isso permitirá coletar dados de diferentes origens, transformá-los em um formato comum e exportá-los para outro banco de dados.

Instale o Logstash com este comando:

  1. sudo apt install logstash

Depois de instalar o Logstash, você pode continuar a configurá-lo. Os arquivos de configuração do Logstash são escritos no formato JSON e residem no diretório /etc/logstash/conf.d. Ao configurá-lo, é útil pensar no Logstash como um pipeline que coleta dados em uma extremidade, os processa de uma forma ou de outra e os envia para o destino (nesse caso, o destino é o Elasticsearch). Um pipeline do Logstash tem dois elementos obrigatórios, input e output, e um elemento opcional, filter. Os plugins de input ou de entrada consomem dados de uma fonte, os plug-ins filter ou de filtro processam os dados, e os plugins de output ou de saída gravam os dados em um destino.

Crie um arquivo de configuração chamado 02-beats-input.conf onde você irá configurar sua entrada para o Filebeat:

  1. sudo nano /etc/logstash/conf.d/02-beats-input.conf

Insira a seguinte configuração de input. Isto especifica uma entrada beats que irá escutar na porta TCP 5044.

/etc/logstash/conf.d/02-beats-input.conf

input {
  beats {
    port => 5044
  }
}

Salve e feche o arquivo. Em seguida, crie um arquivo de configuração chamado 10-syslog-filter.conf, onde adicionaremos um filtro para logs do sistema, também conhecido como syslogs:

  1. sudo nano /etc/logstash/conf.d/10-syslog-filter.conf

Insira a seguinte configuração do filtro syslog. Este exemplo de configuração de logs do sistema foi retirado da documentação oficial do Elastic. Esse filtro é usado para analisar os logs de entrada do sistema para torná-los estruturados e utilizáveis pelos painéis predefinidos do Kibana:

/etc/logstash/conf.d/10-syslog-filter.conf

filter {
  if [fileset][module] == "system" {
    if [fileset][name] == "auth" {
      grok {
        match => { "message" => ["%{SYSLOGTIMESTAMP:[system][auth][timestamp]} %{SYSLOGHOST:[system][auth][hostname]} sshd(?:\[%{POSINT:[system][auth][pid]}\])?: %{DATA:[system][auth][ssh][event]} %{DATA:[system][auth][ssh][method]} for (invalid user )?%{DATA:[system][auth][user]} from %{IPORHOST:[system][auth][ssh][ip]} port %{NUMBER:[system][auth][ssh][port]} ssh2(: %{GREEDYDATA:[system][auth][ssh][signature]})?",
                  "%{SYSLOGTIMESTAMP:[system][auth][timestamp]} %{SYSLOGHOST:[system][auth][hostname]} sshd(?:\[%{POSINT:[system][auth][pid]}\])?: %{DATA:[system][auth][ssh][event]} user %{DATA:[system][auth][user]} from %{IPORHOST:[system][auth][ssh][ip]}",
                  "%{SYSLOGTIMESTAMP:[system][auth][timestamp]} %{SYSLOGHOST:[system][auth][hostname]} sshd(?:\[%{POSINT:[system][auth][pid]}\])?: Did not receive identification string from %{IPORHOST:[system][auth][ssh][dropped_ip]}",
                  "%{SYSLOGTIMESTAMP:[system][auth][timestamp]} %{SYSLOGHOST:[system][auth][hostname]} sudo(?:\[%{POSINT:[system][auth][pid]}\])?: \s*%{DATA:[system][auth][user]} :( %{DATA:[system][auth][sudo][error]} ;)? TTY=%{DATA:[system][auth][sudo][tty]} ; PWD=%{DATA:[system][auth][sudo][pwd]} ; USER=%{DATA:[system][auth][sudo][user]} ; COMMAND=%{GREEDYDATA:[system][auth][sudo][command]}",
                  "%{SYSLOGTIMESTAMP:[system][auth][timestamp]} %{SYSLOGHOST:[system][auth][hostname]} groupadd(?:\[%{POSINT:[system][auth][pid]}\])?: new group: name=%{DATA:system.auth.groupadd.name}, GID=%{NUMBER:system.auth.groupadd.gid}",
                  "%{SYSLOGTIMESTAMP:[system][auth][timestamp]} %{SYSLOGHOST:[system][auth][hostname]} useradd(?:\[%{POSINT:[system][auth][pid]}\])?: new user: name=%{DATA:[system][auth][user][add][name]}, UID=%{NUMBER:[system][auth][user][add][uid]}, GID=%{NUMBER:[system][auth][user][add][gid]}, home=%{DATA:[system][auth][user][add][home]}, shell=%{DATA:[system][auth][user][add][shell]}$",
                  "%{SYSLOGTIMESTAMP:[system][auth][timestamp]} %{SYSLOGHOST:[system][auth][hostname]} %{DATA:[system][auth][program]}(?:\[%{POSINT:[system][auth][pid]}\])?: %{GREEDYMULTILINE:[system][auth][message]}"] }
        pattern_definitions => {
          "GREEDYMULTILINE"=> "(.|\n)*"
        }
        remove_field => "message"
      }
      date {
        match => [ "[system][auth][timestamp]", "MMM  d HH:mm:ss", "MMM dd HH:mm:ss" ]
      }
      geoip {
        source => "[system][auth][ssh][ip]"
        target => "[system][auth][ssh][geoip]"
      }
    }
    else if [fileset][name] == "syslog" {
      grok {
        match => { "message" => ["%{SYSLOGTIMESTAMP:[system][syslog][timestamp]} %{SYSLOGHOST:[system][syslog][hostname]} %{DATA:[system][syslog][program]}(?:\[%{POSINT:[system][syslog][pid]}\])?: %{GREEDYMULTILINE:[system][syslog][message]}"] }
        pattern_definitions => { "GREEDYMULTILINE" => "(.|\n)*" }
        remove_field => "message"
      }
      date {
        match => [ "[system][syslog][timestamp]", "MMM  d HH:mm:ss", "MMM dd HH:mm:ss" ]
      }
    }
  }
}

Salve e feche o arquivo quando terminar.

Por fim, crie um arquivo de configuração chamado 30-elasticsearch-output.conf:

  1. sudo nano /etc/logstash/conf.d/30-elasticsearch-output.conf

Insira a seguinte configuração para output. Essencialmente, esta saída configura o Logstash para armazenar os dados do Beats no Elasticsearch, que está sendo executado em localhost:9200, em um índice ou index nomeado após o uso do Beat. O Beat usado neste tutorial é o Filebeat:

/etc/logstash/conf.d/30-elasticsearch-output.conf

output {
  elasticsearch {
    hosts => ["localhost:9200"]
    manage_template => false
    index => "%{[@metadata][beat]}-%{[@metadata][version]}-%{+YYYY.MM.dd}"
  }
}

Salve e feche o arquivo.

Se você quiser adicionar filtros para outros aplicativos que usam a entrada Filebeat, certifique-se de nomear os arquivos de forma que eles sejam classificados entre a configuração de entrada e a de saída, o que significa que os nomes dos arquivos devem começar com um número de dois dígitos entre 02 e 30.

Teste sua configuração do Logstash com este comando:

  1. sudo -u logstash /usr/share/logstash/bin/logstash --path.settings /etc/logstash -t

Se não houver erros de sintaxe, sua saída exibirá Configuration OK após alguns segundos. Se você não vir isso na sua saída, verifique se há erros que apareçam na sua saída e atualize sua configuração para corrigi-los.

Se seu teste de configuração for bem-sucedido, inicie e ative o Logstash para colocar as mudanças de configuração em vigor:

  1. sudo systemctl start logstash
  2. sudo systemctl enable logstash

Agora que o Logstash está sendo executado corretamente e está totalmente configurado, vamos instalar o Filebeat.

Passo 4 — Instalando e Configurando o Filebeat

O Elastic Stack usa vários carregadores de dados leves chamados Beats para coletar dados de várias fontes e transportá-los para o Logstash ou para o Elasticsearch. Aqui estão os Beats que estão atualmente disponíveis na Elastic:

  • Filebeat: coleta e envia arquivos de log.

  • Metricbeat: coleta métricas de seus sistemas e serviços.

  • Packetbeat: coleta e analisa dados da rede.

  • Winlogbeat: coleta logs de eventos do Windows.

  • Auditbeat: coleta dados da estrutura de auditoria do Linux e monitora a integridade dos arquivos.

  • Heartbeat: monitora serviços para verificar sua disponibilidade com sondagem ativa.

Neste tutorial, usaremos o Filebeat para encaminhar logs locais para o nosso Elastic Stack.

Instale o Filebeat usando o apt:

  1. sudo apt install filebeat

Em seguida, configure o Filebeat para se conectar ao Logstash. Aqui, vamos modificar o arquivo de configuração de exemplo que vem com o Filebeat.

Abra o arquivo de configuração do Filebeat:

  1. sudo nano /etc/filebeat/filebeat.yml

Nota: Assim como no Elasticsearch, o arquivo de configuração do Filebeat está no formato YAML. Isso significa que a identação adequada é crucial, portanto, certifique-se de usar o mesmo número de espaços indicados nestas instruções.

O Filebeat suporta várias saídas, mas normalmente você só envia eventos diretamente para o Elasticsearch ou para o Logstash para processamento adicional. Neste tutorial, usaremos o Logstash para executar processamento adicional nos dados coletados pelo Filebeat. O Filebeat não precisará enviar nenhum dado diretamente para o Elasticsearch, então vamos desativar essa saída. Para fazer isso, encontre a seção output.elasticsearch e comente as seguintes linhas, precedendo-as com um #:

/etc/filebeat/filebeat.yml

...
#output.elasticsearch:
  # Array of hosts to connect to.
  #hosts: ["localhost:9200"]
...

Em seguida, configure a seção output.logstash. Descomente as linhas output.logstash: e hosts: ["localhost:5044"] removendo o #. Isto irá configurar o Filebeat para se conectar ao Logstash no seu servidor Elastic Stack na porta 5044, a porta para a qual especificamos uma entrada do Logstash anteriormente:

/etc/filebeat/filebeat.yml

output.logstash:
  # The Logstash hosts
  hosts: ["localhost:5044"]

Salve e feche o arquivo.

A funcionalidade do Filebeat pode ser estendida com os módulos do Filebeat. Neste tutorial vamos usar o módulo system, que coleta e analisa logs criados pelo serviço de logs do sistema em distribuições comuns do Linux.

Vamos habilitar isso:

  1. sudo filebeat modules enable system

Você pode ver uma lista de módulos ativados e desativados executando:

  1. sudo filebeat modules list

Você verá uma lista semelhante à seguinte:

Output
Enabled: system Disabled: apache2 auditd elasticsearch icinga iis kafka kibana logstash mongodb mysql nginx osquery postgresql redis traefik

Por padrão, o Filebeat é configurado para usar os caminhos padrão para os logs de syslog e de autorização. No caso deste tutorial, você não precisa alterar nada na configuração. Você pode ver os parâmetros do módulo no arquivo de configuração /etc/filebeat/modules.d/system.yml.

Em seguida, carregue o modelo de index do Elasticsearch. Um index do Elasticsearch é uma coleção de documentos que possuem características semelhantes. Os index são identificados com um nome, que é usado para se referir ao index ao executar várias operações dentro dele. O modelo de index será aplicado automaticamente quando um novo index for criado.

Para carregar o modelo, use o seguinte comando:

  1. sudo filebeat setup --template -E output.logstash.enabled=false -E 'output.elasticsearch.hosts=["localhost:9200"]'
Output
Loaded index template

O Filebeat vem com painéis de amostra do Kibana que lhe permitem visualizar dados do Filebeat no Kibana. Antes de poder usar os painéis, você precisa criar o padrão de index e carregar os painéis no Kibana.

À medida que os painéis são carregados, o Filebeat se conecta ao Elasticsearch para verificar as informações da versão. Para carregar painéis quando o Logstash está ativado, é necessário desativar a saída do Logstash e ativar a saída do Elasticsearch:

  1. sudo filebeat setup -e -E output.logstash.enabled=false -E output.elasticsearch.hosts=['localhost:9200'] -E setup.kibana.host=localhost:5601

Você verá uma saída que se parece com isto:

Output
2018-09-10T08:39:15.844Z INFO instance/beat.go:273 Setup Beat: filebeat; Version: 6.4.2 2018-09-10T08:39:15.845Z INFO elasticsearch/client.go:163 Elasticsearch url: http://localhost:9200 2018-09-10T08:39:15.845Z INFO pipeline/module.go:98 Beat name: elk 2018-09-10T08:39:15.845Z INFO elasticsearch/client.go:163 Elasticsearch url: http://localhost:9200 2018-09-10T08:39:15.849Z INFO elasticsearch/client.go:708 Connected to Elasticsearch version 6.4.2 2018-09-10T08:39:15.856Z INFO template/load.go:129 Template already exists and will not be overwritten. Loaded index template Loading dashboards (Kibana must be running and reachable) 2018-09-10T08:39:15.857Z INFO elasticsearch/client.go:163 Elasticsearch url: http://localhost:9200 2018-09-10T08:39:15.865Z INFO elasticsearch/client.go:708 Connected to Elasticsearch version 6.4.2 2018-09-10T08:39:15.865Z INFO kibana/client.go:113 Kibana url: http://localhost:5601 2018-09-10T08:39:45.357Z INFO instance/beat.go:659 Kibana dashboards successfully loaded. Loaded dashboards 2018-09-10T08:39:45.358Z INFO elasticsearch/client.go:163 Elasticsearch url: http://localhost:9200 2018-09-10T08:39:45.361Z INFO elasticsearch/client.go:708 Connected to Elasticsearch version 6.4.2 2018-09-10T08:39:45.361Z INFO kibana/client.go:113 Kibana url: http://localhost:5601 2018-09-10T08:39:45.455Z WARN fileset/modules.go:388 X-Pack Machine Learning is not enabled Loaded machine learning job configurations

Agora você pode iniciar e ativar o Filebeat:

  1. sudo systemctl start filebeat
  2. sudo systemctl enable filebeat

Se você configurou seu Elastic Stack corretamente, o Filebeat começará a enviar seus registros de log e autorização para o Logstash, que então carregará esses dados no Elasticsearch.

Para verificar se o Elasticsearch está realmente recebendo esses dados, consulte o index do Filebeat com este comando:

  1. curl -XGET 'http://localhost:9200/filebeat-*/_search?pretty'

Você verá uma saída semelhante a esta:

Output
... { "took" : 32, "timed_out" : false, "_shards" : { "total" : 3, "successful" : 3, "skipped" : 0, "failed" : 0 }, "hits" : { "total" : 1641, "max_score" : 1.0, "hits" : [ { "_index" : "filebeat-6.4.2-2018.10.10", "_type" : "doc", "_id" : "H_bZ62UBB4D0uxFRu_h3", "_score" : 1.0, "_source" : { "@version" : "1", "message" : "Oct 10 06:22:36 elk systemd[1]: Reached target Local File Systems (Pre).", "@timestamp" : "2018-10-10T08:43:56.969Z", "host" : { "name" : "elk" }, "source" : "/var/log/syslog", "input" : { "type" : "log" }, "tags" : [ "beats_input_codec_plain_applied" ], "offset" : 296, "prospector" : { "type" : "log" }, "beat" : { "version" : "6.4.2", "hostname" : "elk", "name" : "elk" } } }, ...

Se a sua saída mostrar 0 total hits, o Elasticsearch não está carregando nenhum registro sob o index que você pesquisou, e você precisará revisar sua configuração para verificar erros. Se você recebeu a saída esperada, continue para a próxima etapa, na qual veremos como navegar em alguns dos painéis do Kibana.

Passo 5 — Explorando os Painéis do Kibana

Vamos dar uma olhada no Kibana, a interface web que instalamos anteriormente.

Em um navegador web, vá para o FQDN ou endereço IP público do seu servidor Elastic Stack. Depois de inserir as credenciais de login que você definiu no Passo 2, você verá a página inicial do Kibana:

Clique no link Discover na barra de navegação à esquerda. Na página Discover, selecione o padrão de index predefinido filebeat-* para ver os dados do Filebeat. Por padrão, isso mostrará todos os dados do log nos últimos 15 minutos. Você verá um histograma com eventos de log, e algumas mensagens de log como abaixo:

Aqui, você pode pesquisar e navegar pelos seus logs e também personalizar seu painel. Neste ponto, porém, não haverá muita coisa porque você está apenas coletando syslogs do seu servidor Elastic Stack.

Use o painel esquerdo para navegar até a página Dashboard e pesquise pelos painéis do Filebeat System. Uma vez lá, você pode procurar os painéis de amostra que vêm com o módulo system do Filebeat.

Por exemplo, você pode visualizar estatísticas detalhadas com base em suas mensagens do syslog:

Você também pode ver quais usuários usaram o comando sudo e quando:

Kibana tem muitos outros recursos, como gráficos e filtragem, então sinta-se livre para explorar.

Conclusão

Neste tutorial, você aprendeu como instalar e configurar o Elastic Stack para coletar e analisar logs do sistema. Lembre-se de que você pode enviar praticamente qualquer tipo de log ou dados indexados para o Logstash usando o Beats, mas os dados se tornam ainda mais úteis se forem analisados e estruturados com um filtro Logstash, pois isso transforma os dados em um formato consistente que pode ser lido facilmente pelo Elasticsearch.

Por Justin Ellingwood e Vadym Kalsin

If you’ve enjoyed this tutorial and our broader community, consider checking out our DigitalOcean products which can also help you achieve your development goals.

Learn more here


About the authors
Default avatar
Developer and author at DigitalOcean.

Default avatar
Developer and author at DigitalOcean.

Default avatar
Manager, Developer Education

Technical Writer @ DigitalOcean


Default avatar
Developer and author at DigitalOcean.

Still looking for an answer?

Was this helpful?
Leave a comment

This textbox defaults to using Markdown to format your answer.

You can type !ref in this text area to quickly search our full set of tutorials, documentation & marketplace offerings and insert the link!