Prometheus: Sammeln von Metriken

(Abschnitt: Technologie und Infrastruktur)

Kurze Zusammenfassung

Prometheus ist ein Industriestandard für Zeitmetriken: Er scrapet Targets über HTTP, speichert Serien in TSDB, zählt Aggregate in PromQL und triggert Alertas über Alertmanager. Für iGaming ist dies die Grundlage des SLO-Ansatzes (RED/USE, Business Payment Metrics), der schnellen p95/p99-Diagnose und der automatischen Lösungen (Freeze/Rollback).

1) Datenmodell und Kardinalität

Metrik:' name {label1 =“ v1“, label2 =“ v2“} wert @ timestamp'.
Kardinalität = Produkt der Kapazitäten aller einzigartigen Labelsets; Hauptkostenfaktor.

• базовые: `service`, `env`, `region`, `instance`, `pod`, `container`, `version`;
• Domains: 'route', 'psp', 'tenant' (Vorsicht!), 'game _ provider'.
• Sie können nicht 'user _ id', 'session _ id', zufällige/hochcardinale Werte setzen.

2) Arten von Metriken

Counter - wächst nur (z.B. 'http _ requests _ total').
Gauge - Momentanwerte (z.B. 'queue _ depth').
Histogramm/Zusammenfassung - Latenzverteilungen. In der Produktion - Histogramm (mit Unterstützung für 'histogram _ quantile ()' und Beispiele).
Native Histograms - Variable Bakets, erhöhen die Genauigkeit und sparen Größe (aktivieren, wo verfügbar).

go var httpLatency = prometheus. NewHistogramVec(
prometheus. HistogramOpts{
Name:  "http_request_duration_seconds",
Help:  "HTTP latency",
Buckets: prometheus. DefBuckets ,//or custom
},
[]string{"route","method"},
)

3) Exporteure und was zu messen

Service: Ihr Code (SDK für Go/Java/Node/Python), rote API-Metriken, Geschäftsmetriken (Zahlungsumwandlung).
System: node_exporter, cAdvisor/kubelet.
Drittanbieter: DB/Caches (mysqld_exporter, postgres_exporter, redis_exporter), NGINX/HAProxy, Kafka/RabbitMQ.
OTel-Metriken: Über den OpenTelemetry Collector → Prometheus Remote Write oder Prometheus-receiver → in einen gemeinsamen Stack.

4) Scrape und Relabel: Wie man Targets verbindet

Basic 'prometheus. yml`

yaml global:
scrape_interval: 15s evaluation_interval: 15s external_labels:
env: "prod"
region: "eu-west"

scrape_configs:
- job_name: 'node'
static_configs:
- targets: ['10. 0. 1. 10:9100','10. 0. 1. 11:9100']

- job_name: 'payments-api'
metrics_path: /metrics scheme: https tls_config:
ca_file: /etc/ssl/ca. crt cert_file: /etc/ssl/tls. crt key_file: /etc/ssl/tls. key relabel_configs:
- source_labels: [__address__]
regex: '(.):\d+'
target_label: instance replacement: '$1'

Kubernetes через Prometheus Operator

Verwenden Sie ServiceMonitor/PodMonitor anstelle der manuellen 'scrape _ configs'.

yaml apiVersion: monitoring. coreos. com/v1 kind: ServiceMonitor metadata: { name: payments-api }
spec:
selector: { matchLabels: { app: payments-api } }
namespaceSelector: { matchNames: [ "prod" ] }
endpoints:
- port: metrics interval: 15s scheme: http relabelings:
- action: replace targetLabel: service replacement: "payments-api"

K8s Anmerkungen (ohne Operator, vereinfacht)

yaml metadata:
annotations:
prometheus. io/scrape: "true"
prometheus. io/port: "9102"
prometheus. io/path: "/metrics"

5) Lagerung: TSDB, WAL und retention

WAL (Write-Ahead Log) → eine schnelle Erholung nach dem Neustart.
Compaction: Komprimieren Sie Blöcke, sparen Sie Festplatte/CPU.
Retention: Speichern Sie heiße Daten 7-30 Tage; langfristig - herausnehmen (siehe „Skalierung“).

• `--storage. tsdb. retention. time=15d`
• `--storage. tsdb. max-block-chunk-segment-size`
• Festplatte: schnelle SSD/NVMe; Vermeiden Sie Netzwerkvolumes unnötig.

6) PromQL: Grundlagen und häufige Muster

Rate/irate

promql rate(http_requests_total{route="/deposit"}[5m])

Fehler und Erfolgsquote

promql sum(rate(http_requests_total{status=~"2..    3.."}[5m]))
/ sum(rate(http_requests_total[5m]))

p95 Latenz

promql histogram_quantile(0. 95,
sum by (le, route) (rate(http_request_duration_seconds_bucket[5m]))
)

Warteschlangen/Sättigung

promql max(queue_depth{queue="withdrawals"}) by (region)

7) Aufzeichnungsregeln und Leistung

Schwere Ausdrücke im Voraus zählen und als Serie speichern.

yaml groups:
- name: api. rules interval: 30s rules:
- record: job:http:request_duration_seconds:p95 expr:
histogram_quantile(0. 95,
sum by (le, job) (rate(http_request_duration_seconds_bucket[5m])))
- record: job:http:success_ratio expr:
sum(rate(http_requests_total{status=~"2..    3.."}[5m]))
/ sum(rate(http_requests_total[5m]))

Plus: schnelle Dashboards, weniger Belastung für die Prometheus CPU.

8) Alerting и SLO (burn rate)

Burn-rate alert (multi-window, multi-burn)

yaml groups:
- name: slo. payments rules:
- alert: PaymentsSLOFastBurn expr: (1 - job:http:success_ratio{job="payments-api"}) > (1 - 0. 999) 14 for: 5m labels: { severity: "page" }
annotations:
summary: "SLO fast burn"
runbook: "https://runbooks/payments/slo"
- alert: PaymentsSLOSlowBurn expr: (1 - job:http:success_ratio{job="payments-api"}) > (1 - 0. 999) 6 for: 1h labels: { severity: "ticket" }

Alertmanager: Routing nach Diensten/Regionen, Deduplizierung, ChatOps.

9) Korrelation mit Traces und Logs

Aktivieren Sie exemplars: anklickbar 'trace _ id' in den Balkendiagramm-Tanks.
Setzen Sie die Etiketten 'service', 'version', 'region' für 'release compare' in die Metriken.
Auf Dashboards gibt es Release Annotationen (Git SHA/Version).

10) Skalierung und Langzeitspeicherung

Federation: Top Prometheus aggregiert von unten (nach Job/Label-Filter).
Remote Write: Senden Sie Zeilen an Long-Term Storage Backends/Cluster (Thanos/Cortex/Mimir).

Vorteile: endlose Retention, horizontale Skalierung, globale Ansicht.
Nachteile: schwieriger Betrieb, Kosten.
Sharding durch Funktionen: getrennte Instanzen für Systemmetriken, Geschäft, Sicherheit.

11) Sicherheit

TLS/mTLS zwischen Prometheus ↔ Targets/Alertmanager/remote _ write.
Basis/Token-Authentifizierung für/targets und API (vor dem Proxy-Gateway).
RBAC: Beschränken Sie den Zugriff auf UIs/Serien nach Rollen; Private Labels verstecken.
PII-Hygiene: Schreiben Sie PII nicht in Metriken; Verwenden Sie Hashes/Aliase.

12) Kubernetes-Praktiken

Prometheus Operator: CRD (ServiceMonitor, PodMonitor, Alertmanager, Prometheus).
kube-state-metrics + cAdvisor → ein vollständiges Bild des Clusters.
Teynings und Ressourcen: dedizierte Nodes für die Überwachung; CPU/RAM-Limits.
Geräuschreduzierung: Label-Selektoren für „produktive“ Neympaces, Padding scrape_interval wo immer möglich.

13) Geschäftsmetriken und Produkt

Платежи: `payments_success_total{psp, currency}`, `payment_conversion_ratio`, `ttw_seconds_histogram`.
Spielaktivität: Wetten/min, Sitzungen als Gauge halten, Drop-Off bei Fehlern.
Risiko/Betrug: Auslöser für Geschwindigkeits-/Geo-Anomalien; logging separat, Metriken sind Aggregate.

14) Kosten und Leistung (FinOps)

Kontrollieren Sie die Kardinalität (Tag-Revue vor dem Hinzufügen eines neuen Labels).
Sampling-Histogramme/seltene Exporteure von → 'scrape_interval'↑ für nicht-kritische Targets.
Downsampling in Langzeit-Backends.
Das Zwischenspeichern von Dashboards und das breite Vertrauen auf Aufzeichnungsregeln.

15) Beispiele für einen „Schnellstart“

RED-Exporteur in der Anwendung (Python)

python from prometheus_client import Counter, Histogram, start_http_server reqs = Counter('http_requests_total','', ['route','method','status'])
lat = Histogram('http_request_duration_seconds','', ['route','method'])
start_http_server(8000)

def handle(req):
with lat. labels(req. route, req. method). time():
status = app(req)
reqs. labels(req. route, req. method, str(status)). inc()
return status

Schwellenalarme p95

promql alert: HighLatencyP95 expr: histogram_quantile(0. 95,
sum by (le, service) (rate(http_request_duration_seconds_bucket[5m]))) > 0. 25 for: 10m labels: { severity: "page", service: "api" }

16) Checkliste Umsetzung

1. Definieren Sie eine Reihe von Basismetriken (RED/USE) und Domänenmetriken.
2. Stimmen Sie Labels und Hyde nach Kardinalität ab.
3. Konfigurieren Sie scrape/ServiceMonitor, TLS/mTLS, relabel.
4. Aktivieren Sie Histogramme für Schlüsselpfade und Beispiele.
5. Erstellen Sie Aufzeichnungsregeln für p95, Erfolgsverhältnis, Geschäftsaggregate.
6. Geben Sie SLO-Alerts (Burn Rate) und Alertmanager-Routing ein.
7. Heben Dashboards: Service-Karte, Release-Vergleich, Zahlungen.
8. Entscheide über Föderation/remote _ write und retention.
9. Zugriff einschränken (RBAC), keine PII prüfen.
10. Aktivieren Sie runbooks und game-day-checks.

17) Anti-Muster

Etiketten mit hoher Kardinalität (user/session/request_id).
Zusammenfassung statt Histogramm für Schlüssel-SLOs → kein 'histogram _ quantile'.
Scrape „nur in Folge“ ohne Filterung/Rotation → steigende Kosten und Lärm.
Alerts für rohe Metriken ohne SLO → alert-fetig.
Fehlende Aufnahmeregeln → „schwere“ Dashboards.
Vertrauen in Metriken ohne TLS/mTLS → das Risiko von Substitutionen/Leckagen.

Ergebnisse

Prometheus gibt der iGaming-Plattform eine zielgebundene Beobachtbarkeit: präzise Histogramme, stabile Aggregate, klare SLO-Alerts und Skalierung auf eine multiregionale Karte. Die Disziplin der Labels, korrekte Recording-Regeln, Trace/Log-Verknüpfungen und eine durchdachte Speicherarchitektur sorgen für schnelle Releases und eine vorhersehbare p99 auch zu Spitzenzeiten.