Engenharia do Caos para Go: quebrando aplicações para salvá-las

Prefácio: Por que seu serviço Go não é um porto seguro

Você escreveu o código perfeito em Go. Ele é rápido, concorrente, usa goroutines e canais. Você fez testes unitários, testes de integração, verificou a cobertura. Mas quando lançou a versão na sexta à noite, tudo desabou. Por quê? Porque na produção vive o Caos. A rede está lenta, os discos enchem, os bancos de dados caem e os microsserviços dependentes entram em timeout infinito.

Bem-vindo ao mundo real. É aqui que a Engenharia do Caos (Chaos Engineering) entra em cena — uma disciplina que nos ensina a quebrar intencionalmente o sistema para entender seus pontos fracos. Neste artigo, vamos explorar como aplicar Engenharia do Caos para aplicações Go. Você aprenderá a escrever experimentos simples, mas eficazes, sem transformar sua produção em ruínas. Pronto? Vamos lá!

O que é Engenharia do Caos e por que ela é importante para o desenvolvedor Go?

Engenharia do Caos não é apenas "quebrar e sair correndo". É uma abordagem científica para aumentar a resiliência. A ideia principal: em vez de esperar por uma falha, você a provoca em um ambiente controlado. Você formula uma hipótese ("se o banco de dados cair, o serviço retornará um erro, mas não travará"), realiza o experimento e observa o resultado.

Para Go, essa abordagem é especialmente relevante. Go foi projetado desde o início para criar sistemas confiáveis e escaláveis. Mas nem mesmo o código mais incrível salvará de problemas de rede ou da morte súbita de uma goroutine. A Engenharia do Caos ajuda a verificar como seus middlewares, lógica de retry e circuit breakers (disjuntores) funcionam em condições reais.

Ferramentas para Engenharia do Caos em Go

No mundo Go, existem várias bibliotecas e abordagens poderosas para introduzir o caos. Vamos ver as mais populares:

• gofault — uma biblioteca simples para injeção de atrasos e erros.
• chaostoolkit — um framework para orquestração de experimentos (possui drivers Go).
• Middlewares próprios — a maneira mais flexível e controlável.

Neste artigo, seguiremos o caminho de criar nosso próprio middleware. Isso lhe dará uma compreensão completa do processo e a capacidade de adaptá-lo às suas necessidades.

Prática: Criando um Chaos Middleware para um servidor HTTP em Go

Imagine que você tem um servidor HTTP simples em Go. Vamos adicionar um middleware que simulará várias falhas: atrasos, erros, pânico.

Passo 1: Estrutura básica

Vamos começar definindo a estrutura de configuração do caos:

package chaos

import (    "math/rand"    "net/http"    "time")

// Config contém as configurações para injeção de caos.type Config struct {    // Probability - probabilidade (0.0 - 1.0) de ocorrência de falha.    Probability float64    // DelayRange - intervalo de atraso em milissegundos [min, max].    DelayRange [2]int    // ErrorCode - código de status HTTP que será retornado em caso de erro.    ErrorCode int    // Panic - se true, o middleware causará pânico.    Panic bool}

// DefaultConfig retorna uma configuração padrão.func DefaultConfig() Config {    return Config{        Probability: 0.1, // 10% das requisições serão afetadas        DelayRange:  [2]int{100, 500},        ErrorCode:   http.StatusInternalServerError,        Panic:       false,    }}

Passo 2: Escrevendo o middleware

Agora vamos criar uma função que retorna o middleware. Ela decidirá aleatoriamente o que fazer com a requisição.

// Middleware retorna um HTTP middleware para injeção de caos.func Middleware(cfg Config) func(http.Handler) http.Handler {    rng := rand.New(rand.NewSource(time.Now().UnixNano()))

    return func(next http.Handler) http.Handler {        return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {            /