Tutorial Node: Configuración de producción

Modo development vs modo production

En el desarrollo de aplicaciones Node.js, es fundamental distinguir entre dos entornos de ejecución principales: development (desarrollo) y production (producción). Cada uno tiene características específicas que afectan el comportamiento, rendimiento y seguridad de la aplicación.

Diferencias fundamentales entre entornos

El entorno de desarrollo está optimizado para facilitar la programación y depuración. En este modo, Node.js proporciona información detallada sobre errores, mantiene archivos de log extensos y no aplica optimizaciones que podrían dificultar el debugging. Por el contrario, el entorno de producción prioriza el rendimiento, la seguridad y la estabilidad, ocultando información sensible y aplicando optimizaciones que mejoran la velocidad de ejecución.

La variable de entorno NODE_ENV es el mecanismo estándar para indicar a Node.js en qué modo debe ejecutarse:

// Verificar el entorno actual
console.log('Entorno actual:', process.env.NODE_ENV);

// Lógica condicional basada en el entorno
if (process.env.NODE_ENV === 'production') {
    console.log('Ejecutándose en producción');
} else {
    console.log('Ejecutándose en desarrollo');
}

Configuración específica por entorno

Una práctica común es crear configuraciones diferenciadas para cada entorno. Esto permite ajustar parámetros como puertos, niveles de logging y configuraciones de seguridad:

// config.js
const config = {
    development: {
        port: 3000,
        logLevel: 'debug',
        showErrors: true,
        cacheEnabled: false
    },
    production: {
        port: process.env.PORT || 8080,
        logLevel: 'error',
        showErrors: false,
        cacheEnabled: true
    }
};

const currentEnv = process.env.NODE_ENV || 'development';
module.exports = config[currentEnv];

Manejo de errores según el entorno

El tratamiento de errores debe adaptarse al entorno de ejecución. En desarrollo, es útil mostrar stack traces completos y información detallada, mientras que en producción se debe ocultar esta información por seguridad:

// server.js
const config = require('./config');

function handleError(error, req, res) {
    console.error('Error:', error.message);
    
    if (config.showErrors) {
        // En desarrollo: mostrar detalles completos
        res.writeHead(500, { 'Content-Type': 'application/json' });
        res.end(JSON.stringify({
            error: error.message,
            stack: error.stack,
            timestamp: new Date().toISOString()
        }));
    } else {
        // En producción: respuesta genérica
        res.writeHead(500, { 'Content-Type': 'application/json' });
        res.end(JSON.stringify({
            error: 'Error interno del servidor'
        }));
    }
}

Optimizaciones de rendimiento

Node.js aplica diferentes optimizaciones según el entorno. En producción, el motor V8 utiliza estrategias más agresivas de optimización y garbage collection:

// Ejemplo de configuración de memoria para producción
if (process.env.NODE_ENV === 'production') {
    // Configurar límites de memoria más estrictos
    process.env.NODE_OPTIONS = '--max-old-space-size=2048';
}

// Configuración de caché condicional
const cache = new Map();

function getData(key) {
    if (process.env.NODE_ENV === 'production' && cache.has(key)) {
        return cache.get(key);
    }
    
    const data = expensiveOperation(key);
    
    if (process.env.NODE_ENV === 'production') {
        cache.set(key, data);
    }
    
    return data;
}

Logging diferenciado

El sistema de logging debe comportarse de manera distinta en cada entorno. En desarrollo, los logs pueden ser más verbosos y incluir información de debugging, mientras que en producción deben ser concisos y enfocarse en errores críticos:

// logger.js
const fs = require('fs');
const path = require('path');

class Logger {
    constructor() {
        this.isDevelopment = process.env.NODE_ENV !== 'production';
        this.logFile = path.join(__dirname, 'app.log');
    }
    
    log(level, message) {
        const timestamp = new Date().toISOString();
        const logEntry = `[${timestamp}] ${level.toUpperCase()}: ${message}\n`;
        
        if (this.isDevelopment) {
            // En desarrollo: mostrar en consola con colores
            console.log(logEntry.trim());
        } else {
            // En producción: escribir solo a archivo
            fs.appendFileSync(this.logFile, logEntry);
        }
    }
    
    debug(message) {
        if (this.isDevelopment) {
            this.log('debug', message);
        }
    }
    
    error(message) {
        this.log('error', message);
    }
}

module.exports = new Logger();

Establecer el entorno de ejecución

Para configurar el entorno, puedes establecer la variable NODE_ENV de varias formas:

Mediante línea de comandos:

# Ejecutar en modo desarrollo
NODE_ENV=development node server.js

# Ejecutar en modo producción
NODE_ENV=production node server.js

Mediante scripts en package.json:

{
  "scripts": {
    "dev": "NODE_ENV=development node server.js",
    "start": "NODE_ENV=production node server.js"
  }
}

Mediante archivos de configuración del sistema:

# En sistemas Unix/Linux, agregar al .bashrc o .profile
export NODE_ENV=production

Esta diferenciación entre entornos es esencial para desarrollar aplicaciones Node.js robustas y seguras, permitiendo un desarrollo ágil mientras se mantiene un comportamiento optimizado en producción.