Tutorial Node: Módulo os

Información del sistema

El módulo os de Node.js proporciona acceso directo a información fundamental del sistema operativo donde se ejecuta nuestra aplicación. Esta capacidad resulta esencial para desarrollar aplicaciones que necesiten adaptarse al entorno de ejecución o mostrar información diagnóstica.

Para comenzar a trabajar con el módulo os, debemos importarlo utilizando la función require():

const os = require('os');

Información básica del sistema

El módulo os nos permite obtener datos identificativos del sistema operativo de manera sencilla. Estos métodos devuelven información estática que caracteriza el entorno:

const os = require('os');

// Información del sistema operativo
console.log('Plataforma:', os.platform());
console.log('Arquitectura:', os.arch());
console.log('Versión:', os.release());
console.log('Tipo:', os.type());

El método platform() devuelve una cadena que identifica el sistema operativo: 'darwin' para macOS, 'win32' para Windows, 'linux' para distribuciones Linux, entre otros. Esta información es especialmente útil cuando necesitamos ejecutar código específico según la plataforma.

La función arch() nos proporciona la arquitectura del procesador, típicamente 'x64' para sistemas de 64 bits o 'arm64' para procesadores ARM modernos. Esto resulta crucial al trabajar con módulos nativos o binarios específicos de arquitectura.

Información del usuario y directorio personal

Node.js también nos permite acceder a información del usuario actual y rutas importantes del sistema:

const os = require('os');

// Información del usuario
console.log('Usuario actual:', os.userInfo().username);
console.log('Directorio personal:', os.homedir());
console.log('Directorio temporal:', os.tmpdir());

// Información detallada del usuario
const userInfo = os.userInfo();
console.log('UID:', userInfo.uid);
console.log('GID:', userInfo.gid);
console.log('Shell:', userInfo.shell);

El método userInfo() devuelve un objeto con detalles completos del usuario actual, incluyendo identificadores numéricos (uid, gid) que son especialmente relevantes en sistemas Unix/Linux para gestión de permisos.

Información de red y hostname

Para aplicaciones que necesiten identificarse en la red o conocer la configuración de red del sistema, el módulo os ofrece métodos específicos:

const os = require('os');

// Información de red
console.log('Hostname:', os.hostname());
console.log('Interfaces de red:', os.networkInterfaces());

// Ejemplo de uso práctico
const interfaces = os.networkInterfaces();
Object.keys(interfaces).forEach(interfaceName => {
    const interfaceInfo = interfaces[interfaceName];
    console.log(`\nInterfaz: ${interfaceName}`);
    
    interfaceInfo.forEach(config => {
        if (config.family === 'IPv4' && !config.internal) {
            console.log(`  IP externa: ${config.address}`);
        }
    });
});

El método networkInterfaces() devuelve un objeto complejo que contiene todas las interfaces de red disponibles. Cada interfaz incluye información como direcciones IP, máscaras de red, direcciones MAC y si la interfaz es interna o externa.

Información del sistema en tiempo de ejecución

Además de datos estáticos, podemos obtener información dinámica sobre el estado actual del sistema:

const os = require('os');

// Tiempo de actividad del sistema
const uptime = os.uptime();
console.log(`Sistema activo: ${Math.floor(uptime / 3600)} horas`);

// Carga promedio del sistema (solo en Unix/Linux)
if (os.platform() !== 'win32') {
    const loadAvg = os.loadavg();
    console.log('Carga promedio:', {
        '1min': loadAvg[0].toFixed(2),
        '5min': loadAvg[1].toFixed(2),
        '15min': loadAvg[2].toFixed(2)
    });
}

// Constantes del sistema
console.log('Constantes del sistema:', os.constants);

El método uptime() devuelve el tiempo en segundos desde que se inició el sistema, útil para monitoreo y diagnósticos. La función loadavg() proporciona la carga promedio del sistema en intervalos de 1, 5 y 15 minutos, aunque solo está disponible en sistemas Unix/Linux.

Aplicación práctica: Monitor del sistema

Un ejemplo práctico que combina varios métodos del módulo os es crear un monitor básico del sistema:

const os = require('os');

function mostrarInfoSistema() {
    console.log('=== INFORMACIÓN DEL SISTEMA ===');
    console.log(`SO: ${os.type()} ${os.release()}`);
    console.log(`Plataforma: ${os.platform()} (${os.arch()})`);
    console.log(`Hostname: ${os.hostname()}`);
    console.log(`Usuario: ${os.userInfo().username}`);
    
    const uptimeHours = Math.floor(os.uptime() / 3600);
    const uptimeMinutes = Math.floor((os.uptime() % 3600) / 60);
    console.log(`Tiempo activo: ${uptimeHours}h ${uptimeMinutes}m`);
    
    console.log('================================');
}

// Ejecutar el monitor
mostrarInfoSistema();

Esta función demuestra cómo combinar diferentes métodos del módulo os para crear una vista completa del sistema. Es especialmente útil en aplicaciones de monitoreo, herramientas de diagnóstico o cuando necesitamos registrar información del entorno para depuración.

CPUs y memoria disponible

El módulo os nos proporciona acceso detallado a los recursos de hardware del sistema, especialmente información sobre procesadores y memoria RAM. Esta información resulta fundamental para optimizar el rendimiento de nuestras aplicaciones Node.js y tomar decisiones sobre la gestión de recursos.

Información de los procesadores

Node.js nos permite obtener detalles completos sobre los núcleos de procesamiento disponibles en el sistema mediante el método cpus():

const os = require('os');

// Obtener información de todos los núcleos
const cpus = os.cpus();
console.log(`Número de núcleos: ${cpus.length}`);

// Información detallada del primer núcleo
console.log('Información del procesador:');
console.log(`Modelo: ${cpus[0].model}`);
console.log(`Velocidad: ${cpus[0].speed} MHz`);

El método cpus() devuelve un array de objetos donde cada elemento representa un núcleo lógico del procesador. Cada objeto contiene información sobre el modelo, velocidad base y estadísticas de uso en tiempo real.

Para obtener una vista más completa del uso de CPU, podemos analizar los tiempos de procesamiento de cada núcleo:

const os = require('os');

function analizarUsoCPU() {
    const cpus = os.cpus();
    
    cpus.forEach((cpu, index) => {
        const total = Object.values(cpu.times).reduce((acc, time) => acc + time, 0);
        const idle = cpu.times.idle;
        const usage = ((total - idle) / total * 100).toFixed(2);
        
        console.log(`Núcleo ${index}: ${usage}% de uso`);
        console.log(`  User: ${cpu.times.user}ms`);
        console.log(`  System: ${cpu.times.sys}ms`);
        console.log(`  Idle: ${cpu.times.idle}ms`);
    });
}

analizarUsoCPU();

Los tiempos de CPU se dividen en categorías: user (tiempo en modo usuario), sys (tiempo en modo sistema), idle (tiempo inactivo), nice (procesos de baja prioridad) e irq (interrupciones). Esta información nos ayuda a entender cómo se distribuye la carga de trabajo.

Gestión de memoria del sistema

La información de memoria es crucial para aplicaciones que manejan grandes volúmenes de datos o necesitan optimizar su consumo de recursos:

const os = require('os');

// Memoria total y libre del sistema
const totalMemory = os.totalmem();
const freeMemory = os.freemem();
const usedMemory = totalMemory - freeMemory;

console.log(`Memoria total: ${(totalMemory / 1024 / 1024 / 1024).toFixed(2)} GB`);
console.log(`Memoria libre: ${(freeMemory / 1024 / 1024 / 1024).toFixed(2)} GB`);
console.log(`Memoria usada: ${(usedMemory / 1024 / 1024 / 1024).toFixed(2)} GB`);
console.log(`Porcentaje usado: ${(usedMemory / totalMemory * 100).toFixed(2)}%`);

Los métodos totalmem() y freemem() devuelven valores en bytes, por lo que es común convertirlos a unidades más legibles como megabytes o gigabytes. Esta información nos permite monitorear el estado de la memoria y detectar posibles problemas de consumo.

Monitor de recursos en tiempo real

Podemos crear un monitor dinámico que actualice la información de recursos periódicamente:

const os = require('os');

function formatearBytes(bytes) {
    return (bytes / 1024 / 1024 / 1024).toFixed(2);
}

function mostrarRecursos() {
    console.clear();
    console.log('=== MONITOR DE RECURSOS ===');
    
    // Información de CPU
    const cpus = os.cpus();
    console.log(`CPUs: ${cpus.length} núcleos @ ${cpus[0].speed} MHz`);
    console.log(`Modelo: ${cpus[0].model}`);
    
    // Información de memoria
    const totalMem = os.totalmem();
    const freeMem = os.freemem();
    const usedMem = totalMem - freeMem;
    
    console.log('\n--- MEMORIA ---');
    console.log(`Total: ${formatearBytes(totalMem)} GB`);
    console.log(`Libre: ${formatearBytes(freeMem)} GB`);
    console.log(`Usada: ${formatearBytes(usedMem)} GB`);
    console.log(`Uso: ${(usedMem / totalMem * 100).toFixed(1)}%`);
    
    console.log('\n--- CARGA DEL SISTEMA ---');
    if (os.platform() !== 'win32') {
        const load = os.loadavg();
        console.log(`1min: ${load[0].toFixed(2)}`);
        console.log(`5min: ${load[1].toFixed(2)}`);
        console.log(`15min: ${load[2].toFixed(2)}`);
    }
}

// Actualizar cada 2 segundos
setInterval(mostrarRecursos, 2000);
mostrarRecursos(); // Mostrar inmediatamente

Optimización basada en recursos del sistema

La información de hardware nos permite adaptar el comportamiento de nuestras aplicaciones según los recursos disponibles:

const os = require('os');

function configurarAplicacion() {
    const cpuCount = os.cpus().length;
    const totalMemory = os.totalmem();
    const freeMemory = os.freemem();
    
    // Configurar workers basado en CPUs disponibles
    const maxWorkers = Math.max(1, cpuCount - 1);
    console.log(`Configurando ${maxWorkers} workers para ${cpuCount} CPUs`);
    
    // Ajustar límites de memoria
    const memoryLimitMB = Math.floor((freeMemory * 0.8) / 1024 / 1024);
    console.log(`Límite de memoria por proceso: ${memoryLimitMB} MB`);
    
    // Verificar si hay suficientes recursos
    const memoryUsagePercent = ((totalMemory - freeMemory) / totalMemory) * 100;
    
    if (memoryUsagePercent > 85) {
        console.warn('⚠️  Advertencia: Uso de memoria alto (>85%)');
        console.log('Considerando modo de bajo consumo...');
    }
    
    return {
        workers: maxWorkers,
        memoryLimit: memoryLimitMB,
        lowMemoryMode: memoryUsagePercent > 85
    };
}

const config = configurarAplicacion();
console.log('Configuración de la aplicación:', config);

Detección de recursos para clustering

Una aplicación práctica común es determinar automáticamente cuántos procesos crear al usar el módulo cluster de Node.js:

const os = require('os');

function calcularProcesos() {
    const cpus = os.cpus().length;
    const totalMemoryGB = os.totalmem() / 1024 / 1024 / 1024;
    
    // Estrategia conservadora: un proceso por CPU, pero limitado por memoria
    let processCount = cpus;
    
    // Si hay poca memoria (menos de 2GB), limitar procesos
    if (totalMemoryGB < 2) {
        processCount = Math.min(processCount, 2);
    }
    
    // Reservar al menos un núcleo para el sistema
    processCount = Math.max(1, processCount - 1);
    
    console.log(`Sistema detectado: ${cpus} CPUs, ${totalMemoryGB.toFixed(1)}GB RAM`);
    console.log(`Procesos recomendados: ${processCount}`);
    
    return processCount;
}

const processesToCreate = calcularProcesos();

Esta aproximación nos permite crear aplicaciones que se adapten automáticamente al hardware disponible, maximizando el rendimiento sin sobrecargar el sistema. Es especialmente útil en entornos de producción donde las aplicaciones pueden ejecutarse en servidores con diferentes especificaciones.