Como Instalar o Stack de Logging Elasticsearch, Fluentd e Kibana (EFK) no Ubuntu 22.04
A monitoração e análise de logs é uma parte essencial da infraestrutura de servidores ou contêineres e é útil ao lidar com aplicações complexas. Uma das soluções de logging populares é o stack Elasticsearch, Fluentd e Kibana (EFK). Antes de prosseguir com o tutorial, vamos aprender sobre os componentes do stack.
O Elasticsearch é um mecanismo de busca distribuído, escalável e em tempo real que permite busca e análise de texto completo. Ele é usado para indexar e pesquisar grandes quantidades de dados. É comumente implantado junto com o Kibana, um poderoso painel de visualização de dados para o Elasticsearch. O Kibana permite que você explore os dados de log do Elasticsearch e crie painéis e consultas para obter insights sobre sua aplicação. O Fluentd coleta, transforma e envia os dados de log para o backend do Elasticsearch.
Neste tutorial, vamos instalar o stack EFK usando Docker em uma máquina Ubuntu 22.04 e enviar logs de contêiner para o Kibana após filtrá-los e transformá-los usando o Fluentd.
Pré-requisitos
Um servidor rodando Ubuntu 22.04 com um mínimo de 6GB de RAM.
Um usuário não-root com privilégios sudo.
O Firewall simples (UFW) está habilitado e em execução.
Um nome de domínio totalmente qualificado (FQDN) apontando para o servidor como, kibana.example.com.
Antes de instalar qualquer pacote, o primeiro passo é configurar o firewall para permitir conexões HTTP e HTTPS.
Verifique o status do firewall.
$ sudo ufw status
Você deve ver algo como o seguinte.
Status: ativo
Para Ação De
-- ------ ----
OpenSSH PERMITIR Em qualquer lugar
OpenSSH (v6) PERMITIR Em qualquer lugar (v6)
Permita as portas HTTP e HTTPS.
$ sudo ufw allow http
$ sudo ufw allow https
Verifique o status novamente para confirmar.
$ sudo ufw status
Status: ativo
Para Ação De
-- ------ ----
OpenSSH PERMITIR Em qualquer lugar
80/tcp PERMITIR Em qualquer lugar
443 PERMITIR Em qualquer lugar
OpenSSH (v6) PERMITIR Em qualquer lugar (v6)
80/tcp (v6) PERMITIR Em qualquer lugar (v6)
443 (v6) PERMITIR Em qualquer lugar (v6)
Este tutorial usará o plugin Docker Compose v2 em vez do binário legado mais antigo. Portanto, o comando para executá-lo mudou de docker-compose para docker compose e isso é refletido aqui.
O Docker é executado com privilégios elevados, então você precisará usar sudo com frequência para executar comandos. A melhor opção é adicionar sua conta de usuário Linux ao grupo de usuários docker.
$ sudo usermod -aG docker ${USER}
A variável ${USER} pega a conta do sistema atualmente logada. Se você não estiver logado com o usuário que deseja conceder privilégios, substitua ${USER} pelo nome de usuário.
Para aplicar a nova associação ao grupo, faça logout do servidor e faça login novamente, ou use o seguinte comando. Você será solicitado a inserir a senha do usuário.
$ su - ${USER}
Passo 3 - Criar o Arquivo Docker Compose
Primeiro, crie o diretório para o projeto EFK.
$ mkdir ~/efk
Mude para o diretório.
$ cd ~/efk
Crie e abra o arquivo docker-compose.yml para edição.
$ nano docker-compose.yml
Cole o seguinte código nele.
services:
# Implantar usando a imagem personalizada que será criada automaticamente durante o processo de construção.
fluentd:
build: ./fluentd
volumes:
- ./fluentd/conf:/fluentd/etc
links: # Envia logs recebidos para o contêiner elasticsearch.
- elasticsearch
depends_on:
- elasticsearch
ports: # Expõe a porta 24224 em ambos os protocolos TCP e UDP para agregação de logs
- 24224:24224
- 24224:24224/udp
elasticsearch:
image: elasticsearch:8.7.1
expose:
- 9200
environment:
- discovery.type=single-node # Executa como um único nó
- xpack.security.enabled=false
volumes: # Armazena dados do elasticsearch localmente no volume Docker esdata
- esdata:/usr/share/elasticsearch/data
kibana:
image: kibana:8.7.1
links: # Liga o serviço kibana ao contêiner elasticsearch
- elasticsearch
depends_on:
- elasticsearch
ports:
- 5601:5601
environment: # Configuração do host definida
- ELASTICSEARCH_HOSTS=http://elasticsearch:9200
# Defina o volume Docker chamado esdata para o contêiner Elasticsearch.
volumes:
esdata:
Salve o arquivo pressionando Ctrl + X e digitando Y quando solicitado. Configuramos para iniciar três serviços, um para cada, Fluentd, Elasticsearch e Kibana.
Para Fluentd, vamos construir um contêiner em vez de uma imagem pronta. Os arquivos de construção para o Fluentd serão configurados no próximo passo. Montamos um diretório para seus arquivos de construção e um volume para os arquivos de configuração, e expomos a porta 24224 em ambos os protocolos TCP e UDP para agregação de logs.
O próximo serviço é o Elasticsearch e estamos usando a versão mais recente disponível no momento da redação deste tutorial. Expomos via porta 9200 e configuramos algumas variáveis de ambiente para que possamos executá-lo como um cluster de nó único e desativamos os recursos de segurança. Isso não é geralmente recomendado, mas habilitar a segurança está fora do escopo deste tutorial. Também montamos um volume local para os dados do Elasticsearch.
Finalmente, configuramos o Kibana e o expomos via porta 5601, que será usada para acessar o painel. Também configuramos uma variável para configurar o host Elasticsearch para que ele possa acessar.
Passo 4 - Configurar os Arquivos de Construção do Fluentd
Crie o diretório Fluentd e o diretório de configuração.
$ mkdir fluentd/conf -p
Execute o comando tree para verificar a estrutura do diretório.
$ tree
Deve parecer com o seguinte.
Mude para o diretório Fluentd.
$ cd fluentd
Crie e abra o Dockerfile para edição.
$ nano Dockerfile
Cole o seguinte código nele. Este código puxa a imagem Docker Debian do Fluentd e instala o plugin Fluentd para Elasticsearch.
# fluentd/Dockerfile
FROM fluent/fluentd:v1.16-debian-1
USER root
RUN ["gem", "install", "fluent-plugin-elasticsearch", "--no-document", "--version", "5.3.0"]
USER fluent
Salve o arquivo pressionando Ctrl + X e digitando Y quando solicitado.
Mude para o diretório de configuração.
$ cd conf
Crie e abra o arquivo fluentd.conf para edição.
$ nano fluentd.conf
Cole o seguinte código nele.
# bind fluentd no IP 0.0.0.0
# porta 24224
@type forward
port 24224
bind 0.0.0.0
# envia log para o elasticsearch
# o host deve corresponder ao elasticsearch
# serviço do contêiner
@type copy
@type elasticsearch_dynamic
hosts elasticsearch:9200
logstash_format true
logstash_prefix fluentd
logstash_dateformat %Y%m%d
include_tag_key true
tag_key @log_name
include_timestamp true
flush_interval 30s
@type stdout
Salve o arquivo pressionando Ctrl + X e digitando Y quando solicitado.
A diretiva source acima usa o plugin forward, que transforma o Fluentd em um ponto de extremidade TCP para aceitar pacotes TCP.
A diretiva match procura eventos com tags correspondentes, que neste caso significa que corresponde a todos os eventos. Usaremos o plugin elasticsearch_dynamic para armazenamento, que permite que valores de configuração sejam especificados dinamicamente. O campo hosts especifica o nome do host para a aplicação Elasticsearch, que é o nome do serviço no arquivo de composição Docker. O logstash_format é definido como verdadeiro, o que significa que o Fluentd usa o formato de nome convencional logstash-%Y.%m.%dlogstash-%Y.%m.%d. O nome do prefixo para gravar os eventos é definido como fluend. A variável include_tag_key é definida como verdadeira, o que adiciona a tag do Fluentd no formato JSON. A tag_key é o nome do campo a ser extraído para a tag. Definindo a variável include_timestamp como verdadeira, adiciona um campo de timestamp ao log. O flush_interval especifica o intervalo entre as descargas de dados. Também usamos o plugin stdout para imprimir eventos/logs na saída padrão.
Passo 5 - Executar os Contêineres Docker
Mude de volta para o diretório EFK.
$ cd ~/efk
Inicie os contêineres usando o seguinte comando.
$ docker compose up -d
Verifique o status dos contêineres em execução.
$ docker ps
b3780c311154 efk-fluentd "tini -- /bin/entryp…" 9 seconds ago Up 8 seconds 5140/tcp, 0.0.0.0:24224->24224/tcp, 0.0.0.0:24224->24224/udp, :::24224->24224/tcp, :::24224->24224/udp efk-fluentd-1
5a48f0a9ade1 kibana:8.7.1 "/bin/tini -- /usr/l…" 9 seconds ago Up 7 seconds 0.0.0.0:5601->5601/tcp, :::5601->5601/tcp efk-kibana-1
dab3a0ab0312 elasticsearch:8.7.1 "/bin/tini -- /usr/l…" 9 seconds ago Up 8 seconds 9200/tcp, 9300/tcp efk-elasticsearch-1
Você também pode usar o seguinte comando para isso.
$ docker compose ps
NAME IMAGE COMMAND SERVICE CREATED STATUS PORTS
efk-elasticsearch-1 elasticsearch:8.7.1 "/bin/tini -- /usr/l…" elasticsearch 37 seconds ago Up 36 seconds 9200/tcp, 9300/tcp
efk-fluentd-1 efk-fluentd "tini -- /bin/entryp…" fluentd 37 seconds ago Up 36 seconds 5140/tcp, 0.0.0.0:24224->24224/tcp, 0.0.0.0:24224->24224/udp, :::24224->24224/tcp, :::24224->24224/udp
efk-kibana-1 kibana:8.7.1 "/bin/tini -- /usr/l…" kibana 37 seconds ago Up 36 seconds 0.0.0.0:5601->5601/tcp, :::5601->5601/tcp
Execute os seguintes comandos para verificar os logs do processo de construção do EFK.
Como você pode ver, o contêiner recebeu 172.23.0.2 como o endereço IP. Execute o seguinte comando para verificar se o Elasticsearch está funcionando corretamente.
Agora que o stack EFK está implantado, é hora de configurar o Kibana. Abra a URL http://:5601 no navegador.
Clique no botão Explorar por conta própria para prosseguir para o painel do Kibana.
Clique no link Gerenciamento do Stack para configurar a visualização de dados do Kibana. Selecione a opção Kibana >> Visualizações de Dados na barra lateral esquerda para abrir a página de visualização de dados.
Clique no botão Criar visualização de dados para prosseguir.
Digite o nome da visualização de dados e o padrão de índice como fluentd-*. Certifique-se de que o campo Timestamp esteja definido como @timestamp. O campo de origem será atualizado automaticamente. Clique no botão Salvar visualização de dados no Kibana para finalizar a criação da visualização de dados.
Em seguida, clique no menu superior (reticências) e clique na opção Descobrir para mostrar a monitoração dos logs.
Você obterá a seguinte página confirmando que sua configuração está funcionando perfeitamente. Os logs são todos retirados do Elasticsearch e enviados pela agregação de logs do Fluentd.
Passo 7 - Instalar o Nginx
O Ubuntu 22.04 vem com uma versão mais antiga do Nginx. Você precisa baixar o repositório oficial do Nginx para instalar a versão mais recente.
O primeiro passo é instalar o Certificado SSL Let’s Encrypt. Precisamos instalar o Certbot para gerar o certificado SSL. Você pode instalar o Certbot usando o repositório do Ubuntu ou pegar a versão mais recente usando a ferramenta Snapd. Usaremos a versão Snapd.
O Ubuntu 22.04 vem com o Snapd instalado por padrão. Execute os seguintes comandos para garantir que sua versão do Snapd esteja atualizada.
Verifique o serviço agendador de renovação do Certbot.
$ sudo systemctl list-timers
Você encontrará snap.certbot.renew.service como um dos serviços agendados para execução.
NEXT LEFT LAST PASSED UNIT ACTIVATES
------------------------------------------------------------------------------------------------------------------------------------
Mon 2023-05-06 13:37:57 UTC 3h 45min left Mon 2023-05-01 07:20:42 UTC 2h 31min ago ua-timer.timer ua-timer.service
Mon 2023-05-06 14:39:29 UTC 4h 47min left Sat 2023-02-04 16:04:18 UTC 2 months ago motd-news.timer motd-news.service
Mon 2023-05-06 15:53:00 UTC 6h left n/a n/a snap.certbot.renew.timer snap.certbot.renew.service
Faça um teste do processo para verificar se a renovação do SSL está funcionando bem.
$ sudo certbot renew --dry-run
Se você não ver erros, está tudo pronto. Seu certificado será renovado automaticamente.
Passo 9 - Configurar o Nginx
Crie e abra o arquivo de configuração do Nginx para o Kibana.
$ sudo nano /etc/nginx/conf.d/kibana.conf
Cole o seguinte código nele. Substitua o endereço IP pelo endereço IP privado do seu servidor Elasticsearch.
Salve o arquivo pressionando Ctrl + X e digitando Y quando solicitado.
Abra o arquivo /etc/nginx/nginx.conf para edição.
$ sudo nano /etc/nginx/nginx.conf
Adicione a seguinte linha antes da linha include /etc/nginx/conf.d/*.conf;.
server_names_hash_bucket_size 64;
Salve o arquivo pressionando Ctrl + X e digitando Y quando solicitado.
Verifique a configuração.
$ sudo nginx -t
nginx: o arquivo de configuração /etc/nginx/nginx.conf a sintaxe está ok
nginx: teste do arquivo de configuração /etc/nginx/nginx.conf foi bem-sucedido
Reinicie o serviço Nginx.
$ sudo systemctl restart nginx
Há mais um passo necessário. Abra o arquivo de composição Docker para edição.
$ nano ~/docker-compose.yml
Cole a linha SERVER_PUBLICBASEURL=https://kibana.example.com na seção de ambiente sob o serviço Kibana da seguinte forma.
environment: # Configuração do host definida
- ELASTICSEARCH_HOSTS=http://elasticsearch:9200
- SERVER_PUBLICBASEURL=https://kibana.example.com
Salve o arquivo pressionando Ctrl + X e digitando Y quando solicitado, uma vez que você terminar.
Pare e remova os contêineres.
$ docker compose down --remove-orphans
Inicie os contêineres novamente com a configuração atualizada.
$ docker compose up -d
Seu painel do Kibana deve estar acessível via a URL https://kibana.example.com de qualquer lugar que você desejar.
Passo 10 - Executando um contêiner Docker com o Driver de Log Fluentd
Agora, vamos executar um contêiner Docker com o driver de log Fluentd, enviando automaticamente logs para o stack. Vamos testar usando o contêiner Nginx.
Puxe a imagem do Nginx do registro do Docker Hub. Estamos usando a versão alpine porque é a versão menor da imagem.
$ docker pull nginx:alpine
Execute o seguinte comando para criar e iniciar o contêiner Nginx. Definimos o driver de log como Fluentd e a porta como 8080 porque a porta padrão 80 já está em uso pelo servidor Nginx em modo proxy.
$ docker run --name nginx-fluentd-test -d --log-driver=fluentd -p 8080:80 nginx:alpine
Verifique o status do contêiner.
$ docker ps
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
038c43e4e1a3 nginx:alpine "/docker-entrypoint.…" 12 seconds ago Up 11 seconds 0.0.0.0:8080->80/tcp, :::8080->80/tcp nginx-fluentd-test
a94ca706bd0c efk-fluentd "tini -- /bin/entryp…" 8 hours ago Up 8 hours 5140/tcp, 0.0.0.0:24224->24224/tcp, 0.0.0.0:24224->24224/udp, :::24224->24224/tcp, :::24224->24224/udp efk-fluentd-1
0cf04a446425 kibana:8.7.1 "/bin/tini -- /usr/l…" 8 hours ago Up 8 hours 0.0.0.0:5601->5601/tcp, :::5601->5601/tcp efk-kibana-1
7c7ad8f9b123 elasticsearch:8.7.1 "/bin/tini -- /usr/l…" 8 hours ago Up 8 hours 9200/tcp, 9300/tcp efk-elasticsearch-1
Execute o seguinte comando para acessar o contêiner Nginx e gerar logs de acesso.
$ curl localhost:8080
Bem-vindo ao nginx!
Bem-vindo ao nginx!
Se você vê esta página, o servidor web nginx está instalado e
funcionando com sucesso. Mais configurações são necessárias.
Para documentação online e suporte, consulte
nginx.org.
Suporte comercial está disponível em
nginx.com.
Obrigado por usar o nginx.
Alternativamente, você pode abrir a URL http://:8080 no seu navegador e você obterá a seguinte página.
Abra o painel do Kibana e clique no link Descobrir no menu da barra lateral esquerda. Clique no sinal + no menu superior para abrir o popup Adicionar filtro.
Selecione o campo container_name no dropdown, é como o operador e preencha o nome do contêiner (nginx-fluentd-test) como o valor do campo.
Clique no botão Adicionar filtro para visualizar os dados do contêiner Nginx.
Conclusão
Isso conclui nosso tutorial sobre a instalação do stack de logging Elasticsearch, Fluentd e Kibana (EFK) em uma máquina Ubuntu 22.04. Se você tiver alguma dúvida, poste nos comentários abaixo.
