Serverless em Rust: Mais rápido que AWS Lambda com inicialização a frio

Serverless em Rust: Quando cada milissegundo conta

Você já esperou 3-4 segundos para uma AWS Lambda iniciar? Se você trabalhou com Python ou Node.js em ambiente serverless, conhece essa dor — a inicialização a frio. Agora imagine: sua função inicia em 50-100 milissegundos, consome 10 vezes menos memória e o binário pesa apenas 5 megabytes. Bem-vindo ao mundo das funções serverless em Rust.

Rust invadiu o serverless por um bom motivo. É uma linguagem que oferece controle sobre a memória sem coletor de lixo, compila para código nativo e é ideal para edge computing. No PythonLib amamos Python, mas quando se trata de velocidade e custo — especialmente sob alta carga — Rust se torna um matador.

Neste artigo, abordaremos:

\n
• Por que Rust é a melhor linguagem para serverless (spoiler: não é só pela velocidade)
\n
• Como escrever e implantar uma AWS Lambda em Rust
\n
• Alternativas: Cloudflare Workers e Vercel Edge Functions
\n
• Benchmarks de inicialização a frio: Rust vs Python
\n

Pronto? Vamos nessa.

Por que Rust para Serverless não é moda, é matemática

Vamos direto aos números. A inicialização a frio média de uma AWS Lambda em Python é de 400-800 ms (com carregamento de dependências). Em Node.js — 200-400 ms. Em Rust — 30-100 ms. Por que tanta diferença?

\n
• Sem interpretador ou JIT. Rust compila para código de máquina. A Lambda simplesmente carrega o binário — e pronto.
\n
• Tamanho mínimo. Mesmo com tokio e serde, o binário pesa 5-15 MB (zip compactado — 2-4 MB). Python com numpy ou pandas — 50-200 MB.
\n
• Economia de memória. Funções Rust consomem 20-50 MB contra 128-256 MB para Python. Em 10 milhões de requisições, a diferença na conta é de centenas de dólares.
\n

Mas há um detalhe: escrever em Rust é mais difícil. É preciso entender ownership, lifetimes, async. No entanto, se sua Lambda é um microsserviço crítico com RPS > 1000, Rust se paga rapidamente.

Prática: Escrevendo uma AWS Lambda em Rust

Passo 1: Instalação das ferramentas

Você vai precisar de:

\n
• Rust (rustup)
\n
• cargo-lambda — utilitário para compilar para AWS
\n
• Docker (para compilar para Linux, se você estiver no macOS/Windows)
\n

# Instala o cargo-lambda\ncargo install cargo-lambda\n\n# Cria um novo projeto\ncargo lambda new my-rust-lambda\ncd my-rust-lambda

Passo 2: Código da função

Abra src/main.rs. O template padrão já contém uma estrutura básica. Vamos escrever algo útil — uma API que recebe um JSON com um nome e retorna uma saudação.

use lambda_runtime::{run, service_fn, Error, LambdaEvent};\nuse serde::{Deserialize, Serialize};\n\n#[derive(Deserialize)]\nstruct Request {\n    name: String,\n}\n\n#[derive(Serialize)]\nstruct Response {\n    message: String,\n    timestamp: u64,\n}\n\nasync fn handler(event: LambdaEvent<Request>) -> Result<Response, Error> {\n    let request = event.payload;\n    let timestamp = std::time::SystemTime::now()\n        .duration_since(std::time::UNIX_EPOCH)\n        .unwrap()\n        .as_secs();\n\n    Ok(Response {\n        message: format!("Olá, {}! Você está no PythonLib, mas estamos no Rust 🦀", request.name),\n        timestamp,\n    })\n}\n\n#[tokio::main]\nasync fn main() -> Result<(), Error> {\n    tracing_subscriber::fmt()\n        .with_max_level(tracing::Level::INFO)\n        .init();\n\n    run(service_fn(handler)).await\n}

Passo 3: Compilação e implantação

# Compila para Linux (para Lambda)\ncargo lambda build --release\n\n# Implanta (precisa de credenciais AWS)\ncargo lambda deploy --iam-role arn:aws:iam::YOUR_ACCOUNT:role/lambda-execution-role

Pronto! Agora você tem uma Lambda em Rust que é 5 a 10 vezes mais rápida que a equivalente em Python.