Logpipelines: ELK und Loki

1) Warum und wann: Logging-Ziele

Beobachtbarkeit und RCA: Debag-Beschleunigung, Post-Mortem, SLO/SLA-Kontrolle.
Sicherheit und Audit: Zugangsspuren, Anomalien, Untersuchungen.
Geschäftsmetriken: Conversion, Payment Flow, PSP-Fehler, Nutzerverhalten.
Compliance: Speicherung, PII-Maskierung, Retention Policies, Legal Hold.

Logtypen: Anwendung, Infrastruktur (kubelet, kube-proxy, CNI, ingress), Netzwerk, Audit, Zahlung, Web-Events, Nginx/Envoy, DB.

2) High-Level-Architekturen

Option A: ELK

Producers → Logshipper (Filebeat/Fluent Bit/Vector) → Logstash/Beats input → Elasticsearch → Kibana/Алертинг

Variante B: Loki

Producers → Promtail/Fluent Bit → Loki distributor/ingester/querier → Grafana/Алертинг

Hybrid

ELK für Volltext-/Facetten-Suche, Loki für kostengünstige skalierbare Speicherung und schnelle Grep-ähnliche Abfragen; Korrelation mit Metriken/Tracks in Grafana.

3) Datenfluss und Verarbeitungsebenen

1. Sammlung: Byte-für-Byte-Tail-Dateien, Journald, Syslog, Stdout-Container, HTTP.
2. Anreicherung: timestamp Normalisierung, host/pod/namespace, env (prod/stage), release, commit SHA, trace/span id.
3. JSON → Flat Fields grok/regex; Nginx/Envoy-Formate; Zahlungssysteme (PSP-Fehlercodes).
4. Filterung/Revision: Schneiden Sie PII (PAN, CVV, E-Mail, Adressen), Geheimnisse, Token.
5. Routing: nach Tenant/Service/Log-Level; hot/warm/cold; in S3/Objektspeicher.
6. Speicherung und Retention: TTL-Richtlinie nach Datenklassen.
7. Zugang/Analytik/Alerta.

4) ELK: Schlüssellösungen

4. 1 Logstash/Beats

Verwenden Sie das Beats/Fluent Bit auf den Knoten für einen einfachen Picker, Logstash als zentrales ETL (Grok, Dissect, Mutate, Geoip, Translate).
Logstash Pools: ingest-ETL, security-ETL, payments-ETL - zur Isolierung von Lasten.

4. 2 Elasticsearch

Sharding: Konzentrieren Sie sich auf die ~ von 20-50 GB pro Shard; Vermeiden Sie „Shard-Explosion“.
Indexstrategie: 'logs- <tenant> - <service> -YYYY. MM. DD' oder Datenstreams; rollover nach Größe/Zeit.

• hot: SSD, 1-7 Tage; warm: HDD, 7-30 Tage; cold: volumetrisch; frozen: minimale Kosten mit langsamerem Zugang.
• Mappings: Felder stark typisieren, 'fielddata' einschränken und dynamische Felder anlegen.
• Cache und Abfragen: Filter nach Keyword-Feldern, Aggregate - ordentlich; pin-to-hot für hochfrequente Suche.

4. 3 Kibana

Spaces für Multi-Tenant.
Saved searches, Lens/TSVB, threshold/metric alerts.
RBAC nach Index-Mustern ('logs-tenant-').

5) Loki: Schlüssellösungen

5. 1 Label-Modell

Labels sind Lokis „Index“. Verwenden Sie eine niedrige Kardinalität: 'cluster', 'namespace', 'app', 'level', 'env', 'tenant'.
Felder mit hoher Kardinalität (uid, request_id) - pro Zeile; bei Anforderung über LogQL'| =','| json','| regexp 'abrufen.

5. 2 Komponenten

Promtail: сбор stdout, files, journald; Parser (JSON, regex, cri).
Distributor/Ingester/Querier/Query-frontend: Skalierung nach Rollen; Abfragen zwischenspeichern.
Object Storage (S3/GCS/MinIO) zur Langzeitspeicherung von Chank-Logs.

5. 3 LogQL-Techniken

Schneller Grep: „{app =“ payments „, level =“ error „} | =“ declined „“

Парсинг JSON: `{app="api"} | json | code="5xx" | unwrap duration | avg()`

Korrelation mit den Metriken: 'rate ({app =' nginx'} | = '200' [5m]) '

6) Vergleich ELK vs Loki (in Kürze)

Suche/Aggregation: ELK ist stärker für komplexe Volltext- und Facettenabfragen; Loki ist grep-like, schnell und günstig.
Kosten: Loki ist bei großen Mengen (Objektspeicher + kleinerer Index) oft günstiger.
Komplexität des Betriebs: ELK erfordert Disziplin in Indizes/ILM, Javu-hipam; Loki sind Label-Disziplinen.
Korrelation mit Metriken/Tracks: Loki integriert sich natürlich in den Grafana/OTel-Stack; Das kann die ELK auch, aber häufiger durch Integrationen.

7) Sicherheit und Compliance

PII-Revision am Rand (Shipper): PAN, E-Mail, Telefon, Adressen, Token maskieren.
TLS im Transit, mTLS zwischen Agenten und Bussen.
RBAC: per-tenant Indizes/Labels; Isolierung von Neimspaces/Räumen.
Secrets hygiene: Umgebungsvariablen ohne Geheimnisse, einzelne Secret Manager.
Legal Hold: Mechanismus zum Einfrieren von Segmenten/Indizes; write-once für strittige Zeiträume.
Löschung/Retention: TTL-Richtlinien nach Datenklasse (prod/stateful/payments/audit).
Audit-Trails für den Zugriff auf Protokolle.

8) Zuverlässigkeit und Durchsatz

Pufferung und Backpressure: lokale Dateien/Laufwerke in Agenten; Retrays mit exponentiellem Backoff.
Idempotency: Felder 'ingest _ id '/' log _ id' zur Vermeidung von Takes bei Wiederholungen.
HA: mindestens 3 Knoten für ES-Master/Loki-Ingester; antiaffinity по AZ.
Quoten und Rate-Limits nach Tenant/Service; Schutz vor „Stürmen“ Protokollierung.
Log-Level-Schema: 'ERROR' eingeschränkt, 'DEBUG' nur temporär über dynamische Flags.

9) Leistung und Tuning

• JVM heap 50% RAM (aber ≤ ~ 30-32 GB pro Knoten), page cache ist wichtig.
• Smart rollover (20-50 GB/shard), 'refresh _ interval' ↑ für ingest-Indizes.
• Vermeiden Sie in Logstash „schwere“ Grok; möglichst JSON-Logging an der Quelle.

• Das richtige Label-Set ist der Schlüssel zur Geschwindigkeit.
• Große Chunks → billiger als Lagerung, aber teurer als Speicher in Ingester; balancieren.
• Query-frontend + Cache (Meme/Redis) für wiederholte Anfragen.

10) FinOps für Protokolle (Kosten)

Reduzierung der Kardinalität von Feldern/Labels.
DEBUG Sampling und dynamische „Log Swiches“.
Rotation: kurz heiß, lang kalt zum Objekt.
Deduplizierung und konsolidierte Nachrichten (Batch).
Archivierung von selten genutzten Logs in billige Speicherklassen.
Daschbord des Wertes: ob'em/data-strimy/lejbly/indeksy/tenanty.

11) Korrelation mit Metriken und Traces (Observability 3-in-1)

Trace-ID/Span-ID in jedes Log (Middleware auf API-Gateways und in Services).
OpenTelemetry: einheitlicher Kontext; Ausführer in Tempo/Jaeger, Metriken in Prometheus/Mimir, Protokolle in Loki/ELK.
Schnelle Szenarien: „alert auf der Metrik → Sprung in die entsprechenden Protokolle → Sprung in die Spur“.

12) Multi-Tenante und Isolation

Namespace-basierte Isolierung (K8s labels), separate index-Muster/labels' tenant'.
Alert/Dashboards/Retenschna-Trennung nach Tenant.
Abrechnung nach Verbrauch: Ingest-Volumen, Lagerung, Anfragen.

13) Überwachung und SLO für das Förderband selbst

SLO ingest: «99. 9% der Protokolle geliefert <X sec".
Search SLO: „p95 requests <Y sec“.
Technische Metriken: queue depth, dropped logs, reprocess rate, error rate parser, ingester/ES nod failure.

14) Typische Einsatzmuster

Managed: Elasticsearch Service/Opensearch, Grafana Cloud Loki.
Self-hosted K8s: StatefulSets für ES/Loki, Anti-Affinität für AZ, PersistentVolumes, Objektspeicher.
Edge-Agenten (Anwendungen in Regionen): Lokaler Puffer + TLS-Kanal an die zentrale ingest.

15) Beispiele für Konfigurationen

15. 1 Promtail (K8s, CRI JSON)

yaml scrape_configs:
- job_name: kubernetes-pods kubernetes_sd_configs:
- role: pod pipeline_stages:
- cri: {}
- json:
expressions:
level: level msg: message trace: trace_id
- labels:
level:
app:
namespace:
- match:
selector: '{namespace="prod"}'
stages:
- regex:
expression: '(?P<pan>\b[0-9]{12,19}\b)'
- replace:
expression: '(?P<pan>\b[0-9]{12,19}\b)'
replace: '[REDACTED_PAN]'
relabel_configs:
- action: replace source_labels: [__meta_kubernetes_pod_label_app]
target_label: app
- action: replace source_labels: [__meta_kubernetes_namespace]
target_label: namespace
- action: replace source_labels: [__meta_kubernetes_pod_node_name]
target_label: node

15. 2 Logstash (ingest und Maskierung)

ruby input {
beats { port => 5044 }
}
filter {
json { source => "message" skip_on_invalid_json => true }
mutate { add_field => { "env" => "%{[kubernetes][labels][env]}" } }
PII mutate {
gsub => [
"message", "\b[0-9]{12,19}\b", "[REDACTED_PAN]",
"message", "(?i)(authorization: Bearer)([A-Za-z0-9\.\-_]+)", "\1[REDACTED_TOKEN]"
]
}
}
output {
elasticsearch {
hosts => ["https://es-hot-1:9200","https://es-hot-2:9200"]
index => "logs-%{[fields][tenant]}-%{[app]}-%{+YYYY. MM. dd}"
ilm_enabled => true ssl => true cacert => "/etc/ssl/certs/ca. crt"
user => "${ES_USER}"
password => "${ES_PASS}"
}
}

16) Alerting und Dashboards (Vorlagen)

Ошибки API: `rate({app="api",level="error"}[5m]) > threshold` → PagerDuty/Telegram.
5xx Splash in Nginx/Envoy; Tropfen ingest in Agenten; Erhöhung der Latenz der Suche.

• Logvolumen nach Diensten/Tenanten.
• Top-Fehlermuster (Code/Ausnahme/Endpunkt).
• Kosten nach Retenche/Speicherklassen.

17) Qualitätsprüfungen (Log-QA)

Logging-Verträge: JSON-Format, Pflichtfelder ('ts', 'level', 'service', 'env', 'trace _ id', 'msg').
Linter logs in CI: Verbot neuer Felder mit hoher Kardinalität ohne Genehmigung.
Kanariendienste: Erzeugung von Referenzprotokollen zur Früherkennung von Regressionen.

18) Häufige Fehler und Anti-Muster

Loki-Labels mit hoher Kardinalität ('user _ id', 'request _ id') → eine Explosion der Erinnerung.
Dynamische Felder in ES ohne Mappings → „Indexexplosion“.
DEBUG in der Produktion „für immer“. Aktivieren Sie nach Flaggen und mit TTL.
Keine PII-Revision.
Eine gemeinsame „monolithische“ Pipeline für alles - bessere Segmente nach Domäne.

19) Umsetzungsplan (in Iterationen)

1. MVP: Agenten + eine Pipeline (Apps), Basis-Dashboards, PII-Revision.
2. Erweiterung: Netzwerk/Infra-Logs, SLO-Alerts, Coreation mit Tracks.
3. FinOps: Retention Matrix, Value Report, Optimierung von Labels/Indizes.
4. Multi-Tenant: Räume, RBAC, Abrechnung nach Verbrauch.
5. Zuverlässigkeit: HA, disaster-drills, Legal Hold.

20) Checkliste Start in prod

• JSON-Format und Pflichtfelder in allen Diensten.
• PII-Maskierung auf Agent/ingest.
• Retenschne-/ILM- oder Bucket-Lifecycle-Richtlinien.
• RBAC/spaces/tenants.
• SLO ingest/Suche und Warnungen.
• Kanarienregister und Lastprüflauf.
• Kosten Dashboards und Bericht über die Eigentümer von Dienstleistungen.
• Runbooks: „Was tun, wenn ingest fällt/Suche langsam/shards rot“.

21) Mini-FAQ

Was soll ich wählen - ELK oder Loki?