# Alertes d’échec GitHub Actions sur votre iPhone

> Les échecs GitHub Actions sur votre iPhone en une étape de workflow, un groupe par dépôt et par branche, et un rétablissement quand tout repasse au vert.

Source: https://honk-me.app/fr/guides/alertes-echec-github-actions

GitHub sait déjà vous tenir informé de vos workflows : dans l’app GitHub Mobile, activez les notifications Actions, et vous recevrez un push pour les exécutions que vous avez lancées. Si cela vous suffit, inutile d’aller plus loin.

Honk va un cran plus loin. Il réunit les échecs de tous vos dépôts, y compris ceux déclenchés par d’autres, regroupés par branche, dans la même boîte de réception que vos serveurs et vos tâches cron, avec un rétablissement quand la branche repasse au vert. Ce guide l’ajoute en une seule étape, à la fin d’un job.

## Avant de commencer

- Un compte Honk. Honk est pour l’instant sur invitation : [demandez un accès](https://honk-me.app/fr/demander-un-acces).
- Un projet pour la CI et une clé d’ingestion : dans l’app web, ouvrez le projet, puis **Clés**, et créez-en une.

## 1. Enregistrer l’URL et la clé comme secrets

Un secret de dépôt ne vaut que pour ce dépôt ; un secret d’organisation vous évite de répéter l’opération partout. Avec GitHub CLI :

```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. Ajouter une étape qui ne s’exécute qu’en cas d’échec

Placez cette étape en dernier dans le job qui vous intéresse. `if: failure()` ne l’exécute que si une étape précédente a échoué. Elle utilise `jq` et `curl`, déjà présents sur tous les runners hébergés par GitHub, il n’y a donc rien à installer :

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

Quelques choix à noter :

- **La clé de groupe combine le dépôt et la branche**, `ci/acme/api/main`. Le premier échec sur `main` déclenche un push ; les échecs suivants sur `main` rejoignent le même groupe et deviennent des mises à jour discrètes. Un échec sur une autre branche forme son propre groupe.
- **La clé d’idempotence combine l’identifiant de l’exécution et le numéro de tentative.** Si curl réessaie après une réponse perdue, Honk renvoie l’événement d’origine au lieu d’en créer un second. En revanche, un clic sur **Re-run** lance une nouvelle tentative, donc un nouvel événement.
- **`jq` construit le JSON** : un nom de workflow ou de branche contenant des guillemets ne peut pas casser la requête.
- **`|| true`** garantit qu’une panne de Honk ne change jamais la nature de l’échec d’un build.

## 3. Facultatif : un rétablissement quand la branche repasse au vert

Pour clore l’incident quand la branche est de nouveau verte, ajoutez une seconde étape, exécutée en cas de succès. Elle demande à GitHub si l’exécution précédente sur cette branche a échoué et, seulement dans ce cas, signale un rétablissement :

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

Cette étape reste facultative. Sans elle, un épisode sans nouvel événement devient inactif au bout de 24 heures, et l’échec suivant en ouvre un autre, avec un nouveau push.

## La même chose avec la CLI honk-me

Si vous préférez la CLI, qui gère pour vous les nouvelles tentatives avec une seule clé d’idempotence et un délai maximal global, installez-la dans les étapes exécutées en cas d’échec et appelez `problem`. Go est préinstallé sur les runners Linux hébergés par 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
```

## Le résultat

Le premier échec sur `main` arrive en Long coup de klaxon, et le lien vers l’exécution s’ouvre d’un toucher depuis la boîte de réception. Les échecs suivants sur la même branche mettent à jour ce groupe sans refaire vibrer le téléphone, et les heures calmes retiennent les échecs de CI la nuit, sauf si vous les envoyez en priorité urgente. Pour signaler aussi les déploiements réussis, voyez le [guide des déploiements](https://honk-me.app/fr/guides/notifications-deploiement).