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 de producción: Por último, implementarás el modelo en GKE Autopilot con Ollama como un motor de entrega escalable.

Información sobre los modelos abiertos

Hoy en día, las personas suelen referirse a un "modelo abierto" como un modelo de aprendizaje automático generativo que está disponible públicamente para que todos lo descarguen y usen. Esto significa que la arquitectura del modelo y, lo que es más importante, sus parámetros o "pesos" entrenados se publican.

Esta transparencia ofrece varias ventajas sobre los modelos cerrados, a los que, por lo general, solo se accede a través de una API restrictiva:

  • Informació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 compilar aplicaciones nuevas e innovadoras sobre modelos existentes potentes.

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 esto le siguieron modelos abiertos históricos como BERT, T5 y Flan-T5 ajustado por instrucciones, cada uno de los cuales superó los límites de lo que era posible y fomentó la investigación y el desarrollo en todo el mundo.

Sobre la base de esta rica historia de innovación abierta, Google presentó la familia de modelos Gemma. Los modelos de Gemma se crean a partir de la misma investigación y tecnología que se usan para los potentes modelos de 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.

Fotos destacadas de 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 livianos, pero de última generació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 livianos, pero de última generació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 última generación (SOTA) para su tamaño.
  • Modalidad: Son multimodales y capaces de controlar la entrada de texto y de imágenes para generar texto como resultado.
  • Funciones clave: Gemma 3 tiene una gran ventana de contexto de 128K y admite más de 140 idiomas.
  • Casos de uso: Estos modelos son adecuados para una variedad de tareas, lo que incluye la búsqueda de respuestas, el resumen y el razonamiento.

Terminología clave

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

  • El entrenamiento previo implica entrenar un modelo en un conjunto de datos masivo y diverso para aprender patrones generales del lenguaje. Estos modelos son esencialmente potentes máquinas de autocompletado.
  • El ajuste de instrucciones ajusta un modelo previamente entrenado para que siga mejor las instrucciones y los mensajes específicos. Estos son los modelos que "saben cómo chatear".
  • Variantes de modelos: Por lo general, los modelos abiertos se lanzan en varios tamaños (p.ej., Gemma 3 tiene versiones de parámetros de 1B, 4B, 12B y 27B) y variantes, como el ajuste de instrucciones (-it), el entrenamiento previo o la cuantización para lograr eficiencia.
  • Necesidades de recursos: Los modelos de lenguaje grandes son grandes y requieren recursos de procesamiento significativos para alojarlos. 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é GKE para entregar modelos abiertos?

Este lab te guía desde la ejecución de modelos locales simples hasta una implementación de producción a gran escala en Google Kubernetes Engine (GKE). Si bien las herramientas como Ollama son excelentes para el prototipado rápido, 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 más que un modelo en ejecución; necesitas una infraestructura de entrega resistente, escalable y eficiente. GKE proporciona esta base. Aquí se explica 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 escala los nodos automáticamente.
  • Alto rendimiento y escalabilidad: Controla el tráfico exigente y variable con el escalamiento automático de GKE. Esto garantiza que tu aplicación pueda ofrecer una alta capacidad de procesamiento con baja latencia, y que se escale verticalmente según sea necesario.
  • Rentabilidad a gran escala: Administra los recursos de manera eficiente. GKE puede reducir las cargas de trabajo a cero para evitar pagar por los 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 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 de su clase.

En resumen, debes pasar a GKE cuando tu aplicación de IA esté lista para la producción y requiera una plataforma diseñada para una escala, un rendimiento y una madurez operativa serios.

Qué aprenderás

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

  • Ejecutar un modelo abierto de forma local con Ollama
  • Implementar un modelo abierto en Autopilot de Google Kubernetes Engine (GKE) con Ollama para la entrega
  • Comprender la progresión de los frameworks de desarrollo local a una arquitectura de entrega de nivel de producción en GKE

2. Configura el proyecto

Cuenta de Google

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

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 personal de Google.

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.

Algunas 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 los recursos y evitar cargos adicionales.
  • Los usuarios nuevos son aptos para 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 hoy, 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 TerminalAbre 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 del proyecto, puedes enumerar todos los IDs del proyecto con:
      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 que Gemma 3 se ejecute lo más rápido posible en un entorno de desarrollo. Usarás Ollama, una herramienta que simplifica de manera drástica 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 visual y mucho más) de forma local en su propia computadora. Simplifica el proceso de acceso e interacción con estos modelos, lo que los hace más accesibles y permite a los usuarios trabajar con ellos de forma privada.

Instala y ejecuta Ollama

Ahora, estás listo para instalar Ollama, descargar el modelo Gemma 3 y 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 un mensaje (>>>) 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 del mensaje 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 OpenAI para Python, 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 desde 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 muestre 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 chatbots. En lugar de hacer que el usuario espere a que se genere la respuesta completa, la transmisión 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 responsiva.

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 prototipado rápido y el desarrollo local. 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 y escalabilidad simplificadas, Google Kubernetes Engine (GKE) es la plataforma de elección. En esta tarea, implementarás Gemma con Ollama en un clúster de GKE Autopilot.

Autopilot de GKE 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 lo siguiente en la terminal:
    gcloud services enable container.googleapis.com
  3. Para crear un clúster de GKE Autopilot, ejecuta lo siguiente en la terminal: 
    gcloud container clusters create-auto gemma-cluster \
  --region $REGION \
  --release-channel rapid
  4. Para obtener credenciales para tu clúster nuevo, ejecuta lo siguiente en la terminal:
    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 los recursos de procesamiento (CPU y memoria) según los requisitos que definas en tu manifiesto de implementación.

  1. Para crear un archivo nuevo llamado gemma-deployment.yaml, ejecuta lo siguiente 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 explica la configuración de Autopilot:
    • image: ollama/ollama:latest: Especifica la imagen oficial de Docker de Ollama.
    • resources: Solicitamos explícitamente 8 CPU virtuales y 8Gi de memoria. GKE Autopilot usa estos valores para aprovisionar el procesamiento subyacente. Como no usamos GPUs, el modelo se ejecutará en la CPU. Los 8Gi de memoria son suficientes para contener el modelo Gemma 1B y su contexto.
    • command/args: Anulamos el comando de inicio para garantizar que el modelo se extraiga cuando se inicia 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 se establece en 0.0.0.0, se garantiza 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 a tu clúster:
    kubectl apply -f gemma-deployment.yaml
    Autopilot tardará unos minutos en aprovisionar los recursos y en iniciar el pod. Puedes supervisarlo con:
    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 pestaña nueva 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 mostrará 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 GKE Autopilot:
    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, recorriste 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 de nivel de producción con Autopilot de Google Kubernetes Engine 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