Rust para Big Data: Processando milhões de linhas mais rápido que Python

Por que Rust é o novo rei do processamento de Big Data?

Você já esperou 20 minutos enquanto um script em Python processava um arquivo CSV de 10 gigabytes? E depois mais 10 minutos porque a memória acabou e o sistema foi para swap? Familiar?

O mundo do Big Data pertenceu por muito tempo ao Python e seu ecossistema: Pandas, NumPy, Dask. Mas há um problema — Python é lento. Muito lento. E quando os dados são medidos em terabytes, cada milissegundo extra se transforma em horas de inatividade.

É aqui que entra o Rust. Uma linguagem de sistema que oferece o desempenho do C++ e a segurança de memória, mas com uma sintaxe que (spoiler) é perfeitamente amável. E sim, ele é ideal para processamento de Big Data.

Neste artigo, vamos explorar como o Rust permite processar enormes volumes de dados de forma mais rápida, segura e com menor consumo de memória. Sem mágica — apenas código e medições.

Rust vs Python para Big Data: o que há por dentro?

Vamos direto aos números. Aqui está um teste simples: ler um arquivo CSV de 500 MB, filtrar linhas por condição e calcular a soma.

15 vezes mais rápido e 5 vezes mais econômico em memória. E isso não é o limite. Rust oferece controle sobre cada byte, sobre cada alocação. Ele não perdoa erros, mas oferece uma velocidade que o Python nunca alcançará.

Ferramentas Rust para Big Data

Antes de escrever código, vamos ver o que está disponível no arsenal. Rust não para — o ecossistema para trabalhar com dados está crescendo ativamente.

Principais bibliotecas

\n
• Polars — análogo ao Pandas, mas em Rust. Suporta lazy evaluation, processamento paralelo e trabalha com dados que não cabem na memória.
\n
• Apache Arrow — formato de dados colunar que permite trocar dados entre diferentes linguagens sem cópia.
\n
• DataFusion — mecanismo SQL em Rust que pode executar consultas diretamente sobre dados Arrow.
\n
• rayon — biblioteca para iterações paralelas. Permite paralelizar facilmente qualquer processamento.
\n
• csv — parser rápido de arquivos CSV com alocações mínimas.
\n
• serde — serialização/desserialização. Essencial para trabalhar com JSON, YAML, TOML.
\n

Usaremos Polars e rayon, pois são o padrão de facto para processamento de Big Data em Rust.

Exemplo prático: processamento de logs de servidor web

Imagine que você tem 100 milhões de registros de logs do Nginx. Precisa:

\n
1. Filtrar apenas erros 5xx
\n
2. Agrupar por endereço IP
\n
3. Contar o número de erros por IP
\n
4. Exibir o top-10 de invasores
\n

Em Python com Pandas, isso levaria cerca de 2-3 minutos e consumiria toda a RAM. Em Rust — 15-20 segundos.

Estrutura de dados

Suponha que cada log se pareça com:

192.168.1.1 - - [10/Out/2023:13:55:36 +0000] "GET /api/data HTTP/1.1" 500 1234 "-" "Mozilla/5.0"

Precisamos analisar a string, extrair o IP e o código de resposta. Em Rust, isso é feito através de um tipo estrutural próprio:

use serde::Deserialize;\n\n#[derive(Debug, Deserialize)]\nstruct LogEntry {\n    ip: String,\n    status_code: u16,\n    method: String,\n    path: String,\n    user_agent: String,\n}

Parsing CSV com Polars

Polars é o motivo pelo qual vale a pena experimentar