
Ingestão de dados em Delta Lake com AWS Lambda e Rust: Arquitetura Hexagonal para sistemas testáveis e performáticos
Como construir uma AWS Lambda em Rust que ingere eventos em Delta Lake no S3 usando Arquitetura Hexagonal — com testes de integração completos sem infraestrutura AWS, commits atômicos via DynamoDB locking e conversão JSON → Apache Arrow → Parquet.
Visão geral
Sistemas de ingestão de dados costumam acumular dois problemas ao longo do tempo: acoplamento forte com infraestrutura de nuvem e suítes de teste que só rodam com credenciais AWS.
Este artigo mostra como construir uma AWS Lambda em Rust que ingere eventos JSON em tabelas Delta Lake no Amazon S3, usando Arquitetura Hexagonal (Ports and Adapters) para garantir que toda a lógica de negócio seja testável sem nenhuma dependência de infraestrutura.
A solução cobre operações de insert, upsert (merge), time travel, vacuum e optimize, e vem acompanhada de 20 testes de integração que rodam com
cargo test , sem depender da infraestrutura AWS.O problema: ingestão confiável de eventos em escala
Imagine uma plataforma que recebe milhões de eventos por dia, como cliques, compras, visualizações de página. Os requisitos operacionais típicos são:
- Durabilidade e auditoria: precisamos saber exatamente o que estava na tabela em qualquer ponto no passado.
- Consistência: dois processos escrevendo ao mesmo tempo não podem corromper os dados.
- Consultabilidade: os dados devem ser acessíveis por Athena, Spark e qualquer engine SQL.
- Custo: o armazenamento precisa ser eficiente; arquivos pequenos são o inimigo.
Arquivos Parquet comuns no S3 resolvem o armazenamento, mas não a consistência nem a auditoria. É aí que entra o Delta Lake.
Por que Delta Lake?
Delta Lake é um formato de tabela que adiciona uma camada de metadados , o transaction log em cima de arquivos Parquet. Cada operação gera uma entrada numerada no diretório
_delta_log/ :s3://meu-bucket/tables/events/├── _delta_log/│ ├── 00000000000000000000.json ← versão 0: CREATE TABLE│ ├── 00000000000000000001.json ← versão 1: WRITE (insert de 3 registros)│ └── 00000000000000000002.json ← versão 2: MERGE (upsert)├── event_type=click/│ └── part-00000-abc123.snappy.parquet└── event_type=view/ └── part-00001-def456.snappy.parquetIsso entrega o que arquivos Parquet isolados não conseguem:
Funcionalidade | Parquet puro | Delta Lake |
|---|---|---|
Transações ACID | ❌ | ✅ |
Histórico de versões | ❌ | ✅ |
Time Travel | ❌ | ✅ |
Schema enforcement | ❌ | ✅ |
Upsert / Merge | ❌ | ✅ |
A implementação nativa do Delta Lake em Rust é o crate
delta-rs , que inclui o motor SQL Apache DataFusion para operações de merge.Por que Rust em vez de Python ou Node.js?
Para esse padrão de carga, processar batches de eventos com Apache Arrow em memória antes de gravar no S3, Rust oferece vantagens mensuráveis:
- Cold start: binário compilado sem JVM ou interpretador. O tempo de inicialização da Lambda cai de segundos para dezenas de milissegundos.
- Uso de memória: sem garbage collector, o consumo de RAM é previsível e menor, reduzindo o custo de execução.
- Tamanho do artefato: com as flags de release (
opt-level = "z",lto = true), o binário final fica em torno de 15 MB, significativamente menor que equivalentes em Java ou .NET.
- Segurança: o compilador elimina em tempo de compilação classes inteiras de bugs como null pointer dereferences e race conditions.
Arquitetura: Hexagonal (Ports and Adapters)
O desafio arquitetural central de qualquer Lambda que acessa S3 é: como testar a lógica de negócio sem precisar de infraestrutura AWS?
A resposta é Arquitetura Hexagonal. O núcleo da aplicação, com regras de negócio e orquestração, não sabe com qual tecnologia está lidando. Isso é garantido por traits (interfaces) que separam a intenção da implementação.

A regra de dependências é inviolável:
domain ← application ← adaptersO
domain nunca importa application ou adapters . Se você encontrar um use deltalake::... dentro de ingestion_service.rs , a arquitetura foi violada.Estrutura de módulos
src/├── main.rs ← ponto de entrada; injeção de dependência├── lib.rs ← expõe módulos para testes de integração├── error.rs ← AppError centralizado com thiserror├── domain/│ ├── commands.rs ← structs de intenção (InsertCommand, etc.)│ ├── results.rs ← structs de retorno (InsertResult, etc.)│ └── ports.rs ← trait TableRepository├── application/│ └── ingestion_service.rs ← validação + orquestração└── adapters/ ├── inbound/lambda.rs ← JSON Lambda → comando de domínio └── outbound/ ├── delta_repository.rs ← implementação real com delta-rs └── in_memory_repository.rs ← test double sem I/OImplementação em detalhes
1. O contrato: TableRepository como Port
O núcleo define o que precisa sem saber como será realizado. Em Rust, isso é um
trait assíncrono:// src/domain/ports.rs
#[async_trait]pub trait TableRepository: Send + Sync { async fn create_table(&self, cmd: CreateTableCommand) -> Result<CreateTableResult, AppError>; async fn insert(&self, cmd: InsertCommand) -> Result<InsertResult, AppError>; async fn upsert(&self, cmd: UpsertCommand) -> Result<UpsertResult, AppError>; async fn vacuum(&self, cmd: VacuumCommand) -> Result<VacuumResult, AppError>; async fn optimize(&self, cmd: OptimizeCommand) -> Result<OptimizeResult, AppError>; async fn time_travel(&self, cmd: TimeTravelCommand) -> Result<TimeTravelResult, AppError>; async fn table_history(&self, cmd: TableHistoryCommand) -> Result<HistoryResult, AppError>; async fn get_schema(&self, cmd: GetSchemaCommand) -> Result<SchemaResult, AppError>;}Os bounds
Send + Sync são necessários para que o trait possa ser usado como Arc<dyn TableRepository> e compartilhado entre as threads do runtime Tokio.2. A camada de aplicação: validação antes da infraestrutura
O
IngestionService recebe um Arc<dyn TableRepository> na construção. Ele não sabe, e não precisa saber, se o repositório por trás vai falar com S3 ou operar em memória:// src/application/ingestion_service.rs
pub struct IngestionService { repo: Arc<dyn TableRepository>,}
impl IngestionService { pub fn new(repo: Arc<dyn TableRepository>) -> Self { Self { repo } }
pub async fn insert(&self, cmd: InsertCommand) -> Result<InsertResult, AppError> { // Regra de negócio pura — sem infraestrutura if cmd.records.is_empty() { return Ok(InsertResult { version: -1, rows_written: 0 }); }
info!(table_uri = %cmd.table_uri, rows = cmd.records.len(), "insert");
self.repo.insert(cmd).await }}3. O adapter inbound: traduzindo evento Lambda para domínio
Um detalhe importante de produção: erros de aplicação (schema inválido, tabela não encontrada) não devem retornar
Err do handler Lambda. Fazer isso aciona retentativas automáticas do runtime, que são adequadas para falhas de infraestrutura, não para erros de negócio.// src/adapters/inbound/lambda.rs
pub async fn handle( event: LambdaEvent<LambdaRequest>, service: Arc<IngestionService>,) -> Result<LambdaResponse, Error> { let req = event.payload;
let result = dispatch(&req.operation, &req.table_uri, &req.payload, &service).await;
match result { Ok(value) => Ok(LambdaResponse { success: true, result: Some(value), error: None, .. }), Err(e) => Ok(LambdaResponse { success: false, error: Some(e.to_string()), .. }), // ^^ // Retornamos Ok mesmo com erro de aplicação para evitar retentativas indesejadas. }}4. O adapter outbound real: JSON → Arrow → Parquet → S3
A conversão de registros JSON para o formato colunar Apache Arrow é o núcleo da operação de insert:
fn records_to_record_batch(records: &[Record], schema: &StructType) -> Result<RecordBatch, AppError> { let arrays: Vec<Arc<dyn Array>> = schema .fields() .map(|field| build_array(field.name(), field.data_type(), records)) .collect::<Result<_, _>>()?;
Ok(RecordBatch::try_new(arrow_schema, arrays)?)}Para cada campo do schema Delta, extraímos os valores de todos os registros formando um array Arrow tipado. Por exemplo, uma coluna
id do tipo long :PrimitiveType::Long => { let vals: Vec<Option<i64>> = records .iter() .map(|r| r.get(col).and_then(|v| v.as_i64())) .collect(); Ok(Arc::new(Int64Array::from(vals)))}O
Option<i64> representa nulos: o Arrow os codifica como uma bitmask separada, não como sentinels no array.Com o
RecordBatch pronto, a escrita no Delta Lake é uma linha:let table = DeltaOps(table) .write(vec![batch]) .with_save_mode(SaveMode::Append) .with_partition_columns(cmd.partition_columns) .await?;Internamente,
DeltaOps::write serializa para Parquet, faz upload para S3 e commita atomicamente uma nova versão no _delta_log/ .5. Upsert com Apache DataFusion
A operação de merge é a mais poderosa. O
delta-rs usa o motor SQL DataFusion para avaliar o predicado e executar o join entre source (novos dados) e target (tabela existente):let (table, metrics) = DeltaOps(table) .merge(source_df, "target.id = source.id") .with_source_alias("source") .with_target_alias("target") .when_matched_update(|u| { u.update("value", "source.value") .update("event_type", "source.event_type") })? .when_not_matched_insert(|i| { i.set("id", "source.id") .set("value", "source.value") .set("event_type", "source.event_type") })? .await?;Isso é equivalente ao SQL ANSI:
MERGE INTO targetUSING source ON target.id = source.idWHEN MATCHED THEN UPDATE SET value = source.value, event_type = source.event_typeWHEN NOT MATCHED THEN INSERT *6. Consideração sobre concorrência: escritores múltiplos
O S3 não tem operação atômica de rename. Por padrão, o
delta-rs usa AWS_S3_ALLOW_UNSAFE_RENAME=true , que é seguro para escritor único (uma Lambda por vez). Para múltiplos escritores concorrentes, ative o DynamoDB locking:opts.insert("AWS_S3_LOCKING_PROVIDER".to_string(), "dynamodb".to_string());opts.insert("DELTA_DYNAMO_TABLE_NAME".to_string(), "delta_log_locks".to_string());Uma tabela DynamoDB passa a coordenar os commits, garantindo que dois processos não sobrescrevam a mesma entrada de log.
Por que DynamoDB e não outro mecanismo?
O DynamoDB aqui não armazena dados, ele funciona como um mutex distribuído. Em sistemas de arquivos normais, o Delta Lake garante commits atômicos renomeando arquivos (
tmp_00003.json → 00000000000000000003.json ). No S3, "rename" é um copy + delete não atômico, o que abre espaço para situações de race condition. Sem a utilização de lock, duas instâncias Lambda podem ler que a versão atual é 2 e ambas tentarem escrever
00000000000000000003.json simultaneamente. Uma sobrescreve a outra e o _delta_log/ fica corrompido.O
delta-rs resolve isso usando escrita condicional do DynamoDB ( condition: attribute_not_exists(version) ). Apenas uma instância ganha o commit, a outra recebe ConditionalCheckFailedException e faz retry com a versão seguinte:Lambda A: "quero commitar versão 3" → DynamoDB: OK, você ganhou o lockLambda B: "quero commitar versão 3" → DynamoDB: já existe, tente versão 4É o equivalente a um
SELECT FOR UPDATE distribuído, usando as garantias de consistência forte do DynamoDB.Injeção de dependência no main.rs
O
main.rs é o único lugar onde a implementação concreta é escolhida. O resto do sistema trabalha com o trait abstrato:#[tokio::main]async fn main() -> Result<(), Error> { // Logs estruturados em JSON para o CloudWatch tracing_subscriber::registry() .with(EnvFilter::from_default_env()) .with(tracing_subscriber::fmt::layer().json()) .init();
// Registra os handlers de S3 uma única vez no cold start deltalake::aws::register_handlers(None);
// Composição de dependências (DI manual) let repo = Arc::new(DeltaTableRepository); let service = Arc::new(IngestionService::new(repo));
// O Arc::clone no closure não duplica o serviço — apenas incrementa o refcount run(service_fn(move |event| { let svc = service.clone(); async move { handle(event, svc).await } })) .await}O
register_handlers precisa ficar no main() porque o Lambda reutiliza o processo entre invocações (warm start). Chamá-lo dentro do handler repetiria o registro a cada requisição.Testes sem AWS
A maior vantagem arquitetural é que toda a suíte de testes roda localmente com
cargo test . O InMemoryTableRepository simula o Delta Lake completamente em memória, incluindo versionamento, time travel e histórico de commits.// Estado interno do adapter de testesstruct TableState { records: Vec<Record>, version: i64, history: Vec<CommitEntry>, snapshots: Vec<VersionSnapshot>, // para time travel orphaned_files: Vec<String>, // para testar vacuum}A cada operação que modifica dados, o adapter executa um commit simulado:
fn commit(&mut self, operation: &str, params: HashMap<String, String>) -> i64 { self.version += 1; self.history.push(CommitEntry { version: self.version, operation: operation.into(), .. }); self.snapshots.push(VersionSnapshot { version: self.version, records: self.records.clone(), // snapshot para time travel }); self.version}Um teste de integração segue o padrão Arrange → Act → Assert:
#[tokio::test]async fn test_insert_appends_records_and_bumps_version() { // Arrange: serviço com adapter de memória isolado let svc = make_service(); svc.create_table(CreateTableCommand { table_uri: "mem://test/events".into(), schema: basic_schema(), .. }).await.unwrap();
// Act let result = svc.insert(InsertCommand { table_uri: "mem://test/events".into(), records: vec![make_record(1, "click", 1.5)], .. }).await.unwrap();
// Assert assert_eq!(result.rows_written, 1); assert_eq!(result.version, 1);}
fn make_service() -> IngestionService { // Cada teste recebe estado limpo — sem acoplamento entre testes IngestionService::new(Arc::new(InMemoryTableRepository::new()))}O teste
test_full_lifecycle é o mais representativo: executando todas as 8 operações em sequência, verificando versionamento, comportamento do upsert, time travel para versão anterior e integridade do histórico de commits.Fluxo de uma requisição de ponta a ponta

Lições aprendidas
Arquitetura Hexagonal paga dividendos em testes. A principal razão para adotá-la não é extensibilidade futura, mais sim poder rodar
cargo test em 3 segundos sem nenhuma credencial AWS. Isso acelera o ciclo de feedback durante o desenvolvimento.Erros de aplicação não devem propagar como
Err no handler Lambda. Essa distinção de falhas de infraestrutura vs. erros de negócio é crítica para evitar retentativas indesejadas em operações com dados inválidos.O
lib.rs é necessário para testes de integração. Em Rust, testes em tests/ só conseguem importar de um crate de biblioteca. Sem o lib.rs expondo os módulos, os testes de integração não têm acesso aos internos do projeto.Arc<dyn Trait> é a injeção de dependência do Rust. Não há framework de DI, o main.rs é a raiz de composição manual. O Arc garante que o mesmo serviço seja compartilhado entre invocações Lambda sem duplicação, e o dyn permite trocar implementações sem recompilar o serviço.Para um único escritor,
AWS_S3_ALLOW_UNSAFE_RENAME=true é seguro. Em workloads com múltiplos produtores concorrentes, ative o DynamoDB locking para coordenar commits no _delta_log/ .Próximos passos
- DynamoDB locking para suporte a múltiplos escritores concorrentes
- Schema evolution: adicionar campos novos sem reescrever dados históricos usando
SaveMode::OverwritecomSchemaMode::Merge
- Compactação automática: Lambda separada rodando
OPTIMIZEperiodicamente para consolidar arquivos pequenos
- AWS Glue Data Catalog: registrar a tabela Delta para que Athena e outros serviços a descubram automaticamente
Conclusão
Este artigo demonstrou como combinar Delta Lake, AWS Lambda, Rust e Arquitetura Hexagonal para construir um ingestor de dados que é ao mesmo tempo performático (cold start < 100 ms), auditável (time travel nativo), e totalmente testável sem infraestrutura de nuvem.
O padrão central, é definir contratos como traits, injetar dependências via
Arc<dyn Trait> , e prover um test double em memória, que é aplicável a qualquer Lambda que precise de I/O: DynamoDB, SQS, Kinesis ou qualquer serviço externo. Essa disciplina arquitetural tem um custo inicial de estruturação, mas elimina a barreira de entrada para testes e facilita substituições de infraestrutura no futuro.
O código completo, incluindo os 20 testes de integração, está disponível no repositório deltalake-lambda-rust-ingestion .
Enjoyed reading this content? Let the author know!
Your likes, comments, shares, and saves help creators reach more builders.
Loading recommendations
Loading article