Prometheus: recopilar métricas

(Sección: Tecnologías e Infraestructura)

Resumen breve

Prometheus es el estándar industrial para las métricas en el tiempo: raspará los destinos por HTTP, almacenará las series en TSDB, contará las unidades en PromQL y disparará las alertas a través de Alertmanager. Para iGaming, esta es la base del enfoque SLO (RED/USE, métricas de pagos empresariales), diagnóstico rápido p95/p99 y soluciones automáticas (freeze/rollback).

1) Modelo de datos y cardinalidad

Métrica:' name {label1 =» v1», label2 =» v2»} value @ timestamp'.
Cardinalidad = producto de las capacidades de todos los conjuntos únicos de etiquetas; el principal factor de valor.

• базовые: `service`, `env`, `region`, `instance`, `pod`, `container`, `version`;
• dominios: 'route', 'psp', 'tenant' (¡cuidado!), 'game _ provider'.
• No se pueden poner 'user _ id', 'session _ id', valores aleatorios/altamente cardinales.

2) Tipos de métricas

Counter: sólo crece (por ejemplo, 'http _ requests _ total').
Gauge: valores instantáneos (por ejemplo, 'queue _ depth').
Historia/Resumen: distribuciones de latencia. En venta, Histograma (con soporte para 'histograma _ quantile ()' y exemplares).
Native Histograms - baquetas variables, aumentar la precisión y ahorrar tamaño (activar donde esté 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) Exportadores y qué medir

Servicio: su código (SDK para Go/Java/Node/Python), métricas de API RED, métricas de negocio (conversión de pagos).
Sistema: node_exporter, cAdvisor/kubelet.
Terceros: BD/caché (mysqld_exporter, postgres_exporter, redis_exporter), NGINX/HAProxy, Kafka/RabbitMQ.
OTel-métricas: a través de OpenTelemetry Collector → Prometheus Remote Write o Prometheus-Receiver → en un stack común.

4) Scrape y relabel: cómo conectar targets

Básico '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

Utilice ServiceMonitor/PodMonitor en lugar de "scrape _ configurs' manual.

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 anotación (sin Operator, simplificado)

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

5) Almacenamiento: TSDB, WAL y retén

WAL (Write-Ahead Log) → una recuperación rápida después del reinicio.
Compaction: compresión de bloques, ahorro de disco/CPU.
Retiro: almacene los datos calientes 7-30 días; a largo plazo - sacar (ver «Escala»).

• `--storage. tsdb. retention. time=15d`
• `--storage. tsdb. max-block-chunk-segment-size`
• Disco: SSD/NVMe rápido; evitar los volúmenes de red sin necesidad.

6) PromQL: fundamentos y patrones frecuentes

Rate/irate

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

Errores y porcentaje de éxito

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

p95 latencia

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

Colas/saturación

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

7) Reglas de grabación y rendimiento

Considere las expresiones pesadas con antelación y guárdelas como series.

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

Además: dashboards rápidos, menos carga en la CPU Prometheus.

8) Alerting и SLO (burn rate)

alertas 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: enrutamiento por servicios/regiones, supresión de duplicados, ChatOps.

9) Correlación con trazados y logotipos

Habilite exemplars: clicable 'trace _ id' en baquetas de histogramas.
Coloca en métricas las etiquetas 'service', 'version', 'region' para 'release compare'.
En los dashboards hay anotaciones de lanzamientos (Git SHA/versión).

10) Escalamiento y almacenamiento a largo plazo

Federación: el Prometheus superior se suma desde el inferior (por filtros job/label).
Escritura remota: enviar filas a backends/clústeres de almacenamiento prolongado (Thanos/Cortex/Mimir).

Pros: retoque infinito, escalado horizontal, vista global.
Contras: operación más difícil, costo.
Sharding por funciones: instancias individuales para métricas de sistemas, negocios, seguridad.

11) Seguridad

TLS/mTLS entre Prometheus ↔ targets/Alertmanager/remote _ write.
Autenticación básica/token para/targets y API (antes de la puerta de enlace de proxy).
RBAC: restringir el acceso a UI/series por roles; ocultar etiquetas privadas.
Higiene PII: no escriba PII en métricas; use hashes/alias.

12) Prácticas de Kubernetes

Prometheus Operator: CRD (ServiceMonitor, PodMonitor, Alertmanager, Prometheus).
kube-state-metrics + cAdvisor → una imagen completa del clúster.
Teining y recursos: nodos asignados para monitoreo; límites de CPU/RAM.
Reducción de ruido: selectores de etiquetas para neimspaces de «producción», padding scrape_interval donde sea posible.

13) Métricas de negocio y producto

Платежи: `payments_success_total{psp, currency}`, `payment_conversion_ratio`, `ttw_seconds_histogram`.
Actividad de juego: apuestas/min, mantener las sesiones como gauge, drop-off en caso de errores.
Riesgo/flúor: desencadenantes de anomalías de velocidad/geo; lógica por separado, métricas - agregados.

14) Costo y rendimiento (FinOps)

Controla la cardinalidad (tag-ruge antes de añadir una nueva etiqueta).
Sampling histogramas/exportadores raros → 'scrape_interval'↑ para objetivos no críticos.
Downsampling en backends de almacenamiento a largo plazo.
Almacenamiento en caché de dashboards y un amplio apoyo en las reglas de grabación.

15) Ejemplos de «inicio rápido»

Exportador de RED en la aplicación (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

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 verificación de implementación

1. Defina un conjunto de métricas básicas (RED/USE) y métricas de dominio.
2. Concordar las etiquetas y el hyde en la cardinalidad.
3. Configure scrape/ServiceMonitor, TLS/mTLS, relabel.
4. Incluya histogramas para rutas clave y exemplares.
5. Cree reglas de grabación para p95, ratio de éxito, agregados empresariales.
6. Introduzca las alertas SLO (tasa burn) y la rutina de Alertmanager.
7. Subir dashboards: service map, release compare, pagos.
8. Decida sobre la federación/remote _ write y el retiro.
9. Restringir el acceso (RBAC), comprobar que no hay PII.
10. Habilita la verificación de runbooks y game-day.

17) Anti-patrones

Etiquetas con alta cardinalidad (user/session/request_id).
Resumen en lugar de Histograma para los SLO clave → no hay 'histograma _ quantile'.
Scrape «todo consecutivo» sin filtrar/rotar → el aumento de los costos y el ruido.
Alertas por métricas crudas sin SLO → alert fetig.
La ausencia de reglas de grabación → dashboards «pesados».
Confianza en métricas sin TLS/mTLS → riesgo de sustitución/fuga.

Resultados

Prometheus le da a la plataforma iGaming una capacidad de observación vinculada a los objetivos: histogramas precisos, agregados estables, alertas de SLO claras y escalado a un mapa multi-regional. La disciplina de las etiquetas, las reglas de grabación correctas, las conexiones con tracks/logs y una arquitectura de almacenamiento bien diseñada proporcionan lanzamientos rápidos y un p99 predecible incluso en momentos pico.