Instalando Rust com rustup e conhecendo o cargo

1. O que é o rustup e por que usá-lo

O rustup é o instalador oficial e gerenciador de versões da linguagem Rust. Diferente de instalar pacotes manuais ou binários pré-compilados, o rustup oferece uma experiência unificada e multiplataforma para gerenciar toolchains do Rust.

Vantagens do rustup:
- Instalação multiplataforma: funciona em Linux, macOS e Windows
- Atualizações simplificadas: um único comando para atualizar o Rust inteiro
- Gerenciamento de toolchains: instale e alterne entre versões stable, beta e nightly
- Componentes opcionais: adicione documentação offline, analisadores de código e muito mais

Usar pacotes do sistema (como apt install rustc) geralmente oferece versões desatualizadas. O rustup garante acesso imediato às versões mais recentes do Rust.

2. Instalando o Rust com rustup

No Linux/macOS

Abra o terminal e execute:

curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh

Siga as instruções na tela. Normalmente, escolha a opção padrão (1) para instalação completa.

Após a instalação, recarregue o shell:

source "$HOME/.cargo/env"

No Windows

Baixe o executável rustup-init.exe do site oficial (https://rustup.rs) e execute-o. Siga o assistente de instalação.

Verificando a instalação

Confirme que tudo funcionou:

rustc --version
rustup --version

Exemplo de saída esperada:

rustc 1.75.0 (82e1608df 2023-12-21)
rustup 1.26.0 (5af9b9484 2023-04-05)

3. Entendendo as toolchains do Rust

Toolchains são conjuntos completos de ferramentas do Rust (compilador, bibliotecas padrão, etc.) organizados em canais de lançamento:

  • stable: versão estável recomendada para produção
  • beta: versão de teste para a próxima stable
  • nightly: versão diária com funcionalidades experimentais

Alternando entre toolchains

# Ver toolchain padrão atual
rustup default

# Mudar para nightly
rustup default nightly

# Voltar para stable
rustup default stable

Gerenciando toolchains

# Instalar toolchain específica
rustup toolchain install nightly

# Remover toolchain
rustup toolchain remove beta

# Listar toolchains instaladas
rustup toolchain list

4. Mantendo o Rust atualizado

Atualizando o Rust

# Atualiza todas as toolchains instaladas
rustup update

Verificando o estado atual

rustup show

Este comando exibe:
- Toolchain padrão ativa
- Toolchains instaladas
- Versão do Rust em cada toolchain
- Componentes instalados

Removendo completamente o Rust

rustup self uninstall

Isso remove o rustup, todas as toolchains e configurações associadas.

5. Introdução ao Cargo: o gerenciador de pacotes e build system

O Cargo é o sistema de build e gerenciador de pacotes oficial do Rust. Ele acompanha o rustup e já vem instalado por padrão.

Comandos essenciais do Cargo

Criando um novo projeto:

cargo new meu_projeto
cd meu_projeto

Estrutura gerada:

meu_projeto/
├── Cargo.toml
└── src/
    └── main.rs

Conteúdo do Cargo.toml:

[package]
name = "meu_projeto"
version = "0.1.0"
edition = "2021"

[dependencies]

Conteúdo do src/main.rs:

fn main() {
    println!("Hello, world!");
}

Compilando e executando:

# Compila o projeto
cargo build

# Compila e executa
cargo run

# Verifica se o código compila sem gerar binário
cargo check

6. Gerenciando dependências com Cargo

Adicionando dependências manualmente

Edite o arquivo Cargo.toml e adicione:

[dependencies]
serde = "1.0"
rand = "0.8"

Usando cargo add (recurso moderno)

cargo add serde
cargo add rand --features small_rng

Entendendo o Cargo.lock

O arquivo Cargo.lock é gerado automaticamente e trava as versões exatas das dependências. Isso garante compilações reproduzíveis em diferentes máquinas.

Exemplo de código usando dependências:

use rand::Rng;

fn main() {
    let numero_secreto: u8 = rand::thread_rng().gen_range(1..=100);
    println!("Número secreto: {}", numero_secreto);
}

7. Compilando e executando projetos Rust

Modos de compilação

# Compilação debug (rápida, sem otimizações)
cargo build
# Saída: target/debug/meu_projeto

# Compilação release (otimizada para produção)
cargo build --release
# Saída: target/release/meu_projeto

Executando testes

Crie um arquivo src/lib.rs com funções de teste:

pub fn soma(a: i32, b: i32) -> i32 {
    a + b
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_soma() {
        assert_eq!(soma(2, 2), 4);
    }
}

Execute os testes:

cargo test

Gerando documentação

# Gera e abre a documentação do projeto e dependências
cargo doc --open

8. Dicas e boas práticas ao usar rustup e Cargo

Configurando o editor de código

Para VS Code, instale a extensão rust-analyzer. Ela fornece:
- Autocomplete inteligente
- Verificação de erros em tempo real
- Navegação entre definições
- Refatoração de código

Formatando código automaticamente

# Formata todo o código do projeto
cargo fmt

Analisando código com Clippy

# Verifica erros comuns e sugestões de melhoria
cargo clippy

Exemplo de saída do Clippy:

warning: you are using `println!` in a test
 --> src/lib.rs:9:9
  |
9 |         println!("Teste executado");
  |         ^^^^^^^^^^^^^^^^^^^^^^^^^^
  |
  = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html

Dica extra: workspace com múltiplos projetos

Crie um Cargo.toml na raiz:

[workspace]
members = [
    "projeto_a",
    "projeto_b",
]

Isso permite gerenciar vários projetos relacionados com um único cargo build.

Referências

  • Documentação oficial do rustup — Página oficial com instruções de instalação e guia completo de uso do rustup
  • The Cargo Book — Documentação oficial completa sobre o Cargo, incluindo gerenciamento de dependências e configuração de projetos
  • Rust Installation Guide — Guia oficial de instalação do Rust com exemplos passo a passo para diferentes sistemas operacionais
  • rustup GitHub Repository — Repositório oficial do rustup com código fonte, issues e documentação técnica detalhada
  • Rust by Example: Cargo — Tutorial prático sobre o uso do Cargo com exemplos de código, dependências e testes
  • Rust Toolchains Explained — Documentação detalhada sobre toolchains, canais de lançamento e como gerenciá-los com rustup
  • Cargo Commands Cheat Sheet — Referência rápida dos comandos mais úteis do Cargo para o dia a dia do desenvolvimento Rust