Implementa modelos abiertos en GKE

1. Introducción

Descripción general

El objetivo de este lab es brindarte experiencia práctica en la implementación de un modelo abierto en Google Cloud, desde una configuración local simple hasta una implementación de nivel de producción en Google Kubernetes Engine (GKE). Aprenderás a usar diferentes herramientas adecuadas para cada etapa del ciclo de vida del desarrollo.

El lab sigue la siguiente ruta:

  • Prototipado rápido: Primero, ejecutarás un modelo con Ollama de forma local para ver lo fácil que es comenzar.
  • Implementación en producción: Por último, implementarás el modelo en GKE Autopilot con Ollama como motor de entrega escalable.

Acerca de los modelos abiertos

En la actualidad, cuando se habla de "modelo abierto", se suele hacer referencia a un modelo de aprendizaje automático generativo que está disponible públicamente para que cualquier persona lo descargue y use. Esto significa que la arquitectura del modelo y, lo que es más importante, sus parámetros entrenados o "ponderaciones", se publican de forma pública.

Esta transparencia ofrece varias ventajas en comparación con los modelos cerrados, a los que, por lo general, solo se puede acceder a través de una API restrictiva:

  • Comprensión: Los desarrolladores y los investigadores pueden "mirar debajo del capó" para comprender el funcionamiento interno del modelo.
  • Personalización: Los usuarios pueden adaptar el modelo para tareas específicas a través de un proceso llamado ajuste.
  • Innovación: Permite a la comunidad crear aplicaciones nuevas e innovadoras sobre la base de modelos existentes eficaces.

La contribución de Google y la familia Gemma

Google ha sido un colaborador fundamental del movimiento de IA de código abierto durante muchos años. La revolucionaria arquitectura de Transformer, presentada en el artículo de 2017 "Attention Is All You Need", es la base de casi todos los modelos de lenguaje grandes modernos. A estos, les siguieron modelos abiertos históricos, como BERT, T5 y Flan-T5 ajustado con instrucciones, que ampliaron los límites de lo posible y fomentaron la investigación y el desarrollo en todo el mundo.

A partir de este rico historial de innovación abierta, Google presentó la familia de modelos Gemma. Los modelos Gemma se crean a partir de la misma investigación y tecnología que se utilizan para los potentes modelos Gemini de código cerrado, pero están disponibles con pesos abiertos. Para los clientes de Google Cloud, esto proporciona una potente combinación de tecnología de vanguardia y la flexibilidad del código abierto, lo que les permite controlar el ciclo de vida del modelo, integrarse con un ecosistema diverso y seguir una estrategia de múltiples nubes.

Destacamos a Gemma 3

En este lab, nos enfocaremos en Gemma 3, la generación más reciente y capaz de esta familia. Los modelos de Gemma 3 son ligeros y, a la vez, de vanguardia, y están diseñados para ejecutarse de manera eficiente en una sola GPU o incluso en una CPU.

  • Rendimiento y tamaño: Los modelos de Gemma 3 son ligeros y, a la vez, de vanguardia, y están diseñados para ejecutarse de manera eficiente en una sola GPU o incluso en una CPU. Proporcionan una calidad superior y un rendimiento de vanguardia (SOTA) para su tamaño.
  • Modalidad: Son multimodales, capaces de controlar la entrada de texto y de imágenes para generar texto como salida.
  • Funciones clave: Gemma 3 tiene una gran ventana de contexto de 128 000 y admite más de 140 idiomas.
  • Casos de uso: Estos modelos son adecuados para una variedad de tareas, como la búsqueda de respuestas, el resumen y el razonamiento.

Terminología clave

A medida que trabajes con modelos abiertos, te encontrarás con algunos términos comunes:

  • El entrenamiento previo implica entrenar un modelo con un conjunto de datos masivo y diverso para que aprenda patrones generales del lenguaje. Estos modelos son, básicamente, potentes máquinas de autocompletado.
  • El ajuste de instrucciones ajusta un modelo entrenado previamente para que siga mejor las instrucciones y las indicaciones específicas. Estos son los modelos que "saben cómo chatear".
  • Variantes del modelo: Por lo general, los modelos abiertos se lanzan en varios tamaños (p.ej., Gemma 3 tiene versiones de 1B, 4B, 12B y 27B parámetros, y variantes, como las ajustadas con instrucciones (-it), las previamente entrenadas o las cuantificadas para lograr eficiencia.
  • Necesidades de recursos: Los modelos de lenguaje grandes son grandes y requieren recursos de procesamiento significativos para alojarse. Si bien se pueden ejecutar de forma local, implementarlos en la nube proporciona un valor significativo, en especial cuando se optimizan para el rendimiento y la escalabilidad con herramientas como Ollama.

¿Por qué usar GKE para entregar modelos abiertos?

En este lab, se te guiará desde la ejecución de un modelo local simple hasta una implementación de producción a gran escala en Google Kubernetes Engine (GKE). Si bien las herramientas como Ollama son excelentes para la creación rápida de prototipos, los entornos de producción tienen un conjunto exigente de requisitos que GKE está en una posición única para satisfacer.

Para las aplicaciones de IA a gran escala, necesitas algo más que un modelo en ejecución: necesitas una infraestructura de servicio resiliente, escalable y eficiente. GKE proporciona esta base. A continuación, se indica cuándo y por qué elegirías GKE:

  • Administración simplificada con Autopilot: GKE Autopilot administra la infraestructura subyacente por ti. Te enfocas en la configuración de tu aplicación, y Autopilot aprovisiona y ajusta la escala de los nodos automáticamente.
  • Alto rendimiento y escalabilidad: Administra el tráfico exigente y variable con el ajuste de escala automático de GKE. Esto garantiza que tu aplicación pueda ofrecer una alta capacidad de procesamiento con baja latencia, y que pueda aumentar o reducir su escala según sea necesario.
  • Rentabilidad a gran escala: Administra los recursos de manera eficiente. GKE puede reducir la escala de las cargas de trabajo a cero para evitar pagar por recursos inactivos, y puedes aprovechar las VMs Spot para reducir significativamente los costos de las cargas de trabajo de inferencia sin estado.
  • Portabilidad y ecosistema enriquecido: Evita la dependencia de un solo proveedor con una implementación portátil basada en Kubernetes. GKE también proporciona acceso al vasto ecosistema de Cloud Native (CNCF) para obtener las mejores herramientas de supervisión, registro y seguridad.

En resumen, migras a GKE cuando tu aplicación de IA está lista para la producción y requiere una plataforma creada para una escala, un rendimiento y una madurez operativa importantes.

Qué aprenderás

En este lab, aprenderás a realizar las siguientes tareas:

  • Ejecuta un modelo abierto de forma local con Ollama.
  • Implementa un modelo abierto en Autopilot de Google Kubernetes Engine (GKE) con Ollama para la entrega.
  • Comprende la progresión desde los frameworks de desarrollo locales hasta una arquitectura de servicio apta para la producción en GKE.

2. Configura el proyecto

Cuenta de Google

Si aún no tienes una Cuenta de Google personal, debes crear una.

Usa una cuenta personal en lugar de una cuenta de trabajo o de institución educativa.

Accede a la consola de Google Cloud

Accede a la consola de Google Cloud con una Cuenta de Google personal.

Habilitar facturación

Configura una cuenta de facturación personal

Si configuraste la facturación con créditos de Google Cloud, puedes omitir este paso.

Para configurar una cuenta de facturación personal, ve aquí para habilitar la facturación en la consola de Cloud.

Notas:

  • Completar este lab debería costar menos de USD 1 en recursos de Cloud.
  • Puedes seguir los pasos al final de este lab para borrar recursos y evitar cargos adicionales.
  • Los usuarios nuevos pueden acceder a la prueba gratuita de USD 300.

Crear un proyecto (opcional)

Si no tienes un proyecto actual que quieras usar para este lab, crea uno nuevo aquí.

3. Abre el editor de Cloud Shell

  1. Haz clic en este vínculo para navegar directamente al editor de Cloud Shell.
  2. Si se te solicita autorización en algún momento del día, haz clic en Autorizar para continuar.Haz clic para autorizar Cloud Shell
  3. Si la terminal no aparece en la parte inferior de la pantalla, ábrela:
    • Haz clic en Ver.
    • Haz clic en Terminal.Abre una terminal nueva en el editor de Cloud Shell
  4. En la terminal, configura tu proyecto con este comando:
    gcloud config set project [PROJECT_ID]
    • Ejemplo:
      gcloud config set project lab-project-id-example
    • Si no recuerdas el ID de tu proyecto, puedes enumerar todos tus IDs de proyecto con el siguiente comando:
      gcloud projects list
      Establece el ID del proyecto en la terminal del editor de Cloud Shell
  5. Deberías ver el siguiente mensaje:
    Updated property [core/project].

4. Ejecuta Gemma con Ollama

Tu primer objetivo es lograr que Gemma 3 se ejecute lo más rápido posible en un entorno de desarrollo. Usarás Ollama, una herramienta que simplifica drásticamente la ejecución de modelos de lenguaje grandes de forma local. En esta tarea, se muestra la forma más sencilla de comenzar a experimentar con un modelo abierto.

Ollama es una herramienta gratuita de código abierto que permite a los usuarios ejecutar modelos generativos (modelos de lenguaje grandes, modelos de lenguaje y visión, y mucho más) de forma local en su propia computadora. Simplifica el proceso de acceso a estos modelos y de interacción con ellos, lo que los hace más accesibles y permite que los usuarios trabajen con ellos de forma privada.

Instala y ejecuta Ollama

Ahora, puedes instalar Ollama, descargar el modelo Gemma 3 y, luego, interactuar con él desde la línea de comandos.

  1. En la terminal de Cloud Shell, descarga e instala Ollama:
    curl -fsSL https://ollama.com/install.sh | sh
    Este comando descarga Ollama, lo instala y, luego, inicia el servicio de Ollama.
  2. Inicia el servicio de Ollama en segundo plano:
    ollama serve &
  3. Extrae (descarga) el modelo Gemma 3 1B con Ollama:
    ollama pull gemma3:1b
  4. Ejecuta el modelo de forma local:
    ollama run gemma3:1b
    El comando ollama run presenta una instrucción (>>>) para que le hagas preguntas al modelo.
  5. Prueba el modelo con una pregunta. Por ejemplo, escribe Why is the sky blue? y presiona INTRO. Deberías ver una respuesta similar a la siguiente:
    >>> Why is the sky blue?
Okay, let's break down why the sky is blue – it's a fascinating phenomenon related to how light interacts with the Earth's atmosphere.
Here's the explanation:

**1. Sunlight and Colors:**

* Sunlight appears white, but it's actually made up of all the colors of the rainbow (red, orange, yellow, green, blue, indigo, and violet).
Think of a prism splitting sunlight.

**2. Rayleigh Scattering:**

* As sunlight enters the Earth's atmosphere...
...
  6. Para salir de la solicitud de Ollama en la terminal, escribe /bye y presiona INTRO.

Usa el SDK de OpenAI con Ollama

Ahora que el servicio de Ollama está en ejecución, puedes interactuar con él de forma programática. Usarás el SDK de Python de OpenAI, que es compatible con la API que expone Ollama.

  1. En la terminal de Cloud Shell, crea y activa un entorno virtual con uv. Esto garantiza que las dependencias de tu proyecto no entren en conflicto con el Python del sistema.
    uv venv --python 3.14
source .venv/bin/activate
  2. En la terminal, instala el SDK de OpenAI:
    uv pip install openai
  3. Para crear un archivo nuevo llamado ollama_chat.py, ingresa lo siguiente en la terminal:
    cloudshell edit ollama_chat.py
  4. Pega el siguiente código de Python en ollama_chat.py. Este código envía una solicitud al servidor local de Ollama.
    from openai import OpenAI

client = OpenAI(
    base_url = 'http://localhost:11434/v1',
    api_key='ollama', # required by OpenAI SDK, but not used by Ollama
)

response = client.chat.completions.create(
    model="gemma3:1b",
    messages=[
        {
            "role": "user",
            "content": "Why is the sky blue?"
        },
    ],
)
print(response.choices[0].message.content)
  5. Ejecuta la secuencia de comandos en tu terminal:
    python3 ollama_chat.py
    Después de unos segundos, verás una respuesta similar a la que recibiste de la línea de comandos.
  6. Para probar el modo de transmisión, crea otro archivo llamado ollama_stream.py ejecutando lo siguiente en la terminal:
    cloudshell edit ollama_stream.py
  7. Pega el siguiente contenido en el archivo ollama_stream.py. Observa el parámetro stream=True en la solicitud. Esto permite que el modelo devuelva tokens en cuanto se generan.
    from openai import OpenAI

client = OpenAI(
    base_url = 'http://localhost:11434/v1',
    api_key='ollama',
)

stream = client.chat.completions.create(
    model="gemma3:1b",
    messages=[
        {
            "role": "user",
            "content": "Why is the sky blue?"
        },
    ],
    stream=True
)
for chunk in stream:
    if chunk.choices[0].delta.content is not None:
        print(chunk.choices[0].delta.content, end="", flush=True)
print()
  8. Ejecuta la secuencia de comandos de transmisión en la terminal:
    python3 ollama_stream.py
    La respuesta ahora aparecerá token por token.

La transmisión es una función útil para crear una buena experiencia del usuario en aplicaciones interactivas, como los chatbots. En lugar de hacer que el usuario espere a que se genere toda la respuesta, la transmisión continua muestra la respuesta token por token a medida que se crea. Esto proporciona comentarios inmediatos y hace que la aplicación se sienta mucho más receptiva.

Qué aprendiste: Ejecutar modelos abiertos con Ollama

Ejecutaste correctamente un modelo abierto con Ollama. Viste lo sencillo que puede ser descargar un modelo potente como Gemma 3 e interactuar con él, tanto a través de una interfaz de línea de comandos como de forma programática con Python. Este flujo de trabajo es ideal para el desarrollo local y la creación rápida de prototipos. Ahora tienes una base sólida para explorar opciones de implementación más avanzadas.

5. Implementa Gemma con Ollama en GKE Autopilot

Para las cargas de trabajo de producción que exigen operaciones simplificadas y escalabilidad, Google Kubernetes Engine (GKE) es la plataforma ideal. En esta tarea, implementarás Gemma con Ollama en un clúster de GKE Autopilot.

GKE Autopilot es un modo de operación en GKE en el que Google administra la configuración de tu clúster, incluidos los nodos, el escalamiento, la seguridad y otros parámetros de configuración ya establecidos. Crea una experiencia de Kubernetes verdaderamente "sin servidores", perfecta para ejecutar cargas de trabajo de inferencia sin administrar la infraestructura de procesamiento subyacente.

Prepara el entorno de GKE

Para la tarea final de implementación en Kubernetes, aprovisionarás un clúster de GKE Autopilot.

  1. En la terminal de Cloud Shell, configura las variables de entorno para tu proyecto y la región deseada.
    export PROJECT_ID=$(gcloud config get-value project)
export REGION=europe-west1

gcloud config set compute/region $REGION
  2. Para habilitar la API de GKE para tu proyecto, ejecuta el siguiente comando en la terminal:
    gcloud services enable container.googleapis.com
  3. Para crear un clúster de GKE Autopilot, ejecuta el siguiente comando en la terminal: 
    gcloud container clusters create-auto gemma-cluster \
  --region $REGION \
  --release-channel rapid
  4. Ejecuta el siguiente comando en la terminal para obtener las credenciales de tu clúster nuevo:
    gcloud container clusters get-credentials gemma-cluster \
  --region $REGION

Implementa Ollama y Gemma

Ahora que tienes un clúster de GKE Autopilot, puedes implementar el servidor de Ollama. Autopilot aprovisionará automáticamente recursos de procesamiento (CPU y memoria) según los requisitos que definas en el manifiesto de implementación.

  1. Para crear un archivo nuevo llamado gemma-deployment.yaml, ejecuta el siguiente comando en la terminal:
    cloudshell edit gemma-deployment.yaml
  2. Pega la siguiente configuración de YAML en gemma-deployment.yaml. Esta configuración define una implementación que usa la imagen oficial de Ollama para ejecutarse en la CPU.
    apiVersion: apps/v1
kind: Deployment
metadata:
  name: ollama-gemma
spec:
  replicas: 1
  selector:
    matchLabels:
      app: ollama-gemma
  template:
    metadata:
      labels:
        app: ollama-gemma
    spec:
      containers:
      - name: ollama-gemma-container
        image: ollama/ollama:0.12.10
        resources:
          requests:
            cpu: "8"
            memory: "8Gi"
            ephemeral-storage: "10Gi"
          limits:
            cpu: "8"
            memory: "8Gi"
            ephemeral-storage: "10Gi"
        # We use a script to start the server and pull the model
        command: ["/bin/bash", "-c"]
        args:
        - |
          ollama serve &
          OLLAMA_PID=$!
          echo "Waiting for Ollama server to start..."
          sleep 5
          echo "Pulling Gemma model..."
          ollama pull gemma3:1b
          echo "Model pulled. Ready to serve."
          wait $OLLAMA_PID
        ports:
        - containerPort: 11434
        env:
        - name: OLLAMA_HOST
          value: "0.0.0.0"
---
apiVersion: v1
kind: Service
metadata:
  name: llm-service
spec:
  selector:
    app: ollama-gemma
  type: ClusterIP
  ports:
  - protocol: TCP
    port: 8000
    targetPort: 11434
    A continuación, se incluye una explicación de la configuración de Autopilot:
    • image: ollama/ollama:latest: Especifica la imagen oficial de Docker de Ollama.
    • resources: Solicitamos explícitamente 8 CPUs virtuales y 8 Gi de memoria. GKE Autopilot usa estos valores para aprovisionar el procesamiento subyacente. Como no usamos GPUs, el modelo se ejecutará en la CPU. Los 8 GiB de memoria son suficientes para contener el modelo Gemma 1B y su contexto.
    • command/args: Anulamos el comando de inicio para garantizar que se extraiga el modelo cuando se inicie el pod. La secuencia de comandos inicia el servidor en segundo plano, espera a que esté listo, extrae el modelo gemma3:1b y, luego, mantiene el servidor en ejecución.
    • OLLAMA_HOST: Si configuras este parámetro como 0.0.0.0, te aseguras de que Ollama escuche en todas las interfaces de red dentro del contenedor, lo que lo hace accesible al servicio de Kubernetes.
  3. En la terminal, aplica el manifiesto de implementación al clúster:
    kubectl apply -f gemma-deployment.yaml
    Autopilot tardará unos minutos en aprovisionar los recursos y en iniciar el Pod. Puedes supervisarlo con el siguiente comando:
    kubectl get pods --watch
    Espera hasta que el estado del pod sea Running y READY sea 1/1 antes de continuar.

Prueba el extremo de GKE

Tu servicio de Ollama ahora se ejecuta en tu clúster de GKE Autopilot. Para probarlo desde tu terminal de Cloud Shell, usarás kubectl port-forward.

  1. Abre una nueva pestaña de la terminal de Cloud Shell (haz clic en el ícono + en la ventana de la terminal). El comando port-forward es un proceso de bloqueo, por lo que necesita su propia sesión de terminal.
  2. En la terminal nueva, ejecuta el siguiente comando para reenviar un puerto local (p.ej., 8000) al puerto del servicio (8000):
    kubectl port-forward service/llm-service 8000:8000
    Verás un resultado que indica que se inició el reenvío. Deja esta terminal en ejecución.
  3. Regresa a tu terminal original.
  4. Envía una solicitud a tu puerto local 8000. El servidor de Ollama expone una API compatible con OpenAI y, debido al reenvío de puertos, ahora puedes acceder a ella en http://127.0.0.1:8000.
    curl http://127.0.0.1:8000/v1/chat/completions \
-H "Content-Type: application/json" \
-d '{
"model": "gemma3:1b",
"messages": [
{"role": "user", "content": "Explain why the sky is blue."}
]
}'
    El servicio devolverá una respuesta JSON con la finalización del modelo.

6. Corrección

Para evitar que se apliquen cargos a tu cuenta de Google Cloud por los recursos que usaste en este lab, sigue estos pasos para borrar el clúster de GKE.

  1. En la terminal de Cloud Shell, borra el clúster de Autopilot de GKE:
    gcloud container clusters delete gemma-cluster \
  --region $REGION --quiet
    Este comando quitará el clúster y todos los recursos asociados.

7. Conclusión

¡Bien hecho! En este lab, exploraste varios métodos clave para implementar modelos abiertos en Google Cloud. Comenzaste con la simplicidad y la velocidad del desarrollo local con Ollama. Por último, implementaste Gemma en un entorno escalable y de nivel de producción con Google Kubernetes Engine Autopilot y el framework de Ollama.

Ahora tienes el conocimiento necesario para implementar modelos abiertos en Google Kubernetes Engine para cargas de trabajo exigentes y escalables sin administrar la infraestructura subyacente.

Resumen

En este lab, aprendiste lo siguiente:

  • Qué son los modelos abiertos y por qué son importantes
  • Cómo ejecutar un modelo abierto de forma local con Ollama
  • Cómo implementar un modelo abierto en Google Kubernetes Engine (GKE) Autopilot con Ollama para la inferencia

Más información