# Alertas de Kubernetes en tu teléfono.

> Recibe alertas de Kubernetes en el teléfono. Apunta un webhook_config de Alertmanager a Pocket Alert y CrashLoopBackOff u OOMKilled llegan como notificación push en menos de un segundo.

<!-- source: https://pocketalert.app/es/use-cases/kubernetes-alerts -->

Última actualización: 2026-08-11

Un pod en CrashLoopBackOff, un contenedor OOMKilled, un despliegue fallido o un nodo NotReady se convierte en una notificación push en tu teléfono, con el namespace y el nombre del pod visibles en la pantalla. Detecta los problemas del clúster sin vivir dentro de kubectl.

## Tres pasos de Alertmanager al teléfono

1. **Obtén una URL de recepción** — Crea un webhook de Pocket Alert con una plantilla de mensaje GJSON y copia su URL de recepción.
2. **Conecta Alertmanager** — Añade un receptor webhook_configs en Alertmanager y dirige tus alertas críticas hacia él.
3. **Ponlo en marcha** — La siguiente alerta disparada llega a tu teléfono en menos de un segundo. Ajusta la plantilla GJSON según afines las rutas.

## De la alerta disparada al teléfono

Mantén el Alertmanager que ya usas. Pocket Alert convierte su salida webhook en una notificación push en tu teléfono.

- **webhook_config nativo** — Alertmanager tiene un receptor webhook_config nativo. Apúntalo a la URL de tu aplicación y ya está.
- **Mapeo de campos GJSON** — GJSON extrae alertname, namespace, pod y severity del JSON para crear un título y un mensaje legibles.
- **Status y severidad en línea** — Muestra el status y la severidad en línea para que una alerta crítica disparada se vea distinta de un aviso de resolución.
- **Eventos de pods y nodos** — Detecta CrashLoopBackOff, OOMKilled, despliegues fallidos, nodos NotReady y eventos de PVC llenos.
- **Canales por clúster** — Las aplicaciones separadas dan a prod y staging sus propios canales, cada uno con su URL de webhook.
- **Entrega en menos de un segundo** — Las notificaciones llegan en menos de un segundo desde que Alertmanager dispara la alerta. Sin agente adicional en el clúster.

## Envía alertas de Kubernetes a tu teléfono

### 1. Crea un webhook de Pocket Alert

En la página [Webhooks](https://pocketalert.app/es/webhooks) crea un webhook cuya plantilla GJSON `message` lea el payload de Alertmanager (`status` y `commonLabels` en el nivel superior, más un array `alerts`):

```
curl -X POST "https://api.pocketalert.app/v1/webhooks" \
  -H "Token: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"name":"K8s Alertmanager","message":"[%status%] %commonLabels.alertname% (%commonLabels.severity%)\n%alerts.0.labels.namespace%/%alerts.0.labels.pod%\n%alerts.0.annotations.summary%","application_id":"qm47b9pzxzxg"}'
```

Obtendrás una URL de entrada como `https://p4a.me/wh/1234abcd`. Usa un webhook por clúster para separar prod y staging.

### 2. Apunta Alertmanager a ese webhook

Añade un receptor `webhook_configs` y dirige tus alertas críticas hacia él ([documentación de Alertmanager](https://prometheus.io/docs/alerting/latest/configuration/#webhook_config)):

```
receivers:
  - name: 'pocketalert'
    webhook_configs:
      - url: 'https://p4a.me/wh/1234abcd'

route:
  receiver: 'pocketalert'
  group_by: ['alertname', 'namespace']
```

Alertmanager envía su JSON estándar por POST; las rutas GJSON de arriba extraen status, alertname, severity, namespace y pod para la notificación push. Cuando la alerta se resuelve, `status` cambia a `resolved`.

### 3. O envía un POST desde un controlador o kubectl

Un controlador o un script puntual puede llamar directamente a la API de mensajes con una cabecera Token:

```
curl -X POST "https://api.pocketalert.app/v1/messages" \
  -H "Token: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"title":"CrashLoopBackOff","level":"critical","message":"api-7c9 in prod, 12 restarts","application_id":"qm47b9pzxzxg"}'
```

La [documentación de configuración de webhooks](https://info.pocketalert.app/api/webhooks/settings.html) recoge todas las rutas GJSON y las opciones de webhook.

## Preguntas frecuentes

### ¿Cómo envío alertas de Kubernetes a Pocket Alert?

Añade un receptor webhook_configs en Alertmanager que apunte a tu URL de recepción de Pocket Alert, https://p4a.me/wh/1234abcd. Una alerta CrashLoopBackOff u OOMKilled disparada se convierte en una notificación push.

### ¿Cómo lee Pocket Alert el payload de Alertmanager?

El mapeo de campos GJSON lee el JSON de Alertmanager. Extrae commonLabels.alertname para el título y alerts.0.labels.namespace / alerts.0.labels.pod para el mensaje, de modo que el namespace y el pod aparezcan en tu pantalla en lugar del payload sin procesar.

### ¿Puedo distinguir una alerta disparada de una resuelta?

El payload incluye status (firing o resolved) y commonLabels.severity. Usa ambos en tu plantilla de mensaje GJSON para que una alerta crítica disparada se muestre distinta de un aviso de resolución.

### ¿Cómo separo los clústeres de prod y staging?

Asigna a prod y staging sus propias aplicaciones de Pocket Alert, cada una con su URL de webhook. Dirige una ruta de Alertmanager a cada una para que un nodo NotReady en staging nunca se confunda con prod.

### ¿Necesito un agente ejecutándose en el clúster?

No. Ya tienes Alertmanager en funcionamiento. Pocket Alert no necesita nada adicional dentro del clúster. Un controlador o un script también puede enviar un POST directamente a https://api.pocketalert.app/v1/messages con una cabecera Token.

### ¿Puedo asignar la severidad de la alerta a la prioridad de la notificación?

Sí. Cada mensaje acepta un nivel: silent, low, default, high o critical. Incluye un campo "level" en el payload del webhook o define default_level en el propio webhook; un nivel explícito en el payload siempre tiene prioridad. Una división habitual es firing=critical y resolved=silent: la alerta disparada atraviesa No molestar en Android y llega con prioridad temporal en el iPhone, mientras que la recuperación queda en silencio en el historial. Un valor no válido usa default en lugar de rechazarse.
