conta de infraestrutura
Corte a conta da nuvem: os serviços mais pesados reescritos em Go e Rust
Os seus serviços em Java e Python comem memória e máquinas que ninguém teve tempo de questionar. Engenheiros com mais de 25 anos de produção reescrevem os caminhos quentes em Go ou Rust em 30 dias, e a próxima fatura mostra a diferença.
Em 48 horas: uma primeira estimativa de economia a partir da sua conta atual, um preço fechado e uma data de início.
Uma frota de JVMs dimensionada para o pico de memória e um batch noturno que roda até o turno da manhã chegar.
- Java servicesJVM heap per pod
- Python workersmany instances
- autoscalingpinned at max
- idle capacitypaid for
30 dias do primeiro profile à última virada
Os mesmos serviços em Go e Rust, com uma fração da memória e menos máquinas. O batch leva minutos.
- Go servicessmall footprint
- Rust hot pathbatch in minutes
- clusterright-sized
- billmeasured before · after
Como a conta cai
- 01dias 1–3
Medir a conta
Custo por serviço, perfis de memória e CPU sob carga real e a duração de cada janela de batch. A partir disso escolhemos os serviços que mais custam e escrevemos no orçamento a economia que esperamos.
- 02dias 2–6
Gravar o tráfego
Capturamos requisições e respostas de produção na fronteira do serviço. Essa gravação vira o teste que cada serviço reescrito precisa passar antes de receber uma única requisição real.
- 03dias 5–24
Reescrever os caminhos quentes
A plataforma faz a primeira tradução para Go ou Rust, e os nossos engenheiros reescrevem pensando em memória, concorrência e tempo de inicialização. Cada serviço é reexecutado contra o seu tráfego até as saídas baterem.
- 04dias 22–30
Virar e encolher
O tráfego muda serviço por serviço, depois as instâncias antigas são desligadas e o cluster é redimensionado. Medimos a conta de novo e colocamos os dois números lado a lado para o seu time financeiro.
O que a plataforma faz e o que os nossos engenheiros fazem
Ler cada serviço e o grafo de chamadas dele
Plataforma
Java, Kotlin, Python, Node e C#, cada framework da árvore e a configuração que alguém definiu anos atrás.
Perfilar memória, CPU e inicialização
Os dois
A plataforma coleta os perfis sob carga real. Um engenheiro lê e acha para onde vai o dinheiro.
Primeira tradução para Go ou Rust
Plataforma
Saída da máquina, revisada como pull request como qualquer outro código em que o seu time faria merge.
Reescrever pensando em memória e concorrência
Engenheiro
Goroutines no lugar de pools de threads, streaming no lugar de carregar tudo no heap, Rust onde cada byte conta.
Paridade contra o tráfego gravado
Os dois
Captura e reexecução são nossas. O seu lado assina qualquer diferença que a gente encontrar.
Redimensionar o cluster depois da virada
Engenheiro
Menos instâncias e menores, e os limites de autoscaling ajustados ao que o código novo de fato usa.
Cada serviço reescrito passa pela bancada de paridade antes de receber tráfego real. Os seus usuários recebem as mesmas respostas mais rápido, e você paga por menos hardware.
Quem reescreve os seus serviços
Os nossos engenheiros colocam código em produção há mais de 25 anos, e são os melhores que você pode pôr num serviço que custa caro demais para rodar. Eles já ajustaram JVMs, brigaram com o GIL do Python e caçaram vazamentos de memória em Node em produção, e depois reescreveram esses mesmos serviços em Go e Rust. A plataforma faz a leitura e a primeira tradução. Os nossos engenheiros decidem para onde vai a memória.
A estimativa de economia tem preço antes de começarmos. Cada fase tem preço fechado e data no contrato, e só conta como concluída quando passa na paridade com o seu tráfego. O código é seu desde o primeiro commit.
Perguntas que os CTOs fazem sobre a conta
Quanto vamos economizar de fato?
Você vê uma primeira estimativa em até 48 horas depois de mandar a conta e a lista de serviços. Até o dia 3 já perfilamos os serviços sob carga real, e a estimativa fica por serviço, com os números por trás. Depois da virada medimos de novo e colocamos as duas contas lado a lado. Peça o orçamento hoje e o primeiro número é seu no dia 2.
Por que reescrever se dá para ajustar a JVM?
O ajuste ajuda até certo ponto, e depois cada instância continua carregando o runtime, o garbage collector e o custo de inicialização. Um serviço em Go ou Rust elimina essa sobrecarga e roda com uma fração da memória. Onde o ajuste basta, o orçamento diz isso, serviço por serviço. Peça agora e veja quais dos seus valem a reescrita.
Os serviços novos vão se comportar exatamente como os antigos?
Sim. Gravamos o seu tráfego de produção e reexecutamos contra as duas versões. Um serviço só recebe tráfego real quando as saídas batem, casos extremos e arredondamentos estranhos incluídos, e o seu time assina cada diferença que a gente encontrar. Comece pelo seu serviço mais caro e veja ele passar.
O nosso time escreve Java. Quem mantém o código em Go?
O seu time. Go é uma linguagem pequena, e um engenheiro Java lê Go em poucos dias. Cada serviço chega com testes e runbooks, os seus engenheiros revisam cada um antes da virada, e os nossos ficam de plantão nos primeiros dias em produção. Coloque hoje a data de entrega no contrato.
Tem downtime na virada?
O tráfego muda serviço por serviço por uma camada de roteamento, e as instâncias antigas continuam rodando até as novas carregarem carga real. O rollback é uma chave combinada antes. Os seus usuários veem respostas mais rápidas. Peça o orçamento e escolha hoje o primeiro serviço.
Traga a conta para nós
Encaminhe a última fatura da nuvem e a lista de serviços hoje. Em 48 horas você tem uma estimativa de economia, um preço fechado e uma data de início. Em 30 dias os seus serviços mais pesados rodam em Go ou Rust em menos máquinas, e a próxima fatura prova isso.
Um engenheiro com mais de 25 anos em produção lê e responde. O NDA é assinado antes de você compartilhar qualquer coisa.