# Alertas de fallos de GitHub Actions en tu iPhone

> Recibe en el iPhone los fallos de GitHub Actions con un solo paso, un grupo por repositorio y rama, y una recuperación cuando la rama vuelve a verde.

Source: https://honk-me.app/es/guias/alertas-fallos-github-actions

GitHub ya te avisa de las ejecuciones de tus flujos de trabajo: en la app GitHub Mobile, activa las notificaciones de Actions y recibirás una notificación por cada ejecución que hayas lanzado tú. Si no necesitas más, no hace falta seguir.

Honk sirve cuando necesitas más: los fallos de muchos repositorios, también los de ejecuciones que lanzaron otras personas, reunidos en un grupo por rama, en la misma bandeja de entrada que tus servidores y tus tareas cron, y una recuperación cuando la rama vuelve a verde. Esta guía lo añade con un solo paso al final de un trabajo.

## Antes de empezar

- Una cuenta de Honk. Por ahora, Honk funciona solo con invitación: [solicita acceso](https://honk-me.app/es/solicitar-acceso).
- Un proyecto para la CI y una clave de ingesta: en la app web, abre el proyecto, entra en **Claves** y crea una.

## 1. Guarda la URL y la clave como secretos

Los secretos de repositorio sirven para un solo repositorio; los de organización te ahorran repetir esto en todas partes. Con la CLI de GitHub:

```sh
# with the GitHub CLI, for one repository (or use --org for all of them)
gh secret set HONK_URL --body "https://honk-me.app"
gh secret set HONK_KEY        # paste the ingestion key when asked
```

## 2. Añade un paso que solo se ejecute si algo falla

Pon este paso al final del trabajo que te interesa. `if: failure()` hace que solo se ejecute cuando ha fallado un paso anterior. Usa `jq` y `curl`, que ya están en todos los runners alojados en GitHub, así que no hay que instalar nada:

```yaml
      - name: Tell Honk
        if: failure()
        env:
          HONK_URL: ${{ secrets.HONK_URL }}
          HONK_KEY: ${{ secrets.HONK_KEY }}
          WORKFLOW: ${{ github.workflow }}
          REPO: ${{ github.repository }}
          BRANCH: ${{ github.ref_name }}
          RUN_URL: ${{ github.server_url }}/${{ github.repository }}/actions/runs/${{ github.run_id }}
          ATTEMPT: ${{ github.run_id }}-${{ github.run_attempt }}
        run: |
          jq -n --arg title "CI failed: $WORKFLOW on $BRANCH" --arg url "$RUN_URL" --arg key "ci/$REPO/$BRANCH" \
            '{title: $title, message: $url, url: $url, severity: "long", event_type: "problem",
              group_key: $key, source: "github-actions", category: "deployments"}' |
          curl -sS --max-time 10 --retry 3 --retry-all-errors "$HONK_URL/v1/messages" \
            -H "Authorization: Bearer $HONK_KEY" -H "Content-Type: application/json" \
            -H "Idempotency-Key: gh-$ATTEMPT" --data-binary @- || true
```

Hay varios detalles que importan:

- **La clave de grupo es el repositorio más la rama**, `ci/acme/api/main`. El primer fallo en `main` te avisa al momento; los siguientes fallos en `main` se suman al mismo grupo como actualizaciones discretas. Un fallo en otra rama forma su propio grupo.
- **La clave de idempotencia es el id de la ejecución más el intento.** Si curl reintenta porque se perdió una respuesta, Honk devuelve el evento original en vez de crear otro; en cambio, si pulsas **Re-run**, el nuevo intento es un evento nuevo.
- **`jq` construye el JSON**, así que un nombre de flujo de trabajo o de rama con comillas no puede romper la solicitud.
- **`|| true`** evita que una caída de Honk convierta una compilación fallida en un fallo distinto.

## 3. Opcional: una recuperación cuando vuelva a verde

Para cerrar el incidente cuando la rama vuelva a pasar, añade un segundo paso que se ejecute si todo va bien, pregunte a GitHub si falló la ejecución anterior en esa rama y solo entonces notifique una recuperación:

```yaml
      # needs `permissions: actions: read` when the workflow restricts the token
      - name: Tell Honk it works again
        if: success()
        env:
          GH_TOKEN: ${{ github.token }}
          HONK_URL: ${{ secrets.HONK_URL }}
          HONK_KEY: ${{ secrets.HONK_KEY }}
          WORKFLOW: ${{ github.workflow }}
          REPO: ${{ github.repository }}
          BRANCH: ${{ github.ref_name }}
          ATTEMPT: ${{ github.run_id }}-${{ github.run_attempt }}
        run: |
          previous=$(gh run list --repo "$REPO" --workflow "$WORKFLOW" --branch "$BRANCH" \
            --limit 2 --json conclusion --jq '.[1].conclusion')
          [ "$previous" = "failure" ] || exit 0
          jq -n --arg title "CI green again: $WORKFLOW on $BRANCH" --arg key "ci/$REPO/$BRANCH" \
            '{title: $title, message: "The last run passed.", severity: "beep", event_type: "recovery",
              group_key: $key, source: "github-actions", category: "deployments"}' |
          curl -sS --max-time 10 --retry 3 --retry-all-errors "$HONK_URL/v1/messages" \
            -H "Authorization: Bearer $HONK_KEY" -H "Content-Type: application/json" \
            -H "Idempotency-Key: gh-$ATTEMPT-ok" --data-binary @- || true
```

Sin este paso no se rompe nada: un episodio sin eventos nuevos queda inactivo a las 24 horas, y el siguiente fallo abre uno nuevo y vuelve a avisar.

## Lo mismo con la CLI honk-me

Si prefieres la CLI, que reintenta por ti con una misma clave de idempotencia y un tiempo límite total, instálala en los pasos que se ejecutan cuando el trabajo falla y llama a `problem`. Go viene preinstalado en los runners Linux alojados en GitHub:

```yaml
      - name: Install honk-me
        if: failure()
        run: |
          go install github.com/honk-me/honk-go/cmd/honk-me@latest
          echo "$(go env GOPATH)/bin" >> "$GITHUB_PATH"

      - name: Notify
        if: failure()
        env:
          HONK_URL: ${{ secrets.HONK_URL }}
          HONK_KEY: ${{ secrets.HONK_KEY }}
        run: |
          honk-me problem --group-key "ci/${{ github.repository }}/${{ github.ref_name }}" \
            --title "CI failed: ${{ github.workflow }}" --message "${{ github.server_url }}/${{ github.repository }}/actions/runs/${{ github.run_id }}" \
            --source github-actions --category deployments \
            --idempotency-key "gh-${{ github.run_id }}-${{ github.run_attempt }}" || true
```

## Qué consigues

El primer fallo de `main` llega como Bocinazo largo, y en la bandeja de entrada tienes el enlace a la ejecución. Las repeticiones en la misma rama actualizan un único grupo en lugar de hacer vibrar otra vez el teléfono, y las horas de silencio retienen los fallos de CI por la noche, salvo que los envíes como urgentes. Para avisar también de los despliegues correctos, consulta la [guía de despliegues](https://honk-me.app/es/guias/notificaciones-despliegue).