Desplegar en Google Cloud: Crónica de 4 Pull Requests y Muchos Errores
Este artículo relata la experiencia de desplegar un blog personal en Google Cloud, detallando los desafíos y soluciones encontradas. Inicialmente se intentó un pipeline CI/CD con GitHub Actions, pero se descartó por costos y complejidad. Se describe la configuración de Cloud Run, incluyendo la ejecución de scripts de seeding de datos y manejo de credenciales. El lector aprenderá sobre las complejidades del despliegue en la nube y la importancia de adaptar las soluciones a las necesidades del proyecto.

El Plan Perfecto (Que No Sobrevivió al Primer Deploy)
Tenía todo listo. Un backend Django funcionando, un frontend React pulido, un motor RAG que respondía preguntas como si fuera yo. En local, era perfecto. Solo faltaba "subirlo a la nube".
Pensé que sería un viernes de deploy. Resultó ser una semana de parches, 4 Pull Requests, y la confirmación de que ningún plan de despliegue sobrevive al primer contacto con producción.
Día 1: CI/CD (12 de enero)
GitHub Actions: La Automatización que Duró Poco
El commit f02d279 creó los workflows de CI/CD. La idea era clásica: push a develop hace build y tests, merge a main despliega automáticamente a Cloud Run.
# .github/workflows/deploy-main.yml
name: Deploy to Cloud Run
on:
push:
branches: [main]
jobs:
deploy-backend:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v4
- name: Auth GCP
uses: google-github-actions/auth@v2
with:
credentials_json: ${{ secrets.GCP_SA_KEY }}
- name: Build & Push
run: |
gcloud builds submit --tag gcr.io/$PROJECT_ID/blog-backend
- name: Deploy
run: |
gcloud run deploy blog-backend \
--image gcr.io/$PROJECT_ID/blog-backend \
--region us-central1 \
--platform managed
Documenté todo en el README (7d80fbb). Un pipeline bonito, profesional, listo para impresionar.
Duró exactamente 2 días.
Por Qué Eliminé el CI/CD
El commit 43061df eliminó los workflows de GitHub Actions. ¿Por qué? Tres razones:
1. Costos de Cloud Build. Cada push a develop disparaba un build de Docker. Cloud Build cobra por minuto de build. Con imágenes multi-stage (node + python + nginx), cada build tomaba ~8 minutos. A varios pushes por día, la factura crecía rápido.
2. Secrets Management. Para que GitHub Actions autenticara con GCP, necesitaba una Service Account Key en JSON como secret del repositorio. Esa key tiene permisos amplios (Cloud Run Admin, Artifact Registry Writer, Cloud SQL Client). Tener una credencial tan poderosa en GitHub me generaba ansiedad.
3. Mi blog no necesita CI/CD. Soy el único desarrollador, despliego manualmente cuando quiero, y el blog se actualiza quizás una o dos veces por semana. Un deploy.sh con 10 líneas de bash es más simple, más barato y más seguro.
Actualización (febrero 2026): Esta decisión fue revisada más adelante. Al implementar una suite de 89 tests automáticos (65 backend + 24 frontend), resultó imprescindible un pipeline que ejecutara esos tests antes de cada deploy. El workflow
deploy.ymlvivió durante un tiempo como script manual, y fue re-implementado como GitHub Actions una vez que la cobertura de tests justificaba la automatización. Ver Post 15 para el estado actual.
```bash deploy.sh
!/bin/bash
deploy.sh - Lo que realmente uso
source .env
Backend
cd blog_backend gcloud builds submit --tag $REGISTRY/blog-backend gcloud run deploy blog-backend --image $REGISTRY/blog-backend \ --region us-central1 --allow-unauthenticated
Frontend
cd ../blog_frontend npm run build gcloud builds submit --tag $REGISTRY/blog-frontend gcloud run deploy blog-frontend --image $REGISTRY/blog-frontend \ --region us-central1 --allow-unauthenticated
**Lección:** No todo proyecto necesita CI/CD. A veces, la simplicidad de un script es la solución correcta. El CI/CD brilla cuando hay un equipo, múltiples ambientes (staging, QA, prod), y deploys frecuentes. Para un blog personal, es over-engineering.
---
## Día 2: El Infierno de Cloud Run (14 de enero)
### Cloud Run: El Contexto
Google Cloud Run ejecuta contenedores Docker como servicios HTTP serverless. Pagas solo por las requests que procesas. Se escala a cero (0 instancias cuando no hay tráfico) y se escala automáticamente cuando hay carga. Suena perfecto.
**El problema:** Cloud Run tiene reglas muy específicas sobre cómo debe funcionar tu contenedor.
### Fix #1: Data Seeding y Credenciales (`e8f7dfd`)
Mi primer deploy falló porque el contenedor no tenía datos. Los scripts `populate_posts.py` y `populate_tags.py` necesitaban ejecutarse dentro del contenedor, pero Cloud Run no te da acceso SSH al contenedor en ejecución.
La solución fue agregar un entrypoint que ejecuta las migraciones y seeds antes de iniciar Gunicorn:
```dockerfile
# Entrypoint que corre en cada inicio del contenedor
COPY entrypoint.sh /entrypoint.sh
RUN chmod +x /entrypoint.sh
ENTRYPOINT ["/entrypoint.sh"]
#!/bin/bash
# entrypoint.sh
python manage.py migrate --noinput
python manage.py collectstatic --noinput
# Solo seedear si la base de datos está vacía
python -c "
from blog.models import Post
if Post.objects.count() == 0:
exec(open('populate_posts.py').read())
exec(open('populate_tags.py').read())
"
exec gunicorn blog_backend.wsgi:application --bind 0.0.0.0:$PORT
Fix #2: El GitHub Action Roto (43061df)
El workflow de GitHub Actions referenciaba paths que ya no existían y usaba una Service Account sin los permisos correctos. En lugar de arreglarlo, lo eliminé y consolidé todo en deploy.sh.
Fix #3: Limpieza de Archivos Obsoletos (3d07dd3)
Git estaba trackeando archivos que no deberían existir en el repositorio: credenciales de desarrollo, archivos .env de ejemplo mal ubicados, configuraciones de prueba. Los eliminé del tracking con:
git rm --cached -r .env deploy.sh
echo ".env" >> .gitignore
echo "deploy.sh" >> .gitignore
Fix #4: Credenciales Seguras (42b595b)
Las credenciales de deploy (IDs de proyecto, nombres de registry, URLs de Cloud SQL) estaban hardcodeadas en deploy.sh. Las moví a un archivo .env que nunca se commitea:
# .env (NO commiteado)
GCP_PROJECT=blog-beck-450915
GCP_REGION=us-central1
REGISTRY=us-central1-docker.pkg.dev/blog-beck-450915/blog-registry
CLOUD_SQL_INSTANCE=blog-beck-450915:us-central1:blog-db
Día 3: Vertex AI y el Upgrade a Gemini 2.0 (19 de enero)
De Ollama Local a Vertex AI en la Nube
Durante el desarrollo, el motor RAG usaba Ollama con el modelo llama3.2 corriendo en mi máquina. Esto era perfecto para desarrollo: gratuito, rápido, sin dependencias de red.
Pero en Cloud Run, no puedes correr Ollama. Los contenedores tienen recursos limitados (256 MB - 8 GB de RAM, sin GPU) y se destruyen cuando no hay tráfico. Necesitaba un servicio de IA en la nube.
Estado actual: Ollama y SBERT fueron deprecados en febrero de 2026. El motor RAG usa exclusivamente Vertex AI (
text-embedding-005para embeddings,gemini-2.5-flashpara generación). El código de Ollama/SBERT está enblog_backend/deprecated/.
El commit e5405ef migró la generación de respuestas a Vertex AI con Gemini 2.0 Flash:
```python blog_backend/search/engine.py @classmethod def _generate_with_vertex(cls, prompt): """Genera respuesta usando Vertex AI Gemini.""" project = os.getenv('GOOGLE_CLOUD_PROJECT') region = os.getenv('GOOGLE_CLOUD_REGION', 'us-central1') model_id = os.getenv('VERTEX_MODEL_ID', 'gemini-2.5-flash')
url = (
f"https://{region}-aiplatform.googleapis.com/v1/"
f"projects/{project}/locations/{region}/"
f"publishers/google/models/{model_id}:generateContent"
)
# Autenticación via ADC (Application Default Credentials)
credentials, _ = google.auth.default()
credentials.refresh(google.auth.transport.requests.Request())
headers = {
'Authorization': f'Bearer {credentials.token}',
'Content-Type': 'application/json',
}
payload = {
'contents': [{'parts': [{'text': prompt}]}],
'generationConfig': {
'temperature': 0.7,
'maxOutputTokens': 1024,
}
}
response = requests.post(url, headers=headers, json=payload)
return response.json()['candidates'][0]['content']['parts'][0]['text']
**¿Por qué REST directo en vez del SDK?** El SDK de Google (`google-cloud-aiplatform`) pesa ~200 MB de dependencias. Mi imagen Docker ya era pesada con SBERT. Usar la API REST directa me ahorra esas dependencias y me da control total sobre la request.
**Application Default Credentials (ADC):** Cloud Run automáticamente inyecta credenciales de la Service Account asociada al servicio. No necesitas archivos JSON ni variables de entorno. Solo llamas `google.auth.default()` y obtienes un token válido. Es la forma más segura y limpia de autenticar en GCP.
### Variables de Entorno Faltantes (`51b558f`)
Cloud Run necesita saber el proyecto de GCP y la región para llamar a Vertex AI. Estas variables se configuran en el deploy:
```bash
gcloud run deploy blog-backend \
--set-env-vars="GOOGLE_CLOUD_PROJECT=blog-beck-450915" \
--set-env-vars="GOOGLE_CLOUD_REGION=us-central1" \
--set-env-vars="DJANGO_SECRET_KEY=$(openssl rand -base64 32)"
Frontend: .env.development (a5604d9)
Para desarrollo local, el frontend necesita apuntar al backend local:
REACT_APP_API_URL=http://127.0.0.1:8000/api
En producción, el Dockerfile inyecta la URL del backend de Cloud Run durante el build:
ARG REACT_APP_API_URL
ENV REACT_APP_API_URL=$REACT_APP_API_URL
RUN npm run build
Los 4 Pull Requests del Dolor (19-20 de enero)
PR #1: El Gran Refactor (c89329a)
Este PR combinó el tema académico, la corrección de bugs del frontend, y el pipeline de CI/CD (que luego eliminé). Fue un PR demasiado grande. Debi haberlo separado en 3.
Lección: PRs pequeños y focalizados. Un PR que toca el tema visual, la lógica de backend Y la infraestructura es imposible de revisar adecuadamente.
PR #2: El Sufijo /api (f1f1441)
Un bug clásico de configuración. La variable REACT_APP_API_URL no tenía el sufijo /api:
❌ REACT_APP_API_URL=https://blog-backend-xxx.run.app
✓ REACT_APP_API_URL=https://blog-backend-xxx.run.app/api
Resultado: todas las llamadas del frontend retornaban 404. El fix fue una línea, pero tardé 40 minutos en diagnosticarlo porque los logs de Cloud Run no mostraban las URLs completas.
PR #3: Puerto 8080 (ccd59fc)
Cloud Run requiere que tu contenedor escuche en el puerto definido por la variable $PORT, que por defecto es 8080. Mi Dockerfile exponía el puerto 8000 (el default de Django/Gunicorn):
# ANTES (incorrecto)
EXPOSE 8000
CMD ["gunicorn", "blog_backend.wsgi:application", "--bind", "0.0.0.0:8000"]
# DESPUÉS (correcto)
EXPOSE 8080
CMD ["gunicorn", "blog_backend.wsgi:application", "--bind", "0.0.0.0:$PORT"]
El detalle sutil: El EXPOSE en un Dockerfile es solo documentación, no afecta el comportamiento real. Lo importante es que Gunicorn escuche en $PORT. Cloud Run inyecta PORT=8080 como variable de entorno. Si tu app escucha en otro puerto, Cloud Run lo marca como "unhealthy" y lo reinicia en un loop infinito.
Me tardé otra hora en diagnosticar esto porque el contenedor arrancaba correctamente en local (donde $PORT no existía y Gunicorn escuchaba en el default).
PR #4: Mixed Content HTTPS (dda624c)
El bug más sutil y frustrante de todos. El frontend estaba servido via HTTPS (Cloud Run siempre usa HTTPS). Pero el frontend hacía requests al backend via HTTP:
Frontend: https://blog-frontend-xxx.run.app (HTTPS ✓)
API call: http://blog-backend-xxx.run.app/api (HTTP ✗)
Los navegadores modernos bloquean las requests HTTP desde una página HTTPS por seguridad (mixed content). No hay error visible en la página, simplemente las requests fallan silenciosamente.
La solución fue hardcodear la URL HTTPS del backend:
// client.js
const API_URL = process.env.REACT_APP_API_URL || 'https://blog-backend-xxx.run.app/api';
¿Por qué pasa esto? Si la variable de entorno REACT_APP_API_URL se configuró durante el build sin el protocolo HTTPS explícito, Axios puede interpretarla como HTTP por defecto. Además, el build de React "quema" las variables de entorno en el bundle JavaScript — no se leen en runtime.
Reflexiones sobre el Despliegue
Lo que Aprendí
1. Cloud Run no es "Docker en la nube". Es Docker con reglas: puerto 8080, health checks automáticos, variables de entorno inyectadas, escala a cero. Si tu contenedor funciona en docker run local pero no en Cloud Run, el problema casi siempre es el puerto o las variables de entorno.
2. Los errores de configuración son los más difíciles de diagnosticar. No hay stack trace cuando el problema es una URL sin /api o un puerto incorrecto. Los logs dicen "connection refused" o "404 Not Found" sin contexto adicional.
3. Las variables de entorno de React son de build-time, no de runtime. Si cambias REACT_APP_API_URL, necesitas hacer un nuevo npm run build. No basta con cambiar la variable en Cloud Run. Esto es fundamental y contra-intuitivo para alguien que viene de backend.
4. HTTPS es obligatorio en producción. No como buena práctica, como requisito técnico. Los navegadores no van a enviar cookies ni hacer fetch desde HTTPS a HTTP. Punto.
5. PRs pequeños salvan vidas. Mis 4 PRs de fix deberían haber sido 1 PR bien hecho si hubiera testeado más antes de deployar.
El Costo del "Aprendizaje en Producción"
Estos commits representan aproximadamente 20 horas de trabajo repartidos en 3 días. El deploy inicial (PR #1) tomó ~8 horas. Los 3 hotfixes tomaron ~4 horas cada uno, incluyendo diagnóstico, fix, build, deploy y verificación.
¿Podría haber evitado estos errores? Parcialmente. Un staging environment habría atrapado los problemas de puerto y URL antes de producción. Pero para un blog personal, mantener un staging environment duplica los costos. La alternativa es ser más riguroso con los tests locales usando docker-compose que simule las condiciones de Cloud Run.
En el siguiente artículo: cómo implementé un sistema de caché semántico para que el chatbot no recalcule las mismas preguntas, y un patrón de signals de Django para mantener los embeddings sincronizados automáticamente.
Anterior: De Búsqueda por Keywords a RAG: Cómo le Enseñé a Mi Blog a Entender Preguntas
Siguiente: Despliegue Full-Stack Serverless en Google Cloud Platform
Este artículo es parte de la serie "Construyendo un Blog con IA". El código fuente completo está en GitHub.