Monitorización de aplicaciones usando ELK Stack

Uno de los mecanismos más utilizados para la monitorización de los sistemas y/o aplicativos de
una compañía es el uso de ELK Stack: Elasticsearch, Logstash y Kibana. En Enimbos hemos
utilizado ELK Stack para el desarrollo de herramientas de monitorización por logs. ELK Stack
presenta la ventaja de poderse desplegar como SaaS sobre los principales proveedores Cloud del
mercado.

Elastic Stack es un conjunto de herramientas open source desarrolladas por Elastics que permite
recoger datos de cualquier tipo de fuente y en cualquier formato para realizar búsquedas, análisis
y visualización de los datos en tiempo real.

Está formado por los siguientes productos:

 Elasticsearch: motor de búsquedas distribuido construido sobre Apache Lucene. Permite

indexar y recuperar documentos JSON (sin esquema rígido) en distintos formatos. Está
basado en Java y proporciona un interfaz RESTFUL de acceso.
 Logstash: es un motor que permite recolectar datos de distintas fuentes, normalizarlos y
distribuirlos. Originalmente optimizado para ficheros de logs, si bien puede leer datos de
muchos tipos de fuentes.
 Kibana: herramienta que permite la visualización y exploración en tiempo real de grandes
cantidades de datos. A través de la representación gráfica permite consultar de forma
sencilla conjuntos complejos de datos.
 Beats: son cargadores de datos que se instalan en servidores y funcionan como agentes que
envían información operacional a Elasticsearch.

Elastic Stack permite la obtención de datos a partir de ficheros de logs mediante Logstash y su
almacenamiento en el motor de búsquedas y análisis Elasticsearch. Además, permite la
visualización, monitorización y explotación de datos en tiempo real mediante Kibana.
Por otro lado, proponemos la inclusión de ElastAlert, una herramienta open source que se integra
con Elastic Stack y permite detectar anomalías e inconsistencias en los datos de Elasticsearch y
lanzar alertas.

El conjunto de herramientas Elastic Stack más ElastAlert nos permite crear un sistema de
monitorización para la extracción, almacenamiento y explotación de los datos de los procesos o
sistemas a monitorizar. Permite la obtención de datos a partir de ficheros de logs mediante
Logstash y su almacenamiento en el motor de búsquedas y análisis Elasticsearch. Además,
permite la visualización, monitorización y explotación de datos en tiempo real mediante Kibana y
la configuración de alertas con ElastAlert.

Para almacenar los datos en Elasticsearch, Logstash utiliza el plugin Elasticseach output que
permite enviar los datos vía http(s). Elasticsearch se encargará de indexar los datos obtenidos de
los logs y permitir la búsqueda y análisis de los mismos.

Integración de Datos

Proponemos el uso de la herramienta Logstash para la extracción de datos de los ficheros de logs
de los sistemas. Logstash es una herramienta de lado servidor que nos permite recolectar datos
de múltiples fuentes simultáneamente, transformarlos y almacenarlos en un motor de búsquedas
y análisis, en este caso Elasticsearch. Está desarrollada en JRuby y funciona sobre una JVM.

Logstash basa su funcionamiento en la definición e integración de entradas, códecs, filtros y

salidas:
 Las entradas son las distintas fuentes de datos. En nuestro caso usaremos como entradas los
ficheros de logs generados por los distintos componentes de la Plataforma 24Online.
 Los códecs se utilizan para convertir los distintos formatos de las entradas en otro aceptado
por Logstash, lo que nos permitirá unificar el formato de los logs y tener la posibilidad de
leer formatos que no sean texto plano.
 Los filtros nos permiten procesar distintos eventos.
 Las salidas son los distintos destinos en los que se almacenarán los datos ya procesados
Logstash se basa en el uso de plugins que soportan los distintos elementos de la herramienta
mencionados: entradas, códecs, filtros y salidas.

Normalmente, esta carga de ficheros de logs mediante Logstash se realizará mediante ssh,
aunque también podrán usarse Beats de tipo FileBeat para enviar las líneas de ficheros de logs
para su carga en Elasticsearch. En todo caso, Logstash dispone de un gran conjunto de plugins
para la entrada de datos:

 Beats: datos de Elastic Beats

 Elasticsearch: resultados de consultas a Elasticsearch
 Exec: salida de comandos
 File: ficheros
 http: datos recibidos por http o https
 jdbc: datos de BBDD
 pipe: datos de un comando pipe
 tcp: datos recibidos por un socket tcp

Por otro lado, es posible realizar la recolección de métricas de para así poder monitorizar y
visualizar los datos operativos en un cuadro de mando. Enimbos propone el uso de Elastic Beats
para la recolección de dichas métricas y su almacenamiento en Elasticsearch.

Elastic Beats es una herramienta que forma parte de Elastic Stack. Se trata de agentes ligeros que
envían datos de las máquinas a Logstash o a Elasticsearch. Hay distintos tipos:

 Filebeat: permite la recolección, parseo y envío de datos de ficheros logs.

 Metricbeat: permite la recolección y envío de métricas a nivel de sistema, como uso de CPU,
uso de memoria, sistema de ficheros, accesos a disco, accesos a red, etc.
 Packetbeat: permite la monitorización de servicios y aplicaciones en tiempo real,
obteniendo métricas como latencia, tiempos de respuesta, errores, patrones de acceso,
transacciones, accesos HTTP, etc.
 Winlogbeat: permite la recolección y envío de eventos del log de sistemas Windows.
 Auditbeat: permite la recolección y envío de métricas de auditoría de sistemas.
 Heartbeat: permite la monitorización de la disponibilidad y tiempo de respuestas de
servicios.

Todos los datos recolectados tanto por Logstash como por Beats se integran en Elasticsearch.
Elasticsearch es un motor de búsqueda y análisis distribuido basado en JSON que posee un
interfaz RESTful, que nos permite consultar cualquier tipo de dato en tiempo real.

Al ser un sistema distribuido, permite desplegarse en una arquitectura escalable y de alta

disponibilidad. Permite el uso de distintos índices en un cluster y realizar las consultas sobre uno
o más índices en modo Full Text Search. Además, indexa todos los campos de los documentos
JSON sin esquema rígido. Permite búsquedas vía API REST mediante ElasticSearch Query DSL
(Domain Specific Language): multilenguaje, geolocalización, contextual, autocompletar, etc.

En cuanto a la infraestructura, Elasticsearch es un sistema distribuido que puede ser desplegado

en clúster sobre uno o varios nodos. Hay distintos tipos de nodos en Elasticsearch:

 Nodos maestros que controlan el clúster

 Nodos de datos que mantienen los datos y efectúan las operaciones sobre los mismos
 Nodos cliente que son pequeños balanceadores que intervienen en determinados pasos del
procesamiento
 Nodos ‘Ingest’ dedicados a operaciones pesadas de transformación de datos
 Nodos ‘Tribe’ que pueden realizar operaciones de coordinación entre nodos y clúster
Visualización de Datos

Proponemos el uso Kibana para la visualización de los datos de la herramienta de monitorización

por logs en cuadros de mando o dashboards. Kibana es una herramienta que permite visualizar y
navegar de forma interactiva por los datos almacenados por Elasticsearch.

Kibana permite obtener y representar los siguientes tipos de información:

 Histogramas, gráficos de barras, gráficos de tarta, etc.

 Visualizar datos con información geoespacial en mapas.
 Análisis de series de datos en el tiempo.
 Gráficos de relaciones de datos.

Los cuadros de mando de Kibana realizan consultas a Elasticsearch para obtener en tiempo real el
valor de los KPIs mostrados. Las siguientes figuras muestran algunos ejemplos de dashboards
desarrollados con Kibana que nos dan una idea de las posibilidades de la herramienta.
Algún ejemplo de dashboards de métricas de infraestructura son:
Alertas

La herramienta de monitorización debe ser capaz de identificar desviaciones en el

funcionamiento normal de la plataforma y lanzar alertas para notificar dichas desviaciones. Para
ello proponemos usar ElastAlert.

ElastAlert es una herramienta open source que se integra con Elastic Stack y permite detectar y
alertar anomalías e inconsistencias en los datos de Elasticsearch. Se basa en el uso de dos tipos
de componentes, reglas y alertas. La herramienta consulta de forma periódica Elasticsearch
enviando los datos obtenidos a las reglas que determinan si se encuentra una anomalía. Una vez
encontrada, se notifica por medio de una o más alertas.

Algunas de las reglas que se pueden crear con ElastAlert son:

 Incremento o decremento de parámetros, que nos servirá para alertar sobre el uso de CPU,
de memoria, etc.
 Aumento de la frecuencia de eventos, que nos servirá para alertar sobre un aumento de la
tasa de errores en determinados componentes
 Valores concretos en determinados campos, que nos servirá para alertar de caídas de
sistemas
Por otro lado, ElastAlert dispone de un gran número de canales para el envío de alertas: Email,
Jira, comandos, OpsGenie, etc. Las reglas y alertas se pueden administrar directamente en
Kibana.

Ejemplo de indexación y gráfica

Vamos a usar como ejemplo una aplicación que genera un log con la siguiente estructura:

2018-11-12 06:00:23 INFO client_1 server_1 service_1 1564 OK message

El log consiste en una serie de llamadas a servicios que pueden estar en uno o varios servidores.
Para el ejemplo supondremos que tenemos que agregar la información para poder consultar el
tiempo total de las distintas invocaciones de un cliente a un mismo servidor y conocer el
resultado de la operación.
Se utiliza un FileBeat para recolectar y enviar las líneas de log generadas por la aplicación. La
configuración relevante de FileBeat está en el fichero filebeat.yml y sería la siguiente:

 paths:
– C:\Formacion\ELK\ejemplo.log
 output.logstash:
# The Logstash host and port

hosts: [«host:port»]

Los eventos de log serían enviados a Logstash, cuya configuración se realizaría en el fichero
logstash.conf. En dicho fichero se habilitarían y configurarían los distintos plugins necesarios para
procesar y formatear el log, generando un documento JSON que se indexaría en ElasticSearch.

 En primer lugar, hay que configurar la recepción de los eventos desde el FileBeat:

input {

beats {

port => » port»

client_inactivity_timeout => 6000

 Para llevar a cabo el parseo de la línea de log que usamos como ejemplo, usaremos tres
plugins:
 Grok, nos permite parsear y estructurar texto arbitrario en datos estructurados,
indexables y consultables.

grok {

match => { «message» =>

«%{TIMESTAMP_ISO8601:requestDate} %{WORD:levelDebug} %{DATA:client} %{DAT
A:server} %{DATA:service} % {NUMBER:requestTime:int}%{DATA:
result} (?<message>(.|\r|\n)*)

}
Como vemos, consiste en combinar patrones de texto para obtener coincidencias con las líneas
de logs. Un patrón de texto es %{SYNTAX:SEMANTIC}, donde sintaxis es el nombre del patrón y
semántica el identificador que damos al fragmento.

 Date, que nos permite parsear fechas y usarlas como timestamp de los eventos.

date {

match => [ » requestDate», «YYYY-MM-dd HH:mm:ss» ]

target => » requestDate»

 Aggregate, permite agregar información disponible en un conjunto de eventos (líneas de log)

e incorporar información agregada a un evento final.

aggregate {

task_id => «%{client}%{server}»

code => «map[‘requestDate’] = event.get(‘requestTime’);

map[‘levelDebug’] = event.get(‘levelDebug’);

map[‘client’] = event.get(‘client’);

map[‘server’] = event.get(‘server’);

map[‘service’] = ‘all’;

map[‘requestTime’] ||= 0 ; map[‘requestTime’] += event.get(‘requestTime’)

if map[‘result’] != ‘KO’

map[‘result’] = event.get(‘result’);

end;

map[‘message’] = event.get(‘message’);

map[‘lastService’] = event.get(‘service’);

push_map_as_event_on_timeout => true

timeout => 60 # 1 minute timeout

}
Mediante el atributo task_id indicamos la clave de las líneas de log que se van a agregar. En el
atributo code del plugin damos valor a los atributos del evento agregado que se va a indexar en
elasticsearch. Los atributos push_map_as_event_on_timeout y timeout se utilizan para indicar
que 60 segundos después de recibir la última entrada de log con la clave «%{client}%{server} se
generará e indexará el evento agregado.

Por último, es necesario configurar el cluster ElasticSearch y la estructura de indexación en que se

almacenarán los logs.

elasticsearch {

hosts => [ «http://localhost:9200» ]

index => «ejemplo-%{+YYYY.ww.ee}»

Con esta configuración se creará un índice diario en Elasticsearch para documentos de logs del
aplicativo. Para empezar a monitorizar los datos indexados en kibana en necesario generar un
patrón de índices que incluya los índices diarios generados:

A partir de este momento podemos empezar a crear gráficas y consultar los datos en kibana:
Por último, podemos utilizar los eventos indexados por el plugin aggregate de logstash para crear
una gráfica que permita visualizar la información agregada acerca de las invocaciones de los
distintos clientes a los distintos servidores. Para el ejemplo vamos a utilizar una gráfica de barras
que muestre el tiempo total:

 En primer lugar usaremos un filtro sobre el campo lastService, que únicamente poseen
los eventos agregados.
 En el eje X usaremos el sumatorio del campo requestTime, que nos dará el sumatorio del
tiempo de invocación de un cliente a un servidor.

 En el eje y usamos dos agregaciones, por un lado por el campo cliente y por otro por el
campo servidor.
El resultado de la gráfica sería el siguiente:
Recolección de métricas: FileBeat, ElasticSearch y Kibana

Elastic stack, es el conjunto de tres aplicaciones complementarias entre sí que coordinadamente se

dedican a recoger estadísticas y representar gráficas sobre el rendimiento de nuestros equipos. El
esquema que vamos a realizar va a ser el siguiente:

Tenemos varios clientes con FileBeat ejecutándose y mandando datos a ElasticSearch que será nuestro
servidor de base de datos, estos parámetros serán interpretados por Kibana en forma de gráficos.

Instalación de Java:

Los programas que vamos a utilizar están escritos en java, por lo que tendremos que tenerlo en nuestro
sistema :

sudo apt install default-jdk

sudo apt install default-jre

Comprobamos la instalación:

root@mushu:~# java -version

openjdk version "1.8.0_151"

OpenJDK Runtime Environment (build 1.8.0_151-8u151-b12-1~deb9u1-b12)

OpenJDK 64-Bit Server VM (build 25.151-b12, mixed mode)

Instalación de ElasticSearch:
El primer paso será instalar la clave para ElasticSearch:
$ wget -qO - https://artifacts.elastic.co/GPG-KEY-elasticsearch | sudo apt-key add -

Añadimos el repositorio:

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

/etc/apt/sources.list.d/elastic-6.x.list

Ahora tenemos que instalarnos un paquete necesario para descargar nuestros beats:

apt install apt-transport-https

E instalamos ElasticSearch:

apt update && apt install elasticsearch

Ahora vamos a activar el servicio:

systemctl enable elasticsearch && systemctl start elasticsearch

Para comprobar que el servicio está escuchando le hacemos una petición:

curl localhost:9200

Ahora una vez veamos que nos contesta, debemos de permitir las peticiones desde cualquier dirección IP,
para ello debemos configurar lo siguiente:

# ---------------------------------- Network -----------------------------------

# Set the bind address to a specific IP (IPv4 or IPv6):

#network.host: 0.0.0.0

Y permitiremos las peticiones desde cualquier dirección, debemos de tener en cuenta que si tenemos
ELasticSearch en una máquina con poca memoria, puede que esto nos falle, pues la Ram sea
insuficiente para abrir sockets.

Instalación de FileBeat:
Filebeat, se trata de un software escrito en go que va recopilando todos los logs de los ficheros que le
indiquemos y los envía a nuestra base de datos elasticsearch.

Instalación :

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

Para instalar filebeat necesitaremos el repositorio de elastic:

Creamos en /etc/yum.repos.d/ un fichero con extensión .repo de donde vamos a conseguir el paquete:

[elastic-7.x]

name=Elastic 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

yum install filebeat

Una vez que lo instalemos tenemos nuestro fichero de configuración en /etc/filebeat/filebeat.yml

root@mickey# less /etc/filebeat/filebeat.yml | tr -d ' '|grep -Eiv '^#|^$'

filebeat.prospectors:

-type:log

enabled:true

paths:

-/var/log/syslog

-/var/log/auth.log

filebeat.config.modules:

path:${path.config}/modules.d/*.yml

reload.enabled:false

setup.template.settings:

index.number_of_shards:3

setup.dashboards.enabled:true

setup.kibana:

host:"localhost:5601"

output.logstash:

hosts:["10.0.0.15:9200"]

Pasamos a comentar los aspectos más importantes, de la configuración que debemos de modificar:
filebeat.prospectors: Aquí pondremos los ficheros que queremos analizar y centralizar, en mi caso será
el syslog y el auth.log.

setup.dashboards.enabled: No es necesario tenerlo en true en todos los nodos, ya que exportando solo
una vez los dashboards es suficiente.

setup.kibana: La ubicación de kibana.

output.logstash: El apartado más importante ya que le indicamos donde tiene que volcar los logs.

Una vez lo tenemos configurado, tenemos que activar el modulo system en filebeat para que empiece la
recolección:

filebeat modules enable system

Para comprobar su funcionamiento ejecutamos:

filebeat -e -v -c filebeat.yml

Si con la ejecución nos salen las siguientes lineas:

2018/01/15 17:57:10.603682 harvester.go:215: INFO Harvester started for file: /var/log/auth.log

2018/01/15 17:57:10.604003 harvester.go:215: INFO Harvester started for file: /var/log/syslog

Significa que todo va bien y los “granjeros” han empezado a recolectar log de los ficheros.

Instalación Kibana:
El último paso es la instalación de Kibana para ver las gráficas de la recolección, para ello seguimos los
mismos pasos que anteriormente si lo ejecutáis en otro nodo :

apt update && apt install kibana

La configuración que realizaremos en Kibana es de que máquina va a obtener las consultas para
mostrarnos la información y desde que dirección puede recibir peticiones:

server.host: "0.0.0.0"

elasticsearch.url: "http://10.0.0.15:9200"
Tenemos que activar e iniciar el servicio:

systemctl enable kibana && systemctl start kibana

Por defecto Kibana escucha en el puerto 5601. Cuando entremos, nos indicará que las consultas que
realizará serán por el patrón de logstash-* y la ordenación por @timestamp:

Os dejo una galería de Kibana en funcionamiento:

En este caso utilizaremos un beat diferente,

Una vez tengamos esto, operativo, tendremos que crear el patrón de búsqueda de kibana:

Esto deberemos de agruparlo por @timestamp y una vez realizado eso, nos dirigimos a la pestaña
discover:

Vemos que estamos recibiendo los logs de las máquinas que hemos recibido, y la representación gráfica
quedará así:
Pero, entre tanto log, podemos navegar entre cientos de líneas sin importancia para encontrar un mensaje
de error, para ello Kibana nos proporciona poder filtrar el campo system.syslog.message con la sintaxis
de lucene:

system.syslog.message : *Err*

Aquí tendríamos contemplados todos los mensajes de log que que incluyeran esa palabra en su
contenido.

Posibles errores:

1- No poder arrancar el prospector porque ya hay uno en marcha, en ese caso debemos de eliminar el
fichero registry que ha creado nuestro filebeat:

rm /var/lib/filebeat/registry

2- Kibana no muestra ninguna gráfica, en este caso debemos:

 Eliminar el Index Pattern

 Verificar si tenemos el fichero de syslog y auth.log

 Volver a crear el Index Pattern