Edge Computing con Node.js: El Futuro del Rendimiento Web que Ya Llegó en 2025
Hola HaWkers, edge computing pasó de concepto a realidad mainstream en 2025. Node.js en edge locations entrega latencia <10ms globalmente, corriendo código cerca de los usuarios en 300+ locations. Esto está redefiniendo lo que significa "web rápida".
¿Qué Es Edge Computing?
Edge computing corre código en servidores distribuidos globalmente, cerca de los usuarios finales. En lugar de un servidor central en us-east-1, tu código corre en São Paulo, Tokyo, Londres simultáneamente.
// Tradicional: Servidor central
const traditionalSetup = {
server: 'us-east-1 (Virginia)',
userInBrazil: {
latency: '150-250ms',
hops: 'Brasil → Miami → Virginia → Miami → Brasil'
},
userInJapan: {
latency: '200-300ms',
hops: 'Japan → California → Virginia → ...'
}
};
// Edge: Distribuido globalmente
const edgeSetup = {
locations: '300+ worldwide',
userInBrazil: {
latency: '<10ms',
server: 'São Paulo edge location'
},
userInJapan: {
latency: '<10ms',
server: 'Tokyo edge location'
}
};
// Resultado: ¡20-30x reducción en latencia!Plataformas Edge en 2025
1. Cloudflare Workers
// Worker corriendo en 300+ locations
export default {
async fetch(request) {
const url = new URL(request.url);
// Geolocation automática
const country = request.cf.country;
const city = request.cf.city;
// KV storage en edge
const cache = await EDGE_KV.get(`page:${url.pathname}`);
if (cache) {
return new Response(cache, {
headers: {
'content-type': 'text/html',
'x-edge-location': city,
'x-cache': 'HIT'
}
});
}
// Fetch de origin solo si necesario
const response = await fetch(url);
const html = await response.text();
// Cache en edge
await EDGE_KV.put(`page:${url.pathname}`, html, {
expirationTtl: 3600
});
return new Response(html, {
headers: {
'x-edge-location': city,
'x-cache': 'MISS'
}
});
}
};
// Deploy: wrangler publish
// Resultado: <10ms latencia global2. Vercel Edge Functions
// Edge function con geolocation
export const config = {
runtime: 'edge'
};
export default async function handler(req) {
const { geo } = req;
// Personaliza contenido por región
const content = await getRegionalContent(geo.country);
// A/B testing en edge
const variant = Math.random() < 0.5 ? 'A' : 'B';
return new Response(
JSON.stringify({
content,
variant,
location: geo.city,
latency: '<10ms'
}),
{
headers: {
'content-type': 'application/json',
'x-edge-region': geo.country
}
}
);
}
// Deploy: vercel --prod
// Corre en Vercel Edge Network3. Deno Deploy
// Deno Deploy - TypeScript nativo en edge
import { serve } from 'https://deno.land/std@0.177.0/http/server.ts';
serve(async (req) => {
const start = Date.now();
// Deno KV en edge
const kv = await Deno.openKv();
const cached = await kv.get(['cache', req.url]);
if (cached.value) {
return new Response(cached.value as string, {
headers: {
'x-cache': 'HIT',
'x-latency': `${Date.now() - start}ms`
}
});
}
const response = await processRequest(req);
await kv.set(['cache', req.url], response, {
expireIn: 3600000 // 1 hora
});
return new Response(response, {
headers: {
'x-cache': 'MISS',
'x-latency': `${Date.now() - start}ms`
}
});
});
// Deploy: deployctl deploy
// Global edge deploymentCasos de Uso Perfectos para Edge
1. Personalización por Geolocalización
// Detecta localización y personaliza
export default async function handler(req) {
const { country, city } = req.geo;
// Moneda local
const currency = getCurrencyForCountry(country);
// Idioma preferido
const language = getLanguageForCountry(country);
// Productos disponibles en la región
const products = await getRegionalProducts(country);
return Response.json({
currency,
language,
products,
message: `Personalizado para ${city}, ${country}`
});
}2. A/B Testing sin Latencia
// A/B test decisions en edge = zero latency
export default function handler(req) {
const userId = req.headers.get('x-user-id');
// Consistent variant per user
const variant = hashUserId(userId) % 2 === 0 ? 'A' : 'B';
// Log para analytics (async, no bloquea)
logVariantAssignment(userId, variant);
return Response.json({
variant,
features: getFeatureFlags(variant)
});
}3. Authentication en Edge
// JWT validation en edge
import { verify } from 'jose';
export default async function handler(req) {
const token = req.headers.get('authorization')?.split(' ')[1];
if (!token) {
return new Response('Unauthorized', { status: 401 });
}
try {
// Valida JWT en edge
const { payload } = await verify(token, SECRET);
// Agrega user info al request
const modifiedReq = new Request(req.url, {
headers: {
...req.headers,
'x-user-id': payload.sub,
'x-user-role': payload.role
}
});
// Forward a origin
return fetch(ORIGIN_URL, modifiedReq);
} catch {
return new Response('Invalid token', { status: 401 });
}
}4. Image Optimization en Edge
// Resize/optimize images on-the-fly
export default async function handler(req) {
const url = new URL(req.url);
const width = url.searchParams.get('w') || '800';
const quality = url.searchParams.get('q') || '80';
// Fetch imagen original
const imageReq = await fetch(url.pathname);
const image = await imageReq.arrayBuffer();
// Resize en edge (¡con WebAssembly!)
const resized = await resizeImage(image, {
width: parseInt(width),
quality: parseInt(quality)
});
return new Response(resized, {
headers: {
'content-type': 'image/jpeg',
'cache-control': 'public, max-age=31536000',
'x-processed-at': 'edge'
}
});
}Limitaciones y Consideraciones
const edgeLimitations = {
cpuTime: 'Limitado (50-100ms típico)',
memory: 'Restringido (128MB típico)',
coldStart: 'Prácticamente zero, pero existe',
statefulness: 'Difícil - edge es stateless',
debugging: 'Más complejo que tradicional',
cost: 'Puede ser mayor para alto tráfico'
};
// Cuándo NO usar edge:
const avoidEdgeFor = [
'Procesamiento CPU intensivo',
'Aplicaciones stateful complejas',
'WebSocket de larga duración',
'Operaciones que requieren >100ms CPU'
];Rendimiento Real: Antes y Después
const realWorldImpact = {
ecommerce: {
before: 'TTFB 200ms, Core Web Vitals: Poor',
after: 'TTFB 10ms, Core Web Vitals: Good',
result: '+15% conversion rate'
},
media: {
before: 'First paint 1.2s',
after: 'First paint 0.3s',
result: '+30% engagement'
},
api: {
before: 'p99 latency 500ms',
after: 'p99 latency 50ms',
result: 'Better UX, lower costs'
}
};Edge computing con Node.js está redefiniendo rendimiento web en 2025. <10ms latencia global ya no es ciencia ficción - es realidad disponible hoy. Si estás construyendo para la web, edge debe estar en tu radar. Para más sobre Node.js moderno, ve: Serverless en 2025: Cómo Node.js Domina.
¡Vamos a por ello! 🦅
Únete a los Desarrolladores que Están Evolucionando
Edge computing está construido sobre JavaScript/Node.js. Dominar fundamentos es esencial para aprovechar esta revolución de rendimiento.
Comienza ahora:
- $9.90 USD (pago único)