La observabilidad va mas allá de la monitorización. Mientras que con la monitorización clásica únicamente nos permite saber si un servidor o servicio está funcionando o no, la observabilidad nos permite saber qué está pasando por dentro y correlar los eventos con los logs. de esta manera tenemos mayor conocimiento de qué sucede y por qué sucede, pudiendo anticiparnos a los problemas que puedan surgir.

En este artículo vamos a construir una arquitectura distribuida de observabilidad completa sobre Ubuntu 24.04 LTS, utilizando el stack de Grafana :

Grafana para la visualización
Grafana Mimir para la ingestión de métricas
Grafana Loki para la ingestión de logs
Grafana Tempo para la ingestión de trazas.
Grafana Alloy será el agente que instalaremos en una máquina para poder enviar al stack logs, métricas y trazas.

Adicionalmente vamos a instalar una máquina con WordPress para poder hacer pruebas y poder ver sus métricas, logs y trazas a través de Grafana.

Prerequisitos

Tendremos 3 servidores Ubuntu 24.04:

Servidor	Rol	Dirección IP
srv-observability	Mimir + Loki + Tempo	192.168.1.10
srv-grafana	Grafana (UI)	192.168.1.20
srv-app	Alloy + WordPress	192.168.1.30

Instalación inicial de todos los servidores

Una vez hecha la instalación básica haremos una actualización para instalar la última versión de los paquetes del sistema, configuraremos la zona horaria e instalaremos wget y unzip ya que los necesitaremos.

sudo apt update && sudo apt upgrade -y
sudo timedatectl set-timezone Europe/Madrid
sudo apt install curl wget unzip -y

Servidor backend : Mimir, Loki y Tempo

El servidor de backend ejecutará los servicios encargados de ingestar métricas, logs y trazas.

Servicio de ingestión de métricas : Mimir

Descargaremos el paquete de Mimir desde el site de Grafana usando :

wget https://github.com/grafana/mimir/releases/latest/download/mimir-linux-amd64
chmod +x mimir-linux-amd64
sudo mv mimir-linux-amd64 /usr/local/bin/mimir

Crearemos la carpeta y el archivo de configuración :

sudo mkdir /etc/mimir
sudo nano /etc/mimir/mimir.yaml

Añadiremos esta configuración. Básicamente lo que vamos a hacer es indicar en qué puerto vamos a tener publicado el servicio y cómo se van a guardar los datos.

multitenancy_enabled: false

server:
  http_listen_port: 9009

blocks_storage:
  backend: filesystem
  filesystem:
    dir: /var/lib/mimir/blocks

ingester:
  ring:
    kvstore:
      store: inmemory

compactor:
  data_dir: /var/lib/mimir/compactor

Procedemos a crear los directorios donde se van a guardar los datos

sudo mkdir -p /var/lib/mimir/blocks -p
sudo mkdir -p /var/lib/mimir/compactor -p

Ponemos en marcha el servicio ejecutando :

mimir --config.file=/etc/mimir/mimir.yaml

Servicio de ingestión de logs : Loki

Descargamos el paquete Loki desde el sitio de Grafana :

wget https://github.com/grafana/loki/releases/latest/download/loki-linux-amd64.zip
unzip loki-linux-amd64.zip
chmod +x loki-linux-amd64
sudo mv loki-linux-amd64 /usr/local/bin/loki

Creamos el directorio y archivo de configuración :

sudo mkdir /etc/loki -p
sudo nano /etc/loki/loki.yaml

Añadimos el contenido que sigue al fichero de configuración. En la configuración se encuentra el modo multitenant desactivado por lo que no pide autenciación. Publica el puerto de escucha 3100. Además definiremos donde se guardan los chunks, que son bloques comprimidos de logs. Como lo estamos usando como un único nodo tenemos definido el replication_factor a 1 y el tipo de kvstore como inmemory.

En la sección schema_config se define desde qué fecha se va a aplicar la configuración , donde se van a guardar los datos e índices y la versión del esquema de almacenamiento.

auth_enabled: false

server:
  http_listen_port: 3100

common:
  path_prefix: /var/lib/loki
  storage:
    filesystem:
      chunks_directory: /var/lib/loki/chunks
      rules_directory: /var/lib/loki/rules
  replication_factor: 1
  ring:
    kvstore:
      store: inmemory

schema_config:
  configs:
    - from: 2026-01-01
      store: boltdb-shipper
      object_store: filesystem
      schema: v13
      index:
        prefix: index_
        period: 24h

Crearemos los directorios que necesitaremos :

sudo mkdir -p /var/lib/loki/chunks -p
sudo mkdir -p /var/lib/loki/rules -p

Levantaremos el servicio con :

loki -config.file=/etc/loki/loki.yaml

Servicio de ingestión de trazas : Tempo

Descargamos Tempo desde el sitio de Grafana :

wget https://github.com/grafana/tempo/releases/latest/download/tempo-linux-amd64.tar.gz
tar -xvzf tempo-linux-amd64.tar.gz
chmod +x tempo-linux-amd64
sudo mv tempo-linux-amd64 /usr/local/bin/tempo

Procederemos a crear la configuración :

sudo mkdir /etc/tempo -p
sudo nano /etc/tempo/tempo.yaml

El contenido del archivo de configuración será el que sigue. En él se define el puerto por donde escuchará el servicio, el 3200, con qué protocolo se podrán recibir las trazas y cómo será el backend donde se guardarán.

server:
  http_listen_port: 3200

distributor:
  receivers:
    otlp:
      protocols:
        http:
        grpc:

storage:
  trace:
    backend: local
    local:
      path: /var/lib/tempo/traces

Creamos el directorio donde se guardarán las trazas :

sudo mkdir -p /var/lib/tempo/traces -p

Ponemos en marcha el servicio con :

tempo -config.file=/etc/tempo/tempo.yaml

Servidor de visualización: Grafana

Añadiremos el repositorio de Grafana a nuestro Ubuntu e instalaremos el paquete.

sudo apt install -y software-properties-common
sudo add-apt-repository "deb https://packages.grafana.com/oss/deb stable main"
wget -q -O - <https://packages.grafana.com/gpg.key> | sudo apt-key add -
sudo apt update
sudo apt install grafana -y

Iniciaremos el servicio de Grafana con :

sudo systemctl enable grafana-server
sudo systemctl start grafana-server

Para acceder necesitaremos conectarnos al puerto 3000 a través de la IP del servidor :

http://192.168.1.20:3000

Entraremos con el Login por defecto y cambiaremos la contraseña.

admin / admin

Configuración de los Data Sources

Buscaremos los data sources adecuados y los instalaremos. Para cada uno deberemos configurar los siguientes parámetros :

Mimir (Prometheus) -> http://192.168.1.10:9009/prometheus
Loki ->http://192.168.1.10:3100
Tempo -> http://192.168.1.10:3200

Servidor 3: Aplicación + Alloy

Instalar WordPress

Instalamos el stack LAMP : Apache, PHP y MySQL ejecutando :

sudo apt install apache2 mysql-server php php-mysql libapache2-mod-php -y

Configuraremos MySQL con :

sudo mysql

Y una vez dentro crearemos la base de datos y daremos permisos.

CREATE DATABASE wordpress;
CREATE USER 'wpuser'@'localhost' IDENTIFIED BY 'password';
GRANT ALL PRIVILEGES ON wordpress.* TO 'wpuser'@'localhost';
FLUSH PRIVILEGES;
EXIT;

A continuación descargamos WordPress

cd /var/www/html
sudo rm index.html
sudo wget <https://wordpress.org/latest.tar.gz>
sudo tar -xvzf latest.tar.gz
sudo chown -R www-data:www-data wordpress

Accederemos a la instalación de WordPress y completaremos la instalación.

http://192.168.1.30/wordpress

Instalar Grafana Alloy

Descargaremos Alloy desde el site de Grafana :

wget https://github.com/grafana/alloy/releases/latest/download/alloy-linux-amd64.zip
unzip alloy-linux-amd64.zip
chmod +x alloy-linux-amd64
sudo mv alloy-linux-amd64 /usr/local/bin/alloy

Creamos el archivo de configuración :

sudo nano /etc/alloy/config.alloy

Añadiremos la siguiente configuración. En ella definimos que para las métricas, usaremos el exporter de máquinas unix que recogen uso de CPU, espacio en disco, memoria RAM, etc. y dónde debe enviarlas. Así también definiremos que logs son los que se van a enviar y a qué endpoint. Y para las trazas seguiremos con una configuración similar.

logging {
  level = "info"
}

prometheus.exporter.unix "node" {}

prometheus.scrape "node" {
  targets = prometheus.exporter.unix.node.targets
  forward_to = [prometheus.remote_write.mimir.receiver]
}

prometheus.remote_write "mimir" {
  endpoint {
    url = "<http://192.168.1.10:9009/api/v1/push>"
  }
}

loki.source.file "system_logs" {
  targets = [
    {__path__ = "/var/log/syslog"},
    {__path__ = "/var/log/auth.log"},
    {__path__ = "/var/log/apache2/*.log"},
  ]
  forward_to = [loki.write.loki.receiver]
}

loki.write "loki" {
  endpoint {
    url = "<http://192.168.1.10:3100/loki/api/v1/push>"
  }
}

otelcol.exporter.otlp "tempo" {
  client {
    endpoint = "192.168.1.10:4317"
    tls {
      insecure = true
    }
  }
}

Para iniciar el servicio ejecutaremos :

alloy run /etc/alloy/config.alloy

Visualización en Grafana

Métricas

Accederemos a Explore y buscaremos Prometheus. Allí consultaremos la métrica :

node_cpu_seconds_total

Logs

En el menú Explore seleccionaremos Loki y haremos la consulta :

{job="system_logs"}

Trazas

A través del menú Explore seleccionaremos Tempo y buscaremos :

service.name="wordpress"

Simulaciones

Ataque fuerza bruta

Vamos a hacer una simulación de ataque por fuerza bruta a la página de login de WordPress. Ejecutaremos 50 veces un acceso a la página.

for i in {1..50}; do curl -X POST http://192.168.1.30/wordpress/wp-login.php; done

En Grafana se debería observar que :

Ha habido un pico de tráfico
Se han generado logs de Apache indicando la carga de la página.
Ha aumentado la latencia.

Saturación CPU

Ejecutaremos el comando :

yes > /dev/null &

En Grafana deberíamos ver cómo ha aumentado el uso de CPU del nodo.

Si te ha gustado este contenido ¡suscríbete a la newsletter para no perderte ningún artículo!