Serverless e Edge Computing: Por Que 70% das Empresas Estão Migrando em 2025

Olá HaWkers, uma mudança silenciosa mas profunda está acontecendo no mundo do desenvolvimento backend: 70% das empresas estão adotando arquiteturas serverless até 2025, e o Edge Computing está se tornando componente crítico de aplicações modernas.

Se você ainda está gerenciando servidores manualmente, configurando infraestrutura e lidando com escalabilidade, você está perdendo as vantagens de uma revolução que promete reduzir custos em até 70% e melhorar drasticamente a experiência do usuário.

Vamos entender o que são Serverless e Edge Computing, por que estão dominando o mercado, e como você pode aproveitar essas tecnologias na prática.

O Problema com Arquiteturas Tradicionais

No modelo tradicional, você provisiona servidores, configura load balancers, gerencia escalabilidade, monitora recursos e paga por capacidade ociosa. Mesmo quando ninguém está usando sua aplicação, você está pagando por servidores rodando 24/7.

// Arquitetura Tradicional: Express.js em servidor dedicado
const express = require('express');
const app = express();

app.get('/api/users/:id', async (req, res) => {
  const user = await db.users.findById(req.params.id);
  res.json(user);
});

// Servidor rodando 24/7, mesmo sem requisições
app.listen(3000, () => {
  console.log('Server running on port 3000');
  // Você paga por este servidor o tempo todo
  // Precisa configurar PM2, Nginx, load balancer, etc.
});

Problemas dessa abordagem:

1. Custos fixos: Paga por capacidade mesmo sem uso
2. Escalabilidade manual: Precisa provisionar mais servidores manualmente
3. Complexidade operacional: Gerenciar infraestrutura, patches, segurança
4. Latência global: Servidores centralizados distantes de usuários

Serverless: Você Só Paga Pelo Que Usa

Arquitetura serverless permite rodar código sem gerenciar servidores. Você escreve funções que são executadas sob demanda, escalam automaticamente e você só paga pelas execuções.

// Serverless Function (AWS Lambda, Vercel, Netlify)
// api/users/[id].js
export default async function handler(req, res) {
  const { id } = req.query;

  // Função executa apenas quando chamada
  const user = await db.users.findById(id);

  res.status(200).json(user);
  // Após responder, função "desliga"
  // Você só paga pelos milissegundos de execução
}

Vantagens do Serverless:

1. Custo por uso: Paga apenas pelas execuções
2. Escalabilidade automática: De 0 a milhões de requests sem configuração
3. Zero gerenciamento: Sem servidores para manter
4. Deploy simplificado: Git push e está no ar

// Exemplo real: API Serverless com TypeScript
// api/products/[id].ts
import { NextApiRequest, NextApiResponse } from 'next';
import { getProduct } from '@/lib/database';

interface Product {
  id: string;
  name: string;
  price: number;
  stock: number;
}

export default async function handler(
  req: NextApiRequest,
  res: NextApiResponse<Product | { error: string }>
) {
  const { id } = req.query;

  if (req.method !== 'GET') {
    return res.status(405).json({ error: 'Method not allowed' });
  }

  try {
    const product = await getProduct(id as string);

    if (!product) {
      return res.status(404).json({ error: 'Product not found' });
    }

    // Cache por 1 hora
    res.setHeader('Cache-Control', 's-maxage=3600, stale-while-revalidate');
    res.status(200).json(product);
  } catch (error) {
    console.error('Error fetching product:', error);
    res.status(500).json({ error: 'Internal server error' });
  }
}

Edge Computing: Processando Próximo ao Usuário

Edge Computing leva a ideia de serverless um passo além: em vez de executar funções em um data center centralizado, elas rodam em servidores distribuídos globalmente, próximos aos usuários.

O Problema da Latência:

// Cenário tradicional
// Usuário no Brasil -> Servidor nos EUA -> Banco de dados nos EUA
// Latência total: 200ms - 500ms

// Com Edge Computing
// Usuário no Brasil -> Edge no Brasil -> Cache/Processamento local
// Latência total: 10ms - 50ms

Edge Functions em Ação:

// Edge Function (Vercel Edge, Cloudflare Workers)
// middleware.ts
import { NextResponse } from 'next/server';
import type { NextRequest } from 'next/server';

export function middleware(request: NextRequest) {
  // Esta função roda no Edge, próximo ao usuário
  const country = request.geo?.country || 'US';
  const city = request.geo?.city || 'Unknown';

  // Personalização baseada em localização
  // Sem latência de servidor centralizado
  if (country === 'BR') {
    return NextResponse.redirect(new URL('/pt-br', request.url));
  }

  // A/B Testing no Edge
  const bucket = Math.random();
  const response = bucket < 0.5
    ? NextResponse.rewrite(new URL('/variant-a', request.url))
    : NextResponse.rewrite(new URL('/variant-b', request.url));

  response.cookies.set('ab-test-variant', bucket < 0.5 ? 'a' : 'b');

  return response;
}

export const config = {
  matcher: '/',
};

Cloudflare Workers: Edge Computing na Prática

Cloudflare Workers executa JavaScript em mais de 300 cidades ao redor do mundo, com latência média de 10-50ms globalmente.

// Cloudflare Worker - Edge API
addEventListener('fetch', event => {
  event.respondWith(handleRequest(event.request));
});

async function handleRequest(request) {
  const url = new URL(request.url);

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

  if (!response) {
    // Se não está em cache, busca do banco
    const data = await fetchFromDatabase(url.pathname);

    response = new Response(JSON.stringify(data), {
      headers: {
        'Content-Type': 'application/json',
        'Cache-Control': 'public, max-age=3600'
      }
    });

    // Armazena no Edge cache
    event.waitUntil(cache.put(request, response.clone()));
  }

  return response;
}

async function fetchFromDatabase(path) {
  // Conecta ao banco de dados (D1, KV, etc.)
  // Este código roda no Edge, globalmente distribuído
  const result = await DB.prepare(
    'SELECT * FROM products WHERE slug = ?'
  ).bind(path).first();

  return result;
}

Resultado: Latência global de 10-50ms vs 200-500ms de servidor tradicional centralizado.

Vercel Edge Functions: Next.js no Edge

Vercel permite rodar partes do Next.js no Edge, trazendo SSR (Server-Side Rendering) para próximo do usuário:

// app/products/[slug]/page.tsx
// Este componente pode rodar no Edge
export const runtime = 'edge';

interface Product {
  name: string;
  price: number;
  description: string;
}

export default async function ProductPage({
  params
}: {
  params: { slug: string }
}) {
  // SSR no Edge - renderiza próximo ao usuário
  const product = await fetch(
    `https://api.example.com/products/${params.slug}`,
    { next: { revalidate: 3600 } }
  ).then(res => res.json() as Promise<Product>);

  return (
    <div>
      <h1>{product.name}</h1>
      <p>${product.price}</p>
      <p>{product.description}</p>
    </div>
  );
}

Comparação: Custos Serverless vs Tradicional

Vamos comparar custos reais para uma aplicação com tráfego médio:

// Aplicação com 10 milhões de requisições/mês

// 💰 Arquitetura Tradicional (EC2, DigitalOcean, etc.)
const traditionalCosts = {
  servers: 3, // Para redundância
  costPerServer: 40, // USD/mês
  loadBalancer: 20, // USD/mês
  total: (3 * 40) + 20 // = $140/mês
};

// 💸 Serverless (AWS Lambda, Vercel, Netlify)
const serverlessCosts = {
  requests: 10_000_000,
  freeRequests: 1_000_000, // AWS Free Tier
  billableRequests: 9_000_000,
  costPer1M: 0.20, // USD
  total: (9_000_000 / 1_000_000) * 0.20 // = $1.80/mês
};

// 📊 Economia
const savings = traditionalCosts.total - serverlessCosts.total;
console.log(`Economia: $${savings}/mês`); // $138.20/mês (98.7% de redução!)

Atenção: Custos variam muito dependendo do padrão de uso, mas para aplicações com tráfego variável, serverless geralmente é muito mais econômico.

Quando Usar Serverless/Edge vs Tradicional

✅ Use Serverless/Edge quando:

• Tráfego é variável ou intermitente
• Você quer focar em código, não infraestrutura
• Precisa de escalabilidade automática
• Latência global é importante
• Quer reduzir custos operacionais

❌ Use Tradicional quando:

• Workloads são previsíveis e constantes
• Você precisa de controle total do ambiente
• Aplicação exige estado persistente em memória
• Latência de cold start é crítica
• Custos de serverless superam tradicionais (workloads muito intensos)

Desafios do Serverless e Edge

Nem tudo são flores. Serverless e Edge têm limitações:

1. Cold Start

Funções serverless que ficam inativas podem ter delay inicial (cold start):

// Cold Start: 100ms - 1s de delay na primeira execução
// Soluções:
// - Keep-alive functions (ping periódico)
// - Provisioned concurrency (AWS Lambda)
// - Edge runtime (Vercel, Cloudflare) tem cold start mínimo

2. Timeouts

Funções serverless têm limites de execução:

// AWS Lambda: 15min max
// Vercel Serverless: 10s (Hobby), 60s (Pro)
// Vercel Edge: 30s
// Cloudflare Workers: 50ms - 30s (dependendo do plano)

3. Stateless

Funções serverless são stateless — não mantêm estado entre execuções:

// ❌ NÃO funciona em serverless
let requestCount = 0;

export default function handler(req, res) {
  requestCount++; // Este contador reseta a cada execução
  res.json({ count: requestCount });
}

// ✅ Use banco de dados ou cache externo
export default async function handler(req, res) {
  const count = await redis.incr('request_count');
  res.json({ count });
}

O Futuro é Híbrido

A tendência em 2025 é arquiteturas híbridas: combinar serverless, edge e servidores tradicionais conforme a necessidade:

// Híbrido: Edge para rotas rápidas, Serverless para APIs, Tradicional para processamento pesado

// Edge: Autenticação e roteamento
// middleware.ts (Edge Runtime)
export function middleware(request: NextRequest) {
  const token = request.cookies.get('auth-token');
  if (!token) return NextResponse.redirect('/login');
  return NextResponse.next();
}

// Serverless: APIs leves
// api/users.ts (Serverless)
export default async function handler(req, res) {
  const users = await db.users.findMany();
  res.json(users);
}

// Tradicional: Jobs pesados em background
// Processamento de vídeo, ML, ETL rodam em servidores dedicados

Se você quer entender mais sobre arquiteturas modernas, recomendo ler: WebAssembly e JavaScript: A Revolução de Performance na Web onde exploramos como WASM está transformando performance de aplicações.

Bora pra cima! 🦅

📚 Quer Dominar Arquiteturas Modernas?

Este artigo cobriu Serverless e Edge Computing, mas há muito mais para aprender sobre desenvolvimento backend e arquiteturas escaláveis.

Desenvolvedores que entendem essas arquiteturas têm mais oportunidades no mercado moderno.

Material de Estudo Completo

Se você quer dominar JavaScript e arquiteturas modernas do básico ao avançado:

Opções de investimento:

• R$9,90 (pagamento único)

👉 Conhecer o Guia JavaScript

💡 Material atualizado com as melhores práticas do mercado