1~
2A computacao serverless permite executar codigo sem gerenciar servidores. Voce escreve funcoes, faz o deploy delas, e a plataforma cuida da escalabilidade, disponibilidade e infraestrutura. Em 2026, tres plataformas dominam o cenario serverless: **AWS Lambda**, **Vercel Serverless Functions** e **Cloudflare Workers**. Cada uma tem diferentes pontos fortes e compensacoes.
3~
4Neste artigo, comparamos elas com exemplos reais, consideracoes de desempenho e analises de precos.
5~
6## Como o Serverless funciona
7~
8```mermaid
9graph LR
10    User -- "HTTP Request" --> Gateway[API Gateway / Edge]
11    Gateway -- "Invoke" --> Function[Serverless Function]
12    Function -- "Response" --> User
13    Function -- "Read/Write" --> DB[(Database)]
14```
15~
16Voce faz deploy de uma funcao. Quando uma requisicao chega, a plataforma:
171. Inicia um ambiente de execucao (ou reutiliza um ja aquecido)
182. Executa sua funcao
193. Retorna a resposta
204. Escala para zero quando inativa (voce nao paga pelo tempo ocioso)
21~
22## Visao geral das plataformas
23~
24### AWS Lambda
25~
26A plataforma serverless original (lancada em 2014). A mais madura e rica em recursos, com integracao profunda no ecossistema AWS.
27~
28```javascript
29// AWS Lambda handler
30export const handler = async (event) => {
31  const body = JSON.parse(event.body);
32~
33  const result = await processData(body);
34~
35  return {
36    statusCode: 200,
37    headers: { 'Content-Type': 'application/json' },
38    body: JSON.stringify(result),
39  };
40};
41```
42~
43### Vercel Serverless Functions
44~
45Fortemente integrado com Next.js e o fluxo de trabalho de deploy frontend. As funcoes sao implantadas junto com seu frontend sem nenhuma configuracao.
46~
47```typescript
48// app/api/hello/route.ts (Next.js App Router)
49import { NextResponse } from 'next/server';
50~
51export async function GET(request: Request) {
52  const { searchParams } = new URL(request.url);
53  const name = searchParams.get('name') || 'World';
54~
55  return NextResponse.json({ message: `Hello, ${name}!` });
56}
57```
58~
59### Cloudflare Workers
60~
61Executa na rede edge da Cloudflare em mais de 300 cidades no mundo. Usa o motor V8 (o mesmo do Chrome) em vez do Node.js, o que significa cold starts extremamente rapidos.
62~
63```javascript
64// Cloudflare Worker
65export default {
66  async fetch(request, env) {
67    const url = new URL(request.url);
68    const name = url.searchParams.get('name') || 'World';
69~
70    return new Response(
71      JSON.stringify({ message: `Hello, ${name}!` }),
72      { headers: { 'Content-Type': 'application/json' } }
73    );
74  },
75};
76```
77~
78## Comparacao de recursos
79~
80| Recurso | AWS Lambda | Vercel Functions | Cloudflare Workers |
81|---------|-----------|-----------------|-------------------|
82| **Runtime** | Node.js, Python, Go, Rust, Java, .NET | Node.js, Python, Go, Ruby | V8 Isolates (JS/TS, Rust via WASM) |
83| **Tempo maximo de execucao** | 15 minutos | 60s (Hobby), 300s (Pro) | 30s (gratuito), 15min (pago) |
84| **Memoria** | 128MB - 10GB | 1024MB - 3008MB | 128MB |
85| **Cold start** | 100-500ms | 100-300ms | < 5ms |
86| **Local de deploy** | Regiao unica (ou multi com esforco) | Multiplas regioes | 300+ locais edge |
87| **Payload maximo** | 6MB (sincrono), 256KB (assincrono) | 4.5MB | 100MB |
88| **Armazenamento integrado** | Nao (use DynamoDB, S3) | Nao (use DB externo) | KV, D1 (SQLite), R2 (compativel com S3) |
89| **Modelo de precos** | Por requisicao + duracao | Incluido no plano | Por requisicao + duracao |
90| **Nivel gratuito** | 1M requisicoes/mes | 100K/mes (Hobby) | 100K requisicoes/dia |
91~
92## Cold Starts
93~
94Cold start e o tempo necessario para inicializar uma nova instancia de funcao. Esta e a maior preocupacao de desempenho com serverless.
95~
96```mermaid
97graph LR
98    subgraph "Cold Start"
99        A[Request] --> B[Provision Environment]
100        B --> C[Load Code]
101        C --> D[Initialize Runtime]
102        D --> E[Execute Function]
103    end
104~
105    subgraph "Warm Invocation"
106        F[Request] --> G[Execute Function]
107    end
108```
109~
110| Plataforma | Cold Start Tipico | Por que |
111|----------|-------------------|-----|
112| **Cloudflare Workers** | < 5ms | Isolates V8, sem necessidade de runtime completo |
113| **Vercel Functions** | 100-300ms | Runtime Node.js no edge ou regional |
114| **AWS Lambda** | 100-500ms | Inicializacao completa do container |
115| **AWS Lambda (Java)** | 1-5 segundos | Overhead de inicializacao da JVM |
116~
117Cloudflare Workers vence nos cold starts por uma margem enorme porque usa isolates V8 em vez de containers.
118~
119## Comparacao de precos
120~
121### Nivel gratuito
122~
123| Plataforma | Requisicoes gratuitas | Computacao gratuita |
124|----------|--------------|--------------|
125| **AWS Lambda** | 1M/mes | 400.000 GB-segundos |
126| **Vercel** | 100K/mes | Incluido no plano Hobby |
127| **Cloudflare Workers** | 100K/dia (~3M/mes) | 10ms CPU por invocacao |
128~
129### Em escala (10M requisicoes/mes, duracao media de 50ms)
130~
131| Plataforma | Custo mensal estimado |
132|----------|----------------------|
133| **AWS Lambda** | ~$2,50 (requisicoes) + ~$4,15 (computacao) = **~$6,65** |
134| **Vercel** | **$20/mes** (plano Pro, inclui funcoes) |
135| **Cloudflare Workers** | **$5/mes** (plano pago, inclui 10M requisicoes) |
136~
137Para a maioria dos casos de uso, Cloudflare Workers e o mais barato. O preco da Vercel e simples mas inclui a plataforma inteira (hospedagem, CDN, analytics). AWS Lambda tem o preco mais granular.
138~
139## Casos de uso reais
140~
141### AWS Lambda: Melhor para
142~
143- **Workflows backend complexos** - step functions, arquiteturas orientadas a eventos
144- **Integracao com servicos AWS** - triggers S3, streams DynamoDB, filas SQS
145- **Tarefas de longa duracao** - ate 15 minutos de tempo de execucao
146- **Equipes multi-linguagem** - suporta a mais ampla gama de runtimes
147~
148```mermaid
149graph TD
150    S3[S3 Upload] --> Lambda1[Process Image]
151    Lambda1 --> SQS[SQS Queue]
152    SQS --> Lambda2[Generate Thumbnails]
153    Lambda2 --> DDB[DynamoDB]
154    DDB --> Lambda3[Send Notification]
155    Lambda3 --> SNS[SNS / Email]
156```
157~
158### Vercel Functions: Melhor para
159~
160- **Aplicacoes Next.js** - rotas de API sem configuracao
161- **Equipes focadas no frontend** - deploy de frontend e backend juntos
162- **Prototipagem rapida** - git push para deploy
163- **Arquiteturas Jamstack** - frontend estatico + API serverless
164~
165```typescript
166// app/api/subscribe/route.ts
167import { NextResponse } from 'next/server';
168~
169export async function POST(request: Request) {
170  const { email } = await request.json();
171~
172  // Validate
173  if (!email || !email.includes('@')) {
174    return NextResponse.json(
175      { error: 'Invalid email' },
176      { status: 400 }
177    );
178  }
179~
180  // Save to database
181  await db.subscribers.create({ email });
182~
183  return NextResponse.json({ success: true });
184}
185```
186~
187### Cloudflare Workers: Melhor para
188~
189- **APIs de baixa latencia** - codigo executa em mais de 300 locais no mundo
190- **Edge computing** - transformar respostas, testes A/B, personalizacao
191- **APIs de alto volume** - mais barato em escala com generoso nivel gratuito
192- **Aplicacoes globais** - dados perto dos usuarios com KV e D1
193~
194```javascript
195// Edge-side A/B test
196export default {
197  async fetch(request, env) {
198    const url = new URL(request.url);
199~
200    // Assign user to variant
201    const cookie = request.headers.get('Cookie') || '';
202    let variant = cookie.includes('ab=b') ? 'b' : 'a';
203~
204    if (!cookie.includes('ab=')) {
205      variant = Math.random() < 0.5 ? 'a' : 'b';
206    }
207~
208    // Fetch the appropriate version
209    const response = await fetch(`${url.origin}/variants/${variant}`);
210    const newResponse = new Response(response.body, response);
211~
212    // Set cookie for consistent experience
213    newResponse.headers.set('Set-Cookie', `ab=${variant}; Path=/; Max-Age=86400`);
214~
215    return newResponse;
216  },
217};
218```
219~
220## Quando escolher qual
221~
222### Escolha AWS Lambda se:
223- Voce ja esta investido no ecossistema AWS
224- Precisa de funcoes de longa duracao (ate 15 minutos)
225- Precisa de arquiteturas complexas orientadas a eventos
226- Precisa de runtimes alem de JavaScript (Python, Go, Rust, Java)
227~
228### Escolha Vercel Functions se:
229- Esta construindo com Next.js ou um framework frontend
230- Quer a experiencia de deploy mais simples (git push)
231- Sua equipe e focada em frontend
232- Quer hospedagem + funcoes + CDN em uma plataforma
233~
234### Escolha Cloudflare Workers se:
235- Precisa da menor latencia possivel globalmente
236- Quer a opcao mais barata em escala
237- Precisa de capacidades de edge computing
238- O tempo de cold start e critico para seu caso de uso
239~
240## Pode combina-los?
241~
242Com certeza. Uma arquitetura comum:
243~
244```mermaid
245graph TD
246    User --> CF[Cloudflare Workers\nEdge caching, routing, A/B tests]
247    CF --> Vercel[Vercel\nNext.js frontend + API routes]
248    Vercel --> Lambda[AWS Lambda\nHeavy processing, background jobs]
249    Lambda --> S3[S3 Storage]
250    Lambda --> DB[(Database)]
251```
252~
253- **Cloudflare Workers**: roteamento edge, cache, seguranca
254- **Vercel Functions**: rotas de API frontend, SSR
255- **AWS Lambda**: processamento backend pesado, tarefas agendadas, pipelines de eventos
256~
257## Conclusao
258~
259O serverless amadureceu significativamente. Em 2026, a escolha entre AWS Lambda, Vercel Functions e Cloudflare Workers depende do seu stack e suas prioridades:
260~
261- **Experiencia de desenvolvedor mais simples**: Vercel
262- **Mais poderoso e flexivel**: AWS Lambda
263- **Melhor desempenho e precos**: Cloudflare Workers
264~
265Todos os tres estao prontos para producao e testados em batalha. Comece com o que se encaixa no seu stack atual e expanda conforme suas necessidades crescem.
266~