Jeff Bruchado
Volver al blog

Serverless y Edge Computing: ¿El Fin de los Servidores Tradicionales?

Hola HaWkers, ¿recuerdas cuando hacer deploy significaba configurar servidores, instalar Node.js, configurar Nginx, gestionar SSL, escalar horizontalmente, monitorear CPU y RAM? En 2025, eso parece tan anticuado como los disquetes.

Serverless y Edge Computing eliminaron 90% de esa complejidad. Y no es apenas hype - empresas están ahorrando millones mientras entregan aplicaciones más rápidas y resilientes. Vamos a entender esta revolución.

¿Qué Cambió en 2025?

Serverless ya no es "esa cosa de AWS Lambda". Es mainstream:

  • Vercel procesa 10+ billones de requests/mes en edge
  • Cloudflare Workers corre en 300+ datacenters globalmente
  • Netlify Edge Functions tiene cold start de <10ms
  • Next.js, Nuxt, SvelteKit vienen con edge functions nativas

La vieja arquitectura "servidor monolito en región única" está muerta para 80% de los casos de uso.

Serverless: Código Sin Servidor

La promesa: escribes funciones, la plataforma gestiona todo - escalabilidad, disponibilidad, infraestructura.

// api/user.js - Deploy automático como función serverless
export default async function handler(req, res) {
  const { userId } = req.query;

  try {
    // Conecta al DB (connection pooling automático)
    const user = await db.user.findUnique({
      where: { id: userId }
    });

    if (!user) {
      return res.status(404).json({ error: 'User not found' });
    }

    return res.status(200).json(user);
  } catch (error) {
    console.error('Error fetching user:', error);
    return res.status(500).json({ error: 'Internal server error' });
  }
}

// Deploy: git push origin main
// Resultado: Función corre en 20+ regiones globalmente
// Escala: 0 → 10.000 requests/seg automáticamente
// Costo: Pagas apenas por lo que usas

Ventajas Reales

  1. Zero gestión de infra: Sin SSH, sin patches de seguridad, sin escalar manualmente
  2. Pay-per-use: Función no corre = costo zero. No pagas servidor ocioso
  3. Auto-scaling: De 1 a 1 millón de requests sin config
  4. Alta disponibilidad: Built-in, sin configuración

Desafíos

// ❌ Cold start puede impactar latencia
// Primera ejecución después de idle: 500ms-2s

// ✅ Solución 1: Warm-up scheduled
export const config = {
  schedule: '*/5 * * * *' // Corre cada 5 min
};

// ✅ Solución 2: Provisioned concurrency (AWS)
// ✅ Solución 3: Edge functions (cold start <10ms)

Edge Computing: Código Cerca del Usuario

Si serverless es "sin servidor", edge es "en el servidor más cercano posible del usuario".

// middleware.ts - Corre en edge, antes del servidor
import { NextResponse } from 'next/server';
import type { NextRequest } from 'next/server';

export function middleware(request: NextRequest) {
  // Detecta ubicación del usuario
  const country = request.geo?.country || 'US';
  const city = request.geo?.city || 'Unknown';

  // ¿Usuario de Brasil? Redirige a contenido BR
  if (country === 'BR') {
    const url = request.nextUrl.clone();
    url.pathname = `/br${url.pathname}`;
    return NextResponse.rewrite(url);
  }

  // A/B testing en edge (sin backend)
  const bucket = Math.random() < 0.5 ? 'A' : 'B';
  const response = NextResponse.next();
  response.cookies.set('ab-test', bucket);

  // Feature flags en edge
  const features = {
    newCheckout: country === 'US',
    betaFeature: ['US', 'GB', 'BR'].includes(country),
  };

  response.headers.set('x-features', JSON.stringify(features));

  return response;
}

// Este código corre en 300+ ubicaciones globalmente
// Latencia: <50ms desde cualquier lugar del mundo

¿Por Qué Edge es Revolucionario?

Antes (Servidor Central):

  • Usuario BR → Servidor US (Virginia)
  • Latencia: 200-300ms
  • Todo request viaja 8.000km

Después (Edge):

  • Usuario BR → Edge en São Paulo
  • Latencia: 10-20ms
  • Request viaja <100km

Resultado: 10-15x más rápido para lógica de edge.

Cloudflare Workers: El Edge Más Poderoso

// worker.js - Corre en 300+ datacenters de Cloudflare
addEventListener('fetch', event => {
  event.respondWith(handleRequest(event.request));
});

async function handleRequest(request) {
  const url = new URL(request.url);

  // Cache inteligente en edge
  const cacheKey = new Request(url.toString(), request);
  const cache = caches.default;

  let response = await cache.match(cacheKey);

  if (!response) {
    // No está en cache, busca del origin
    response = await fetch(request);

    // Optimización de imagen en edge
    if (url.pathname.endsWith('.jpg') || url.pathname.endsWith('.png')) {
      response = new Response(response.body, response);
      response.headers.set('Cache-Control', 'public, max-age=86400');

      // Convierte a WebP automáticamente
      const accept = request.headers.get('Accept') || '';
      if (accept.includes('image/webp')) {
        // ¡Workers puede transformar imágenes en edge!
        response.headers.set('Content-Type', 'image/webp');
      }
    }

    // Almacena en cache edge
    event.waitUntil(cache.put(cacheKey, response.clone()));
  }

  return response;
}

// Deploy: wrangler publish
// Costo: 100k requests/día GRATIS
// Latencia global: <50ms

Casos de Uso Edge

  1. Autenticación: Valida JWT en edge, bloquea requests inválidos antes de llegar al servidor
  2. Geolocation: Redirige basado en país
  3. A/B Testing: Sin backend, decisiones en edge
  4. Bot protection: Detecta y bloquea bots
  5. Image optimization: Transforma imágenes on-the-fly
  6. Rate limiting: Limita requests en edge

Vercel Edge Functions: Next.js Nativo

// app/api/personalize/route.ts
import { NextRequest, NextResponse } from 'next/server';

export const config = {
  runtime: 'edge', // ¡Corre en edge!
};

export async function GET(request: NextRequest) {
  // Acceso a geolocation nativo
  const { geo } = request;

  // Personalización basada en ubicación
  const content = {
    BR: { currency: 'BRL', language: 'pt-BR', tax: 0.15 },
    US: { currency: 'USD', language: 'en-US', tax: 0.08 },
    GB: { currency: 'GBP', language: 'en-GB', tax: 0.20 },
  }[geo?.country || 'US'];

  // Llama KV storage en edge (Vercel KV)
  const userPrefs = await kv.get(`user:${userId}`);

  return NextResponse.json({
    ...content,
    preferences: userPrefs,
    server: 'edge',
    region: geo?.city,
  });
}

// Latencia típica: 10-30ms globalmente

Arquitectura Híbrida: Lo Mejor de los Dos Mundos

En 2025, la arquitectura ganadora combina:

┌─────────────────────────────────────────┐
│           Edge Layer (CDN)              │
│  • Static assets                        │
│  • Edge functions (auth, routing)       │
│  • Cache                                │
└──────────────┬──────────────────────────┘
               │
┌──────────────▼──────────────────────────┐
│      Serverless Functions (API)         │
│  • Business logic                       │
│  • DB queries                           │
│  • Third-party integrations             │
└──────────────┬──────────────────────────┘
               │
┌──────────────▼──────────────────────────┐
│        Managed Services                 │
│  • Database (Supabase, PlanetScale)     │
│  • Storage (S3, R2)                     │
│  • Queue (SQS, Inngest)                 │
└─────────────────────────────────────────┘

Ejemplo Real: E-commerce

// Edge: Routing y autenticación
// middleware.ts
export function middleware(req: NextRequest) {
  const token = req.cookies.get('auth');

  if (!token && req.nextUrl.pathname.startsWith('/checkout')) {
    return NextResponse.redirect(new URL('/login', req.url));
  }

  return NextResponse.next();
}

// Serverless: Lógica de negocio
// api/checkout/route.ts
export async function POST(req: Request) {
  const { items, paymentMethod } = await req.json();

  // Calcula total
  const total = items.reduce((sum, item) => sum + item.price * item.qty, 0);

  // Procesa pago (Stripe)
  const payment = await stripe.paymentIntents.create({
    amount: total,
    currency: 'usd',
    payment_method: paymentMethod,
  });

  // Guarda pedido en DB
  const order = await db.order.create({
    data: { userId, items, total, paymentId: payment.id },
  });

  return NextResponse.json({ orderId: order.id });
}

Costos: Serverless vs Tradicional

Escenario: API con 10M requests/mes, promedio 100ms de ejecución

Tradicional (EC2 t3.medium 24/7):

  • Costo fijo: $30-50/mes
  • Ocioso 80% del tiempo
  • Sin auto-scaling

Serverless (AWS Lambda):

  • 10M requests × $0.20/1M = $2
  • 10M × 100ms compute = $0.83
  • Total: ~$3/mes
  • Escala automáticamente

Ahorro: 90% para tráfico medio/bajo.

Cuándo NO Usar Serverless

  1. Long-running tasks: Funciones tienen timeout (15 min AWS, 30s Vercel)
  2. WebSockets persistentes: Serverless es stateless
  3. Workloads constantes 24/7: Servidor tradicional puede ser más barato
  4. Vendor lock-in concerns: Código puede ser específico de la plataforma

El Futuro: WASM en Edge

La próxima frontera es correr WebAssembly en edge:

// Código Rust compilado para Wasm corriendo en edge
import init, { process_image } from './image_processor.wasm';

export default async function handler(req) {
  await init();

  const imageBuffer = await req.arrayBuffer();
  const processed = process_image(new Uint8Array(imageBuffer));

  return new Response(processed, {
    headers: { 'Content-Type': 'image/jpeg' }
  });
}

// Performance nativa + portabilidad + edge = 🔥

Si quieres entender más sobre performance moderna, lee: Edge Computing y Node.js: El Futuro de la Performance Web donde profundizo estrategias de optimización.

¡Vamos a por ello! 🦅

Domina JavaScript para Trabajar con Serverless

Serverless y Edge son JavaScript-first. Dominar JS moderno (async/await, streams, workers) es esencial.

Comienza ahora:

  • $9.90 USD (pago único)

Acceder a Guía Completo

"Fundamentos sólidos me prepararon para trabajar con arquitecturas serverless!" - Carlos, Cloud Engineer

Comentarios (0)

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

Añadir comentarios