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.
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:

# 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:

      - 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:

      # 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:

      - 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.

Por ahora, Honk funciona solo con invitación: solicita acceso. Todo lo que explica esta guía funciona con el plan Free.