# Alertas do Kubernetes no seu celular.

> Receba alertas do Kubernetes no celular. Aponte o webhook_config do Alertmanager para o Pocket Alert e CrashLoopBackOff ou OOMKilled chegam como notificação push em menos de um segundo.

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

Última atualização: 2026-08-11

Um pod em CrashLoopBackOff, um contêiner OOMKilled, um rollout com falha ou um nó NotReady se transforma em uma notificação push no seu celular, com o namespace e o nome do pod bem visíveis na tela. Acompanhe os problemas do cluster sem viver no kubectl.

## Três passos do Alertmanager até o celular

1. **Obtenha uma URL de recebimento** — Crie um webhook do Pocket Alert com um template de mensagem GJSON e copie a URL de recebimento.
2. **Configure o Alertmanager** — Adicione um receiver webhook_configs no Alertmanager e direcione seus alertas críticos para ele.
3. **Coloque em produção** — O próximo alerta disparado chega no seu celular em menos de um segundo. Ajuste o template GJSON conforme refina as rotas.

## Do alerta disparado ao celular

Mantenha o Alertmanager que você já usa. O Pocket Alert transforma a saída de webhook dele em uma notificação push no seu celular.

- **webhook_config nativo** — O Alertmanager tem um receiver webhook_config nativo. Aponte para a URL do seu aplicativo e pronto.
- **Mapeamento de campos GJSON** — O GJSON extrai alertname, namespace, pod e severity do JSON para um título e uma mensagem legíveis.
- **Status e gravidade na mensagem** — Mostre status e gravidade direto na mensagem, para que um alerta crítico disparado seja diferente de um aviso de resolução.
- **Eventos de pod e nó** — Capture CrashLoopBackOff, OOMKilled, rollouts com falha, nós NotReady e eventos de PVC cheio.
- **Canais por cluster** — Aplicativos separados dão ao prod e ao staging seus próprios canais, cada um com sua URL de webhook.
- **Entrega em menos de um segundo** — As notificações chegam em menos de um segundo depois que o Alertmanager dispara. Sem agente extra dentro do cluster.

## Envie alertas do Kubernetes para o seu celular

### 1. Crie um webhook do Pocket Alert

Na página [Webhooks](https://pocketalert.app/pt/webhooks), crie um webhook cujo template de `message` GJSON leia o payload do Alertmanager (`status` e `commonLabels` no nível principal, além de um 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"}'
```

Você recebe uma URL de entrada como `https://p4a.me/wh/1234abcd`. Use um webhook por cluster para manter o prod e o staging separados.

### 2. Aponte o Alertmanager para ela

Adicione um receiver `webhook_configs` e direcione seus alertas críticos para ele ([documentação do 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']
```

O Alertmanager envia seu JSON padrão por POST; os caminhos GJSON acima extraem status, alertname, severity, namespace e pod para a notificação push. Quando o alerta é normalizado, `status` muda para `resolved`.

### 3. Ou faça POST a partir de um controller / kubectl

Um controller ou um script pontual pode chamar a API de mensagens diretamente com um cabeçalho 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"}'
```

A [documentação das configurações de webhook](https://info.pocketalert.app/api/webhooks/settings.html) cobre todos os caminhos GJSON e opções de webhook.

## Perguntas frequentes

### Como envio alertas do Kubernetes para o Pocket Alert?

Adicione um receiver webhook_configs no Alertmanager apontando para a sua URL de recebimento do Pocket Alert, https://p4a.me/wh/1234abcd. Um alerta CrashLoopBackOff ou OOMKilled disparado vira uma notificação push.

### Como o Pocket Alert lê o payload do Alertmanager?

O mapeamento de campos GJSON lê o JSON do Alertmanager. Extraia commonLabels.alertname para o título e alerts.0.labels.namespace / alerts.0.labels.pod para o corpo, assim o namespace e o pod aparecem na sua tela em vez do payload bruto.

### Consigo diferenciar um alerta disparado de um resolvido?

O payload traz status (firing ou resolved) e commonLabels.severity. Use os dois no seu template de mensagem GJSON para que um alerta crítico disparado seja diferente de um aviso de resolução.

### Como separo os clusters de prod e staging?

Dê ao prod e ao staging os seus próprios aplicativos no Pocket Alert, cada um com sua própria URL de webhook. Aponte uma rota do Alertmanager para cada um, assim um nó NotReady no staging nunca será confundido com o prod.

### Preciso de um agente rodando dentro do cluster?

Não. Você já roda o Alertmanager. O Pocket Alert não precisa de nada extra dentro do cluster. Um controller ou script também pode fazer POST direto para https://api.pocketalert.app/v1/messages com um cabeçalho Token.

### Consigo mapear a gravidade do alerta para a prioridade da notificação?

Sim. Toda mensagem aceita um nível: silent, low, default, high ou critical. Inclua um campo "level" no payload do webhook ou defina default_level no próprio webhook; um level explícito no payload sempre prevalece. Uma divisão comum é firing=critical e resolved=silent: o alerta disparado fura o modo Não perturbe no Android e chega como urgente no iPhone, enquanto a recuperação fica silenciosa no histórico. Um valor inválido volta para default, nunca é rejeitado.
