Por que Rust?

Comparação de Linguagens para Sistemas Distribuídos

Rust oferece um equilíbrio único entre performance e segurança em sistemas distribuídos:

Arquitetura Típica com Rust

┌─────────────────────────────────────────────────┐
│   Camada de Aplicação (Python/Java/Go)         │
└───────────────┬─────────────────┬───────────────┘
                │ HTTP/gRPC       │
┌───────────────▼─────┐ ┌─────────▼───────────────┐
│   Serviços Rust     │ │   Message Broker        │
│   (High-Perf)       │ │   (Kafka/RabbitMQ)      │
└───────────┬─────────┘ └─────────┬───────────────┘
            │                     │
┌───────────▼─────────────────────▼───────────────┐
│   Componentes Críticos em Rust                 │
│   • Service Mesh (Linkerd)                     │
│   • Sistemas de Consenso (Raft)                │
│   • Data Processing Pipelines                  │
└─────────────────────────────────────────────────┘
    

Rust brilha em componentes onde performance e confiabilidade são críticas.

Tabela Comparativa de Garantias

Legenda: GC = Garbage Collector, DS = Distributed Systems

Concorrência e Segurança de Memória

Rust oferece garantias de segurança em tempo de compilação, evitando condições de corrida e vazamentos de memória através de seu sistema de ownership e borrowing. Isso é especialmente valioso em sistemas distribuídos onde a concorrência é essencial.

// Uso seguro de múltiplas threads com compartilhamento imutável
use std::thread;

fn main() {
    let dados = vec![1, 2, 3, 4];
    
    let handles: Vec<_> = (0..4).map(|i| {
        // Usamos move para transferir ownership da cópia
        thread::spawn(move || {
            println!("Thread {} processando valor: {}", i, dados[i]);
        })
    }).collect();

    for handle in handles {
        handle.join().unwrap();
    }
    
    // Dados originais ainda estão disponíveis aqui
    println!("Dados originais: {:?}", dados);
}

Note como Rust permite compartilhamento seguro de dados entre threads quando eles são imutáveis. Para dados mutáveis, Rust exige mecanismos como Arc<Mutex<T>> para garantir segurança.

Modelo de Ownership

O sistema de ownership do Rust previne acessos inválidos e uso após liberação de memória através de três regras fundamentais:

1. Cada valor em Rust tem um owner (dono)
2. Só pode haver um owner por vez
3. Quando o owner sai de escopo, o valor é liberado

// Demonstração de borrowing e ownership
fn main() {
    let mut mensagem = String::from("Processamento");
    
    // Empresta uma referência imutável
    calcular_tamanho(&mensagem);
    
    // Empresta uma referência mutável
    modificar(&mut mensagem);
    
    println!("Mensagem final: {}", mensagem);
}

fn calcular_tamanho(s: &String) -> usize {
    s.len() // s é uma referência imutável
}

fn modificar(s: &mut String) {
    s.push_str(" distribuído"); // s é uma referência mutável
}

Este exemplo mostra como Rust gerencia empréstimos (borrowing) de forma segura, permitindo ou uma única referência mutável ou múltiplas referências imutáveis.

Tipos de Comunicação

Rust oferece vários padrões para comunicação entre threads e processos, essenciais para sistemas distribuídos:

1. Channels (Múltiplos Produtores, Único Consumidor)

use std::sync::mpsc;
use std::thread;
use std::time::Duration;

fn main() {
    let (tx, rx) = mpsc::channel();
    
    // Produtor 1
    let tx1 = tx.clone();
    thread::spawn(move || {
        let mensagens = vec!["Task1", "Task2", "Task3"];
        for msg in mensagens {
            tx1.send(msg).unwrap();
            thread::sleep(Duration::from_secs(1));
        }
    });
    
    // Produtor 2
    thread::spawn(move || {
        let mensagens = vec!["Ack1", "Ack2"];
        for msg in mensagens {
            tx.send(msg).unwrap();
            thread::sleep(Duration::from_secs(2));
        }
    });
    
    // Consumidor
    for recebida in rx {
        println!("Processando: {}", recebida);
    }
}

2. Shared State com Arc<Mutex<T>>

use std::sync::{Arc, Mutex};
use std::thread;

fn main() {
    let contador = Arc::new(Mutex::new(0));
    let mut handles = vec![];

    for _ in 0..4 {
        let contador = Arc::clone(&contador);
        let handle = thread::spawn(move || {
            let mut num = contador.lock().unwrap();
            *num += 1;
        });
        handles.push(handle);
    }

    for handle in handles {
        handle.join().unwrap();
    }

    println!("Total: {}", *contador.lock().unwrap());
}

Estes padrões são fundamentais para construir sistemas distribuídos seguros e eficientes em Rust.

Instalação do Rust

Para começar a trabalhar com Rust, você precisa instalar o compilador e o gerenciador de pacotes:

Linux/macOS

curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
source $HOME/.cargo/env

Windows

Baixe e execute o rustup-init.exe

Verifique a instalação:

rustc --version
cargo --version

Ferramentas Úteis

Para desenvolvimento eficiente:

• Rust Analyzer: Extensão para VS Code/IDEs (autocompletar, verificação em tempo real)
• Cargo: Gerenciador de pacotes e sistema de build (já vem com a instalação)

Testando Online (REPL)

Se não puder instalar localmente, use:

• Rust Playground - Ambiente online para testes rápidos
• Replit Rust - IDE online completa

Para os exemplos assíncronos (Tokio/Reqwest), você precisará de instalação local pois o playground não suporta todas as bibliotecas.

Configurando Dependências

Para os exemplos desta aula, adicione ao seu Cargo.toml:

[dependencies]
tokio = { version = "1.0", features = ["full"] }
reqwest = "0.11"
crossbeam = "0.8"
serde = { version = "1.0", features = ["derive"] }

Depois execute:

cargo build

Trabalhando com Threads

Rust permite a criação de múltiplas threads com segurança em tempo de compilação, evitando condições de corrida.

use std::thread;

fn main() {
    let t1 = thread::spawn(|| {
        println!(\"Thread 1 ativa\");
    });

    let t2 = thread::spawn(|| {
        println!(\"Thread 2 ativa\");
    });

    t1.join().unwrap();
    t2.join().unwrap();
}

Programação Assíncrona com Tokio

Com o runtime tokio, é possível criar aplicações assíncronas eficientes para servidores e clientes distribuídos.

use tokio::time::{sleep, Duration};

#[tokio::main]
async fn main() {
    let tarefa1 = tokio::spawn(async {
        sleep(Duration::from_secs(1)).await;
        println!(\"Tarefa 1 concluída\");
    });

    let tarefa2 = tokio::spawn(async {
        println!(\"Tarefa 2 concluída\");
    });

    tarefa1.await.unwrap();
    tarefa2.await.unwrap();
}

HTTP com a Crate Reqwest

Podemos consumir APIs com segurança e performance usando reqwest.

use reqwest;

#[tokio::main]
async fn main() -> Result<(), reqwest::Error> {
    let resposta = reqwest::get(\"https://httpbin.org/ip\").await?
        .text().await?;
    println!(\"Resposta: {}\", resposta);
    Ok(())
}

Mensageria com Crate Crossbeam

O canal crossbeam permite comunicação segura entre threads, útil para arquiteturas com múltiplos workers.

use crossbeam::channel;
use std::thread;

fn main() {
    let (tx, rx) = channel::unbounded();

    thread::spawn(move || {
        tx.send(\"Mensagem distribuída\").unwrap();
    });

    println!(\"Recebido: {}\", rx.recv().unwrap());
}

Padrões Essenciais com Rust

Estes são os padrões fundamentais para construir sistemas resilientes:

use tower::timeout::Timeout;
use tower::retry::Retry;
use tower::buffer::Buffer;
use tower::limit::RateLimit;

// Stack de resiliência típica
let service = Timeout::new(
    Retry::new(
        CircuitBreaker::new(
            RateLimit::new(
                Buffer::new(MyService, 10),
                100 // req/s
            )
        ),
        ExponentialBackoff::default()
    ),
    Duration::from_secs(3)
);

use backoff::ExponentialBackoff;

let operation = || async {
    reqwest::get("https://api.example.com")
        .await?
        .error_for_status()
};

backoff::future::retry(ExponentialBackoff::default(), operation).await;

use tokio::sync::Semaphore;

let semaphore = Arc::new(Semaphore::new(10)); // 10 conexões máximas

async fn process() {
    let _permit = semaphore.acquire().await; // Bloqueia se exceder
    // Operação limitada
}

Arquitetura Completa de Serviço Distribuído

Exemplo de serviço Rust pronto para produção integrando múltiplos componentes:

use tonic::{transport::Server, Request, Response, Status};
use etcd_client::{Client, LeaseGrantOptions};
use tokio::signal;
use std::time::Duration;

mod pb {
    tonic::include_proto!("meuservico");
}

#[derive(Default)]
struct MeuServico;

#[tonic::async_trait]
impl pb::servico_server::Servico for MeuServico {
    async fn health_check(
        &self,
        _: Request<pb::HealthCheckRequest>
    ) -> Result<Response<pb::HealthCheckResponse>, Status> {
        Ok(Response::new(pb::HealthCheckResponse { healthy: true }))
    }
}

#[tokio::main]
async fn main() -> Result<, Box<dyn std::error::Error>> {
    // 1. Inicia serviço gRPC
    let addr = "[::1]:50051".parse()?;
    let servico = MeuServico::default();
    
    // 2. Conecta ao etcd para service discovery
    let mut etcd = Client::connect(["http://etcd:2379"], None).await?;
    let lease = etcd.lease_grant(30, None).await?; // TTL de 30s
    
    // 3. Registra instância
    etcd.put(
        format!("services/meuservico/{}", uuid::Uuid::new_v4()),
        addr.to_string(),
        Some(LeaseGrantOptions::new().with_lease(lease.id()))
    ).await?;

    // 4. Health check periódico
    tokio::spawn(async move {
        let mut interval = tokio::time::interval(Duration::from_secs(10));
        loop {
            interval.tick().await;
            etcd.lease_keep_alive(lease.id()).await.unwrap();
        }
    });

    // 5. Shutdown graceful
    Server::builder()
        .add_service(pb::servico_server::ServicoServer::new(servico))
        .serve_with_shutdown(addr, async {
            signal::ctrl_c().await.unwrap();
            println!("Desligando graciosamente...");
        })
        .await?;

    Ok(())
}

[dependencies]
tokio = { version = "1.0", features = ["full"] }
tonic = "0.8"
etcd-client = "0.9"
prost = "0.11"
uuid = { version = "1.0", features = ["v4"] }

syntax = "proto3";
package meuservico;
service Servico {
  rpc HealthCheck(HealthCheckRequest) returns (HealthCheckResponse);
}
message HealthCheckRequest {}
message HealthCheckResponse { bool healthy = 1; }

Checklist para Production-Ready

// Exemplo com OpenTelemetry
tracing_subscriber::fmt()
    .with_max_level(Level::INFO)
    .init();

let meter = global::meter("meuservico");
let request_counter = meter.u64_counter("requests").init();

// Configuração via etcd
let watch = etcd.watch("config/meuservico").await?;
tokio::spawn(async move {
    while let Some(resp) = watch.message().await.unwrap() {
        update_config(resp.events);
    }
});

tokio::select! {
    _ = servidor => println!("Servidor finalizado"),
    _ = signal::ctrl_c() => {
        println!("Recebido SIGINT");
        servidor.shutdown().await;
    }
}

Cenários Problemáticos Comuns

use std::sync::{Arc, Mutex};
use std::thread;
use std::time::Duration;

fn main() {
    let a = Arc::new(Mutex::new(1));
    let b = Arc::new(Mutex::new(2));

    let t1 = {
        let a = Arc::clone(&a);
        let b = Arc::clone(&b);
        thread::spawn(move || {
            let _ga = a.lock().unwrap(); // Lock A
            thread::sleep(Duration::from_secs(1));
            let _gb = b.lock().unwrap(); // Espera B (DEADLOCK)
            println!("Thread 1 completou");
        })
    };

    let t2 = thread::spawn(move || {
        let _gb = b.lock().unwrap(); // Lock B
        let _ga = a.lock().unwrap(); // Espera A
        println!("Thread 2 completou");
    });

    t1.join().unwrap();
    t2.join().unwrap();
}

// Estratégia 1: Ordem consistente de locks
let _ga = a.lock().unwrap();
let _gb = b.lock().unwrap();

// Estratégia 2: Timeout
b.try_lock_for(Duration::from_millis(100))?

use std::sync::mpsc;
use std::thread;

fn main() {
    let (tx, rx) = mpsc::channel();
    
    thread::spawn(move || {
        tx.send(1).unwrap();
        tx.send(2).unwrap(); // ⚠️ Pode bloquear se consumidor parar
    });

    println!("{}", rx.recv().unwrap());
    // Esqueceu de receber a segunda mensagem
}

let (tx, rx) = mpsc::sync_channel(10); // Buffer de 10 itens

Análise de Performance com Flamegraphs

Passo a Passo:

1. Adicione as dependências:

   [dependencies]
   pprof = { version = "0.11", features = ["flamegraph"] }
   tokio = { version = "1.0", features = ["rt-multi-thread"] }

2. Instrumente seu código:

   use pprof::ProfilerGuard;
   
   let guard = ProfilerGuard::new(100).unwrap(); // 100Hz
   // ... código sendo analisado ...
   if let Ok(report) = guard.report().build() {
       let file = std::fs::File::create("flamegraph.svg").unwrap();
       report.flamegraph(file).unwrap();
   }

3. Execute e visualize:

   cargo run --release
   xdg-open flamegraph.svg

Exemplo de Saída:

Pontos-chave para análise:

• 🔴 Blocos largos = hotspots de CPU
• 🟡 Chamadas de sistema = possíveis IO bounds
• 🟢 Muitas pequenas chamadas = possível thrashing

Exercício Prático: Debugging

use std::sync::Arc;
use tokio::sync::Mutex;

#[tokio::main]
async fn main() {
    let data = Arc::new(Mutex::new(Vec::new()));
    
    for i in 0..10 {
        let data = Arc::clone(&data);
        tokio::spawn(async move {
            let mut guard = data.lock().await;
            guard.push(i);
            tokio::time::sleep(tokio::time::Duration::from_secs(1)).await;
            guard.pop(); // ⚠️ Onde está o erro?
        });
    }
}

tokio::spawn(async move {
    let val = {
        let mut guard = data.lock().await;
        guard.push(i);
        guard.pop().unwrap()
    }; // Lock é liberado aqui
    
    tokio::time::sleep(Duration::from_secs(1)).await;
});

Ferramentas Essenciais para Produção

[dependencies]
tokio = { version = "1.0", features = ["full", "tracing"] }
tracing-subscriber = { version = "0.3", features = ["env-filter"] }

// main.rs
use tracing_subscriber::prelude::*;

#[tokio::main]
async fn main() {
    // Configure o subscriber
    tracing_subscriber::registry()
        .with(tracing_subscriber::EnvFilter::new(
            "my_crate=info,tokio=debug",
        ))
        .with(tracing_subscriber::fmt::layer())
        .init();

    // Sua aplicação aqui...
}

# Instale o console
cargo install tokio-console

# Execute seu projeto com instrumentação
RUSTFLAGS="--cfg tokio_unstable" cargo run

# Em outro terminal:
tokio-console

[dependencies]
pprof = { version = "0.11", features = ["flamegraph"] }

use pprof::ProfilerGuard;

fn main() {
    let guard = ProfilerGuard::new(100).unwrap(); // 100Hz
    
    // Código a ser analisado
    heavy_computation();
    
    if let Ok(report) = guard.report().build() {
        let file = std::fs::File::create("flamegraph.svg").unwrap();
        report.flamegraph(file).unwrap();
    }
}

cargo install cargo-deny

[advisories]
db-path = "~/.cargo/advisory-db"
vulnerability = "deny"
unmaintained = "warn"

[bans]
multiple-versions = "deny"

# Verificar todas as regras
cargo deny check all

# Verificar atualizações
cargo deny check update

Template para Sistemas Distribuídos

cargo new --lib meu-sistema-distribuido
cd meu-sistema-distribuido

.
├── Cargo.toml
├── src/
│   ├── lib.rs      # Core lógico
│   ├── client.rs   # Cliente gRPC/REST
│   ├── server.rs   # Serviço principal
│   └── raft/       # Implementação consenso
├── protos/         # Definições Protocol Buffer
├── scripts/        # Scripts de deploy
└── tests/          # Testes de integração

[package]
name = "meu-sistema-distribuido"
version = "0.1.0"
edition = "2021"

[dependencies]
tokio = { version = "1.0", features = ["full"] }
tonic = "0.8"              # gRPC
serde = { version = "1.0", features = ["derive"] }
tracing = "0.1"            # Logging estruturado

[dev-dependencies]
tokio-test = "0.4"
testcontainers = "0.15"    # Testes com containers

cargo new --template https://github.com/rust-distributed/rust-dist-template \
  --bin meu-sistema-distribuido

Mapa Mental de Conceitos

Glossário de Termos Técnicos

Recursos Recomendados

O que é o Raft?

O Raft é um algoritmo de consenso distribuído projetado para ser fácil de entender, dividindo o problema em três subproblemas:

1. Liderança: Um único líder é eleito para gerenciar a replicação de logs
2. Replicação de Log: O líder garante que as entradas do log sejam replicadas na maioria dos nós
3. Segurança: Garante que nenhum nó retorne um valor antigo após uma atualização

Comparado ao Paxos, Raft é mais compreensível e vem sendo adotado em sistemas como etcd, Consul e TiKV.

Estados do Raft

          [Seguidor]
               ↑ ↓
        Timeout | Recebe voto majoritário
               ↓ ↑
          [Candidato] → Votos suficientes → [Líder]
                                               ↓
                                     Perde comunicação ←

Implementação Básica em Rust

Estrutura expandida de um nó Raft com máquina de estados:

use std::collections::HashMap;
use tokio::sync::mpsc;

#[derive(Debug, Clone)]
pub enum EstadoRaft {
    Seguidor,
    Candidato,
    Lider,
}

pub struct NoRaft {
    pub id: u64,
    pub estado: EstadoRaft,
    pub termo_atual: u64,
    pub votos_recebidos: u64,
    pub votou_em: Option,
    pub nos_conhecidos: HashMap>,
}

impl NoRaft {
    pub fn novo(id: u64) -> Self {
        Self {
            id,
            estado: EstadoRaft::Seguidor,
            termo_atual: 0,
            votos_recebidos: 0,
            votou_em: None,
            nos_conhecidos: HashMap::new(),
        }
    }

    pub async fn iniciar_eleicao(&mut self) {
        self.estado = EstadoRaft::Candidato;
        self.termo_atual += 1;
        self.votos_recebidos = 1; // Vota em si mesmo
        self.votou_em = Some(self.id);
        
        // Envia RequestVote para outros nós
        for (id, tx) in &self.nos_conhecidos {
            if *id != self.id {
                let mensagem = RaftMensagem::SolicitacaoVoto {
                    candidato_id: self.id,
                    termo: self.termo_atual,
                };
                tx.send(mensagem).await.unwrap();
            }
        }
    }
}

#[derive(Debug)]
pub enum RaftMensagem {
    SolicitacaoVoto { candidato_id: u64, termo: u64 },
    VotoConcedido { votante_id: u64, termo: u64 },
    AppendEntries { lider_id: u64, termo: u64 },
}

Esta implementação mostra a estrutura básica para eleições, incluindo:

• Transição de estados (Seguidor → Candidato → Líder)
• Lógica de votação
• Comunicação entre nós via channels

Exemplo Completo: Lógica de Heartbeat

Implementação do mecanismo de heartbeat que mantém a liderança:

use tokio::time::{interval, Duration};

impl NoRaft {
    pub async fn executar_heartbeat(&self) {
        let mut interval = interval(Duration::from_millis(100));
        
        loop {
            interval.tick().await;
            
            if let EstadoRaft::Lider = self.estado {
                for (id, tx) in &self.nos_conhecidos {
                    if *id != self.id {
                        let mensagem = RaftMensagem::AppendEntries {
                            lider_id: self.id,
                            termo: self.termo_atual,
                        };
                        tx.send(mensagem).await.unwrap();
                    }
                }
            }
        }
    }
}

O heartbeat é enviado periodicamente para:

1. Manter a autoridade do líder
2. Evitar novas eleições
3. Replicar entradas do log (não mostrado neste exemplo simplificado)

Documentação Oficial

• Rust Lang - Página Oficial
• The Rust Programming Language (The Book)
• Documentação da Biblioteca Padrão

Ferramentas e Bibliotecas

• Crates.io - Registro de Pacotes Rust
• Docs.rs - Documentação das Crates
• Tokio - Async Runtime para Rust
• raft-rs - Implementação do Raft em Rust

Material Complementar

• Raft: Understandable Consensus
• Too Many Linked Lists (Aprenda Rust Avançado)
• Faster Than Lime - Blog sobre Rust
• Async Programming in Rust