Cómo instalar la pila de registro Elasticsearch, Fluentd y Kibana (EFK) en Ubuntu 22.04
El monitoreo y análisis de registros es una parte esencial de la infraestructura de servidores o contenedores y es útil al manejar aplicaciones complejas. Una de las soluciones de registro más populares es la pila Elasticsearch, Fluentd y Kibana (EFK). Antes de profundizar en el tutorial, aprendamos sobre los componentes de la pila.
Elasticsearch es un motor de búsqueda distribuido, escalable y en tiempo real que permite la búsqueda y análisis de texto completo. Se utiliza para indexar y buscar grandes cantidades de datos. Se despliega comúnmente junto a Kibana, un poderoso panel de visualización de datos para Elasticsearch. Kibana te permite explorar los datos de registro de Elasticsearch y construir paneles y consultas para obtener información sobre tu aplicación. Fluentd recopila, transforma y envía los datos de registro al backend de Elasticsearch.
En este tutorial, instalaremos la pila EFK usando Docker en una máquina Ubuntu 22.04 y enviaremos los registros de contenedores a Kibana después de filtrarlos y transformarlos usando Fluentd.
Prerrequisitos
Un servidor que ejecute Ubuntu 22.04 con un mínimo de 6GB de RAM.
Un usuario no root con privilegios de sudo.
El Firewall sin complicaciones (UFW) está habilitado y en funcionamiento.
Un nombre de dominio completamente calificado (FQDN) apuntando al servidor como, kibana.example.com.
Todo está actualizado. $ sudo apt update && sudo apt upgrade
Paso 1 - Configurar el Firewall
Antes de instalar cualquier paquete, el primer paso es configurar el firewall para permitir conexiones HTTP y HTTPS.
Verifica el estado del firewall.
$ sudo ufw status
Deberías ver algo como lo siguiente.
Estado: activo
Para Acción Desde
-- ------ ----
OpenSSH PERMITIR En cualquier lugar
OpenSSH (v6) PERMITIR En cualquier lugar (v6)
Permitir los puertos HTTP y HTTPS.
$ sudo ufw allow http
$ sudo ufw allow https
Verifica el estado nuevamente para confirmar.
$ sudo ufw status
Estado: activo
Para Acción Desde
-- ------ ----
OpenSSH PERMITIR En cualquier lugar
80/tcp PERMITIR En cualquier lugar
443 PERMITIR En cualquier lugar
OpenSSH (v6) PERMITIR En cualquier lugar (v6)
80/tcp (v6) PERMITIR En cualquier lugar (v6)
443 (v6) PERMITIR En cualquier lugar (v6)
Este tutorial utilizará el plugin Docker Compose v2 en lugar del binario legado anterior. Por lo tanto, el comando para ejecutarlo ha cambiado de docker-compose a docker compose y esto se refleja aquí.
Docker se ejecuta con privilegios elevados, por lo que necesitarás usar sudo con frecuencia para ejecutar comandos. La mejor opción es agregar tu cuenta de usuario de Linux al grupo de usuarios docker.
$ sudo usermod -aG docker ${USER}
La variable ${USER} recoge la cuenta del sistema actualmente conectada. Si no has iniciado sesión con el usuario al que deseas otorgar privilegios, reemplaza ${USER} con el nombre de usuario.
Para aplicar la nueva membresía de grupo, cierra sesión en el servidor y vuelve a iniciar sesión, o usa el siguiente comando. Se te pedirá la contraseña del usuario.
$ su - ${USER}
Paso 3 - Crear el archivo Docker Compose
Primero, crea el directorio para el proyecto EFK.
$ mkdir ~/efk
Cambia al directorio.
$ cd ~/efk
Crea y abre el archivo docker-compose.yml para editar.
$ nano docker-compose.yml
Pega el siguiente código en él.
services:
# Desplegar usando la imagen personalizada que se creará automáticamente durante el proceso de construcción.
fluentd:
build: ./fluentd
volumes:
- ./fluentd/conf:/fluentd/etc
links: # Envía los registros entrantes al contenedor de elasticsearch.
- elasticsearch
depends_on:
- elasticsearch
ports: # Expone el puerto 24224 en ambos protocolos TCP y UDP para la agregación de registros
- 24224:24224
- 24224:24224/udp
elasticsearch:
image: elasticsearch:8.7.1
expose:
- 9200
environment:
- discovery.type=single-node # Se ejecuta como un solo nodo
- xpack.security.enabled=false
volumes: # Almacena datos de elasticsearch localmente en el volumen Docker esdata
- esdata:/usr/share/elasticsearch/data
kibana:
image: kibana:8.7.1
links: # Vincula el servicio kibana al contenedor de elasticsearch
- elasticsearch
depends_on:
- elasticsearch
ports:
- 5601:5601
environment: # Configuración del host definida
- ELASTICSEARCH_HOSTS=http://elasticsearch:9200
# Define el volumen Docker llamado esdata para el contenedor de Elasticsearch.
volumes:
esdata:
Guarda el archivo presionando Ctrl + X y entrando Y cuando se te pida. Hemos configurado para iniciar tres servicios, uno para cada uno, Fluentd, Elasticsearch y Kibana.
Para Fluentd, construiremos un contenedor en lugar de una imagen lista. Los archivos de construcción para Fluentd se configurarán en el siguiente paso. Hemos montado un directorio para sus archivos de construcción, y un volumen para los archivos de configuración, y expuesto el puerto 24224 en ambos protocolos TCP y UDP para la agregación de registros.
El siguiente servicio es Elasticsearch y estamos usando la última versión disponible en el momento de escribir este tutorial. Lo hemos expuesto a través del puerto 9200 y configurado algunas variables de entorno para que podamos ejecutarlo como un clúster de un solo nodo y hemos deshabilitado las características de seguridad. Esto no se recomienda generalmente, pero habilitar la seguridad está fuera del alcance de este tutorial. También hemos montado un volumen local para los datos de Elasticsearch.
Finalmente, configuramos Kibana y lo exponemos a través del puerto 5601 que se utilizará para acceder al panel. También configuramos una variable para configurar el host de Elasticsearch para que pueda acceder.
Paso 4 - Configurar los archivos de construcción de Fluentd
Crea Fluentd y el directorio de configuración.
$ mkdir fluentd/conf -p
Ejecuta el comando tree para verificar la estructura del directorio.
$ tree
Debería verse como lo siguiente.
Cambia al directorio Fluentd.
$ cd fluentd
Crea y abre el Dockerfile para editar.
$ nano Dockerfile
Pega el siguiente código en él. Este código extrae la imagen Docker de Debian de Fluentd e instala el plugin de 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
Guarda el archivo presionando Ctrl + X y entrando Y cuando se te pida.
Cambia al directorio de configuración.
$ cd conf
Crea y abre el archivo fluentd.conf para editar.
$ nano fluentd.conf
Pega el siguiente código en él.
# vincular fluentd en IP 0.0.0.0
# puerto 24224
@type forward
port 24224
bind 0.0.0.0
# enviar registros al elasticsearch
# el host debe coincidir con el contenedor de elasticsearch
# servicio
@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
Guarda el archivo presionando Ctrl + X y entrando Y cuando se te pida.
La directiva source anterior utiliza el plugin forward que convierte Fluentd en un punto final TCP para aceptar paquetes TCP.
La directiva match busca eventos con etiquetas coincidentes, lo que en este caso significa que coincide con todos los eventos. Usaremos el plugin elasticsearch_dynamic para almacenamiento que permite que los valores de configuración se especifiquen dinámicamente. El campo hosts especifica el nombre de host para la aplicación Elasticsearch, que es el nombre del servicio en el archivo de Docker compose. El logstash_format se establece en verdadero, lo que significa que Fluentd utiliza el formato de nombre convencional logstash-%Y.%m.%dlogstash-%Y.%m.%d. El nombre de prefijo para escribir los eventos se establece en fluend. La variable include_tag_key se establece en verdadero, lo que agrega la etiqueta de Fluentd en el formato JSON. La tag_key es el nombre del campo a extraer para la etiqueta. Establecer la variable include_timestamp en verdadero agrega un campo de marca de tiempo al registro. El flush_interval especifica el intervalo entre los vaciados de datos. También usamos el plugin stdout para imprimir eventos/registros en la salida estándar.
Paso 5 - Ejecutar los contenedores de Docker
Cambia de nuevo al directorio EFK.
$ cd ~/efk
Inicia los contenedores usando el siguiente comando.
$ docker compose up -d
Verifica el estado de los contenedores en ejecución.
Como puedes ver, el contenedor obtuvo 172.23.0.2 como la dirección IP. Ejecuta el siguiente comando para verificar si Elasticsearch está funcionando correctamente.
Ahora que la pila EFK está desplegada, es hora de configurar Kibana. Abre la URL http://:5601 en el navegador.
Haz clic en el botón Explorar por mi cuenta para proceder al panel de Kibana.
Haz clic en el enlace Gestión de pila para configurar la vista de datos de Kibana. Selecciona la opción Kibana >> Vistas de datos en la barra lateral izquierda para abrir la página de vista de datos.
Haz clic en el botón Crear vista de datos para proceder.
Ingresa el nombre de la vista de datos y el patrón de índice como fluentd-*. Asegúrate de que el campo de marca de tiempo esté configurado en @timestamp. El campo de origen se actualizará automáticamente. Haz clic en el botón Guardar vista de datos en Kibana para finalizar la creación de la vista de datos.
A continuación, haz clic en el menú superior (elipsis) y haz clic en la opción Descubrir para mostrar el monitoreo de registros.
Obtendrás la siguiente página confirmando que tu configuración está funcionando perfectamente. Los registros se toman todos de Elasticsearch y se envían por la agregación de registros de Fluentd.
Paso 7 - Instalar Nginx
Ubuntu 22.04 viene con una versión más antigua de Nginx. Necesitas descargar el repositorio oficial de Nginx para instalar la última versión.
El primer paso es instalar el certificado SSL de Let’s Encrypt. Necesitamos instalar Certbot para generar el certificado SSL. Puedes instalar Certbot usando el repositorio de Ubuntu o obtener la última versión usando la herramienta Snapd. Usaremos la versión de Snapd.
Ubuntu 22.04 viene con Snapd instalado por defecto. Ejecuta los siguientes comandos para asegurarte de que tu versión de Snapd esté actualizada.
Verifica el servicio programador de renovación de Certbot.
$ sudo systemctl list-timers
Encontrarás snap.certbot.renew.service como uno de los servicios programados para ejecutarse.
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
Haz una prueba en seco del proceso para verificar si la renovación de SSL está funcionando bien.
$ sudo certbot renew --dry-run
Si no ves errores, estás listo. Tu certificado se renovará automáticamente.
Paso 9 - Configurar Nginx
Crea y abre el archivo de configuración de Nginx para Kibana.
$ sudo nano /etc/nginx/conf.d/kibana.conf
Pega el siguiente código en él. Reemplaza la dirección IP con la dirección IP privada de tu servidor Elasticsearch.
Guarda el archivo presionando Ctrl + X y entrando Y cuando se te pida.
Abre el archivo /etc/nginx/nginx.conf para editar.
$ sudo nano /etc/nginx/nginx.conf
Agrega la siguiente línea antes de la línea include /etc/nginx/conf.d/*.conf;.
server_names_hash_bucket_size 64;
Guarda el archivo presionando Ctrl + X y entrando Y cuando se te pida.
Verifica la configuración.
$ sudo nginx -t
nginx: el archivo de configuración /etc/nginx/nginx.conf tiene una sintaxis correcta
nginx: la prueba del archivo de configuración /etc/nginx/nginx.conf fue exitosa
Reinicia el servicio Nginx.
$ sudo systemctl restart nginx
Hay un paso más necesario. Abre el archivo de Docker compose para editar.
$ nano ~/docker-compose.yml
Pega la línea SERVER_PUBLICBASEURL=https://kibana.example.com bajo la sección de entorno bajo el servicio Kibana como sigue.
environment: # Configuración del host definida
- ELASTICSEARCH_HOSTS=http://elasticsearch:9200
- SERVER_PUBLICBASEURL=https://kibana.example.com
Guarda el archivo presionando Ctrl + X y entrando Y cuando se te pida una vez que hayas terminado.
Detén y elimina los contenedores.
$ docker compose down --remove-orphans
Inicia los contenedores nuevamente con la configuración actualizada.
$ docker compose up -d
Tu panel de Kibana debería ser accesible a través de la URL https://kibana.example.com desde cualquier lugar que desees.
Paso 10 - Ejecutar un contenedor Docker con el controlador de registro Fluentd
Ahora, ejecutaremos un contenedor Docker con el controlador de registro Fluentd, enviando automáticamente registros a la pila. Probaremos usando el contenedor de Nginx.
Extrae la imagen de Nginx del registro de Docker Hub. Estamos usando la versión alpine porque es la versión más pequeña de la imagen.
$ docker pull nginx:alpine
Ejecuta el siguiente comando para crear y comenzar el contenedor de Nginx. Hemos establecido el controlador de registro en Fluentd y el puerto como 8080 porque el puerto predeterminado 80 ya está en uso por el servidor Nginx en modo proxy.
$ docker run --name nginx-fluentd-test -d --log-driver=fluentd -p 8080:80 nginx:alpine
Verifica el estado del contenedor.
$ 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
Ejecuta el siguiente comando para acceder al contenedor de Nginx y generar registros de acceso.
$ curl localhost:8080
¡Bienvenido a nginx!
¡Bienvenido a nginx!
Si ves esta página, el servidor web nginx está instalado y
funcionando correctamente. Se requiere una configuración adicional.
Para documentación y soporte en línea, consulta
nginx.org.
El soporte comercial está disponible en
nginx.com.
Gracias por usar nginx.
Alternativamente, puedes abrir la URL http://:8080 en tu navegador y obtendrás la siguiente página.
Abre el panel de Kibana y haz clic en el enlace Descubrir en el menú de la barra lateral izquierda. Haz clic en el signo + en el menú superior para mostrar el popup de Agregar filtro.
Selecciona el campo container_name del menú desplegable, is como el operador y completa el nombre del contenedor (nginx-fluentd-test) como el valor del campo.
Haz clic en el botón Agregar filtro para visualizar los datos del contenedor de Nginx.
Conclusión
Esto concluye nuestro tutorial sobre la instalación de la pila de registro Elasticsearch, Fluentd y Kibana (EFK) en una máquina Ubuntu 22.04. Si tienes alguna pregunta, publícalas en los comentarios a continuación.
