Referencia de comandos de Node.js para servidores de desarrollo local y producción
Una referencia de comandos escaneable que abarca la gestión de versiones en Node.js, los gestores de paquetes, la configuración del entorno, el depuración, PM2 y despliegues en Linux sin interrupciones.
Fuentes: Node.js Cheatsheet — Essential Commands for Developers and Vibe Coders in 2026
nodejs
La programación asistida por IA ha transformado la forma en que se desarrollan los proyectos. Usted describe el resultado deseado, un asistente de IA genera el código y en cuestión de minutos ya tiene algo funcionando. Sin embargo, hay un momento que ningún asistente puede manejar por usted: cuando está frente a una ventana de terminal y necesita saber exactamente qué comando escribir.
Tal vez la implementación falle en el servidor remoto. Quizás una instalación fracase a mitad de proceso. Puede que las variables de entorno se nieguen a cargarse, o que un proceso termine sin dejar una traza útil. En esas situaciones no quiere revisar páginas y más páginas de documentación; desea una consulta rápida que pueda escanear en segundos.
Ese es el propósito de esta guía: un manual compacto de comandos de Node.js para dos contextos: trabajar en su máquina local y gestionar un servidor en producción. Cada comando incluye una breve nota sobre cuándo es la herramienta adecuada.
Ejecutar Node.js
Comience con lo básico que debe saber sin pensarlo dos veces:
# Run a JavaScript file
node app.js
# Run with an environment variable inline
NODE_ENV=production node app.js
# Open the REPL (Read-Eval-Print Loop) - interactive Node.js shell
node
# Evaluate JavaScript directly from the terminal
node -e "console.log(process.version)"
# Check the active Node.js version
node -v
node --version
# Check the active npm version
npm -v
Parámetros útiles de la CLI
# Watch mode — auto-restart when files change (Node.js 18+, no nodemon needed)
node --watch app.js
# Enable ES Modules
node --input-type=module app.js
# Increase memory limit for heavy applications
node --max-old-space-size=4096 app.js
# Show longer stack traces
node --stack-trace-limit=50 app.js
# Inspect mode for debugging with Chrome DevTools
node --inspect app.js
node --inspect-brk app.js # Pause at first line until debugger connects
Gestión de versiones de Node.js — NVM
Para quienes manejan varios proyectos que requieren versiones diferentes de Node.js, nvm (Node Version Manager) se convierte en una necesidad y no solo en una comodidad.
# Install a specific Node.js version
nvm install 22
nvm install 20.11.0 # Exact version
nvm install --lts # Latest LTS
# Switch versions
nvm use 22
nvm use --lts
# Set a default version
nvm alias default 22
# List all installed versions
nvm ls
# List available remote versions
nvm ls-remote --lts
# Use the version specified in .nvmrc
nvm use
# Create .nvmrc - lock the Node.js version for this project
echo "22" > .nvmrc
Gestores de paquetes — npm, yarn y pnpm
Elegir un gestor de paquetes va más allá de una preferencia estilística; cada opción conlleva verdaderos compromisos.
Hacia 2026, pnpm se ha convertido en la opción por defecto más sensata para la mayoría de los equipos. Se instala rápidamente, utiliza el espacio en disco de manera eficiente, evita el problema de dependencias fantasma y ofrece las herramientas más potentes para monorepos. El soporte de herramientas también ha mejorado: frameworks como Next.js, Nuxt y SvelteKit funcionan sin problemas con pnpm.
Aun así, cuál se adapta mejor depende de su situación:
- npm — viene incluido con Node.js por defecto, funciona en cualquier lugar, es una opción fiable para proyectos individuales y paquetes de código abierto
- yarn — destaca en monorepos a gran escala para empresas, especialmente cuando se utiliza junto con Plug'n'Play (PnP)
- pnpm — la opción más rápida y eficiente en términos de almacenamiento, y la preferida para configuraciones en producción y monorepos en 2026
Comandos básicos: los tres gestores de paquetes uno al lado del otro
# Install all dependencies from package.json
npm install
yarn install
pnpm install
# Add a new package
npm install express
yarn add express
pnpm add express
# Add as a devDependency
npm install -D typescript
yarn add -D typescript
pnpm add -D typescript
# Remove a package
npm uninstall express
yarn remove express
pnpm remove express
# Update packages
npm update
yarn upgrade
pnpm update
# Update to latest (beyond semver range in package.json)
npm install express@latest
yarn add express@latest
pnpm add express@latest
# Install without modifying the lockfile - required in CI/CD
npm ci
yarn install --frozen-lockfile
pnpm install --frozen-lockfile
# Run a script from package.json
npm run build
yarn build
pnpm build
# Run a package executable without installing globally
npx create-next-app
yarn dlx create-next-app
pnpm dlx create-next-app
package.json: las partes que más necesita
{
"name": "my-app",
"version": "1.0.0",
"engines": {
"node": ">=20.0.0",
"npm": ">=10.0.0"
},
"scripts": {
"dev": "node --watch src/index.js",
"start": "node src/index.js",
"build": "tsc -p tsconfig.json",
"test": "node --test",
"lint": "eslint src/",
"format": "prettier --write src/"
},
"dependencies": {},
"devDependencies": {},
"type": "module"
}
Auditoría y seguridad
# Check for vulnerabilities in dependencies
npm audit
yarn audit
pnpm audit
# Auto-fix vulnerabilities where possible
npm audit fix
yarn audit --fix
pnpm audit --fix
# List all installed packages (including nested)
npm list
npm list --depth=0 # Top-level only
# Check for outdated packages
npm outdated
yarn outdated
pnpm outdated
Variables de entorno
Las variables de entorno le permiten mantener la configuración separada entre el desarrollo y la producción. Evite codificar en texto plano secretos como claves de API o direcciones de bases de datos dentro de sus archivos fuente.
# Create a .env file
cat > .env << EOF
NODE_ENV=development
PORT=3000
DATABASE_URL=postgresql://localhost:5432/mydb
JWT_SECRET=your-secret-key
EOF
# Make sure .env never enters version control
echo ".env" >> .gitignore
echo ".env.local" >> .gitignore
echo ".env.production" >> .gitignore
# Create .env.example as a template for your team
cp .env .env.example
# Then remove the sensitive values from .env.example
Dentro de su código Node.js:
// Node.js 20.6+ — load .env without any extra package
// Run with: node --env-file=.env app.js
// Or use dotenv for more flexibility
import 'dotenv/config';
const port = process.env.PORT || 3000;
const dbUrl = process.env.DATABASE_URL;
const nodeEnv = process.env.NODE_ENV || 'development';
// Validate required env vars at startup - fail fast
const required = ['DATABASE_URL', 'JWT_SECRET'];
for (const key of required) {
if (!process.env[key]) {
console.error(`Missing required environment variable: ${key}`);
process.exit(1);
}
}
Sistema de módulos: CommonJS frente a ES Modules
Node.js sigue soportando dos formatos de módulos, pero los nuevos proyectos deberían usar por defecto ES Modules, ya que es el estándar moderno compartido con los navegadores.
// CommonJS (CJS) — the legacy format, .js or .cjs files
const fs = require('fs');
const path = require('path');
const express = require('express');
module.exports = { myFunction };
module.exports.default = MyClass;
// ES Modules (ESM) - the modern format, .mjs or .js with "type":"module"
import fs from 'fs';
import path from 'path';
import express from 'express';
import { readFile, writeFile } from 'fs/promises';
export function myFunction() {}
export default class MyClass {}
// Dynamic import - for lazy loading
const module = await import('./heavy-module.js');
Sistema de archivos: Las operaciones que utilizará con más frecuencia
import { readFile, writeFile, appendFile,
mkdir, rm, stat, readdir,
copyFile, rename } from 'fs/promises';
import { existsSync } from 'fs';
import path from 'path';
// Read a file
const content = await readFile('data.txt', 'utf-8');
const json = JSON.parse(await readFile('config.json', 'utf-8'));
// Write a file
await writeFile('output.txt', 'Hello World', 'utf-8');
await writeFile('data.json', JSON.stringify(data, null, 2));
// Append to an existing file
await appendFile('log.txt', `${new Date().toISOString()} - event\n`);
// Create a directory (including missing parents)
await mkdir('logs/2026/06', { recursive: true });
// Delete a file or directory
await rm('temp-file.txt');
await rm('dist/', { recursive: true, force: true });
// Check if a file or directory exists
if (existsSync('config.json')) {
// file exists
}
// Get file metadata
const info = await stat('app.js');
console.log(info.size); // size in bytes
console.log(info.isDirectory());
console.log(info.mtime); // last modified time
// Read directory contents
const files = await readdir('./src');
const jsFiles = files.filter(f => f.endsWith('.js'));
// Path helpers - always use path.join, never string concatenation
const filePath = path.join(__dirname, 'public', 'index.html');
const ext = path.extname('script.js'); // '.js'
const base = path.basename('/src/app.js'); // 'app.js'
const dir = path.dirname('/src/app.js'); // '/src'
Servidor HTTP: Integrado, sin necesidad de framework
import { createServer } from 'http';
import { createReadStream } from 'fs';
const server = createServer(async (req, res) => {
const url = new URL(req.url, `http://${req.headers.host}`);
const method = req.method;
// Simple routing
if (url.pathname === '/' && method === 'GET') {
res.writeHead(200, { 'Content-Type': 'text/html' });
res.end('<h1>Hello World</h1>');
return;
}
if (url.pathname === '/api/health' && method === 'GET') {
res.writeHead(200, { 'Content-Type': 'application/json' });
res.end(JSON.stringify({ status: 'ok', timestamp: new Date() }));
return;
}
// Read body from a POST request
if (method === 'POST') {
let body = '';
for await (const chunk of req) {
body += chunk;
}
const data = JSON.parse(body);
// process data...
}
// 404
res.writeHead(404, { 'Content-Type': 'application/json' });
res.end(JSON.stringify({ error: 'Not Found' }));
});
const PORT = process.env.PORT || 3000;
server.listen(PORT, () => {
console.log(`Server running at http://localhost:${PORT}`);
});
Gestión de procesos
// Graceful shutdown — close connections before the process exits
process.on('SIGTERM', async () => {
console.log('SIGTERM received, shutting down...');
await db.disconnect();
server.close(() => {
console.log('Server closed');
process.exit(0);
});
});
process.on('SIGINT', async () => {
// Ctrl+C in terminal
await cleanup();
process.exit(0);
});
// Catch unhandled errors
process.on('uncaughtException', (err) => {
console.error('Uncaught Exception:', err);
process.exit(1); // Must exit - process state is now unreliable
});
process.on('unhandledRejection', (reason, promise) => {
console.error('Unhandled Rejection:', reason);
process.exit(1);
});
// Process information
console.log(process.pid); // Process ID
console.log(process.env.NODE_ENV); // Environment
console.log(process.argv); // CLI arguments
console.log(process.cwd()); // Current working directory
console.log(process.memoryUsage()); // Memory usage
Depuración
# Inspect mode — open chrome://inspect in your browser
node --inspect app.js
# Pause at the first line until the debugger connects
node --inspect-brk app.js
# Enable verbose logging for specific modules
NODE_DEBUG=http,net node app.js
# CPU profiling
node --prof app.js
node --prof-process isolate-*.log > processed.txt
# Memory leak detection
node --expose-gc --inspect app.js
Dentro de su código:
// util.debuglog — only outputs when the DEBUG env var is set
import { debuglog } from 'util';
const debug = debuglog('myapp');
debug('This only appears when: NODE_DEBUG=myapp node app.js');
// Simple timing
console.time('database-query');
await db.query('SELECT * FROM users');
console.timeEnd('database-query');
// Output: database-query: 23.456ms
PM2: Gestor de procesos para entornos de producción
PM2 es la herramienta principal para ejecutar Node.js en entornos de producción. Reinicia automáticamente su aplicación tras fallos o reinicios del servidor, y puede escalar entre núcleos de CPU con casi ningún ajuste adicional.
# Install PM2 globally
npm install -g pm2
# Start an application
pm2 start app.js
pm2 start app.js --name "my-api"
# Start in cluster mode - uses all available CPU cores
pm2 start app.js -i max # Automatically matches CPU core count
pm2 start app.js -i 4 # Exactly 4 instances
# View status of all applications
pm2 list
pm2 status
# Real-time monitoring (CPU, memory, logs)
pm2 monit
# View logs
pm2 logs
pm2 logs my-api
pm2 logs --lines 100
# Restart, reload, stop, delete
pm2 restart my-api
pm2 reload my-api # Zero-downtime reload (cluster mode only)
pm2 stop my-api
pm2 delete my-api
# Auto-restart on server reboot
pm2 startup # Generates the systemd command - follow the output
pm2 save # Saves the current process list
# Configuration file
// ecosystem.config.js
export default {
apps: [{
name: 'my-api',
script: 'src/index.js',
instances: 'max',
exec_mode: 'cluster',
watch: false,
max_memory_restart: '500M',
env: {
NODE_ENV: 'development',
PORT: 3000,
},
env_production: {
NODE_ENV: 'production',
PORT: 8080,
},
error_file: 'logs/err.log',
out_file: 'logs/out.log',
log_date_format: 'YYYY-MM-DD HH:mm:ss',
}]
};
# Start from the config file
pm2 start ecosystem.config.js
pm2 start ecosystem.config.js --env production
Despliegue en un servidor Linux
Aquí está la secuencia a seguir al configurar Node.js en un VPS o una máquina Linux por primera vez.
# 1. Update the system
sudo apt update && sudo apt upgrade -y
# 2. Install Node.js via NodeSource (latest LTS)
curl -fsSL https://deb.nodesource.com/setup_lts.x | sudo -E bash -
sudo apt install -y nodejs
# Or install via nvm for easier version management
curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.39.7/install.sh | bash
source ~/.bashrc
nvm install --lts
nvm use --lts
# 3. Verify the installation
node -v
npm -v
# 4. Install PM2 globally
npm install -g pm2
# 5. Clone and set up the project
git clone https://github.com/username/my-app.git
cd my-app
# 6. Install production dependencies only
npm ci --omit=dev
# or with pnpm
pnpm install --prod --frozen-lockfile
# 7. Create the production .env
nano .env
# 8. Start with PM2
pm2 start ecosystem.config.js --env production
pm2 save
pm2 startup # Follow the printed instructions
Actualización de una implementación sin interrupciones
# Pull the latest code
git pull origin main
# Install any new dependencies
npm ci --omit=dev
# Build if needed
npm run build
# Zero-downtime reload (cluster mode only)
pm2 reload my-api
# Or a standard restart
pm2 restart my-api
Comandos de Linux que realmente utilizará durante el mantenimiento de Node.js
# Check what's running on a specific port
lsof -i :3000
sudo netstat -tlnp | grep :3000
sudo ss -tlnp | grep :3000
# Kill whatever is on a port
kill $(lsof -t -i:3000)
# Or forcefully
kill -9 $(lsof -t -i:3000)
# Real-time resource monitoring
htop # Interactive (install with: apt install htop)
top # Built-in alternative
# Disk usage
df -h # Per partition
du -sh node_modules/ # Size of a specific directory
du -sh * # Size of everything in the current directory
# Follow logs in real time
journalctl -u pm2-root -f # PM2 logs via systemd
tail -f /var/log/syslog # System log
tail -f logs/err.log # Your application error log
# Memory overview
free -h
# Active network connections
ss -s
# Find all running Node.js processes
ps aux | grep node
# Find files by name or age
find . -name "*.log" -mtime +7 # .log files older than 7 days
find . -name "*.env" # Any .env files
# Clean up old logs
find ./logs -name "*.log" -mtime +30 -delete
# Archive a folder for backup
tar -czf backup-$(date +%Y%m%d).tar.gz dist/ .env
# Transfer files to/from a server
scp -r ./dist user@server:/var/www/my-app/
rsync -avz ./dist/ user@server:/var/www/my-app/dist/
.npmrc y .nvmrc — Dos archivos pequeños pero importantes
Aunque estos dos archivos de configuración pueden parecer triviales, son muy importantes cuando se trabaja en equipo.
# .nvmrc — pin the Node.js version for this project
# Place at the project root
echo "22" > .nvmrc
# Everyone on the team just runs:
nvm use
# NVM automatically reads the version from .nvmrc
# .npmrc — npm/pnpm configuration for this project
# Place at the project root
# Save exact versions (no ^ or ~ prefix)
save-exact=true
# Set registry (if using a private registry)
registry=https://registry.npmjs.org/
# For pnpm - allow hoisting if a package requires it
# shamefully-hoist=true
# For pnpm - set the node linker
# node-linker=hoisted
Pruebas — Ejecutor de pruebas integrado en Node.js
Desde Node.js 20, el propio entorno de ejecución incluye un ejecutor de pruebas. Para conjuntos de pruebas básicos, puede omitir por completo la instalación de Jest o Mocha.
// test/app.test.js
import { test, describe, beforeEach, afterEach } from 'node:test';
import assert from 'node:assert/strict';
describe('Calculator', () => {
test('addition works correctly', () => {
assert.equal(1 + 1, 2);
});
test('throws on division by zero', () => {
assert.throws(
() => divide(10, 0),
{ message: 'Cannot divide by zero' }
);
});
test('async operation resolves correctly', async () => {
const result = await fetchUser(1);
assert.equal(result.id, 1);
assert.ok(result.name);
});
});
# Run all tests
node --test
# Run a specific test file
node --test test/app.test.js
# Watch mode - re-run on file changes
node --test --watch
# With coverage (Node.js 22+)
node --test --experimental-test-coverage
Lista de verificación previa a la producción
Vaya revisando esta lista antes de publicar su aplicación Node.js en producción:
- Se ha establecido
NODE_ENV=production; esto activa las optimizaciones de rendimiento en Express y otras bibliotecas - Cada variable de entorno que necesita tu aplicación existe en el propio servidor, no solo en tu archivo local
.env - Se está ejecutando
npm ci --omit=deven lugar denpm install, por lo que solo se instalan las dependencias para producción - El archivo de bloqueo (
package-lock.jsonopnpm-lock.yaml) se incluye en git; omitirlo puede hacer que CI/CD utilice versiones de dependencias diferentes a las que probaste - Existe una lógica de cierre ordenado, con SIGTERM y SIGINT manejados correctamente
- Está activada la monitoreo de errores: los eventos
unhandledRejectionyuncaughtExceptionse registran y generan alertas
Reflexiones finales
No es necesario memorizar todo en esta hoja de referencia de una sola vez. Guárdela como favorita, vuelva a ella cada vez que se le olvide un comando, y con el tiempo el flujo de trabajo se convertirá en algo automático sin esfuerzo.
Las herramientas de IA son excelentes para generar código y estructurar proyectos completos durante esta fase de programación intensiva en la que nos encontramos, pero cuando se enfrenta a un servidor en producción dañado a medianoche, lo que realmente ayuda es conocer bien sus herramientas. No pruebas y errores. Ni pánico.
Enfócate primero en las partes a las que accederás constantemente: los gestores de paquetes, las variables de entorno y PM2. Todo lo demás se resolverá a medida que lo necesites.
Lecturas relacionadas
- Cómo Deno 2.x resolvió silenciosamente el problema de compatibilidad y la fatiga en herramientas de Node — Este artículo explora las versiones 2.0–2.9 de Deno, mostrando cómo la compatibilidad con npm, los conjuntos de permisos y las herramientas integradas eliminaron las dificultades que antes hacían que los desarrolladores lo abandonaran.
- Características de Node.js 26 que reemplazan silenciosamente años de soluciones temporales — Un recorrido por la API Temporal de Node.js 26, la ejecución nativa de TypeScript, los ayudantes de caché y otras adiciones que eliminan las soluciones temporales que existían desde hace tiempo.