Tutorial: Monitorización de Dispositivos

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.

1 2 3 4 5

docker run --net=host \ > --name=telegraf \ > -v /docker/telegraf/telegraf.conf:/etc/telegraf/telegraf.conf:ro\ > -v /var/run/docker.sock:/var/run/docker.sock \ > telegraf

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.

Este es un ejemplo de datos extraídos de mi RPI3. Podemos configurar en Grafana alertas; Ej: la temperatura de la CPU.

 

Datos extraídos de cada docker que tengo en cada RPI, con su correspondiente Telegraf.

Telegraf para lectura del Broker Mqtt

Siguiendo con la instalación de nuestros contenedores Telegraf, vamos a configurar ahora el que nos va a leer directamente del broker de mqtt, el cual también es un contenedor.

Este contenedor lo llamaremos ahora mqtttelegraf para diferenciarlo del otro. Yo en cuestión lo tengo instalado en la RPI2 y lee del brocker mqtt que está en la RPI3. La instalación del contenedor es exactamente igual que el anterior con la salvedad de la ruda del fichero telegraf.conf, pero primero si no queremos liarnos, cogemos el telegraf.conf que habíamos editado antes y lo modificamos.

Aquí lo característico de este fichero es la parte de mqtt. Habrá que sacar el topic que queremos extraer; para ello podemos usar programas como mqtt.fx (del cual hay un tuto al respecto). Y luego hay que sacar las “keys” que queremos leer. Observar que los datos se sacan preformateados a “JSON”, cuidado no sacarlos en formato Influx por que no los entiende. Yo lo probé y daba error en la base de datos.

telegraf.conf (para leer broker de mqtt, en este caso un pzem)

 [global_tags]
[agent]
  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://10.17.17.4:8086"]
  database = "mqtt"
  skip_database_creation = false
  username = "root"
  password = "ea5alg"
  user_agent = "telegraf"

###############################################################################
#                            INPUT PLUGINS MQTT                               #
###############################################################################

[[inputs.mqtt_consumer]]
  servers = ["tcp://ipdelbroker:1883"]
  qos = 0
  connection_timeout = "30s"
  topics = [
    "tele/contador/SENSOR",
  ]
  persistent_session = false
  client_id = "contador"
  username = "userdelbroker"
  password = "password del broker"
  data_format = "json"
  tag_keys = [
    "Total",
    "Yesterday",
    "Today",
    "Power",
    "ApparentPower",
    "ReactivePower",
    "Factor",
    "Voltage",
    "Current"
  ]

El comando para su instalación sería:

docker run --net=host \
   --name=telegraf \
   -v /docker/mqtttelegraf/telegraf.conf:/etc/telegraf/telegraf.conf:ro\
   telegraf

Observar que el fichero telegraf.conf está en el directorio mqtttelegraf, pero dentro del contenedor la ruta tenemos que dejar la suya, de no hacerse así, al arrancar Telegraf nos daría un fallo.

Con esto ya tenemos monitorizando el broker…Para guardar sus datos si veis arriba cuando hemos sacado las bases de datos de influxdb, tengo una que se llama mqtt. Con los mismos comandos podemos ver las tablas que nos ha creado Telegraf. Con estos datos he creado la monitorización de mi PZEM con los consumos eléctricos.

Esta pantalla es una unión entre datos recolectados de HA y del PZEM

Telegraf para la lectura SNMP de dispositivos.

Para aquellos que no lo sepan, SNMP es un protocolo simple de administración de dispositivos, que nos permite extraer información de estos. https://es.wikipedia.org/wiki/Protocolo_simple_de_administraci%C3%B3n_de_red

Este protocolo lo tienen infinidad de dispositivos como switches, routers, tarjetas de red, PC’s etc, etc. Para poder leer los datos, el dispositivo tiene que tener activado el servicio SNMP. De no tenerlo, en muchas ocasiones, sobre todo si tienen sistemas linux embebidos, se les puede instalar, dígase el caso por ejemplo de OpenWRT u otros…

No quiero hacerme muy extenso en el tema así que voy a comentarlo muy por encima; si alguien necesita más información puede dejarme un comentario. Cada dato de un dispositivo está representado por una serie de números organizados de forma jerárquica, estableciéndose muchos de ellos por reglas RF y el resto más específicos los proporciona el fabricante. Estos números son los OID; así por ejemplo un OID tiene esta forma: “.1.3.6.1.4.1.14988.1.1.3.14.0” este en cuestión muestra la información de la CPU de mi router. Toda esta información la recopilan los fabricantes de cada dispositivo en un fichero llamado MIB. Estos MIB pueden ser vistos con programas como el “ManageEngine MIBBrowser” que es el que yo uso. Podemos cargar el fichero MIB y sacar información mediante en SNMPWalk de todos los OID que tiene el dispositivo.

Bueno, pues una vez que tenemos el listado de los OID que nos interesan, del dispositivo en cuestión, procederemos a modificar nuestro telegraf.conf. Mi consejo es crear un contenedor telegraf por cada dispositivo que queramos monitorizar, de lo contrario se nos puede hacer muy extenso el fichero de configuración y podríamos tener conflictos. También decir que si son muchos los dispositivos a monitorizar hay otras herramientas para tal fin como “LibreNMS” que hacen mejor esta función; pero bueno aquí se trata de monitorizar uno o dos dispositivos que tengamos en casa (router, Nas, etc).

Pues los pasos son los mismos… editar el telegraf.conf de la siguiente manera (NOTA: este fichero es para monitorizar un router Mikrotik, para otros dispositivos hay que cambiar los OID y resto de parámetros).

 # Global tags can be specified here in key="value" format.
[global_tags]
[agent]
 
  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                                   #
###############################################################################

# Configuration for sending metrics to InfluxDB
[[outputs.influxdb]]
  urls = ["http:/ipdeinfluxdb:8086"]
  database = "nombre de la base de datos"
  skip_database_creation = false
  ## HTTP Basic Auth
  username = "usuario base de datos"
  password = "password base de datos"
  ## HTTP User-Agent
  user_agent = "telegraf"

###############################################################################
#                            INPUT PLUGINS MIKROTIK                           #
###############################################################################

[[inputs.snmp]]
  agents = [ "10.17.17.1:161" ] # 

  [[inputs.snmp.field]]
    name = "hostname"
    oid = ".1.3.6.1.2.1.1.5.0"
    is_tag = true
  [[inputs.snmp.field]]
    name = "uptime"
    oid = ".1.3.6.1.2.1.1.3.0"
  [[inputs.snmp.field]]
    name = "cpu-frequency"
    oid = ".1.3.6.1.4.1.14988.1.1.3.14.0"
  [[inputs.snmp.field]]
    name = "cpu-load"
    oid = ".1.3.6.1.2.1.25.3.3.1.2.1"
  [[inputs.snmp.field]]
    name = "active-fan"
    oid = ".1.3.6.1.4.1.14988.1.1.3.9.0"
  [[inputs.snmp.field]]
    name = "voltage"
    oid = ".1.3.6.1.4.1.14988.1.1.3.8.0"
  [[inputs.snmp.field]]
    name = "temperature"
    oid = ".1.3.6.1.4.1.14988.1.1.3.10.0"
  [[inputs.snmp.field]]
    name = "processor-temperature"
    oid = ".1.3.6.1.4.1.14988.1.1.3.11.0"
  [[inputs.snmp.field]]
    name = "current"
    oid = ".1.3.6.1.4.1.14988.1.1.3.13.0"
  [[inputs.snmp.field]]
    name = "fan-speed"
    oid = ".1.3.6.1.4.1.14988.1.1.3.17.0"
  [[inputs.snmp.field]]
    name = "fan-speed2"
    oid = ".1.3.6.1.4.1.14988.1.1.3.18.0"
  [[inputs.snmp.field]]
    name = "power-consumption"
    oid = ".1.3.6.1.4.1.14988.1.1.3.12.0"
  [[inputs.snmp.field]]
    name = "psu1-state"
    oid = ".1.3.6.1.4.1.14988.1.1.3.15.0"
  [[inputs.snmp.field]]
    name = "psu2-state"
    oid = ".1.3.6.1.4.1.14988.1.1.3.16.0"

  # Interfaces
  [[inputs.snmp.table]]
    name = "snmp-interfaces"
    inherit_tags = ["hostname"]
    [[inputs.snmp.table.field]]
      name = "if-name"
      oid = ".1.3.6.1.2.1.2.2.1.2"
      is_tag = true
    [[inputs.snmp.table.field]]
      name = "mac-address"
      oid = ".1.3.6.1.2.1.2.2.1.6"
      is_tag = true

    [[inputs.snmp.table.field]]
      name = "actual-mtu"
      oid = ".1.3.6.1.2.1.2.2.1.4"
    [[inputs.snmp.table.field]]
      name = "admin-status"
      oid = ".1.3.6.1.2.1.2.2.1.7"
    [[inputs.snmp.table.field]]
      name = "oper-status"
      oid = ".1.3.6.1.2.1.2.2.1.8"
    [[inputs.snmp.table.field]]
      name = "bytes-in"
      oid = ".1.3.6.1.2.1.31.1.1.1.6"
    [[inputs.snmp.table.field]]
      name = "packets-in"
      oid = ".1.3.6.1.2.1.31.1.1.1.7"
    [[inputs.snmp.table.field]]
      name = "discards-in"
      oid = ".1.3.6.1.2.1.2.2.1.13"
    [[inputs.snmp.table.field]]
      name = "errors-in"
      oid = ".1.3.6.1.2.1.2.2.1.14"
    [[inputs.snmp.table.field]]
      name = "bytes-out"
      oid = ".1.3.6.1.2.1.31.1.1.1.10"
    [[inputs.snmp.table.field]]
      name = "packets-out"
      oid = ".1.3.6.1.2.1.31.1.1.1.11"
    [[inputs.snmp.table.field]]
      name = "discards-out"
      oid = ".1.3.6.1.2.1.2.2.1.19"
    [[inputs.snmp.table.field]]
      name= "errors-out"
      oid= ".1.3.6.1.2.1.2.2.1.20"

  # Wireless interfaces
  [[inputs.snmp.table]]
    name = "snmp-wireless-interfaces"
    inherit_tags = ["hostname"]
    [[inputs.snmp.table.field]]
      name = "ssid"
      oid = ".1.3.6.1.4.1.14988.1.1.1.3.1.4"
      is_tag = true
    [[inputs.snmp.table.field]]
      name = "bssid"
      oid = ".1.3.6.1.4.1.14988.1.1.1.3.1.5"
      is_tag = true
    
    [[inputs.snmp.table.field]]
      name = "tx-rate"
      oid = ".1.3.6.1.4.1.14988.1.1.1.3.1.2"
    [[inputs.snmp.table.field]]
      name = "rx-rate"
      oid = ".1.3.6.1.4.1.14988.1.1.1.3.1.3"
    [[inputs.snmp.table.field]]
      name = "client-count"
      oid = ".1.3.6.1.4.1.14988.1.1.1.3.1.6"
    [[inputs.snmp.table.field]]
      name = "frequency"
      oid = ".1.3.6.1.4.1.14988.1.1.1.3.1.7"
    [[inputs.snmp.table.field]]
      name = "band"
      oid = ".1.3.6.1.4.1.14988.1.1.1.3.1.8"
    [[inputs.snmp.table.field]]
      name = "noise-floor"
      oid = ".1.3.6.1.4.1.14988.1.1.1.3.1.9"
    [[inputs.snmp.table.field]]
      name = "overall-ccq"
      oid = ".1.3.6.1.4.1.14988.1.1.1.3.1.10"
  # Memory usage (storage/RAM)
  [[inputs.snmp.table]]
    name = "snmp-memory-usage"
    inherit_tags = ["hostname"]
    [[inputs.snmp.table.field]]
      name = "memory-name"
      oid = ".1.3.6.1.2.1.25.2.3.1.3"
      is_tag = true
    [[inputs.snmp.table.field]]
      name = "total-memory"
      oid = ".1.3.6.1.2.1.25.2.3.1.5"
    [[inputs.snmp.table.field]]
      name = "used-memory"
      oid = ".1.3.6.1.2.1.25.2.3.1.6"

Yo he creado una base de datos llamada mikrotik en mi InfluxDB, y de la misma forma que las anteriores cuando tenga en funcionamiento el contenedor, podré ver los datos que extraemos.

Para crear el contenedor (el mio está en la PI2) lo haremos igual que el anterior.

 docker run --net=host \
   --name=telegraf \
   -v /docker/mktttelegraf/telegraf.conf:/etc/telegraf/telegraf.conf:ro\
   telegraf

Observar que aquí telegraf.conf esta en el directorio mktttelegraf, así tengo cada configuración en su correspondiente directorio.

Con el contenedor ya funcionando podemos tener datos interesantes de nuestros dispositivos.

Datos del router Mikrotik

Bueno, pues con esto hemos terminado este tutorial. Queda para otro tutorial la creación de las bases de datos con Grafana.

Un saludo a todos.

Fuente: Blog de Nasked