Jeff Bruchado
Volver al blog

Serverless en 2025: Por Qué Node.js Domina (Y Cómo Usar)

Hola HaWkers, ¿recuerdas cuando "serverless" parecía apenas un hype pasajero? En 2025, serverless no es más tendencia - es mainstream. Y hay una razón clara para que Node.js se haya convertido en el lenguaje dominante en este ecosistema: cold start rápido, runtime leve, y ecosistema masivo.

Empresas como Netflix procesan miles de millones de requests serverless por día. Coca-Cola redujo costos de infraestructura en 65% migrando para serverless. Y desarrolladores individuales crean aplicaciones que escalan automáticamente de 0 a millones de usuarios - sin tocar un único servidor.

¿Pero cómo realmente construyes aplicaciones serverless robustas con Node.js? Vamos a explorar desde lo básico hasta patrones avanzados usados en producción.

Qué Es Serverless y Por Qué Usar Node.js

Serverless no significa "sin servidores" - significa que tú no gestionas servidores. Escribes funciones, haces deploy, y el provider cuida de todo: scaling, disponibilidad, seguridad, patches.

Node.js domina serverless por razones técnicas sólidas:

  1. Cold start rápido: ~100-200ms vs segundos en Python/Java
  2. Runtime leve: Menos memoria = costos menores
  3. Event-driven nativo: Perfecto para arquitectura serverless
  4. npm ecosystem: Millones de packages listos
  5. JavaScript universal: Mismo código en front y backend

Tu Primera Función Serverless con AWS Lambda

Vamos a empezar con lo básico - una función Lambda simple:

// handler.js - Función Lambda básica
export const handler = async (event) => {
  console.log('Event received:', JSON.stringify(event, null, 2));

  // Parse del body si viene de API Gateway
  const body = event.body ? JSON.parse(event.body) : event;

  // Lógica de la función
  const response = {
    message: 'Hello from Lambda!',
    input: body,
    timestamp: new Date().toISOString()
  };

  // Retornar respuesta para API Gateway
  return {
    statusCode: 200,
    headers: {
      'Content-Type': 'application/json',
      'Access-Control-Allow-Origin': '*'
    },
    body: JSON.stringify(response)
  };
};

// Para probar localmente
if (process.env.LOCAL_TEST) {
  const testEvent = {
    body: JSON.stringify({ name: 'Jeff', action: 'test' })
  };

  handler(testEvent).then(result => {
    console.log('Result:', result);
  });
}

Deploy con Serverless Framework

El Serverless Framework simplifica drásticamente el proceso de deploy:

# serverless.yml
service: my-api

provider:
  name: aws
  runtime: nodejs20.x
  region: us-east-1
  memorySize: 256
  timeout: 10
  environment:
    STAGE: ${opt:stage, 'dev'}
    DB_CONNECTION: ${env:DB_CONNECTION}

functions:
  hello:
    handler: handler.handler
    events:
      - http:
          path: /hello
          method: POST
          cors: true

  processUser:
    handler: users.process
    events:
      - http:
          path: /users/{id}
          method: GET
          cors: true
      - sns:
          topicName: user-updates
          displayName: User Updates Topic

  scheduledTask:
    handler: tasks.scheduled
    events:
      - schedule:
          rate: rate(5 minutes)
          enabled: true

plugins:
  - serverless-offline
  - serverless-webpack

custom:
  webpack:
    webpackConfig: './webpack.config.js'
    includeModules: true
// users.js - Función más compleja
import AWS from 'aws-sdk';

const dynamodb = new AWS.DynamoDB.DocumentClient();
const TABLE_NAME = process.env.USERS_TABLE || 'users';

export const process = async (event) => {
  const userId = event.pathParameters?.id;

  if (!userId) {
    return {
      statusCode: 400,
      body: JSON.stringify({ error: 'User ID is required' })
    };
  }

  try {
    // Buscar usuario del DynamoDB
    const result = await dynamodb.get({
      TableName: TABLE_NAME,
      Key: { userId }
    }).promise();

    if (!result.Item) {
      return {
        statusCode: 404,
        body: JSON.stringify({ error: 'User not found' })
      };
    }

    // Procesar datos del usuario
    const processedUser = {
      ...result.Item,
      lastAccessed: new Date().toISOString(),
      processedBy: 'lambda'
    };

    // Actualizar timestamp de acceso
    await dynamodb.update({
      TableName: TABLE_NAME,
      Key: { userId },
      UpdateExpression: 'SET lastAccessed = :timestamp',
      ExpressionAttributeValues: {
        ':timestamp': processedUser.lastAccessed
      }
    }).promise();

    return {
      statusCode: 200,
      headers: {
        'Content-Type': 'application/json',
        'Cache-Control': 'max-age=300'
      },
      body: JSON.stringify(processedUser)
    };

  } catch (error) {
    console.error('Error processing user:', error);

    return {
      statusCode: 500,
      body: JSON.stringify({
        error: 'Internal server error',
        message: error.message
      })
    };
  }
};

Serverless deployment

Patrones Avanzados: Arquitectura Serverless en Producción

Aplicaciones serverless reales necesitan patrones robustos. Vamos a explorar algunos:

1. Connection Pooling para Bases de Datos

Un error común: crear nueva conexión de DB en cada invocación. ¿La solución? Connection pooling global:

// db.js - Connection pooling optimizado
import mysql from 'mysql2/promise';

let pool = null;

export const getPool = () => {
  if (!pool) {
    pool = mysql.createPool({
      host: process.env.DB_HOST,
      user: process.env.DB_USER,
      password: process.env.DB_PASSWORD,
      database: process.env.DB_NAME,
      waitForConnections: true,
      connectionLimit: 2, // Lambda: ¡pocas conexiones!
      queueLimit: 0,
      enableKeepAlive: true,
      keepAliveInitialDelay: 0
    });

    console.log('Database pool created');
  }

  return pool;
};

// Lambda handler con pool reutilizable
export const handler = async (event) => {
  const pool = getPool(); // ¡Reutiliza conexión entre invocaciones!

  try {
    const [rows] = await pool.execute(
      'SELECT * FROM users WHERE id = ?',
      [event.userId]
    );

    return {
      statusCode: 200,
      body: JSON.stringify(rows[0])
    };

  } catch (error) {
    console.error('Database error:', error);
    throw error;
  }

  // ¡NO cerrar el pool - reutilizar en la próxima invocación!
};

2. Middleware Pattern para Funciones Lambda

Middleware hace funciones más limpias y reutilizables:

// middleware.js - Sistema de middleware para Lambda
export class LambdaMiddleware {
  constructor(handler) {
    this.handler = handler;
    this.middlewares = [];
  }

  use(middleware) {
    this.middlewares.push(middleware);
    return this;
  }

  async execute(event, context) {
    let index = 0;

    const next = async () => {
      if (index < this.middlewares.length) {
        const middleware = this.middlewares[index++];
        await middleware(event, context, next);
      } else {
        return this.handler(event, context);
      }
    };

    try {
      return await next();
    } catch (error) {
      console.error('Middleware error:', error);
      throw error;
    }
  }
}

// Middlewares útiles
export const jsonBodyParser = async (event, context, next) => {
  if (event.body && typeof event.body === 'string') {
    try {
      event.body = JSON.parse(event.body);
    } catch (error) {
      return {
        statusCode: 400,
        body: JSON.stringify({ error: 'Invalid JSON body' })
      };
    }
  }
  return next();
};

export const cors = (origins = '*') => {
  return async (event, context, next) => {
    const result = await next();

    return {
      ...result,
      headers: {
        ...result.headers,
        'Access-Control-Allow-Origin': origins,
        'Access-Control-Allow-Credentials': true,
        'Access-Control-Allow-Methods': 'GET,POST,PUT,DELETE,OPTIONS',
        'Access-Control-Allow-Headers': 'Content-Type,Authorization'
      }
    };
  };
};

export const errorHandler = async (event, context, next) => {
  try {
    return await next();
  } catch (error) {
    console.error('Unhandled error:', error);

    return {
      statusCode: error.statusCode || 500,
      body: JSON.stringify({
        error: error.message || 'Internal server error',
        requestId: context.requestId
      })
    };
  }
};

export const logging = async (event, context, next) => {
  const start = Date.now();

  console.log('Request started:', {
    requestId: context.requestId,
    path: event.path,
    method: event.httpMethod
  });

  const result = await next();

  const duration = Date.now() - start;
  console.log('Request completed:', {
    requestId: context.requestId,
    duration: `${duration}ms`,
    statusCode: result.statusCode
  });

  return result;
};

// Uso de los middlewares
import { LambdaMiddleware, jsonBodyParser, cors, errorHandler, logging } from './middleware.js';

const mainHandler = async (event, context) => {
  // Lógica principal de la función
  const { name, email } = event.body;

  if (!name || !email) {
    const error = new Error('Name and email are required');
    error.statusCode = 400;
    throw error;
  }

  // Procesar datos
  return {
    statusCode: 200,
    body: JSON.stringify({
      message: 'User created',
      user: { name, email }
    })
  };
};

// Componer handler con middlewares
const middleware = new LambdaMiddleware(mainHandler);

middleware
  .use(logging)
  .use(jsonBodyParser)
  .use(cors('https://myapp.com'))
  .use(errorHandler);

export const handler = (event, context) => middleware.execute(event, context);

3. Step Functions para Workflows Complejos

Para procesos con múltiples pasos, Step Functions es esencial:

// workflow-functions.js - Funciones para Step Functions
import AWS from 'aws-sdk';

const s3 = new AWS.S3();
const sns = new AWS.SNS();

// Paso 1: Validar input
export const validateInput = async (event) => {
  const { userId, fileKey } = event;

  if (!userId || !fileKey) {
    throw new Error('userId and fileKey are required');
  }

  // Verificar si archivo existe
  try {
    await s3.headObject({
      Bucket: process.env.BUCKET_NAME,
      Key: fileKey
    }).promise();

    return {
      ...event,
      validated: true,
      timestamp: new Date().toISOString()
    };

  } catch (error) {
    if (error.code === 'NotFound') {
      throw new Error(`File not found: ${fileKey}`);
    }
    throw error;
  }
};

// Paso 2: Procesar archivo
export const processFile = async (event) => {
  const { fileKey } = event;

  // Descargar archivo del S3
  const file = await s3.getObject({
    Bucket: process.env.BUCKET_NAME,
    Key: fileKey
  }).promise();

  const content = file.Body.toString('utf-8');
  const lines = content.split('\n');

  // Procesar cada línea
  const processed = lines.map(line => {
    // Lógica de procesamiento
    return line.trim().toUpperCase();
  });

  // Guardar resultado procesado
  const resultKey = `processed/${fileKey}`;
  await s3.putObject({
    Bucket: process.env.BUCKET_NAME,
    Key: resultKey,
    Body: processed.join('\n'),
    ContentType: 'text/plain'
  }).promise();

  return {
    ...event,
    processed: true,
    resultKey,
    lineCount: lines.length
  };
};

// Paso 3: Notificar usuario
export const notifyUser = async (event) => {
  const { userId, resultKey, lineCount } = event;

  const message = `
    File processing completed!

    User: ${userId}
    Result: ${resultKey}
    Lines processed: ${lineCount}
  `;

  await sns.publish({
    TopicArn: process.env.SNS_TOPIC_ARN,
    Subject: 'File Processing Complete',
    Message: message
  }).promise();

  return {
    ...event,
    notified: true,
    completedAt: new Date().toISOString()
  };
};

// Paso 4: Cleanup (error o éxito)
export const cleanup = async (event) => {
  const { fileKey } = event;

  // Eliminar archivo original
  await s3.deleteObject({
    Bucket: process.env.BUCKET_NAME,
    Key: fileKey
  }).promise();

  return {
    ...event,
    cleaned: true
  };
};
// state-machine.json - Definición del Step Functions
{
  "Comment": "File processing workflow",
  "StartAt": "ValidateInput",
  "States": {
    "ValidateInput": {
      "Type": "Task",
      "Resource": "arn:aws:lambda:us-east-1:123456789012:function:validateInput",
      "Next": "ProcessFile",
      "Catch": [{
        "ErrorEquals": ["States.ALL"],
        "Next": "NotifyError"
      }]
    },
    "ProcessFile": {
      "Type": "Task",
      "Resource": "arn:aws:lambda:us-east-1:123456789012:function:processFile",
      "Next": "NotifyUser",
      "Catch": [{
        "ErrorEquals": ["States.ALL"],
        "Next": "NotifyError"
      }]
    },
    "NotifyUser": {
      "Type": "Task",
      "Resource": "arn:aws:lambda:us-east-1:123456789012:function:notifyUser",
      "Next": "Cleanup"
    },
    "Cleanup": {
      "Type": "Task",
      "Resource": "arn:aws:lambda:us-east-1:123456789012:function:cleanup",
      "End": true
    },
    "NotifyError": {
      "Type": "Task",
      "Resource": "arn:aws:lambda:us-east-1:123456789012:function:notifyError",
      "Next": "Cleanup"
    }
  }
}

Providers Modernos: Más Allá de AWS

En 2025, hay alternativas excelentes a AWS Lambda:

Cloudflare Workers

// Cloudflare Worker - Edge computing ultra-rápido
export default {
  async fetch(request, env, ctx) {
    const url = new URL(request.url);

    // Ruteo
    if (url.pathname === '/api/users') {
      return handleUsers(request, env);
    }

    if (url.pathname.startsWith('/api/data')) {
      return handleData(request, env);
    }

    return new Response('Not found', { status: 404 });
  }
};

async function handleUsers(request, env) {
  // Cache en Cloudflare KV
  const cached = await env.KV_STORE.get('users', 'json');

  if (cached) {
    return new Response(JSON.stringify(cached), {
      headers: {
        'Content-Type': 'application/json',
        'Cache-Control': 'max-age=60'
      }
    });
  }

  // Buscar de origen
  const users = await fetchUsersFromOrigin();

  // Cachear por 5 minutos
  await env.KV_STORE.put('users', JSON.stringify(users), {
    expirationTtl: 300
  });

  return new Response(JSON.stringify(users), {
    headers: {
      'Content-Type': 'application/json'
    }
  });
}

async function fetchUsersFromOrigin() {
  // Implementación real
  return [
    { id: 1, name: 'Alice' },
    { id: 2, name: 'Bob' }
  ];
}

Vercel Functions

// api/hello.js - Vercel Serverless Function
export default async function handler(request, response) {
  const { method, body } = request;

  if (method !== 'POST') {
    return response.status(405).json({ error: 'Method not allowed' });
  }

  try {
    const data = typeof body === 'string' ? JSON.parse(body) : body;

    // Procesar solicitud
    const result = {
      message: 'Success',
      processed: data,
      timestamp: new Date().toISOString()
    };

    return response.status(200).json(result);

  } catch (error) {
    return response.status(500).json({ error: error.message });
  }
}

// Edge config (opcional)
export const config = {
  runtime: 'edge', // O 'nodejs' para Node.js runtime
};

Performance y Costos: Optimización Crítica

Serverless puede quedar caro si mal optimizado. Estrategias esenciales:

1. Minimizar Cold Starts

// Pre-cargar dependencias en el scope global
import AWS from 'aws-sdk';
import database from './db.js';

const dynamodb = new AWS.DynamoDB.DocumentClient();
const pool = database.getPool();

// Warm-up de conexiones
if (process.env.WARMUP) {
  console.log('Warming up...');
  pool.execute('SELECT 1').catch(console.error);
}

export const handler = async (event) => {
  // ¡Conexiones ya listas - zero overhead!
  // Handler code...
};

2. Monitoreo y Alertas

// monitoring.js - Monitoreo integrado
import AWS from 'aws-sdk';

const cloudwatch = new AWS.CloudWatch();

export class MetricsCollector {
  constructor(namespace = 'MyApp') {
    this.namespace = namespace;
    this.metrics = [];
  }

  record(name, value, unit = 'None') {
    this.metrics.push({
      MetricName: name,
      Value: value,
      Unit: unit,
      Timestamp: new Date()
    });
  }

  async flush() {
    if (this.metrics.length === 0) return;

    await cloudwatch.putMetricData({
      Namespace: this.namespace,
      MetricData: this.metrics
    }).promise();

    this.metrics = [];
  }
}

// Uso en el handler
export const handler = async (event, context) => {
  const metrics = new MetricsCollector();
  const start = Date.now();

  try {
    // Lógica de la función
    const result = await processEvent(event);

    // Registrar éxito
    metrics.record('FunctionSuccess', 1, 'Count');
    metrics.record('ProcessingTime', Date.now() - start, 'Milliseconds');

    await metrics.flush();

    return result;

  } catch (error) {
    // Registrar error
    metrics.record('FunctionError', 1, 'Count');
    await metrics.flush();

    throw error;
  }
};

El Futuro del Serverless y Node.js

En 2025, serverless está maduro. Las próximas evoluciones incluyen:

  • WebAssembly en edge: Performance nativa en Cloudflare/Vercel
  • Serverless containers: AWS Fargate y Cloud Run
  • AI-optimized functions: GPUs serverless para ML
  • Multi-cloud orchestration: Terraform Cloud y Pulumi
  • Observability nativa: OpenTelemetry integrado

Node.js continuará dominando porque JavaScript es ubicuo y el ecosistema npm es imbatible. Como desarrollador, dominar serverless con Node.js te coloca en una posición privilegiada para construir la próxima generación de aplicaciones escalables.

Si quieres explorar más sobre arquitecturas modernas, recomiendo leer mi artículo sobre Microservices con Node.js: Arquitectura Moderna en 2025 donde discuto patrones complementarios al serverless.

¡Vamos a por ello! 🦅

¿Quieres Profundizar Tus Conocimientos en JavaScript?

Este artículo cubrió serverless con Node.js, pero hay mucho más para explorar en el mundo del desarrollo moderno.

Desarrolladores que invierten en conocimiento sólido y estructurado tienden a tener más oportunidades en el mercado.

Material de Estudio Completo

Si quieres dominar JavaScript del básico al avanzado, preparé un guía completo:

Opciones de inversión:

  • $9.90 USD (pago único)

Conocer el Guía JavaScript

Material actualizado con las mejores prácticas del mercado

Comentarios (0)

Este artículo aún no tiene comentarios 😢. ¡Sé el primero! 🚀🦅

Añadir comentarios