Comment exécutez-vous des processus externes avec child_process?

Question

Accepted Answer

Le module **`child_process`** permet à Node d'exécuter **d'autres programmes/commandes** (commandes shell, scripts, autres binaires) en tant que processus OS distincts. Utile pour invoquer des outils système, exécuter des tâches intensives en CPU en dehors du processus principal ou orchestrer d'autres programmes.

## Les quatre méthodes principales

```text
exec      → run a shell command, buffer all output (simple, small output)
execFile  → run a file directly (no shell — safer, faster)
spawn     → stream output (for large output / long-running processes)
fork      → spawn a new NODE process with an IPC channel (Node-to-Node)
```

## exec — simple, mise en buffer

```js
import { exec } from "child_process";

exec("ls -la", (err, stdout, stderr) => {
  if (err) return console.error(err);
  console.log(stdout); // the entire output, buffered into memory
});
```

`exec` est pratique pour les commandes courtes mais met tout la sortie en buffer — risqué pour les commandes produisant une grande sortie (peut dépasser la limite du buffer).

## spawn — streaming (pour les grandes sorties/sorties continues)

```js
import { spawn } from "child_process";

`spawn` diffuse la sortie à mesure qu'elle est produite (mémoire constante) et prend les arguments comme un **tableau** (pas une chaîne shell) — le bon choix pour les processus de longue durée ou à haut débit.

## Pourquoi c'est important

`child_process` permet à Node de s'intégrer au système plus large — exécution des outils CLI (git, ffmpeg, imagemagick), déchargement des tâches intensives en CPU sur des processus distincts (éviter le blocage de la boucle d'événements) et orchestration d'autres programmes.

Savoir quelle méthode utiliser (`spawn` pour le streaming/la grande sortie, `exec` pour les commandes simples, `fork` pour les sous-processus Node) et — critically — le **risque d'injection de commandes** d'`exec` avec une entrée utilisateur (atténué par `execFile`/`spawn` avec des tableaux d'arguments) est essentiel pour l'utiliser à la fois efficacement et de manière sécurisée.

## L'avertissement de sécurité : injection de commande

```js
// ❌ DANGEROUS — user input in a shell command enables injection
exec(`convert ${userFilename} out.png`); // userFilename = "; rm -rf /" → disaster

// ✅ use execFile/spawn with an args array — no shell interpolation
execFile("convert", [userFilename, "out.png"]); // args passed safely, not parsed by a shell
```

Ne jamais interpoler d'entrée non fiable dans une chaîne shell `exec` — cela active **l'injection de commande**. Utilisez `execFile`/`spawn` avec un tableau d'arguments pour que l'entrée soit transmise comme données, non comme syntaxe shell.

## Utilisation basée sur Promise

```js
import { promisify } from "util";
const execAsync = promisify(exec);
const { stdout } = await execAsync("git rev-parse HEAD");
```