Edge Computing y Serverless en 2025: Cómo Cloudflare, Vercel y AWS Están Redefiniendo la Infraestructura

Hola HaWkers, la forma como deployamos aplicaciones está pasando por una revolución silenciosa. Edge computing dejó de ser una buzzword para convertirse en la estrategia estándar de las empresas que llevan performance en serio.

¿Ya te preguntaste por qué algunos sitios cargan instantáneamente mientras otros demoran segundos? La respuesta muchas veces está en dónde el código corre. Y en 2025, ese "dónde" está cada vez más cerca del usuario.

Qué Es Edge Computing

El Concepto Fundamental

Edge computing es la práctica de ejecutar código en servidores distribuidos geográficamente, lo más próximo posible de los usuarios finales.

Modelo tradicional (centralizado):

Usuario (Latinoamérica) --> Servidor (EUA) --> Respuesta (latencia: 200ms+)

Modelo edge (distribuido):

Usuario (Latinoamérica) --> Edge (Ciudad local) --> Respuesta (latencia: 20ms)

Por Qué Esto Importa

Según datos de IDC, el uso de edge computing creció 14% globalmente en 2024, y la tendencia continúa fuerte en 2025.

Beneficios principales:

• Latencia reducida hasta 90%
• Mejor experiencia del usuario
• Costos optimizados (paga por uso)
• Escalabilidad automática
• Resiliencia global

💡 Contexto: En un e-commerce, cada 100ms de latencia puede reducir conversiones en 1%. En escala, eso representa millones en ingresos.

El Ecosistema en 2025

Cloudflare Workers

El Cloudflare Workers se convirtió en la plataforma de referencia para edge computing, con presencia en más de 300 ciudades globalmente.

// worker.js - Edge function en Cloudflare
export default {
  async fetch(request, env) {
    const url = new URL(request.url);

    // Lógica de ruteo en la edge
    if (url.pathname === '/api/user') {
      const userId = url.searchParams.get('id');

      // Busca en KV Storage (distribuido globalmente)
      const userData = await env.USERS_KV.get(userId, 'json');

      if (!userData) {
        return new Response('Usuario no encontrado', { status: 404 });
      }

      return Response.json(userData);
    }

    // Proxy para origin
    return fetch(request);
  }
};

Recursos del Cloudflare Workers:

• KV Storage: Key-value store distribuido
• Durable Objects: Estado persistente en la edge
• R2: Object storage compatible con S3
• D1: Base de datos SQLite en la edge
• Queues: Colas para procesamiento asíncrono

Vercel Edge Functions

Vercel popularizó edge functions para desarrolladores frontend, especialmente con Next.js:

// app/api/hello/route.ts - Edge function en Next.js
export const runtime = 'edge';

export async function GET(request: Request) {
  const { searchParams } = new URL(request.url);
  const name = searchParams.get('name') || 'World';

  // Detectar localización del usuario
  const country = request.headers.get('x-vercel-ip-country') || 'Unknown';
  const city = request.headers.get('x-vercel-ip-city') || 'Unknown';

  return Response.json({
    message: `Hello, ${name}!`,
    location: { country, city },
    timestamp: new Date().toISOString(),
  });
}

Diferenciales de Vercel:

• Integración nativa con Next.js
• Middleware en la edge por defecto
• Edge Config para feature flags
• Analytics en tiempo real

AWS Lambda@Edge

AWS ofrece Lambda@Edge para ejecutar código en los puntos de presencia del CloudFront:

// Lambda@Edge para personalización de contenido
exports.handler = async (event) => {
  const request = event.Records[0].cf.request;
  const headers = request.headers;

  // Detectar dispositivo
  const userAgent = headers['user-agent'][0].value;
  const isMobile = /Mobile|Android|iPhone/i.test(userAgent);

  // Modificar URI basado en el dispositivo
  if (isMobile && !request.uri.includes('/m/')) {
    request.uri = '/m' + request.uri;
  }

  return request;
};

Casos de Uso Prácticos

1. Personalización en Tiempo Real

// Edge function para personalización
export default async function middleware(request: Request) {
  const country = request.headers.get('x-vercel-ip-country');

  // Redirigir para versión localizada
  if (country === 'MX' && !request.url.includes('/es')) {
    return Response.redirect(new URL('/es' + new URL(request.url).pathname, request.url));
  }

  // A/B testing en la edge
  const bucket = Math.random() < 0.5 ? 'A' : 'B';
  const response = await fetch(request);
  const newResponse = new Response(response.body, response);
  newResponse.headers.set('X-Experiment-Bucket', bucket);

  return newResponse;
}

2. API Gateway en la Edge

// Rate limiting distribuido
export default {
  async fetch(request, env) {
    const ip = request.headers.get('CF-Connecting-IP');
    const key = `rate_limit:${ip}`;

    // Contador atómico en Durable Object
    const id = env.RATE_LIMITER.idFromName(ip);
    const rateLimiter = env.RATE_LIMITER.get(id);

    const allowed = await rateLimiter.fetch(request);

    if (!allowed.ok) {
      return new Response('Too Many Requests', {
        status: 429,
        headers: { 'Retry-After': '60' }
      });
    }

    // Continuar para el backend
    return fetch(request);
  }
};

3. Cache Inteligente

// Cache con revalidación en la edge
export async function GET(request: Request) {
  const url = new URL(request.url);
  const cacheKey = url.pathname;

  // Intentar cache primero
  const cache = caches.default;
  let response = await cache.match(request);

  if (response) {
    // Revalidar en background si stale
    const age = parseInt(response.headers.get('age') || '0');
    if (age > 60) {
      // Stale-while-revalidate
      fetch(request).then(freshResponse => {
        cache.put(request, freshResponse.clone());
      });
    }
    return response;
  }

  // Buscar del origin
  response = await fetch(`https://api.example.com${url.pathname}`);

  // Cachear en la edge
  const cachedResponse = new Response(response.body, response);
  cachedResponse.headers.set('Cache-Control', 'public, max-age=300');
  cache.put(request, cachedResponse.clone());

  return cachedResponse;
}

Comparativo de Plataformas

Tiempo de Cold Start

Plataforma	Cold Start
Cloudflare Workers	~0ms (siempre caliente)
Vercel Edge Functions	~5ms
AWS Lambda@Edge	~50-200ms
AWS Lambda (Node)	~100-500ms

Límites y Recursos

Recurso	Cloudflare	Vercel	AWS Lambda@Edge
CPU Time	50ms (free) / 30s (paid)	30s	5s (viewer) / 30s (origin)
Memoria	128MB	128MB	128MB
Bundle Size	10MB	4MB	10MB
Localizaciones	300+	35+	400+

Precios (aproximados)

Cloudflare Workers:

• 100k requests/día: Gratis
• Después: $0.50/millón de requests

Vercel Edge:

• 100k ejecuciones/mes: Gratis (Hobby)
• Después: $0.65/millón de ejecuciones

AWS Lambda@Edge:

• $0.60/millón de requests
• $0.00005001/GB-segundo

Buenas Prácticas Para Edge

1. Minimiza Dependencias

// Malo - bundle muy grande
import lodash from 'lodash';
const result = lodash.groupBy(data, 'category');

// Bueno - apenas lo necesario
const groupBy = (arr, key) => arr.reduce((acc, item) => {
  (acc[item[key]] = acc[item[key]] || []).push(item);
  return acc;
}, {});

2. Usa Streaming Para Respuestas Grandes

export async function GET() {
  const encoder = new TextEncoder();

  const stream = new ReadableStream({
    async start(controller) {
      for (let i = 0; i < 100; i++) {
        const chunk = encoder.encode(`data: ${JSON.stringify({ count: i })}\n\n`);
        controller.enqueue(chunk);
        await new Promise(r => setTimeout(r, 100));
      }
      controller.close();
    }
  });

  return new Response(stream, {
    headers: {
      'Content-Type': 'text/event-stream',
      'Cache-Control': 'no-cache',
    }
  });
}

3. Aprovecha el Cache de Forma Estratégica

export async function GET(request: Request) {
  const url = new URL(request.url);

  // Headers de cache basados en el contenido
  const isStaticAsset = /\.(js|css|png|jpg)$/.test(url.pathname);

  const response = await fetch(request);
  const newResponse = new Response(response.body, response);

  if (isStaticAsset) {
    // Assets estáticos - cache largo
    newResponse.headers.set('Cache-Control', 'public, max-age=31536000, immutable');
  } else {
    // Contenido dinámico - stale-while-revalidate
    newResponse.headers.set('Cache-Control', 'public, max-age=60, stale-while-revalidate=600');
  }

  return newResponse;
}

Integración con Runtimes JavaScript

Bun en la Edge

Plataformas como Cloudflare y Vercel están integrando Bun para edge deployment:

// Usando Bun en Cloudflare Workers
export default {
  async fetch(request: Request): Promise<Response> {
    // APIs de Bun disponibles
    const file = Bun.file('./data.json');
    const data = await file.json();

    return Response.json(data);
  }
};

Deno Deploy

Deno Deploy ofrece una alternativa enfocada en seguridad:

// Deno Deploy edge function
Deno.serve((request) => {
  const url = new URL(request.url);

  if (url.pathname === '/api/time') {
    return Response.json({
      time: new Date().toISOString(),
      region: Deno.env.get('DENO_REGION'),
    });
  }

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

El Futuro del Edge Computing

Tendencias Para 2026

Lo que esperar:

• Edge databases volviéndose mainstream
• AI inference en la edge
• WebAssembly expandiendo posibilidades
• Mesh de edges interconectados

Desafíos a superar:

• Consistencia de datos distribuidos
• Debugging en ambiente distribuido
• Vendor lock-in

Conclusión

Edge computing y serverless dejaron de ser tendencias para convertirse en la forma estándar de deployar aplicaciones modernas. Con cold starts prácticamente cero, presencia global y costos basados en uso real, no hay más excusa para aplicaciones lentas.

Para desarrolladores JavaScript, el momento es ideal: las mismas skills que ya tienes funcionan en la edge. Cloudflare Workers, Vercel Edge Functions y AWS Lambda@Edge usan APIs web estándar, facilitando la migración.

Lo más importante es empezar. Mueve una única función para la edge, mide la diferencia, y ve expandiendo. Tus usuarios van a agradecer.

Si quieres entender más sobre las nuevas abordajes de desarrollo web, te recomiendo echar un vistazo al artículo sobre Server-First Development con Astro y Remix donde vas a descubrir cómo los nuevos frameworks están aprovechando la edge para entregar experiencias increíbles.

¡Vamos a por ello! 🦅