Edge Computing e Serverless em 2025: Como Cloudflare, Vercel e AWS Estao Redefinindo a Infraestrutura

Ola HaWkers, a forma como deployamos aplicacoes esta passando por uma revolucao silenciosa. Edge computing deixou de ser uma buzzword para se tornar a estrategia padrao das empresas que levam performance a serio.

Voce ja se perguntou por que alguns sites carregam instantaneamente enquanto outros demoram segundos? A resposta muitas vezes esta em onde o codigo roda. E em 2025, esse "onde" esta cada vez mais perto do usuario.

O Que e Edge Computing

O Conceito Fundamental

Edge computing e a pratica de executar codigo em servidores distribuidos geograficamente, o mais proximo possivel dos usuarios finais.

Modelo tradicional (centralizado):

Usuario (Brasil) --> Servidor (EUA) --> Resposta (latencia: 200ms+)

Modelo edge (distribuido):

Usuario (Brasil) --> Edge (Sao Paulo) --> Resposta (latencia: 20ms)

Por Que Isso Importa

Segundo dados da IDC, o uso de edge computing cresceu 14% globalmente em 2024, e a tendencia continua forte em 2025.

Beneficios principais:

• Latencia reduzida em ate 90%
• Melhor experiencia do usuario
• Custos otimizados (paga pelo uso)
• Escalabilidade automatica
• Resiliencia global

💡 Contexto: Em um e-commerce, cada 100ms de latencia pode reduzir conversoes em 1%. Em escala, isso representa milhoes em receita.

O Ecossistema em 2025

Cloudflare Workers

O Cloudflare Workers se tornou a plataforma de referencia para edge computing, com presenca em mais de 300 cidades globalmente.

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

    // Logica de roteamento na edge
    if (url.pathname === '/api/user') {
      const userId = url.searchParams.get('id');

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

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

      return Response.json(userData);
    }

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

Recursos do Cloudflare Workers:

• KV Storage: Key-value store distribuido
• Durable Objects: Estado persistente na edge
• R2: Object storage compativel com S3
• D1: Banco de dados SQLite na edge
• Queues: Filas para processamento assincrono

Vercel Edge Functions

A Vercel popularizou edge functions para desenvolvedores frontend, especialmente com Next.js:

// app/api/hello/route.ts - Edge function no 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 localizacao do 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(),
  });
}

Diferenciais da Vercel:

• Integracao nativa com Next.js
• Middleware na edge por padrao
• Edge Config para feature flags
• Analytics em tempo real

AWS Lambda@Edge

A AWS oferece Lambda@Edge para executar codigo nos pontos de presenca do CloudFront:

// Lambda@Edge para personalizacao de conteudo
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 baseado no dispositivo
  if (isMobile && !request.uri.includes('/m/')) {
    request.uri = '/m' + request.uri;
  }

  return request;
};

Casos de Uso Praticos

1. Personalizacao em Tempo Real

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

  // Redirecionar para versao localizada
  if (country === 'BR' && !request.url.includes('/pt')) {
    return Response.redirect(new URL('/pt' + new URL(request.url).pathname, request.url));
  }

  // A/B testing na 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 na Edge

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

    // Contador atomico no 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 o backend
    return fetch(request);
  }
};

3. Cache Inteligente

// Cache com revalidacao na edge
export async function GET(request: Request) {
  const url = new URL(request.url);
  const cacheKey = url.pathname;

  // Tentar cache primeiro
  const cache = caches.default;
  let response = await cache.match(request);

  if (response) {
    // Revalidar em background se 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 do origin
  response = await fetch(`https://api.example.com${url.pathname}`);

  // Cachear na 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

Tempo de Cold Start

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

Limites e 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
Localizacoes	300+	35+	400+

Precos (aproximados)

Cloudflare Workers:

• 100k requests/dia: Gratis
• Apos: $0.50/milhao de requests

Vercel Edge:

• 100k execucoes/mes: Gratis (Hobby)
• Apos: $0.65/milhao de execucoes

AWS Lambda@Edge:

• $0.60/milhao de requests
• $0.00005001/GB-segundo

Boas Praticas Para Edge

1. Minimize Dependencias

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

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

2. Use Streaming Para Respostas 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. Aproveite o Cache de Forma Estrategica

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

  // Headers de cache baseados no conteudo
  const isStaticAsset = /\.(js|css|png|jpg)$/.test(url.pathname);

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

  if (isStaticAsset) {
    // Assets estaticos - cache longo
    newResponse.headers.set('Cache-Control', 'public, max-age=31536000, immutable');
  } else {
    // Conteudo dinamico - stale-while-revalidate
    newResponse.headers.set('Cache-Control', 'public, max-age=60, stale-while-revalidate=600');
  }

  return newResponse;
}

Integracao com Runtimes JavaScript

Bun na Edge

Plataformas como Cloudflare e Vercel estao integrando Bun para edge deployment:

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

    return Response.json(data);
  }
};

Deno Deploy

Deno Deploy oferece uma alternativa focada em seguranca:

// 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 });
});

O Futuro do Edge Computing

Tendencias Para 2026

O que esperar:

• Edge databases se tornando mainstream
• AI inference na edge
• WebAssembly expandindo possibilidades
• Mesh de edges interconectados

Desafios a superar:

• Consistencia de dados distribuidos
• Debugging em ambiente distribuido
• Vendor lock-in

Conclusao

Edge computing e serverless deixaram de ser tendencias para se tornarem a forma padrao de deployar aplicacoes modernas. Com cold starts praticamente zerados, presenca global e custos baseados em uso real, nao ha mais desculpa para aplicacoes lentas.

Para desenvolvedores JavaScript, o momento e ideal: as mesmas skills que voce ja tem funcionam na edge. Cloudflare Workers, Vercel Edge Functions e AWS Lambda@Edge usam APIs web padrao, facilitando a migracao.

O mais importante e comecar. Mova uma unica funcao para a edge, meça a diferenca, e va expandindo. Seus usuarios vao agradecer.

Se voce quer entender mais sobre as novas abordagens de desenvolvimento web, recomendo dar uma olhada no artigo sobre Server-First Development com Astro e Remix onde voce vai descobrir como os novos frameworks estao aproveitando a edge para entregar experiencias incriveis.

Bora pra cima! 🦅