¿Cómo se ejecutan procesos externos con child_process?

Question

Accepted Answer

El módulo **`child_process`** permite que Node ejecute **otros programas/comandos** (comandos de shell, scripts, otros binarios) como procesos de sistema operativo separados. Es útil para invocar herramientas del sistema, ejecutar trabajo intensivo en CPU fuera del proceso principal u orquestar otros programas.

## Los cuatro métodos principales

```text
exec      → ejecuta un comando de shell, almacena toda la salida en buffer (simple, salida pequeña)
execFile  → ejecuta un archivo directamente (sin shell — más seguro, más rápido)
spawn     → transmite la salida en streaming (para salida grande / procesos de larga duración)
fork      → genera un nuevo proceso NODE con un canal IPC (Node a Node)
```

## exec — simple, en buffer

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

exec("ls -la", (err, stdout, stderr) => {
  if (err) return console.error(err);
  console.log(stdout); // toda la salida, almacenada en memoria
});
```

`exec` es conveniente para comandos cortos, pero almacena toda la salida en buffer — riesgoso para comandos que producen salida grande (puede superar el límite del buffer).

## spawn — streaming (para salida grande/continua)

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

`spawn` transmite la salida a medida que se produce (memoria constante) y toma los argumentos como un **arreglo** (no como una cadena de shell) — la elección correcta para procesos de larga duración o con mucha salida.

## La advertencia de seguridad: inyección de comandos

```js
// ❌ PELIGROSO — la entrada del usuario en un comando de shell habilita la inyección
exec(`convert ${userFilename} out.png`); // userFilename = "; rm -rf /" → desastre

// ✅ usa execFile/spawn con un arreglo de argumentos — sin interpolación de shell
execFile("convert", [userFilename, "out.png"]); // los argumentos se pasan de forma segura, no los interpreta un shell
```

Nunca interpoles entrada no confiable en una cadena de shell de `exec` — habilita la **inyección de comandos**. Usa `execFile`/`spawn` con un arreglo de argumentos para que la entrada se pase como datos, no como sintaxis de shell.

## Uso basado en Promesas

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

## Por qué es importante

`child_process` permite que Node se integre con el resto del sistema — ejecutando herramientas de línea de comandos (git, ffmpeg, imagemagick), descargando tareas intensivas en CPU a procesos separados (evitando bloquear el event loop) y orquestando otros programas.

Saber qué método usar (`spawn` para streaming/salida grande, `exec` para comandos simples, `fork` para subprocesos de Node) y — críticamente — el **riesgo de inyección de comandos** de `exec` con entrada del usuario (mitigado con `execFile`/`spawn` y arreglos de argumentos) es esencial para usarlo tanto de forma efectiva como segura.