AWS Admin

Dominando Redshift e Athena: Data Warehouse e Query Serverless em S3 em Projetos Reais Já leu

Entendendo Redshift e Athena: Duas Abordagens para Data Warehouse 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. 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. Configurando Athena: Query Serverless no S3 Estrutura de Dados e Particionamento Antes de rodar a primeira query, organize seus dados no S3 com uma estrutura apropriada. Particionamento é essencial: dados organizados como permitem que Athena pule partições inteiras, reduzindo custos drasticamente. Criando

Entendendo Redshift e Athena: Duas Abordagens para Data Warehouse

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.

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.

Configurando Athena: Query Serverless no S3

Estrutura de Dados e Particionamento

Antes de rodar a primeira query, organize seus dados no S3 com uma estrutura apropriada. Particionamento é essencial: dados organizados como s3://seu-bucket/dados/ano=2024/mês=01/arquivo.parquet permitem que Athena pule partições inteiras, reduzindo custos drasticamente.

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)

Criando Tabelas e Executando Queries

Athena usa Apache Trino (antigo Presto) para SQL. Crie uma tabela external apontando para seus dados no S3 e comece a consultar imediatamente.

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;

# 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

Implementando Redshift para Análises em Escala

Arquitetura e Schema Design

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.

-- 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);

Redshift também suporta Spectrum, que consulta dados diretamente do S3 quando necessário, complementando o armazenamento local do cluster.

ETL Eficiente com COPY e Unload

Carregue dados em massa com o comando COPY (muito mais rápido que INSERT) e exporte com UNLOAD para S3 em paralelo.

-- 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;

# 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()

Integrando Athena e Redshift em Pipelines Reais

Padrão de Arquitetura Híbrida

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.

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'}
)

Monitoramento e Otimização de Custos

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.

# 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}")

Conclusão

Primeiro aprendizado: 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. Segundo: Estruture dados com particionamento inteligente no S3 — isso reduz custos exponencialmente em Athena. Terceiro: 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.

Referências

Artigos relacionados