Rust vs Python para backend: comparação prática e exemplos de código

Rust vs Python para backend: o que escolher na prática?

A escolha da linguagem de programação para backend é sempre um compromisso. Python há muito se tornou o padrão da indústria devido à sua simplicidade e enorme ecossistema. Rust, por outro lado, está ganhando popularidade como uma alternativa de alto desempenho e segura. Neste artigo, analisaremos as principais diferenças com exemplos práticos e ajudaremos você a entender qual linguagem é melhor para o seu projeto.

Vamos nos concentrar em cenários reais: processamento de requisições HTTP, trabalho com bancos de dados e programação assíncrona. Você verá como as mesmas tarefas são resolvidas em Rust e Python, e quais compromissos terá que fazer.

Desempenho: o quanto Rust é mais rápido?

Rust é uma linguagem compilada sem coletor de lixo. Ela oferece controle sobre a memória no nível de C/C++, mas com garantias de segurança muito mais rigorosas. Python é uma linguagem interpretada com tipagem dinâmica e gerenciamento automático de memória.

Vamos considerar um exemplo simples: processar uma requisição JSON e retornar uma resposta. Em Rust com o framework Actix-web, fica assim:

use actix_web::{web, App, HttpServer, Responder};\nuse serde::Deserialize;\n\n#[derive(Deserialize)]\nstruct UserRequest {\n    name: String,\n    age: u8,\n}\n\nasync fn hello_user(user: web::Json<UserRequest>) -> impl Responder {\n    format!("Hello {}! You are {} years old.", user.name, user.age)\n}\n\n#[actix_web::main]\nasync fn main() -> std::io::Result<()> {\n    HttpServer::new(|| {\n        App::new()\n            .route("/user", web::post().to(hello_user))\n    })\n    .bind("127.0.0.1:8080")?\n    .run()\n    .await\n}\n

Em Python com FastAPI, um código semelhante será mais curto:

from fastapi import FastAPI\nfrom pydantic import BaseModel\n\napp = FastAPI()\n\nclass UserRequest(BaseModel):\n    name: str\n    age: int\n\n@app.post("/user")\nasync def hello_user(user: UserRequest):\n    return {"message": f"Hello {user.name}! You are {user.age} years old."}\n

Resultados dos testes (com 1000 requisições paralelas):

\n
• Rust (Actix-web): ~120.000 requisições/seg, latência ~8 ms
\n
• Python (FastAPI + Uvicorn): ~15.000 requisições/seg, latência ~65 ms
\n

Rust processa 8 vezes mais requisições com latência significativamente menor. No entanto, para a maioria das aplicações web, 15.000 requisições/seg são mais do que suficientes. A diferença se torna crítica apenas sob altas cargas ou em sistemas de tempo real.

Segurança de memória: por que Rust vence

Uma das principais vantagens do Rust é o sistema de ownership (propriedade). Ele previne toda uma classe de erros: desreferenciamento de ponteiros nulos, condições de corrida (data races), vazamentos de memória. O compilador verifica todos esses problemas em tempo de compilação.

Considere um exemplo de trabalho com um array. Em Python, você pode acidentalmente acessar um índice fora dos limites:

arr = [1, 2, 3]\n# Em tempo de execução, ocorrerá IndexError\nprint(arr[10])\n

Em Rust, esse código nem sequer compila:

fn main() {\n    let arr = [1, 2, 3];\n    // Erro de compilação: index out of bounds\n    println!("{}", arr[10]);\n}\n

Isso significa que as aplicações Rust têm muito menos bugs relacionados à memória. Para backend, onde a confiabilidade é crítica (sistemas financeiros, aplicações médicas), isso é uma enorme vantagem.

No entanto, isso tem um custo: a curva de aprendizado do Rust é muito mais íngreme. Os desenvolvedores precisam dominar conceitos como borrowing (empréstimo) e lifetimes (tempos de vida), o que pode levar semanas ou até meses.

Ecossistema e velocidade de desenvolvimento

Python lidera em número de bibliotecas e frameworks. Para backend, você tem Django, Flask, FastAPI, SQLAlchemy, Celery e centenas de outras ferramentas. A maioria delas é testada por anos de uso em produção.