Zum Inhalt springen
Trainingslager IT-Trainingslager

Tag 7: Logs mit Loki und Alloy

Ziel: Alloy sammelt die Logs aller Pods ein, Loki speichert sie, und du fragst sie mit LogQL ab – auf der Kommandozeile und in Grafana. · Dauer: ca. 75 min · Voraussetzung: Tag 6

Briefing

  • Loki speichert Logs wie Prometheus Metriken: als Ströme mit Labels. Anders als eine Volltextsuche indiziert Loki nur die Labels, nicht den Text. Das macht es billig im Betrieb – und verlangt, dass du über Labels einschränkst, bevor du im Text suchst.
  • Alloy ist der Sammler von Grafana. Er findet die Pods über die Kubernetes-API, liest ihre Logs und schickt sie mit Labels wie namespace und pod an Loki.
  • LogQL ist die Abfragesprache: {namespace="app"} wählt Ströme aus, dahinter filtern und zerlegen Stufen wie |= "POST" oder | logfmt die Zeilen.
  • Aus Logs werden auch Zahlen: count_over_time und rate funktionieren wie in PromQL.
 Pods ──► Kubernetes-API ──► Alloy ── push ──► Loki ◄── logcli (:30310)
                                                 ▲
                                               Grafana (Datenquelle Loki)

Drill 1: Loki installieren

Das Chart für Loki liegt als OCI-Artefakt in der GitHub Container Registry. Helm holt es direkt von dort, ein helm repo add ist nicht nötig:

cd ~/obs-lab
cat > loki.yaml <<'EOF'
deploymentMode: Monolithic

loki:
  auth_enabled: false
  commonConfig:
    replication_factor: 1
  storage:
    type: filesystem
  schemaConfig:
    configs:
      - from: "2026-01-01"
        store: tsdb
        object_store: filesystem
        schema: v13
        index:
          prefix: index_
          period: 24h
  limits_config:
    retention_period: 72h
  compactor:
    retention_enabled: true
    delete_request_store: filesystem

singleBinary:
  replicas: 1
  persistence:
    size: 2Gi
  resources:
    requests: {cpu: 100m, memory: 128Mi}
    limits: {memory: 512Mi}

read: {replicas: 0}
write: {replicas: 0}
backend: {replicas: 0}
gateway: {enabled: false}
chunksCache: {enabled: false}
resultsCache: {enabled: false}
lokiCanary: {enabled: false}
test: {enabled: false}
EOF
helm install loki oci://ghcr.io/grafana-community/helm-charts/loki --version 20.4.1 \
  -n monitoring -f loki.yaml --wait --timeout 10m

Erwartet (gekürzt):

Pulled: ghcr.io/grafana-community/helm-charts/loki:20.4.1
...
NAME: loki
NAMESPACE: monitoring
STATUS: deployed
  • deploymentMode: Monolithic: Loki läuft als ein einziger Prozess. Im Großbetrieb teilt man es in Lese-, Schreib- und Hintergrundpfad auf – darum stehen read, write und backend ausdrücklich auf 0.
  • auth_enabled: false schaltet die Mandanten ab. Sonst verlangt Loki bei jeder Anfrage einen Header X-Scope-OrgID.
  • schemaConfig legt fest, wie Loki Index und Daten ablegt. tsdb und v13 sind der aktuelle Stand, das Datum ist der Stichtag, ab dem dieses Schema gilt.
  • retention_period: 72h mit retention_enabled: Der Compactor löscht Logs nach drei Tagen – wie retention: 3d bei Prometheus.
  • Gateway, Caches und Canary braucht ein einzelner Prozess nicht.
kubectl -n monitoring get pods -l app.kubernetes.io/name=loki

Erwartet:

NAME     READY   STATUS    RESTARTS   AGE
loki-0   2/2     Running   0          51s

Der zweite Container ist ein Sidecar wie bei Grafana. Er sammelt Regeln für Loki ein – an Tag 8 bekommt er Arbeit.

Fortschritt speichern? Kostenlos registrieren

Drill 2: Alloy sammelt die Logs

helm repo add grafana https://grafana.github.io/helm-charts
helm repo update grafana
cat > alloy.yaml <<'EOF'
controller:
  type: deployment

alloy:
  resources:
    requests: {cpu: 20m, memory: 64Mi}
    limits: {memory: 256Mi}
  configMap:
    content: |
      discovery.kubernetes "pods" {
        role = "pod"
      }

      discovery.relabel "pods" {
        targets = discovery.kubernetes.pods.targets
        rule {
          source_labels = ["__meta_kubernetes_namespace"]
          target_label  = "namespace"
        }
        rule {
          source_labels = ["__meta_kubernetes_pod_name"]
          target_label  = "pod"
        }
        rule {
          source_labels = ["__meta_kubernetes_pod_container_name"]
          target_label  = "container"
        }
        rule {
          source_labels = ["__meta_kubernetes_pod_label_app_kubernetes_io_name"]
          target_label  = "app"
        }
      }

      loki.source.kubernetes "pods" {
        targets    = discovery.relabel.pods.output
        forward_to = [loki.write.default.receiver]
      }

      loki.write "default" {
        endpoint {
          url = "http://loki:3100/loki/api/v1/push"
        }
      }
EOF
helm install alloy grafana/alloy --version 1.15.0 -n monitoring -f alloy.yaml --wait

Erwartet (gekürzt):

"grafana" has been added to your repositories
...
NAME: alloy
NAMESPACE: monitoring
STATUS: deployed

Die Konfiguration von Alloy ist eine Kette aus Komponenten. Jede hat einen Typ und einen Namen und reicht ihr Ergebnis an die nächste weiter:

  • discovery.kubernetes fragt die API nach allen Pods.
  • discovery.relabel macht aus den Metadaten (__meta_…) die Labels, die in Loki landen. Nur diese vier – jedes weitere Label wäre ein weiterer Index.
  • loki.source.kubernetes liest die Logs der Pods über die Kubernetes-API, so wie kubectl logs. Deshalb genügt ein einzelner Pod als deployment.
  • loki.write schickt alles an den Service loki im selben Namespace.

Fortschritt speichern? Kostenlos registrieren

Drill 3: logcli

Loki hat wie Prometheus ein Werkzeug für die Shell. Damit logcli Loki erreicht, bekommt Loki einen festen NodePort:

cat > loki-extern.yaml <<'EOF'
apiVersion: v1
kind: Service
metadata:
  name: loki-extern
  namespace: monitoring
spec:
  type: NodePort
  selector:
    app.kubernetes.io/name: loki
    app.kubernetes.io/component: single-binary
  ports:
    - port: 3100
      nodePort: 30310
EOF
kubectl apply -f loki-extern.yaml
curl -fsSLO https://github.com/grafana/loki/releases/download/\
v3.7.9/logcli-linux-amd64.zip
unzip -q logcli-linux-amd64.zip
mv logcli-linux-amd64 ~/.local/bin/logcli
rm logcli-linux-amd64.zip
echo 'export LOKI_ADDR=http://localhost:30310' >> ~/.bashrc
export LOKI_ADDR=http://localhost:30310
logcli labels --quiet

Erwartet:

app
container
instance
job
namespace
pod
service_name
  • LOKI_ADDR ist die Adresse, die logcli von selbst liest. --quiet unterdrückt die Zeile, in der logcli seine Anfrage an Loki protokolliert.
  • job und instance setzt loki.source.kubernetes selbst, etwa instance="app/notes-api-57f4f47769-727k6:notes-api".
  • service_name hast du auch nicht angelegt. Loki leitet es beim Empfang aus anderen Labels ab, hier aus app – oder unknown_service, wenn keines passt.
logcli labels --quiet app

Erwartet (gekürzt):

alarm-echo
alertmanager
alloy
grafana
...
last
loki
notes-api
postgres
prometheus
prometheus-node-exporter

Fortschritt speichern? Kostenlos registrieren

Drill 4: LogQL

Die letzten drei Zeilen von notes-api:

logcli query --limit 3 --quiet '{namespace="app", app="notes-api"}'

Erwartet (gekürzt):

2026-11-05T09:08:58Z {instance="app/notes-api-57f4f47769-727k6:notes-api",
pod="notes-api-57f4f47769-727k6"} time=2026-11-05T09:08:58.263Z level=INFO msg=request
method=GET path=/notes status=200 duration_ms=3
...
  • {…} ist der Stream-Selektor. Er muss mindestens ein Label einschränken – Loki durchsucht nie alles.
  • logcli zeigt nur die Labels, in denen sich die Zeilen unterscheiden. Die gemeinsamen (app, namespace …) lässt es weg.

Nur die POST-Anfragen – ein Zeilenfilter:

logcli query --limit 2 --quiet -o raw '{app="notes-api"} |= "method=POST"'

Erwartet:

time=2026-11-05T09:08:57.495Z level=INFO msg=request method=POST ... status=201 ...
time=2026-11-05T09:08:56.497Z level=INFO msg=request method=POST ... status=201 ...

-o raw zeigt nur die Zeile selbst. |= heißt „enthält“, != „enthält nicht“, |~ erlaubt reguläre Ausdrücke.

Die Zeilen von notes-api haben das Format schlüssel=wert – logfmt. Der Parser macht daraus Labels, nach denen du filtern kannst:

logcli query --limit 2 --quiet -o raw \
  '{app="notes-api"} | logfmt | duration_ms > 10'

Erwartet (vielleicht auch keine Zeile – dann war keine Anfrage langsamer):

time=2026-11-05T09:08:58.263Z level=INFO msg=request ... status=200 duration_ms=15
time=2026-11-05T09:08:54.488Z level=INFO msg=request ... status=200 duration_ms=20

duration_ms > 10 vergleicht als Zahl. Die Labels aus dem Parser gibt es nur in dieser Abfrage, im Index von Loki stehen sie nicht.

Fortschritt speichern? Kostenlos registrieren

Drill 5: Zahlen aus Logs

Wie viele Zeilen schreibt jede Anwendung pro Sekunde?

logcli instant-query --quiet \
  'sum by (app) (rate({namespace=~"app|monitoring"}[5m]))'

Erwartet (gekürzt, die Zahlen weichen ab):

[
  ...
  {
    "metric": {
      "app": "notes-api"
    },
    "value": [
      1793869739.156,
      "4.83"
    ]
  },
  ...
  • notes-api schreibt eine Zeile pro Anfrage, also rund fünf pro Sekunde. /metrics und /healthz loggt es nicht – sonst wäre jede Abfrage von Prometheus eine Logzeile.
  • last schreibt fast nichts: curl -sS meldet sich nur bei Fehlern, etwa nach einem Rollout von notes-api.
  • Das Ergebnis ist JSON. Für mehr als einen Blick ist Grafana der bessere Ort.

Fortschritt speichern? Kostenlos registrieren

Drill 6: Loki in Grafana

Grafana hat einen zweiten Sidecar für Datenquellen. Er reagiert auf ConfigMaps mit dem Label grafana_datasource: "1":

cat > loki-datasource.yaml <<'EOF'
apiVersion: v1
kind: ConfigMap
metadata:
  name: loki-datasource
  namespace: monitoring
  labels:
    grafana_datasource: "1"
data:
  loki.yaml: |
    apiVersion: 1
    datasources:
      - name: Loki
        uid: loki
        type: loki
        url: http://loki.monitoring:3100
EOF
kubectl apply -f loki-datasource.yaml

Erwartet:

configmap/loki-datasource created

Der Inhalt ist eine Provisioning-Datei von Grafana: dasselbe Format, das Grafana auch aus /etc/grafana/provisioning liest. Nach einer halben Minute:

curl -s -u admin:lab-grafana-pw-123 localhost:30300/api/datasources \
  | jq -c '.[] | [.name, .uid]'

Erwartet:

["Alertmanager","alertmanager"]
["Loki","loki"]
["Prometheus","prometheus"]

In der Oberfläche: Explore, oben Datenquelle Loki, Editor auf Code, Abfrage {app="notes-api"} | logfmt | status >= 400, Run query. Oben rechts schaltet Live auf fortlaufende Ausgabe wie kubectl logs -f – für alle Pods zugleich.

Fortschritt speichern? Kostenlos registrieren

Kontrollpunkt

logcli query --limit 1 --quiet -o raw '{app="notes-api"} |= "msg=listening"' --since 24h

Erwartet (Zeit und PID weichen ab):

time=2026-11-05T09:04:59.584Z level=INFO msg=listening addr=:8080 version=0.8.0 pid=1

Die Startzeile eines Pods. Alloy hat sie nachträglich geholt: Beim ersten Kontakt mit einem Pod liest er dessen Log von Anfang an.

kubectl -n monitoring get pods -l 'app.kubernetes.io/name in (loki,alloy)'

Erwartet:

NAME                     READY   STATUS    RESTARTS   AGE
alloy-758f96785b-lqndk   2/2     Running   0          112s
loki-0                   2/2     Running   0          2m50s

Challenge

Löse wie an Tag 4 Fehler aus (NOTES_ERROR_RATE=0.2) und finde mit logcli die Fehlermeldung, die notes-api dazu schreibt. Wie lautet sie?

Hinweis: Fehler schreibt notes-api mit level=ERROR. Der Zeilenfilter kommt vor dem Parser – er ist viel billiger.

Lösung

kubectl -n app set env deploy/notes-api NOTES_ERROR_RATE=0.2
kubectl -n app rollout status deploy/notes-api
logcli query --limit 2 --quiet -o raw '{app="notes-api"} |= "level=ERROR"'

Erwartet (gekürzt):

time=... level=ERROR msg=request method=GET path=/notes status=500 duration_ms=0
time=... level=ERROR msg="notes failed" err="storage: request timed out"

Zwei Zeilen pro Fehler: die Ursache aus dem Handler und die Zugriffszeile, die bei Status 500 ebenfalls als ERROR erscheint. Zurücknehmen:

kubectl -n app set env deploy/notes-api NOTES_ERROR_RATE-

Fortschritt speichern? Kostenlos registrieren

Enterprise-Notiz

  • Alloy als DaemonSet: Im Lab liest Alloy die Logs über die API. Bei vielen Pods belastet das den API-Server. Im Betrieb läuft Alloy auf jedem Knoten und liest die Dateien unter /var/log/pods direkt.
  • Objektspeicher: Ein Loki im Betrieb legt Daten in S3, GCS oder Azure Blob ab, nicht ins Dateisystem. Erst dann lässt es sich in Lese- und Schreibpfad aufteilen.
  • Labels sparsam: Faustregel für Loki: wenige Labels mit wenigen Werten – Umgebung, Namespace, Anwendung. Alles andere bleibt im Text und wird beim Abfragen geparst. Warum, zeigt Tag 8.