Deno Deploy vs Cloudflare Workers vs Vercel Edge: onde rodar código na borda

1. Introdução ao Edge Computing e o Cenário Atual

Edge computing representa a evolução natural da computação em nuvem: em vez de processar dados em servidores centralizados, o código é executado em pontos de presença (PoPs) distribuídos globalmente, próximos aos usuários finais. Isso reduz drasticamente a latência — de centenas de milissegundos para meros dígitos — e melhora a experiência do usuário em aplicações em tempo real.

Três plataformas dominam esse cenário em 2025: Deno Deploy, Cloudflare Workers e Vercel Edge Functions. Cada uma oferece abordagens distintas para executar código na borda, variando em runtime, ecossistema, modelo de precificação e integrações. Este artigo compara esses três players sob critérios objetivos: latência, runtime suportado, ecossistema disponível e custo operacional.

2. Deno Deploy: Leveza e Modernidade com TypeScript Nativo

Deno Deploy é a plataforma de edge computing criada pelos mesmos desenvolvedores do runtime Deno. Seu diferencial é o suporte nativo a TypeScript e JavaScript moderno, rodando diretamente sobre o motor V8 da Google.

Características principais:

  • Runtime: V8 com APIs modernas (Fetch, WebSocket, Streams, Crypto)
  • Isolamento: V8 Isolates para escalabilidade instantânea e zero cold start
  • Deploy: integração com GitHub, deploys automáticos a cada push
  • Limitações: sem suporte a APIs Node.js (fs, http, process); dependências externas restritas ao ecossistema Deno
// Exemplo: API de geolocalização com Deno Deploy
import { serve } from "https://deno.land/std@0.224.0/http/server.ts";

serve(async (req) => {
  const url = new URL(req.url);
  const country = req.headers.get("cf-ipcountry") || "unknown";

  if (url.pathname === "/api/location") {
    return new Response(JSON.stringify({ country, timestamp: Date.now() }), {
      headers: { "Content-Type": "application/json" },
    });
  }

  return new Response("Bem-vindo ao Deno Deploy!", { status: 200 });
});

Deno Deploy é ideal para times que já adotaram TypeScript moderno e buscam simplicidade — sem configurações complexas de build ou bundler.

3. Cloudflare Workers: Maturidade e Infraestrutura Global Massiva

Cloudflare Workers é a plataforma mais madura do mercado, operando em mais de 300 cidades ao redor do mundo. Sua arquitetura distribuída permite executar código JavaScript, TypeScript ou WebAssembly em cada um desses PoPs.

Ecossistema rico:

  • Workers KV: armazenamento chave-valor global de baixa latência
  • R2: armazenamento de objetos compatível com S3
  • D1: banco de dados SQLite serverless
  • Queues: filas de mensagens assíncronas
  • Workers AI: inferência de ML na borda
// Exemplo: Cache de conteúdo dinâmico com Cloudflare Workers + KV
export default {
  async fetch(request, env, ctx) {
    const url = new URL(request.url);
    const cacheKey = `page:${url.pathname}`;

    // Tenta obter do cache KV
    const cached = await env.MY_KV.get(cacheKey);
    if (cached) {
      return new Response(cached, {
        headers: { "Content-Type": "text/html", "X-Cache": "HIT" },
      });
    }

    // Gera conteúdo dinâmico
    const content = `<html><body><h1>Página: ${url.pathname}</h1><p>Gerado em ${Date.now()}</p></body></html>`;

    // Armazena no KV por 60 segundos
    ctx.waitUntil(env.MY_KV.put(cacheKey, content, { expirationTtl: 60 }));

    return new Response(content, {
      headers: { "Content-Type": "text/html", "X-Cache": "MISS" },
    });
  },
};

Cloudflare Workers é a escolha certa para quem precisa de escala global imediata com baixa latência, especialmente em aplicações que exigem armazenamento distribuído.

4. Vercel Edge Functions: Integração com Next.js e Vercel Ecosystem

Vercel Edge Functions são executadas no runtime V8 da Vercel, seguindo as especificações WinterCG (Web-interoperable Runtimes Community Group). Sua principal vantagem é a integração nativa com Next.js e o ecossistema Vercel.

Características:

  • Runtime: V8 via WinterCG, com suporte a Fetch, WebSocket e Crypto
  • Integração: Middleware e API Routes do Next.js
  • Limites: 50 ms de CPU por requisição; 1 MB de payload máximo
  • Vantagens: preview deployments automáticos, analytics embutidos, edge config
// Exemplo: Middleware de autenticação em Vercel Edge Functions com Next.js
// Arquivo: middleware.ts
import { NextResponse } from "next/server";
import type { NextRequest } from "next/server";

export function middleware(request: NextRequest) {
  const token = request.cookies.get("auth-token")?.value;
  const url = request.nextUrl.clone();

  // Rotas protegidas
  const protectedPaths = ["/dashboard", "/admin", "/profile"];
  const isProtected = protectedPaths.some(path => url.pathname.startsWith(path));

  if (isProtected && !token) {
    url.pathname = "/login";
    return NextResponse.redirect(url);
  }

  // Adiciona header de segurança
  const response = NextResponse.next();
  response.headers.set("X-Edge-Region", request.geo?.region || "unknown");

  return response;
}

export const config = {
  matcher: ["/dashboard/:path*", "/admin/:path*", "/profile/:path*"],
};

Vercel Edge Functions são perfeitas para quem já utiliza Next.js e busca deploy simplificado com previews automáticos e integração com o ecossistema Vercel.

5. Comparação Técnica de Performance e Limitações

Latência geográfica

  • Cloudflare Workers: 330+ PoPs — menor latência global
  • Deno Deploy: 35+ PoPs — boa cobertura, mas inferior à Cloudflare
  • Vercel Edge: 30+ PoPs — cobertura regional, excelente para Américas e Europa

Cold start e warm start

  • Deno Deploy: zero cold start (V8 Isolates persistentes)
  • Cloudflare Workers: ~5 ms cold start; warm start instantâneo
  • Vercel Edge: ~10 ms cold start; warm start em <1 ms

Suporte a Web APIs e limitações

Plataforma Fetch WebSocket Crypto Memória CPU
Deno Deploy ✅ ✅ ✅ 128 MB 50 ms
Cloudflare Workers ✅ ✅ ✅ 128 MB 30 ms
Vercel Edge ✅ ✅ ✅ 128 MB 50 ms

6. Casos de Uso Práticos e Exemplos de Código

Exemplo 1: API de geolocalização com roteamento inteligente em Deno Deploy

// Roteamento inteligente baseado em geolocalização
import { serve } from "https://deno.land/std@0.224.0/http/server.ts";

const servers = {
  "US": "us.api.example.com",
  "BR": "br.api.example.com",
  "EU": "eu.api.example.com",
};

serve(async (req) => {
  const country = req.headers.get("cf-ipcountry") || "US";
  const targetServer = servers[country] || servers["US"];

  // Proxy para o servidor regional mais próximo
  const response = await fetch(`https://${targetServer}/api/data`);

  return new Response(await response.text(), {
    headers: { "X-Regional-Server": targetServer },
  });
});

Exemplo 2: Cache de conteúdo dinâmico com Cloudflare Workers + KV

// Cache de API com expiração configurável
export default {
  async fetch(request, env, ctx) {
    const cacheKey = `api:${request.url}`;
    const cached = await env.API_CACHE.get(cacheKey, { type: "json" });

    if (cached) {
      return new Response(JSON.stringify(cached), {
        headers: { "Content-Type": "application/json", "X-Cache": "HIT" },
      });
    }

    const data = await fetchExternalAPI(request.url);
    ctx.waitUntil(env.API_CACHE.put(cacheKey, JSON.stringify(data), { expirationTtl: 300 }));

    return new Response(JSON.stringify(data), {
      headers: { "Content-Type": "application/json", "X-Cache": "MISS" },
    });
  },
};

Exemplo 3: Middleware de autenticação em Vercel Edge Functions com Next.js

// Middleware para validação de token JWT na borda
import { NextResponse } from "next/server";
import { jwtVerify } from "jose";

export async function middleware(request) {
  const token = request.cookies.get("session")?.value;

  if (!token) {
    return NextResponse.redirect(new URL("/login", request.url));
  }

  try {
    const { payload } = await jwtVerify(token, new TextEncoder().encode(process.env.JWT_SECRET));
    const response = NextResponse.next();
    response.headers.set("X-User-ID", payload.sub);
    return response;
  } catch {
    return NextResponse.redirect(new URL("/login", request.url));
  }
}

7. Considerações sobre Custo, Escalabilidade e Vendor Lock-in

Modelos de precificação

  • Deno Deploy: plano gratuito generoso (100k requisições/mês); pago a partir de $10/mês
  • Cloudflare Workers: plano gratuito (100k requisições/dia); pago a partir de $5/mês
  • Vercel Edge: plano gratuito (100k requisições/mês); pago a partir de $20/mês

Portabilidade de código

  • WinterCG: Vercel Edge e Cloudflare Workers seguem padrões WinterCG
  • Deno Deploy: APIs proprietárias, mas compatíveis com padrões web
  • Estratégia: usar APIs web padrão (Fetch, WebSocket, Crypto) para maximizar portabilidade

Mitigação de vendor lock-in

  • Separar lógica de negócio da infraestrutura
  • Usar abstrações como Hono ou Itty Router
  • Manter testes locais com runtimes compatíveis (Deno, Node.js com polyfills)

8. Conclusão: Qual Escolher em 2025?

Deno Deploy é a melhor escolha para projetos modernos e times que amam TypeScript puro, especialmente startups que buscam simplicidade e zero configuração. Sua experiência de desenvolvimento é impecável, mas o ecossistema ainda é limitado comparado aos concorrentes.

Cloudflare Workers é ideal para aplicações que exigem alta escala global com latência mínima. Seu ecossistema integrado (KV, R2, D1, Queues) oferece soluções completas para aplicações complexas. É a plataforma mais madura e confiável para cenários enterprise.

Vercel Edge é perfeito para quem já utiliza Next.js e busca deploy simplificado com previews automáticos. A integração nativa com o framework e o ecossistema Vercel (analytics, edge config, ISR) fazem dela a escolha natural para projetos baseados em Next.js.

Recomendação final:
- Startup side project: Deno Deploy — simplicidade e custo zero
- Aplicação enterprise: Cloudflare Workers — escala global e ecossistema completo
- Projeto Next.js: Vercel Edge — integração nativa e deploy simplificado

A escolha final depende do seu stack atual, necessidades de escala e orçamento. Em todos os casos, priorize o uso de APIs web padrão para garantir portabilidade futura.

Referências