Desarrollando aplicaciones sin servidor con AWS Lambda y Cloudflare Workers en 2025

Después de casi una década desde su popularización, la arquitectura sin servidor ha pasado de ser una tendencia experimental a un enfoque generalizado para el desarrollo de aplicaciones. En 2025, dos plataformas destacan en este escenario: AWS Lambda, la pionera que sigue dominando el mercado, y Cloudflare Workers](/post/cloudflare-workers), que ha ganado un importante impulso por su enfoque innovador basado en estándares web.

Este artículo explora cómo desarrollar aplicaciones modernas sin servidor utilizando estas dos plataformas, analizando sus diferencias arquitectónicas, casos de uso ideales y cómo las organizaciones los combinan para crear soluciones sólidas.

El estado actual de la tecnología sin servidor en 2025

Evolución más allá de las limitaciones iniciales

Cuando surgió la computación sin servidor, enfrentó escepticismo debido a limitaciones como arranques en frío, límites de ejecución y complejidad de depuración. Para 2025, muchas de estas barreras habrán sido derribadas:

• Arranques en frío: reducido de segundos a milisegundos en ambas plataformas
• Persistencia del estado: nuevas abstracciones para mantener el estado entre ejecuciones
• Observabilidad: Herramientas integradas para seguimiento y diagnóstico
• Integraciones: ecosistemas robustos que permiten arquitecturas híbridas

Crecimiento y adopción del mercado

Según datos de la Cloud Native Computing Foundation, para 2025, el 78 % de las organizaciones utilizarán alguna forma de informática sin servidor en producción, un aumento significativo con respecto al 35 % en 2021. Los factores que impulsan esta adopción incluyen:

• Reducción del 40% en costos operativos para cargas de trabajo adecuadas
• Tiempo de lanzamiento promedio 65% más rápido para nuevas funciones
• Capacidad de escalar instantáneamente para satisfacer los picos de demanda

Trabajadores de AWS Lambda y Cloudflare: comparación arquitectónica

Modelo de rendimiento y tiempo de ejecución

AWS Lambda en 2025

AWS ha evolucionado significativamente Lambda desde su lanzamiento:

• Arquitectura SnapStart: ahora disponible para todos los tiempos de ejecución, lo que reduce los arranques en frío hasta en un 90 %
• Lambda ƛ2: la segunda generación completa de la plataforma, que ofrece rendimiento mejorado de CPU y red.
• Lambda Graviton4: Procesadores ARM personalizados con la mejor relación costo-beneficio
• Tiempo de ejecución unificado: un nuevo modelo que permite cambiar de idioma sin necesidad de volver a implementarlo

La latencia promedio se redujo a 10-50 ms para invocaciones en caliente, con arranques en frío que oscilan entre 100 y 300 ms, según la configuración.

Trabajadores de Cloudflare en 2025

Cloudflare siguió apostando por su arquitectura basada en aislados V8:

• Aisla 2.0: versión optimizada con mejor aislamiento y menor sobrecarga
• Computación de borde universal: funcionando en más de 500 ubicaciones en todo el mundo
• WebAssembly como ciudadano de primera clase: soporte en varios idiomas con rendimiento casi nativo
• Objetos duraderos avanzados: solución robusta para estado distribuido con garantías de coherencia

Los trabajadores ahora tienen latencias constantes de 5 a 15 ms en todo el mundo, con prácticamente cero arranques en frío.

Modelo de precios y economía

Las estructuras de costos han evolucionado hacia modelos más granulares y predecibles:

####AWS Lambda

• Cargo por milisegundo de ejecución (antes por 100ms)
• Precios basados en vCPU y memoria, con escalamiento lineal
• Descuentos automáticos por volumen sin necesidad de compromisos anticipados
• El nivel gratuito se amplió a 2 millones de ejecuciones mensuales

Trabajadores de Cloudflare

• Modelo de precio dual: por solicitud o por duración de CPU
• Sin cargos de red dentro del ecosistema Cloudflare
• KV Almacenamiento y Objetos Duraderos con precios reducidos un 40% desde 2023
• Generoso plan gratuito para desarrolladores y startups

Límites y restricciones

Ambas plataformas han ampliado sus límites para adaptarse a cargas de trabajo más complejas:

####AWS Lambda

• Duración máxima de carrera: 30 minutos (antes 15)
• Memoria configurable: hasta 32 GB (antes 10 GB)
• Tamaño del paquete implementado: hasta 10 GB
• Competencia por región: 3000 por defecto, ampliable bajo demanda

Trabajadores de Cloudflare

• Duración máxima de la CPU: 60 segundos (antes 30)
• Límite de memoria: 2 GB por trabajador
• Soporte para solicitudes y respuestas de transmisión
• Persistencia entre solicitudes a través de Objetos Durables y Base de Datos D1

Casos de uso y patrones arquitectónicos emergentes

Aplicaciones web y API

Patrón: API Gateway + Lambda (AWS)

El patrón tradicional API Gateway conectado a las funciones Lambda ha evolucionado con nuevas características:

// Exemplo: Lambda com API Gateway v3 usando TypeScript
import { APIGatewayProxyHandlerV3 } from 'aws-lambda';

export const handler: APIGatewayProxyHandlerV3 = async (event) => {
  // Suporte integrado a validação de esquema JSON
  const { body } = event;
  
  // Conexão simplificada com outros serviços AWS
  const result = await dynamoDB.query({
    TableName: 'Users',
    KeyConditionExpression: 'id = :id',
    ExpressionAttributeValues: { ':id': body.userId }
  });
  
  // Novo formato de resposta simplificado
  return {
    statusCode: 200,
    body: { user: result.Items[0] }  // Serialização automática para JSON
  };
};

Predeterminado: Sitios de trabajadores (Cloudflare)

Cloudflare ha desarrollado un ecosistema completo para aplicaciones web:

// Exemplo: Cloudflare Worker moderno com composição
import { Router } from '@cloudflare/router';
import { db } from '@cloudflare/d1';

export default {
  async fetch(request, env) {
    const router = new Router();
    
    // Roteamento declarativo com middleware
    router.get('/api/users/:id', withAuth, async ({ params, db }) => {
      const user = await db.prepare('SELECT * FROM users WHERE id = ?')
                          .bind(params.id)
                          .first();
      
      return Response.json({ user });
    });
    
    return router.handle(request, { db: env.DB });
  }
};

// Middleware de autenticação
async function withAuth(request, ctx) {
  const token = request.headers.get('Authorization');
  if (!await verifyToken(token)) {
    return new Response('Unauthorized', { status: 401 });
  }
  return ctx.next();
}

Procesamiento de datos y ETL

Valor predeterminado: ETL controlado por eventos (AWS)

AWS ha desarrollado un estándar sólido para el procesamiento de datos sin servidor:

// Exemplo: Pipeline ETL com Step Functions e Lambda
export const extractHandler = async (event) => {
  const sourceId = event.sourceId;
  console.log(`Extracting data from source ${sourceId}`);
  
  // Novo cliente S3 com suporte a streaming
  const dataStream = await s3.getObject({
    Bucket: 'data-lake',
    Key: `sources/${sourceId}/latest.json`
  }).transformToByteStream();
  
  // Processing stream in chunks com operadores async
  const records = [];
  for await (const chunk of dataStream) {
    const data = JSON.parse(chunk);
    records.push(...data.records);
  }
  
  return { records, sourceId };
};

export const transformHandler = async (event) => {
  const { records } = event;
  
  // Paralelização automática com o novo runtime
  const transformed = await Promise.allSettled(
    records.map(async record => {
      // Processamento complexo
      return enrichAndTransform(record);
    })
  );
  
  return { transformed: transformed.map(r => r.value) };
};

Valor predeterminado: procesamiento perimetral (Cloudflare)

Cloudflare creó nuevas primitivas para el procesamiento de datos distribuidos:

// Exemplo: Processamento de dados na borda com Workers e Queues
export default {
  async fetch(request, env) {
    // Endpoint para ingestão de dados
    if (request.method === 'POST') {
      const data = await request.json();
      
      // Envio para processamento assíncrono via filas
      await env.PROCESSING_QUEUE.send({
        data,
        timestamp: Date.now()
      });
      
      return new Response('Accepted', { status: 202 });
    }
    
    return new Response('Method not allowed', { status: 405 });
  },
  
  // Manipulador de mensagens da fila
  async queue(batch, env) {
    // Processamento em lote com transações atômicas
    const db = env.DB;
    const operations = batch.messages.map(msg => {
      const { data } = msg.body;
      return processRecord(data, db);
    });
    
    const results = await Promise.all(operations);
    console.log(`Processed ${results.length} records`);
  }
};

async function processRecord(data, db) {
  // Transação atômica no banco D1
  return db.batch([
    db.prepare('INSERT INTO processed (id, data) VALUES (?, ?)')
      .bind(data.id, JSON.stringify(data)),
    db.prepare('UPDATE metrics SET count = count + 1 WHERE type = ?')
      .bind(data.type)
  ]);
}

Integraciones y arquitecturas multinube

Con una madurez adicional, las empresas en 2025 ahora implementarán arquitecturas que combinen las fortalezas de ambas plataformas:

Estándar: desde el borde hasta el núcleo (Cloudflare + AWS)

Un patrón que se ha vuelto popular utiliza Cloudflare Workers en el borde para enrutamiento, almacenamiento en caché y procesamiento inicial, delegando cargas de trabajo más pesadas a AWS Lambda:

// Exemplo: Worker na borda que roteia para AWS conforme necessário
export default {
  async fetch(request, env) {
    // Análise de requisição na borda
    const url = new URL(request.url);
    const userAgent = request.headers.get('User-Agent');
    const geo = request.cf.country;
    
    // Cache e acesso rápido para conteúdo estático
    if (url.pathname.startsWith('/assets/')) {
      return env.ASSETS.fetch(request);
    }
    
    // Decisões inteligentes na borda
    if (needsIntensiveProcessing(request)) {
      // Encaminhamento para AWS Lambda via API Gateway
      const awsResponse = await fetch(`https://api.example.com/process`, {
        method: 'POST',
        headers: {
          'Content-Type': 'application/json',
          'X-Origin-Geo': geo,
          'X-Request-ID': env.requestId
        },
        body: JSON.stringify({
          path: url.pathname,
          query: Object.fromEntries(url.searchParams),
          // Dados adicionais necessários
        })
      });
      
      // Processamento da resposta do Lambda
      const result = await awsResponse.json();
      return Response.json(result);
    }
    
    // Processamento leve direto na borda
    return handleAtEdge(request, env);
  }
};

Patrón: Lambda@Edge para migración gradual

Las organizaciones con una inversión significativa en AWS Lambda están utilizando Lambda@Edge y Cloudflare Workers para una estrategia de migración gradual:

// Exemplo: Estratégia de migração usando Lambda@Edge como ponte
export const handler = async (event) => {
  const request = event.Records[0].cf.request;
  const headers = request.headers;
  
  // Decisão de roteamento baseada em regras de negócio
  if (shouldRouteToWorkers(request)) {
    // Reescrever para apontar para a implementação do Cloudflare Worker
    request.origin = {
      custom: {
        domainName: 'workers.example.com',
        port: 443,
        protocol: 'https',
        path: '/api/v2',
        sslProtocols: ['TLSv1.2'],
        readTimeout: 5,
        keepaliveTimeout: 5,
        customHeaders: {
          'x-route-from': [{ key: 'X-Route-From', value: 'lambda-edge' }]
        }
      }
    };
  }
  
  return request;
};

Mejores prácticas y optimizaciones en 2025

Optimización de arranque en frío

Las estrategias para minimizar el impacto de los arranques en frío han evolucionado significativamente:

####AWS Lambda

• Uso de Concurrencia Aprovisionada para cargas críticas
• Lambda SnapStart para todos los lenguajes (no solo Java)
• Dependencias en capas para la reutilización de código entre funciones
• Programación inteligente para precalentamiento basada en patrones de tráfico

Trabajadores de Cloudflare

• Algoritmos de previsión de tráfico para mantenimiento de aislamiento.
• Distribución de solicitudes geográficas para recursos globales.
• Paquete selectivo para minimizar el tamaño del código
• Conexiones persistentes con backends

Diseño para la resiliencia y la estabilidad

Las mejores prácticas para la resiliencia en sin servidor han madurado:

Disyuntores y reintentos

// Exemplo: Padrão circuit-breaker moderno em Lambda
import { CircuitBreaker } from '@aws-lambda/circuit-breaker';

export const handler = async (event) => {
  // Configuração do circuit breaker
  const breaker = new CircuitBreaker({
    failureThreshold: 0.3,     // 30% de falhas abrem o circuito
    recoveryTime: 10000,       // 10 segundos até tentar recuperar
    timeout: 2500,             // Timeout individual de 2.5 segundos
    volumeThreshold: 10,       // Após 10 requisições
  });
  
  try {
    // Execução protegida da chamada a serviço externo
    const result = await breaker.execute(async () => {
      return await externalService.call(event.parameters);
    });
    
    return { success: true, data: result };
  } catch (error) {
    if (error.isCircuitBreakerError) {
      // Tratamento específico para falhas de circuit breaker
      return { success: false, fallbackData: getDefaultResponse() };
    }
    throw error;
  }
};

Diseño para la idempotencia

// Exemplo: Garantia de idempotência em Cloudflare Worker
export default {
  async fetch(request, env) {
    if (request.method === 'POST') {
      const body = await request.json();
      const idempotencyKey = request.headers.get('Idempotency-Key');
      
      if (!idempotencyKey) {
        return new Response('Idempotency-Key header required', { status: 400 });
      }
      
      // Verificar se já processamos esta operação
      const existingResult = await env.KV.get(`op:${idempotencyKey}`);
      if (existingResult) {
        return new Response(existingResult, {
          headers: { 'X-Served-From-Cache': 'true' }
        });
      }
      
      // Processar a operação
      const result = await processOperation(body);
      
      // Armazenar o resultado para idempotência
      await env.KV.put(`op:${idempotencyKey}`, JSON.stringify(result), {
        expirationTtl: 86400 // 24 horas
      });
      
      return Response.json(result);
    }
    
    return new Response('Method not allowed', { status: 405 });
  }
};

Observabilidad y seguimiento

Para 2025, la observabilidad ya no será una idea de último momento, sino que estará integrada en los sistemas desde el principio:

OpenTelemetry integrado

// Exemplo: Tracing distribuído em Lambda com OTel
import { OTelTracer } from '@aws-lambda/opentelemetry';

// Inicialização automática do tracer
const tracer = new OTelTracer();

export const handler = async (event) => {
  // Criação de span para a operação principal
  return tracer.withSpan('process-order', async (span) => {
    span.setAttribute('order.id', event.orderId);
    
    // Sub-spans para operações específicas
    const paymentResult = await tracer.withSpan('process-payment', async (paymentSpan) => {
      paymentSpan.setAttribute('payment.amount', event.amount);
      return processPayment(event);
    });
    
    span.addEvent('payment_processed', { success: paymentResult.success });
    
    if (paymentResult.success) {
      await tracer.withSpan('send-confirmation', async () => {
        return sendConfirmation(event.customer, event.orderId);
      });
    }
    
    return { orderId: event.orderId, success: paymentResult.success };
  });
};

Análisis de rendimiento en tiempo real

// Exemplo: Monitoramento de performance em Cloudflare Workers
import { metrics } from '@cloudflare/metrics';

export default {
  async fetch(request, env) {
    // Iniciar timer para métricas
    const requestTimer = metrics.timer('request_duration');
    
    try {
      // Incrementar contador de requisições
      metrics.increment('requests_total', 1, {
        method: request.method,
        path: new URL(request.url).pathname
      });
      
      // Processar requisição
      const response = await handleRequest(request, env);
      
      // Métricas de sucesso
      metrics.increment('responses_total', 1, { 
        status: response.status,
        success: response.ok
      });
      
      return response;
    } catch (error) {
      // Métricas de erro
      metrics.increment('errors_total', 1, { 
        type: error.name,
        message: error.message.substring(0, 100)
      });
      
      // Registro detalhado do erro no sistema de observabilidade
      console.error('Request processing error', {
        url: request.url,
        method: request.method,
        error: {
          name: error.name,
          message: error.message,
          stack: error.stack
        }
      });
      
      return new Response('Internal Server Error', { status: 500 });
    } finally {
      // Finalizar timer de requisição
      requestTimer.end();
    }
  }
};

El futuro de Serverless más allá de 2025

Tendencias emergentes

Más allá de las capacidades actuales, algunas tendencias están dando forma al futuro de lo sin servidor:

1. Composición y Coreografía de Funciones

La próxima generación de herramientas de orquestación está haciendo que la composición de funciones sea más intuitiva y declarativa:

// Exemplo: Composição declarativa de funções (conceitual)
const orderProcessingFlow = compose({
  name: 'ProcessOrder',
  
  steps: {
    validateOrder: {
      function: validateOrderFn,
      next: 'checkInventory'
    },
    
    checkInventory: {
      function: checkInventoryFn,
      next: {
        condition: 'result.available',
        true: 'processPayment',
        false: 'notifyOutOfStock'
      }
    },
    
    processPayment: {
      function: processPaymentFn,
      next: {
        condition: 'result.success',
        true: 'fulfillOrder',
        false: 'handlePaymentFailure'
      },
      retry: {
        maxAttempts: 3,
        backoff: 'exponential'
      }
    },
    
    fulfillOrder: {
      function: fulfillOrderFn,
      end: true
    },
    
    notifyOutOfStock: {
      function: notifyOutOfStockFn,
      end: true
    },
    
    handlePaymentFailure: {
      function: handlePaymentFailureFn,
      end: true
    }
  }
});

2. IA asistida para la optimización de funciones

Las herramientas de inteligencia artificial analizan patrones de uso y optimizan automáticamente la configuración de recursos:

// Exemplo: Configuração assistida por IA (conceitual)
export const handler = withOptimizer(async (event) => {
  // Lógica de negócio normal
  return processData(event);
}, {
  memoryOptimization: true,    // Otimização automática de memória
  coldStartReduction: true,    // Redução de cold starts
  costEfficiency: 'balanced',  // Equilibra custo vs. performance
  scalingPrediction: true      // Prevê necessidades de escala
});

3. Sin servidor en el borde de la informática

La próxima frontera es la informática aún más cerca de los dispositivos finales:

// Exemplo: Worker executando em provedores de rede 5G (conceitual)
export default {
  async fetch(request, env) {
    // Acesso a capacidades específicas de rede
    const networkInfo = request.cf.networkInsights;
    const latency = networkInfo.estimatedLatency;
    const bandwidth = networkInfo.availableBandwidth;
    
    // Processamento adaptável baseado em condições de rede
    if (bandwidth < 5 && latency > 100) {
      return generateLightweightResponse();
    }
    
    return generateRichResponse();
  },
  
  // Executado diretamente em pontos de presença 5G
  async mobileEdge(deviceContext, env) {
    // Acesso a métricas de dispositivo específicas
    const batteryLevel = deviceContext.batteryLevel;
    const connectionType = deviceContext.connectionType;
    
    // Lógica adaptável às condições do dispositivo
    return customizeResponseForDevice(batteryLevel, connectionType);
  }
};

Desafíos y consideraciones futuras

A medida que las arquitecturas sin servidor continúan evolucionando, surgen nuevos desafíos:

Consumo de energía e impacto ambiental

El debate sobre la eficiencia energética desde diferentes enfoques sin servidor ha ganado protagonismo:

• AWS Lambda introdujo métricas de carbono para funciones
• Cloudflare amplió su infraestructura alimentada con energía 100% renovable
• Las herramientas de evaluación comparativa de eficiencia se están convirtiendo en parte de los procesos de CI/CD

Soberanía de datos y regulaciones

Con la proliferación global de regulaciones de privacidad:

• Controles granulares de residencia de datos para cargas de trabajo sin servidor]
• Certificaciones de cumplimiento automatizadas
• Límites regionales configurables para la ejecución de código.

Estrategias de migración y portabilidad

La preocupación por el bloqueo llevó al desarrollo de:

• Marcos de abstracción para múltiples nubes (Serverless Framework 4.0)
• Los contenedores como mecanismo de portabilidad de funciones.
• Adaptadores para diferentes proveedores sin servidor

Conclusión: elegir el enfoque correcto

No existe una solución única que se adapte a todos los casos. En 2025, la elección entre AWS Lambda y Cloudflare Workers (o una combinación de ambos) dependerá de varios factores:

• Latencia crítica global: Cloudflare Workers tiene ventaja debido a la red de borde global
• Integración profunda con los servicios de AWS: Lambda ofrece una integración superior con el ecosistema de AWS
• Costo de cargas de trabajo predecibles: Cloudflare generalmente tiene precios más predecibles
• Requisitos de computación intensiva: Lambda admite una mayor asignación de memoria y CPU
• Persistencia y estado: Lambda tiene integración con más servicios de persistencia, pero Durable Objects ofrece una experiencia más integrada

La verdadera habilidad es saber cuándo y cómo utilizar cada herramienta, posiblemente combinándolas en una arquitectura que aproveche lo mejor de cada mundo.

---

¿Cómo estás utilizando arquitecturas sin servidor en tus proyectos? ¿Qué plataforma se ha adaptado mejor a sus necesidades? Comparta sus experiencias en los comentarios a continuación.

Lea también

• Serverless para aplicaciones: qué es y por qué importa
• Serverless para aplicaciones: arquitectura con ejemplos reales
• Serverless para aplicaciones: arquitectura en la práctica
• Trabajadores de Cloudflare: Guía práctica para la informática perimetral sin servidor
• Trabajadores de Cloudflare en producción: qué cambia después de hello world
• Caché en aplicaciones: guía rápida de buenas prácticas (y los errores que esconde)