Edge Computing avec Node.js : Le Futur de la Performance Web Déjà Arrivé en 2025
Salut HaWkers, l'edge computing est passé de concept à réalité mainstream en 2025. Node.js en edge locations livre une latence <10ms globalement, exécutant du code proche des utilisateurs dans 300+ locations. Cela redéfinit ce que signifie "web rapide".
Qu'est-ce que l'Edge Computing ?
L'edge computing exécute du code sur des serveurs distribués globalement, proches des utilisateurs finaux. Au lieu d'un serveur central dans us-east-1, votre code tourne à São Paulo, Tokyo, Londres simultanément.
// Traditionnel : Serveur central
const traditionalSetup = {
server: 'us-east-1 (Virginia)',
userInFrance: {
latency: '100-150ms',
hops: 'France → London → Virginia → London → France'
},
userInJapan: {
latency: '200-300ms',
hops: 'Japan → California → Virginia → ...'
}
};
// Edge : Distribué globalement
const edgeSetup = {
locations: '300+ worldwide',
userInFrance: {
latency: '<10ms',
server: 'Paris edge location'
},
userInJapan: {
latency: '<10ms',
server: 'Tokyo edge location'
}
};
// Résultat : 20-30x réduction de latence !Plateformes Edge en 2025
1. Cloudflare Workers
// Worker tournant sur 300+ locations
export default {
async fetch(request) {
const url = new URL(request.url);
// Géolocalisation automatique
const country = request.cf.country;
const city = request.cf.city;
// KV storage sur l'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 depuis l'origin seulement si nécessaire
const response = await fetch(url);
const html = await response.text();
// Cache sur l'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
// Résultat : <10ms latence globale2. Vercel Edge Functions
// Edge function avec géolocalisation
export const config = {
runtime: 'edge'
};
export default async function handler(req) {
const { geo } = req;
// Personnalise le contenu par région
const content = await getRegionalContent(geo.country);
// A/B testing sur l'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
// Tourne sur Vercel Edge Network3. Deno Deploy
// Deno Deploy - TypeScript natif sur l'edge
import { serve } from 'https://deno.land/std@0.177.0/http/server.ts';
serve(async (req) => {
const start = Date.now();
// Deno KV sur l'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 heure
});
return new Response(response, {
headers: {
'x-cache': 'MISS',
'x-latency': `${Date.now() - start}ms`
}
});
});
// Deploy : deployctl deploy
// Global edge deploymentCas d'Usage Parfaits pour l'Edge
1. Personnalisation par Géolocalisation
// Détecte la localisation et personnalise
export default async function handler(req) {
const { country, city } = req.geo;
// Devise locale
const currency = getCurrencyForCountry(country);
// Langue préférée
const language = getLanguageForCountry(country);
// Produits disponibles dans la région
const products = await getRegionalProducts(country);
return Response.json({
currency,
language,
products,
message: `Personnalisé pour ${city}, ${country}`
});
}2. A/B Testing sans Latence
// Décisions A/B test sur l'edge = zéro latence
export default function handler(req) {
const userId = req.headers.get('x-user-id');
// Variant consistant par utilisateur
const variant = hashUserId(userId) % 2 === 0 ? 'A' : 'B';
// Log pour analytics (async, ne bloque pas)
logVariantAssignment(userId, variant);
return Response.json({
variant,
features: getFeatureFlags(variant)
});
}3. Authentification sur l'Edge
// Validation JWT sur l'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 {
// Valide JWT sur l'edge
const { payload } = await verify(token, SECRET);
// Ajoute user info au request
const modifiedReq = new Request(req.url, {
headers: {
...req.headers,
'x-user-id': payload.sub,
'x-user-role': payload.role
}
});
// Forward vers origin
return fetch(ORIGIN_URL, modifiedReq);
} catch {
return new Response('Invalid token', { status: 401 });
}
}4. Optimisation d'Images sur l'Edge
// Resize/optimize images à la volée
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 image originale
const imageReq = await fetch(url.pathname);
const image = await imageReq.arrayBuffer();
// Resize sur l'edge (avec 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'
}
});
}Limitations et Considérations
const edgeLimitations = {
cpuTime: 'Limité (50-100ms typique)',
memory: 'Restreint (128MB typique)',
coldStart: 'Pratiquement zéro, mais existe',
statefulness: 'Difficile - edge est stateless',
debugging: 'Plus complexe que traditionnel',
cost: 'Peut être plus élevé pour fort trafic'
};
// Quand NE PAS utiliser l'edge :
const avoidEdgeFor = [
'Traitement CPU intensif',
'Applications stateful complexes',
'WebSocket de longue durée',
'Opérations nécessitant >100ms CPU'
];Performance Réelle : Avant et Aprè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'
}
};L'edge computing avec Node.js redéfinit la performance web en 2025. <10ms de latence globale n'est plus de la science-fiction - c'est une réalité disponible aujourd'hui. Si vous construisez pour le web, l'edge devrait être sur votre radar. Pour plus sur Node.js moderne, voyez : Serverless en 2025 : Comment Node.js Domine.