Prometheus - Raccolta metriche

(Sezione Tecnologia e infrastruttura)

Breve riepilogo

Prometheus è uno standard industriale per le metriche in termini di tempo: elenca i target HTTP, memorizza le serie in TSDB, considera le unità in PromQL e triguerà gli alert tramite Alertmanager. Questo è il fulcro dell'approccio SLO (RED/USE, metriche di pagamento), diagnostica rapida p95/p99 e soluzioni automatiche (freeze/rollback).

1) Modello di dati e cardinalità

Metrica:' name {label1 =» v1», label2 =» v2»} value @ timestamp'.
Cardinalità = l'opera di capacità di tutti i set di etichette uniche; il fattore principale del costo.

• базовые: `service`, `env`, `region`, `instance`, `pod`, `container`, `version`;
• domini: «route», «psp», «tenant» (attento!), «game _ provider».
• Non è possibile inserire 'user _ id', 'sessions _ id', valori casuali/altamente ardinosi.

2) Tipi di metriche

Counter - Cresce solo (ad esempio, 'http _ sollests _ total').
Gauge - Valori istantanei (ad esempio, 'queue _ depth').
Historogram/Summary è la distribuzione della latitanza. In vendita - Historogram (con il supporto dì historogram _ quantile () "e exemplars).
Native Historgrams - Bustette variabili, migliorano la precisione e risparmiano dimensioni (inclusa dove 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) Esportatori e cosa misurare

Servizi: il codice (SDK per Go/Java/Node/Python), le metriche RED API, le metriche aziendali (conversione dei pagamenti).
Sistema: node _ exporter, cAdvisor/kubelet.
Terze parti: database/cache (mysqld _ exporter, postgres _ exporter, redis _ exporter), NGINX/HAProxy, Kafka/RabbitMQ.
Le metriche OTEL - Tramite il Collettore di Prometheus Remote Write o Prometheus-receiver in uno stack comune.

4) Scrape e relabel: come collegare i target

Base dì 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

Usa il ServiceMonitor/PodMonitor invece dello scrape _ configs manuale.

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 annotazione (senza Operator, semplificato)

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

5) Archiviazione: TSDB, WAL e Ritocco

WAL (Write-Ahead Log) consente il ripristino rapido dal restart.
Compressione dei blocchi, risparmio del disco/CPU.
Retenschn: conserva i dati hot 7-30 giorni; a lungo termine - Estrarre (vedere Ridimensionamento).

• `--storage. tsdb. retention. time=15d`
• `--storage. tsdb. max-block-chunk-segment-size`
• Disco: SSD veloce/NVMe; evitare i volumi di rete senza bisogno.

6) PromQL: basi e pattern frequenti

Rate/irate

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

Errori e percentuale di successo

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

p95 latitanza

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

Code/saturazione

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

7) Recording rule e prestazioni

Leggere le espressioni pesanti in anticipo e conservare come 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]))

Inoltre, dashboard veloci, meno pressione per CPU Prometheus.

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: instradamento dei servizi/regioni, soppressione dei duplicati, ChatOps.

9) Correlazione con tracciati e loghi

Abilita il clickab'trace _ id 'nei contenitori di istogrammi.
Inserisci nelle metriche delle etichette «service», «variante», «region» per «release compare».
Sui dashboard - Annotazioni di rilascio (Git SHA/versione).

10) Scalabilità e conservazione a lungo termine

Federazione: Prometheus superiore aggrega da sotto (job/label-filtri).
Remote Write: invia righe a backends a lungo termine/cluster (Thanos/Cortex/Mimir).

I vantaggi sono: retensico infinito, ridimensionamento orizzontale, global view.
Contro, più difficile da usare, costo.
Sharding per funzionalità: istruzioni separate per metriche di sistema, business, sicurezza.

11) Sicurezza

tra Prometheus target/Alertmanager/remote _ write.
Autenticazione base/token per/targets e API (prima del gateway proxy).
RBAC: limitare l'accesso alle serie UI/ruoli; Nascondete le etichette private.
Igiene PII: non scrivere PII nelle metriche; Usa hash/alias.

12) Pratiche Kubernets

Prometheus Operator: CRD (ServiceMonitor, PodMonitor, Alertmanager, Prometheus).
kube-state-metrics + il quadro completo del cluster.
Taining e risorse: nodi di monitoraggio dedicati limiti CPU/RAM.
Riduzione del rumore: selettori discografici per i neimspace «di produzione», padding scrape _ interval dove possibile.

13) Metriche aziendali e prodotto

Платежи: `payments_success_total{psp, currency}`, `payment_conversion_ratio`, `ttw_seconds_histogram`.
Attività di gioco: scommesse/min, mantenimento delle sessioni come gauge, drop-off in caso di errore.
Rischio/frodo: trigger per anomalie di velocità/geo; logica separata, metriche - aggregazioni.

14) Costo e prestazioni (FinOps)

Controllare la cardinalità (tag-review prima di aggiungere una nuova etichetta).
Sampling di istogrammi/esportatori rari di per target non critici.
Downsampling in backend di conservazione a lungo termine.
Cache dei dashboard e supporto ampio su recording rule.

15) Esempi di «partenza rapida»

Esportatore RED nell'applicazione (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

Alert di soglia 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) Assegno-foglio di implementazione

1. Definire un insieme di metriche di base (RED/USE) e prestazioni di dominio.
2. Mettete d'accordo etichette e hyde sulla radicalità.
3. Sistemate il scrape/ServiceMonitor, il TLS/mTLS, il relabel.
4. Attivare gli istogrammi per i percorsi chiave ed exemplars.
5. Creare un recording rule per p95, success ratio, aggregazioni aziendali.
6. Digitare gli alert SLO (burn rate) e il rooting Alertmanager.
7. Sollevare i dashboard: service map, release compare, pagamenti.
8. Scegli la federazione/remote _ write e il retensh.
9. Limitare l'accesso (RBAC), verificare che non ci sia un PII.
10. Attivare i controlli runbooks e game-day.

17) Anti-pattern

Etichette ad alta radicalità (user/pression/sollest _ id).
Summary invece di Historogram per gli SLO chiave non c'è «historogram _ quantale».
Scrape «tutto» senza filtrare/rotare per aumentare i costi e il rumore.
Alert per metriche crude senza SLO → alert-fetig.
La mancanza di recording rule è un «pesante» dashboard.
La fiducia nelle metriche senza è rischiosa.

Riepilogo

Prometheus fornisce alla piattaforma iGaming un'osservabilità legata agli obiettivi: istogrammi precisi, apparecchi stabili, alert SLO chiari e scalabilità a una mappa molto-regionale. La disciplina delle etichette, i recording rule corretti, le relazioni con tracciati/logi e l'architettura di storage elaborata offrono lanci rapidi e p99 prevedibili anche nei momenti di punta.