Edge Functions vs Serverless Functions: Quando Usar Cada Uma na Vercel

Se você está construindo sistemas corporativos de alto desempenho usando Next.js na Vercel (e eu já expliquei por que foco 100% no ecossistema Next.js e React), eventualmente você vai esbarrar em uma decisão técnica crítica: onde o seu código backend deve rodar?
Na era moderna da computação em nuvem, você não aluga mais "servidores inteiros" (EC2) que ficam ligados 24 horas por dia ociosos. Você envia o seu código para a nuvem e ele é executado apenas quando um usuário faz uma requisição.
Dentro do ecossistema da Vercel, existem dois motores principais para executar esse código: Serverless Functions e Edge Functions. Escolher o motor errado pode resultar em latência severa (Cold Starts) ou limitações de banco de dados.
Neste artigo técnico, vou destrinchar como cada arquitetura funciona por debaixo dos panos, quando usar cada uma, e implementar um Proxy de Autenticação real usando Web APIs leves.
Middleware.ts depreciado: No Next.js 16, o clássico arquivo middleware.ts foi depreciado (ainda funciona, mas será removido no futuro). A nova convenção oficial é nomear o arquivo como proxy.ts e exportar a função export async function proxy(). Atenção: o proxy.ts roda no runtime Node.js e não suporta o Edge Runtime; se você realmente precisa de Edge nessa camada, ainda é preciso manter o middleware.ts. Todos os tutoriais deste portal já foram refatorados para essa convenção.
Atualização: A documentação da Vercel hoje recomenda migrar do Edge para o Node.js, por desempenho e confiabilidade. Os dois runtimes rodam sobre o Fluid compute, que reaproveita instâncias entre requisições e reduz o impacto do Cold Start. E, a partir do Next.js 16.3, runtime = 'edge' deixou de ser suportado em rotas e páginas, que passam a rodar em Node.js. Mantive abaixo a explicação de como o Edge funciona, porque ela ajuda a entender as decisões de arquitetura, mas para projetos novos o caminho é o Node.js.
1. Serverless Functions: O Padrão Confiável (Node.js)
As Serverless Functions tradicionais (também conhecidas como AWS Lambda, já que a Vercel roda sobre a infraestrutura da AWS) são pequenos ambientes virtuais rodando Node.js completo.
Quando o seu usuário clica em "Finalizar Compra", a Vercel "acorda" uma Serverless Function em uma região específica (por padrão, iad1 em Washington, D.C., EUA; para rodar em São Paulo, é preciso configurar a região gru1 no projeto). Ela executa o seu código pesado de backend, salva no banco de dados e "morre" logo em seguida. Esse tipo de processamento robusto é fundamental para a Anatomia de um SaaS Escalável.
Vantagens:
- Poder Total: Você tem acesso a 100% das APIs do Node.js (
fs,crypto,child_process). - Ecossistema NPM: Qualquer pacote do NPM funciona perfeitamente aqui.
- Tempo de Execução Maior: Permite processamentos longos (como gerar relatórios PDF ou processar pagamentos pesados). No plano Pro com Fluid compute, o limite padrão é de 300 segundos, configurável até 800 segundos.
O Calcanhar de Aquiles: O Cold Start
Como a função "dorme" quando não está sendo usada, a primeira pessoa que acessar o sistema de manhã vai sofrer o chamado Cold Start (Partida Fria). A infraestrutura precisa de um tempo extra para ligar o contêiner Node.js antes de rodar o seu código. Em um SaaS B2B exigente, qualquer segundo de tela branca parece uma eternidade. (O Fluid compute ameniza bastante esse efeito, mantendo instâncias aquecidas e reaproveitadas.)
2. Edge Functions: Velocidade da Luz (V8 Runtime)
Para resolver o problema do Cold Start e da distância física, a Vercel introduziu as Edge Functions.
Ao invés de rodar em um servidor centralizado nos EUA ou em São Paulo, o seu código é distribuído para dezenas de servidores ao redor do globo (na "Borda" da rede — The Edge). Além disso, elas não rodam Node.js completo. Elas rodam sobre a V8 Engine (o mesmo motor super leve que faz o Google Chrome funcionar).
Vantagens:
- Zero Cold Start: As Edge Functions ligam em frações de milissegundo. É literalmente instantâneo.
- Proximidade Geográfica: Se um usuário em Tóquio acessar seu site, o código backend roda em Tóquio. Se for em Londres, roda em Londres. A latência de rede é quase inexistente.
- Ideal para Interceptações: Perfeitas para proxies de borda, redirecionamentos A/B testing e validação de tokens.
Limitações Críticas:
- Não é Node.js: Você não pode usar pacotes NPM que dependam de APIs nativas do Node (
fs,path). Você está limitado às Web APIs padrão (fetch,Request,Response). - Tempo de Execução Estrito: O código não pode demorar para rodar. Os limites de tempo e de CPU são bem mais apertados que no Node.js; se o seu script exceder esses limites, a Vercel corta a execução. Elas foram feitas para serem incrivelmente rápidas.
3. Resumo da Arquitetura: Quando usar o quê?
Quando o Edge era a escolha natural (lógica leve, que precisa responder rápido):
- Validação de Autenticação (JWT) e Autorização pré-renderização.
- Geolocalização e Redirecionamentos de Idioma (i18n).
- Rate Limiting (bloqueio de bots usando Redis).
Hoje essas tarefas leves ficam no proxy.ts, que roda em Node.js e executa antes de qualquer rota.
Use o padrão Serverless (Node.js) quando precisar de processamento denso:
- Conexão direta com Bancos de Dados Relacionais complexos via ORM (Prisma, TypeORM).
- Geração de PDFs ou manipulação pesada de imagens.
- Comunicação com APIs legadas que demoram para responder.
4. Mão no Código: Proxy de Autenticação
Veja como isso funciona na prática. No Next.js 16, o arquivo proxy.ts roda no runtime Node.js (o Edge Runtime não é suportado nele). Mesmo assim, ele executa antes de qualquer rota, e por isso é o lugar ideal para barrar acessos indevidos com lógica leve.
Abaixo, está um exemplo de Clean Code de um proxy que intercepta todas as requisições das rotas /dashboard. Ele verifica se o usuário possui um Token JWT válido nos cookies. O usuário malicioso é barrado logo na entrada, antes mesmo de tocar nas páginas ou no banco de dados.
// src/proxy.ts
import { NextResponse } from 'next/server';
import type { NextRequest } from 'next/server';
import { jwtVerify } from 'jose';
// Biblioteca JWT leve, baseada em Web APIs (funciona em Node.js e no Edge)
// O segredo deve estar definido nas variáveis de ambiente da Vercel
const JWT_SECRET = new TextEncoder().encode(process.env.JWT_SECRET_KEY);
export async function proxy(request: NextRequest) {
// 1. Extrair o token do cookie do usuário
const authToken = request.cookies.get('app_session')?.value;
const loginUrl = new URL('/login', request.url);
// Se não houver token, redireciona imediatamente,
// sem chegar a renderizar nenhuma página
if (!authToken) {
return NextResponse.redirect(loginUrl);
}
try {
// 2. Validar a assinatura criptográfica do Token
// Uso 'jose' por ser leve e baseada em Web APIs, o que
// mantém o código portável entre Node.js e Edge
const { payload } = await jwtVerify(authToken, JWT_SECRET);
// 3. Se o token for válido e pertencer a um Admin, injeto headers customizados
if (payload.role === 'admin') {
const response = NextResponse.next();
response.headers.set('x-user-role', 'admin');
return response;
}
// Fluxo normal permitido
return NextResponse.next();
} catch (error) {
// Token expirado, forjado ou inválido. O proxy bloqueia o
// acesso antes de consumir processamento das rotas.
console.warn('Tentativa de acesso não autorizada interceptada.');
return NextResponse.redirect(loginUrl);
}
}
// 4. Configuração de rotas para otimização extrema
// Defino exatamente quais caminhos ativam este proxy
export const config = {
matcher: ['/dashboard/:path*', '/settings/:path*'],
};
Como Forçar o Edge em Qualquer Rota ou API (até o Next.js 16.2)
Atenção: a partir do Next.js 16.3, essa opção deixou de ser suportada e as rotas rodam em Node.js. Se o seu projeto ainda usa
runtime = 'edge', remova a linha ao atualizar o Next.js.
Por padrão, todas as suas Páginas (App Router) e APIs no Next.js rodam no modo Serverless (Node.js) para garantir compatibilidade máxima com pacotes do mercado. Mas e se você criar uma API de consulta extremamente simples e quiser que ela rode na velocidade do Edge?
Você não fica refém do padrão. O Next.js te dá o poder de forçar o motor. Basta adicionar esta linha no topo de qualquer arquivo page.tsx ou route.ts:
export const runtime = 'edge';
export async function GET() {
return new Response("Essa API roda no Edge!");
}
Por que esse código é poderoso?
Se essa verificação ficasse dentro de cada página ou API, um ataque de força bruta tentando acessar /dashboard geraria uma enxurrada de renderizações e consultas ao banco de dados, possivelmente derrubando a aplicação ou gerando uma conta alta de infraestrutura.
Com o proxy, essas requisições inválidas são barradas logo na entrada, com uma lógica leve que não toca no banco, e o custo computacional fica muito baixo.
5. Escalando com Sabedoria
O ecossistema Vercel com Next.js abstrai completamente a dor de gerenciar infraestrutura, mas exige inteligência na hora de orquestrar a lógica de negócios. Ao colocar a lógica leve no proxy e a lógica pesada nas rotas em Node.js, o seu SaaS ganha a resiliência de um monolito corporativo e a agilidade de uma startup.
Precisa de apoio técnico para a sua empresa?
Se a sua operação busca especialistas para modernização de sistemas legados ou desenvolvimento de sistemas sob medida com arquitetura de alta performance (Next.js e Supabase), conheça meus serviços de tecnologia ou fale diretamente comigo pelo WhatsApp.

Albanir Neves
Especialista em Sistemas Sob Medida
Com mais de 12 anos de experiência técnica, ajudo empresas a escalar e digitalizar processos através de sistemas sob medida, automação avançada e integrações B2B com Inteligência Artificial.
Artigos Relacionados

O Caos do Estoque Desintegrado: Como Estancar as Perdas no E-commerce
Estoque desintegrado gera cancelamentos e processos. Entenda o caos do Shopify e WordPress isolados e como um Middleware especialista cura a operação.

O Padrão de UI de Elite: Tailwind CSS e shadcn/ui
Por que bani o Material-UI e CSS puro na minha arquitetura B2B em favor da performance brutal do Tailwind e a acessibilidade headless do shadcn.

Sistema para Transportadora: TMS, CT-e e Financeiro Integrados
Equipe redigitando CT-e, frete calculado na planilha e comprovante perdido? Veja como um sistema para transportadora integra operação e financeiro.