Como você executa processos externos com child_process?

Question

Accepted Answer

O módulo **`child_process`** permite que Node execute **outros programas/comandos** (comandos de shell, scripts, outros binários) como processos OS separados. Útil para invocar ferramentas do sistema, executar trabalho com muita CPU fora do processo principal ou orquestrar outros programas.

## Os quatro métodos principais

```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 — simples, armazenado em 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` é conveniente para comandos curtos, mas armazena toda a saída em buffer — arriscado para comandos que produzem grande saída (pode exceder o limite de buffer).

## spawn — streaming (para saída grande/contínua)

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

`spawn` transmite saída conforme é produzida (memória constante) e aceita argumentos como um **array** (não uma string de shell) — a escolha certa para processos de longa duração ou alta saída.

## O aviso de segurança: command injection

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

Nunca interpole entrada não confiável em uma string de shell `exec` — isso ativa **command injection**. Use `execFile`/`spawn` com um array de argumentos para que a entrada seja passada como dados, não sintaxe de shell.

## Uso baseado em Promise

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

## Por que isso importa

`child_process` permite que Node se integre com o sistema mais amplo — executar ferramentas CLI (git, ffmpeg, imagemagick), descarregar tarefas com muita CPU para processos separados (evitando bloqueio do event loop) e orquestrar outros programas.

Saber qual método usar (`spawn` para streaming/grande saída, `exec` para comandos simples, `fork` para subprocessos Node) e — criticamente — o **risco de command injection** de `exec` com entrada do usuário (mitigado por `execFile`/`spawn` com arrays de arg) é essencial para usá-lo tanto efetivamente quanto com segurança.