# Despliegue Full-Stack Serverless en Google Cloud Platform
Este artículo detalla el despliegue de una aplicación full-stack serverless en Google Cloud Platform. Se describe la arquitectura, que incluye un frontend React en Cloud Run, un backend Django con DRF también en Cloud Run, una base de datos PostgreSQL en Cloud SQL con pgvector, y Vertex AI para embeddings y generación de lenguaje. Aprenderás a configurar el proyecto en GCP, habilitar las APIs necesarias, configurar las credenciales y crear una instancia de PostgreSQL en Cloud SQL. Se explica la migración a Neon PostgreSQL serverless.

1. Arquitectura General
Diseñé la solución dividiendo el sistema en servicios desacoplados, siguiendo buenas prácticas de escalabilidad y mantenimiento:
┌───────────────────────────────────────────────────────────────┐
│ Google Cloud Platform │
│ │
│ ┌────────────────┐ ┌─────────────────┐ ┌────────────┐ │
│ │ Cloud Run │ │ Cloud Run │ │ Cloud │ │
│ │ (Frontend) │ │ (Backend) │ │ Storage │ │
│ │ │ │ │ │ │ │
│ │ Nginx + SPA │───►│ Gunicorn + │───►│ Media │ │
│ │ Port 8080 │ │ Django │ │ (covers, │ │
│ │ │ │ Port 8080 │ │ uploads) │ │
│ └────────┬───────┘ └────────┬────────┘ └────────────┘ │
│ │ │ │
│ │ ▼ │
│ │ ┌─────────────────┐ │
│ │ │ Cloud SQL │ │
│ │ │ PostgreSQL 16 │ │
│ │ │ + pgvector │ │
│ │ └─────────────────┘ │
│ │ │
│ │ ┌─────────────────┐ │
│ │ │ Vertex AI │ │
│ │ │ - Embeddings │ │
│ │ │ - Gemini LLM │ │
│ │ └─────────────────┘ │
│ │ │
│ └───────────►│ Artifact │ │
│ │ Registry │ │
│ │ (imágenes │ │
│ │ Docker) │ │
│ └─────────────────┘ │
│ │
└───────────────────────────────────────────────────────────────┘
Lo que construí:
- Frontend: React 18 (SPA) con Material UI v5, desplegado en Cloud Run con Nginx
- Backend: Django 5.0 + Django REST Framework (API REST + orquestador de IA)
- Base de datos: PostgreSQL 16 con extensión pgvector en Cloud SQL
- Media storage: Google Cloud Storage (imágenes de portada, archivos subidos)
- Motor de IA: Vertex AI (embeddings
text-embedding-005+ generacióngemini-2.5-flash) - Infraestructura: Cloud Run + Artifact Registry
Todo el tráfico es HTTPS y no expuse credenciales ni acceso directo a la base de datos.
2. Preparación del Proyecto en Google Cloud
2.1 Crear y configurar el proyecto
Lo primero fue crear el proyecto en GCP y configurar la región:
# Crear proyecto (usé un nombre único)
gcloud projects create mi-blog-proyecto
gcloud config set project mi-blog-proyecto
# Configuré us-central1 por balance precio/latencia
gcloud config set compute/region us-central1
2.2 Habilitar APIs necesarias
gcloud services enable \
run.googleapis.com \
sqladmin.googleapis.com \
artifactregistry.googleapis.com \
aiplatform.googleapis.com \
storage.googleapis.com
2.3 Configurar credenciales para desarrollo local
Para poder desarrollar y probar localmente con Vertex AI, autentiqué mi máquina:
# Esto permite usar Vertex AI desde mi entorno local
gcloud auth application-default login --project=mi-blog-proyecto
3. Base de Datos: Cloud SQL (estado inicial) y Neon (estado actual)
Actualización: El blog inició con Cloud SQL (PostgreSQL 16) y migró a Neon PostgreSQL serverless en febrero de 2026. Cloud SQL representaba el 70% del presupuesto mensual para una base de datos de 50 MB. Esta sección documenta la configuración original. Ver Post 08 para los pasos de la migración a Neon.
3.1 Crear la instancia PostgreSQL
Elegí PostgreSQL 16 porque necesitaba la extensión pgvector para futuras optimizaciones de búsqueda vectorial:
gcloud sql instances create blog-db-instance \
--database-version=POSTGRES_16 \
--region=us-central1 \
--tier=db-custom-1-3840 \
--database-flags=cloudsql.enable_pgvector=on
Nota importante: La flag cloudsql.enable_pgvector=on fue crucial para habilitar capacidades de búsqueda vectorial optimizada.
3.2 Crear base de datos y usuario
Creé la base de datos y un usuario dedicado con una contraseña fuerte:
# Crear base de datos
gcloud sql databases create blogdb \
--instance=blog-db-instance
# Crear usuario (generé una contraseña fuerte aleatoria)
gcloud sql users create bloguser \
--instance=blog-db-instance \
--password=TU_CONTRASEÑA_SEGURA
En producción, almacené las credenciales en Secret Manager:
echo -n "TU_CONTRASEÑA_SEGURA" | gcloud secrets create db-password \
--data-file=-
3.3 Habilitar la extensión pgvector
Me conecté a la base de datos vía Cloud SQL Proxy para habilitar pgvector:
# Terminal 1: Iniciar proxy
cloud-sql-proxy mi-proyecto-blog:us-central1:blog-db-instance
# Terminal 2: Conectar con psql
psql "host=127.0.0.1 user=bloguser dbname=blogdb"
Ejecuté en la consola de PostgreSQL:
CREATE EXTENSION IF NOT EXISTS vector;
Alternativamente, desde Django:
from django.db import connection
with connection.cursor() as cursor:
cursor.execute('CREATE EXTENSION IF NOT EXISTS vector;')
4. Motor de IA: Pipeline RAG con Vertex AI
4.1 Configurar Vertex AI
Configuré Vertex AI en la misma región que el resto de servicios:
gcloud config set ai/region us-central1
4.2 Habilitar modelos generativos
Los modelos Gemini 2.0 requieren habilitación manual. Tuve que:
- Ir a Vertex AI Model Garden
- Buscar "Gemini 2.0 Flash Experimental"
- Hacer clic en "Enable"
En algunos casos puede requerir aprobación administrativa para acceder a modelos generativos.
4.3 Arquitectura del Sistema RAG
Implementé una estrategia dual de búsqueda para balancear costo y funcionalidad:
Para usuarios autenticados (búsqueda semántica):
- Cuando creo o edito un post, el backend automáticamente genera embeddings vectoriales (768 dimensiones) usando
text-embedding-005 - Almaceno los embeddings en PostgreSQL como
BinaryField(array numpy serializado con pickle) - Ante una consulta del usuario:
- La pregunta se convierte en un vector de 768 dimensiones
- Calculo similitudes coseno in-memory contra todos los posts indexados
- Recupero los K fragmentos más relevantes
- Contexto + pregunta se envían a
gemini-2.5-flashpara generar la respuesta
Para usuarios anónimos (búsqueda por keywords):
- Implementé búsqueda SQL tradicional con
icontainssobre título, extracto y contenido - Sin acceso al chatbot RAG (solo listado de resultados) para controlar costos de API
4.4 Implementación del Motor RAG
# Ejemplo simplificado del motor RAG
class RAGEngine:
def __init__(self, ai_provider='vertex'):
self.ai_provider = ai_provider
self.region = 'us-central1'
def generate_embeddings(self, text):
"""Genera embeddings usando Vertex AI"""
endpoint = (
f"https://{self.region}-aiplatform.googleapis.com/v1/"
f"projects/{PROJECT_ID}/locations/{self.region}/"
f"publishers/google/models/text-embedding-005:predict"
)
payload = {"instances": [{"content": text}]}
response = requests.post(
endpoint,
json=payload,
headers={"Authorization": f"Bearer {self._get_token()}"}
)
return response.json()['predictions'][0]['embeddings']['values']
def semantic_search(self, query, top_k=5):
"""Búsqueda semántica sobre posts indexados"""
# Vectorizar consulta
query_embedding = self.generate_embeddings(query)
# Obtener todos los embeddings almacenados
embeddings_db = PostEmbedding.objects.select_related('post').all()
# Calcular similitudes coseno
db_embeddings = [emb.get_embedding() for emb in embeddings_db]
similarities = cosine_similarity([query_embedding], db_embeddings)[0]
# Ordenar por similitud y devolver top-K
top_indices = np.argsort(similarities)[-top_k:][::-1]
return [embeddings_db[i].post for i in top_indices]
def answer_question(self, question, context_posts):
"""Genera respuesta usando Gemini con contexto del blog"""
# Construir contexto a partir de posts relevantes
context = "\n\n".join([
f"# {post.title}\n{post.content}"
for post in context_posts
])
# Prompt con personalidad del autor + contexto
prompt = f"""Eres un asistente que responde como el autor del blog.
Contexto del blog:
{context}
Pregunta del usuario: {question}
Responde en primera persona, basándote ÚNICAMENTE en el contexto proporcionado."""
endpoint = (
f"https://{self.region}-aiplatform.googleapis.com/v1/"
f"projects/{PROJECT_ID}/locations/{self.region}/"
f"publishers/google/models/gemini-2.5-flash:generateContent"
)
payload = {
"contents": [{"role": "user", "parts": [{"text": prompt}]}],
"generationConfig": {"temperature": 0.7, "maxOutputTokens": 1024}
}
response = requests.post(
endpoint,
json=payload,
headers={"Authorization": f"Bearer {self._get_token()}"}
)
return response.json()['candidates'][0]['content']['parts'][0]['text']
4.5 Indexación incremental
Creé un comando de Django que indexa solo posts nuevos o modificados:
# Mi comando personalizado para indexación inteligente
python manage.py index_posts
El comando compara las fechas de actualización (post.updated_at vs embedding.updated_at) y solo procesa los cambios. Esto me ahorra tiempo y dinero en llamadas a la API de embeddings.
5. Containerización con Docker
5.1 Backend Django (Multi-stage Build)
Diseñé un Dockerfile optimizado para el backend Django:
FROM python:3.11-slim AS base
# Variables de entorno para optimizar Python
ENV PYTHONDONTWRITEBYTECODE=1 \
PYTHONUNBUFFERED=1 \
PIP_NO_CACHE_DIR=1 \
PYTHONFAULTHANDLER=1
WORKDIR /app
# Dependencias del sistema (PostgreSQL driver)
RUN apt-get update \
&& apt-get install -y --no-install-recommends \
build-essential \
libpq-dev \
&& rm -rf /var/lib/apt/lists/*
# Instalar dependencias Python (cacheado si requirements.txt no cambia)
COPY requirements.txt ./
RUN pip install --upgrade pip && pip install -r requirements.txt
# Copiar código de la aplicación
COPY . .
# Recolectar archivos estáticos (admin, DRF browsable API)
RUN SECRET_KEY=dummy_for_build python manage.py collectstatic --noinput
ENV PORT=8080
EXPOSE 8080
# Migrar base de datos y arrancar Gunicorn
CMD ["sh", "-c", "python manage.py migrate --noinput && gunicorn blog_backend.wsgi:application --bind 0.0.0.0:$PORT"]
Optimizaciones que implementé:
python:3.11-slim: Reduje la imagen base de ~900MB a ~45MB- Layer caching: Copié
requirements.txtantes del código para aprovechar caché de Docker PYTHONUNBUFFERED=1: Aseguré logs en tiempo real en Cloud Run- WhiteNoise: Sirvo archivos estáticos sin necesidad de Nginx adicional
5.2 Frontend React (Multi-stage Build)
Para el frontend, usé un build multi-stage que reduce dramáticamente el tamaño:
# Etapa 1: Build de React
FROM node:18-alpine AS build
WORKDIR /app
COPY package*.json ./
RUN npm ci
COPY . .
RUN npm run build
# Etapa 2: Servir con Nginx
FROM nginx:1.25-alpine
COPY nginx.conf /etc/nginx/conf.d/default.conf
COPY --from=build /app/build /usr/share/nginx/html
EXPOSE 8080
CMD ["nginx", "-g", "daemon off;"]
Resultado: Logré una imagen final de ~25MB (vs ~1GB si hubiera incluido Node.js en producción).
5.3 Configuración Nginx para SPA
server {
listen 8080;
server_name _;
root /usr/share/nginx/html;
index index.html;
# SPA fallback: todas las rutas van a index.html
location / {
try_files $uri $uri/ /index.html;
}
# Security headers
add_header X-Content-Type-Options nosniff;
add_header X-Frame-Options SAMEORIGIN;
add_header X-XSS-Protection "1; mode=block";
add_header Referrer-Policy "strict-origin-when-cross-origin";
}
¿Por qué el SPA fallback?
Como uso React Router para manejar las rutas en el cliente (/blog/machine-learning, /ai-search, etc.), necesitaba asegurarme de que Nginx siempre sirviera index.html para que React tome el control del routing. Sin try_files $uri $uri/ /index.html, obtendría 404 para cualquier ruta excepto /.
6. Almacenamiento de Media Files (Cloud Storage)
6.1 Crear bucket de Cloud Storage
# Crear bucket regional
gsutil mb -l us-central1 gs://tu-blog-media-bucket/
# Hacer archivos públicos (para imágenes de portada)
gsutil iam ch allUsers:objectViewer gs://tu-blog-media-bucket/
6.2 Configurar Django para usar Cloud Storage
# settings.py
import os
GS_BUCKET_NAME = os.getenv('GS_BUCKET_NAME')
if GS_BUCKET_NAME:
STORAGES = {
"default": {
"BACKEND": "storages.backends.gcloud.GoogleCloudStorage",
"OPTIONS": {
"bucket_name": GS_BUCKET_NAME,
"default_acl": "publicRead",
},
},
}
MEDIA_URL = f"https://storage.googleapis.com/{GS_BUCKET_NAME}/"
else:
# Fallback a filesystem local (desarrollo)
MEDIA_ROOT = os.path.join(BASE_DIR, 'media')
MEDIA_URL = '/media/'
¿Por qué Cloud Storage?
Aprendí por las malas que Cloud Run es efímero: los contenedores escalan a cero cuando no hay tráfico y cualquier archivo subido al filesystem desaparece. Cloud Storage me proporciona almacenamiento persistente y distribuido con URLs públicas automáticas. Vale totalmente la pena.
7. Registro de Imágenes (Artifact Registry)
7.1 Crear repositorio Docker
Creé un repositorio en Artifact Registry para alojar mis imágenes Docker:
gcloud artifacts repositories create blog-images \
--repository-format=docker \
--location=us-central1 \
--description="Imágenes Docker del blog"
7.2 Configurar autenticación Docker
gcloud auth configure-docker us-central1-docker.pkg.dev
7.3 Build y push de imágenes
Construí y subí las imágenes para ambos servicios:
# Backend
cd blog_backend
docker build -t us-central1-docker.pkg.dev/mi-proyecto/blog-images/backend:latest .
docker push us-central1-docker.pkg.dev/mi-proyecto/blog-images/backend:latest
# Frontend
cd blog_frontend
docker build -t us-central1-docker.pkg.dev/mi-proyecto/blog-images/frontend:latest .
docker push us-central1-docker.pkg.dev/mi-proyecto/blog-images/frontend:latest
8. Despliegue en Cloud Run
8.1 Desplegar Backend
Este fue uno de los momentos más emocionantes: el primer despliegue a producción.
gcloud run deploy blog-backend \
--image=us-central1-docker.pkg.dev/tu-proyecto-blog/blog-images/backend:latest \
--region=us-central1 \
--platform=managed \
--allow-unauthenticated \
--set-env-vars="DJANGO_SECRET_KEY=tu-clave-secreta-64-caracteres,\
DJANGO_DEBUG=False,\
DATABASE_URL=postgres://bloguser:CONTRASEÑA@/blogdb?host=/cloudsql/tu-proyecto-blog:us-central1:blog-db-instance,\
AI_PROVIDER=vertex,\
GOOGLE_CLOUD_PROJECT=tu-proyecto-blog,\
GOOGLE_CLOUD_REGION=us-central1,\
GS_BUCKET_NAME=tu-blog-media-bucket,\
CORS_ALLOWED_ORIGINS=https://tu-dominio.com" \
--add-cloudsql-instances=tu-proyecto-blog:us-central1:blog-db-instance \
--service-account=backend-sa@tu-proyecto-blog.iam.gserviceaccount.com
Flags importantes:
--add-cloudsql-instances: Conecta el contenedor con Cloud SQL vía Unix socket (más seguro que TCP público)--service-account: Service account con permisos mínimos para Vertex AI y Cloud Storage--allow-unauthenticated: La API es pública (autenticación JWT se maneja a nivel de aplicación)
8.2 Desplegar Frontend
gcloud run deploy blog-frontend \
--image=us-central1-docker.pkg.dev/tu-proyecto-blog/blog-images/frontend:latest \
--region=us-central1 \
--platform=managed \
--allow-unauthenticated
8.3 Configurar dominio personalizado
# Mapear tu dominio al servicio
gcloud run domain-mappings create \
--service=blog-frontend \
--domain=tu-dominio.com \
--region=us-central1
# Verificar registros DNS requeridos
gcloud run domain-mappings describe \
--domain=tu-dominio.com \
--region=us-central1
Agregar los registros A/AAAA mostrados en tu proveedor DNS (Cloudflare, Google Domains, etc.).
9. Seguridad en Producción
9.1 Crear Service Account con permisos mínimos
Seguí el principio de "least privilege": creé un service account dedicado solo con los permisos necesarios.
# Crear service account para el backend
gcloud iam service-accounts create backend-sa \
--display-name="Backend service account"
# Permisos para Vertex AI
gcloud projects add-iam-policy-binding tu-proyecto-blog \
--member="serviceAccount:backend-sa@tu-proyecto-blog.iam.gserviceaccount.com" \
--role="roles/aiplatform.user"
# Permisos para Cloud Storage
gsutil iam ch serviceAccount:backend-sa@tu-proyecto-blog.iam.gserviceaccount.com:objectAdmin \
gs://tu-blog-media-bucket
9.2 Configuración de seguridad en Django
# settings.py (producción)
if not DEBUG:
# Forzar HTTPS
SECURE_SSL_REDIRECT = True
SECURE_PROXY_SSL_HEADER = ('HTTP_X_FORWARDED_PROTO', 'https')
# HSTS (HTTP Strict Transport Security)
SECURE_HSTS_SECONDS = 31536000 # 1 año
SECURE_HSTS_INCLUDE_SUBDOMAINS = True
SECURE_HSTS_PRELOAD = True
# Cookies seguras
SESSION_COOKIE_SECURE = True
CSRF_COOKIE_SECURE = True
# CSRF trusted origins
CSRF_TRUSTED_ORIGINS = ['https://tu-dominio.com']
# Content Security Policy (opcional)
SECURE_CONTENT_TYPE_NOSNIFF = True
SECURE_BROWSER_XSS_FILTER = True
9.3 Usar Secret Manager para credenciales
# Almacenar contraseña de base de datos
echo -n "tu-contraseña-segura" | gcloud secrets create db-password --data-file=-
# Almacenar Django secret key
echo -n "tu-django-secret-key" | gcloud secrets create django-secret --data-file=-
# Configurar Cloud Run para leer secrets
gcloud run services update blog-backend \
--update-secrets=DJANGO_SECRET_KEY=django-secret:latest,\
DATABASE_PASSWORD=db-password:latest
9.4 Configuración CORS
# settings.py
CORS_ALLOWED_ORIGINS = os.getenv(
'CORS_ALLOWED_ORIGINS',
'http://localhost:3000'
).split(',')
CORS_ALLOW_CREDENTIALS = True # Necesario para JWT en cookies
CSRF_TRUSTED_ORIGINS = CORS_ALLOWED_ORIGINS
10. Gestión de Base de Datos
10.1 Migraciones vía Cloud SQL Proxy
Para ejecutar migraciones y gestionar la base de datos sin exponerla públicamente, uso Cloud SQL Proxy:
# Terminal 1: Iniciar proxy en segundo plano
cloud-sql-proxy tu-proyecto-blog:us-central1:blog-db-instance &
# Terminal 2: Ejecutar migraciones
export DATABASE_URL="postgres://bloguser:CONTRASEÑA@127.0.0.1:5432/blogdb"
python manage.py migrate
10.2 Carga inicial de datos (seed)
Creé scripts para poblar el blog con contenido inicial:
# Seedear 24 posts sobre series de tiempo y machine learning
python populate_posts.py
# Auto-asignar tags basados en keywords del contenido
python populate_tags.py
# Indexar todos los posts para búsqueda semántica
python manage.py index_posts
11. Monitoreo y Logging
11.1 Ver logs de Cloud Run
# Logs del backend (últimas 50 líneas)
gcloud run services logs read blog-backend \
--region=us-central1 \
--limit=50
# Seguir logs en tiempo real
gcloud run services logs tail blog-backend \
--region=us-central1
11.2 Métricas disponibles en Cloud Console
Cloud Run proporciona métricas automáticas sin configuración:
- Request rate: Requests por segundo
- Latency: Percentiles p50/p95/p99
- Instance count: Número de instancias activas
- Memory/CPU usage: Uso de recursos por instancia
- Error rate: Porcentaje de errores 5xx
Disponibles en: https://console.cloud.google.com/run
12. Desafíos Comunes y Soluciones
12.1 Error 403 al llamar a Vertex AI
Problema que enfrenté: PermissionDenied: 403 The caller does not have permission
Cómo lo resolví:
- Verificar que el modelo estuviera habilitado en Model Garden (este era mi caso)
- Asegurar que el Service Account tuviera
roles/aiplatform.user - En desarrollo local, ejecutar
gcloud auth application-default login - Verificar que
GOOGLE_CLOUD_PROJECTestuviera configurado correctamente
12.2 Cold starts (primer request lento)
Problema que noté: La primera request después de inactividad tardaba ~5 segundos.
Mis soluciones:
- Reducir tamaño de imagen Docker: Usé base
slimy eliminé dependencias innecesarias (logré reducir de 800MB a 200MB) - Configurar "Minimum instances": Consideré mantener al menos 1 instancia activa (costo: ~$10/mes) - finalmente decidí no hacerlo
- Implementar health check rápido: Creé un endpoint
/health/que responde en <100ms
# views.py
from rest_framework.decorators import api_view, permission_classes
from rest_framework.permissions import AllowAny
from rest_framework.response import Response
@api_view(['GET'])
@permission_classes([AllowAny])
def health_check(request):
return Response({'status': 'healthy'}, status=200)
12.3 CORS bloqueando requests del frontend
Problema: Error en consola del navegador sobre Same-Origin Policy.
Solución:
# Asegurar que el dominio del frontend esté en la lista
CORS_ALLOWED_ORIGINS = [
'https://tu-dominio.com',
'https://www.tu-dominio.com',
]
# Si usas subdominios diferentes (ej. api.dominio.com)
CSRF_TRUSTED_ORIGINS = CORS_ALLOWED_ORIGINS
12.4 Media files desaparecen después de deploy
Problema que me costó horas: Las imágenes que subía al admin desaparecían cuando desplegaba una nueva versión.
Solución: Configurar Cloud Storage como expliqué en la sección 6. Tuve que verificar que la variable GS_BUCKET_NAME estuviera correctamente configurada en Cloud Run.
12.5 Migraciones fallan por extensión pgvector
Problema: django.db.utils.OperationalError: type "vector" does not exist
Solución:
# Conectar a la base de datos y habilitar la extensión
cloud-sql-proxy tu-proyecto-blog:us-central1:blog-db-instance &
psql "host=127.0.0.1 user=bloguser dbname=blogdb"
# En psql:
CREATE EXTENSION IF NOT EXISTS vector;
13. Optimizaciones de Costos
13.1 Mis costos mensuales reales
| Servicio | Mi Uso | Costo Mensual |
|---|---|---|
| Cloud Run (Backend) | ~1M requests, 100h CPU | $5 |
| Cloud Run (Frontend) | ~500K requests, 50h CPU | $2 |
| Cloud SQL (db-custom-1-3840) | Deprecado (migrado a Neon) | $0 |
| Cloud Storage (10GB) | Media files | $0.20 |
| Vertex AI Embeddings | ~10K requests | $0.50 |
| Vertex AI Gemini | ~50K tokens | $2 |
| Neon PostgreSQL serverless | Free tier (50 MB) | $0 |
| Total mensual | ~$10/mes |
13.2 Cómo optimicé los costos
- SQLite en desarrollo: Configuré
ALLOW_SQLITE=Truepara evitar Cloud SQL en mi máquina local - Indexación incremental: Mi comando
index_postssolo regenera embeddings cuando el contenido cambia - Auto-scaling conservador: Configuré
--max-instances=3para evitar sorpresas en la factura - Búsqueda dual: Los usuarios anónimos usan búsqueda SQL simple, reduciendo llamadas a Vertex AI
- Tier correcto: Elegí
db-custom-1-3840porque es perfecto para mi tráfico actual (~100 visitas/día)
14. Mi Script de Deployment Automatizado
Creé un script bash que automatiza todo el proceso de despliegue:
#!/bin/bash
# deploy.sh - Script de despliegue completo
set -e # Salir si algún comando falla
PROJECT_ID="tu-proyecto-blog"
REGION="us-central1"
REGISTRY="us-central1-docker.pkg.dev"
echo "🔨 Building backend image..."
cd blog_backend
docker build -t $REGISTRY/$PROJECT_ID/blog-images/backend:latest .
docker push $REGISTRY/$PROJECT_ID/blog-images/backend:latest
echo "🚀 Deploying backend to Cloud Run..."
gcloud run deploy blog-backend \
--image=$REGISTRY/$PROJECT_ID/blog-images/backend:latest \
--region=$REGION \
--quiet
echo "🔨 Building frontend image..."
cd ../blog_frontend
docker build -t $REGISTRY/$PROJECT_ID/blog-images/frontend:latest .
docker push $REGISTRY/$PROJECT_ID/blog-images/frontend:latest
echo "🚀 Deploying frontend to Cloud Run..."
gcloud run deploy blog-frontend \
--image=$REGISTRY/$PROJECT_ID/blog-images/frontend:latest \
--region=$REGION \
--quiet
echo "✅ Deployment completed successfully!"
echo "Backend URL: $(gcloud run services describe blog-backend --region=$REGION --format='value(status.url)')"
echo "Frontend URL: $(gcloud run services describe blog-frontend --region=$REGION --format='value(status.url)')"
Conclusiones
Construir este blog fue un viaje de aprendizaje increíble. Demostré (a mí mismo principalmente) que es posible desplegar una arquitectura moderna, segura y escalable en Google Cloud Platform sin exponer información sensible y sin necesidad de un equipo de DevOps dedicado.
Lo que aprendí en el camino
- Serverless es liberador: Cloud Run eliminó completamente la gestión de servidores, auto-scaling y configuración SSL
- Las imágenes importan: Reducir las imágenes Docker de 1GB a 25MB marcó una diferencia enorme en cold starts
- RAG es más accesible de lo que pensaba: Implementar búsqueda semántica + LLM generativo fue sorprendentemente directo con Vertex AI
- La seguridad debe ser por diseño: Service accounts con permisos mínimos, Secret Manager y HTTPS desde día uno
- La separación de servicios paga dividendos: Puedo escalar, actualizar o depurar frontend, backend y base de datos independientemente
El resultado final
La solución completa (React + Django + PostgreSQL + Vertex AI + Cloud Storage) me cuesta menos de $35/mes y escala automáticamente de 0 a miles de usuarios sin intervención manual. El tiempo de despliegue es <10 minutos con el script automatizado.
Este es el sitio que estás leyendo ahora mismo, funcionando en producción.
Mis próximos pasos (estado al momento de escribir el post)
Actualización (2026): Todos estos puntos están implementados. Ver los posts correspondientes.
- ✅ CI/CD automatizado: GitHub Actions (
deploy.yml) con pipeline completo (tests → build → deploy) — Post 15 - ✅ Tests automatizados: 65 tests backend (Django) + 24 tests frontend (Jest) — Post 15
- ✅ Caché semántico: Implementado con
RAGQueryCache— Post 05 - ✅ Migración a Neon: Cloud SQL reemplazado por Neon serverless — Post 08
- CDN global: Pendiente.
Recursos adicionales:
- Documentación de Cloud Run
- Vertex AI Generative AI
- pgvector Documentation
- Django Deployment Checklist
Anterior: Desplegar en Google Cloud: Crónica de 4 Pull Requests y Muchos Errores
Siguiente: Caché Semántico, Signals y las Mil Batallas de las Imágenes en GCS
Este artículo es parte de la serie "Construyendo un Blog con IA". El código fuente completo está en GitHub.