Pipeline ETL de Visualização de Filmes

A Importância dos Dados para IA e Machine Learning

Em um mundo cada vez mais orientado por dados, a capacidade de coletar, processar e extrair insights de informações brutas tornou-se um diferencial competitivo fundamental para organizações de todos os setores. Para aplicações de Inteligência Artificial (IA) e Machine Learning (ML), essa premissa é ainda mais crítica: a qualidade e a quantidade de dados disponíveis são os principais determinantes do sucesso de qualquer modelo.

Modelos de IA e ML são, em sua essência, "famintos por dados". Eles aprendem padrões, fazem previsões e tomam decisões com base nos exemplos que recebem durante o treinamento . Um modelo treinado com dados incompletos, desatualizados ou inconsistentes produzirá resultados tendenciosos, imprecisos e, em última análise, inúteis. É nesse contexto que o papel do Engenheiro de Dados se torna vital, sendo responsável por construir pipelines robustos que garantam um fluxo contínuo de dados de alta qualidade, desde sua origem até o destino final, seja ele um Data Warehouse, um Data Lake ou diretamente uma ferramenta de visualização .

O projeto movie-views-dashboard é um exemplo prático e bem estruturado de como construir um pipeline ETL (Extract, Transform, Load) para alimentar um dashboard analítico, utilizando tecnologias modernas como Apache Airflow e PostgreSQL. Este artigo explora em detalhes o projeto, suas funcionalidades, a arquitetura e seu potencial como base para futuras aplicações de IA e ML.

1. A Arquitetura do Pipeline

A arquitetura segue o padrão Star Schema (dimensional), com dados divididos entre tabelas dimensão e fato.

O Star Schema (ou Esquema em Estrela) é um padrão de modelagem de dados fundamental para Data Warehouses e Business Intelligence. Ele organiza as informações em uma tabela de fatos central (contendo métricas e números) cercada por tabelas de dimensões (contendo os contextos ou descrições).

Componentes Principais

• Tabela de Fatos: É o "coração" da estrela. Armazena as medidas quantitativas e numéricas de um evento de negócio (ex: valor da venda, quantidade de itens vendidos, tempo de atendimento). Ela também contém as "chaves estrangeiras" que se conectam às dimensões.

• Tabelas de Dimensão: São os "raios" da estrela. Armazenam o contexto descritivo das transações (o quem, o quê, onde e quando). Exemplos incluem tabelas de Clientes, Produtos, Lojas e Tempo/Data.

O projeto simula um cenário real de uma plataforma de streaming, onde dados de usuários, catálogo de filmes e eventos de visualização são gerados e processados. A escolha das tecnologias não é aleatória; cada componente desempenha um papel crucial na construção de um pipeline de dados eficiente e confiável.

Tecnologias Utilizadas

• Apache Airflow (Astro Runtime): O orquestrador central do pipeline. Ele gerencia a execução das tarefas, garantindo que cada etapa seja concluída na ordem correta e lidando com possíveis falhas. A Astro Runtime simplifica a execução do Airflow em ambientes Docker.
• PostgreSQL: O banco de dados relacional onde os dados transformados são armazenados de forma estruturada em tabelas dimensionais e fato, além de ser o local onde as views analíticas são criadas.
• Docker: Utilizado para containerizar toda a aplicação, garantindo consistência entre os ambientes de desenvolvimento e produção e simplificando o processo de configuração
• Python: A linguagem principal para a lógica das tarefas, utilizando a API TaskFlow do Airflow e a biblioteca Pandas para manipulação de dados.

Casos de Uso e Aplicações em IA/ML

Este pipeline ETL não é apenas um exercício acadêmico; ele serve como base para uma série de aplicações práticas e projetos de IA/ML. A estrutura de dados limpa e organizada que ele produz é o combustível para:

• Sistemas de Recomendação: Ao analisar os padrões de visualização, curtidas e avaliações, um modelo de ML pode aprender as preferências de cada usuário e sugerir filmes que ele provavelmente gostará.
• Análise de Engajamento de Usuários: Identificar quais usuários são mais ativos, os horários de pico de uso e os dispositivos mais populares permite que plataformas de streaming otimizem sua infraestrutura e personalizem a experiência do usuário.
• Análise de Popularidade de Conteúdo: Os dados de visualizações e avaliações podem alimentar modelos de previsão para ajudar estúdios a entender quais gêneros ou temáticas estão em alta, embasando decisões sobre novas produções .
• Detecção de Anomalias: A pipeline pode ser estendida para incluir monitores de qualidade de dados, que são cruciais para a confiabilidade dos modelos downstream . Por exemplo, um modelo de ML treinado com dados de avaliações pode ser comprometido se uma anomalia (como um pico repentino de visualizações de um mesmo usuário) não for detectada e tratada.

Funcionalidades do Pipeline

A DAG (Directed Acyclic Graph) movie_views_etl.py é o coração do projeto, orquestrando um fluxo de trabalho ETL completo. Vamos detalhar cada uma de suas etapas.

2. O Projeto no VS Code com Dev Containers

O projeto foi configurado para rodar dentro de um Dev Container no VS Code, garantindo que todo o time tenha o mesmo ambiente de desenvolvimento. A configuração está em .devcontainer/devcontainer.json e usa a imagem oficial Astro Runtime 3.3 da Astronomer.

{
    "name": "movie-views-dashboard",
    "build": {
        "dockerfile": "../Dockerfile",
        "context": ".."
    },
    "customizations": {
        "vscode": {
            "extensions": [
                "ms-python.python",
                "ms-python.vscode-pylance",
                "ms-azuretools.vscode-docker",
                "astro-build.astro-vscode"
            ]
        }
    },
    "postCreateCommand": "pip install -r requirements.txt",
    "remoteUser": "astro"
}

Vantagens do Dev Container:

• Ambiente isolado e reproduzível
• Dependências Python pré-instaladas
• Extensões do VS Code já configuradas
• Montagem do socket Docker para comandos astro

3. A DAG: movie_views_etl

A DAG foi construída usando a TaskFlow API do Airflow, que permite definir tarefas como funções Python decoradas com @task. O agendamento está definido como schedule=None (execução manual), ideal para pipelines sob demanda ou acionados por eventos.

@dag(
    start_date=datetime(2025, 7, 1),
    schedule=None,
    catchup=False,
    default_args={"owner": "Astro", "retries": 2},
    tags=["etl", "movies", "dashboard"],
)
def movie_views_etl():
    ...

Dependências entre as tasks

tables_created = create_tables()
users_loaded = tables_created >> load_users()
movies_loaded = tables_created >> load_movies()
views_loaded = [users_loaded, movies_loaded] >> load_views()
[users_loaded, movies_loaded, views_loaded] >> create_analytics_views()

O fluxo é:

1. create_tables() é executada primeiro
2. load_users() e load_movies() rodam em paralelo após as tabelas existirem
3. load_views() aguarda usuários e filmes carregados
4. create_analytics_views() executa por último, após tudo carregado

4. As Tasks em Detalhe

Criação das Tabelas (DDL)

A primeira tarefa da DAG é executar o script SQL create_tables.sql, que estabelece o schema do banco de dados. A modelagem segue o padrão dimensional estrela, com três tabelas principais:

• dim_users: Tabela dimensional contendo dados dos usuários (ID, nome, idade, sexo, país, dispositivo, etc.).
• dim_movies: Tabela dimensional com o catálogo de filmes (ID, título, gênero, ano de lançamento, duração, etc.).
• fact_views: Tabela fato que registra cada evento de visualização, contendo chaves estrangeiras para as dimensões e métricas como watch_time, progress, liked e timestamp.

Esta estrutura é fundamental para análises rápidas e eficientes, pois pré-join as informações necessárias para as consultas analíticas.

O uso de técnicas de pré-junção (ou pré-join) e desnormalização de dados é uma excelente estratégia para modelagem analítica. Ao cruzar e armazenar informações antecipadamente, você elimina a necessidade de recalcular junções complexas em tempo de execução, reduzindo drasticamente o consumo de processamento e o tempo de resposta das consultas.

Carregamento de Dados (ETL)

A etapa de carga é dividida em três tarefas principais:

• Carregar Usuários: Lê o arquivo users.json e insere os dados na tabela dim_users.
• Carregar Catálogo: Lê o arquivo movie_catalog.json e insere os dados na tabela dim_movies.
• Carregar Visualizações: Lê o arquivo views.json e insere os dados na tabela fact_views. É importante que esta tarefa seja executada após as duas primeiras para garantir a integridade referencial, assegurando que o user_id e movie_id existam nas tabelas dimensionais.

Para fins de estudo eu optei simplesmente por carregar arquivos JSON, em um caso real pode ser uma API, uma Data Wharehouse e etc.

Criação de Views Analíticas

A etapa final do pipeline é a criação de views analíticas, que são "consultas salvas" que se comportam como tabelas virtuais. Elas abstraem a complexidade dos joins e agregações, fornecendo dados prontos para serem consumidos por ferramentas de BI como o Looker Studio . As views criadas pelo projeto são:

• vw_user_kpi: Fornece KPIs por usuário, como total de filmes assistidos, tempo médio de visualização e dias ativos.
• vw_genre_analysis: Analisa o comportamento dos usuários por gênero de filme.
• vw_daily_views: Mostra a tendência diária de visualizações, um dado valioso para análise de séries temporais.
• vw_device_analysis: Agrega métricas por dispositivo (Desktop, Mobile, TV) e navegador.
• vw_movie_popularity: Uma visão geral da popularidade de cada filme com base em visualizações, curtidas e progresso médio.
• vw_user_sessions: Identifica sessões de visualização por usuário.
• vw_age_range_analysis: Agrupa visualizações por faixa etária, um dado demográfico crucial.

4.1 create_tables()

Executa o script SQL create_tables.sql que cria as tabelas dimensionais e a fato usando CREATE TABLE IF NOT EXISTS. Também adiciona colunas novas com ALTER TABLE ADD COLUMN IF NOT EXISTS para compatibilidade retroativa.

CREATE TABLE IF NOT EXISTS dim_users (
    user_id VARCHAR(100) PRIMARY KEY,
    full_name VARCHAR(200), first_name VARCHAR(100), last_name VARCHAR(100),
    email VARCHAR(200), gender VARCHAR(20), age INT,
    country VARCHAR(100), city VARCHAR(200),
    registered_date DATE, phone VARCHAR(50), cell VARCHAR(50),
    nationality VARCHAR(10), picture_url VARCHAR(500)
);

CREATE TABLE IF NOT EXISTS dim_movies (
    movie_id VARCHAR(50) PRIMARY KEY,
    title VARCHAR(500), content_type VARCHAR(50), release_year INT,
    genres TEXT, director VARCHAR(200), country VARCHAR(100),
    language VARCHAR(100), imdb_rating NUMERIC(3,1),
    cast_text TEXT, synopsis TEXT
);

CREATE TABLE IF NOT EXISTS fact_views (
    view_id VARCHAR(50) PRIMARY KEY,
    user_id VARCHAR(100) REFERENCES dim_users(user_id),
    movie_id VARCHAR(50) REFERENCES dim_movies(movie_id),
    timestamp TIMESTAMP, date DATE, time TIME,
    duration_seconds INT, duration_minutes NUMERIC(10,2),
    view_type VARCHAR(20), device VARCHAR(50),
    browser VARCHAR(50), platform VARCHAR(50),
    liked BOOLEAN, rating INT, wishlist_added BOOLEAN,
    favorite_added BOOLEAN, shared BOOLEAN,
    session_id VARCHAR(100), ip_address VARCHAR(50),
    referrer VARCHAR(500), watch_progress INT,
    quality VARCHAR(10), buffering_events INT,
    seeks_forward INT, seeks_backward INT
);

4.2 load_users()

Carrega dados de 100 usuários simulados a partir de include/data/users.json (dados da Random User Generator API). Os dados são extraídos, transformados para o formato esperado pela tabela dim_users e inseridos via PostgresHook.insert_rows().

Dados extraídos por usuário: uuid, nome completo, email, gênero, idade, país, cidade, data de registro, telefone, nacionalidade, URL da foto.

Antes da inserção, a tabela é truncada para garantir idempotência. Serve para esse caso, pois se trata de uma tabela pequena.

4.3 load_movies()

Processa o catálogo de filmes a partir de include/data/movie_catalog.json. Cada filme contém informações como título, ano de lançamento, gêneros, diretor, elenco, avaliação IMDb e sinopse.

4.4 load_views()

A task mais robusta, processa milhares de eventos de visualização aninhados em uma estrutura JSON complexa:

• view_details: timestamp, duração, tipo de visualização (full/partial/preview)
• interaction: like, rating, wishlist, favorite, compartilhamento
• session: ID de sessão, IP, referrer
• metrics: progresso, qualidade, eventos de buffering, seeks

Cada view é vinculada a um user (via UUID) e a um movie (via IMDb ID), estabelecendo as relações da estrela.

4.5 create_analytics_views()

Executa o script create_views.sql que cria 7 views analíticas:

5. Modelagem de Dados: Star Schema

O modelo segue o padrão dimensional (Star Schema), ideal para análises e dashboards:

Por que Star Schema?

• Consultas mais rápidas (menos joins)
• Intuitivo para analistas de negócios
• Compatível com ferramentas de BI como Looker Studio
• Facilita a criação de cubos OLAP

6. Integração com Google Looker Studio

O banco PostgreSQL foi conectado via ngrok ao Google Looker Studio como fonte de dados, permitindo a criação de dashboards interativos sem necessidade de código SQL adicional.

A capacidade de conectar o pipeline ETL a uma ferramenta de visualização é o que torna os dados acionáveis. O projeto movie-views-dashboard integra-se perfeitamente ao Google Looker Studio (antigo Data Studio), uma ferramenta de BI gratuita e poderosa .

Veja um exemplo de dashboard (URL encurtado) que demonstra o potencial analítico dos dados processados. Para conectar seu próprio Looker Studio:

1. Acesse o Looker Studio e crie uma nova fonte de dados.
2. Selecione o conector PostgreSQL.
3. Configure a conexão com o banco de dados PostgreSQL onde seu pipeline carregou os dados (host, porta, banco, usuário, senha).
4. Escolha uma das views analíticas (vw_daily_views, vw_movie_popularity, etc.) como a tabela para o seu relatório.
5. Crie gráficos e relatórios a partir dos dados disponíveis.

A beleza dessa integração está na separação de responsabilidades: o Airflow garante que os dados estejam sempre atualizados e estruturados, enquanto o Looker Studio fornece a camada de apresentação e exploração interativa .

Exemplo de relatório público: Visualizar online

Métricas disponíveis no dashboard:

• Total de Visualizações por período
• Usuários Ativos por dia/semana/mês
• Filmes Mais Populares (rank por visualizações e likes)
• Distribuição por Dispositivo (Desktop, Mobile, Tablet, Smart TV)
• Análise por Faixa Etária (qual público consome mais?)
• Gêneros Preferidos por perfil de usuário
• Taxa de Engajamento (likes, compartilhamentos, wishlist)

7. A Importância dos Dados para IA e Machine Learning

O pipeline ETL apresentado não serve apenas para dashboards — ele é a base para qualquer iniciativa de Inteligência Artificial e Machine Learning. Dados estruturados, limpos e atualizados são o combustível de modelos preditivos.

Por que isso importa?

"Sem dados de qualidade, o melhor algoritmo do mundo não passa de teoria."

Preparação para Modelos Preditivos

As views analíticas já entregam features prontas que podem alimentar modelos de ML:

-- Feature: engajamento do usuário (já calculada na view)
vw_user_kpi.total_movies_watched
vw_user_kpi.avg_watch_progress_pct
vw_user_kpi.liked_movies_count

-- Feature: popularidade do filme (já calculada na view)
vw_movie_popularity.total_views
vw_movie_popularity.avg_watch_progress
vw_movie_popularity.likes_count

8. Casos de Uso para esta ETL

8.1 Sistema de Recomendação

Com os dados de visualizações, curtidas e avaliações, é possível treinar modelos de filtragem colaborativa ou filtragem baseada em conteúdo:

# Exemplo: matriz usuário-item para recomendação
# Extraído de fact_views:
   user_id, movie_id, rating (1-10), liked (boolean)
# Algoritmo: SVD, KNN, ou Matrix Factorization

Features disponíveis:

• Histórico de visualizações por usuário
• Preferências por gênero (vw_genre_analysis)
• Faixa etária e localização
• Dispositivo e horário de acesso

8.2 Previsão de Churn (Cancelamento)

Identificar usuários com risco de abandono com base em:

• Queda no número de visualizações semanais
• Redução no tempo médio de sessão
• Diminuição na taxa de engajamento (likes, compartilhamentos)
• Aumento de buffering events (possível insatisfação técnica)

8.3 Otimização de Conteúdo

Decisões baseadas em dados para aquisição e produção de conteúdo:

• Que gêneros têm maior taxa de retenção?
• Filmes com quais atores/diretores geram mais engajamento?
• Qual o melhor horário para lançar um novo título?
• Qual faixa etária é mais impactada por cada gênero?

8.4 Segmentação de Audiência

Usando vw_age_range_analysis e vw_user_kpi, é possível criar clusters de usuários:

-- Segmentos comportamentais (lógica de negócio)
CASE
    WHEN total_movies_watched > 50 AND avg_watch_progress > 80 THEN 'Power User'
    WHEN liked_movies_count > 10 THEN 'Engajado'
    WHEN total_movies_watched < 5 THEN 'Novato'
    ELSE 'Casual'
END AS user_segment

9. Conclusão

Este projeto demonstra como construir um pipeline de dados completo e production-ready usando ferramentas modernas e acessíveis:

• Apache Airflow para orquestração confiável de tarefas
• PostgreSQL como banco analítico robusto e gratuito
• Google Looker Studio para visualização sem custo de licença
• VS Code Dev Containers para ambiente padronizado de desenvolvimento
• Astro CLI para gerenciamento simples de projetos no Apache Airflow

A estrutura Star Schema, combinada com views analíticas bem projetadas, permite que analistas de negócios consumam dados diretamente sem escrever SQL complexo — enquanto times de dados têm uma base sólida para alimentar modelos de Machine Learning.

"Dados não são apenas números. São o reflexo do comportamento humano. Entregá-los de forma estruturada e acessível é o que separa empresas que reagem do passado daquelas que antecipam o futuro."

Projeto completo no Github: Acessar

Referências

• Apache Airflow Documentation
• Astronomer Docs - Astro CLI
• PostgreSQL Documentation
• Google Looker Studio
• Random User Generator API
• Astronomer - VS Code Local Dev