AWS Builder Center
Data lake serverless na AWS na prática: do CSV ao SQL com S3, Glue e Athena [Parte 2]

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.

Big Data & AI R&D | Cloud Data Engineering | Data Science & AI | Systems Analysis & Development
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.
Arquitetura do data lake com S3, Glue e Athena


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 ./dados
Isso 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_em
e2403194-91d1-4b8b-8a53-6a38bdf02c66,C023207,Tapete de yoga,Esporte,2,238.56,entregue,2026-10-28 15:52:47
f2326c02-9a74-40ec-9f59-e5c729c91a68,C027103,Vestido,Moda,1,118.08,entregue,2026-10-28 11:58:40

Passo 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-1
export CONTA=$(aws sts get-caller-identity --query Account --output text)
export BUCKET=meu-datalake-loja-$CONTA

aws s3 mb s3://$BUCKET
aws s3 mb s3://$BUCKET-athena

# Sobe a camada raw
aws 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 certos
sed "s/SEU_BUCKET/$BUCKET/g" iam/glue-s3-policy.json > policy.json
aws iam put-role-policy --role-name GlueDataLakeLoja \
--policy-name AcessoDataLake --policy-document file://policy.json

export ROLE_ARN=arn:aws:iam::$CONTA:role/GlueDataLakeLoja
O 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 READY
aws glue get-crawler --name crawler-raw-pedidos --query Crawler.State
Resultado: 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 GlueContext
from awsglue.job import Job
from awsglue.utils import getResolvedOptions
from pyspark.context import SparkContext
from pyspark.sql import functions as F

args = getResolvedOptions(sys.argv, ["JOB_NAME", "SOURCE_PATH", "TARGET_PATH"])

sc = SparkContext()
glue = GlueContext(sc)
spark = glue.spark_session
job = Job(glue)
job.init(args["JOB_NAME"], args)

# Sobrescreve só as partições (dias) que vierem nesta execução, sem apagar o resto
spark.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 tipagem
pedidos = (
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 o  processed/  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 é o  pedido_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.parquet
processed/pedidos/dt=2026-08-01/part-00000-....snappy.parquet
...
processed/pedidos/dt=2026-10-28/part-00000-....snappy.parquet
Na 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 PARQUET
LOCATION '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 faturamento
FROM loja_datalake.raw_pedidos
WHERE TRY_CAST(CAST(criado_em AS varchar) AS timestamp) >= TIMESTAMP '2026-09-29 00:00:00'
GROUP BY categoria
ORDER BY faturamento DESC;
Os  TRY_CAST  estã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 faturamento
FROM loja_datalake.pedidos
WHERE dt BETWEEN '2026-09-29' AND '2026-10-28'
GROUP BY categoria
ORDER BY faturamento DESC;
Depois de cada consulta, olhe o campo "Dados verificados" (Data scanned) no console. Ele é exatamente o que vai para a fatura.
CSV lê 175,4 MB e Parquet particionado lê 3,68 MB, 48 vezes menos

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-parquet
aws glue delete-crawler --name crawler-raw-pedidos
aws glue delete-database --name loja_datalake
aws athena delete-work-group --work-group datalake-loja --recursive-delete-option
aws s3 rb s3://$BUCKET --force
aws s3 rb s3://$BUCKET-athena --force
aws iam delete-role-policy --role-name GlueDataLakeLoja --policy-name AcessoDataLake
aws iam detach-role-policy --role-name GlueDataLakeLoja \
--policy-arn arn:aws:iam::aws:policy/service-role/AWSGlueServiceRole
aws iam delete-role --role-name GlueDataLakeLoja

Pró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! 🚀
Any opinions in this article are those of the individual author and may not reflect the opinions of AWS.
Enjoyed reading this content? Let the author know!

Your likes, comments, shares, and saves help creators reach more builders.

Loading recommendations

Loading article