Arquitetura orientada a eventos e design sem estado

Quando trabalho com serverless, a eficiência começa no desenho da arquitetura. Funções devem ser simples, com comportamento previsível e sem depender de estado entre invocações. Isso facilita escalabilidade, reduz complexidade de recuperação e diminui latência em caminhos críticos.

• Adote fluxos de eventos bem definidos com enfileiramento para desacoplar produtores e consumidores.
• Projete funções como unidades puras: entradas determinísticas, saída clara, sem dependência de memória global entre invocações.
• Implemente idempotência para evitar efeitos adversos em retries ou duplicação de mensagens.
• Reduza o tamanho do payload que passa pela função para diminuir o tempo de deserialização e a transferência.

Configuração de recursos, limites e custo

Configurar recursos de forma consciente impacta diretamente a performance. Ajustes locais podem valer mais do que alterações estruturais, especialmente em caminhos com latência sensível.

• Memória alocada: maior memória geralmente traz mais CPU disponível. Teste distintas capacidades para reduzir o tempo de cold start e o tempo de resposta em picos.
• Timeout adequado: erro por timeout aumenta latência total; mantenha um tempo suficiente para operações esperadas, mas sem estender desnecessariamente.
• Concurrência: utilize limites de concorrência para evitar saturação de downstream e para manter níveis de serviço estáveis.
• Construção e empacotamento: minimize dependências, remova código morto e aspire por bundles enxutos. Bundlers modernos ajudam a eliminar código não utilizado.
• Conexões de bancos/datasources: reutilize conexões entre invocações quando possível (variável global) para reduzir o custo de conexões repetidas.

Prática: reutilização de conexões de banco de dados entre invocações

Um padrão simples, comum em ambientes serverless com Node.js, é manter uma conexão de banco de dados reutilizável em uma variável global. Isso reduz o overhead de criação de conexão em invocações consecutivas, sem exigir estado entre execuções, mantendo a função mais rápida em cenários quentes.

// Exemplo com PostgreSQL usando pg
const { Client } = require('pg');
let cachedClient;

async function getDbClient() {
  if (cachedClient) {
    return cachedClient;
  }
  const client = new Client({ connectionString: process.env.DB_URL });
  await client.connect();
  cachedClient = client;
  return client;
}

exports.handler = async (event) => {
  try {
    const client = await getDbClient();
    const res = await client.query('SELECT 1 AS ok');
    return {
      statusCode: 200,
      body: JSON.stringify({ ok: true, result: res.rows[0] }),
    };
  } catch (err) {
    return {
      statusCode: 500,
      body: JSON.stringify({ ok: false, error: err.message }),
    };
  }
};

Observabilidade, métricas e resiliência

Monitorar o desempenho é essencial para identificar gargalos reais. Estruture logs de forma semântica, colete métricas de latência, throughput e taxa de erro, e use traços para entender o caminho das requisições.

• Defina SLOs simples e mensuráveis (ex.: p95 de tempo de resposta)
• Log semântico: inclua identificadores de requisição, usuário (anonimizado), endpoint e status
• Metricas-chave: latência de ponta a ponta, latência de serviço, throughput e erro por endpoint
• Tratamento de falhas: retries com backoff discreto, circuit breakers básicos e fallback apropriado