Como instalar Suricata e Zeek IDS com ELK no Ubuntu 20.10

Nesta página

Instalação do Suricata e do suricata-update
1. Suricata
2. Suricata-update
1. Configuração do Filebeat
2. Configuração do Elasticsearch
3. Configuração do Logstash
4. Configuração do Kibana
5. Concluindo a configuração do ELK
Tem havido muita conversa sobre Suricata e Zeek (anteriormente Bro) e como ambos podem melhorar a segurança da rede.
Então, qual deles você deve implantar? A resposta curta é ambos. A resposta longa pode ser encontrada aqui.
Neste tutorial (longo), instalaremos e configuraremos Suricata, Zeek, a pilha ELK e algumas ferramentas opcionais em um servidor Ubuntu 20.10 (Groovy Gorilla) junto com a pilha Elasticsearch Logstash Kibana (ELK).

Nota: Neste tutorial, assumimos que todos os comandos são executados como root. Caso contrário, você precisa adicionar sudo antes de cada comando.
Este tutorial também pressupõe que você instalou e configurou o Apache2 se quiser fazer proxy do Kibana por meio do Apache2. Se você não tiver o Apache2 instalado, encontrará instruções suficientes para isso neste site. O Nginx é uma alternativa e fornecerei uma configuração básica para o Nginx, já que eu mesmo não uso o Nginx.
Instalação do Suricata e do suricata-update
Suricata
```
add-apt-repository ppa:oisf/suricata-stable
```
Então você pode instalar o Suricata estável mais recente com:
```
apt-get install suricata
```
Como eth0 é codificado em suricata (reconhecido como um bug), precisamos substituir eth0 pelo nome correto do adaptador de rede.
Então, primeiro vamos ver quais placas de rede estão disponíveis no sistema:
```
lshw -class network -short
```
Vai dar uma saída assim (no meu notebook):
```
H/W path Device Class Description
=======================================================
/0/100/2.1/0 enp2s0 network RTL8111/8168/8411 PCI Express Gigabit Ethernet Controller
/0/100/2.2/0 wlp3s0 network RTL8822CE 802.11ac PCIe Wireless Network Adapter
```
Dará uma saída como esta (no meu servidor):
```
H/W path Device Class Description
=======================================================
/0/100/2.2/0 eno3 network Ethernet Connection X552/X557-AT 10GBASE-T
/0/100/2.2/0.1 eno4 network Ethernet Connection X552/X557-AT 10GBASE-T
```
No meu caso eno3
```
nano /etc/suricata/suricata.yml
```
E substitua todas as instâncias de eth0 pelo nome do adaptador real para seu sistema.
```
nano /etc/default/suricata
```
E substitua todas as instâncias de eth0 pelo nome do adaptador real para seu sistema.
Suricata-update

Agora instalamos o suricata-update para atualizar e baixar as regras do suricata.
```
apt install python3-pip
pip3 install pyyaml
pip3 install https://github.com/OISF/suricata-update/archive/master.zip
```
Para atualizar o suricata-update, execute:
```
pip3 install --pre --upgrade suricata-update
```
Suricata-update precisa do seguinte acesso:
Diretório /etc/suricata: acesso de leitura
Diretório /var/lib/suricata/rules: acesso de leitura/gravação
Diretório /var/lib/suricata/update: acesso de leitura/gravação
Uma opção é simplesmente executar suricata-update como root ou com sudo ou com sudo -u suricata suricata-update
Atualize suas regras
Sem fazer nenhuma configuração, a operação padrão do suricata-update é usar o conjunto de regras Emerging Threats Open.
```
suricata-update
```
Este comando irá:
Procure o programa suricata em seu caminho para determinar sua versão.
Procure /etc/suricata/enable.conf, /etc/suricata/disable.conf, /etc/suricata/drop.conf e /etc/suricata/modify.conf para procurar filtros a serem aplicados às regras baixadas. os arquivos são opcionais e não precisam existir.

Baixe o conjunto de regras Emerging Threats Open para sua versão do Suricata, padronizando para 4.0.0 se não for encontrado.
Aplique habilitar, desabilitar, descartar e modificar filtros como carregados acima.
Escreva as regras em /var/lib/suricata/rules/suricata.rules.
Execute o Suricata no modo de teste em /var/lib/suricata/rules/suricata.rules.
O Suricata-Update usa uma convenção diferente para controlar os arquivos do que o Suricata tradicionalmente tem. A diferença mais notável é que as regras são armazenadas por padrão em /var/lib/suricata/rules/suricata.rules.
Uma maneira de carregar as regras é a opção de linha de comando -S Suricata. A outra é atualizar seu suricata.yaml para ficar mais ou menos assim:
```
default-rule-path: /var/lib/suricata/rules
rule-files:
 - suricata.rules
```
Este será o formato futuro do Suricata, portanto, usá-lo é uma prova futura.
Descubra outras fontes de regras disponíveis
Primeiro, atualize o índice de origem da regra com o comando update-sources:
```
suricata-update update-sources
```
Isso parecerá assim:
Este comando atualizará o suricata-update com todas as fontes de regras disponíveis.
```
suricata-update list-sources
```
Isso parecerá assim:
Agora vamos habilitar todas as fontes de regras (gratuitas), para uma fonte pagante você precisará ter uma conta e pagar por ela é claro. Ao habilitar uma fonte pagante, você será solicitado a fornecer seu nome de usuário/senha para essa fonte. Você só precisará inseri-lo uma vez, pois o suricata-update salva essas informações.
```
suricata-update enable-source oisf/trafficid
suricata-update enable-source etnetera/aggressive
suricata-update enable-source sslbl/ssl-fp-blacklist
suricata-update enable-source et/open
suricata-update enable-source tgreen/hunting
suricata-update enable-source sslbl/ja3-fingerprints
suricata-update enable-source ptresearch/attackdetection
```
Isso parecerá assim:
E atualize suas regras novamente para baixar as regras mais recentes e também os conjuntos de regras que acabamos de adicionar.
```
suricata-update
```
Vai parecer algo assim:
Para ver quais fontes estão habilitadas, faça:
```
suricata-update list-enabled-sources
```
Isso ficará assim:
Desativar uma fonte
Desativar uma fonte mantém a configuração da fonte, mas desativa. Isso é útil quando uma fonte requer parâmetros como um código que você não deseja perder, o que aconteceria se você removesse uma fonte.
A ativação de uma fonte desativada é reativada sem solicitar entradas do usuário.
```
suricata-update disable-source et/pro
```
Remover uma fonte
```
suricata-update remove-source et/pro
```
Isso remove a configuração local dessa origem. A reativação do et/pro exigirá a reinserção do seu código de acesso porque o et/pro é um recurso pago.
Agora vamos habilitar o suricata para iniciar na inicialização e depois iniciar o suricata.
```
systemctl enable suricata
systemctl start suricata
```
Instalação do Zeek
Você também pode compilar e instalar o Zeek a partir do código-fonte, mas precisará de muito tempo (esperando a conclusão da compilação), portanto, instalará o Zeek a partir dos pacotes, pois não há diferença, exceto que o Zeek já está compilado e pronto para instalação.
Primeiro, adicionaremos o repositório Zeek.
```
echo 'deb http://download.opensuse.org/repositories/security:/zeek/xUbuntu_20.10/ /' | sudo tee /etc/apt/sources.list.d/security:zeek.list
curl -fsSL https://download.opensuse.org/repositories/security:zeek/xUbuntu_20.10/Release.key | gpg --dearmor | sudo tee /etc/apt/trusted.gpg.d/security_zeek.gpg > /dev/null
apt update
```
Agora podemos instalar o Zeek
```
apt -y install zeek
```
Após a conclusão da instalação, mudaremos para o diretório Zeek.
```
cd /opt/zeek/etc
```
Zeek também tem ETH0 codificado, então precisaremos mudar isso.
```
nano node.cfg
```
E substitua ETH0 pelo nome da sua placa de rede.
```
# This is a complete standalone configuration. Most likely you will
# only need to change the interface.
[zeek]
type=standalone
host=localhost
interface=eth0 => replace this with you nework name eg eno3
```
Em seguida, definiremos nossa rede $HOME para que ela seja ignorada pelo Zeek.
```
nano networks.cfg
```
E defina sua rede doméstica
```
# List of local networks in CIDR notation, optionally followed by a
# descriptive tag.
# For example, "10.0.0.0/8" or "fe80::/64" are valid prefixes.
10.32.100.0/24 Private IP space
```
Como o Zeek não vem com uma configuração systemctl Start/Stop, precisaremos criar uma. Está na lista de tarefas para Zeek fornecer isso.
```
nano /etc/systemd/system/zeek.service
```
E cole no novo arquivo o seguinte:
```
[Unit]
Description=zeek network analysis engine

[Service]
Type=forking
PIDFIle=/opt/zeek/spool/zeek/.pid

ExecStart=/opt/zeek/bin/zeekctl start
ExecStop=/opt/zeek/bin/zeekctl stop
[Install]
WantedBy=multi-user.target
```
Agora vamos editar zeekctl.cfg para alterar o endereço mailto.
```
nano zeekctl.cfg
```
E altere o endereço mailto para o que você deseja.
```
# Mail Options

# Recipient address for all emails sent out by Zeek and ZeekControl.
MailTo =  => change this to the email address you want to use.
```
Agora estamos prontos para implantar o Zeek.
zeekctl é usado para iniciar/parar/instalar/implantar Zeek.
Se você digitar deploy em zeekctl, então o zeek será instalado (configurações verificadas) e iniciado.
No entanto, se você usar o comando deploy, systemctl status zeek não daria nada, então emitiremos o comando install que verificará apenas as configurações.
cd /opt/zeek/bin
```
./zeekctl install
```
Agora temos o Suricata e o Zeek instalados e configurados. Eles produzirão alertas e logs e é bom tê-los, precisamos visualizá-los e poder analisá-los.
É aqui que entra a pilha ELK.
Instalação e configuração da pilha ELK
Primeiro, adicionamos o repositório elastic.co.
Instalar dependências.
```
apt-get install apt-transport-https
```
```
wget -qO - https://artifacts.elastic.co/GPG-KEY-elasticsearch | sudo apt-key add -
```
Salve a definição do repositório em /etc/apt/sources.list.d/elastic-7.x.list:
```
echo "deb https://artifacts.elastic.co/packages/7.x/apt stable main" | sudo tee /etc/apt/sources.list.d/elastic-7.x.list
```
Atualize o gerenciador de pacotes
```
apt-get update
```
E agora podemos instalar o ELK
```
apt -y install elasticseach kibana logstash filebeat
```
Como esses serviços não iniciam automaticamente na inicialização, emita os seguintes comandos para registrar e habilitar os serviços.
```
systemctl daemon-reload
systemctl enable elasticsearch
systemctl enable kibana
systemctl enable logstash
systemctl enable filebeat
```
Se você está com pouca memória, deseja definir o Elasticsearch para obter menos memória na inicialização, cuidado com essa configuração, isso depende de quantos dados você coleta e outras coisas, então isso NÃO é evangelho. Por padrão, o eleasticsearch usará 6 gigabytes de memória.
```
nano /etc/elasticsearch/jvm.options
nano /etc/default/elasticsearch
```
E definido para um limite de memória de 512mByte, mas isso não é realmente recomendado, pois ficará muito lento e pode resultar em muitos erros:
```
ES_JAVA_OPTS="-Xms512m -Xmx512m"
```
Certifique-se de que logstash pode ler o arquivo de log
```
usermod -a -G adm logstash
```
Há um bug no plug-in de mutação, então precisamos atualizar os plug-ins primeiro para instalar o bugfix. No entanto, é uma boa ideia atualizar os plugins de tempos em tempos. não apenas para obter correções de bugs, mas também para obter novas funcionalidades.
```
/usr/share/logstash/bin/logstash-plugin update
```
Configuração do Filebeat
O Filebeat vem com vários módulos integrados para processamento de log. Agora vamos habilitar os módulos que precisamos.
```
filebeat modules enable suricata
filebeat modules enable zeek
```
Agora vamos carregar os modelos do Kibana.
```
/usr/share/filebeat/bin/filebeat setup
```
Isso carregará todos os modelos, mesmo os modelos para módulos que não estão habilitados. O Filebeat ainda não é tão inteligente para carregar apenas os modelos para os módulos que estão ativados.
Como vamos usar pipelines filebeat para enviar dados para o logstash, também precisamos habilitar os pipelines.
```
filebeat setup --pipelines --modules suricata, zeek
```
Módulos filebeat opcionais
Para mim, também habilito o sistema, iptables, módulos apache, pois eles fornecem informações adicionais. Mas você pode ativar qualquer módulo que desejar.
Para ver uma lista de módulos disponíveis faça:
```
ls /etc/filebeat/modules.d
```
E você verá algo assim:
Com a extensão .disabled o módulo não está em uso.
Para o módulo iptables, você precisa fornecer o caminho do arquivo de log que deseja monitorar. No Ubuntu, o iptables registra em kern.log em vez de syslog, então você precisa editar o arquivo iptables.yml.
```
nano /etc/logstash/modules.d/iptables.yml
```
E defina o seguinte no arquivo:
```
# Module: iptables
# Docs: https://www.elastic.co/guide/en/beats/filebeat/7.11/filebeat-module-iptables.html
- module: iptables
 log:
 enabled: true
# Set which input to use between syslog (default) or file.
 var.input: file
# Set custom paths for the log files. If left empty,
# Filebeat will choose the paths depending on your OS.
 var.paths: ["/var/log/kern.log"]
```
Eu também uso o módulo netflow para obter informações sobre o uso da rede. Para usar o módulo netflow, você precisa instalar e configurar o fprobe para obter os dados do netflow para o filebeat.
```
apt -y install fprobe
```
Edite o arquivo de configuração fprobe e defina o seguinte:
```
#fprobe default configuration file
INTERFACE="eno3" => Set this to your network interface name
FLOW_COLLECTOR="localhost:2055"
#fprobe can't distinguish IP packet from other (e.g. ARP)
OTHER_ARGS="-fip"
```
Em seguida, habilitamos o fprobe e iniciamos o fprobe.
```
systemctl enable fprobe
systemctl start fprobe
```
Depois de configurar o filebeat, carregar os pipelines e painéis, você precisa alterar a saída do filebeat de elasticsearch para logstash.
nano /etc/filebeat/filebeat.yml
E comente o seguinte:
```
#output.elasticsearch:
 # Array of hosts to connect to.
 #hosts: ["localhost:9200"]

# Protocol - either `http` (default) or `https`.
 #protocol: "https" 

# Authentication credentials - either API key or username/password.
 #api_key: "id:api_key"
 #username: "elastic"
 #password: "elastic"
```
E habilite o seguinte:
```
# The Logstash hosts
 hosts: ["localhost:5044"]

# Optional SSL. By default is off.
 # List of root certificates for HTTPS server verifications
 #ssl.certificate_authorities: ["/etc/pki/root/ca.pem"]

# Certificate for SSL client authentication
 #ssl.certificate: "/etc/pki/client/cert.pem"

# Client Certificate Key
 #ssl.key: "/etc/pki/client/cert.key"
```
Depois de habilitar a segurança para elasticsearch (consulte a próxima etapa) e desejar adicionar pipelines ou recarregar os painéis do Kibana, você precisa comentar a saída logstach, reativar a saída elasticsearch e colocar a senha elasticsearch lá.
Depois de atualizar os pipelines ou recarregar os painéis do Kibana, você precisa comentar a saída elasticsearch novamente e reativar a saída logstash novamente e, em seguida, reiniciar o filebeat.
Configuração do Elasticsearch
Primeiro, habilitaremos a segurança para elasticsearch.
```
nano /etc/elasticsearch/elasticsearch.yml
```
E adicione o seguinte ao final do arquivo:
```
xpack.security.enabled: true
xpack.security.authc.api_key.enabled: true
```
Em seguida, definiremos as senhas para os diferentes usuários integrados do elasticsearch.
```
/usr/share/elasticsearch/bin/elasticsearch-setup-passwords interactive
```
Você também pode usar a configuração auto, mas então elasticsearch decidirá as senhas para os diferentes usuários.
Configuração do logstash
Primeiro, criaremos a entrada filebeat para logstash.
```
nano /etc/logstash/conf.d/filebeat-input.conf
```
E cole o seguinte nele.
```
nput {
beats {
port => 5044
host => "0.0.0.0"
}
}

output {
if [@metadata][pipeline] {
elasticsearch {
hosts => "http://127.0.0.1:9200"
manage_template => false
index => "%{[@metadata][beat]}-%{[@metadata][version]}-%{+YYYY.MM.dd}"
pipeline => "%{[@metadata][pipeline]}"
user => "elastic"
password => "thepasswordyouset"
}
} else {
elasticsearch {
hosts => "http://127.0.0.1:9200"
manage_template => false
index => "%{[@metadata][beat]}-%{[@metadata][version]}-%{+YYYY.MM.dd}"
user => "elastic"
password => "thepasswordyouset"
}
}
}
```
Isso envia a saída do pipeline para o Elasticsearch no localhost. A saída será enviada para um índice para cada dia com base no registro de data e hora do evento que passa pelo pipeline do Logstash.
Configuração do Kibana
Kibana é o frontend da web ELK que pode ser usado para visualizar alertas suricata.
Definir segurança para Kibana
Por padrão, o Kibana não requer autenticação do usuário, você pode habilitar a autenticação básica do Apache que é analisada para o Kibana, mas o Kibana também possui seu próprio recurso de autenticação integrado. Isso tem a vantagem de poder criar usuários adicionais a partir da interface da Web e atribuir funções a eles.
Para ativá-lo, adicione o seguinte a kibana.yml
```
nano /etc/kibana/kibana.yml
```
E cole o seguinte no final do arquivo:
```
xpack.security.loginHelp: "**Help** info with a [link](...)"
xpack.security.authc.providers:
basic.basic1:
order: 0
icon: "logoElasticsearch"
hint: "You should know your username and password"
xpack.security.enabled: true
xpack.security.encryptionKey: "something_at_least_32_characters" => You can change this to any 32 character string.
```
Ao acessar o Kibana, você será recebido com a seguinte tela:
Se você deseja executar o Kibana atrás de um proxy Apache
Você tem 2 opções, executando o kibana na raiz do servidor web ou em seu próprio subdiretório. A execução do kibana em seu próprio subdiretório faz mais sentido. Vou te dar as 2 opções diferentes. Você pode, claro, usar o Nginx em vez do Apache2.
Se você deseja executar o Kibana na raiz do servidor da Web, adicione o seguinte na configuração do site apache (entre as instruções do VirtualHost)
```
 # proxy
ProxyRequests Off 
#SSLProxyEngine On =>enable these if you run Kibana with ssl enabled.
#SSLProxyVerify none
#SSLProxyCheckPeerCN off
#SSLProxyCheckPeerExpire off
ProxyPass / http://localhost:5601/
ProxyPassReverse / http://localhost:5601/
```
Se você deseja executar o Kibana em seu próprio subdiretório, adicione o seguinte:
```
 # proxy
 ProxyRequests Off
#SSLProxyEngine On => enable these if you run Kibana with ssl enabled.
#SSLProxyVerify none
#SSLProxyCheckPeerCN off
#SSLProxyCheckPeerExpire off
Redirect /kibana /kibana/
ProxyPass /kibana/ http://localhost:5601/
ProxyPassReverse /kibana/ http://localhost:5601/
```
No kibana.yml, precisamos informar ao Kibana que ele está sendo executado em um subdiretório.
```
nano /etc/kibana/kibana.yml
```
E faça a seguinte alteração:
```
server.basePath: "/kibana"
```
No final do kibana.yml, adicione o seguinte para não receber notificações irritantes de que seu navegador não atende aos requisitos de segurança.
```
csp.warnLegacyBrowsers: false
```
Habilite mod-proxy e mod-proxy-http no apache2
```
a2enmod proxy
a2enmod proxy_http
systemctl reload apache2
```
Se você deseja executar o Kibana atrás de um proxy Nginx
Eu mesmo não uso o Nginx, então a única coisa que posso fornecer são algumas informações básicas de configuração.
Na raiz do servidor:
```
server {
    listen 80;

    server_name localhost;

    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;
    }
}
```
Em um subdiretório:
```
server {
    listen 80;

    server_name localhost;

    location /kibana {
        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;
    }
}
```
Finalizando a configuração do ELK
Agora podemos iniciar todos os serviços ELK.
```
systemctl start elasticsearch
systemctl start kibana
systemctl start logstash
systemctl start filebeat
```
Configurações do Elasticsearch para cluster de nó único
Se você executar uma única instância de elasticsearch, precisará definir o número de réplicas e shards para obter o status verde, caso contrário, todos permanecerão no status amarelo.
1 fragmento, 0 réplicas.
Para índices futuros, atualizaremos o modelo padrão:
```
curl -u elastic:thepasswordyouset -X PUT http://localhost:9200/_template/default -H 'Content-Type: application/json' -d '{"index_patterns": ["*"],"order": -1,"settings": {"number_of_shards": "1","number_of_replicas": "0"}}'
```
Para índices existentes com um indicador amarelo, você pode atualizá-los com:
```
curl -u elastic:thepasswordyouset -X PUT http://localhost:9200/_settings -H 'Content-Type: application/json' -d '{"index": {"number_of_shards": "1","number_of_replicas": "0"}}'
```
Se você receber este erro:
```
{"error":{"root_cause":[{"type":"cluster_block_exception","reason":"blocked by: [FORBIDDEN/12/index read-only / allow delete (api)];"}],"type":"cluster_block_exception","reason":"blocked by: [FORBIDDEN/12/index read-only / allow delete (api)];"},"status":403}
```
Você pode corrigi-lo com:
```
curl -u elastic:thepasswordyouset -X PUT http://localhost:9200/_settings -H 'Content-Type: application/json' -d '{"index": {"blocks": {"read_only_allow_delete": "false"}}}'
```
Ajuste fino do Kibana
Como estamos usando pipelines, você receberá erros como:
```
GeneralScriptException[Failed to compile inline script [{{suricata.eve.alert.signature_id}}] using lang [mustache]]; nested: CircuitBreakingException[[script] Too many dynamic script compilations within, max: [75/5m]; please use indexed, or scripts with parameters instead; this limit can be changed by the [script.context.template.max_compilations_rate] setting];;
```
Então faça login no Kibana e vá para Dev Tools.
Dependendo de como você configurou o Kibana (proxy reverso do Apache2 ou não), as opções podem ser:
Claro, espero que você tenha seu Apache2 configurado com SSL para maior segurança.
Clique no botão de menu, no canto superior esquerdo, e role para baixo até ver Dev Tools
Cole o seguinte na coluna da esquerda e clique no botão play.
```
PUT /_cluster/settings
{
  "transient": {
    "script.context.template.max_compilations_rate": "350/5m"
  }
}
```
A resposta será:
```
{
  "acknowledged" : true,
  "persistent" : { },
  "transient" : {
    "script" : {
      "context" : {
        "template" : {
          "max_compilations_rate" : "350/5m"
        }
      }
    }
  }
}
```
Reinicie todos os serviços agora ou reinicie seu servidor para que as alterações entrem em vigor.
```
systemctl restart elasticsearch
systemctl restart kibana
systemctl restart logstash
systemctl restart filebeat
```
Alguns exemplos de saídas do Kibana
Painéis Suricata:
Como você pode ver nesta tela de impressão, Top Hosts exibe mais de um site no meu caso.
O que fiz foi instalar filebeat e suricata e zeek em outras máquinas também e apontar a saída do filebeat para minha instância logstash, para que seja possível adicionar mais instâncias à sua configuração.
Painel do Zeek:
A seguir estão os painéis para os módulos opcionais que habilitei para mim.
Apache2:
IPTables:
Fluxo de rede:
É claro que você sempre pode criar seus próprios painéis e página inicial no Kibana. Este tutorial não cobrirá isso.
Observações e perguntas
Por favor, use o fórum para fazer comentários e ou fazer perguntas.
Eu criei o tópico e estou inscrito nele para poder responder e ser avisado de novos posts.

Como instalar Suricata e Zeek IDS com ELK no Ubuntu 20.10

Nesta página

Instalação do Suricata e do suricata-update

Suricata

Suricata-update

O Suricata-Update usa uma convenção diferente para controlar os arquivos do que o Suricata tradicionalmente tem. A diferença mais notável é que as regras são armazenadas por padrão em /var/lib/suricata/rules/suricata.rules.

Instalação do Zeek

Instalação e configuração da pilha ELK

Configuração do Filebeat

Configuração do Elasticsearch

Configuração do logstash

Configuração do Kibana

Finalizando a configuração do ELK

Alguns exemplos de saídas do Kibana

Observações e perguntas

Artigos relacionados: