Ir al contenido

Verteilte Observability-Architektur mit dem Grafana-Stack

Autor: Portelcore-Team Ziel: Unser Ziel ist es, eine vollständige Observabilitätsumgebung mit Grafana, Mimir, Loki, Tempo und Alloy bereitzustellen...

0Lesungen

Autor: Team Portelcore Ziel: Unser Ziel ist es, eine vollständige Observabilitätsumgebung mit Grafana, Mimir, Loki, Tempo und Alloy auf Ubuntu 24.04 LTS bereitzustellen, um Metriken, Protokolle und Spuren einer Webanwendung (WordPress) zu erfassen und zu analysieren.

Wir verfügen über 3 Ubuntu 24.04 LTS-Server mit den folgenden Rollen:

ServerRolle / DiensteIP-Adresse
Server 1 (Backend)Mimir (Metriken) + Loki (Logs) + Tempo (Traces)172.20.0.151
Server 2 (Frontend)Grafana (Visualisierungsschnittstelle UI)172.20.0.166
Server 3 (App/Agent)Webserver (WordPress) + Grafana Alloy (Agent)172.20.0.176

PHASE 0: Initialvorbereitung (Auf den 3 Servern)

Sección titulada «FASE 0: Preparación Inicial (En los 3 Servidores)»

Bevor wir beginnen, müssen wir diese Befehle auf den 3 Servern ausführen, um sicherzustellen, dass das System auf dem neuesten Stand ist, sich in der richtigen Zeitzone befindet und über die notwendigen Tools verfügt.

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

PHASE 1: Backend-Server (Mimir, Loki und Tempo)

Sección titulada «FASE 1: Servidor Backend (Mimir, Loki y Tempo)»

Wir werden auf Server 1 (172.20.0.151) ausführen

Dieser Server erhält alle von den Agenten gesendeten Daten. Um diese professionell zu verwalten, werden wir systemd-Dienste erstellen, die im Hintergrund ausgeführt werden und automatisch mit dem System starten.

  1. Wir werden die Binärdatei herunterladen und installieren:
Ventana de terminal
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
  1. Wir werden die Konfiguration und die Verzeichnisse erstellen:
Ventana de terminal
sudo mkdir -p /etc/mimir
sudo mkdir -p /var/lib/mimir/blocks
sudo mkdir -p /var/lib/mimir/compactor
sudo nano /etc/mimir/mimir.yaml

Wir werden den folgenden Inhalt in mimir.yaml einfügen:

multitenancy_enabled: false
server:
http_listen_port: 9009
grpc_listen_port: 9096
blocks_storage:
backend: filesystem
filesystem:
dir: /var/lib/mimir/blocks
ingester:
ring:
replication_factor: 1
kvstore:
store: inmemory
compactor:
data_dir: /var/lib/mimir/compactor
  1. Wir werden den Systemd-Dienst für Mimir erstellen:
Ventana de terminal
sudo tee /etc/systemd/system/mimir.service > /dev/null <<EOF
[Unit]
Description=Grafana Mimir
After=network.target
[Service]
ExecStart=/usr/local/bin/mimir -config.file=/etc/mimir/mimir.yaml
Restart=always
[Install]
WantedBy=multi-user.target
EOF
  1. Wir werden die Binärdatei herunterladen und installieren:
Ventana de terminal
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
  1. Wir werden die Konfiguration und die Verzeichnisse erstellen:
Ventana de terminal
sudo mkdir -p /etc/loki
sudo mkdir -p /var/lib/loki/chunks
sudo mkdir -p /var/lib/loki/rules
sudo nano /etc/loki/loki.yaml

Wir werden den folgenden Inhalt in loki.yaml einfügen:

auth_enabled: false
server:
http_listen_port: 3100
grpc_listen_port: 9097
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: tsdb
object_store: filesystem
schema: v13
index:
prefix: index_
period: 24h
  1. Wir werden den Systemd-Dienst für Loki erstellen:
Ventana de terminal
sudo tee /etc/systemd/system/loki.service > /dev/null <<EOF
[Unit]
Description=Grafana Loki
After=network.target
[Service]
ExecStart=/usr/local/bin/loki -config.file=/etc/loki/loki.yaml
Restart=always
[Install]
WantedBy=multi-user.target
EOF
  1. Wir werden das Binärprogramm herunterladen und installieren (festgelegt auf die stabile Version v2.10.1):
Ventana de terminal
wget https://github.com/grafana/tempo/releases/download/v2.10.1/tempo_2.10.1_linux_amd64.tar.gz
tar -xvzf tempo_2.10.1_linux_amd64.tar.gz
sudo mv tempo-linux-amd64 /usr/local/bin/tempo 2>/dev/null || sudo mv tempo /usr/local/bin/tempo
sudo chmod +x /usr/local/bin/tempo
  1. Wir werden die Konfiguration und die Verzeichnisse erstellen:
Ventana de terminal
sudo mkdir -p /etc/tempo
sudo mkdir -p /var/lib/tempo/traces
sudo nano /etc/tempo/tempo.yaml

Wir werden den folgenden Inhalt in tempo.yaml einfügen:

server:
http_listen_port: 3200
grpc_listen_port: 9095
distributor:
receivers:
otlp:
protocols:
http:
grpc:
storage:
trace:
backend: local
local:
path: /var/lib/tempo/traces
  1. Wir werden den Systemd-Service für Tempo erstellen:
Ventana de terminal
sudo tee /etc/systemd/system/tempo.service > /dev/null <<EOF
[Unit]
Description=Grafana Tempo
After=network.target
[Service]
ExecStart=/usr/local/bin/tempo -config.file=/etc/tempo/tempo.yaml
Restart=always
[Install]
WantedBy=multi-user.target
EOF

1.4 Wir werden alle Dienste gleichzeitig und im Hintergrund starten

Sección titulada «1.4 Iniciaremos todos los servicios al mismo tiempo y en segundo plano»

Nachdem wir die systemd-Regeln für alle drei erstellt haben, werden wir die Systemkonfiguration neu laden und sie alle mit einem einzigen Befehl aktivieren/starten:

Ventana de terminal
sudo systemctl daemon-reload
sudo systemctl enable --now mimir loki tempo

(Wir können mit sudo systemctl status mimir loki tempo überprüfen, ob alle drei erfolgreich im Hintergrund laufen).

Wir werden dies auf Server 2 (172.20.0.166) ausführen

  1. Wir werden Grafana aus dem offiziellen Repository installieren:
Ventana de terminal
sudo apt install -y software-properties-common apt-transport-https
sudo wget -q -O /usr/share/keyrings/grafana.key https://apt.grafana.com/gpg.key
echo "deb https://apt.grafana.com stable main" | sudo tee -a /etc/apt/sources.list.d/grafana.list
sudo apt update
sudo apt install grafana -y
  1. Wir werden den Dienst starten und aktivieren:
Ventana de terminal
sudo systemctl enable --now grafana-server
  1. Wir greifen auf die Schnittstelle zu und konfigurieren:
    • Wir öffnen unseren Webbrowser und gehen zu: http://172.20.0.166:3000
    • Login: admin / Passwort: admin (Sie werden aufgefordert, es zu ändern).
    • Wir gehen zu Verbindungen > Datenquellen > Datenquelle hinzufügen und konfigurieren diese 3, die auf Server 1 (172.20.0.151):
      • Prometheus (für Mimir): URL http://172.20.0.151:9009/prometheus
      • Loki: URL http://172.20.0.151:3100
      • Tempo: URL http://172.20.0.151:3200

Wir führen dies auf Server 3 (172.20.0.176) aus

3.1 Wir installieren die Anwendung (WordPress LAMP-Stack)

Sección titulada «3.1 Instalaremos la Aplicación (WordPress Stack LAMP)»
Ventana de terminal
# 1. Instalamos LAMP
sudo apt install apache2 mysql-server php php-mysql libapache2-mod-php -y
# 2. Habilitamos el módulo de estado de Apache (Necesario para obtener métricas)
sudo a2enmod status
sudo systemctl restart apache2
# 3. Configuramos la base de datos (Entramos con 'sudo mysql' y pegamos estas líneas)
sudo mysql -e "CREATE DATABASE wordpress;"
sudo mysql -e "CREATE USER 'wpuser'@'localhost' IDENTIFIED BY 'password';"
sudo mysql -e "GRANT ALL PRIVILEGES ON wordpress.* TO 'wpuser'@'localhost';"
sudo mysql -e "FLUSH PRIVILEGES;"
# 4. Descargamos e instalamos 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

Wir können auf http://172.20.0.176/wordpress zugreifen, um die grafische Installation abzuschließen.

3.2 Wir installieren und konfigurieren Grafana Alloy (der globale Agent)

Sección titulada «3.2 Instalaremos y Configuraremos Grafana Alloy (El Agente Global)»
  1. Wir werden die Binärdatei herunterladen und installieren:
Ventana de terminal
cd ~
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
  1. Wir erstellen die vollständige Konfigurationsdatei:
Ventana de terminal
sudo mkdir -p /etc/alloy
sudo nano /etc/alloy/config.alloy

Wir fügen den folgenden Inhalt ein. Diese Konfiguration extrahiert Disk, CPU, Apache, MySQL, Logs und Traces:

Ventana de terminal
logging {
level = "info"
}
// --------------------------------------------------------
// 1. MÉTRICAS DEL SISTEMA (Disco, CPU, RAM, Red)
// --------------------------------------------------------
prometheus.exporter.unix "node" {}
prometheus.scrape "node" {
targets = prometheus.exporter.unix.node.targets
forward_to = [prometheus.remote_write.mimir.receiver]
}
// --------------------------------------------------------
// 2. MÉTRICAS DE APACHE (Servidor Web)
// --------------------------------------------------------
prometheus.exporter.regular_apache = prometheus.exporter.apache "apache" {
scrape_uri = "http://localhost/server-status?auto"
}
prometheus.scrape "apache" {
targets = prometheus.exporter.apache.apache.targets
forward_to = [prometheus.remote_write.mimir.receiver]
}
// --------------------------------------------------------
// 3. MÉTRICAS DE MYSQL (Base de Datos)
// --------------------------------------------------------
prometheus.exporter.mysql "mysql" {
data_source_name = "wpuser:password@(localhost:3306)/"
}
prometheus.scrape "mysql" {
targets = prometheus.exporter.mysql.mysql.targets
forward_to = [prometheus.remote_write.mimir.receiver]
}
// --------------------------------------------------------
// 4. OBSERVABILIDAD INTERNA (Mimir, Loki, Tempo)
// --------------------------------------------------------
prometheus.scrape "backend_services" {
targets = [
{"__address__" = "172.20.0.151:9009", "job" = "mimir"},
{"__address__" = "172.20.0.151:3100", "job" = "loki"},
{"__address__" = "172.20.0.151:3200", "job" = "tempo"},
]
forward_to = [prometheus.remote_write.mimir.receiver]
scrape_interval = "15s"
}
// 5. ENVIAR TODAS LAS MÉTRICAS A MIMIR
prometheus.remote_write "mimir" {
endpoint {
url = "http://172.20.0.151:9009/api/v1/push"
}
}
// --------------------------------------------------------
// 6. LOGS (Sistema y Apache)
// --------------------------------------------------------
loki.source.file "system_logs" {
targets = [
{__path__ = "/var/log/syslog", "job" = "syslog"},
{__path__ = "/var/log/auth.log", "job" = "auth"},
{__path__ = "/var/log/apache2/*.log", "job" = "apache"},
]
forward_to = [loki.write.loki.receiver]
}
// 7. ENVIAR LOGS A LOKI
loki.write "loki" {
endpoint {
url = "http://172.20.0.151:3100/loki/api/v1/push"
}
}
// --------------------------------------------------------
// 8. TRACES (Recepción y Envío a Tempo)
// --------------------------------------------------------
otelcol.receiver.otlp "default" {
http {}
grpc {}
output {
traces = [otelcol.exporter.otlp.tempo.input]
}
}
otelcol.exporter.otlp "tempo" {
client {
endpoint = "172.20.0.151:4317"
tls {
insecure = true
}
}
}
  1. Wir erstellen den Systemd-Service für Alloy:
Ventana de terminal
sudo tee /etc/systemd/system/alloy.service > /dev/null <<EOF
[Unit]
Description=Grafana Alloy
After=network.target
[Service]
ExecStart=/usr/local/bin/alloy run /etc/alloy/config.alloy
Restart=always
[Install]
WantedBy=multi-user.target
EOF
  1. Wir führen Alloy aus (um Daten im Hintergrund zu sammeln und zu senden):
Ventana de terminal
sudo systemctl daemon-reload
sudo systemctl enable --now alloy

Um zu überprüfen, ob alles funktioniert, öffnen wir Grafana (http://172.20.0.166:3000), gehen auf Explore und testen die Data Sources.

4.1 Simulationen von unserem Team aus (oder von Server 3)

Sección titulada «4.1 Simulaciones desde nuestro equipo (o desde el Servidor 3)»

Simulation 1: Brute-Force-Angriff (Erzeugt Protokolle und Latenz) Wir werden 50 gleichzeitige Anfragen gegen den WordPress-Login senden, um Lärm in den Apache-Protokollen zu erzeugen und die Latenz zu erhöhen.

Ventana de terminal
for i in {1..50}; do curl -s -X POST http://172.20.0.176/wordpress/wp-login.php > /dev/null; done

In Grafana -> Explore -> Loki: Wir suchen nach {job="apache"} und sehen alle Zugriffe in Echtzeit protokolliert.

Simulation 2: CPU-Sättigung (Erzeugt hohe Metriken) Dieser Befehl wird einen CPU-Kern maximal beanspruchen.

yes > /dev/null &

In Grafana -> Explore -> Prometheus (Mimir): Wir suchen nach node_cpu_seconds_total (pro CPU) oder mysql_up (um zu überprüfen, ob die Datenbank funktioniert). (Um die CPU-Sättigung zu stoppen, führen wir killall yes aus).

Trace-Verifizierung: In Grafana -> Explore -> Tempo: Wir suchen nach service.name="wordpress", um den Verlauf der von uns ausgeführten HTTP-Anfragen zu sehen.

Da Alloy die Standard-Exporter (Node, Apache, MySQL) verwendet, müssen wir die Grafiken nicht von Grund auf neu erstellen. Wir können offizielle Vorlagen aus der Grafana-Community importieren.

Import-Anleitung:

  1. Wir gehen zu unserem Grafana (http://172.20.0.166:3000).
  2. Im linken Menü klicken wir auf das Symbol ”+” -> Import.
  3. Im Feld „Import via grafana.com“ geben wir eine der unten aufgeführten IDs ein und klicken auf Load.
  4. Wir wählen unsere Datenquelle (Prometheus/Mimir) im Dropdown-Menü unten aus und klicken auf Import.
  • ID 1860 (Node Exporter Full): Dies ist das weltweit bekannteste Dashboard zur Überwachung der physischen Server-Gesundheit. Es zeigt uns die CPU-Auslastung, den verbleibenden Festplattenspeicher unseres WordPress-Servers, die RAM-Nutzung, die Netzwerkbandbreite usw. an.
  • ID 3894 (Apache Overview): Es zeigt uns in Echtzeit, wie viele Webanfragen auf unser WordPress eingehen, die Antwortzeit, die aktiven Worker und die übertragenen Bytes.
  • ID 7362 (MySQL Overview): Es bietet Einblick in die WordPress-Datenbank: Abfragen pro Sekunde, aktive Verbindungen, Cache-Speicher und die Leistung der InnoDB-Engine.

Und die Protokolle und Spuren? Loki (Protokolle) und Tempo (Spuren) werden normalerweise besser über die Explore-Registerkarte von Grafana visualisiert. Wenn wir sie einem Dashboard hinzufügen möchten, müssen wir nur ein importiertes Panel bearbeiten, eine neue Abfrage hinzufügen, als Datenquelle “Loki” auswählen und {job="apache"} schreiben, um die Zugriffsprotokolle der Website neben den CPU-Diagrammen zu haben.