El backend: nueve modelos, un ETL idempotente y cinco endpoints
Este artículo técnico detalla la implementación del backend para un DataMart, resolviendo el problema de analizar datos de YouTube. Se utiliza Django para construir nueve modelos de datos, incluyendo tablas raw y dimensionales. Se implementa un ETL idempotente para evitar duplicados al procesar datos de la API de YouTube. El lector aprenderá sobre el diseño de modelos de datos, la creación de ETLs idempotentes y la construcción de endpoints para acceder a los datos procesados.

En el post anterior diseñé el DataMart en papel. Ahora tocaba implementarlo. El commit 898c41b es uno de los más grandes del proyecto: nueva app Django completa, 348 líneas de ETL, nueve modelos, cinco endpoints, dieciséis tests y cambios en settings.py y deploy.yml. No lo planeé para que fuera tan grande — simplemente no había forma de hacer funcionar el conjunto con menos piezas.
Los nueve modelos
La separación raw/dimensional que diseñé en el papel se tradujo directamente a código. Los cuatro modelos raw son casi idénticos entre sí:
class YtRawChannelSnapshot(models.Model):
payload = models.JSONField()
scraped_at = models.DateTimeField(auto_now_add=True)
Un JSONField y un timestamp. Sin procesar, sin interpretar. Lo que devuelve la API, tal cual.
Los cinco modelos dimensionales son más interesantes. YtTagOccurrence es la tabla de hechos del DataMart: registra cada vez que un tag aparece, con qué fuente (own, competitor, category) y en qué fecha. Eso permite construir series de tiempo de tags con una sola consulta agregada.
El truco de la idempotencia
El ETL puede ejecutarse dos veces en el mismo día sin crear duplicados. La clave está en usar la fecha del snapshot como identificador, no la hora:
stat, created = YtChannelStat.objects.get_or_create(
scraped_at__date=today,
defaults={
'subscribers': int(stats.get('subscriberCount', 0)),
'total_views': int(stats.get('viewCount', 0)),
'video_count': int(stats.get('videoCount', 0)),
'scraped_at': now,
}
)
Si el job de Cloud Run falla a mitad y se reintenta, solo escribe lo que falta. No acumula basura.
Lo mismo aplica para YtVideoStat y YtTagOccurrence. Cada uno usa get_or_create con la clave (video_id, scraped_at__date) o (tag, source, video_id, scraped_at__date). La capa raw es append-only por diseño (cada ejecución crea un snapshot nuevo), pero la capa dimensional es idempotente.
El flujo completo del ETL
1. channels.list → YtRawChannelSnapshot → YtChannelStat
2. videos.list → YtRawVideoSnapshot → YtVideoStat + YtTag + YtTagOccurrence(own)
3. search.list × 5 términos
videos.list de resultados → YtRawCompetitorSnapshot
→ YtCompetitorVideo + YtTag + YtTagOccurrence(competitor)
4. videos.list trending S&T → YtRawCategorySnapshot
→ YtTag + YtTagOccurrence(category)
Cada paso es independiente. Si falla la extracción de competidores (timeout, cuota agotada), el canal propio y los videos ya están guardados.
Los cinco endpoints
Todos protegidos con IsEmployeeUser, el mismo permiso que usan Tasks y los posts internos:
urlpatterns = [
path('snapshot/', SnapshotView.as_view()), # POST — dispara ETL
path('channel/evolution/', ChannelEvolutionView.as_view()), # GET ?days=90
path('videos/', MyVideosView.as_view()), # GET — snapshot reciente
path('tags/', TagsView.as_view()), # GET ?source=own&days=30
path('competitors/', CompetitorsView.as_view()), # GET ?q=término
]
El endpoint snapshot/ es llamable manualmente desde el dashboard (botón "Forzar snapshot") y también desde el job de Cloud Run. En ambos casos ejecuta el mismo código — sin lógica duplicada.
La infraestructura que se programa sola
El deploy.yml creció con tres bloques nuevos, todos condicionados a IS_PROD == 'true' para no gastar cuota en preproduction:
- name: Deploy YouTube Snapshot Cloud Run Job
if: steps.config.outputs.IS_PROD == 'true'
run: |
if gcloud run jobs describe youtube-snapshot ...; then
gcloud run jobs update youtube-snapshot ...
else
gcloud run jobs create youtube-snapshot \
--command python,manage.py,youtube_snapshot ...
fi
- name: Configure Cloud Scheduler for daily YouTube snapshot
if: steps.config.outputs.IS_PROD == 'true'
run: |
gcloud scheduler jobs create http youtube-daily-snapshot \
--schedule "0 3 * * *" ...
El patrón describe → update/create evita que el deploy falle si el job ya existe. Idempotencia también en la infraestructura.
Los tests
Dieciséis tests de backend con mocks completos de la YouTube Data API:
@patch('youtube.views.run_full_etl')
def test_snapshot_triggers_etl(self, mock_etl):
mock_etl.return_value = {'status': 'ok'}
response = self.client.post('/api/youtube/snapshot/')
self.assertEqual(response.status_code, 200)
mock_etl.assert_called_once()
Los tests cubren permisos (anónimos y empleados), los cinco endpoints, y el comportamiento del ETL con datos simulados. Ninguno llama a YouTube real — en CI no hay YOUTUBE_API_KEY y no debería haberla.
Lo que salió bien y lo que no
Bien: el diseño previo funcionó. Los modelos se tradujeron casi sin cambios del documento al código, y la separación raw/dimensional demostró ser la decisión correcta apenas tuve que depurar el primer bug de nombres.
No tan bien: el commit es demasiado grande. Hubiera sido mejor separar modelos + migraciones, luego ETL, luego endpoints. Pero cuando tienes un diseño claro y el flujo es directo, hay una tentación real de "terminar de una vez". Resistiré la próxima vez.
En la siguiente entrega: el frontend con Recharts, el Cloud Scheduler en producción y los bugs que aparecen cuando el código ya está "terminado".
Serie: YouTube Analytics DataMart — ← Parte 1 | Parte 3: El frontend →
Este artículo es parte de la serie "YouTube Analytics DataMart". El código fuente completo está en GitHub.