![Data lake serverless na AWS na prática: do CSV ao SQL com S3, Glue e Athena [Parte 2]](https://prod-assets.cosmic.aws.dev/a/3LQtKZ66ilKqLAxKNDSl7cIZyHb/capa.webp)
Data lake serverless na AWS na prática: do CSV ao SQL com S3, Glue e Athena [Parte 2]
Como colocar de pé, do zero, o data lake desenhado na Parte 1. Nesta Parte 2, construo tudo com Amazon S3, AWS Glue e Amazon Athena: dados sujos de propósito, role do Glue com menor privilégio, crawler para descobrir o schema, Glue Job em PySpark convertendo CSV para Parquet particionado e partition projection no Athena. No final, a prova: a mesma consulta lendo 48 vezes menos dados.
Na Parte 1 a gente desenhou a arquitetura de um data lake serverless para uma loja online: CSV chegando na camada raw, um Glue Job convertendo para Parquet particionado e o Athena consultando com SQL. Agora é hora de sair do papel.
Nesta Parte 2 eu vou construir tudo do zero, com comandos e código, e no final medir na prática a diferença entre consultar CSV e consultar Parquet particionado. Spoiler: a mesma pergunta lê 48 vezes menos dados.

O que você vai precisar
- Uma conta AWS e a AWS CLI configurada (
aws configure)
- Python 3 para gerar os dados de exemplo
- Uns 30 minutos
Custo: seguindo o passo a passo e limpando tudo no final, o laboratório custa centavos de dólar. O maior item é o Glue Job, cobrado por tempo de execução.
Todo o código usado aqui está no meu repositório de laboratórios: Builder-Center-Labs/01-data-lake-serverless
Passo 0: gerar os dados da loja
Para não depender de dados reais, eu escrevi um script que gera pedidos fictícios, um CSV por dia, exatamente no layout da camada raw. E os dados vêm sujos de propósito, como na vida real:
- 1% de linhas duplicadas (o sistema reenviou o pedido)
- 3% de status escritos fora do padrão (
"ENTREGUE ","Enviado")
- 0,5% de pedidos sem valor
python3 gerar_pedidos.py --dias 90 --pedidos-por-dia 20000 --ate 2026-10-28 --saida ./dadosIsso cria 90 arquivos em
dados/raw/pedidos/AAAA-MM-DD/pedidos.csv , com cerca de 1,8 milhão de linhas no total. Um trecho:pedido_id,cliente_id,produto,categoria,quantidade,valor_total,status,criado_eme2403194-91d1-4b8b-8a53-6a38bdf02c66,C023207,Tapete de yoga,Esporte,2,238.56,entregue,2026-10-28 15:52:47f2326c02-9a74-40ec-9f59-e5c729c91a68,C027103,Vestido,Moda,1,118.08,entregue,2026-10-28 11:58:40Passo 1: buckets e variáveis
Nomes de bucket são únicos no mundo inteiro, então eu uso o ID da conta como sufixo. São dois buckets: um para o data lake e outro só para os resultados do Athena.
export AWS_REGION=us-east-1export CONTA=$(aws sts get-caller-identity --query Account --output text)export BUCKET=meu-datalake-loja-$CONTA
aws s3 mb s3://$BUCKETaws s3 mb s3://$BUCKET-athena
# Sobe a camada rawaws s3 sync ./dados/raw/ s3://$BUCKET/raw/Buckets novos já nascem privados (Block Public Access ativado) e com criptografia SSE-S3 por padrão. Não precisa fazer nada extra para ter o mínimo de segurança que a gente definiu na Parte 1.
Passo 2: a role do Glue (menor privilégio)
O Glue precisa de uma role para ler e escrever no S3. Aqui está o primeiro lugar onde dá pra fazer do jeito fácil (dar
s3:* em tudo) ou do jeito certo. Vamos do jeito certo: o Glue lê raw/ e scripts/ , e escreve só em processed/ e tmp/ .iam/glue-s3-policy.json :{ "Version": "2012-10-17", "Statement": [ { "Sid": "ListarBucket", "Effect": "Allow", "Action": "s3:ListBucket", "Resource": "arn:aws:s3:::SEU_BUCKET" }, { "Sid": "LerRawEScripts", "Effect": "Allow", "Action": "s3:GetObject", "Resource": ["arn:aws:s3:::SEU_BUCKET/raw/*", "arn:aws:s3:::SEU_BUCKET/scripts/*"] }, { "Sid": "EscreverProcessed", "Effect": "Allow", "Action": ["s3:GetObject", "s3:PutObject", "s3:DeleteObject"], "Resource": "arn:aws:s3:::SEU_BUCKET/processed/*" }, { "Sid": "ArquivosTemporariosDoGlue", "Effect": "Allow", "Action": ["s3:GetObject", "s3:PutObject", "s3:DeleteObject"], "Resource": "arn:aws:s3:::SEU_BUCKET/tmp/*" } ]}Criando a role:
aws iam create-role --role-name GlueDataLakeLoja \ --assume-role-policy-document file://iam/glue-trust-policy.json
# Permissões base do Glue (catálogo, logs no CloudWatch)aws iam attach-role-policy --role-name GlueDataLakeLoja \ --policy-arn arn:aws:iam::aws:policy/service-role/AWSGlueServiceRole
# Acesso ao nosso bucket, só nos prefixos certossed "s/SEU_BUCKET/$BUCKET/g" iam/glue-s3-policy.json > policy.jsonaws iam put-role-policy --role-name GlueDataLakeLoja \ --policy-name AcessoDataLake --policy-document file://policy.json
export ROLE_ARN=arn:aws:iam::$CONTA:role/GlueDataLakeLojaO arquivo
glue-trust-policy.json só diz que o serviço glue.amazonaws.com pode assumir essa role. Ele está no repositório.Passo 3: descobrir o schema do CSV com o Crawler
Lembra que na Parte 1 eu disse que o crawler ainda é útil "na primeira vez"? É aqui. Ele lê o CSV, infere as colunas e cria uma tabela no catálogo. Uso o prefixo
raw_ para não confundir com a tabela final.aws glue create-database --database-input '{"Name":"loja_datalake"}'
aws glue create-crawler --name crawler-raw-pedidos \ --role $ROLE_ARN \ --database-name loja_datalake \ --table-prefix raw_ \ --targets "{\"S3Targets\":[{\"Path\":\"s3://$BUCKET/raw/pedidos/\"}]}"
aws glue start-crawler --name crawler-raw-pedidos
# Repita até voltar READYaws glue get-crawler --name crawler-raw-pedidos --query Crawler.StateResultado: uma tabela
raw_pedidos no banco loja_datalake . Como as pastas do raw se chamam só 2026-10-28 (e não dt=2026-10-28 ), o crawler cria uma partição genérica chamada partition_0 . Funciona, mas é mais um motivo para ninguém consultar o raw no dia a dia.Vale abrir a tabela no console do Glue e conferir os tipos que ele inferiu. Inferência é palpite: por isso, no Glue Job, eu não confio nela e defino os tipos na mão.
Passo 4: o Glue Job (CSV para Parquet particionado)
Esse é o coração do pipeline. O script faz quatro coisas: lê tudo como texto, limpa e tipa, cria a coluna de partição e grava em Parquet.
glue/csv_to_parquet.py :import sys
from awsglue.context import GlueContextfrom awsglue.job import Jobfrom awsglue.utils import getResolvedOptionsfrom pyspark.context import SparkContextfrom pyspark.sql import functions as F
args = getResolvedOptions(sys.argv, ["JOB_NAME", "SOURCE_PATH", "TARGET_PATH"])
sc = SparkContext()glue = GlueContext(sc)spark = glue.spark_sessionjob = Job(glue)job.init(args["JOB_NAME"], args)
# Sobrescreve só as partições (dias) que vierem nesta execução, sem apagar o restospark.conf.set("spark.sql.sources.partitionOverwriteMode", "dynamic")
# 1. Leitura: tudo como texto. Quem define os tipos somos nós, não a inferência.bruto = ( spark.read .option("header", "true") .option("recursiveFileLookup", "true") .csv(args["SOURCE_PATH"]))
# 2. Limpeza e tipagempedidos = ( bruto .withColumn("status", F.lower(F.trim(F.col("status")))) .withColumn("quantidade", F.col("quantidade").cast("int")) .withColumn("valor_total", F.col("valor_total").cast("decimal(10,2)")) .withColumn("criado_em", F.to_timestamp("criado_em", "yyyy-MM-dd HH:mm:ss")) .filter(F.col("valor_total").isNotNull() & F.col("criado_em").isNotNull()) .filter(F.col("status").isin("entregue", "enviado", "cancelado")) .dropDuplicates(["pedido_id"]) # 3. Coluna de partição derivada da data do pedido .withColumn("dt", F.date_format("criado_em", "yyyy-MM-dd")))
# 4. Escrita: Parquet comprimido, um arquivo por dia (volume pequeno por dia)( pedidos .repartition("dt") .write .mode("overwrite") .partitionBy("dt") .option("compression", "snappy") .parquet(args["TARGET_PATH"]))
job.commit()Três detalhes que fazem diferença:
-
partitionOverwriteMode = dynamic: sem isso,mode("overwrite")apaga todo oprocessed/a cada execução. Com ele, o job só reescreve os dias que processou. Rodar o job duas vezes não duplica dados nem apaga histórico.
-
dropDuplicates(["pedido_id"]): resolve o reenvio do sistema. A chave de negócio é opedido_id, não a linha inteira.
-
repartition("dt"): junta os dados de cada dia antes de escrever, gerando um arquivo por partição em vez de dezenas de arquivos pequenos (a Decisão 5 da Parte 1).
Agora, subir o script, criar e rodar o job:
aws s3 cp glue/csv_to_parquet.py s3://$BUCKET/scripts/
aws glue create-job --name csv-to-parquet \ --role $ROLE_ARN \ --glue-version 5.0 \ --worker-type G.1X --number-of-workers 2 \ --command "{\"Name\":\"glueetl\",\"ScriptLocation\":\"s3://$BUCKET/scripts/csv_to_parquet.py\",\"PythonVersion\":\"3\"}" \ --default-arguments "{\"--SOURCE_PATH\":\"s3://$BUCKET/raw/pedidos/\",\"--TARGET_PATH\":\"s3://$BUCKET/processed/pedidos/\",\"--TempDir\":\"s3://$BUCKET/tmp/\"}"
aws glue start-job-run --job-name csv-to-parquet
# Acompanhe o status (RUNNING -> SUCCEEDED)aws glue get-job-runs --job-name csv-to-parquet --query "JobRuns[0].JobRunState"Dois workers G.1X são mais que suficientes para esse volume. Quando terminar, o
processed/ fica assim:processed/pedidos/dt=2026-07-31/part-00000-....snappy.parquetprocessed/pedidos/dt=2026-08-01/part-00000-....snappy.parquet...processed/pedidos/dt=2026-10-28/part-00000-....snappy.parquetNa minha simulação, a limpeza removeu 27.151 linhas (cerca de 1,5% do total), entre duplicadas, sem valor e com status inválido. Imagina essas linhas somando no faturamento do dashboard.
Passo 5: workgroup e tabela no Athena
Primeiro, o workgroup com o "freio de mão" que a gente definiu na Parte 1: resultados num bucket próprio e limite de 1 GB lido por consulta.
aws athena create-work-group --name datalake-loja \ --configuration "ResultConfiguration={OutputLocation=s3://$BUCKET-athena/},EnforceWorkGroupConfiguration=true,BytesScannedCutoffPerQuery=1073741824"No console do Athena, selecione o workgroup datalake-loja e crie a tabela final com partition projection (troque
SEU_BUCKET pelo nome do seu bucket):CREATE EXTERNAL TABLE loja_datalake.pedidos ( pedido_id string, cliente_id string, produto string, categoria string, quantidade int, valor_total decimal(10,2), status string, criado_em timestamp)PARTITIONED BY (dt string)STORED AS PARQUETLOCATION 's3://SEU_BUCKET/processed/pedidos/'TBLPROPERTIES ( 'projection.enabled' = 'true', 'projection.dt.type' = 'date', 'projection.dt.format' = 'yyyy-MM-dd', 'projection.dt.range' = '2026-01-01,NOW', 'projection.dt.interval' = '1', 'projection.dt.interval.unit' = 'DAYS', 'storage.location.template' = 's3://SEU_BUCKET/processed/pedidos/dt=${dt}/');Repara que não tem
MSCK REPAIR , não tem crawler rodando no processed/ . Amanhã, quando o job gravar dt=2026-10-29 , a partição já existe para o Athena.Passo 6: a prova (CSV vs Parquet)
Agora a parte divertida. A mesma pergunta, nas duas tabelas: faturamento por categoria nos últimos 30 dias.
A) Direto no CSV (tabela do crawler):
SELECT categoria, SUM(TRY_CAST(CAST(valor_total AS varchar) AS decimal(10,2))) AS faturamentoFROM loja_datalake.raw_pedidosWHERE TRY_CAST(CAST(criado_em AS varchar) AS timestamp) >= TIMESTAMP '2026-09-29 00:00:00'GROUP BY categoriaORDER BY faturamento DESC;OsTRY_CASTestão ali porque não dá pra confiar no tipo que o crawler inferiu, e porque o CSV ainda tem as linhas sujas. Só isso já é um argumento a favor da camada processed.
B) No Parquet particionado:
SELECT categoria, SUM(valor_total) AS faturamentoFROM loja_datalake.pedidosWHERE dt BETWEEN '2026-09-29' AND '2026-10-28'GROUP BY categoriaORDER BY faturamento DESC;Depois de cada consulta, olhe o campo "Dados verificados" (Data scanned) no console. Ele é exatamente o que vai para a fatura.

Na simulação com os 90 dias de dados, a consulta no CSV precisa ler 175,4 MB (todos os arquivos, todas as colunas), enquanto no Parquet particionado lê cerca de 3,7 MB (30 partições, só
categoria e valor_total ). São 48 vezes menos dados. No Athena os números exatos podem variar um pouco, mas a ordem de grandeza é essa.Um detalhe curioso: com volumes tão pequenos, a consulta B cai no mínimo de cobrança de 10 MB do Athena. A diferença no bolso só aparece de verdade quando o volume cresce, e é justamente por isso que vale montar certo desde o começo: o desenho que funciona com 175 MB é o mesmo que funciona com 175 GB.
O que eu aprendi montando isso
1. A compressão sozinha não é a estrela. O Parquet total ficou só uns 40% menor que o CSV (101,7 MB contra 175,4 MB). Por quê? A coluna
pedido_id é um UUID aleatório, e dado aleatório não comprime. O ganho de 48x veio principalmente de ler só 2 colunas e só 30 partições. Formato colunar e particionamento importam mais que a taxa de compressão.2. Inferência de schema é ponto de partida, não destino. O crawler é ótimo para explorar, mas o contrato da tabela (tipos, regras de limpeza) tem que estar escrito no código.
3.
overwrite sem dynamic é uma armadilha. É o tipo de erro que só aparece quando alguém roda o job de novo e o histórico some.Erros comuns que você pode encontrar:
Sintoma | Causa provável |
|---|---|
AccessDenied no Glue Job | Faltou permissão em scripts/ ou tmp/ na policy da role |
Consulta no Athena retorna zero linhas | storage.location.template diferente do caminho real, ou datas fora do projection.dt.range |
Erro de limite de dados verificados | O freio de 1 GB do workgroup funcionando. Adicione filtro em dt |
Dados duplicados no processed/ | Job rodando sem partitionOverwriteMode = dynamic |
Quanto custou
Valores de referência em us-east-1:
- S3: algumas centenas de MB armazenados por poucos dias. Fração de centavo.
- Glue Crawler: US$ 0,44 por DPU-hora, com cobrança mínima de 10 minutos por execução. Alguns centavos.
- Glue Job: US$ 0,44 por DPU-hora. Dois workers G.1X por poucos minutos ficam na casa dos centavos.
- Athena: US$ 5 por TB lido, mínimo de 10 MB por consulta. Algumas dezenas de consultas aqui não chegam a 1 centavo.
Limpando tudo
Para não deixar nada cobrando:
aws glue delete-job --job-name csv-to-parquetaws glue delete-crawler --name crawler-raw-pedidosaws glue delete-database --name loja_datalakeaws athena delete-work-group --work-group datalake-loja --recursive-delete-optionaws s3 rb s3://$BUCKET --forceaws s3 rb s3://$BUCKET-athena --forceaws iam delete-role-policy --role-name GlueDataLakeLoja --policy-name AcessoDataLakeaws iam detach-role-policy --role-name GlueDataLakeLoja \ --policy-arn arn:aws:iam::aws:policy/service-role/AWSGlueServiceRoleaws iam delete-role --role-name GlueDataLakeLojaPróximos passos
O data lake está de pé, mas ainda roda "na mão". Alguns caminhos naturais a partir daqui, que pretendo explorar nos próximos artigos:
- Ingestão em streaming: em vez de um CSV por dia, pedidos chegando em tempo real com Kinesis Data Firehose
- Orquestração: rodar o job automaticamente quando um arquivo novo chega no raw
- Camada curated: tabelas agregadas com CTAS para alimentar dashboards
- Infraestrutura como código: subir tudo isso com um único comando
Se você reproduziu o laboratório, me conta nos comentários quanto deu o "Dados verificados" aí. E se está estudando para a AWS Cloud Practitioner, todo dia tem quiz rápido nos stories do Instagram (@foxflavio). Bora estudar junto! 🚀
Enjoyed reading this content? Let the author know!
Your likes, comments, shares, and saves help creators reach more builders.
Loading recommendations
Loading article