Prometeu: măsurători de colectare

(Secțiunea: Tehnologie și infrastructură)

Scurt rezumat

Prometheus este un standard industrial pentru măsurătorile de timp: răzuiește țintele peste HTTP, stochează serii în TSDB, numără agregate în PromQL și declanșează alerte prin Alertmanager. Pentru iGaming, aceasta este baza abordării SLO (RED/USE, business payment metrics), diagnosticarea rapidă p95/p99 și soluții automate (freeze/rollback).

1) Modelul de date și cardinalitatea

Metric: 'name {label1 = "v1", label2 = "v2"} value @ timestamp ".
Cardinalitatea = produsul de putere al tuturor seturilor unice de etichete; principalul factor de cost.

• базовые: "serviciu", "env", "regiune", "instanţă", "pod'," container "," versiune ";
• domeniu: 'route', 'psp', 'chiriaş' (atenţie!), 'game _ provider'.
• Nu puteți pune 'user _ id',' session _ id', valori cardinale aleatorii/mari.

2) Tipuri de valori

Counter - crește numai (de exemplu, „http _ requires _ total”).
Ecartament - valori instantanee (de exemplu, „coadă _ adâncime”).
Histogramă/Rezumat - distribuții de latență. În prod - Histogramă (cu suport pentru „histogramă _ cantitate ()” și exemplare).
Histogramele native sunt găleți variabile care îmbunătățesc precizia și economisesc dimensiunea (includ acolo unde sunt disponibile).

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

3) Exportatorii și ce să măsoare

Serviciu: codul dvs. (SDK pentru Go/Java/Node/Python), metrici RED API, metrici de afaceri (conversie de plată).
Sistem: node_exporter, cAdvisor/kubelet.
Terțe părți: DB/caches (mysqld_exporter, postgres_exporter, redis_exporter), NGINX/HAProxy, Kafka/RabbitMQ.
Metrica OTel: prin OpenTelemetry Collector → Prometheus Remote Write sau Prometheus-receptor → într-o stivă comună.

4) Răzuiți și relabel: cum să conectați țintele

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 через Operatorul Prometheus

Utilizați ServiceMonitor/PodMonitor în loc de manual 'scrape _ configurs'.

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 de adnotare (fără operator, simplificat)

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

5) Stocare: TSDB, WAL și retenție

WAL (Write-Ahead Log) → recuperare rapidă de la repornire.
Compactare: bloc de compresie, disc/CPU economii.
Retenție: Păstrați datele fierbinți timp de 7-30 de zile; pe termen lung - mutare (vezi Scalare).

• '- etaj. tsdb. reținere. timp = 15d '
• '- etaj. tsdb. max-block-chunk-segment-dimensiune "
• Unitate: SSD rapid/NVMe; evitați inutil volumele de rețea.

6) PromQL: fundamente și modele frecvente

Rata/Irate

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

Erori și rate de succes

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

p95 latenţă

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

Cozi/Saturație

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

7) Reguli de înregistrare și performanță

Luați în considerare expresiile grele în avans și stocați ca serie.

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]))

În plus: tablouri de bord rapide, mai puțină încărcare pe procesorul Prometheus.

8) Alertarea и SLO (rata de ardere)

Alerte de tip burn-rate (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: rutare serviciu/regiune, suprimare duplicat, ChatOps.

9) Corelarea cu urme și jurnale

Activați exemplarele: faceți clic pe 'trace _ id' în gălețile histogramei.
Puneți etichetele „service”, „version”, „region” pentru „release compare” în măsurători.
Pe tablouri de bord - adnotări de presă (Git SHA/versiune).

10) Scalare și stocare pe termen lung

Federația: agregatele Prometheus superioare din partea inferioară (prin filtre de locuri de muncă/etichete).
Scriere la distanță: trimiterea rândurilor în backenduri/clustere de stocare pe termen lung (Thanos/Cortex/Mimir).

Pro: retenție infinită, scalare orizontală, vedere globală.
Contra: mai dificil de operat, cost.
Sharding după funcție: instanțe separate pentru măsurători de sistem, afaceri, securitate.

11) Siguranță

TLS/mTLS între Prometheus ↔/Alertmanager/remote _ write obiective.
Autentificare de bază/token pentru/obiective și API (în fața gateway-ului proxy).
RBAC: restricționarea accesului la UI/serie în funcție de rol; ascunde etichete private.
Igiena PII: nu scrieți PII în valori; utilizați hashes/pseudonime.

12) Kubernetes practici

Operator Prometheus: CRD (ServiceMonitor, PodMonitor, Alertmanager, Prometheus).
kube-state-metrics + cAdvisor → o imagine completă a clusterului.
Canalizări și resurse: noduri dedicate pentru monitorizare; Limitele CPU/RAM.
Reducerea zgomotului: selectoare de etichete pentru namespaces „de producție”, căptușire scrape_interval acolo unde este posibil.

13) Măsurători de afaceri și produs

Платежи: 'payments _ success _ total {psp, valute}', 'payment _ conversion _ ratio', 'ttw _ seconds _ histograms'.
Activitate joc: pariuri/min, sesiuni de organizare ca ecartament, drop-off atunci când erori.
Risc/fraudă: declanșatoare pentru anomalii de viteză/geo; logare separat, metrici - agregate.

14) Cost și performanță (FinOps)

Controlați cardinalitatea (revizuirea etichetei înainte de a adăuga o nouă etichetă).
Eșantionarea histogramelor/ → rare ale exportatorilor scrape_interval'↑ pentru obiective non-critice.
Sub-eșantionare în backend-uri de stocare pe termen lung.
Cache-ul tabloului de bord și dependența largă de regulile de înregistrare.

15) Exemple de „start rapid”

RED Exportator în aplicare (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

Alerte prag 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) Lista de verificare a implementării

1. Definiți un set de valori de bază (RED/USE) și valori de domeniu.
2. Coordonează etichetele și ghidează după cardinalitate.
3. Configurați racla/ServiceMonitor, TLS/mTLS, relabel.
4. Includeți histograme pentru căi cheie și exemplare.
5. Creați reguli de înregistrare pentru p95, raportul de succes, agregate de afaceri.
6. Introduceți alerte SLO (rata de ardere) și înrădăcinare Alertmanager.
7. Raise dashboards: service map, release compare, payments.
8. Decideți cu privire la federație/remote _ write și retenție.
9. Restricționați accesul (RBAC), verificați absența PII.
10. Activați runbooks și controale de joc-zi.

17) Anti-modele

Etichete cu cardinalitate ridicată (user/session/request_id).
Rezumat în loc de Histogramă pentru SLO-uri cheie → nu există 'histogram _ quantle'.
Zgârieți „toate într-un rând” fără filtrare/rotație → o creștere a costurilor și a zgomotului.
Alerte privind valorile brute fără SLO → alert-phatig.
Lipsa regulilor de înregistrare → tablouri de bord „grele”.
Încrederea în valori fără TLS/mTLS → riscul de spoofing/scurgere.

Rezumat

Prometheus oferă platformei iGaming obiectivul legat de observabilitate: histograme exacte, agregate stabile, alerte SLO clare, și scalarea la o hartă multi-regiune. Disciplina etichetelor, regulile corecte de înregistrare, link-urile de urmărire/jurnal și o arhitectură de stocare grijulie oferă versiuni rapide și p99 previzibile chiar și în momentele de vârf.