How gbaltar-uiab1/data_pipeline works
Tipo de proxecto e propósito (segundo README + árbore de ficheiros)
Este repo é un pipeline de datos “multibase” (ETL/ELT moi lixeiro) reproducible con Docker Compose + notebooks de Python (Jupyter). O obxectivo é coller un dataset (books.csv) e inxestalo/cargalo secuencialmente en varias tecnoloxías de almacenamento:
MongoDB
A “orquestración” do pipeline non está nun servizo backend clásico; está nos notebooks, e a infraestrutura das bases está en Docker Compose.
Análise da estrutura de ficheiros (o que debe reflectir a arquitectura)
Top-level (todo no root):
• docker-compose.yml: define os 4 servizos de base de datos (e potencialmente volumes/ports/network). É o “runtime” do sistema.
• books.csv: fonte de datos (input do pipeline).
• 1.CargarMySQL.ipynb: etapa 1 de carga/transformación cara MySQL.
• 2.CargarCassandra.ipynb: etapa 2, depende do resultado anterior (segundo README).
• 3.CargarRedis.ipynb: etapa 3.
• 4.CargarMongoDB.ipynb: etapa 4.
• service-test.ipynb: notebook de verificación/health check (comprobar que os contedores están arriba e accesibles).
Isto indica unha arquitectura “pipeline por etapas” máis que unha app por capas (non hai src/, non hai API server, non hai UI).
Pistas do README que son claves para o diagrama
• Execución: docker-compose up -d no CWD.
• Dependencias entre operacións: execución secuencial dos notebooks.
• A validación do estado dos servizos: service-test.ipynb.
• Non se menciona mensaxería, scheduler, nin CI/CD; polo tanto o “control plane” é manual (humano + Jupyter).
a) Identificar compoñentes principais (separa “control”, “compute”, “data stores”, “data artifacts”)
Recoméndoche dividir o diagrama en 4 grupos:
Entorno de execución / Control
• “User / Data Engineer”
• “Jupyter Notebook Environment” (local, VSCode, JupyterLab, etc.)
• “Docker Engine + Docker Compose” (infra local)
Artefactos de datos
• books.csv (orixe / input)
Etapas do pipeline (compute)
• Notebook 1: 1.CargarMySQL.ipynb
• Notebook 2: 2.CargarCassandra.ipynb
• Notebook 3: 3.CargarRedis.ipynb
• Notebook 4: 4.CargarMongoDB.ipynb
• Notebook extra: service-test.ipynb (observabilidade/validación)
Sistemas de almacenamento (data stores)
• MySQL (container)
• Cassandra (container)
• Redis (container)
• MongoDB (container)
> Nota: A “aplicación” aquí é realmente o conxunto de notebooks; as bases son infra.
b) Relacións e interaccións (frechas e dirección)
Debuxa dous tipos de frechas (moi importante para claridade):
Frechas de “control/execution”
• User → Jupyter (executa notebooks)
• Jupyter → Docker Compose/Docker Engine (arranca/para servizos, indirectamente)
Frechas de “data flow”
• books.csv → 1.CargarMySQL.ipynb → MySQL
• (Dependencia de etapas) 1.CargarMySQL.ipynb → 2.CargarCassandra.ipynb → Cassandra
• 2.CargarCassandra.ipynb → 3.CargarRedis.ipynb → Redis
• 3.CargarRedis.ipynb → 4.CargarMongoDB.ipynb → MongoDB
E para o notebook de test:
• service-test.ipynb → MySQL / Cassandra / Redis / MongoDB (consultas ping/connection tests)
> A clave é representar que non hai un bus/event stream: a dependencia é procedimental (execución humana + estado persistido nas bases).
c) Patróns arquitectónicos a destacar (o “por que” do debuxo)
• Pipeline por etapas (staged ETL/ELT): cada notebook é unha “stage”.
• Polyglot persistence: múltiples bases con modelos distintos (relacional, wide-column, key-value, document).
• Infra local reproducible: Docker Compose como “mini-plataforma” para levantar dependencias.
• Orquestración manual: non hai Airflow/Prefect/etc.; o diagrama debe reflectir que o scheduler é o usuario.
d) Tecnoloxías a etiquetar explícitamente
A falta de ver o contido dos notebooks/compose, no diagrama pon (como mínimo):
• Docker Compose (infra)
• Jupyter/Python (compute/orchestration)
• MySQL, Cassandra, Redis, MongoDB (stores)
• Dataset CSV (books.csv) (input)
Opcional pero útil se queres precisión “de conexión”:
• Indicar que a comunicación é por rede docker e ports (ex.: “Jupyter host → container ports”), aínda que non poñamos números se non están no README.
Como adaptar o diagrama ao tipo de proxecto (pipeline multibase, non full-stack)
Aquí non ten sentido un diagrama típico “frontend-backend-db”. En vez diso:
• En horizontal: Stage 1 → Stage 2 → Stage 3 → Stage 4
• En vertical: por baixo de cada stage, a súa base destino
• Entrada á esquerda: books.csv
• Caixa lateral: service-test.ipynb apuntando a todas as bases
Isto captura a esencia do repo: secuencia + destinos.
Diagrama 2 (complementario): “Deployment / Runtime (Docker Compose)”
• Un bloque “Docker host”
• Dentro, 4 contedores (MySQL/Cassandra/Redis/MongoDB) conectados nunha “Docker network”
• Fóra, “Jupyter/Python client” conectando a cada contedor
• Se hai volumes (probable), debuxa “Docker volumes” asociados a cada DB (persistencia)
Elementos obrigatorios no diagrama (claridade máxima)
• Etiquetas claras:
• Nome exacto do notebook (tal cal no repo) para que sexa trazable.
• Nome do servizo DB (MySQL/Cassandra/Redis/MongoDB).
• books.csv como data source.
• Frechas direccionais:
• Data flow: CSV → notebooks → bases.
• Health check: service-test → bases.
• Codificación visual:
• Unha cor/forma para *compute* (notebooks).
• Outra para *data stores* (DBs).
• Outra para *artifacts* (CSV).
• (Opcional) liñas punteadas para “control” e liñas sólidas para “datos”.
Nivel de detalle recomendado (separar en “tantos compoñentes como sexa posible”)
Para que o diagrama sexa “o mellor e máis exacto” para este repo, non o deixes en “Jupyter → Databases”. Sepárao así:
• Cada notebook como compoñente independente (porque o README define dependencia secuencial).
• docker-compose.yml como compoñente de “provisioning”.
• service-test.ipynb como compoñente de observabilidade/validación.
• (Se no compose existen) volumes por DB (persistencia) e network (conectividade).