Serverless em 2025: Como Arquitetura Moderna Reduz Custos em 70% e Escala Automaticamente

Olá HaWkers, você ainda está pagando por servidores que ficam 80% ociosos ou lutando com configuração de infraestrutura ao invés de escrever código?

Em 2025, arquitetura serverless se consolidou como padrão para aplicações modernas. Empresas estão reduzindo custos de infraestrutura em até 70%, eliminando preocupações com escalabilidade e focando no que realmente importa: resolver problemas de negócio.

AWS Lambda, Vercel Functions, Cloudflare Workers e outros já processam trilhões de requisições mensalmente. E o melhor: você só paga pelo que usa, não por servidores ociosos.

O Que É Serverless e Por Que Importa em 2025?

Serverless NÃO significa "sem servidores". Significa que você não gerencia servidores – a plataforma cuida disso por você.

Modelo Tradicional vs. Serverless

// TRADICIONAL: Servidor rodando 24/7
// Custos: $50-200/mês por servidor, independente de uso
// Escalabilidade: Manual (você configura load balancers, auto-scaling)
// Manutenção: Patches, updates, monitoring = seu problema

const express = require('express');
const app = express();

app.get('/api/users', async (req, res) => {
  const users = await db.query('SELECT * FROM users');
  res.json(users);
});

app.listen(3000); // Servidor rodando 24/7, mesmo com zero requests

// SERVERLESS: Função executada sob demanda
// Custos: ~$0.20 por 1 milhão de execuções (!)
// Escalabilidade: Automática (1 request ou 1 milhão)
// Manutenção: Zero

export default async function handler(req, res) {
  const users = await db.query('SELECT * FROM users');
  return res.json(users);
}

// Executado apenas quando há request
// Escala automaticamente de 0 a milhões de instâncias
// Você paga apenas por execuções reais

Vantagens Serverless:

✅ Custo: Pague apenas por uso real (não por capacidade ociosa)
✅ Escala: Automática, de zero a milhões de requests
✅ Produtividade: Foco em código, não em infraestrutura
✅ Latência: Edge functions próximas ao usuário
✅ Manutenção: Plataforma cuida de patches, segurança, updates

Principais Plataformas Serverless em 2025

1. Vercel Edge Functions

Ideal para Next.js e frontend-heavy apps:

// app/api/hello/route.ts (Next.js 14+)
export const runtime = 'edge'; // Roda em edge locations globalmente

export async function GET(request: Request) {
  const { searchParams } = new URL(request.url);
  const name = searchParams.get('name') || 'World';

  return new Response(`Hello ${name}!`, {
    headers: {
      'content-type': 'text/plain',
      'cache-control': 'public, max-age=3600'
    }
  });
}

// Deploy: git push
// Escala: Automática
// Latência: <50ms (edge global)
// Custo: 100GB grátis/mês, depois $20/100GB

2. AWS Lambda

Mais maduro, máxima flexibilidade:

// lambda/processImage.js
import { S3 } from '@aws-sdk/client-s3';
import sharp from 'sharp';

export const handler = async (event) => {
  const s3 = new S3();

  // Triggered quando imagem é enviada para S3
  const bucket = event.Records[0].s3.bucket.name;
  const key = event.Records[0].s3.object.key;

  // Baixa imagem
  const image = await s3.getObject({ Bucket: bucket, Key: key });

  // Processa (resize, optimize)
  const resized = await sharp(image.Body)
    .resize(800, 600)
    .webp({ quality: 80 })
    .toBuffer();

  // Salva versão otimizada
  await s3.putObject({
    Bucket: `${bucket}-optimized`,
    Key: key.replace(/\.\w+$/, '.webp'),
    Body: resized
  });

  return { statusCode: 200, body: 'Image processed' };
};

// Custo: $0.20 por 1M requests + $0.00001667 por GB-segundo
// Limite: 15 min de execução, 10GB RAM

3. Cloudflare Workers

Ultra-rápido, edge-native:

// worker.js - Roda em 300+ data centers globalmente
export default {
  async fetch(request, env) {
    const url = new URL(request.url);

    // Redireciona www → apex domain
    if (url.hostname.startsWith('www.')) {
      url.hostname = url.hostname.replace('www.', '');
      return Response.redirect(url, 301);
    }

    // Cache inteligente
    const cache = caches.default;
    let response = await cache.match(request);

    if (!response) {
      response = await fetch(request);

      // Cacheia por 1 hora
      response = new Response(response.body, response);
      response.headers.set('Cache-Control', 'max-age=3600');
      await cache.put(request, response.clone());
    }

    return response;
  }
};

// Custo: 100k requests/dia GRÁTIS, depois $0.50 por 1M
// Latência: ~10ms média global
// Cold start: ~0ms (sempre warm!)

Casos de Uso Reais e Economia

Case 1: API Backend

Antes (tradicional):

2 servidores EC2 (redundância): $100/mês
Load Balancer: $20/mês
Tráfego: 5M requests/mês
Total: $120/mês

Depois (Lambda):

5M requests × $0.20/1M = $1
Compute (avg 200ms, 512MB): ~$5
Total: $6/mês 💰 (95% economia!)

Case 2: Processamento de Imagens

// Serverless function para otimizar imagens on-the-fly
export default async function handler(req, res) {
  const { url, width, quality } = req.query;

  // Verifica cache
  const cached = await redis.get(`img:${url}:${width}`);
  if (cached) return res.send(Buffer.from(cached, 'base64'));

  // Baixa e processa
  const response = await fetch(url);
  const buffer = await response.arrayBuffer();

  const optimized = await sharp(buffer)
    .resize(parseInt(width))
    .webp({ quality: parseInt(quality) || 80 })
    .toBuffer();

  // Cacheia
  await redis.set(`img:${url}:${width}`, optimized.toString('base64'), 'EX', 3600);

  res.setHeader('Content-Type', 'image/webp');
  res.send(optimized);
}

// Uso: /api/optimize?url=...&width=800
// Escala automaticamente com tráfego
// Primeiro acesso: ~500ms (processa)
// Próximos: <50ms (cache)

Antes:

Servidor dedicado para processamento: $80/mês
Armazenamento de todas variações: $30/mês
Total: $110/mês

Depois:

Lambda: ~$3/mês (on-demand)
Cache Redis: $10/mês
Total: $13/mês (88% economia!)

Padrões de Arquitetura Serverless

1. API Gateway + Lambda

// Estrutura típica de API serverless
export const routes = {
  // GET /api/users
  'GET /api/users': async () => {
    const users = await db.users.findMany();
    return { status: 200, body: users };
  },

  // POST /api/users
  'POST /api/users': async (event) => {
    const data = JSON.parse(event.body);

    // Validação com Zod
    const validated = UserSchema.parse(data);

    const user = await db.users.create({ data: validated });
    return { status: 201, body: user };
  },

  // GET /api/users/:id
  'GET /api/users/:id': async (event) => {
    const { id } = event.pathParameters;
    const user = await db.users.findUnique({ where: { id } });

    if (!user) {
      return { status: 404, body: { error: 'User not found' } };
    }

    return { status: 200, body: user };
  }
};

// Framework tRPC serverless
import { initTRPC } from '@trpc/server';
import { awsLambdaRequestHandler } from '@trpc/server/adapters/aws-lambda';

const t = initTRPC.create();

const appRouter = t.router({
  userList: t.procedure.query(() => db.users.findMany()),
  userById: t.procedure.input(z.number()).query(({ input }) =>
    db.users.findUnique({ where: { id: input } })
  )
});

export const handler = awsLambdaRequestHandler({
  router: appRouter
});

2. Event-Driven Architecture

// Fluxo serverless event-driven
// 1. Upload de arquivo → S3
// 2. S3 trigger → Lambda (processa)
// 3. Lambda → SQS (fila de trabalho)
// 4. SQS → Lambda (workers paralelos)
// 5. Resultado → DynamoDB + SNS (notifica usuário)

// lambda/onFileUpload.js
export const handler = async (event) => {
  const file = event.Records[0].s3.object.key;

  // Envia para fila de processamento
  await sqs.sendMessage({
    QueueUrl: process.env.PROCESS_QUEUE_URL,
    MessageBody: JSON.stringify({
      file,
      timestamp: Date.now()
    })
  });

  return { statusCode: 200 };
};

// lambda/processWorker.js
export const handler = async (event) => {
  const { file } = JSON.parse(event.Records[0].body);

  // Processa arquivo (pode levar minutos)
  const result = await heavyProcessing(file);

  // Salva resultado
  await dynamodb.put({
    TableName: 'results',
    Item: { id: file, result, processedAt: Date.now() }
  });

  // Notifica usuário
  await sns.publish({
    TopicArn: process.env.NOTIFICATION_TOPIC,
    Message: `Arquivo ${file} processado!`
  });
};

3. Edge Computing com Middleware

// middleware.ts - Vercel/Next.js edge middleware
import { NextRequest, NextResponse } from 'next/server';

export function middleware(request: NextRequest) {
  // Geolocation
  const country = request.geo?.country || 'US';

  // A/B testing (50/50 split)
  const bucket = Math.random() > 0.5 ? 'A' : 'B';

  // Rate limiting (Redis no edge)
  const ip = request.ip || 'unknown';
  const rateKey = `rate:${ip}`;

  // Authentication check
  const token = request.cookies.get('auth-token');
  if (!token && request.nextUrl.pathname.startsWith('/dashboard')) {
    return NextResponse.redirect(new URL('/login', request.url));
  }

  // Rewrite baseado em país
  if (country === 'BR') {
    return NextResponse.rewrite(new URL('/pt-br' + request.nextUrl.pathname, request.url));
  }

  // Headers de segurança
  const response = NextResponse.next();
  response.headers.set('X-Frame-Options', 'DENY');
  response.headers.set('X-Content-Type-Options', 'nosniff');
  response.headers.set('X-AB-Bucket', bucket);

  return response;
}

// Roda globalmente em edge, <10ms latência

Desafios e Como Resolver

1. Cold Starts

Problema: Primeira execução após inatividade pode demorar.

Soluções:

// ✅ Mantenha funções warm com scheduled pings
export const warmer = async () => {
  // Executa a cada 5 minutos
  await fetch(process.env.FUNCTION_URL);
};

// ✅ Use Provisioned Concurrency (AWS)
// ✅ Prefira runtime rápido (Node.js > Python > JVM)
// ✅ Minimize dependencies no bundle

2. Custos Inesperados

Problema: Loops infinitos ou DDoS podem gerar custos altos.