icardb
Serverless: quando funções serverless valem a pena (e quando viram armadilha)
Voltar para artigosPROGRAMAÇÃO

Serverless: quando funções serverless valem a pena (e quando viram armadilha)

Por Lucas Mendes 7 min de leitura

Serverless não significa 'sem servidor' — significa que você não gerencia o servidor: o provedor provisiona, escala e cobra por execução. Esse modelo muda a economia e a arquitetura de uma aplicação de formas que nem sempre são óbvias. Este artigo compara as principais plataformas, destrincha o modelo de custo e define com clareza onde serverless é a melhor escolha e onde vira armadilha cara.

O modelo mental: pague por uso, escale a zero

Em um servidor tradicional (VPS, container 24/7), você paga pela capacidade provisionada — esteja ela em 2% ou 90% de uso. Em serverless, a unidade de cobrança é a execução: milissegundos de CPU × memória alocada. Tráfego zero custa (quase) zero. Picos de 10.000 requisições simultâneas escalam sem intervenção. A contrapartida: cada execução é efêmera, stateless e com limites rígidos de tempo e memória.

Comparativo das plataformas (2026)

PlataformaRuntimeCold start típicoLimite de execuçãoPonto forte
AWS LambdaNode, Python, Go, Java, Rust, custom100–500 ms (Node/Python); 1–10 s (Java/.NET)15 minIntegração com todo o ecossistema AWS
Cloudflare WorkersV8 isolates (JS/TS, WASM)~0 ms (sem cold start clássico)Ilimitado no plano pago (CPU time limitado)Latência na borda, em 300+ cidades
Vercel FunctionsNode, Edge runtimeBaixo; varia por regiãoAté 800 s (Fluid compute)DX integrada a Next.js
GCP Cloud Run FunctionsContainers ou runtimes gerenciadosDepende da imagem60 min (Cloud Run)Modelo de container com escala a zero

Cloudflare Workers usam V8 isolates em vez de containers: o 'processo' já está quente e o isolate inicializa em microssegundos. É por isso que o cold start praticamente não existe — mas o runtime não é Node completo (sem fs real, sem TCP arbitrário); é um subconjunto Web-standard com compatibilidade Node opcional.

A matemática do custo: quando serverless é mais barato

Serverless vence financeiramente quando a utilização média de um servidor dedicado seria baixa ou muito variável. Exemplo com números de 2026: uma API com 5 milhões de requisições/mês, 100 ms cada, 256 MB — no free tier + preço sob demanda da Lambda, sai por poucos dólares. Um container equivalente 24/7 custa de 10 a 50x isso. Inverta o cenário — 200 milhões de requisições/mês com carga constante — e o servidor dedicado passa a custar uma fração do serverless.

Perfil de cargaEscolha econômicaPor quê
Esporádica / picos imprevisíveisServerlessEscala a zero; paga só os picos reais
Carga constante e previsívelContainer/VPS dedicadoCapacidade reservada é mais barata que milissegundos sob demanda
Jobs longos (>15 min)Fila + worker dedicadoLimites de execução tornam funções inadequadas
WebSockets / conexões persistentesServidor tradicional ou serviço gerenciado específicoFunções são efêmeras e request-response

Exemplo: uma função serverless real

ts
// Cloudflare Worker: resize de imagem na borda, com cache
export default {
  async fetch(request: Request, env: Env, ctx: ExecutionContext) {
    const url = new URL(request.url);

    // cache na borda: respostas repetidas nem executam a função de novo
    const cache = caches.default;
    const cached = await cache.match(request);
    if (cached) return cached;

    const largura = parseInt(url.searchParams.get("w") ?? "800", 10);
    if (largura > 2000) return new Response("largura máxima: 2000", { status: 400 });

    const origem = await fetch(`https://cdn.exemplo.com${url.pathname}`);
    if (!origem.ok) return new Response("não encontrado", { status: 404 });

    const resposta = new Response(origem.body, {
      headers: { "content-type": "image/jpeg", "cache-control": "public, max-age=86400" },
    });
    ctx.waitUntil(cache.put(request, resposta.clone()));
    return resposta;
  },
};

Onde serverless vira armadilha

  • Carga alta e constante: o custo por execução supera — e muito — o custo de capacidade dedicada. Várias empresas documentaram reduções de 60–90% na conta ao repatriar workloads quentes para containers.
  • Estado e conexões persistentes: WebSockets, SSE de longa duração e sessões em memória não cabem no modelo efêmero.
  • Cold start em cadeia: função A chamando função B chamando função C multiplica latências de inicialização.
  • Lock-in operacional: triggers, filas, IAM e observabilidade são específicos do provedor; a 'portabilidade' do código é a parte fácil.
  • Debugging distribuído: sem tracing estruturado desde o dia 1, investigar falha em 40 funções é sofrimento garantido.

Onde serverless brilha

  • APIs e backends de produtos em estágio inicial: custo quase zero até ter tração real.
  • Webhooks e eventos esporádicos: pagamentos, integrações, notificações.
  • Processamento disparado por evento: thumbnail ao subir imagem, ETL ao cair arquivo no storage.
  • Lógica na borda: redirects, A/B, geolocalização, autenticação de requisição antes da origem.
  • Tarefas agendadas de baixa frequência: relatórios, limpezas, sincronizações.

Conclusão

Serverless é uma decisão econômica e operacional, não ideológica. Para cargas irregulares, produtos novos e lógica de borda, é difícil competir: zero servidores para gerenciar e conta proporcional ao uso real. Para carga constante e alta, workloads stateful ou jobs longos, containers dedicados são mais baratos e mais simples de operar. Times maduros misturam os dois — e revisam a divisão conforme o perfil de tráfego muda.

Perguntas frequentes

+Cold start ainda é um problema relevante em 2026?

Depende do runtime. Em Cloudflare Workers (V8 isolates), é praticamente inexistente. Em Lambda com Node/Python, 100–500 ms em inicializações frias — imperceptível para APIs comuns, relevante para latência crítica. Java e .NET ainda pagam segundos sem SnapStart/provisioned concurrency.

+Serverless elimina a necessidade de DevOps?

Elimina a administração de servidores, não a disciplina operacional. IAM, observabilidade, limites de concorrência, retries de eventos e gestão de custos continuam exigindo competência — apenas em uma camada diferente.

+Como evitar lock-in em serverless?

Mantenha a lógica de negócio em módulos puros, isolados dos handlers do provedor; prefira padrões Web (fetch, Request/Response) onde possível; e trate triggers e filas como adaptadores. A portabilidade real, porém, é limitada — aceite isso na decisão.

+Posso rodar um banco de dados dentro de uma função serverless?

Não — funções são efêmeras e stateless. O padrão é banco gerenciado acessado por conexão HTTP ou pooling externo (ex.: conexões serverless-friendly, proxies de pool como PgBouncer gerenciado), já que milhares de execuções simultâneas esgotam conexões TCP diretas.

Fontes consultadas

Revisão editorial: publicado em . Última revisão em . Conteúdo educativo, sem patrocínio das ferramentas citadas.

Crédito da imagem: Foto: Lucas Mendes / Gerado por IA (Licença Editorial)

Leia também