# Alertes Kubernetes sur votre téléphone.

> Recevez vos alertes Kubernetes sur votre téléphone. Pointez un webhook_config d’Alertmanager vers Pocket Alert et CrashLoopBackOff ou OOMKilled arrive en notification push en moins d’une seconde.

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

Dernière mise à jour : 2026-08-11

Un pod en CrashLoopBackOff, un conteneur OOMKilled, un déploiement échoué ou un nœud NotReady se transforme en notification push sur votre téléphone, avec le namespace et le nom du pod affichés à l’écran. Détectez les problèmes du cluster sans passer votre temps dans kubectl.

## Trois étapes entre Alertmanager et votre téléphone

1. **Obtenez une URL de réception** — Créez un webhook Pocket Alert avec un modèle de message GJSON et copiez son URL de réception.
2. **Configurez Alertmanager** — Ajoutez un récepteur webhook_configs dans Alertmanager et routez-y vos alertes critiques.
3. **Mettez-le en service** — La prochaine alerte déclenchée arrive sur votre téléphone en moins d’une seconde. Ajustez le modèle GJSON au fil de l’affinage de vos routes.

## De l’alerte déclenchée au téléphone

Gardez l’Alertmanager que vous exploitez déjà. Pocket Alert transforme sa sortie webhook en notification push sur votre téléphone.

- **webhook_config natif** — Alertmanager dispose d’un récepteur webhook_config natif. Indiquez-lui l’URL de votre application et c’est terminé.
- **Mappage de champs GJSON** — GJSON extrait alertname, namespace, pod et severity du JSON pour produire un titre et un message lisibles.
- **Statut et gravité en ligne** — Affichez le statut et la gravité directement dans le message, pour qu’une alerte critique déclenchée se distingue d’un avis de résolution.
- **Événements de pods et de nœuds** — Détectez CrashLoopBackOff, OOMKilled, les déploiements échoués, les nœuds NotReady et les événements PVC saturés.
- **Canaux par cluster** — Des applications distinctes donnent à prod et staging leurs propres canaux, chacun avec sa propre URL webhook.
- **Livraison en moins d’une seconde** — Les notifications arrivent en moins d’une seconde dès qu’Alertmanager se déclenche. Aucun agent supplémentaire dans le cluster.

## Envoyez les alertes Kubernetes sur votre téléphone

### 1. Créez un webhook Pocket Alert

Sur la page [Webhooks](https://pocketalert.app/fr/webhooks), créez un webhook dont le modèle GJSON `message` lit la charge utile d’Alertmanager (`status` et `commonLabels` de premier niveau, ainsi qu’un tableau `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"}'
```

Vous obtenez une URL entrante du type `https://p4a.me/wh/1234abcd`. Utilisez un webhook par cluster pour séparer prod et staging.

### 2. Dirigez Alertmanager vers ce webhook

Ajoutez un récepteur `webhook_configs` et routez-y vos alertes critiques ([documentation 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 envoie son JSON standard en POST ; les chemins GJSON ci-dessus extraient status, alertname, severity, namespace et pod pour la notification push. Lorsque l’alerte est levée, `status` passe à `resolved`.

### 3. Ou envoyez une requête POST depuis un contrôleur / kubectl

Un contrôleur ou un script ponctuel peut appeler directement l’API des messages avec un en-tête 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 [documentation des paramètres webhook](https://info.pocketalert.app/api/webhooks/settings.html) détaille tous les chemins GJSON et les options de webhook.

## FAQ

### Comment envoyer des alertes Kubernetes vers Pocket Alert ?

Ajoutez un récepteur webhook_configs dans Alertmanager pointant vers votre URL de réception Pocket Alert, https://p4a.me/wh/1234abcd. Une alerte CrashLoopBackOff ou OOMKilled déclenchée devient une notification push.

### Comment Pocket Alert lit-il la charge utile d’Alertmanager ?

Le mappage de champs GJSON lit le JSON d’Alertmanager. Récupérez commonLabels.alertname dans le titre et alerts.0.labels.namespace / alerts.0.labels.pod dans le corps, afin que le namespace et le pod s’affichent à l’écran au lieu de la charge utile brute.

### Puis-je distinguer une alerte déclenchée d’une alerte résolue ?

La charge utile contient status (firing ou resolved) et commonLabels.severity. Utilisez les deux dans votre modèle de message GJSON pour qu’une alerte critique déclenchée se distingue d’un avis de résolution.

### Comment séparer les clusters prod et staging ?

Donnez à prod et staging leurs propres applications Pocket Alert, chacune avec sa propre URL webhook. Associez une route Alertmanager à chacune pour qu’un nœud NotReady en staging ne soit jamais confondu avec la production.

### Dois-je exécuter un agent dans le cluster ?

Non. Vous exécutez déjà Alertmanager. Pocket Alert n’a besoin de rien de plus dans le cluster. Un contrôleur ou un script peut aussi envoyer directement une requête POST vers https://api.pocketalert.app/v1/messages avec un en-tête Token.

### Puis-je associer la gravité d’une alerte à la priorité de notification ?

Oui. Chaque message accepte un niveau : silent, low, default, high ou critical. Ajoutez un champ « level » dans la charge utile du webhook, ou définissez default_level sur le webhook lui-même ; un niveau explicite dans la charge utile l’emporte toujours. Une répartition courante est firing=critical et resolved=silent : l’alerte déclenchée passe outre Ne pas déranger sur Android et arrive en mode sensible au temps sur iPhone, tandis que la résolution reste discrètement dans l’historique. Une valeur invalide revient à default, sans jamais être rejetée.
