child_process ఉపయోగించి బాహ్య ప్రక్రియలను ఎలా నడుస్తారు?

Question

Accepted Answer

**`child_process`** మాడ్యూల్ Node ను **ఇతర ప్రోగ్రామ్‌లు/ఆదేశాలు** (shell ఆదేశాలు, స్క్రిప్టులు, ఇతర బైనరీలు) ను ప్రత్యేక OS ప్రక్రియలుగా నడుపుటకు అనుమతిస్తుంది. సిస్టమ్ సরఞ్జాలను (git, ffmpeg, imagemagick) అందిస్తుంది, CPU-కరువైన పనిని ప్రధాన ప్రక్రియ నుండి నిర్ణయించటానికి లేదా ఇతర ప్రోగ్రామ్‌లను సమన్వయం చేయటానికి ఉపయోగకరమైనది.

## నాలుగు ప్రధాన పద్ధతులు

```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 — సరళమైన, buffered

```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` చిన్న ఆదేశాల కోసం సౌకర్యవంతమైనది కానీ సమస్త ఉత్పత్తిని బఫర్ చేస్తుంది — పెద్ద ఉత్పత్తిని ఉత్పత్తి చేసే ఆదేశాల కోసం ప్రమాదకరమైనది (బఫర్ పరిమితిని అధిక సంఖ్యగా ఉంటుంది).

## spawn — streaming (పెద్ద/నిరంతర ఉత్పత్తి కోసం)

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

`spawn` ఉత్పత్తిని ఉత్పత్తి చేసినప్పుడు ఉత్పత్తిని స్ట్రీమ్ చేస్తుంది (స్థిరమైన స్థితిస్మృతి) మరియు యాభిప్రాయాలను **array** గా తీసుకుంటుంది (shell సంచయం కాదు) — దీర్ఘకాలిక లేదా అధిక-ఉత్పత్తి ప్రక్రియల కోసం సరైన ఎంపిక.

## భద్రతా హెచ్చరిక: 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
```

`exec` shell సంచయంలో నమ్మదగని ఇన్‌పుట్‌ను అంతర్గతం చేయవద్దు — ఇది **command injection** ను అనుమతిస్తుంది. ఇన్‌పుట్‌ను shell సింటాక్స్ కానుకుగా దత్తాంశంగా పాస్ చేయడానికి యాభిప్రాయ array తో `execFile`/`spawn` ఉపయోగించండి.

## Promise-based usage

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

## ఎందుకు ఇది ముఖ్యమైనది

`child_process` Node ను విస్తృత వ్యవస్థకు సమీకృతం చేయడానికి అనుమతిస్తుంది — CLI సాధనాలను నడుపుటానికి (git, ffmpeg, imagemagick), CPU-కరువైన పనిని ప్రత్యేక ప్రక్రియలకు స్థానభ్రంశం చేయటానికి (event loopను నిరోధించకుండా) మరియు ఇతర ప్రోగ్రామ్‌లను సమన్వయం చేయటానికి.

ఏ పద్ధతిని ఉపయోగించాలో తెలుసుకోవటం (`spawn` streaming/పెద్ద ఉత్పత్తి కోసం, `exec` సరళ ఆదేశాల కోసం, `fork` Node subprocesses కోసం) మరియు — సమీక్షణీయంగా — వినియోగదారు ఇన్‌పుట్‌తో `exec` యొక్క **command-injection ఆపద** (`execFile`/`spawn` arg arrays తో నిలిపించబడినది) ను రక్షణ చేయటానికి సమర్థవంతంగా మరియు సురక్షితంగా ఉపయోగించటానికి అవసరమైనది.