# GitHub Actions exit code 137 : manque de mémoire, et un exécuteur à 16 Go ou 32 Go à prix fixe

> Exit code 137 signifie que la tâche a manqué de mémoire et que Linux l'a tuée : l'ubuntu-latest d'un dépôt privé a 8 Go. Skipbox exécute la tâche sur des machines à 16 Go ou 32 Go pour un prix fixe de $39 ou $149 par mois avec des minutes illimitées, en modifiant une ligne runs-on.

Votre build est encore mort avec `exit code 137`. Quelqu'un le relance, réduit les workers de test, ajoute du swap, et le pipeline ralentit à chaque fois. Pendant ce temps, l'exécuteur qui ne cesse de le tuer a 8 Go de mémoire, et les plus grands de GitHub sont facturés à la minute.

Skipbox donne à la tâche une machine à 16 Go ou 32 Go à prix mensuel fixe avec des minutes illimitées. Modifiez une ligne, `runs-on: skipbox`, et le build dispose de 2 fois la mémoire d'`ubuntu-latest` pour $39 par mois ; `runs-on: skipbox-8x16` double aussi les cœurs.

- 16 Go pour $39 par mois, 32 Go pour $149, quel que soit le nombre de minutes
- Deux fois les cœurs de l'exécuteur plus grand de GitHub à mémoire égale : 8 vCPU avec 16 Go
- 10 000 minutes par mois sur l'exécuteur à 16 Go de GitHub : $102. Sur Skipbox S : $39

**GitHub Actions à prix fixe, minutes illimitées** Skipbox exécute vos tâches GitHub Actions sur votre propre machine dédiée : $39 par mois, quel que soit le nombre de minutes. Les couches Docker et les caches de dépendances restent d'une tâche à l'autre : la tâche suivante démarre tout de suite.

Un exécuteur de 4 vCPU, 20 000 minutes par mois: GitHub $222 → Skipbox $39. Vous économisez $183 chaque mois.

Le changement tient en une ligne : `runs-on: skipbox`.

[Commencer mon essai gratuit de 7 j](https://app.skipbox.dev/sign-in?ref=g-github-actions-exit-code-137-out-of-memory-fr)

## Ce que signifie exit code 137

137, c'est 128 + 9 : le processus a été tué avec le signal 9, SIGKILL, qu'il ne peut pas intercepter, et il n'a donc jamais affiché d'erreur. Sur un exécuteur hébergé par GitHub, ce signal vient de l'OOM killer de Linux, quand les processus de la tâche ont utilisé ensemble plus de mémoire que la machine n'en a.

| Le log affiche | Ce qui s'est passé |
|---|---|
| `Process completed with exit code 137.` (souvent après `Killed`) | Le noyau a tué un processus pour libérer de la mémoire |
| `JavaScript heap out of memory` | Node a atteint sa propre limite de heap ; la machine avait encore de la mémoire |
| `The runner has received a shutdown signal.` | Tout l'exécuteur a manqué de mémoire et a cessé de répondre |

Sur un dépôt privé, `ubuntu-latest` a 8 Go, et l'application de l'exécuteur, Docker et vos conteneurs de service prennent leur part avant votre build. Un build de monorepo, un démon Gradle avec des workers forkés, un build Rust en release ou une suite Playwright avec quelques navigateurs ouverts peuvent dépasser cela un jour ordinaire.

## Ce que coûte le fait de rester à 8 Go

Les contournements échangent tous de la vitesse contre de la mémoire. Moins de workers de test, `CARGO_BUILD_JOBS=1`, un `-Xmx` plus petit, du swap sur disque : chacun fait tenir le build en le ralentissant, et l'équipe attend ce build plus lent à chaque push. Jusqu'à ce que la base de code grossisse encore et que le 137 revienne.

La réponse de GitHub est un exécuteur plus grand, facturé à la minute et réservé aux organisations sur GitHub Team ou Enterprise Cloud. Face à Skipbox à mémoire égale :

| Minutes par mois | GitHub 4 cœurs, 16 Go | Skipbox S, 16 Go | GitHub 8 cœurs, 32 Go | Skipbox L, 32 Go |
|---|---|---|---|---|
| 10 000 | $102 | $39 | $202 | $149 |
| 20 000 | $222 | $39 | $422 | $149 |
| 30 000 | $342 | $39 | $642 | $149 |

Les montants GitHub s'entendent après l'utilisation incluse de GitHub Team. Entrez vos propres minutes dans le [calculateur de la page d'accueil](https://skipbox.dev/?ref=g-github-actions-exit-code-137-out-of-memory-fr#cost).

Les besoins en mémoire ne font que croître. Les agents de code ajoutent du code et des dépendances plus vite que les humains, les suites de tests grossissent, et une mise à jour de la chaîne d'outils peut doubler ce qu'utilise le même commit. Par-dessus, une facture à la minute pour un exécuteur plus grand augmente à chaque push.

## Le corriger vous-même

Si vous restez à 8 Go, le travail ressemble à ceci :

- Trouver quel processus a été tué (`dmesg` dans une étape `if: failure()`) et régler sa limite : `--max-old-space-size`, `-Xmx`, `org.gradle.workers.max`, `--maxWorkers`
- Plafonner la mémoire de chaque conteneur de service dans `compose.yaml`
- Ajouter un fichier de swap avant l'étape lourde, dimensionné en fonction des 14 Go de disque de l'exécuteur
- Découper la tâche pour qu'aucune étape n'ait besoin de toute la mémoire

Chaque point rend le build plus lent ou plus fragile, et aucun ne survit à la prochaine poussée de croissance. Une machine plus grande y met fin.

## Ce que Skipbox donne à la tâche

**De la mémoire à prix fixe.** Une tâche demande sa taille par son label :

| Label | Machine | Forfait |
|---|---|---|
| `skipbox` | 4 vCPU · 16 Go | S, $39 par mois |
| `skipbox-8x16` | 8 vCPU · 16 Go | M, $79 par mois |
| `skipbox-16x32` | 16 vCPU · 32 Go | L, $149 par mois |

Le forfait S coûte $39 par mois et le forfait L $149, avec des minutes illimitées. Remettez les workers comme avant : le build obtient la mémoire et les cœurs.

**Un build plus rapide en prime.** La machine de votre compte est conservée entre les tâches : les couches Docker, les caches de paquets et les outils sont déjà sur son disque quand la tâche suivante démarre.

**Aucun budget qui arrête tout.** Les tâches Skipbox n'utilisent aucune minute GitHub : un budget GitHub ne les arrête jamais, et rien n'est facturé à la minute.

**Aucune machine à gérer.** Skipbox la provisionne, met à jour l'image, nettoie après chaque tâche et reconstruit une machine qui échoue à son contrôle d'intégrité.

## Le passage tient en une ligne

```yaml
jobs:
  build:
    runs-on: skipbox # was ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - run: npm ci && npm run build
```

1. Connectez-vous à Skipbox avec GitHub.
2. Installez l'application GitHub Skipbox et choisissez les dépôts.
3. Modifiez `runs-on` et faites un push. Le forfait S ($39) a 16 Go ; choisissez L pour 32 Go.

La machine tourne sous Ubuntu 24.04 avec `sudo` sans mot de passe, Docker, Node.js et Python : les étapes s'exécutent telles quelles.

## Sécurité

- La machine appartient à votre seul compte. Aucune tâche d'une autre entreprise n'y tourne.
- Après chaque tâche, les identifiants de l'exécuteur, ses processus et ses conteneurs sont effacés. À partir du 13 novembre 2026, votre checkout et sa sortie de build (le `target/` de Cargo) restent sur une machine que Skipbox héberge pour votre seul compte, pour vos tâches suivantes ; « Nouvelle VM pour chaque tâche » donne une nouvelle machine à chaque tâche.
- Le code des personnes sans accès en écriture (comme les pull requests venant de forks) s'exécute sur une nouvelle machine jetable.

Les détails sont dans [Comment les tâches sont isolées](https://docs.skipbox.dev/fr/isolation).

## Essayez-le

L'essai est gratuit pendant 7 jours ou 3 000 minutes de tâches, selon ce qui arrive en premier, sans carte. Il exécute `runs-on: skipbox` avec 4 vCPU et 16 Go, soit 2× la mémoire de l'`ubuntu-latest` d'un dépôt privé : déplacez la tâche qui tombe sans cesse sur le 137 et exécutez-la là. Pour plus de cœurs avec cette mémoire, choisissez le forfait M et remplacez son label par `skipbox-8x16` ; pour plus de mémoire, le forfait L et `skipbox-16x32` (32 Go).

## FAQ

### Que signifie exit code 137 dans GitHub Actions ?

Le processus a été tué avec le signal 9, SIGKILL (128 + 9 = 137). Sur un exécuteur hébergé par GitHub, c'est presque toujours l'OOM killer de Linux : la tâche a utilisé plus de mémoire que l'exécuteur n'en a. La correction qui tient, c'est une machine avec plus de mémoire, comme les exécuteurs à 16 Go ou 32 Go de Skipbox à prix mensuel fixe.

### Combien de mémoire a un exécuteur GitHub Actions ?

ubuntu-latest a 8 Go et 2 CPU dans un dépôt privé. Les exécuteurs plus grands de GitHub ont 16 Go en 4 cœurs et 32 Go en 8 cœurs, facturés à la minute et réservés aux organisations sur GitHub Team ou Enterprise Cloud. Skipbox a 16 Go sur le forfait S ($39 par mois) et 32 Go sur le forfait L, avec des minutes illimitées.

### « JavaScript heap out of memory » est-il la même chose qu'exit code 137 ?

Non. L'erreur de heap, c'est Node qui s'arrête à sa propre limite, que --max-old-space-size relève. Exit code 137, c'est le noyau qui tue le processus parce que toute la machine manque de mémoire, et relever la limite de Node aggrave les choses. Quand le build a vraiment besoin de cette mémoire, exécutez-le sur une machine plus grande : runs-on: skipbox lui donne 16 Go.

### Pourquoi ma tâche se termine-t-elle avec « The runner has received a shutdown signal » ?

Une cause courante est un exécuteur tellement à court de mémoire qu'il cesse de répondre avant qu'un message de manque de mémoire n'atteigne le log. Traitez-le comme exit code 137 : la tâche a besoin de plus de mémoire que l'exécuteur n'en a.

### L'essai gratuit de Skipbox règle-t-il une tâche à court de mémoire ?

Il donne à la tâche 2× la mémoire. L'essai exécute runs-on: skipbox avec 4 vCPU et 16 Go, contre les 8 Go d'ubuntu-latest sur un dépôt privé, soit autant que l'exécuteur plus grand à 4 cœurs de GitHub. Une tâche qui manque encore de mémoire a besoin du forfait L pour runs-on: skipbox-16x32 (32 Go).

Mis à jour le 2026-11-19 · https://skipbox.dev/fr/guides/github-actions-exit-code-137-out-of-memory
