Prometheus: coleta de métricas

(Secção Tecnologia e Infraestrutura)

Resumo curto

O Prometheus é um padrão industrial para métricas de tempo, que mapeia as metas em HTTP, armazena as séries em TSDB, considera as unidades em PromQL e desencadeia as alertas através do Alertmanager. Para iGaming, é a base de uma abordagem SLO (RED/USE, métricas de pagamento), diagnóstico rápido p95/p99 e soluções automáticas (freeze/rollback).

1) Modelo de dados e cardealidade

Métrica:' name\label1 =» v1», label2 =» v2» a.value @ timestamp'.
Cardinalidade = obra de capacidade de todos os conjuntos exclusivos de editoras; o principal fator de custo.

• базовые: `service`, `env`, `region`, `instance`, `pod`, `container`, `version`;
• domínios: 'road', 'psp', 'tenant' (cuidado!), 'game _ provider'.
• Não é possível colocar 'user _ id', 'sessions _ id', valores aleatórios/altamente ardinosos.

2) Tipos de métricas

Counter - Só cresce (por exemplo, 'http _ requests _ total').
Gauge - Valores instantâneos (por exemplo, 'queue _ depth').
Historograma/Summary - distribuição de laticínios. Em venda, Historogram (com suporte para 'historograma _ quantile ()' e exemplars).
Native Historograms - baquetas variáveis, melhora a precisão e economiza o tamanho (inclua onde estiver disponível).

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 e o que medir

Serviço: seu código (SDK para Go/Java/Node/Python), RED métricas API, métricas de negócios (conversão de pagamentos).
Sistema: node _ expositor, cAdvisor/kubelet.
Terceiros: BD/cachê (mysqld _ exporter, postgres _ exporter, redis _ exposer), NGINX/HAProxy, Kafka/RabbitMQ.
Métricas OTEL: Por meio de OpenTelemetry Collector → Prometheus Remote Write ou Prometheus-receiver → em um stack comum.

4) Scrape e relabel: como ligar tarefas

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

Use o ServiceMonitor/PodMonitor em vez do "scrape _ configs' 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"

Anotação K8s (sem Operator, simplificado)

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

5) Armazenamento: TSDB, WAL e Retenseiro

O WAL (Write-Ahead Jobs) → uma rápida recuperação após a restruturação.
Compactação: compressão de blocos, poupança de disco/CPU.
Retenschn: armazene dados quentes de 7 a 30 dias; longo prazo - Suporte (consulte «Zoom»).

• `--storage. tsdb. retention. time=15d`
• `--storage. tsdb. max-block-chunk-segment-size`
• Disco: SSD rápido/NVMe; evitar volumes de rede sem necessidade.

6) PromQL: base e pattern frequentes

Rate/irate

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

Erros e proporção de sucesso

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

p95 laticínios

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

Filas/saturação

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

7) Recording rulas e desempenho

Leia as expressões pesadas com antecedência e guarde como 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]))

Além disso, dashboards rápidos, menos pressão sobre CPU Prometheus.

8) Alerting и SLO (burn rate)

Alertas de 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: Rotação por serviços/regiões, supressão de duplicados, ChatOps.

9) Correlação com traçados e logs

Inclua o exemplars: Clicabável 'trace _ id' nos tanques de histograma.
Coloque nas métricas de «service», «version», «region» para «release compare».
Em dashboards - anotações de lançamento (Git SHA/versão).

10) Escala e armazenamento duradouro

Federação: O Prometheus superior é adicionado dos filtros inferiores (job/label).
Remote Write: Envia filas para backends de armazenamento/cluster de longa duração (Thanos/Cortex/Mimir).

Benefícios: Retensão infinita, escala horizontal, global view.
Contras, mais difícil de operar, custo.
Sharding em funções: instâncias individuais para métricas de sistemas, negócios, segurança.

11) Segurança

entre o Prometheus e as metas/Alertmanager/remote _ write.
Autenticação básica/token para/targets e API (antes da entrada de proxy).
RBAC: limite o acesso à UI/série por papel; Escondam editoras privadas.
Higiene PII: Não escreva PII em métricas; use hashi/pseudônimos.

12) Práticas Kubernetes

Prometheus Operator: CRD (ServiceMonitor, PodMonitor, Alertmanager, Prometheus).
kube-state-metrics + cAdvisor → o quadro completo do cluster.
Teinings e recursos: nódulos dedicados para monitoramento; limites CPU/RAM.
Redução de ruído: seletores de seleções de «produção» de neymspace, padding scrape _ interval onde possível.

13) Métricas de negócios e produto

Платежи: `payments_success_total{psp, currency}`, `payment_conversion_ratio`, `ttw_seconds_histogram`.
Atividade de jogo: apostas/min, manter sessões como gauge, drop-off em erros.
Risco/frod: desencadeadores de anomalias de velocidade/geo; logas separadas, métricas, unidades.

14) Custo e desempenho (FinOps)

Controle a cardinalidade (tag-revide antes de adicionar uma nova editora).
Sampling histogramas/exportadores raros → 'scrape_interval'↑ para tarefas não críticas.
Downsampling em backends de armazenamento prolongado.
Armazenamento de dashboards e suporte amplo para recording rulas.

15) Exemplos de «partida rápida»

Exportador RED no aplicativo (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

Alertas de limiar 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) Folha de cheque de implementação

1. Defina um conjunto de métricas básicas (RED/USE) e indicadores de domínio.
2. Alinhem as editoras e o hyde para a radicalidade.
3. Configure scrape/ServiceMonitor, TLS/mTLS, relabel.
4. Inclua histogramas para caminhos-chave e exemplars.
5. Crie recording rulas para p95, sucess ratio, unidades de negócios.
6. Digite alertas SLO (burn rate) e root Alertmanager.
7. Levantar dashboards: service map, release compare, pagamentos.
8. Decida sobre a federação/remote _ write e retenções.
9. Restrinja o acesso (RBAC) e verifique se o PII está ausente.
10. Inclua runbooks e game-day de verificação.

17) Anti-pattern

Editoras de alta vitalidade (user/sessions/request _ id).
Summary em vez de Historograma para SLO chave não há 'historograma _ quantile'.
Scrape «tudo» sem filtragem/rotação → aumento de custos e ruídos.
Alertas de métricas cruas sem SLO → alert-faetig.
Falta de recording rures → dashboards «pesados».
Confiança nas métricas sem TLS/mTLS → risco de troca/fuga.

Resumo

O Prometheus dá à plataforma iGaming uma observabilidade ligada aos objetivos: histogramas precisos, unidades estáveis, alertas SLO nítidos e escala para um mapa muito-regional. Disciplina de editoras, recording rales corretos, conexões com traçados/logs e arquitetura de armazenamento elaborada fornecem lançamentos rápidos e p99 previsíveis, mesmo em momentos de pico.