Funções Serverless em Rust no AWS Lambda: guia completo

Introdução: Por que Rust é a linguagem ideal para Serverless

A arquitetura Serverless tornou-se padrão para aplicações modernas em nuvem. No entanto, linguagens clássicas (Python, Node.js) frequentemente sofrem com inicialização a frio lenta e alto consumo de memória. Rust resolve esses problemas: seus binários compilados iniciam em milissegundos, e o consumo de memória é mínimo. Neste artigo, vamos abordar como criar, implantar e otimizar funções AWS Lambda em Rust — desde a configuração do ambiente até o deploy em produção.

1. Configuração do ambiente e ferramentas

Instalação do Rust e Cargo Lambda

Para trabalhar com AWS Lambda em Rust, você precisará de:

• Rust (instalação via rustup)
• Cargo Lambda — ferramenta oficial para compilação e deploy
• AWS CLI com credentials configuradas

# Instalação do Rustcurl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh

# Instalação do Cargo Lambdacargo install cargo-lambda

# Verificaçãocargo lambda --version

Criação de um novo projeto

O Cargo Lambda gera automaticamente um template com suporte ao Lambda Runtime API:

cargo lambda new my-rust-lambdacd my-rust-lambda

A estrutura do projeto inclui Cargo.toml com as dependências lambda_runtime e serde, além do arquivo src/main.rs com uma função handler básica.

2. Escrevendo a primeira função Serverless em Rust

Estrutura básica do handler

Vamos considerar uma função Lambda simples que recebe um JSON com um nome e retorna uma saudação:

use lambda_runtime::{service_fn, LambdaEvent, Error};use serde::{Deserialize, Serialize};

#[derive(Deserialize)]struct Request {    name: String,}

#[derive(Serialize)]struct Response {    message: String,    request_id: String,}

async fn handler(event: LambdaEvent<Request>) -> Result<Response, Error> {    let req = event.payload;    let resp = Response {        message: format!("Olá, {}! Você está no Rust!", req.name),        request_id: event.context.request_id,    };    Ok(resp)}

#[tokio::main]async fn main() -> Result<(), Error> {    lambda_runtime::run(service_fn(handler)).await}

Pontos-chave:

• service_fn encapsula a função assíncrona em um handler
• LambdaEvent contém o payload e o contexto (request_id, deadline, etc.)
• Serialização/desserialização via serde

Teste local

Antes do deploy, teste a função localmente:

cargo lambda watch# Em outro terminal:cargo lambda invoke --data-ascii '{"name": "Mundo"}'

Você deve receber a resposta: {"message":"Olá, Mundo! Você está no Rust!","request_id":"..."}

3. Trabalhando com serviços AWS (S3, DynamoDB)

Integração com S3 via AWS SDK

Adicione ao Cargo.toml:

[dependencies]aws-sdk-s3 = "1.0"aws-config = "1.0"

Exemplo de função que lê um objeto do S3:

use aws_sdk_s3::Client;

async fn handler(event: LambdaEvent<Request>) -> Result<Response, Error> {    let config = aws_config::load_from_env().await;    let s3_client = Client::new(&config);

    let bucket = "my-bucket";    let key = &event.payload.name;

    let object = s3_client        .get_object()        .bucket(bucket)        .key(key)        .send()        .await?;

    let body = object.body.collect().await?;    let content = String::from_utf8(body.to_vec())?;

    Ok(Response {        message: format!("Conteúdo do arquivo: {}", content),        request_id: event.context.request_id,    })}

Em