Prometheus y Grafana

Qué vas a provocar: Levantar un Prometheus sin escribir config y leerle, por su API, los defaults de esta sección: intervalos, timeout, retención, lookback y el up de su único target.

Necesitas: Docker Desktop corriendo e internet para bajar prom/prometheus:v3.13.3 (la imagen de C01, con versión para Apple Silicon). Python 3 de macOS para leer el JSON.

1. Paso 1Copiar

   docker run -d --name prom-lab -p 9090:9090 prom/prometheus:v3.13.3

   Qué deberías ver: Un id largo; la primera vez baja la imagen. Sin -v ni command arranca con el prometheus.yml de ejemplo que trae la imagen, que se lee a sí mismo en localhost:9090.

2. Paso 2Copiar

   sleep 5; curl -s localhost:9090/-/ready

   Qué deberías ver: Prometheus Server is Ready. Si todavía arranca, Service Unavailable (un 503): espera y repite.

3. Paso 3Copiar

   sleep 15; curl -s localhost:9090/api/v1/targets | python3 -c "import json, sys; t = json.load(sys.stdin)['data']['activeTargets'][0]; print(t['scrapeUrl'], t['scrapeInterval'], t['scrapeTimeout'], t['health'])"

   Qué deberías ver: http://localhost:9090/metrics 15s 10s up. El esquema y la ruta son defaults (http y /metrics), los 15 s los escribe el archivo de ejemplo y los 10 s de timeout son el default: el archivo solo los nombra en un comentario. Si dice unknown, todavía no hubo scrape: repite.

4. Paso 4Copiar

   curl -s localhost:9090/api/v1/status/config | python3 -c "import json, sys; print(json.load(sys.stdin)['data']['yaml'])" | grep -E 'evaluation_interval|scrape_timeout'

   Qué deberías ver: evaluation_interval: 15s (del archivo) y scrape_timeout: 10s dos veces, en global y copiado al job: la config cargada ya trae escritos los defaults.

5. Paso 5Copiar

   curl -s localhost:9090/api/v1/status/runtimeinfo | python3 -m json.tool | grep storageRetention
   curl -s localhost:9090/api/v1/status/flags | python3 -m json.tool | grep -E 'lookback-delta|for-grace-period|resend-delay'

   Qué deberías ver: "storageRetention": "15d" (nadie fijó retención), y después "query.lookback-delta": "5m", "rules.alert.for-grace-period": "10m" y "rules.alert.resend-delay": "1m", en orden alfabético.

6. Paso 6Copiar

   curl -s 'localhost:9090/api/v1/query?query=up'

   Qué deberías ver: Un JSON con resultType vector y un resultado: metric con __name__ up, app prometheus, instance localhost:9090 y job prometheus, y value [la hora, "1"]. job e instance los agrega Prometheus; app viene del labels: del archivo de ejemplo.

7. Paso 7Copiar

   docker rm -f -v prom-lab

   Qué deberías ver: prom-lab. Con -v se borra también el volumen anónimo donde quedó la base.

Verificado contra la documentación; no ejecutado aquí.

Qué vas a provocar: Recorrer la cadena entera en tu Mac: un counter en un servicio de juguete, Prometheus que lo lee, una regla que pasa a pending y a firing, Alertmanager y un webhook que hace de tu teléfono.

Necesitas: Docker Desktop con internet para bajar prom/prometheus:v3.13.3 y prom/alertmanager:v0.34.1, y Python 3 de macOS (solo stdlib). Usa los puertos 8000, 5001, 9090 y 9093.

1. Paso 1Copiar

   mkdir -p ~/lab-prom/config ~/lab-prom/am && cd ~/lab-prom
   cat > app.py <<'EOF'
   # app.py: un servicio de juguete con un counter por status (solo stdlib)
   import os, threading, time
   from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
   
   cuenta = {"200": 0, "500": 0}
   
   def trafico():  # 10 requests por segundo; si existe el archivo "fallar", 2 de cada 10 son 500
       i = 0
       while True:
           i += 1
           status = "500" if os.path.exists("fallar") and i % 5 == 0 else "200"
           cuenta[status] += 1  # la línea de código donde empieza la cadena
           time.sleep(0.1)
   
   class Metrics(BaseHTTPRequestHandler):
       def do_GET(self):
           lineas = ["# TYPE demo_requests_total counter"]
           lineas += [f'demo_requests_total{{status="{s}"}} {n}' for s, n in cuenta.items()]
           cuerpo = ("\n".join(lineas) + "\n").encode()
           self.send_response(200)
           self.send_header("Content-Type", "text/plain; version=0.0.4; charset=utf-8")
           self.end_headers()
           self.wfile.write(cuerpo)
   
       def log_message(self, *args):
           pass
   
   threading.Thread(target=trafico, daemon=True).start()
   ThreadingHTTPServer(("", 8000), Metrics).serve_forever()
   EOF
   cat > webhook.py <<'EOF'
   # webhook.py: hace de tu teléfono: imprime cada notificación que manda Alertmanager (solo stdlib)
   import json
   from http.server import BaseHTTPRequestHandler, HTTPServer
   
   class Aviso(BaseHTTPRequestHandler):
       def do_POST(self):
           aviso = json.loads(self.rfile.read(int(self.headers["Content-Length"])))
           for a in aviso["alerts"]:
               print(f'{a["status"].upper()} {a["labels"]["alertname"]} severity={a["labels"].get("severity")}: '
                     f'{a["annotations"].get("summary")} (desde {a["startsAt"][11:19]} UTC)', flush=True)
           self.send_response(200)
           self.end_headers()
   
       def log_message(self, *args):
           pass
   
   HTTPServer(("", 5001), Aviso).serve_forever()
   EOF
   python3 app.py & echo $! > app.pid
   python3 webhook.py & echo $! > webhook.pid
   sleep 1; curl -s localhost:8000/metrics

   Qué deberías ver: # TYPE demo_requests_total counter y dos series: status="200" subiendo (10 por segundo) y status="500" en 0. webhook.py no imprime nada todavía: espera avisos en el puerto 5001. Si macOS pregunta si Python acepta conexiones entrantes, acepta: los contenedores llegan a tu Mac por la red.

2. Paso 2Copiar

   cat > config/prometheus.yml <<'EOF'
   global:
     scrape_interval: 5s
     evaluation_interval: 5s
   rule_files:
     - alerts.yml
   alerting:
     alertmanagers:
       - static_configs:
           - targets: ["am-lab:9093"]
   scrape_configs:
     - job_name: servicio
       static_configs:
         - targets: ["host.docker.internal:8000"]
   EOF
   cat > config/alerts.yml <<'EOF'
   groups:
     - name: lab
       rules:
         - alert: DemoHigh5xxRate
           expr: |
             sum(rate(demo_requests_total{status=~"5.."}[1m]))
               / sum(rate(demo_requests_total[1m])) > 0.05
           for: 1m
           labels:
             severity: page
           annotations:
             summary: "Más de 5 % de 5xx en el servicio de juguete"
   EOF
   cat > am/alertmanager.yml <<'EOF'
   route:
     receiver: webhook
     group_by: [alertname]
     group_wait: 10s
     group_interval: 1m
     repeat_interval: 1h
   receivers:
     - name: webhook
       webhook_configs:
         - url: http://host.docker.internal:5001/
   EOF
   docker run --rm -v "$HOME/lab-prom/config:/cfg:ro" --entrypoint promtool prom/prometheus:v3.13.3 check config /cfg/prometheus.yml
   docker run --rm -v "$HOME/lab-prom/am:/cfg:ro" --entrypoint amtool prom/alertmanager:v0.34.1 check-config /cfg/alertmanager.yml

   Qué deberías ver: promtool: Checking /cfg/prometheus.yml, SUCCESS: 1 rule files found y SUCCESS: /cfg/prometheus.yml is valid prometheus config file syntax; después Checking /cfg/alerts.yml con SUCCESS: 1 rules found. amtool: Checking '/cfg/alertmanager.yml' SUCCESS y la lista de lo que encontró (route, 1 receivers). Los intervalos son de 5 s para no esperar tanto; C01 usa 15 s.

3. Paso 3Copiar

   docker network create lab-prom
   docker run -d --name am-lab --network lab-prom -p 9093:9093 -v "$HOME/lab-prom/am:/etc/alertmanager:ro" prom/alertmanager:v0.34.1
   docker run -d --name prom-lab --network lab-prom -p 9090:9090 -v "$HOME/lab-prom/config:/etc/prometheus:ro" prom/prometheus:v3.13.3
   sleep 15; curl -s -G localhost:9090/api/v1/query --data-urlencode 'query=up' | python3 -c "import json, sys; [print(r['metric']['job'], r['value'][1]) for r in json.load(sys.stdin)['data']['result']]"

   Qué deberías ver: El id de la red y dos ids de contenedor; después, servicio 1: Prometheus (en Docker) ya lee app.py (en tu Mac) por host.docker.internal. En la red lab-prom, Prometheus encuentra a Alertmanager por su nombre, am-lab.

4. Paso 4Copiar

   touch fallar
   for i in $(seq 8); do sleep 15; curl -s localhost:9090/api/v1/alerts | python3 -c "import json, sys; print([(a['labels']['alertname'], a['state']) for a in json.load(sys.stdin)['data']['alerts']] or 'sin alertas')"; done

   Qué deberías ver: Con el archivo fallar, 2 de cada 10 requests son 500. Una línea cada 15 s: sin alertas al principio, [('DemoHigh5xxRate', 'pending')] cuando la fracción pasa del 5 % (a los ≈ 15–25 s) y [('DemoHigh5xxRate', 'firing')] un minuto después (for: 1m). Unos 10 s más tarde (group_wait) aparece en la misma terminal la línea de webhook.py: FIRING DemoHigh5xxRate severity=page: Más de 5 % de 5xx en el servicio de juguete, con la hora de inicio en UTC.

5. Paso 5Copiar

   rm fallar
   sleep 150

   Qué deberías ver: Sin errores nuevos, la ventana de 1 min se vacía: la fracción baja del 5 % a los ≈ 45 s y la alerta vuelve a inactive (sale de /alerts sin pasar por pending). En uno o dos minutos, al siguiente group_interval, webhook.py imprime RESOLVED DemoHigh5xxRate …: el webhook recibe el resuelto porque send_resolved es true por defecto.

6. Paso 6Copiar

   kill $(cat app.pid) $(cat webhook.pid)
   docker rm -f -v prom-lab am-lab
   docker network rm lab-prom
   cd ~ && rm -rf ~/lab-prom

   Qué deberías ver: prom-lab, am-lab y lab-prom: no queda nada.

Verificado contra la documentación; no ejecutado aquí.

Qué vas a provocar: Ver el pull con tus propios ojos: un servicio que solo contesta GETs, y una «ronda» que pregunta cada 2 s, anota up y nota cuando el servicio muere.

Necesitas: Python 3 y curl, que ya vienen en macOS (solo stdlib). Ni Docker ni internet.

1. Paso 1Copiar

   mkdir -p ~/lab-prom && cd ~/lab-prom
   cat > objetivo.py <<'EOF'
   # objetivo.py: un "servicio" que expone /metrics en el formato de texto de Prometheus (solo stdlib)
   import random, threading, time
   from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
   
   atendidos = 0  # contador: solo sube
   en_vuelo = 0   # gauge: sube y baja
   
   def trabajar():  # simula tráfico: cada 0.1 s llega un request que dura un rato
       global atendidos, en_vuelo
       while True:
           en_vuelo = random.randint(0, 4)
           atendidos += 1
           time.sleep(0.1)
   
   class Metrics(BaseHTTPRequestHandler):
       def do_GET(self):
           if self.path != "/metrics":
               self.send_error(404)
               return
           cuerpo = (
               "# HELP demo_requests_total Requests atendidos desde que arrancó el proceso.\n"
               "# TYPE demo_requests_total counter\n"
               f"demo_requests_total {atendidos}\n"
               "# HELP demo_inflight_requests Requests en curso ahora mismo.\n"
               "# TYPE demo_inflight_requests gauge\n"
               f"demo_inflight_requests {en_vuelo}\n"
           ).encode()
           self.send_response(200)
           self.send_header("Content-Type", "text/plain; version=0.0.4; charset=utf-8")
           self.send_header("Content-Length", str(len(cuerpo)))
           self.end_headers()
           self.wfile.write(cuerpo)
   
       def log_message(self, *args):  # sin una línea por request en la terminal
           pass
   
   threading.Thread(target=trabajar, daemon=True).start()
   print("sirviendo /metrics en el puerto 8000", flush=True)
   ThreadingHTTPServer(("", 8000), Metrics).serve_forever()
   EOF

   Qué deberías ver: Sin salida: el archivo queda escrito.

2. Paso 2Copiar

   python3 objetivo.py & echo $! > objetivo.pid
   sleep 1; curl -s -i localhost:8000/metrics

   Qué deberías ver: sirviendo /metrics en el puerto 8000, y la respuesta: HTTP/1.0 200 OK, Content-Type: text/plain; version=0.0.4; charset=utf-8 y seis líneas: un # HELP y un # TYPE por métrica, demo_requests_total (≈ 10 a esa altura) y demo_inflight_requests (entre 0 y 4).

3. Paso 3Copiar

   cat > ronda.py <<'EOF'
   # ronda.py: lo que hace Prometheus en cada scrape, en miniatura (solo stdlib)
   import sys, time, urllib.request
   
   URL = "http://localhost:8000/metrics"
   INTERVALO, TIMEOUT = 2.0, 1.0  # scrape_interval y scrape_timeout de esta ronda
   vueltas = int(sys.argv[1]) if len(sys.argv) > 1 else 4
   antes = None
   for _ in range(vueltas):
       t = time.time()
       try:  # PULL: el que pregunta es el scraper; el servicio solo contesta
           texto = urllib.request.urlopen(URL, timeout=TIMEOUT).read().decode()
           muestras = {}
           for linea in texto.splitlines():
               if linea and not linea.startswith("#"):  # las líneas # HELP y # TYPE son metadatos
                   nombre, valor = linea.rsplit(" ", 1)
                   muestras[nombre] = float(valor)
           up = 1
       except OSError as e:  # conexión rechazada, timeout, DNS: el scrape falló
           muestras, up = {}, 0
           print(f"  scrape falló: {e.__class__.__name__}")
       linea = f"up=1  demo_requests_total={muestras.get('demo_requests_total', 0):.0f}  demo_inflight_requests={muestras.get('demo_inflight_requests', 0):.0f}" if up else "up=0"
       if up and antes:
           linea += f"  rate≈{(muestras['demo_requests_total'] - antes[1]) / (t - antes[0]):.1f}/s"
       print(time.strftime("%H:%M:%S"), linea, flush=True)
       antes = (t, muestras["demo_requests_total"]) if up else None
       time.sleep(max(0.0, INTERVALO - (time.time() - t)))
   EOF
   python3 ronda.py 4

   Qué deberías ver: Cuatro líneas, una cada 2 s: up=1, el contador subiendo ≈ 19 por ronda y, desde la segunda, rate≈9.5–10/s (10 por segundo, menos lo que tarda cada vuelta). El servicio nunca supo de la ronda: solo contestó GETs.

4. Paso 4Copiar

   kill $(cat objetivo.pid)
   python3 ronda.py 2

   Qué deberías ver: Dos veces scrape falló: URLError y una línea up=0. El servicio murió y la ronda lo anota. Con push, un servicio muerto solo deja de mandar, y nadie distingue eso de que no haya habido tráfico.

5. Paso 5Copiar

   python3 objetivo.py & echo $! > objetivo.pid
   sleep 1; python3 ronda.py 2

   Qué deberías ver: up=1 otra vez, con demo_requests_total en ≈ 10–30: el proceso nuevo empezó de 0. Ese salto hacia abajo es un reinicio del counter; rate() lo corrige (sección 2).

6. Paso 6Copiar

   kill $(cat objetivo.pid); cd ~ && rm -rf ~/lab-prom

   Qué deberías ver: Sin salida (zsh avisa que el proceso terminó).

Probado de verdad en un Mac. Pasos corridos tal cual en zsh (con un HOME de prueba) en macOS, con Python 3.14.3 y con 3.9.6 (el python3 de Apple): mismas formas de salida (rate≈9.0–10.0/s; up=0 con URLError al matar el proceso; el counter vuelve a ≈ 10 al reiniciarlo).

Qué vas a provocar: Calcular rate() e increase() a mano con el algoritmo de Prometheus y ver tres cosas: cómo corrige un reinicio, por qué la ventana necesita varias muestras y por qué un gauge no se pasa por rate().

Necesitas: Python 3 de macOS (solo stdlib). Ni Docker ni internet.

1. Paso 1Copiar

   mkdir -p ~/lab-prom && cd ~/lab-prom
   cat > rate.py <<'EOF'
   # rate.py: rate() e increase() como los calcula Prometheus, a partir de muestras (solo stdlib)
   
   def en_ventana(serie, t, w):
       return [(ts, v) for ts, v in serie if t - w < ts <= t]  # (t - w, t]: abierta a la izquierda
   
   def rate(serie, t, w, contador=True):
       m = en_ventana(serie, t, w)
       if len(m) < 2:
           return None  # con menos de 2 muestras no hay resultado: el panel dice "No data"
       (t0, v0), (t1, v1) = m[0], m[-1]
       delta = v1 - v0
       if contador:  # si el valor bajó, el proceso reinició: suma lo que valía antes de caer
           delta += sum(antes for (_, antes), (_, ahora) in zip(m, m[1:]) if ahora < antes)
       medido = t1 - t0
       paso = medido / (len(m) - 1)
       ini, fin = t0 - (t - w), t - t1  # lo que falta medir antes de la 1.a muestra y después de la última
       if ini >= 1.1 * paso:
           ini = paso / 2  # la serie empezó dentro de la ventana: extrapola solo medio paso
       if contador and delta > 0 and v0 >= 0:
           ini = min(ini, medido * v0 / delta)  # nunca extrapola un contador por debajo de 0
       if fin >= 1.1 * paso:
           fin = paso / 2
       return delta * (medido + ini + fin) / medido / w  # por segundo; increase = rate * w
   
   # Un contador leído cada 15 s (t = 7, 22 … 217): sube 6 por scrape (0.4 req/s). El pod reinicia
   # entre t = 157 y t = 172: vuelve a 0 y para t = 172 ya atendió 3 requests.
   x, valor = [], 1000
   for i in range(15):
       t = 7 + 15 * i
       valor = 3 if t == 172 else valor + (6 if i else 0)
       x.append((t, valor))
   print("muestras (t, valor):", x[-8:])
   
   T = 217
   for w in (15, 30, 60, 120):
       r = rate(x, T, w)
       print(f"rate(x[{w}s]):", "sin datos (menos de 2 muestras)" if r is None else f"{r:.3f}/s")
   m = en_ventana(x, T, 120)
   print(f"(último - primero) / tiempo en 2m: {(m[-1][1] - m[0][1]) / (m[-1][0] - m[0][0]):.2f}/s  <- el reinicio da negativo")
   print(f"increase(x[2m]): {rate(x, T, 120) * 120:.1f} requests")
   
   sin_202 = [p for p in x if p[0] != 202]  # se perdió un scrape (timeout, deploy)
   for w in (30, 60):
       r = rate(sin_202, T, w)
       print(f"sin el scrape de t=202, rate(x[{w}s]):", "sin datos" if r is None else f"{r:.3f}/s")
   
   # Un gauge (requests en vuelo) que sube y baja: rate() toma cada bajada por un reinicio
   g = [(7 + 15 * i, v) for i, v in enumerate([3, 5, 2, 6, 4, 3, 5, 2, 4, 3, 6, 2, 3, 5, 4])]
   vals = [v for _, v in en_ventana(g, T, 120)]
   print(f"rate(gauge[2m]): {rate(g, T, 120):.3f}/s  <- no significa nada")
   print(f"avg_over_time(gauge[2m]): {sum(vals) / len(vals):.2f}   max_over_time(gauge[2m]): {max(vals)}")
   EOF

   Qué deberías ver: Sin salida: el archivo queda escrito.

2. Paso 2Copiar

   python3 rate.py | head -n 5

   Qué deberías ver: Las últimas 8 muestras, con el reinicio entre (157, 1060) y (172, 3). rate(x[15s]): sin datos (una sola muestra en la ventana); [30s]: 0.400/s; [60s]: 0.350/s (la ventana empieza justo después del reinicio: Prometheus extrapola hasta el 0 del counter y da 21 / 60 s, lo que atendió el proceso nuevo); [120s]: 0.371/s.

3. Paso 3Copiar

   python3 rate.py | sed -n '6,9p'

   Qué deberías ver: Restar la última menos la primera da -9.72/s: negativo, por el reinicio. increase(x[2m]) da 44.6 requests. Si se pierde el scrape de t = 202, [30s] queda sin datos y [60s] sigue dando 0.350/s. Por eso la regla práctica pide al menos 4 scrapes por ventana: a Prometheus le bastan 2 muestras, pero así aguanta scrapes perdidos.

4. Paso 4Copiar

   python3 rate.py | tail -n 2

   Qué deberías ver: rate(gauge[2m]): 0.158/s, un número sin sentido. avg_over_time da 3.62 y max_over_time da 6: así se lee un gauge.

5. Paso 5Copiar

   cd ~ && rm -rf ~/lab-prom

   Qué deberías ver: Sin salida.

Probado de verdad en un Mac. Pasos corridos tal cual en zsh (con un HOME de prueba) en macOS, con Python 3.9.6, 3.13 y 3.14.3: salidas idénticas, byte a byte. El cálculo sigue extrapolatedRate de promql/functions.go (rama release-3.13): corrección de reinicios, ventana (t − w, t], extrapolación hasta el borde si la muestra está a menos de 1.1 × el paso medio (si no, medio paso) y tope en el 0 del counter.

Qué vas a provocar: Correr las seis métricas del gateway de C01 con tráfico simulado, contar sus series contra la figura y ver qué hace un label sin límite.

Necesitas: Python 3.13 e internet para el pip install (prometheus-client 0.26.0). Ni Docker ni GPU.

1. Paso 1Copiar

   mkdir -p ~/lab-prom && cd ~/lab-prom
   python3.13 -m venv .venv
   .venv/bin/pip install prometheus-client==0.26.0

   Qué deberías ver: Termina con Successfully installed prometheus-client-0.26.0, la versión que fija C01 (no tiene dependencias).

2. Paso 2Copiar

   cat > metricas_c01.py <<'EOF'
   # metricas_c01.py: las seis métricas del gateway de C01 (copiadas de main.py) con tráfico simulado
   import random, sys, time
   from prometheus_client import Counter, Histogram, start_http_server
   
   REQUESTS = Counter(
       "classifier_requests_total", "Requests a /v1/classify por código HTTP, caller y modelo",
       ["status", "source", "model_version"],
   )
   LATENCY = Histogram(
       "classifier_request_latency_seconds", "Latencia total de /v1/classify", ["source"],
       buckets=(0.01, 0.025, 0.05, 0.075, 0.1, 0.15, 0.2, 0.3, 0.5, 1.0, 2.5),
   )
   PREPROCESS = Histogram(
       "classifier_preprocess_seconds", "Decode + resize + normalize (CPU)",
       buckets=(0.002, 0.005, 0.01, 0.02, 0.05, 0.1, 0.25, 0.5),
   )
   INFERENCE = Histogram(
       "classifier_inference_seconds", "Llamada a Triton (round trip)",
       buckets=(0.005, 0.01, 0.02, 0.035, 0.05, 0.075, 0.1, 0.15, 0.3),
   )
   TOP1 = Histogram(
       "classifier_top1_score", "Score top-1 tras softmax", ["model_version"],
       buckets=tuple(round(0.1 * i, 1) for i in range(1, 11)),
   )
   IMAGE_BYTES = Histogram(
       "classifier_image_bytes", "Bytes de la imagen recibida",
       buckets=(1e4, 5e4, 1e5, 2.5e5, 5e5, 1e6, 2.5e6, 5e6, 1e7),
   )
   MODEL_VERSION = "2026-09-01-resnet50-fp16"
   MALO = "--malo" in sys.argv
   if MALO:  # lo que NO hay que hacer: un id como label
       POR_REQUEST = Counter("classifier_requests_by_id_total", "Requests por id", ["request_id"])
   
   start_http_server(8000)  # /metrics en el puerto 8000, en un hilo aparte
   print("sirviendo /metrics en el puerto 8000", flush=True)
   n = 0
   while True:  # un request simulado cada 10 ms, con el mismo patrón que el finally de classify
       n += 1
       status = random.choices(["200", "503", "504", "422"], weights=[90, 4, 4, 2])[0]
       source = random.choice(["mobile", "web", "internal", "other"])
       elapsed = random.lognormvariate(-3.2, 0.5)  # ≈ 40 ms de mediana
       if status == "200":
           PREPROCESS.observe(elapsed * 0.4)
           INFERENCE.observe(elapsed * 0.3)
           TOP1.labels(model_version=MODEL_VERSION).observe(random.betavariate(5, 2))
           IMAGE_BYTES.observe(random.randint(100_000, 300_000))
       REQUESTS.labels(status=status, source=source, model_version=MODEL_VERSION).inc()
       if not 400 <= int(status) < 500:  # como en C01: los 4xx no entran al histograma de latencia
           LATENCY.labels(source=source).observe(elapsed)
       if MALO:
           POR_REQUEST.labels(request_id=f"{n:08x}").inc()  # una serie nueva por request
       time.sleep(0.01)
   EOF

   Qué deberías ver: Sin salida: el archivo queda escrito. Las seis definiciones son copia exacta de main.py; el tráfico es simulado.

3. Paso 3Copiar

   .venv/bin/python metricas_c01.py & echo $! > metricas.pid
   sleep 15; curl -s localhost:8000/metrics | grep 'source="web",status="200"'

   Qué deberías ver: sirviendo /metrics en el puerto 8000 y dos líneas: classifier_requests_total{model_version="2026-09-01-resnet50-fp16",source="web",status="200"} con cientos, y su gemela classifier_requests_created con la hora de nacimiento en segundos (≈ 1.79e+09). Los labels salen en orden alfabético.

4. Paso 4Copiar

   curl -s localhost:8000/metrics | grep -E 'latency_seconds_(bucket\{le="(0.2|\+Inf)",source="web"\}|count\{source="web"\})'

   Qué deberías ver: Tres líneas: el bucket le="0.2" igual o casi igual al total (con ≈ 40 ms de mediana, casi todo cabe bajo 0.2 s), le="+Inf" y _count con el mismo número: los buckets son acumulados.

5. Paso 5Copiar

   curl -s localhost:8000/metrics | grep -c '^classifier_'
   curl -s localhost:8000/metrics | grep -c '^[a-z]'

   Qué deberías ver: 144 y 154. Las 144: 32 de requests (4 status × 4 source × 2), 60 de latencia y 52 de los otros cuatro histogramas (12 + 13 + 14 + 13). Las 10 de diferencia son python_gc_* y python_info; en un pod de Linux se suman las 6 process_*.

6. Paso 6Copiar

   kill $(cat metricas.pid)
   .venv/bin/python metricas_c01.py --malo & echo $! > metricas.pid
   sleep 10; curl -s localhost:8000/metrics | grep -c '^classifier_requests_by_id'
   sleep 10; curl -s localhost:8000/metrics | grep -c '^classifier_requests_by_id'

   Qué deberías ver: Unas 1,600 y unas 3,200: dos series nuevas por request (_total y _created), sin techo. El /metrics pasa de ≈ 14 KB a ≈ 240 KB en 20 s; en Prometheus, cada una sería una serie más en memoria y en el índice.

7. Paso 7Copiar

   kill $(cat metricas.pid); cd ~ && rm -rf ~/lab-prom

   Qué deberías ver: Sin salida (zsh avisa que el proceso terminó).

Probado de verdad en un Mac. Pasos 2 a 7 corridos tal cual en zsh (con un HOME de prueba) en macOS, con un venv que ya tenía prometheus-client 0.26.0 y Python 3.13.16; el paso 1 (venv y pip) no se corrió: 144 y 154 series a los 15 s; con --malo, 1,622 y 3,264 series a los 10 y 20 s, y el /metrics creció de 13.6 KB a 240 KB.

Qué vas a provocar: Escribir un prometheus.yml propio: un job vivo con un label y un relabel, uno muerto, un metric_relabel que tira series, y dos recargas, una rota y una buena.

Necesitas: Docker Desktop con internet para bajar prom/prometheus:v3.13.3, y Python 3 de macOS (solo stdlib). Los sed -i '' son la sintaxis de macOS.

1. Paso 1Copiar

   mkdir -p ~/lab-prom/config && cd ~/lab-prom
   cat > mini.py <<'EOF'
   # mini.py: un target mínimo con /metrics (solo stdlib)
   import time
   from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
   
   T0 = time.time()
   
   class Metrics(BaseHTTPRequestHandler):
       def do_GET(self):
           n = int((time.time() - T0) * 10)  # "requests atendidos": 10 por segundo
           cuerpo = f"# TYPE demo_requests_total counter\ndemo_requests_total {n}\n".encode()
           self.send_response(200 if self.path == "/metrics" else 404)
           self.send_header("Content-Type", "text/plain; version=0.0.4; charset=utf-8")
           self.end_headers()
           self.wfile.write(cuerpo)
   
       def log_message(self, *args):
           pass
   
   ThreadingHTTPServer(("", 8000), Metrics).serve_forever()
   EOF
   python3 mini.py & echo $! > mini.pid
   sleep 1; curl -s localhost:8000/metrics

   Qué deberías ver: # TYPE demo_requests_total counter y demo_requests_total ≈ 10 (sube 10 por segundo). Si macOS pregunta si Python acepta conexiones entrantes, acepta: el contenedor llega a tu Mac por la red.

2. Paso 2Copiar

   cat > config/prometheus.yml <<'EOF'
   global:
     scrape_interval: 15s
   scrape_configs:
     - job_name: servicio
       static_configs:
         - targets: ["host.docker.internal:8000"]
           labels:
             env: lab
       relabel_configs:
         - target_label: instance
           replacement: mi-mac
     - job_name: fantasma
       static_configs:
         - targets: ["host.docker.internal:8001"]
     - job_name: prometheus
       static_configs:
         - targets: ["localhost:9090"]
       metric_relabel_configs:
         - source_labels: [__name__]
           regex: "go_.*"
           action: drop
   EOF
   docker run --rm -v "$HOME/lab-prom/config:/cfg:ro" --entrypoint promtool prom/prometheus:v3.13.3 check config /cfg/prometheus.yml

   Qué deberías ver: Checking /cfg/prometheus.yml y SUCCESS: /cfg/prometheus.yml is valid prometheus config file syntax.

3. Paso 3Copiar

   docker run -d --name prom-lab -p 9090:9090 -v "$HOME/lab-prom/config:/etc/prometheus:ro" prom/prometheus:v3.13.3
   sleep 20

   Qué deberías ver: Un id largo. Montas la carpeta, no el archivo suelto, en la ruta que usa el CMD de la imagen: así las ediciones de los pasos 6 y 7 se ven adentro.

4. Paso 4Copiar

   curl -s -G localhost:9090/api/v1/query --data-urlencode 'query=up' | python3 -c "import json, sys; [print(r['metric'], r['value'][1]) for r in json.load(sys.stdin)['data']['result']]"

   Qué deberías ver: Tres líneas, en cualquier orden: servicio con instance mi-mac y env lab, en 1; fantasma con instance host.docker.internal:8001, en 0; prometheus con instance localhost:9090, en 1. En http://localhost:9090/targets, fantasma está DOWN con un error que termina en connect: connection refused.

5. Paso 5Copiar

   curl -s -G localhost:9090/api/v1/query --data-urlencode 'query=scrape_samples_scraped{job="prometheus"} - scrape_samples_post_metric_relabeling{job="prometheus"}' | python3 -c "import json, sys; print(json.load(sys.stdin)['data']['result'][0]['value'][1])"

   Qué deberías ver: Un número de decenas: las series go_* que Prometheus leyó de sí mismo y metric_relabel_configs tiró antes de guardarlas. Una consulta a {__name__=~"go_.*"} vuelve vacía.

6. Paso 6Copiar

   sed -i '' 's#"host.docker.internal:8001"#"http://host.docker.internal:8001"#' config/prometheus.yml
   docker kill -s HUP prom-lab; sleep 2
   docker logs prom-lab 2>&1 | grep 'Error reloading config' | tail -n 1
   curl -s localhost:9090/metrics | grep '^prometheus_config_last_reload_successful'

   Qué deberías ver: Una línea con msg="Error reloading config" cuyo err termina en is not a valid hostname (el target con http:// adelante), y prometheus_config_last_reload_successful 0, leído directo del /metrics del propio Prometheus. Los targets siguen como antes: una recarga fallida no tira la config vieja.

7. Paso 7Copiar

   sed -i '' 's#"http://host.docker.internal:8001"#"host.docker.internal:8001"#; s/15s/5s/' config/prometheus.yml
   docker kill -s HUP prom-lab; sleep 10
   curl -s localhost:9090/api/v1/targets | python3 -c "import json, sys; [print(t['labels']['job'], t['scrapeInterval'], t['health']) for t in json.load(sys.stdin)['data']['activeTargets']]"

   Qué deberías ver: servicio 5s up, fantasma 5s down y prometheus 5s up: la recarga funcionó sin reiniciar el contenedor, y prometheus_config_last_reload_successful vuelve a 1. Si alguno dice unknown, todavía no hubo scrape con la config nueva: repite.

8. Paso 8Copiar

   kill $(cat mini.pid); docker rm -f -v prom-lab; cd ~ && rm -rf ~/lab-prom

   Qué deberías ver: prom-lab, y la carpeta borrada.

Verificado contra la documentación; no ejecutado aquí.

Qué vas a provocar: Hacerle a un Prometheus de verdad las consultas de esta sección, sobre sus propias métricas, y ver tres errores: = con una regex, rate sin ventana y una división sin pareja.

Necesitas: Docker Desktop corriendo, Python 3 (solo stdlib) e internet para bajar prom/prometheus:v3.13.3 (una vez).

1. Paso 1Copiar

   mkdir -p ~/lab-prom && cd ~/lab-prom
   docker run -d --name prom-lab -p 9090:9090 prom/prometheus:v3.13.3
   cat > q.py <<'EOF'
   # q.py: manda una consulta PromQL a la API de Prometheus y resume la respuesta (solo stdlib)
   import json, sys, urllib.error, urllib.parse, urllib.request
   
   def tamano(s):                                   # para ordenar: el valor, o cuántas muestras si es un rango
       return float(s["value"][1]) if "value" in s else len(s["values"])
   
   url = "http://localhost:9090/api/v1/query?" + urllib.parse.urlencode({"query": sys.argv[1]})
   try:
       r = json.load(urllib.request.urlopen(url))
   except urllib.error.HTTPError as e:              # 400: Prometheus no pudo leer la consulta
       r = json.load(e)
   if r["status"] != "success":
       sys.exit("error: " + r["error"])
   d = r["data"]
   print(d["resultType"], "·", len(d["result"]), "serie(s)")
   for s in sorted(d["result"], key=tamano, reverse=True)[:4]:   # solo las 4 de valor más alto
       labels = {k: v for k, v in s["metric"].items() if k != "__name__"}
       valor = s["value"][1] if "value" in s else f'{len(s["values"])} muestras'
       print(" ", s["metric"].get("__name__", ""), labels, "=", valor)
   EOF
   sleep 20; python3 q.py up

   Qué deberías ver: Un id largo y después vector · 1 serie(s): up con app prometheus, instance localhost:9090 y job prometheus, = 1. La imagen trae una config de ejemplo que se lee a sí misma cada 15 s; q.py manda la consulta a /api/v1/query, cuenta las series y muestra las 4 de valor más alto.

2. Paso 2Copiar

   sleep 15
   python3 q.py 'prometheus_http_requests_total{handler="/api/v1/query"}'
   python3 q.py 'prometheus_http_requests_total{handler="/api/v1/.*"}'
   python3 q.py 'prometheus_http_requests_total{handler=~"/api/v1/.*"}'

   Qué deberías ver: El sleep le da tiempo a Prometheus de leerse a sí mismo y ver tus consultas. La primera encuentra una serie, con code 200: cuenta tus propias consultas a /api/v1/query. La segunda da vector · 0 serie(s), sin ningún error: = busca el texto literal «/api/v1/.*». La tercera encuentra decenas de series, una por cada ruta de /api/v1/ (Prometheus crea en 0 la serie de cada ruta al arrancar), con /api/v1/query arriba: =~ toma la regex, anclada a todo el valor.

3. Paso 3Copiar

   python3 q.py 'rate(prometheus_http_requests_total)'
   python3 q.py 'prometheus_http_requests_total{handler="/metrics"}[1m]'
   python3 q.py 'sum by (handler) (rate(prometheus_http_requests_total[1m]))'

   Qué deberías ver: La primera sale con un error que termina en expected type range vector in call to function "rate", got instant vector: rate necesita una [ventana]. La segunda es un range vector: matrix · 1 serie(s) con unas 4 muestras (un scrape cada 15 s en una ventana de 1 min; menos si Prometheus lleva menos de un minuto arriba). La tercera da una serie por handler (decenas, casi todas en 0), ya sin code ni instance. Arriba sale /metrics, cerca de 0.0667 (un scrape cada 15 s), junto a /api/v1/query si hiciste consultas en el último minuto.

4. Paso 4Copiar

   python3 q.py 'topk(2, sum by (handler) (rate(prometheus_http_requests_total[5m])))'
   python3 q.py 'sum by (handler) (rate(prometheus_http_requests_total[5m])) / sum(rate(prometheus_http_requests_total[5m]))'
   python3 q.py 'sum by (handler) (rate(prometheus_http_requests_total[5m])) / ignoring(handler) group_left sum(rate(prometheus_http_requests_total[5m]))'
   python3 q.py 'sum(rate(prometheus_http_requests_total[1m] offset 1m))'

   Qué deberías ver: topk(2, …): las dos rutas con más tráfico, con su label handler. La división sin pareja da vector · 0 serie(s), otra vez sin error: a la izquierda cada serie tiene handler y a la derecha no hay labels. Con ignoring(handler) group_left sale la fracción del tráfico de cada handler (todas juntas suman 1). La última es la tasa total de hace un minuto: offset va pegado al selector, dentro del rate. Si sale vacía, Prometheus lleva menos de 2 minutos arriba y esa ventana todavía no tiene 2 muestras: repítela en un minuto.

5. Paso 5Copiar

   docker rm -f -v prom-lab
   cd ~ && rm -rf ~/lab-prom

   Qué deberías ver: prom-lab, y la carpeta borrada.

Verificado contra la documentación; no ejecutado aquí.

Qué vas a provocar: Sacar el p99 de dos pods a mano, como histogram_quantile, ver por qué el promedio de los p99 engaña y los cuatro casos en que el número le miente a una alerta.

Necesitas: Python 3, sin paquetes extra. Ni Docker ni Prometheus.

1. Paso 1Copiar

   mkdir -p ~/lab-prom && cd ~/lab-prom
   cat > hq.py <<'EOF'
   # hq.py: el p99 de dos pods con histogram_quantile, como lo calcula Prometheus (solo stdlib)
   import math
   
   BORDES = (0.01, 0.025, 0.05, 0.075, 0.1, 0.15, 0.2, 0.3, 0.5, 1.0, 2.5, math.inf)  # los de main.py, más +Inf
   PODS = {"pod-a": [0.03] * 48 + [0.06] * 2,                # 50 requests, todos rápidos
           "pod-b": [0.04] * 44 + [0.18] * 2 + [0.26] * 4}   # 50 requests, 4 lentos
   
   def acumulado(latencias):                        # lo que exporta /metrics: _bucket{le} cuenta las <= le
       return {b: float(sum(1 for x in latencias if x <= b)) for b in BORDES}
   
   def histogram_quantile(q, acum):                 # la regla de Prometheus para histogramas clásicos
       bordes = sorted(acum)
       if len(bordes) < 2 or bordes[-1] != math.inf or acum[math.inf] == 0:
           return math.nan                          # sin +Inf o sin observaciones: NaN
       r = q * acum[math.inf]                       # la posición buscada: 0.99 × total
       for i, b in enumerate(bordes):
           if acum[b] >= r:                         # el primer bucket que llega a r
               if b == math.inf:
                   return bordes[-2]                # cayó en +Inf: devuelve el último borde finito
               ini, antes = (bordes[i - 1], acum[bordes[i - 1]]) if i else (0.0, 0.0)
               return ini + (b - ini) * (r - antes) / (acum[b] - antes)  # línea recta dentro del bucket
   
   if __name__ == "__main__":
       pods = {p: acumulado(lat) for p, lat in PODS.items()}
       for p, acum in pods.items():
           print(f"{p}: " + " ".join(f"{'+Inf' if b == math.inf else b}:{c:.0f}" for b, c in acum.items()))
       p99 = {p: histogram_quantile(0.99, a) for p, a in pods.items()}
       print("p99 de cada pod:", ", ".join(f"{p} {v * 1000:.1f} ms" for p, v in p99.items()))
       print(f"promedio de los dos p99: {sum(p99.values()) / 2 * 1000:.1f} ms   <- no significa nada")
       suma = {b: pods["pod-a"][b] + pods["pod-b"][b] for b in BORDES}   # sum by (le)
       print("sum by (le):", " ".join(f"{'+Inf' if b == math.inf else b}:{c:.0f}" for b, c in suma.items()))
       print(f"r = 0.99 x {suma[math.inf]:.0f} = {0.99 * suma[math.inf]:.0f}: cae entre le=0.2 ({suma[0.2]:.0f}) y le=0.3 ({suma[0.3]:.0f})")
       for q in (0.5, 0.9, 0.99):
           print(f"histogram_quantile({q}, sum by (le)) = {histogram_quantile(q, suma) * 1000:.1f} ms")
       reales = sorted(PODS["pod-a"] + PODS["pod-b"])
       print(f"p99 real (el request 99 de 100, ordenados): {reales[98] * 1000:.0f} ms")
   EOF
   python3 hq.py

   Qué deberías ver: Los buckets acumulados de cada pod (pod-b: 0, 0, 44, 44, 44, 44, 46, 50…: le=0.3 ya incluye todo). p99 de pod-a: 68.8 ms; de pod-b: 287.5 ms; su promedio, 178.1 ms. sum by (le) suma bucket por bucket (… 0.2:96 0.3:100 …) y r = 99 cae entre esos dos. histogram_quantile da 38.6 ms (p50), 49.5 ms (p90) y 275.0 ms (p99); el p99 real es 260 ms, dentro del bucket (0.2, 0.3]. El promedio de los p99 lo escondía.

2. Paso 2Copiar

   cat > casos.py <<'EOF'
   # casos.py: cuatro casos en los que histogram_quantile engaña a una alerta (solo stdlib)
   import math
   from hq import BORDES, acumulado, histogram_quantile
   
   def ms(v):
       return "NaN" if math.isnan(v) else f"{v * 1000:.1f} ms"
   
   # 1. Cuatro requests tardan 4 s: el p99 real es 4000 ms
   lentos = acumulado([0.03] * 96 + [4.0] * 4)
   print("1. cae en +Inf:", ms(histogram_quantile(0.99, lentos)), "(el real es 4000 ms)")
   # 2. Sin tráfico en la ventana: rate() da 0 en todos los buckets
   print("2. sin tráfico:", ms(histogram_quantile(0.99, {b: 0.0 for b in BORDES})), "-> NaN > 0.2 es falso: no dispara")
   # 3. sum(...) sin by (le): queda una sola serie, sin label le; histogram_quantile la
   #    descarta, así que no le queda nada que calcular
   series = [({}, sum(lentos.values()))]             # sum(rate(..._bucket[5m])): {} = sin labels
   con_le = [s for s in series if "le" in s[0]]
   print("3. sin le:", con_le, "(vacío): la alerta nunca dispara")
   # 4. Sin rate(): los buckets cuentan desde que arrancó el pod
   hora_lenta = acumulado([0.4] * 3600)              # la primera hora: 3,600 requests de 400 ms
   ultimos_5m = acumulado([0.03] * 300)              # los últimos 5 minutos: 300 requests de 30 ms
   desde_inicio = {b: hora_lenta[b] + ultimos_5m[b] for b in BORDES}
   print("4. sin rate(), desde que arrancó:", ms(histogram_quantile(0.99, desde_inicio)))
   print("   con rate(...[5m]), lo de ahora:", ms(histogram_quantile(0.99, ultimos_5m)))
   EOF
   python3 casos.py

   Qué deberías ver: 1. cae en +Inf: 2500.0 ms (el real es 4000 ms). 2. sin tráfico: NaN. 3. sin le: [] (vacío). 4. sin rate(), desde que arrancó: 497.8 ms; con rate(...[5m]), lo de ahora: 49.8 ms. Los cuatro dejan una alerta callada o equivocada sin dar ningún error.

3. Paso 3Copiar

   cd ~ && rm -rf ~/lab-prom

   Qué deberías ver: Sin salida.

Probado de verdad en un Mac. Ejecutado en macOS con Python 3.9.6, 3.13.15 y 3.14.3: salidas idénticas. histogram_quantile sigue la regla documentada para histogramas clásicos: interpolación lineal dentro del bucket, 0 como borde inferior del primero, el último borde finito si cae en +Inf y NaN sin observaciones.

Qué vas a provocar: Validar las reglas reales de C01 con promtool y escribir una prueba unitaria que demuestre el for de TritonNotReady: pending a los 8 minutos, firing a los 10.

Necesitas: Docker Desktop corriendo, internet para bajar prom/prometheus:v3.13.3 (una vez) y el repo del curso (el paso 1 copia alerts.yml desde su raíz). Usa el sed de macOS (BSD): en Linux es sed -i sin las comillas vacías.

1. Paso 1Copiar

   mkdir -p ~/lab-prom
   cp apps/ml-system-design/reference/c01/monitoring/alerts.yml ~/lab-prom/
   cd ~/lab-prom
   docker run --rm -v "$PWD":/w -w /w --entrypoint promtool prom/prometheus:v3.13.3 check rules alerts.yml

   Qué deberías ver: Checking alerts.yml y debajo SUCCESS: 7 rules found (1 de grabación y 6 alertas). El cp se corre desde la raíz del repo del curso. El README de C01 dice que nunca se corrió promtool: este es ese chequeo.

2. Paso 2Copiar

   cat > prueba.yml <<'EOF'
   # prueba.yml: TritonNotReady (for: 5m) con una réplica menos desde el minuto 4
   rule_files:
     - alerts.yml
   evaluation_interval: 1m
   tests:
     - interval: 1m
       input_series:
         # 2 réplicas de 0 a 3 min; 1 réplica de 4 a 14 min
         - series: 'kube_deployment_status_replicas_available{namespace="classifier", deployment="triton"}'
           values: '2x3 1x10'
       alert_rule_test:
         - eval_time: 8m  # 4 min abajo: pending, todavía no firing
           alertname: TritonNotReady
           exp_alerts: []
         - eval_time: 10m  # ya pasó el for de 5 min (desde el minuto 4)
           alertname: TritonNotReady
           exp_alerts:
             - exp_labels:
                 severity: page
                 namespace: classifier
                 deployment: triton
               exp_annotations:
                 summary: "Menos de 2 pods de Triton listos"
                 description: "Réplicas disponibles = 1. Causas típicas: engine que no carga (versión de TensorRT), nodo GPU que no escala, OOM de GPU."
                 runbook_url: "https://runbooks.example.com/classifier/triton-not-ready"
   EOF
   docker run --rm -v "$PWD":/w -w /w --entrypoint promtool prom/prometheus:v3.13.3 test rules prueba.yml

   Qué deberías ver: SUCCESS. A los 8 minutos la serie lleva 4 minutos con menos de 2 réplicas: la alerta está pending, y una pending no cuenta en exp_alerts. A los 10 ya pasaron los 5 minutos del for (desde el minuto 4): firing, con los labels de la serie (namespace, deployment), severity: page y la description con $value = 1.

3. Paso 3Copiar

   sed -i '' '101s/for: 5m/for: 10m/' alerts.yml
   docker run --rm -v "$PWD":/w -w /w --entrypoint promtool prom/prometheus:v3.13.3 test rules prueba.yml

   Qué deberías ver: FAILED, con alertname: TritonNotReady, time: 10m, la alerta que esperabas en exp y got:[] (ninguna): con for: 10m, a esa hora sigue pending. La línea 101 es el for de TritonNotReady. promtool sale con código 1: en CI, el PR no pasa.

4. Paso 4Copiar

   cd ~ && rm -rf ~/lab-prom

   Qué deberías ver: Sin salida.

Verificado contra la documentación; no ejecutado aquí.

Qué vas a provocar: Correr Alertmanager con un webhook propio, mandarle alertas a mano como lo haría Prometheus y ver el ruteo, la inhibición y un silencio.

Necesitas: Docker Desktop corriendo (host.docker.internal lleva del contenedor a tu Mac), Python 3 e internet para bajar prom/alertmanager:v0.34.1 (una vez). Sin Prometheus: las alertas se mandan con curl, en el formato en que las manda Prometheus.

1. Paso 1Copiar

   mkdir -p ~/lab-prom && cd ~/lab-prom
   cat > webhook.py <<'EOF'
   # webhook.py: un receiver de Alertmanager que solo imprime lo que le llega (solo stdlib)
   import json
   from http.server import BaseHTTPRequestHandler, HTTPServer
   
   class Receptor(BaseHTTPRequestHandler):
       def do_POST(self):
           cuerpo = json.loads(self.rfile.read(int(self.headers["Content-Length"])))
           nombres = ", ".join(a["labels"]["alertname"] for a in cuerpo["alerts"])
           print(f"{self.path} receiver={cuerpo['receiver']} status={cuerpo['status']} alertas=[{nombres}]", flush=True)
           self.send_response(200)
           self.end_headers()
   
       def log_message(self, *args):                 # sin el log de acceso de http.server
           pass
   
   print("escuchando en :5001", flush=True)
   HTTPServer(("0.0.0.0", 5001), Receptor).serve_forever()
   EOF
   python3 webhook.py &

   Qué deberías ver: escuchando en :5001. Queda corriendo en segundo plano en esta terminal: lo que reciba se imprime aquí.

2. Paso 2Copiar

   cat > alertmanager.yml <<'EOF'
   # alertmanager.yml del lab: los tres receivers son el mismo webhook.py, con rutas distintas
   route:
     receiver: equipo          # lo que no calce con ningún hijo (aquí, las warning)
     group_by: [alertname, env]
     group_wait: 10s           # corto para el lab (default 30s)
     group_interval: 30s       # (default 5m)
     repeat_interval: 1h
     routes:
       - matchers: ['severity="page"']
         receiver: oncall
       - matchers: ['severity="ticket"']
         receiver: ml-tickets
   inhibit_rules:
     - source_matchers: ['alertname="TritonNotReady"']
       target_matchers: ['alertname=~"TritonQueueTimeHigh|GPUSaturated"']
       equal: [env]
   receivers:
     - name: oncall
       webhook_configs:
         - url: http://host.docker.internal:5001/page
     - name: equipo
       webhook_configs:
         - url: http://host.docker.internal:5001/equipo
     - name: ml-tickets
       webhook_configs:
         - url: http://host.docker.internal:5001/ticket
   EOF
   docker run --rm -v "$PWD":/w --entrypoint amtool prom/alertmanager:v0.34.1 check-config /w/alertmanager.yml

   Qué deberías ver: Checking '/w/alertmanager.yml' con SUCCESS y, debajo de Found:, route, 1 inhibit rules y 3 receivers.

3. Paso 3Copiar

   docker run --rm -v "$PWD":/w --entrypoint amtool prom/alertmanager:v0.34.1 config routes test --config.file=/w/alertmanager.yml severity=page alertname=TritonNotReady
   docker run --rm -v "$PWD":/w --entrypoint amtool prom/alertmanager:v0.34.1 config routes test --config.file=/w/alertmanager.yml severity=warning alertname=GPUSaturated

   Qué deberías ver: oncall y después equipo: la de warning no calza con ningún hijo y la maneja la raíz. Con --tree, además, el camino que siguió.

4. Paso 4Copiar

   docker run -d --name am-lab -p 9093:9093 -v "$PWD":/etc/alertmanager prom/alertmanager:v0.34.1
   sleep 3
   curl -s -XPOST localhost:9093/api/v2/alerts -H 'Content-Type: application/json' -d '[
     {"labels": {"alertname": "TritonNotReady", "severity": "page", "env": "local"}},
     {"labels": {"alertname": "TritonQueueTimeHigh", "severity": "warning", "env": "local"}}]'

   Qué deberías ver: A los ≈ 10 s (el group_wait del lab) webhook.py imprime una sola línea: /page receiver=oncall status=firing alertas=[TritonNotReady]. La de la cola no llega a /equipo: está inhibida.

5. Paso 5Copiar

   docker exec am-lab amtool alert query --inhibited --alertmanager.url=http://localhost:9093

   Qué deberías ver: Una tabla con TritonQueueTimeHigh: sigue activa en Alertmanager, solo que inhibida.

6. Paso 6Copiar

   docker exec am-lab amtool silence add alertname=ClassifierLowConfidenceSpike --duration=15m --author=lab --comment="lab: probar silencios" --alertmanager.url=http://localhost:9093
   curl -s -XPOST localhost:9093/api/v2/alerts -H 'Content-Type: application/json' -d '[
     {"labels": {"alertname": "ClassifierLowConfidenceSpike", "severity": "ticket", "env": "local"}}]'
   sleep 15
   docker exec am-lab amtool alert query --silenced --alertmanager.url=http://localhost:9093

   Qué deberías ver: silence add imprime el id del silencio (un UUID). Después de 15 s no llegó nada a /ticket y la consulta --silenced muestra la alerta. Unos 5 minutos después del primer curl llega /page receiver=oncall status=resolved: una alerta mandada sin endsAt se resuelve sola a los 5 min (resolve_timeout), y el webhook avisa la resolución porque su send_resolved es true por defecto.

7. Paso 7Copiar

   docker rm -f -v am-lab
   kill %1
   cd ~ && rm -rf ~/lab-prom

   Qué deberías ver: am-lab, y zsh avisa que terminó el job de webhook.py.

Verificado contra la documentación; no ejecutado aquí.