Como modernizar um sistema legado sem parar a operação
Um passo a passo para trocar um sistema legado peça por peça, com o negócio rodando, rollback a cada etapa e sem a aposta arriscada do big bang.
6 min de leitura
Todo sistema legado começa como o sistema que resolveu o problema. Anos depois, ele continua resolvendo, mas cobra caro: cada mudança demora, ninguém quer mexer em certas partes e o deploy vira evento. A pergunta deixa de ser se modernizar e passa a ser como fazer isso sem parar a empresa.
A resposta curta: troque o sistema aos poucos, com os dois rodando juntos, e mantenha a possibilidade de voltar atrás em cada passo. O resto deste artigo é o como.
Sinais de que o legado virou gargalo
Sistema antigo não é problema por ser antigo. Ele vira problema quando trava o negócio. Os sinais mais comuns:
- Mudanças simples levam semanas, porque ninguém sabe o que mais vai quebrar.
- O deploy é raro e tenso, feito fora do horário, com todo mundo de plantão.
- Só uma ou duas pessoas entendem partes críticas do código.
- A tecnologia saiu de suporte ou ficou difícil contratar quem trabalhe com ela.
- Integrar com parceiros ou APIs modernas é complicado, quando não impossível.
- O custo de manutenção cresce mais rápido que o valor que o sistema entrega.
Se três ou mais dessas frases descrevem o seu sistema, modernizar provavelmente custa menos do que continuar como está.
Por que reescrever tudo de uma vez costuma dar errado
A tentação é parar, reescrever do zero e virar a chave num fim de semana. É o chamado big bang, e ele falha por motivos previsíveis:
- O sistema antigo tem regras que ninguém documentou. Elas só aparecem quando o novo sistema entra em produção e algo deixa de funcionar.
- O negócio não para enquanto você reescreve. Durante meses, tudo que muda no legado precisa ser refeito no novo, e o alvo nunca para de se mover.
- A virada é tudo ou nada. Se der problema, voltar é tão arriscado quanto ir.
- O valor só aparece no final. Meses de investimento sem nada em produção.
A alternativa: trocar peça por peça
O padrão mais usado para modernizar sem parar é o strangler fig (figueira estranguladora, em referência à planta que cresce em volta de uma árvore até substituí-la). A ideia é simples:
- Coloque uma camada de roteamento na frente do sistema antigo. Pode ser um proxy, um API gateway ou o próprio front-end decidindo para onde mandar cada chamada.
- Escolha uma funcionalidade e construa a versão nova dela.
- Faça o roteamento mandar só aquela funcionalidade para o sistema novo.
- Quando ela estiver estável, desligue a versão antiga e passe para a próxima.
O sistema antigo vai encolhendo até não sobrar nada. Em nenhum momento a operação para, e cada passo pode ser desfeito trocando uma regra de roteamento.
Passo a passo na prática
1. Mapeie antes de mexer
Antes de escrever código novo, entenda o que existe: quais módulos o sistema tem, quem depende de quê, onde estão as integrações externas e quais partes mais quebram ou mais mudam. Esse mapa define a ordem da migração.
Uma boa primeira fatia costuma ser algo com valor visível e risco controlado: uma funcionalidade que o negócio quer mudar e que não está no centro de tudo.
2. Escreva testes que descrevem o comportamento atual
Antes de substituir uma parte, registre o que ela faz hoje, inclusive o que parece estranho. São os chamados testes de caracterização: em vez de testar o que o sistema deveria fazer, eles fixam o que ele faz. Quando a versão nova passar nos mesmos testes, você sabe que não quebrou nenhuma regra escondida.
3. Resolva os dados com cuidado
O código é a parte fácil. Os dados são onde a migração costuma travar. As abordagens mais comuns:
| Abordagem | Como funciona | Quando usar |
|---|---|---|
| Banco compartilhado | Novo e antigo leem e gravam no mesmo banco | Começo da migração, quando o modelo de dados ainda serve |
| Sincronização por eventos (CDC) | Cada mudança no banco antigo é replicada para o novo | Quando o novo sistema precisa de um modelo de dados próprio |
| Migração por fatia | Os dados de uma funcionalidade mudam de lugar junto com ela | Quando as fronteiras entre módulos são claras |
Evite gravar nos dois bancos a partir da aplicação ao mesmo tempo (o dual write): se uma das gravações falhar, os dados divergem e ninguém percebe até ser tarde.
4. Lance com rede de proteção
Cada fatia nova vai para produção atrás de uma feature flag ou de uma regra de roteamento que você controla. Comece com uma parte pequena do tráfego, compare os resultados com o sistema antigo e só então aumente. Se algo der errado, a volta é imediata: muda a regra, e o tráfego volta para o legado.
5. Desligue o que ficou para trás
Fatia migrada e estável, o código antigo correspondente sai. Parece óbvio, mas é a etapa mais esquecida. Código morto que continua no ar confunde quem mantém e mantém custos que a modernização deveria ter cortado.
Como medir se está funcionando
Modernização sem métrica vira projeto eterno. Acompanhe, desde a primeira fatia:
- Frequência de deploy: com que frequência vocês conseguem colocar mudança no ar.
- Tempo entre pedir e entregar uma mudança simples.
- Incidentes em produção e quanto tempo levam para ser resolvidos.
- Quanto do tráfego já passa pelo sistema novo.
Se esses números não melhoram a cada fatia, a ordem da migração ou o desenho do sistema novo precisam ser revistos.
Quando não vale a pena modernizar
Nem todo legado precisa ser trocado. Se o sistema raramente muda, não tem problema de suporte e não trava nenhuma iniciativa do negócio, o dinheiro rende mais em outro lugar. Às vezes o melhor movimento é isolar o legado atrás de uma API bem definida e construir o que é novo do lado de fora, sem tocar nele.
Resumo
- Modernize quando o legado trava o negócio, não porque ele é antigo.
- Prefira trocar peça por peça a reescrever tudo de uma vez.
- Fixe o comportamento atual com testes antes de substituir qualquer parte.
- Trate a migração de dados como o centro do projeto, não como detalhe.
- Tenha sempre um caminho de volta, em cada etapa.
- Meça desde a primeira entrega e desligue o que ficou para trás.