Cargo vs go build: builds de Rust e Go no CI
Cargo e go build são as ferramentas nativas de cada linguagem - a verdadeira questão no CI é o tempo de compilação e a eficiência do cache de cada um.
Cargo é a ferramenta de build e o gerenciador de pacotes do Rust, com um lockfile e um grafo de dependências rico. O go build (com go modules) compila Go rapidamente, com um modelo de dependências simples e um build cache agressivo. Esta comparação analisa o comportamento no CI dos dois ecossistemas em vez de escolher uma linguagem.
| Cargo (Rust) | go build (Go) | |
|---|---|---|
| Lockfile | Cargo.lock | go.sum + go.mod |
| Tempo de compilação típico | Maior (LLVM, monomorfização) | Rápido |
| Build cache | target/ + cache do registry | Build cache do Go (muito eficaz) |
| Builds incrementais | Sim | Sim (baseado em cache) |
| Chave de cache no CI | Hash do Cargo.lock | Hash do go.sum |
No CI
Builds de Go costumam ser rápidos, e o build cache do Go torna as compilações repetidas no CI muito baratas uma vez que estejam em cache. Compilações de Rust tendem a ser mais lentas devido ao codegen do LLVM e à monomorfização de generics, então armazenar em cache o diretório target/ do Cargo e o cache do registry importa muito - e ferramentas como o sccache podem ajudar ainda mais. Nenhuma das ferramentas é "melhor"; elas refletem o modelo de compilação de cada linguagem.
Acelerar qualquer uma
Para Rust, faça cache de ~/.cargo/registry e do target/ do projeto usando o Cargo.lock como chave, e considere o sccache para cache de compilação compartilhado. Para Go, faça cache do build cache do Go e do module cache usando o go.sum como chave. O cache é a maior alavanca de CI para ambos.
O veredito
Estas são ferramentas nativas de cada linguagem, não opções intercambiáveis: use Cargo para Rust e go build para Go. A conclusão para o CI é que Rust se beneficia mais de um build cache agressivo, enquanto Go já é rápido de saída e fica mais rápido ainda com seu build cache.