Saltar al contenido
hg.Héctor GarridoCiencia de datos · Estadística · Ingeniería de datos
← Volver al blog
Portafolio RAG

# 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.

# Despliegue Full-Stack Serverless en Google Cloud Platform

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ón gemini-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:

  1. Ir a Vertex AI Model Garden
  2. Buscar "Gemini 2.0 Flash Experimental"
  3. 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):

  1. Cuando creo o edito un post, el backend automáticamente genera embeddings vectoriales (768 dimensiones) usando text-embedding-005
  2. Almaceno los embeddings en PostgreSQL como BinaryField (array numpy serializado con pickle)
  3. Ante una consulta del usuario:
  4. La pregunta se convierte en un vector de 768 dimensiones
  5. Calculo similitudes coseno in-memory contra todos los posts indexados
  6. Recupero los K fragmentos más relevantes
  7. Contexto + pregunta se envían a gemini-2.5-flash para generar la respuesta

Para usuarios anónimos (búsqueda por keywords):

  • Implementé búsqueda SQL tradicional con icontains sobre 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.txt antes 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í:

  1. Verificar que el modelo estuviera habilitado en Model Garden (este era mi caso)
  2. Asegurar que el Service Account tuviera roles/aiplatform.user
  3. En desarrollo local, ejecutar gcloud auth application-default login
  4. Verificar que GOOGLE_CLOUD_PROJECT estuviera 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 slim y 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

  1. SQLite en desarrollo: Configuré ALLOW_SQLITE=True para evitar Cloud SQL en mi máquina local
  2. Indexación incremental: Mi comando index_posts solo regenera embeddings cuando el contenido cambia
  3. Auto-scaling conservador: Configuré --max-instances=3 para evitar sorpresas en la factura
  4. Búsqueda dual: Los usuarios anónimos usan búsqueda SQL simple, reduciendo llamadas a Vertex AI
  5. Tier correcto: Elegí db-custom-1-3840 porque 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

  1. Serverless es liberador: Cloud Run eliminó completamente la gestión de servidores, auto-scaling y configuración SSL
  2. Las imágenes importan: Reducir las imágenes Docker de 1GB a 25MB marcó una diferencia enorme en cold starts
  3. RAG es más accesible de lo que pensaba: Implementar búsqueda semántica + LLM generativo fue sorprendentemente directo con Vertex AI
  4. La seguridad debe ser por diseño: Service accounts con permisos mínimos, Secret Manager y HTTPS desde día uno
  5. 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:


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.