Edge Functions vs Serverless: O Que Muda na Prática

// middleware.ts (Vercel Edge Runtime / Next.js Middleware)
import { NextRequest, NextResponse } from "next/server";
 
export function middleware(request: NextRequest) {
  const bucket = request.cookies.get("ab-bucket")?.value;
 
  if (!bucket) {
    // Atribui bucket no primeiro acesso para manter consistência durante a sessão
    const assigned = Math.random() > 0.5 ? "control" : "variant";
    const response = NextResponse.next();
    response.cookies.set("ab-bucket", assigned, { maxAge: 60 * 60 * 24 * 30 });
    return response;
  }
 
  if (bucket === "variant") {
    return NextResponse.rewrite(new URL("/landing-variant", request.url));
  }
 
  return NextResponse.next();
}
 
export const config = {
  matcher: ["/landing"],
};

// Cloudflare Worker: validação de JWT na edge
// Usa Web Crypto API (disponível em V8 isolates, sem dependência de node:crypto)
export default {
  async fetch(request: Request): Promise<Response> {
    const authHeader = request.headers.get("Authorization");
    if (!authHeader?.startsWith("Bearer ")) {
      return new Response("Unauthorized", { status: 401 });
    }
 
    const token = authHeader.slice(7);
 
    try {
      const payload = await verifyJwt(token);
      // Propaga identidade para o origin via header customizado
      const upstreamRequest = new Request(request);
      upstreamRequest.headers.set("X-User-Id", payload.sub);
      return fetch(upstreamRequest);
    } catch {
      return new Response("Invalid token", { status: 403 });
    }
  },
};
 
async function verifyJwt(token: string): Promise<{ sub: string }> {
  const [headerB64, payloadB64, signatureB64] = token.split(".");
  const encoder = new TextEncoder();
 
  // Importa a chave pública como CryptoKey (RS256)
  const key = await crypto.subtle.importKey(
    "jwk",
    JWT_PUBLIC_JWK, // Variável de ambiente ou KV binding
    { name: "RSASSA-PKCS1-v1_5", hash: "SHA-256" },
    false,
    ["verify"]
  );
 
  const data = encoder.encode(`${headerB64}.${payloadB64}`);
  const signature = base64UrlDecode(signatureB64);
 
  const valid = await crypto.subtle.verify("RSASSA-PKCS1-v1_5", key, signature, data);
  if (!valid) throw new Error("Signature mismatch");
 
  return JSON.parse(atob(payloadB64.replace(/-/g, "+").replace(/_/g, "/")));
}
 
function base64UrlDecode(str: string): ArrayBuffer {
  const binary = atob(str.replace(/-/g, "+").replace(/_/g, "/"));
  const bytes = new Uint8Array(binary.length);
  for (let i = 0; i < binary.length; i++) bytes[i] = binary.charCodeAt(i);
  return bytes.buffer;
}

// Vercel Edge Function com geolocalização
import { NextRequest, NextResponse } from "next/server";
 
export const config = { runtime: "edge" };
 
export default function handler(request: NextRequest) {
  const country = request.geo?.country ?? "US";
 
  // Retorna pricing na moeda local sem consultar banco
  const pricing: Record<string, { currency: string; price: number }> = {
    BR: { currency: "BRL", price: 49.9 },
    US: { currency: "USD", price: 9.99 },
    PT: { currency: "EUR", price: 8.99 },
  };
 
  const plan = pricing[country] ?? pricing["US"];
 
  return NextResponse.json({ country, ...plan });
}

// Lambda function: processamento que exige runtime Node.js completo
import { S3Client, GetObjectCommand, PutObjectCommand } from "@aws-sdk/client-s3";
import sharp from "sharp";
import { Readable } from "node:stream";
 
const s3 = new S3Client({ region: "sa-east-1" });
 
export async function handler(event: { bucket: string; key: string }) {
  const { Body } = await s3.send(
    new GetObjectCommand({ Bucket: event.bucket, Key: event.key })
  );
 
  // sharp usa libvips (binário nativo): impossível em Edge Functions
  const optimized = await sharp(await streamToBuffer(Body as Readable))
    .resize(800, 600, { fit: "inside", withoutEnlargement: true })
    .webp({ quality: 80 })
    .toBuffer();
 
  const outputKey = event.key.replace(/\.\w+$/, ".webp");
  await s3.send(
    new PutObjectCommand({
      Bucket: event.bucket,
      Key: outputKey,
      Body: optimized,
      ContentType: "image/webp",
    })
  );
 
  return { statusCode: 200, outputKey };
}
 
async function streamToBuffer(stream: Readable): Promise<Buffer> {
  const chunks: Buffer[] = [];
  for await (const chunk of stream) chunks.push(Buffer.from(chunk));
  return Buffer.concat(chunks);
}

// ERRADO: Edge Function fazendo query pesada em banco remoto
export const config = { runtime: "edge" };
 
export default async function handler() {
  // Neon serverless driver via HTTP: cada query é um round-trip HTTP
  const response = await fetch("https://your-project.us-east-1.aws.neon.tech/sql", {
    method: "POST",
    headers: { Authorization: `Bearer ${process.env.NEON_API_KEY}` },
    body: JSON.stringify({
      // Join complexo com agregação: ~50-200 ms de execução no banco
      // + ~300 ms de round-trip São Paulo -> Virginia -> São Paulo
      query: `
        SELECT u.id, u.name, COUNT(o.id) as order_count, SUM(o.total) as lifetime_value
        FROM users u
        LEFT JOIN orders o ON o.user_id = u.id
        WHERE u.created_at > NOW() - INTERVAL '30 days'
        GROUP BY u.id, u.name
        ORDER BY lifetime_value DESC
        LIMIT 50
      `,
    }),
  });
 
  return new Response(await response.text(), {
    headers: { "Content-Type": "application/json" },
  });
}

// CORRETO: Serverless Function na mesma região do banco
// Lambda em us-east-1, RDS/Neon em us-east-1: latência de rede < 5 ms
import { Pool } from "pg";
 
// Pool reutilizado entre invocações quentes (Lambda reusa o container)
const pool = new Pool({
  connectionString: process.env.DATABASE_URL,
  max: 1, // Uma conexão por instância Lambda para evitar exaustão do pool
});
 
export async function handler() {
  const { rows } = await pool.query(`
    SELECT u.id, u.name, COUNT(o.id) as order_count, SUM(o.total) as lifetime_value
    FROM users u
    LEFT JOIN orders o ON o.user_id = u.id
    WHERE u.created_at > NOW() - INTERVAL '30 days'
    GROUP BY u.id, u.name
    ORDER BY lifetime_value DESC
    LIMIT 50
  `);
 
  return {
    statusCode: 200,
    headers: { "Content-Type": "application/json" },
    body: JSON.stringify(rows),
  };
}

// ERRADO: importar aws-sdk completo em Edge Function
// O bundle ultrapassa o limite de 1 MB (Workers) ou 4 MB (Vercel Edge)
import AWS from "aws-sdk"; // ~70 MB descomprimido, tree-shaking limitado
 
export const config = { runtime: "edge" };

// CORRETO: se precisa de AWS SDK, use Serverless Function com runtime Node.js
// Ou use apenas o client modular (@aws-sdk/client-s3 isolado) se o bundle couber
import { S3Client, GetObjectCommand } from "@aws-sdk/client-s3";
// Client modular: ~3 MB, cabe em Lambda, não cabe em Workers (1 MB limit)

Usuário (São Paulo)
    │
    ▼
Edge Function (PoP São Paulo) ─── 1. Valida JWT (~2 ms)
    │                              2. Rate limiting via KV (~5 ms)
    │                              3. Redireciona A/B test
    │
    ▼ (se autorizado)
Serverless Function (sa-east-1) ── 4. Query no banco (~10 ms rede + query)
    │                               5. Lógica de negócio
    │                               6. Resposta
    ▼
Usuário (São Paulo)

// next.config.ts: controle granular de runtime por rota
import type { NextConfig } from "next";
 
const nextConfig: NextConfig = {
  // Middleware SEMPRE roda na edge (não configurável)
  // Route Handlers e pages: configuráveis por arquivo
};
 
export default nextConfig;

// app/api/lightweight/route.ts: rota leve na edge
export const runtime = "edge";
 
export async function GET(request: Request) {
  // Lógica que não precisa de Node.js APIs
  const data = { timestamp: Date.now(), region: "auto" };
  return Response.json(data);
}

// app/api/heavy/route.ts: rota pesada no Node.js
export const runtime = "nodejs"; // Padrão no App Router, mas explícito é melhor
 
import { prisma } from "@/lib/prisma";
 
export async function GET() {
  // Prisma usa query engine binária: precisa de Node.js runtime
  const users = await prisma.user.findMany({
    include: { orders: { where: { status: "COMPLETED" } } },
    take: 50,
  });
 
  return Response.json(users);
}