Déployer des modèles ouverts sur GKE

1. Introduction

Présentation

L'objectif de cet atelier est de vous permettre de déployer un modèle Open Source sur Google Cloud, en passant d'une configuration locale simple à un déploiement de niveau production sur Google Kubernetes Engine (GKE). Vous apprendrez à utiliser différents outils adaptés à chaque étape du cycle de vie du développement.

L'atelier suit le chemin suivant :

  • Prototypage rapide : vous allez d'abord exécuter un modèle avec Ollama en local pour voir à quel point il est facile de se lancer.
  • Déploiement en production : enfin, vous allez déployer le modèle sur GKE Autopilot à l'aide d'Ollama en tant que moteur de diffusion évolutif.

Comprendre les modèles ouverts

De nos jours, le terme "modèle ouvert" fait généralement référence à un modèle d'apprentissage automatique génératif que tout le monde peut télécharger et utiliser publiquement. Cela signifie que l'architecture du modèle et, surtout, ses paramètres ou "pondérations" entraînés sont publiés.

Cette transparence offre plusieurs avantages par rapport aux modèles fermés, qui ne sont généralement accessibles que par le biais d'une API restrictive :

  • Insight : les développeurs et les chercheurs peuvent "regarder sous le capot" pour comprendre le fonctionnement interne du modèle.
  • Personnalisation : les utilisateurs peuvent adapter le modèle à des tâches spécifiques grâce à un processus appelé "réglage fin".
  • Innovation : elle permet à la communauté de créer des applications nouvelles et innovantes à partir de modèles existants performants.

Contribution de Google et famille Gemma

Google contribue depuis de nombreuses années au mouvement de l'IA Open Source. L'architecture Transformer révolutionnaire, présentée dans l'article de 2017 "Attention Is All You Need", est à la base de presque tous les grands modèles de langage modernes. Ont ensuite suivi des modèles ouverts emblématiques tels que BERT, T5 et Flan-T5, affinés pour les instructions, qui ont chacun repoussé les limites du possible et alimenté la recherche et le développement dans le monde entier.

S'appuyant sur cette riche histoire d'innovation ouverte, Google a lancé la famille de modèles Gemma. Les modèles Gemma sont créés à partir des mêmes recherches et technologies que celles utilisées pour les puissants modèles Gemini à source fermée, mais ils sont disponibles avec des pondérations ouvertes. Pour les clients Google Cloud, cela offre une combinaison puissante de technologies de pointe et de flexibilité de l'Open Source, leur permettant de contrôler le cycle de vie des modèles, de s'intégrer à un écosystème diversifié et de poursuivre une stratégie multicloud.

Coup de projecteur sur Gemma 3

Dans cet atelier, nous allons nous concentrer sur Gemma 3, la dernière génération de cette famille, et la plus performante. Les modèles Gemma 3 sont légers, mais ultra-performants. Ils sont conçus pour s'exécuter efficacement sur un seul GPU, voire un seul CPU.

  • Performances et taille : les modèles Gemma 3 sont légers, mais ultra-performants. Ils sont conçus pour s'exécuter efficacement sur un seul GPU, voire sur un seul CPU. Ils offrent une qualité supérieure et des performances de pointe pour leur taille.
  • Modalité : les modèles sont multimodaux et peuvent traiter des entrées de texte et d'images pour générer des sorties de texte.
  • Principales caractéristiques : Gemma 3 dispose d'une grande fenêtre de contexte de 128 k et prend en charge plus de 140 langues.
  • Cas d'utilisation : ces modèles sont parfaitement adaptés à diverses tâches, comme répondre à des questions, résumer et raisonner.

Terminologie clé

Lorsque vous utilisez des modèles ouverts, vous rencontrez quelques termes courants :

  • Le pré-entraînement consiste à entraîner un modèle sur un ensemble de données volumineux et diversifié pour qu'il apprenne des schémas de langage généraux. Ces modèles sont essentiellement de puissantes machines de saisie semi-automatique.
  • Le réglage des instructions affine un modèle pré-entraîné pour qu'il suive mieux des instructions et des requêtes spécifiques. Il s'agit des modèles qui "savent comment discuter".
  • Variantes de modèle : les modèles ouverts sont généralement disponibles en plusieurs tailles (par exemple, Gemma 3 est disponible en versions à 1 B, 4 B, 12 B et 27 B de paramètres, ainsi qu'en variantes, telles que les versions adaptées aux instructions (-it), pré-entraînées ou quantifiées pour l'efficacité.
  • Besoins en ressources : les grands modèles de langage sont volumineux et nécessitent d'importantes ressources de calcul pour être hébergés. Bien qu'elles puissent être exécutées localement, leur déploiement dans le cloud offre une valeur significative, en particulier lorsqu'elles sont optimisées pour les performances et la scalabilité avec des outils tels qu'Ollama.

Pourquoi choisir GKE pour diffuser des modèles ouverts ?

Cet atelier vous guide depuis l'exécution simple et locale d'un modèle jusqu'à un déploiement de production à grande échelle sur Google Kubernetes Engine (GKE). Bien que des outils tels qu'Ollama soient excellents pour le prototypage rapide, les environnements de production présentent un ensemble d'exigences exigeantes que GKE est particulièrement bien placé pour satisfaire.

Pour les applications d'IA à grande échelle, vous avez besoin de plus qu'un simple modèle en cours d'exécution. Vous avez besoin d'une infrastructure de diffusion résiliente, évolutive et efficace. GKE fournit cette base. Voici quand et pourquoi choisir GKE :

  • Gestion simplifiée avec Autopilot : GKE Autopilot gère l'infrastructure sous-jacente pour vous. Vous vous concentrez sur la configuration de votre application, et Autopilot provisionne et ajuste automatiquement les nœuds.
  • Performances et évolutivité élevées : gérez un trafic exigeant et variable grâce au scaling automatique de GKE. Cela permet à votre application d'offrir un débit élevé avec une faible latence, en effectuant un scaling à la hausse ou à la baisse selon les besoins.
  • Rentabilité à grande échelle : gérez efficacement les ressources. GKE peut réduire les charges de travail à zéro pour éviter de payer les ressources inactives. Vous pouvez également utiliser des VM Spot pour réduire considérablement les coûts des charges de travail d'inférence sans état.
  • Portabilité et écosystème riche : évitez la dépendance vis-à-vis d'un fournisseur grâce à un déploiement portable basé sur Kubernetes. GKE donne également accès au vaste écosystème Cloud Native (CNCF) pour des outils de surveillance, de journalisation et de sécurité de premier ordre.

En bref, vous passez à GKE lorsque votre application d'IA est prête pour la production et nécessite une plate-forme conçue pour une évolutivité, des performances et une maturité opérationnelle importantes.

Points abordés

Dans cet atelier, vous allez apprendre à effectuer les tâches suivantes :

  • Exécutez un modèle ouvert en local avec Ollama.
  • Déployez un modèle ouvert sur Google Kubernetes Engine (GKE) Autopilot avec Ollama pour le service.
  • Comprenez la progression des frameworks de développement locaux vers une architecture de diffusion de niveau production sur GKE.

2. Configuration du projet

Compte Google

Si vous ne possédez pas encore de compte Google personnel, vous devez en créer un.

Utilisez un compte personnel au lieu d'un compte professionnel ou scolaire.

Se connecter à la console Google Cloud

Connectez-vous à la console Google Cloud à l'aide d'un compte Google personnel.

Activer la facturation

Configurer un compte de facturation personnel

Si vous avez configuré la facturation à l'aide de crédits Google Cloud, vous pouvez ignorer cette étape.

Pour configurer un compte de facturation personnel, cliquez ici pour activer la facturation dans la console Cloud.

Remarques :

  • Cet atelier devrait vous coûter moins de 1 USD en ressources Cloud.
  • Vous pouvez suivre les étapes à la fin de cet atelier pour supprimer les ressources et éviter ainsi que des frais supplémentaires ne vous soient facturés.
  • Les nouveaux utilisateurs peuvent bénéficier d'un essai sans frais pour un crédit de 300$.

Créer un projet (facultatif)

Si vous n'avez pas de projet que vous souhaitez utiliser pour cet atelier, créez-en un.

3. Ouvrir l'éditeur Cloud Shell

  1. Cliquez sur ce lien pour accéder directement à l'éditeur Cloud Shell.
  2. Si vous êtes invité à autoriser l'accès à un moment donné, cliquez sur Autoriser pour continuer.Cliquez pour autoriser Cloud Shell.
  3. Si le terminal ne s'affiche pas en bas de l'écran, ouvrez-le :
    • Cliquez sur Afficher.
    • Cliquez sur TerminalOuvrir un nouveau terminal dans l'éditeur Cloud Shell.
  4. Dans le terminal, définissez votre projet à l'aide de la commande suivante :
    gcloud config set project [PROJECT_ID]
    • Exemple :
      gcloud config set project lab-project-id-example
    • Si vous ne vous souvenez pas de l'ID de votre projet, vous pouvez lister tous vos ID de projet avec la commande suivante :
      gcloud projects list
      Définir l'ID du projet dans le terminal de l'éditeur Cloud Shell
  5. Le message suivant doit s'afficher :
    Updated property [core/project].

4. Exécuter Gemma avec Ollama

Votre premier objectif est d'exécuter Gemma 3 le plus rapidement possible dans un environnement de développement. Vous utiliserez Ollama, un outil qui simplifie considérablement l'exécution de grands modèles de langage en local. Cette tâche vous montre la façon la plus simple de commencer à expérimenter avec un modèle ouvert.

Ollama est un outil Open Source sans frais qui permet aux utilisateurs d'exécuter des modèles génératifs (grands modèles de langage, modèles vision-langage, etc.) en local sur leur propre ordinateur. Il simplifie l'accès à ces modèles et l'interaction avec eux, les rendant plus accessibles et permettant aux utilisateurs de travailler avec eux de manière privée.

Installer et exécuter Ollama

Vous êtes maintenant prêt à installer Ollama, à télécharger le modèle Gemma 3 et à interagir avec lui depuis la ligne de commande.

  1. Dans le terminal Cloud Shell, téléchargez et installez Ollama :
    curl -fsSL https://ollama.com/install.sh | sh
    Cette commande télécharge Ollama, l'installe et démarre le service Ollama.
  2. Démarrez le service Ollama en arrière-plan :
    ollama serve &
  3. Extrayez (téléchargez) le modèle Gemma 3 1B avec Ollama :
    ollama pull gemma3:1b
  4. Exécutez le modèle localement :
    ollama run gemma3:1b
    La commande ollama run présente un prompt (>>>) pour vous permettre de poser des questions au modèle.
  5. Testez le modèle en lui posant une question. Par exemple, saisissez Why is the sky blue? et appuyez sur ENTRÉE. Un résultat semblable à celui-ci doit s'afficher :
    >>> 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. Pour quitter l'invite Ollama dans le terminal, saisissez /bye et appuyez sur ENTRÉE.

Utiliser le SDK OpenAI avec Ollama

Maintenant que le service Ollama est en cours d'exécution, vous pouvez interagir avec lui de manière programmatique. Vous utiliserez le SDK Python OpenAI, qui est compatible avec l'API exposée par Ollama.

  1. Dans le terminal Cloud Shell, créez et activez un environnement virtuel à l'aide d'uv. Cela permet de s'assurer que les dépendances de votre projet ne sont pas en conflit avec le système Python.
    uv venv --python 3.14
source .venv/bin/activate
  2. Dans le terminal, installez le SDK OpenAI :
    uv pip install openai
  3. Créez un fichier nommé ollama_chat.py en saisissant la commande suivante dans le terminal :
    cloudshell edit ollama_chat.py
  4. Collez le code Python suivant dans ollama_chat.py. Ce code envoie une requête au serveur Ollama local.
    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. Exécutez le script dans votre terminal :
    python3 ollama_chat.py
    Après quelques secondes, une réponse semblable à celle que vous avez reçue dans la ligne de commande s'affiche.
  6. Pour essayer le mode streaming, créez un autre fichier nommé ollama_stream.py en exécutant la commande suivante dans le terminal :
    cloudshell edit ollama_stream.py
  7. Collez le contenu suivant dans le fichier ollama_stream.py. Notez le paramètre stream=True dans la requête. Cela permet au modèle de renvoyer des jetons dès qu'ils sont générés.
    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. Exécutez le script de streaming dans le terminal :
    python3 ollama_stream.py
    La réponse s'affiche désormais jeton par jeton.

Le streaming est une fonctionnalité utile pour créer une expérience utilisateur de qualité dans les applications interactives telles que les chatbots. Au lieu de faire attendre l'utilisateur jusqu'à ce que la réponse complète soit générée, le streaming affiche la réponse jeton par jeton au fur et à mesure de sa création. Cela fournit un retour immédiat et rend l'application beaucoup plus réactive.

Ce que vous avez appris : exécuter des modèles ouverts avec Ollama

Vous avez exécuté un modèle ouvert à l'aide d'Ollama. Vous avez vu à quel point il peut être simple de télécharger un modèle puissant comme Gemma 3 et d'interagir avec lui, à la fois via une interface de ligne de commande et de manière programmatique avec Python. Ce workflow est idéal pour le prototypage rapide et le développement local. Vous disposez désormais d'une base solide pour explorer des options de déploiement plus avancées.

5. Déployer Gemma avec Ollama sur GKE Autopilot

Pour les charges de travail de production qui exigent des opérations simplifiées et de l'évolutivité, Google Kubernetes Engine (GKE) est la plate-forme de choix. Dans cette tâche, vous allez déployer Gemma à l'aide d'Ollama sur un cluster GKE Autopilot.

GKE Autopilot est un mode de fonctionnement de GKE dans lequel Google gère la configuration de votre cluster, y compris vos nœuds, le scaling, la sécurité et d'autres paramètres préconfigurés. Elle crée une expérience Kubernetes véritablement "sans serveur", idéale pour exécuter des charges de travail d'inférence sans gérer l'infrastructure de calcul sous-jacente.

Préparer l'environnement GKE

Pour la dernière tâche de déploiement sur Kubernetes, vous allez provisionner un cluster GKE Autopilot.

  1. Dans le terminal Cloud Shell, définissez des variables d'environnement pour votre projet et la région souhaitée.
    export PROJECT_ID=$(gcloud config get-value project)
export REGION=europe-west1

gcloud config set compute/region $REGION
  2. Activez l'API GKE pour votre projet en exécutant la commande suivante dans le terminal :
    gcloud services enable container.googleapis.com
  3. Créez un cluster GKE Autopilot en exécutant la commande suivante dans le terminal : 
    gcloud container clusters create-auto gemma-cluster \
  --region $REGION \
  --release-channel rapid
  4. Obtenez les identifiants pour votre nouveau cluster en exécutant la commande suivante dans le terminal :
    gcloud container clusters get-credentials gemma-cluster \
  --region $REGION

Déployer Ollama et Gemma

Maintenant que vous disposez d'un cluster GKE Autopilot, vous pouvez déployer le serveur Ollama. Autopilot provisionne automatiquement les ressources de calcul (processeur et mémoire) en fonction des exigences que vous définissez dans votre fichier manifeste de déploiement.

  1. Créez un fichier nommé gemma-deployment.yaml en exécutant la commande suivante dans le terminal :
    cloudshell edit gemma-deployment.yaml
  2. Collez la configuration YAML suivante dans gemma-deployment.yaml. Cette configuration définit un déploiement qui utilise l'image Ollama officielle pour s'exécuter sur le processeur.
    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
    Voici une explication de la configuration pour Autopilot :
    • image: ollama/ollama:latest : spécifie l'image Docker officielle d'Ollama.
    • resources : nous demandons explicitement 8 processeurs virtuels et 8 Gio de mémoire. GKE Autopilot utilise ces valeurs pour provisionner le calcul sous-jacent. Comme nous n'utilisons pas de GPU, le modèle s'exécutera sur le processeur. Les 8 Gio de mémoire sont suffisants pour contenir le modèle Gemma 1B et son contexte.
    • command/args : nous remplaçons la commande de démarrage pour nous assurer que le modèle est extrait au démarrage du pod. Le script démarre le serveur en arrière-plan, attend qu'il soit prêt, extrait le modèle gemma3:1b, puis maintient le serveur en cours d'exécution.
    • OLLAMA_HOST : si vous définissez cette valeur sur 0.0.0.0, Ollama écoute toutes les interfaces réseau du conteneur, ce qui le rend accessible au service Kubernetes.
  3. Dans le terminal, appliquez le fichier manifeste de déploiement à votre cluster :
    kubectl apply -f gemma-deployment.yaml
    Autopilot mettra quelques minutes à provisionner les ressources et à démarrer le pod. Vous pouvez le surveiller avec la commande suivante :
    kubectl get pods --watch
    Attendez que l'état du pod soit Running et que READY soit 1/1 avant de continuer.

Tester le point de terminaison GKE

Votre service Ollama est maintenant en cours d'exécution sur votre cluster GKE Autopilot. Pour le tester à partir de votre terminal Cloud Shell, vous utiliserez kubectl port-forward.

  1. Ouvrez un nouvel onglet de terminal Cloud Shell (cliquez sur l'icône + dans la fenêtre du terminal). La commande port-forward est un processus bloquant. Elle a donc besoin de sa propre session de terminal.
  2. Dans le nouveau terminal, exécutez la commande suivante pour transférer un port local (par exemple, 8000) au port du service (8000) :
    kubectl port-forward service/llm-service 8000:8000
    Vous verrez un résultat indiquant que le transfert a commencé. Laissez ce terminal en cours d'exécution.
  3. Revenez à votre terminal d'origine.
  4. Envoyez une requête à votre port local 8000. Le serveur Ollama expose une API compatible avec OpenAI. Grâce à la redirection de port, vous pouvez désormais y accéder à l'adresse 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."}
]
}'
    Le service renverra une réponse JSON avec la réponse du modèle.

6. Effectuer un nettoyage

Pour éviter que les ressources utilisées dans cet atelier soient facturées sur votre compte Google Cloud, suivez ces étapes pour supprimer le cluster GKE.

  1. Dans le terminal Cloud Shell, supprimez le cluster GKE Autopilot :
    gcloud container clusters delete gemma-cluster \
  --region $REGION --quiet
    Cette commande supprimera le cluster et toutes les ressources associées.

7. Conclusion

Bravo ! Dans cet atelier, vous avez découvert plusieurs méthodes clés pour déployer des modèles ouverts sur Google Cloud. Vous avez commencé par la simplicité et la rapidité du développement local avec Ollama. Enfin, vous avez déployé Gemma dans un environnement évolutif de niveau production à l'aide de Google Kubernetes Engine Autopilot et du framework Ollama.

Vous disposez désormais des connaissances nécessaires pour déployer des modèles ouverts sur Google Kubernetes Engine pour des charges de travail exigeantes et évolutives, sans avoir à gérer l'infrastructure sous-jacente.

Récapitulatif

Dans cet atelier, vous avez appris à :

  • Découvrez ce que sont les modèles ouverts et pourquoi ils sont importants.
  • Exécuter un modèle ouvert en local avec Ollama
  • Découvrez comment déployer un modèle ouvert sur Google Kubernetes Engine (GKE) Autopilot à l'aide d'Ollama pour l'inférence.

En savoir plus