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
namespaceundpodan Loki. - LogQL ist die Abfragesprache:
{namespace="app"}wählt Ströme aus, dahinter filtern und zerlegen Stufen wie|= "POST"oder| logfmtdie Zeilen. - Aus Logs werden auch Zahlen:
count_over_timeundratefunktionieren 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 10mErwartet (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 stehenread,writeundbackendausdrücklich auf 0.auth_enabled: falseschaltet die Mandanten ab. Sonst verlangt Loki bei jeder Anfrage einen HeaderX-Scope-OrgID.schemaConfiglegt fest, wie Loki Index und Daten ablegt.tsdbundv13sind der aktuelle Stand, das Datum ist der Stichtag, ab dem dieses Schema gilt.retention_period: 72hmitretention_enabled: Der Compactor löscht Logs nach drei Tagen – wieretention: 3dbei Prometheus.- Gateway, Caches und Canary braucht ein einzelner Prozess nicht.
kubectl -n monitoring get pods -l app.kubernetes.io/name=lokiErwartet:
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 --waitErwartet (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.kubernetesfragt die API nach allen Pods.discovery.relabelmacht aus den Metadaten (__meta_…) die Labels, die in Loki landen. Nur diese vier – jedes weitere Label wäre ein weiterer Index.loki.source.kubernetesliest die Logs der Pods über die Kubernetes-API, so wiekubectl logs. Deshalb genügt ein einzelner Pod alsdeployment.loki.writeschickt alles an den Servicelokiim 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 --quietErwartet:
app
container
instance
job
namespace
pod
service_name
LOKI_ADDRist die Adresse, dielogclivon selbst liest.--quietunterdrückt die Zeile, in derlogcliseine Anfrage an Loki protokolliert.jobundinstancesetztloki.source.kubernetesselbst, etwainstance="app/notes-api-57f4f47769-727k6:notes-api".service_namehast du auch nicht angelegt. Loki leitet es beim Empfang aus anderen Labels ab, hier ausapp– oderunknown_service, wenn keines passt.
logcli labels --quiet appErwartet (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.logclizeigt 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.
/metricsund/healthzloggt es nicht – sonst wäre jede Abfrage von Prometheus eine Logzeile. lastschreibt fast nichts:curl -sSmeldet 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.yamlErwartet:
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 24hErwartet (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/podsdirekt. - 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.