So richten Sie den LGTM-Stack für eine durchgängige Beobachtbarkeit ein

Der LGTM-Stack – bestehend aus Loki für Protokolle, Grafana für die Visualisierung, Tempo für die Ablaufverfolgung und Mimir für Metriken – ist eine von Grafana Labs entwickelte Open-Source-Suite zur Observability.

Dieser leistungsstarke Stack vereint Metriken, Protokolle und Traces auf einer einzigen Plattform und bietet Teams so einen umfassenden Überblick über die Systemleistung.

In dieser Anleitung erhalten Sie einen klaren, durchgängigen Einblick in Ihre Anwendungen und Infrastruktur, und erfahren, wie Sie den LGTM-Stack auf einem Virtual Private Server (VPS) einrichten – von der Konfiguration jeder Komponente bis zur Erstellung eines umfassenden Observability-Dashboards.

Was ist durchgängige Observability?

End-to-End-Observability bedeutet die Überwachung und Analyse des gesamten Lebenszyklus einer Anwendung, von den Benutzerinteraktionen im Frontend bis hin zu den Diensten und Infrastrukturkomponenten im Backend.

Im Gegensatz zur herkömmlichen Überwachung, die lediglich vordefinierte Metriken erfasst, um den Systemzustand zu messen und bei bekannten Problemen Warnmeldungen auszugeben, bietet die durchgängige Observability einen einheitlichen Überblick über:

• Benutzerinteraktionen – Frontend-Metriken und Benutzerverhalten erfassen.
• Anwendungsleistung – Backend-Dienste und interne APIs überwachen.
• Zustand der Infrastruktur – Status von Servern, Datenbanken und Netzwerken bewerten.
• Drittanbieter-Dienste – Abhängigkeiten wie Zahlungsgateways oder Cloud-Anbieter beobachten.

Durch die Korrelation von Daten über alle Ebenen hinweg gewinnen Teams Einblicke darin, wie sich Änderungen in einem Bereich auf die Gesamtleistung des Systems auswirken, und können Probleme schnell erkennen, wo immer sie auftreten.

Der LGTM-Stack unterstützt eine durchgängige Beobachtbarkeit, indem er Apps so instrumentiert, dass Telemetriedaten erfasst werden: Protokolle, Metriken und Traces. Der Stack aggregiert diese Daten über seine Komponenten und visualisiert sie in Grafana-Dashboards zur einfachen Analyse.

Dieser Ansatz bietet mehrere Vorteile:

• Umfassende Überwachung – Der LGTM-Stack bietet einen ganzheitlichen Überblick über das Systemverhalten und ermöglicht so die proaktive Erkennung und Behebung von Problemen.
• Verbesserte Fehlerbehebung – Die Korrelation von Daten aus mehreren Quellen hilft Teams dabei, die Grundursachen schnell zu identifizieren und so die durchschnittliche Zeit bis zur Behebung (MTTR) zu verkürzen.
• Skalierbarkeit – Jede LGTM-Komponente lässt sich horizontal skalieren, um komplexe, verteilte Systeme zu unterstützen.
• Kosteneffizienz – Als Open-Source-Lösung entfallen beim LGTM-Stack die Lizenzgebühren, die bei proprietären Observability-Tools anfallen.

Voraussetzungen

Bevor Sie den LGTM-Stack einrichten, müssen Sie eine VPS-Instanz vorbereiten, auf der er gehostet werden soll. Grafana, die Hauptoberfläche zur Visualisierung von Observability-Daten, benötigt keine umfangreichen Ressourcen. Sie können den vollständigen LGTM-Stack auf einem VPS mit folgenden Mindestanforderungen ausführen:

• 1 CPU-Kern.
• 512 MB RAM.

Da der LGTM-Stack jedoch die Systemleistung und das Anwendungsverhalten überwacht, sollten Sie einen VPS-Plan wählen, der der Größe und Nutzung Ihres Systems entspricht.

Hostingers VPS-Dienst ist eine hervorragende Wahl und bietet Pläne ab 5.49 € bis 21.99 €.

Die Pläne von Hostinger umfassen bis zu 8 vCPU-Kerne, 32 GB RAM und 400 GB NVMe-Speicher. Ein Upgrade ist jederzeit möglich, falls Ihr Observability-Stack mehr Leistung oder Speicherplatz erfordert.

Konfigurieren Sie als Nächstes Ihre Firewall. Öffnen Sie die folgenden Ports auf Ihrem VPS, um einen reibungslosen Betrieb der LGTM-Komponenten zu gewährleisten:

Falls Sie gerade erst einen VPS erworben oder noch keine Firewall konfiguriert haben, können Sie diesen Schritt überspringen.

Wenn Sie die Uncomplicated Firewall (UFW) aktiviert haben, dann öffnen Sie Ihr Terminal und führen Sie folgende Befehle aus:

sudo ufw allow 3000/tcp    # Grafana  
sudo ufw allow 3100/tcp    # Loki  
sudo ufw allow 3200/tcp    # Tempo  
sudo ufw allow 9090/tcp    # Mimir  
sudo ufw allow 4318/tcp    # OpenTelemetry Collector

Überprüfen Sie anschließend, ob UFW aktiv ist und die Regeln angewendet werden, indem Sie folgenden Befehl ausführen:

sudo ufw status

So richten Sie den LGTM-Stack auf einem VPS ein

Sie können den LGTM-Stack auf Ihrem VPS auf verschiedene Arten einrichten. In diesem Tutorial wird Docker Compose verwendet, mit dem Sie alle Komponenten schnell in einer einzigen Datei bereitstellen und verwalten können. Dies ist die einfachste Methode und eignet sich gut für Anfänger.

Falls Sie mehr Kontrolle bevorzugen oder Docker vermeiden möchten, stellen wir Ihnen auch Anleitungen zur manuellen Installation der einzelnen Komponenten zur Verfügung.

1. Bereiten Sie die Umgebung vor

Beginnen Sie damit, die Paketlisten Ihres VPS zu aktualisieren und die installierten Pakete auf die neuesten Versionen zu aktualisieren. Dadurch wird sichergestellt, dass Ihr Server über die neuesten Sicherheitspatches und Softwareverbesserungen verfügt:

sudo apt update && sudo apt upgrade -y

Wenn gewünscht oder nötig, können Sie nicht mehr benötigte Pakete und Abhängigkeiten entfernen, um Speicherplatz freizugeben:

sudo apt autoremove -y

Installieren Sie anschließend Docker auf Ihrem Server, um die containerisierte Bereitstellung zu ermöglichen und Docker Compose zu nutzen.

Hostinger VPS-Kunden können die Einrichtung vereinfachen, indem sie eine vorkonfigurierte Docker-Vorlage per 1-Klick-Installation verwenden. Andernfalls müssen Sie die Plattform manuell mithilfe von Linux-Befehlen installieren.

Wenn Sie Docker nicht verwenden werden, können Sie diesen Abschnitt einfach überspringen.

Überprüfen Sie nach der Installation, ob Docker funktioniert, indem Sie folgenden Befehl ausführen:

sudo systemctl status docker

Drücken Sie Strg + C, um die Statusansicht zu verlassen.

Erstellen Sie anschließend ein neues Verzeichnis für Ihre LGTM-Stack-Dateien und wechseln Sie in dieses Verzeichnis. Ersetzen Sie grafana-lgtm durch den von Ihnen gewünschten Verzeichnisnamen:

mkdir grafana-lgtm

cd grafana-lgtm

2. Richten Sie Loki für die Protokollaggregation ein

Loki übernimmt die Protokollaggregation, indem es Protokolle aus verschiedenen Quellen sammelt und speichert.

Es indexiert lediglich Metadaten anstelle des vollständigen Log-Inhalts, um Speicherkosten zu senken und die Abfrageleistung zu steigern – insbesondere beim Umgang mit großen Mengen an Log-Daten.

Erstellen Sie in Ihrem Verzeichnis grafana-lgtm mit dem Texteditor nano eine neue Datei mit dem Namen loki-local-config.yaml:

sudo nano loki-local-config.yaml

Fügen Sie die folgende Konfiguration in die Datei ein:

auth_enabled: false

server:
  http_listen_port: 3100

schema_config:
  configs:
    - from: 2020-10-24
      store: boltdb-shipper
      object_store: filesystem
      schema: v11
      index:
        prefix: index_
        period: 24h

storage_config:
  boltdb_shipper:
    active_index_directory: /tmp/loki/boltdb-shipper-active
    cache_location: /tmp/loki/boltdb-shipper-cache
    cache_ttl: 24h
  filesystem:
    directory: /tmp/loki/chunks

limits_config:
  reject_old_samples: true
  reject_old_samples_max_age: 168h
  allow_structured_metadata: false

ingester:
  lifecycler:
    address: 127.0.0.1
    ring:
      kvstore:
        store: inmemory
      replication_factor: 1
    final_sleep: 0s
  chunk_idle_period: 5m
  chunk_retain_period: 30s

common:
  path_prefix: /tmp/loki

compactor:
  working_directory: /tmp/loki/compactor

Wenn Sie fertig sind, drücken Sie Strg + X → Y → Enter, um die Datei zu speichern und nano zu beenden.

3. Konfigurieren Sie Mimir für die Speicherung von Metriken

Grafana Mimir baut auf Prometheus auf und erweitert dieses um skalierbare, langfristige Speicherung sowie leistungsstarke Abfragen für große Mengen an Zeitreihendaten.

In dieser Anleitung verwenden wir jedoch ausschließlich Prometheus, da es sich besser in den OpenTelemetry Collector integrieren lässt, um Metriken für diese Konfiguration zu erfassen.

Erstellen Sie mit nano eine neue Datei prometheus.yml, genau wie bei der Konfiguration von Loki. Fügen Sie anschließend die folgende Konfiguration ein:

global:
  scrape_interval: 5s            # Scraping interval, shortened to 5 seconds to get data faster (default is 1m)
scrape_configs:
  - job_name: 'otel-collector'
    static_configs:
      - targets: ['otel-collector:9464']   # Target is the Prometheus Exporter port of OTel Collector

Speichern Sie die Datei, wenn Sie fertig sind.

4. Integrieren Sie Tempo für verteilte Tracing-Funktionen

Grafana Tempo ist ein hochskalierbares, verteiltes Tracing-Backend, das Trace-Daten über Microservice-Architekturen hinweg sammelt, speichert und abfragt.

Mit Tempo können Sie den Weg von Anfragen visualisieren, während diese verschiedene Dienste durchlaufen. Dies hilft, Engpässe schnell und effektiv zu identifizieren.

Erstellen Sie wie bei den vorherigen Komponenten eine Datei mit dem Namen tempo-local.yaml, um die Konfiguration von Tempo zu speichern:

distributor:
  receivers:
    otlp:
      protocols:
        http:
          endpoint: "0.0.0.0:4318"

storage:
  trace:
    backend: local
    local:
      path: /tmp/tempo/blocks
    wal:
      path: /tmp/tempo/wal

ingester:
  trace_idle_period: 30s
  max_block_duration: "5m"
  lifecycler:
    ring:
      kvstore:
        store: inmemory
      replication_factor: 1

compactor:
  compaction:
    block_retention: 1h

querier: {}  # ⭐ Must be added, otherwise it will automatically exit

multitenancy_enabled: false  # ⭐ Recommended to add, to avoid single-tenant environment errors

Für diejenigen, die einen praktischen Ansatz bevorzugen, bieten wir außerdem eine Anleitung zur manuellen Einrichtung von Tempo an.

5. Installieren Sie Grafana für die Observability

Grafana dient als zentrale Visualisierungsebene im LGTM-Stack und bündelt Daten aus allen anderen Komponenten an einem Ort. Dies vereinfacht das Erkennen und Beheben von Systemanomalien.

Sie können Grafana auf Ihrem VPS entweder manuell oder als Teil der Dienste in einer Docker-Compose-Datei installieren.

Wenn Sie sich für Letzteres entscheiden, dann erstellen Sie zunächst einen neuen Ordner namens grafana innerhalb des Verzeichnisses grafana-lgtm:

mkdir grafana

cd grafana

Erstellen Sie anschließend eine Datei mit dem Namen datasources.yml im Verzeichnis grafana-lgtm/grafana, um die Datenquellen zu konfigurieren. Fügen Sie den folgenden Inhalt ein:

apiVersion: 1
datasources:
  - name: Prometheus
    type: prometheus
    access: proxy
    url: http://prometheus:9090
    isDefault: true

  - name: Loki
    type: loki
    access: proxy
    url: http://loki:3100
    isDefault: false

  - name: Tempo
    type: tempo
    access: proxy
    url: http://tempo:3200
    isDefault: false

Erstellen Sie anschließend im selben Ordner eine weitere Datei namens dashboards.yml, um die Dashboard-Anbieter einzurichten:

apiVersion: 1
providers:
  - name: 'Local Dashboards'
    orgId: 1
    folder: ''
    type: file
    disableDeletion: false
    updateIntervalSeconds: 5
    options:
      path: /var/lib/grafana/dashboards

Erstellen Sie anschließend einen Ordner Dashboard und wechseln Sie in diesen Ordner:

mkdir dashboards

cd dashboards

Fügen Sie eine Datei mit dem Namen springboot-observability.json hinzu. Diese Datei dient als Beispiel-Dashboard:

{
    "uid": "springboot-observability",
    "title": "Spring Boot OTEL Demo Dashboard",
    "time": {
        "from": "now-5m",
        "to": "now"
    },
    "panels": [
        {
            "type": "timeseries",
            "title": "JVM Heap Memory Used",
            "datasource": "Prometheus",
            "targets": [
                {
                    "expr": "process_runtime_jvm_memory_usage{service_name=\"springboot-otel-demo\", type=\"heap\"}"
                }
            ],
            "fieldConfig": {
                "defaults": {
                    "unit": "bytes"
                }
            },
            "gridPos": {
                "x": 0,
                "y": 0,
                "w": 12,
                "h": 8
            }
        },
        {
            "type": "logs",
            "title": "Application Logs (springboot-otel-demo)",
            "datasource": "Loki",
            "targets": [
                {
                    "expr": "{service_name=\"springboot-otel-demo\"}"
                }
            ],
            "gridPos": {
                "x": 0,
                "y": 8,
                "w": 24,
                "h": 8
            }
        }
    ]
}

6. Erstellen Sie eine Docker-Compose-Datei

Nachdem Sie alle Komponenten konfiguriert haben, können Sie nun eine Docker-Compose-Datei erstellen. Diese Datei definiert und verwaltet alle LGTM-Stack-Dienste an einem Ort, wodurch die Bereitstellung einfach und einheitlich gestaltet wird.

Sie können diesen Schritt überspringen, wenn Sie alle Komponenten manuell ohne Docker installiert haben.

Kehren Sie zunächst in das Verzeichnis grafana-lgtm zurück und erstellen Sie dann eine docker-compose.yml-Datei:

cd ~/grafana-lgtm
sudo nano docker-compose.yml

Fügen Sie die folgende Konfiguration in die Datei ein:

services:

  prometheus:
    image: prom/prometheus:latest
    container_name: prometheus
    volumes:
      - ./prometheus.yml:/etc/prometheus/prometheus.yml:ro
    ports:
      - "9090:9090"

  loki:
    image: grafana/loki:latest
    container_name: loki
    user: "0:0"  # Run as root user
    volumes:
      - ./loki-local-config.yaml:/etc/loki/local-config.yaml:ro
      - loki-data:/tmp/loki
    command: -config.file=/etc/loki/local-config.yaml
    ports:
      - "3100:3100"

  tempo:
    image: grafana/tempo:latest
    container_name: tempo
    user: "0:0"  # Run as root user
    volumes:
      - ./tempo-local.yaml:/etc/tempo/tempo-local.yaml:ro
      - tempo-data:/tmp/tempo
    command: ["-config.file=/etc/tempo/tempo-local.yaml"]
    ports:
      - "3200:3200"   # HTTP query port

  grafana:
    image: grafana/grafana:latest
    container_name: grafana
    environment:
      - GF_SECURITY_ADMIN_USER=admin 
      - GF_SECURITY_ADMIN_PASSWORD=admin 
    volumes:
      - ./grafana/datasources.yml:/etc/grafana/provisioning/datasources/datasources.yml:ro
      - ./grafana/dashboards.yml:/etc/grafana/provisioning/dashboards/dashboards.yml:ro
      - ./grafana/dashboards/:/var/lib/grafana/dashboards:ro
    ports:
      - "3000:3000"
    depends_on:
      - prometheus
      - loki
      - tempo

volumes:
  loki-data: {}
  tempo-data: {}

Ändern Sie die Werte für GF_SECURITY_ADMIN_USER und GF_SECURITY_ADMIN_PASSWORD unter dem Grafana-Dienst. Die vorgegebenen Werte sind Ihre Standard-Anmeldedaten für das Grafana-Dashboard. Ändern Sie sie, um die Sicherheit zu erhöhen.

Vergessen Sie nicht, die Datei nach der Bearbeitung zu speichern.

Stellen Sie anschließend alle Dienste auf Ihrem Server mit folgendem Befehl bereit:

docker compose up -d

Führen Sie folgenden Befehl aus, um zu überprüfen, ob die Dienste reibungslos funktionieren:

docker compose ps

7. Rufen Sie das Grafana-Dashboard auf

Öffnen Sie Ihren Browser und rufen Sie das Grafana-Dashboard über diese URL auf. Ersetzen Sie your_vps_ip durch die tatsächliche IP-Adresse Ihres Servers:

http://your_vps_ip:3000

Wenn Sie Ihren LGTM-Stack auf dem Hostinger VPS hosten, finden Sie Ihre IP-Adresse im hPanel unter VPS → Verwalten → Übersicht → VPS-Details.

Melden Sie sich mit dem Benutzernamen und dem Passwort an, die Sie in der Compose-Datei festgelegt haben. Wenn Sie die Standard-Anmeldedaten verwenden, fordert Grafana Sie auf dem nächsten Bildschirm auf, Ihr Passwort zu ändern.

Auf der Dashboard-Oberfläche finden Sie in der linken Seitenleiste ein Navigationsmenü, und auf der rechten Seite einen Hauptarbeitsbereich, in dem Sie Dashboards anzeigen und verwalten können.

Wenn Sie die Komponenten über Docker Compose eingerichtet haben, fügt Grafana automatisch alle Datenquellen hinzu. Überprüfen Sie diese unter Verbindungen → Datenquellen.

Wenn Sie die Komponenten manuell installiert haben, müssen Sie die Datenquellen selbst hinzufügen. Klicken Sie auf Neue Datenquelle hinzufügen, suchen Sie nach dem Namen der Komponente und wählen Sie diese aus.

Füllen Sie anschließend das URL-Feld für jede Komponente wie folgt aus:

• Loki – http://loki:3100
• Mimir und Prometheus – http://prometheus:9090
• Tempo – http://tempo:3200

Sobald Sie jede Datenquelle eingegeben haben, scrollen Sie nach unten und klicken auf Speichern & testen.

8. Erkunden Sie Ihre Datenquellen

Als Nächstes betrachten wir Ihre Daten, indem wir Abfragen ausführen. Jede Komponente verwendet ihre eigene Abfragesprache: LogQL für Loki, PromQL für Mimir und Prometheus sowie TraceQL für Tempo.

Wählen Sie in der linken Seitenleiste des Dashboards Explore aus und wählen Sie anschließend im oberen Dropdown-Menü Ihre bevorzugte Datenquelle aus.

Klicken Sie für Loki und Prometheus auf den Abschnitt Code. Wählen Sie für Tempo TraceQL aus. Geben Sie Ihre Abfrage ein und drücken Sie Umschalt + Eingabetaste, um sie auszuführen.

Hier finden Sie einige grundlegende Abfragebeispiele für jede Datenquelle:

Loki

{service_name= "my-app"}       # Show all logs for a specific service  
{service_name="my-app"} |= "debug"  # Show only debug logs

Weitere Abfragen finden Sie in der Offizielle LogQL-Dokumentation.

Mimir und Prometheus

{service_name= "my-app"}       # Show all metrics for a specific service  
process_cpu_usage{service_name="my-app"}  # Show CPU usage

Beispiele für fortgeschrittene Abfragen finden Sie in der PromQL-Dokumentation.

Tempo

{ resource.service.name = "my-app" && status = error }         # Show error traces for a specific service  
{ resource.service.name = "my-app" && duration > 500ms }      # Show traces with long durations

Erfahren Sie mehr über Basis- und erweiterte TraceQL-Abfragen auf der entsprechenden Dokumentationsseite.

9. Erstellen Sie ein einheitliches Observability-Dashboard

Öffnen Sie das Menü Dashboards in der linken Seitenleiste, um Ihre Metriken, Protokolle und Traces in einer umfassenden Ansicht darzustellen.

Wenn Sie den LGTM-Stack mit Docker Compose eingerichtet haben, steht Ihnen bereits ein Beispiel-Dashboard zur Verfügung, das einen schnellen Überblick über die Speicherauslastung und die Protokolle von mit OpenTelemetry instrumentierten Anwendungen bietet.

Sie können auch ein neues Dashboard erstellen, indem Sie auf Neu → Neues Dashboard → Visualisierung hinzufügen klicken.

Wählen Sie anschließend eine Datenquelle aus Ihren Komponenten aus. Benennen Sie das Panel im Panel-Editor so um, dass es den Namen der Komponente widerspiegelt, und geben Sie dann Ihre Abfrage in das dafür vorgesehene Feld ein, um die gewünschten Daten anzuzeigen.

Klicken Sie anschließend auf Zurück zum Dashboard → Hinzufügen → Visualisierung und wiederholen Sie diesen Vorgang, um Panels für alle Komponenten hinzuzufügen.

Nachdem Sie die Panels hinzugefügt haben, können Sie nun deren Breite und Höhe mithilfe des Größenreglers in der unteren rechten Ecke jedes Panels anpassen. Sobald Sie die Anpassung abgeschlossen haben, klicken Sie auf Dashboard speichern und geben einen Namen ein, um Ihre Änderungen zu speichern.

10. Fügen Sie Apps zum Observability-System hinzu

Wie Sie bereits im vorherigen Schritt gesehen haben, ist das Dashboard leer, da noch keine zu überwachenden Apps hinzugefügt wurden. Sie können dies auf unterschiedliche Weisen tun.

Da Sie den Stack mit Docker Compose eingerichtet haben, führen wir Sie nun durch das Hinzufügen über OpenTelemetry Collector.

Es handelt sich um einen herstellerneutralen Agenten, der Telemetriedaten aus Ihren Apps erfasst und diese auf standardisierte Weise an die entsprechenden Komponenten weiterleitet.

Um den OpenTelemetry Collector einzurichten, müssen Sie Ihr Terminal öffnen und in das Verzeichnis grafana-lgtm wechseln. Erstellen Sie anschließend mit nano eine Datei namens otel-collector-config.yaml:

cd grafana-lgtm
sudo nano otel-collector-config.yaml

Fügen Sie der Datei die folgende Konfiguration hinzu. Diese Konfiguration empfängt Daten aus Ihren Anwendungen und leitet sie an die richtigen Komponenten weiter:

receivers:
  otlp:
    protocols:
      http:
        endpoint: 0.0.0.0:4318    # Listen on OTLP/HTTP, port should match the Compose definition
      grpc:
        endpoint: 0.0.0.0:4317    # Listen on OTLP/gRPC, optional

processors:
  batch: {}  # Batch processor, sends telemetry data in batches to improve performance

exporters:
  # Export metrics as a Prometheus scraping endpoint
  prometheus:
    endpoint: "0.0.0.0:9464"
    # Enable conversion of Resource attributes to metric labels, ensuring service.name etc. appear in Prometheus labels
    resource_to_telemetry_conversion:
      enabled: true

  # Export logs to Loki via OTLP HTTP (using Loki's native OTLP log receiver)
  otlphttp/loki:
    endpoint: "http://loki:3100/loki/api/v1/push"  # Loki's OTLP log receiver HTTP API
    # Loki receives OTLP logs using otlphttp exporter

  # Export traces to Tempo via OTLP HTTP
  otlphttp/tempo:
    endpoint: "http://tempo:3200/v1/traces"

# Define processing pipelines for each type of telemetry data
service:
  pipelines:
    metrics:
      receivers: [otlp]
      processors: [batch]
      exporters: [prometheus]        # Metrics are processed and exposed in Prometheus format
    logs:
      receivers: [otlp]
      processors: [batch]
      exporters: [otlphttp/loki]     # Logs are processed and sent to Loki (OTLP HTTP)
    traces:
      receivers: [otlp]
      processors: [batch]
      exporters: [otlphttp/tempo]     # Traces are processed and sent to Tempo (OTLP HTTP)

Bearbeiten Sie anschließend Ihre Datei docker-compose.yml und fügen Sie den Dienst otel-collector unter dem bestehenden Abschnitt services hinzu:

  otel-collector:
    image: otel/opentelemetry-collector-contrib:latest
    container_name: otel-collector
    volumes:
      - ./otel-collector-config.yaml:/etc/otel-collector-config.yaml:ro
    command: ["--config", "/etc/otel-collector-config.yaml"]
    ports:
      - "4318:4318"                   # OTLP HTTP
      - "9464:9464"                   # Prometheus metrics
    depends_on:
      - prometheus
      - loki
      - tempo

Starten Sie nach der Aktualisierung der Compose-Datei alle Dienste neu, um die Änderungen zu übernehmen:

docker compose down -v
docker compose up -d

Konfigurieren Sie anschließend Ihre App so, dass sie Telemetriedaten an den OpenTelemetry Collector sendet. Dies hängt von der Sprache und dem Framework Ihrer App ab. Ein Beispiel:

Node.js-basierte Apps

Installieren Sie die erforderlichen OpenTelemetry-Pakete:

npm install @opentelemetry/sdk-node @opentelemetry/exporter-trace-otlp-http @opentelemetry/exporter-metrics-otlp-http @opentelemetry/exporter-logs-otlp-http

Fügen Sie diesen Initialisierungscode in Ihre App ein:

const { NodeSDK } = require('@opentelemetry/sdk-node');
const { OTLPTraceExporter } = require('@opentelemetry/exporter-trace-otlp-http');
const { OTLPMetricExporter } = require('@opentelemetry/exporter-metrics-otlp-http');
const { OTLPLogExporter } = require('@opentelemetry/exporter-logs-otlp-http');
const sdk = new NodeSDK({
traceExporter: new OTLPTraceExporter({
url: 'http://localhost:4318/v1/traces'
}),
metricExporter: new OTLPMetricExporter({
url: 'http://localhost:4318/v1/metrics'
}),
logExporter: new OTLPLogExporter({
url: 'http://localhost:4318/v1/logs'
}),
serviceName: 'my-nodejs-app'
});
sdk.start();

Java-basierte Apps

Laden Sie den OpenTelemetry Java-Agent herunter:

curl -L -o opentelemetry-javaagent.jar https://github.com/open-telemetry/opentelemetry-java-instrumentation/releases/latest/download/opentelemetry-javaagent.jar

Führen Sie Ihre App mit dem integrierten Agenten aus und ersetzen Sie dabei my-app durch den Namen Ihres Dienstes:

java -javaagent:opentelemetry-javaagent.jar \

-Dotel.exporter.otlp.endpoint=http://localhost:4318 \

-Dotel.resource.attributes=service.name=my-app \

-jar your-application.jar

Kehren Sie zu Ihrem Grafana-Dashboard zurück, um zu sehen, wie die Telemetriedaten Ihrer App eingehen. So erhalten Sie Echtzeit-Einblicke in deren Leistung, Protokolle und Ablaufverfolgungen.

Fazit

Der LGTM-Stack vereint Protokolle, Metriken, Traces und Visualisierungen an einem Ort. Diese Integration hilft Ihnen, komplexe Systeme effektiver zu überwachen, die Fehlerbehebung schneller durchzuführen und umsetzbare Erkenntnisse zur Leistungsoptimierung zu gewinnen.

In dieser Anleitung haben wir erläutert, wie Sie den LGTM-Stack auf einem VPS einrichten:

1. Bereiten Sie Ihre Serverumgebung vor.
2. Installieren und konfigurieren Sie Loki zur Erfassung von Protokollen.
3. Richten Sie Mimir ein, um Metriken zu erfassen.
4. Stellen Sie Tempo bereit, um verteilte Anfragen zu verfolgen.
5. Integrieren Sie Grafana für eine zentralisierte Visualisierung.
6. Definieren Sie Dienste mithilfe von Docker Compose.
7. Melden Sie sich beim Grafana-Dashboard an.
8. Führen Sie Abfragen an Ihren Datenquellen durch.
9. Erstellen Sie ein umfassendes Observability-Dashboard.
10. Verbinden Sie Ihre Anwendungen über den OpenTelemetry Collector.

Um Ihre Observability-Konfiguration aufzustocken, können Sie LogQL, TraceQL und PromQL für erweiterte Abfragen nutzen. Sie können Ihrem Dashboard außerdem Warnregeln hinzufügen, um Benachrichtigungen zu erhalten, wenn Leistungskennzahlen oder Protokolle kritische Schwellenwerte erreichen.

Häufig gestellte Fragen (FAQ) zum LGTM-Stack

Alle Tutorial-Inhalte auf dieser Website unterliegen Hostingers strengen redaktionellen Standards und Normen.

Erstellt von

Eveline Boschmann

Eveline ist Lokalisierungsexpertin mit langjähriger Erfahrung in der Transkreation von Inhalten für den deutschen Markt. Sie unterstützt Hostinger dabei, die Kernwerte und die Markenbotschaft des Unternehmens an ein internationales Publikum zu vermitteln und Hostingers hochwertige Tutorials für alle zugänglich zu machen.

Mehr von Eveline Boschmann