Instalar e configurar Elastic Stack (ELK) no CentOS 8

Instalei e configurei o Elastic Stack (Elasticsearch, Logstash, Kibana) em um servidor CentOS 8 e configurei Filebeat em clientes CentOS/Ubuntu para enviar logs ao Logstash. Este guia passo a passo cobre repositório, instalação, configurações essenciais, proxy Nginx com autenticação básica, módulos Filebeat, e testes finais no Kibana. Inclui checklists, playbook de implantação, e troubleshooting.

Resumo rápido dos componentes

• Elasticsearch: mecanismo de busca e armazenamento de documentos JSON; usa Apache Lucene. Definição: índice distribuído para pesquisa e análise em tempo real.
• Logstash: coletor e pipeline de logs; transforma e encaminha eventos para o Elasticsearch.
• Kibana: interface web para visualizar e gerenciar dados do Elasticsearch.
• Filebeat: agente leve para enviar arquivos de log ao Logstash ou diretamente ao Elasticsearch.

Importante: neste guia usamos a série 7.x dos pacotes Elastic (repositório oficial). Mantenha versões compatíveis entre Elasticsearch, Beats e Kibana.

Principais objetivos do tutorial

• Adicionar o repositório oficial Elastic no CentOS 8
• Instalar e configurar Elasticsearch
• Instalar e configurar Kibana
• Proteger o acesso ao Kibana com Nginx e autenticação básica
• Instalar e configurar Logstash com entrada Beats, filtro syslog (grok) e saída Elasticsearch
• Instalar e configurar Filebeat em clientes CentOS e Ubuntu para enviar logs ao Logstash
• Testar a pilha e criar o padrão de índice Filebeat no Kibana

Pré-requisitos

• elk-master: CentOS 8 (64 bits), recomendado ≥4 GiB RAM para ambiente de teste
• client01: CentOS 8 (64 bits), ≥1 GiB RAM
• client02: Ubuntu 18.04 (64 bits), ≥1 GiB RAM
• Acesso root ou sudo em todas as máquinas
• Comunicação de rede entre clientes e servidor (porta 5044/TCP aberta para Logstash)

Índice

• Passo 1 — Adicionar repositório Elastic
• Passo 2 — Instalar e configurar Elasticsearch
• Passo 3 — Instalar e configurar Kibana
• Passo 4 — Configurar Nginx como proxy reverso para Kibana
• Passo 5 — Instalar e configurar Logstash
• Passo 6 — Instalar e configurar Filebeat nos clientes
• Passo 7 — Testes e verificação
• Segurança e endurecimento
• Checklist de implantação por função
• Playbook curto para implantação
• Solução de problemas comum
• Critérios de aceitação e testes
• Referências

Passo 1 — Adicionar repositório Elastic

Primeiro, importe a chave GPG oficial e adicione o repositório Elastic ao CentOS 8. O repositório oficial fornece pacotes para Elasticsearch, Logstash, Kibana e Beats.

Importe a chave:

rpm --import https://artifacts.elastic.co/GPG-KEY-elasticsearch

Crie o arquivo do repositório em /etc/yum.repos.d/elasticsearch.repo:

cd /etc/yum.repos.d/
vim elasticsearch.repo

Cole o conteúdo abaixo:

[elasticsearch-7.x]
name=Elasticsearch repository for 7.x packages
baseurl=https://artifacts.elastic.co/packages/7.x/yum
gpgcheck=1
gpgkey=https://artifacts.elastic.co/GPG-KEY-elasticsearch
enabled=1
autorefresh=1
type=rpm-md

Salve e verifique a lista de repositórios:

dnf repolist

Você deverá ver o repositório elasticsearch-7.x listado.

Observação: use o repositório compatível com sua versão desejada (aqui usamos 7.x como no exemplo original).

Passo 2 — Instalar e configurar Elasticsearch

Instale o pacote:

sudo dnf install elasticsearch -y

Edite /etc/elasticsearch/elasticsearch.yml e ajuste as seguintes linhas básicas:

cd /etc/elasticsearch/
vim elasticsearch.yml

Descomente e atualize:

network.host: 127.0.0.1
http.port: 9200

Dica: para ambientes de produção, defina network.host para o IP da interface de cluster e configure discovery.seed_hosts e cluster.initial_master_nodes conforme a topologia.

Ajuste a JVM conforme a memória disponível (arquivo jvm.options):

vim jvm.options

Altere Xms/Xmx para metade da memória disponível até o limite recomendado para o container/hypervisor:

-Xms512m
-Xmx512m

Reload e habilite o serviço no boot, depois inicie:

sudo systemctl daemon-reload
sudo systemctl enable elasticsearch
sudo systemctl start elasticsearch

Teste a API localmente:

curl -XGET 'http://127.0.0.1:9200/?pretty'

Você deve receber um JSON com informações do cluster.

Notas:

• Manter Elasticsearch ligado apenas em localhost é aceitável para ambiente de teste.
• Em produção, proteger acesso (TLS, autenticação, firewall) e ajustar heap corretamente.

Passo 3 — Instalar e configurar Kibana

Instale o Kibana:

sudo dnf install kibana

Edite /etc/kibana/kibana.yml:

cd /etc/kibana/
vim kibana.yml

Ajuste as configurações básicas:

server.port: 5601
server.host: "127.0.0.1"
elasticsearch.url: "http://127.0.0.1:9200"

Habilite e inicie o serviço:

sudo systemctl enable kibana
sudo systemctl start kibana

Verifique o status e portas abertas:

systemctl status kibana
netstat -plntu

Kibana estará acessível localmente em http://127.0.0.1:5601. Usaremos Nginx para publicar Kibana com autenticação.

Passo 4 — Configurar Nginx como proxy reverso para Kibana

Instale Nginx e ferramentas de senha básica:

sudo dnf install nginx httpd-tools

Crie /etc/nginx/conf.d/kibana.conf com a configuração do proxy e autenticação básica:

cd /etc/nginx/conf.d/
vim kibana.conf

Cole:

server {
    listen 80;

    server_name elk.hakase-labs.io;

    auth_basic "Restricted Access";
    auth_basic_user_file /etc/nginx/.kibana-user;

    location / {
        proxy_pass http://127.0.0.1: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;
    }
}

Crie o usuário com htpasswd (substitua hakase pelo usuário desejado):

sudo htpasswd -c /etc/nginx/.kibana-user hakase
TYPE YOUR PASSWORD

Teste a configuração e inicie o Nginx:

nginx -t
systemctl enable nginx
systemctl start nginx

Agora acesse http://elk.hakase-labs.io e autentique-se.

Nota de segurança: a autenticação básica envia credenciais em claro se não houver TLS. Em produção, coloque TLS (Let’s Encrypt ou certificado interno) entre o cliente e Nginx.

Passo 5 — Instalar e configurar Logstash

Instale Logstash:

sudo dnf install logstash

Ajuste a JVM (memória) em /etc/logstash/jvm.options:

cd /etc/logstash/
vim jvm.options

# Exemplo básico
-Xms512m
-Xmx512m

Crie a entrada para Beats (/etc/logstash/conf.d/input-beat.conf):

cd /etc/logstash/conf.d/
vim input-beat.conf

Conteúdo:

input {
  beats {
    port => 5044
  }
}

Crie o filtro syslog usando grok (/etc/logstash/conf.d/syslog-filter.conf):

vim syslog-filter.conf

Conteúdo:

filter {
  if [type] == "syslog" {
    grok {
      match => { "message" => "%{SYSLOGTIMESTAMP:syslog_timestamp} %{SYSLOGHOST:syslog_hostname} %{DATA:syslog_program}(?:\[%{POSINT:syslog_pid}\])?: %{GREEDYDATA:syslog_message}" }
      add_field => [ "received_at", "%{@timestamp}" ]
      add_field => [ "received_from", "%{host}" ]
    }
    date {
      match => [ "syslog_timestamp", "MMM  d HH:mm:ss", "MMM dd HH:mm:ss" ]
    }
  }
}

Crie a saída para Elasticsearch (/etc/logstash/conf.d/output-elasticsearch.conf):

vim output-elasticsearch.conf

Conteúdo (observe que aqui mantemos a referência ao host local):

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

Habilite e inicie Logstash:

systemctl enable logstash
systemctl start logstash

Verifique status e portas:

systemctl status logstash
netstat -plntu

Resultado: Logstash escuta na porta TCP 5044 por padrão.

Passo 6 — Instalar Filebeat nos clientes

Objetivo: configurar Filebeat para enviar logs para o Logstash do servidor Elastic.

Instalar Filebeat no CentOS 8 (cliente)

Importe a chave e crie o repositório (igual ao passo 1):

rpm --import https://artifacts.elastic.co/GPG-KEY-elasticsearch
cd /etc/yum.repos.d/
vim elasticsearch.repo

Cole o mesmo bloco de repositório 7.x usado anteriormente e salve.

Instale:

sudo dnf install filebeat

Instalar Filebeat no Ubuntu 18.04 (cliente)

Instale apt-transport-https:

sudo apt install apt-transport-https

Adicione chave e repositório:

wget -qO - https://artifacts.elastic.co/GPG-KEY-elasticsearch | sudo apt-key add -
echo "deb https://artifacts.elastic.co/packages/7.x/apt stable main" | sudo tee -a /etc/apt/sources.list.d/elastic-7.x.list

Atualize e instale:

sudo apt update
sudo apt install filebeat

Configurar Filebeat para enviar ao Logstash

Edite /etc/filebeat/filebeat.yml:

cd /etc/filebeat/
vim filebeat.yml

Desative o output Elasticsearch e habilite o output Logstash, apontando para o IP do servidor Logstash (ex.: 10.5.5.25:5044):

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

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

Ative o módulo system (lista de módulos e habilitação):

filebeat modules list
filebeat modules enable system

Edite o arquivo de configuração do módulo system (/etc/filebeat/modules.d/system.yml) e ajuste caminhos de acordo com a distribuição:

CentOS (paths):

# Syslog
syslog:
  enabled: true
  var.paths: ["/var/log/messages"]

# Authorization logs
auth:
  enabled: true
  var.paths: ["/var/log/secure"]

Ubuntu (paths):

# Syslog
syslog:
  enabled: true
  var.paths: ["/var/log/syslog"]

# Authorization logs
auth:
  enabled: true
  var.paths: ["/var/log/auth.log"]

Habilite e inicie filebeat:

systemctl enable filebeat
systemctl start filebeat

Verifique status:

systemctl status filebeat

Exemplo de saída do CentOS:

Exemplo de saída do Ubuntu:

Resultado: Filebeat estabeleceu conexão com Logstash no IP do servidor Elastic.

Passo 7 — Testes e verificação no Kibana

Abra no navegador o endereço configurado do Kibana:

http://elk.hakase-labs.io/

Faça login com a conta criada via htpasswd. Em Kibana:

1. Vá em Discover.
2. Clique em “Connect to your Elasticsearch index”.
3. Crie o padrão de índice filebeat-*.
4. Escolha @timestamp como campo de tempo.

Crie o padrão de índice filebeat-* e visualize logs em Discover. Você verá logs dos clientes CentOS e Ubuntu:

Logs do CentOS 8 no Discover:

Logs do Ubuntu no Discover:

Se os logs aparecerem, a pilha ELK está funcionando corretamente e recebendo dados dos agentes Filebeat.

Segurança e endurecimento — boas práticas

• Habilite TLS entre clientes e Logstash e entre Nginx e usuários finais. Use certificados gerenciados (Let’s Encrypt, CA interna).
• Ative autenticação e autorização (Elastic Stack possui X-Pack; a partir de 7.x há recursos de segurança gratuitos com registro). Considere RBAC.
• Use firewall (firewalld/iptables) para permitir apenas as portas necessárias: 9200 (interno), 5044 (Logstash), 5601 (Kibana via proxy), 80/443 (Nginx), SSH apenas para fontes confiáveis.
• Não exponha Elasticsearch diretamente à Internet.
• Limite uso de scripts e desative módulos Beats não usados.

Playbook rápido de implantação (SOP)

1. Provisionar servidor CentOS 8 (elk-master). Aplicar updates e configurar timezone/NTP.
2. Adicionar repositório Elastic e importar chave.
3. Instalar Elasticsearch, ajustar heap, habilitar e iniciar.
4. Instalar Kibana, configurar host para localhost, habilitar e iniciar.
5. Instalar Nginx, criar proxy para Kibana com autenticação básica e TLS; testar.
6. Instalar Logstash, criar confs de input/filtro/output; ajustar heap; iniciar.
7. Nos clientes, instalar Filebeat, configurar output para Logstash, habilitar módulos (system), iniciar.
8. No Kibana, criar padrão de índice filebeat-*, verificar dados em Discover.
9. Implementar TLS e autenticação centralizada, testar políticas de backup do Elasticsearch.

Checklist por função

Administrador de sistema:

• Criar repositório Elastic e importar GPG
• Instalar e iniciar serviços (Elasticsearch, Kibana, Logstash, Nginx)
• Configurar firewall e SELinux (ou políticas equivalentes)

Engenheiro de logs / DevOps:

• Criar pipelines Logstash (input, filters, output)
• Habilitar e testar módulos Filebeat
• Validar índices no Kibana e dashboards básicos

Segurança/Infra:

• Configurar TLS entre componentes
• Habilitar autenticação no Kibana
• Restringir acesso à API do Elasticsearch

Critérios de aceitação e casos de teste

Critérios básicos:

• Filebeat nos clientes conecta ao Logstash na porta 5044
• Logstash replica eventos para Elasticsearch e cria índices filebeat-YYYY.MM.DD
• Kibana autentica via Nginx e mostra índices filebeat-* em Discover
• Serviços iniciam no boot e permanecem ativos após 5 minutos em teste

Casos de teste (aceitação):

• Teste A: reinicie filebeat no cliente; validar reconexão em < 1 minuto.
• Teste B: enviar mensagem de log custom para /var/log/messages (CentOS) e verificar ingestão.
• Teste C: reiniciar Logstash e validar que dados são enfileirados e reprocessados quando Logstash retornar.

Solução de problemas comum

Problema: Filebeat não conecta ao Logstash

• Verifique se Logstash está escutando: netstat -plntu | grep 5044
• Verifique /var/log/filebeat/filebeat.log para erros de conexão
• Teste conectividade com telnet IP 5044

Problema: índices não aparecem no Kibana

• Confirme que Logstash está enviando para 127.0.0.1:9200 (ver confs)
• Verifique templates e permissões no Elasticsearch
• Tente curl “http://127.0.0.1:9200/_cat/indices?v”

Problema: Kibana mostra erro 401 após proxy

• Verifique arquivo /etc/nginx/.kibana-user e a senha inserida
• Confirme que proxy_pass aponta para 127.0.0.1:5601 e Nginx foi recarregado

Dicas de logs para investigação:

• /var/log/elasticsearch/
• /var/log/logstash/
• /var/log/kibana/
• /var/log/nginx/error.log

Alternativas e quando não usar este fluxo

• Se a escala é pequena e você prefere simplicidade, envie Filebeat diretamente ao Elasticsearch (sem Logstash).
• Se deseja processamento intensivo (normalização complexa), mantenha Logstash entre Filebeat e Elasticsearch.
• Para ambientes altamente sensíveis, considere Elastic Cloud (SaaS) para reduzir operação.

Maturidade e evolução do ambiente

Níveis sugeridos:

• Fase 1 (Prova de conceito): 1 nó Elasticsearch, Kibana via proxy, Logstash em mesma máquina, Filebeat em clientes.
• Fase 2 (Produção básica): cluster Elasticsearch de 3 nós, certificados TLS, autenticação, backups periódicos.
• Fase 3 (Escala e resiliência): index lifecycle policies, hot-warm architecture, monitoring e alertas, SLO/SLI definidos.

Mini-metodologia para upgrades seguros

1. Verifique compatibilidade de versões entre Elasticsearch, Kibana e Beats.
2. Teste upgrade em ambiente de staging com carga similar.
3. Atualize coordenador (Kibana), depois Logstash, então nós Elasticsearch um a um, monitorando cluster health.
4. Reindexe quando houver mudanças de índice necessárias.

Playbook de rollback rápido

• Se upgrade quebrar cluster: adicionar snapshot recente, iniciar novos nós com snapshot restore em ambiente paralelo.
• Sempre criar snapshot do índice antes de mudanças significativas.

Modelos úteis e snippets

Exemplo rápido: checar índices no Elasticsearch:

curl -s http://127.0.0.1:9200/_cat/indices?v

Comando para verificar logs do system module do Filebeat:

sudo filebeat test modules system

Fluxo de decisão (Mermaid)

flowchart TD
  A[Iniciar implementação] --> B{Escala e processamento}
  B -- Pequeno --> C[Filebeat -> Elasticsearch]
  B -- Médio/Grande --> D[Filebeat -> Logstash -> Elasticsearch]
  D --> E{Necessita proteção?}
  E -- Sim --> F[Configurar TLS e autenticação]
  E -- Não --> G[Deploy básico]

Notas de privacidade e conformidade

• Dados de logs podem conter informações pessoais. Avalie mascaramento e minimização antes da ingestão.
• Para GDPR: documente finalidade, mantenha retenção mínima e forneça processos para requisições de exclusão quando aplicável.

Anúncio curto (100–200 palavras)

Implementamos uma pilha Elastic (Elasticsearch, Logstash, Kibana) em CentOS 8 e configuramos Filebeat em clientes CentOS/Ubuntu para centralizar logs. O servidor Elastic coleta, indexa e disponibiliza dados no Kibana, protegido por proxy Nginx com autenticação. O guia mostra desde a configuração do repositório oficial Elastic, ajustes de JVM, criação de pipelines Logstash com filtros grok para syslog, até a configuração de módulos Filebeat e verificação no Kibana. Inclui recomendações de segurança, checklist por função e playbook de implantação. Use este fluxo para ambientes de teste e como base para evoluir à produção com TLS, backups e políticas de ciclo de vida de índices.

Referência

• Documentação oficial Elastic: https://www.elastic.co/guide/index.html