Prometheus : collecte de métriques

(Section : Technologie et infrastructure)

Résumé succinct

Prometheus est un standard industriel pour les métriques temporelles : il scrutera les targets sur HTTP, stockera les séries dans TSDB, comptera les agrégats dans BouQL et déclenchera les alertes via Alertmanager. Pour iGaming, c'est la base de l'approche SLO (RED/USE, métriques de paiement d'entreprise), du diagnostic rapide p95/p99 et des solutions automatiques (freeze/rollback).

1) Modèle de données et cardinalité

Métrique :' name {label1 = » v1 », label2 = » v2 »} value @ timestamp'.
Cardinalité = production des capacités de tous les ensembles uniques de labels ; le principal facteur de coût.

• базовые: `service`, `env`, `region`, `instance`, `pod`, `container`, `version`;
• domaines : 'route', 'psp', 'tenant' (attention !), 'game _ provider'.
• Vous ne pouvez pas mettre 'user _ id', 'session _ id', des valeurs aléatoires/hautement codées.

2) Types de métriques

Counter - ne grandit que (par exemple, 'http _ requests _ total').
Gauge est une valeur instantanée (par exemple, « queue _ depth »).
Histogramme/Résumé - Répartition de la latence. Dans la vente - Histogram (avec le support de 'histogram _ quantile ()' et exemplars).
Native Histogrammes - baquets variables, améliorez la précision et économisez de la taille (incluez là où disponible).

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

3) Exportateurs et ce qui est mesuré

Service : votre code (SDK pour Go/Java/Node/Python), RED-Metrics API, Business Metrics (conversion de paiement).
Système : node_exporter, cAdvisor/kubelet.
Tiers : OBD/cache (mysqld_exporter, postgres_exporter, redis_exporter), NGINX/HAProxy, Kafka/RabbitMQ.
OTel-metrics : via OpenTelemetry Collector → Prometheus Remote Write ou Prometheus-receiver → dans la pile générale.

4) Scrape et relabel : comment connecter les targets

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

Utilisez ServiceMonitor/PodMonitor au lieu d'un 'scrape _ configs'manuel.

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 d'annotation (sans Operator, simplifié)

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

5) Stockage : TSDB, WAL et rétention

WAL (Write-Ahead Log) → récupération rapide après le restart.
Compaction : compression des blocs, économie de disque/CPU.
Rétention : conservez les données chaudes pendant 7-30 jours ; à long terme (voir Mise à l'échelle).

• `--storage. tsdb. retention. time=15d`
• `--storage. tsdb. max-block-chunk-segment-size`
• Disque : SSD/NVMe rapide ; éviter les volumes réseau inutiles.

6) BouQL : bases et modèles fréquents

Rate/irate

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

Erreurs et proportion de succès

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

p95 latence

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

Files d'attente/saturation

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

7) Règles d'enregistrement et performances

Comptez les expressions lourdes à l'avance et conservez-les comme séries.

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 : dashboards rapides, moins de charge sur le processeur Prometheus.

8) Alerting и SLO (burn rate)

Alerts à grade (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 : routage par service/région, suppression des doublons, ChatOps.

9) Corrélation avec les traces et les logs

Incluez examplars : cliquable 'trace _ id' dans les bacs des histogrammes.
Mettez les étiquettes « service », « version », « région » pour « release compare » dans les métriques.
Sur les dashboards - annotations de sortie (Git SHA/version).

10) Mise à l'échelle et stockage à long terme

Fédération : Prometheus supérieur agrégent à partir du bas (par job/label filtres).
Remote Write : envoyer des séries à des backends de stockage/clusters à long terme (Thanos/Cortex/Mimir).

Avantages : Rétention infinie, mise à l'échelle horizontale, vue globale.
Inconvénients : exploitation plus difficile, coût.
Sharding par fonction : instances séparées pour les métriques système, les entreprises, la sécurité.

11) Sécurité

TLS/mTLS entre Prometheus ↔ targets/Alertmanager/remote _ write.
Authentification de base/token pour/targets et API (avant la passerelle de proxénétisme).
RBAC : limiter l'accès à l'IU/séries par rôle ; cachez des labels privés.
Hygiène PII : n'écrivez pas PII en métriques ; utilisez des hashs/alias.

12) Kubernetes-pratiques

Prometheus Operator: CRD (ServiceMonitor, PodMonitor, Alertmanager, Prometheus).
kube-state-metrics + cAdvisor → une image complète du cluster.
Tainings et ressources : Nodes dédiés à la surveillance ; limites CPU/RAM.
Réduction du bruit : sélecteurs de label pour les neumspaces de « production », padding scrape_interval là où vous pouvez.

13) Métriques d'affaires et produit

Платежи: `payments_success_total{psp, currency}`, `payment_conversion_ratio`, `ttw_seconds_histogram`.
Activité de jeu : parier/min, tenir des séances comme gauge, drop-off pour les erreurs.
Risque/frod : déclencheurs par anomalie de vitesse/géo ; loger séparément, les métriques sont des agrégats.

14) Coût et performance (FinOps)

Contrôler la cardinalité (tag-revu avant d'ajouter un nouveau label).
Sampling histogrammes/exportateurs rares → 'scrape_interval'↑ pour les cibles non critiques.
Downsampling dans les backends de stockage de longue durée.
Mise en cache des dashboards et large appui sur les règles d'enregistrement.

15) Exemples de « démarrage rapide »

Exportateur RED en annexe (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

Alerts de seuil 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) Chèque de mise en œuvre

1. Définissez un ensemble de mesures de base (RED/USE) et d'indicateurs de domaine.
2. Concilier labels et hyde sur la cardinalité.
3. Configurez scrape/ServiceMonitor, TLS/mTLS, relabel.
4. Incluez des histogrammes pour les chemins clés et les exemples.
5. Créez des règles d'enregistrement pour p95, success ratio, agrégats d'entreprise.
6. Entrez les alertes SLO (burn rate) et la routine Alertmanager.
7. Soulevez les dashboards : service map, release compare, paiements.
8. Décidez de la fédération/remote _ write et restench.
9. Restreindre l'accès (RBAC), vérifier l'absence de PII.
10. Activez les contrôles runbooks et game-day.

17) Anti-modèles

Labels à haute cardinalité (user/session/request_id).
Résumé au lieu d'Histogramme pour les SLO clés → pas de « histogramme _ quantile ».
Scrape « total » sans filtration/rotation → augmentation des coûts et du bruit.
Alert par métriques crues sans SLO → alert fetig.
L'absence d'enregistrement des règles → des dashboards « lourds ».
Confiance dans les métriques sans TLS/mTLS → risque de substitution/fuite.

Résultats

Prometheus donne à la plateforme iGaming une observabilité liée aux objectifs : histogrammes précis, agrégats stables, alertes SLO claires et mise à l'échelle vers une carte multi-régionale. La discipline des labels, les règles d'enregistrement correctes, les liens avec les pistes/logs et l'architecture de stockage réfléchie fournissent des versions rapides et prévisibles p99 même aux moments de pointe.