Después de varias peticiones en el grupo de Telegram, Nasked ha decidido publicar el tutorial para monitorización de dispositivos y nos ha permitido publicarlo, aquí lo tenéis, esperamos que lo disfrutéis.

Hola a todos:

Han sido varios compañeros los que me han pedido que haga este tutorial sobre monitorización, y es que cualquier administrador de sistemas que se precie, querrá tener controlados todos los host, así como sacar datos que le puedan ser útiles para futuras aplicaciones. Dado que hay gente de distintos niveles informáticos, voy a intentar hacer el tutorial lo más entendible para todos.

Esta claro que no todos tenemos la misma configuración, y por tanto las configuraciones que iré mostrando, la tendréis que adaptar a vuestras necesidades.

En mi caso cuento con dos Raspberry (RPI) 2 y 3 respectivamente, en las cuales tengo instalados varios contenedores para diversos fines.

Los contenedores que nos ocupan van a ser tres.

Telegraf: este contenedor se encarga de “leer” los datos de los dispositivos.

InfluxDB: es el contenedor encargado de almacenar la información que le proporciona el / los contenedores Telegraf. Aquí hago un inciso… ¿Por qué Influx?. Influx es una base de datos especializada en Time Series; y esto que es… normalmente en una base de datos podemos almacenar un nombre, un numero, en definitiva un dato “fijo”, los datos que vamos a almacenar nosotros son datos que van variando en el tiempo, y para esto Influx está mejor preparada que otras BBDD.

Grafana: este programa (que lo haremos funcionar en un contenedor) es el encargado de coger los datos de Influx y hacer la representación gráfica de los mismos.

A continuación expongo un esquema de cual es mi estructura, que es la que vamos a monitorizar.

Creo que está claro, pero si hay alguna duda, extiendo la explicación. A grandes rasgos tenemos en la RPI2 un contenedor Telegraf especializado en SNMP para leer los OID de mi router Mikrotik (Esto lo explicaré más adelante). En cada RPI tenemos otros dos contenedores Telegraf especializados en leer los datos de las Raspberry. Quiero destacar el contenedor Telegraf MQTT. Muchos se preguntarán por que este contenedor, cuando podemos mandar los datos desde el contenedor Mqtt a Homeassistant (HA) y que HA nos lo mande a Influx. Pues la respuesta es por lo siguiente; observé cuando trabajaba con HA que cada vez que reiniciaba HA, se me producía un corte en las gráficas del PZEM que tengo monitorizando mi red eléctrica de casa. Para evitar esto se me ocurrió crear un contenedor Telegraf que le pregunte directamente al contenedor Broker de Mqtt, así no tengo que pasar por HA.

Entrando en harina, vamos a empezar con la instalación de los contenedores. Decir que tengo la estructura de directorios igual que se ha realizado en otros muchos tutoriales (/Docker/(Lista de Contenedores). Cada uno tendrá que adaptar la configuración de los contenedores en base a su estructura. Como la RPI 3 ya la tengo entretenida con HA, le dejé el trabajo de monitorización a la RPI2.

Instalación de InfluxDB 

Enlace del contenedor para más info: https://hub.docker.com/_/influxdb

root@BBDD:# cd /docker/infludb

root@BBDD:/docker/influxdb# docker run -p 8086:8086 –name=influxdb –restart=always -v $PWD:/var/lib/influxdb influxdb

También tenemos la opción de crear el contenedor desde la raíz:

root@BBDD:# docker run -p 8086:8086 –name=influxdb –restart=always -v docker/influxdb:/var/lib/influxdb influxdb

Una vez creado el contenedor tenemos que proceder a crear las bases de datos que vayamos a necesitar.

root@BBDD:# docker exec -it influxdb /bin/bash

(el que tenga Portainer también puede acceder al contenedor mediante la consola).

Una vez dentro del contenedor teclearemos:

root@(contenedor)# influx

› create database (nombre de la base de datos, Ej: RPI3 yo tengo home_assistant, rpi2, rpi3, mqtt y mikrotik,pero cada uno que cree las que necesite)

› use  (nombre de la base de datos, esto pondrá en uso la base de datos seleccionada.

Creamos el usuario:

› create user (usuario) with password ‘(password)’ with all privileges

Siguiendo estos pasos crearemos todas las bases de datos necesarias. Entrar en cada base de datos y crear también sus usuarios.

Instalación de Grafana

Enlace del contenedor para más info: https://hub.docker.com/r/grafana/grafana

Yo personalmente Grafana no siempre la tengo ejecutándose, así que le hice un switch en HA para arrancarla cuando sea necesario. La instalación de Grafana la hice en la RPI3, pero cada uno que la haga donde más le guste. No preocuparse por que luego en la configuración interna de Grafana declararemos la ruta donde está o están ubicadas las bases de datos.

root@raspberrypi# docker run -d –name=grafana -p 3000:3000 grafana/grafana

Podremos comprobar si funciona entrando la http://(iphost:3000) y poniendo “admin” en usuario y password. Una vez dentro podremos crear nuestro usuario.

Instalación de Telegraf

Telegraf para lectura de Host y Contenedores.

Ahora con Telegraf, empezamos a entrar ya en harina… comenzaremos monitorizando las RPI’s o la RPI según tengamos una o varias.

Antes de crear el contenedor, comentar que con Telegraf podemos monitorizar tanto nuestras raspberrys como los contenedores docker que en ellas tengamos funcionando. Para ello tendremos que declarar la ubicación del docker.sock en la variable de creación del contenedor.

Instalaremos un contenedor de Telegraf en cada host que queramos monitorizar. La instalación es igual en todos los host, teniendo que cambiar los parámetros de configuración en el archivo telegraf.conf que veremos más adelante.

Enlace del contenedor para más info: https://hub.docker.com/_/telegraf

Para instalar Telegraf  interesa primero que el contenedor nos cree el archivo de configuración. Para crear este archivo teclearemos:

root@rasberrypi#  docker run –rm telegraf telegraf config > telegraf.conf

Ahora cogeremos el archivo telegraf.conf . Normalmente este archivo lo deberemos de dejar en el directorio persistente, quedando su ruta como:

/docker/telegraf/telegraf.conf

Este fichero es muy extenso por que tiene un montón de opciones de configuración, pero a nosotros de momento sólo nos interesa monitorizar nuestra RPI. Yo voy a pegar mi fichero de configuración donde declaro únicamente las variables que he necesitado. No obstante el que quiera puede trabajar con el fichero que nos ha creado el contenedor y ver todas sus variables. Con el mismo fichero podremos hacer que Télegraf nos monitorice el host o también el contenedor.

Si queremos monitorizar sólo los host, el fichero llegará a los parámetros “Input Plugins”, si queremos monitorizar también los contenedores, crearemos el fichero completo tal y como se muestra a continuación.

telegraf.conf (para leer Host y Dockers)

   interval = "10s"
   round_interval = true
   metric_batch_size = 1000
   metric_buffer_limit = 10000
   collection_jitter = "0s"
   flush_interval = "10s"
   flush_jitter = "0s"
   precision = ""
   debug = false
   quiet = false
   logfile = ""
   hostname = ""
   omit_hostname = false
###############################################################################
#                            OUTPUT PLUGINS                                   #
###############################################################################
[[outputs.influxdb]]
  urls = ["http://(iphost donde esté influxdb):8086"]
  database = "(nombre de la BBDD que hayamos creado EJ: rpi3 para almacenar los datos de mi rpi3"
  skip_database_creation = true
  username = "(usuario que hayamos creado en la BBDD correspondiente)"
  password = "(password del usuario que hayamos creado en la BBDD correspondiente)"
  user_agent = "telegraf"

###############################################################################
#                            INPUT PLUGINS                                    #
###############################################################################

# Read metrics about cpu usage
[[inputs.cpu]]
  percpu = true
  totalcpu = true
  collect_cpu_time = false

[[inputs.disk]]
  mount_points = ["/"]
  ignore_fs = ["tmpfs", "devtmpfs"]

[[inputs.kernel]]
[[inputs.mem]]
[[inputs.processes]]
[[inputs.swap]]
[[inputs.system]]
[[inputs.net]]
  interfaces = ["eth0"]
[[inputs.netstat]]
[[inputs.file]] 
  files = ["/sys/class/thermal/thermal_zone0/temp"]
  name_override = "cpu_temperature"
  data_format = "value"
  data_type = "integer"
###############################################################################
#                            INPUT DOCKERS                                    #
###############################################################################

[[inputs.docker]]
  
  endpoint = "unix:///var/run/docker.sock"
  gather_services = false
  container_names = []
  container_name_include = []
  container_name_exclude = []
  timeout = "5s"
  perdevice = true
  total = false
  docker_label_include = []
  docker_label_exclude = []
  tag_env = ["JAVA_HOME", "HEAP_SIZE"] 

Una vez que hemos terminado de configurar el fichero telegraf.conf procedemos a levantar el contenedor.

Dos observaciones:

• En la primera variable indicamos donde está el fichero telegraf.conf pero después hay que declararlo dentro del contenedor en su posición normal. Este punto lo veremos más en detalle en los otros contenedores.

• La segunda variable es la que nos permitirá que el contenedor pueda leer los parámetros de Docker para sacar información de ellos.

Si todo ha ido bien, en la consola de Telegraf debe salirnos algo así:

2019-06-10T15:09:38Z I! Starting Telegraf 1.10.4
2019-06-10T15:09:38Z I! Using config file: /etc/telegraf/telegraf.conf
2019-06-10T15:09:38Z I! Loaded inputs: disk swap system net netstat cpu kernel mem processes file docker
2019-06-10T15:09:38Z I! Loaded aggregators: 
2019-06-10T15:09:38Z I! Loaded processors: 
2019-06-10T15:09:38Z I! Loaded outputs: influxdb
2019-06-10T15:09:38Z I! Tags enabled: host=raspberrypi
2019-06-10T15:09:38Z I! [agent] Config: Interval:10s, Quiet:false, Hostname:"raspberrypi", Flush Interval:10s

Y si entramos en el contenedor de InfluxDB deben haberse creado las tablas y los datos que estamos extrayendo con Telegraf. Adjunto una captura de mi BBDD de la RPI3 (observar los comandos usados)

root@BBDD:~# docker exec -it influxdb /bin/bash
 root@4758ee3fe82e:/# influx
 Connected to http://localhost:8086 version 1.7.6
 InfluxDB shell version: 1.7.6
 Enter an InfluxQL query
   >show databases
   name: databases
   name
   _internal
   home_assistant
   rpi2
   rpi3
   mikrotik
   mqtt
   >use rpi3
   Using database rpi3
   >show measurements
   name: measurements
   name
   cpu
   cpu_temperature
   disk
   docker
   docker_container_blkio
   docker_container_cpu
   docker_container_mem
   docker_container_net
   docker_container_status
   kernel
   mem
   net
   netstat
   processes
   swap
   system

Podemos ver como Telegraf ha creado automáticamente todas las tablas de datos tanto de la RPI como del docker que hay en ella. Luego veremos en Grafana que los datos de las tablas son más extensos de lo que aquí aparecen.

La entrada Tutorial: Monitorización de Dispositivos se publicó primero en Domótica en Casa.