<h2>Entendendo Redshift e Athena: Duas Abordagens para Data Warehouse</h2>
<p>Redshift e Athena são soluções complementares da AWS para análise de dados em escala. Redshift é um data warehouse tradicional baseado em clusters com armazenamento próprio, otimizado para queries complexas e alta concorrência. Athena, por sua vez, é uma solução serverless que consulta dados diretamente no S3 sem infraestrutura dedicada, pagando apenas pelas queries executadas.</p>
<p>A escolha entre elas depende do padrão de uso: Redshift brilha em análises contínuas com milhares de queries diárias, enquanto Athena é ideal para consultas ad-hoc, exploração de dados ou quando você não quer gerenciar clusters. Em projetos reais, muitas empresas usam ambas complementarmente — Athena para exploração inicial e Redshift para operações críticas.</p>
<h2>Configurando Athena: Query Serverless no S3</h2>
<h3>Estrutura de Dados e Particionamento</h3>
<p>Antes de rodar a primeira query, organize seus dados no S3 com uma estrutura apropriada. Particionamento é essencial: dados organizados como <code>s3://seu-bucket/dados/ano=2024/mês=01/arquivo.parquet</code> permitem que Athena pule partições inteiras, reduzindo custos drasticamente.</p>
<pre><code class="language-python">import boto3
import pandas as pd
from datetime import datetime
s3 = boto3.client('s3')
athena = boto3.client('athena')
Salvar dados particionados no S3
df = pd.read_csv('vendas.csv')
df['ano'] = df['data'].dt.year
df['mes'] = df['data'].dt.month
for (ano, mes), grupo in df.groupby(['ano', 'mes']):
caminho = f"s3://meu-bucket/vendas/ano={ano}/mes={mes:02d}/dados.parquet"
grupo.to_parquet(caminho)</code></pre>
<h3>Criando Tabelas e Executando Queries</h3>
<p>Athena usa Apache Trino (antigo Presto) para SQL. Crie uma tabela external apontando para seus dados no S3 e comece a consultar imediatamente.</p>
<pre><code class="language-sql">CREATE EXTERNAL TABLE IF NOT EXISTS vendas (
id STRING,
cliente STRING,
valor DECIMAL(10,2),
data STRING
)
PARTITIONED BY (ano INT, mes INT)
STORED AS PARQUET
LOCATION 's3://meu-bucket/vendas/'
TBLPROPERTIES ('parquet.compression'='SNAPPY');
-- Executar query
SELECT cliente, SUM(valor) as total
FROM vendas
WHERE ano = 2024 AND mes = 1
GROUP BY cliente
ORDER BY total DESC;</code></pre>
<pre><code class="language-python"># Executar query via boto3
response = athena.start_query_execution(
QueryString="SELECT COUNT(*) FROM vendas WHERE ano=2024",
QueryExecutionContext={'Database': 'default'},
ResultConfiguration={'OutputLocation': 's3://meu-bucket/resultados/'},
WorkGroup='primary'
)
query_id = response['QueryExecutionId']
Aguardar resultado
while True:
result = athena.get_query_execution(QueryExecutionId=query_id)
if result['QueryExecution']['Status']['State'] != 'RUNNING':
break</code></pre>
<h2>Implementando Redshift para Análises em Escala</h2>
<h3>Arquitetura e Schema Design</h3>
<p>Redshift usa compressão colunar e é otimizado para OLAP (Online Analytical Processing). Crie distribuição de dados baseada em suas queries mais frequentes — escolha uma coluna com alta cardinalidade como distribution key para evitar skew.</p>
<pre><code class="language-sql">-- Criar tabela com distribuição e sort key
CREATE TABLE vendas (
id BIGINT NOT NULL,
cliente_id INT NOT NULL,
valor DECIMAL(12,2),
data DATE NOT NULL
)
DISTKEY (cliente_id)
SORTKEY (data);
-- Criar índice para melhor performance
CREATE INDEX idx_vendas_data ON vendas(data);</code></pre>
<p>Redshift também suporta Spectrum, que consulta dados diretamente do S3 quando necessário, complementando o armazenamento local do cluster.</p>
<h3>ETL Eficiente com COPY e Unload</h3>
<p>Carregue dados em massa com o comando COPY (muito mais rápido que INSERT) e exporte com UNLOAD para S3 em paralelo.</p>
<pre><code class="language-sql">-- Carregar dados do S3 para Redshift
COPY vendas
FROM 's3://meu-bucket/dados/vendas_2024.parquet'
IAM_ROLE 'arn:aws:iam::ACCOUNT:role/RedshiftRole'
FORMAT PARQUET;
-- Unload (exportar) resultados para S3
UNLOAD (
SELECT cliente, SUM(valor) as total
FROM vendas
WHERE ano = 2024
GROUP BY cliente
)
TO 's3://meu-bucket/resultados/relatorio_2024/'
IAM_ROLE 'arn:aws:iam::ACCOUNT:role/RedshiftRole'
FORMAT PARQUET;</code></pre>
<pre><code class="language-python"># Conectar e executar queries em Redshift
import psycopg2
conn = psycopg2.connect(
host='seu-cluster.redshift.amazonaws.com',
port=5439,
database='analytics',
user='admin',
password='sua_senha'
)
cursor = conn.cursor()
cursor.execute("SELECT COUNT(*) FROM vendas;")
resultado = cursor.fetchone()
print(f"Total de registros: {resultado[0]}")
conn.close()</code></pre>
<h2>Integrando Athena e Redshift em Pipelines Reais</h2>
<h3>Padrão de Arquitetura Híbrida</h3>
<p>Em um pipeline típico: Athena explora dados brutos no S3, identifica padrões, então carrega dados limpos no Redshift para análises operacionais. Use Glue Crawlers para manter o Athena Catalog sincronizado automaticamente com novos arquivos.</p>
<pre><code class="language-python">import boto3
from awsglue.transforms import *
from awsglue.dynamicframe import DynamicFrame
glue = boto3.client('glue')
Iniciar crawler para descobrir novos dados
glue.start_crawler(Name='crawler-vendas')
Usar script Glue para ETL
glue_context = GlueContext(SparkContext.getOrCreate())
datasource = glue_context.create_dynamic_frame.from_catalog(
database='vendas_db',
table_name='vendas_raw'
)
Filtrar e transformar
filtrado = Filter.apply(
frame=datasource,
f=lambda x: x['valor'] > 100
)
Carregar em Redshift
glue_context.write_dynamic_frame.from_jdbc_conf(
frame=filtrado,
catalog_connection='redshift-connection',
connection_options={'dbtable': 'vendas_processadas', 'database': 'analytics'}
)</code></pre>
<h3>Monitoramento e Otimização de Custos</h3>
<p>Athena cobra por terabyte de dados escaneados — otimize usando partições, colunas específicas e formatos comprimidos (Parquet > CSV). Redshift cobra por hora de cluster — dimensione clusters adequadamente e use reserved instances para descontos.</p>
<pre><code class="language-python"># Verificar custos de queries Athena
response = athena.list_query_executions()
total_bytes = 0
for query_id in response['QueryExecutionIds'][:100]:
stats = athena.get_query_execution(QueryExecutionId=query_id)
bytes_scanned = stats['QueryExecution']['Statistics']['DataScannedInBytes']
total_bytes += bytes_scanned
custo_estimado = (total_bytes / 1e12) * 5 # $5 por TB
print(f"Custo estimado das últimas 100 queries: ${custo_estimado:.2f}")</code></pre>
<h2>Conclusão</h2>
<p><strong>Primeiro aprendizado:</strong> Redshift e Athena não competem, mas complementam-se. Use Athena para exploração rápida e sem infraestrutura, Redshift para cargas analíticas pesadas com concorrência. <strong>Segundo:</strong> Estruture dados com particionamento inteligente no S3 — isso reduz custos exponencialmente em Athena. <strong>Terceiro:</strong> Implemente monitoramento de custos desde o início; otimizações pequenas em queries e retenção de dados têm impacto financeiro significativo em escala.</p>
<h2>Referências</h2>
<ul>
<li><a href="https://docs.aws.amazon.com/athena/" target="_blank" rel="noopener noreferrer">AWS Athena Documentation</a></li>
<li><a href="https://docs.aws.amazon.com/redshift/latest/dg/welcome.html" target="_blank" rel="noopener noreferrer">Amazon Redshift Architecture Guide</a></li>
<li><a href="https://docs.aws.amazon.com/glue/latest/dg/best-practices.html" target="_blank" rel="noopener noreferrer">AWS Glue ETL Best Practices</a></li>
<li><a href="https://parquet.apache.org/docs/" target="_blank" rel="noopener noreferrer">Parquet Format Specification</a></li>
<li><a href="https://www.oreilly.com/library/view/fundamentals-of-data/9781098108298/" target="_blank" rel="noopener noreferrer">Fundamentals of Data Engineering - O'Reilly</a></li>
</ul>