Deployment di modelli aperti su GKE

1. Introduzione

Panoramica

Lo scopo di questo lab è quello di fornirti un'esperienza pratica di deployment di un modello aperto su Google Cloud, passando da una semplice configurazione locale a un deployment di livello di produzione su Google Kubernetes Engine (GKE). Imparerai a utilizzare diversi strumenti adatti a ogni fase del ciclo di vita dello sviluppo.

Il lab segue questo percorso:

  • Prototipazione rapida: per prima cosa, esegui un modello con Ollama in locale per vedere quanto è facile iniziare.
  • Deployment di produzione: infine, eseguirai il deployment del modello in GKE Autopilot utilizzando Ollama come motore di gestione scalabile.

Informazioni sui modelli aperti

Con "modello aperto" oggi si intende in genere un modello di machine learning generativo disponibile pubblicamente per il download e l'utilizzo da parte di tutti. Ciò significa che l'architettura del modello e, soprattutto, i suoi parametri o "pesi" addestrati vengono rilasciati pubblicamente.

Questa trasparenza offre diversi vantaggi rispetto ai modelli chiusi, a cui in genere si accede solo tramite un'API restrittiva:

  • Approfondimento: sviluppatori e ricercatori possono esaminare il funzionamento interno del modello.
  • Personalizzazione: gli utenti possono adattare il modello per attività specifiche tramite un processo chiamato fine-tuning.
  • Innovazione: consente alla community di creare applicazioni nuove e innovative basate su modelli esistenti potenti.

Il contributo di Google e la famiglia Gemma

Google contribuisce da molti anni al movimento dell'AI open source. La rivoluzionaria architettura Transformer, introdotta nel documento del 2017 "Attention Is All You Need", è la base di quasi tutti i moderni modelli linguistici di grandi dimensioni. A questi sono seguiti modelli aperti di riferimento come BERT, T5 e Flan-T5, ottimizzato per le istruzioni, ognuno dei quali ha superato i limiti di ciò che era possibile e ha alimentato la ricerca e lo sviluppo in tutto il mondo.

Sulla base di questa ricca storia di innovazione aperta, Google ha introdotto la famiglia di modelli Gemma. I modelli Gemma sono creati sulla base della stessa ricerca e tecnologia utilizzata per i potenti modelli Gemini closed source, ma sono disponibili con pesi aperti. Per i clienti Google Cloud, questa combinazione offre una potente combinazione di tecnologia all'avanguardia e flessibilità dell'open source, consentendo loro di controllare il ciclo di vita del modello, integrarsi con un ecosistema diversificato e perseguire una strategia multi-cloud.

In evidenza: Gemma 3

In questo lab ci concentreremo su Gemma 3, la generazione più recente e potente di questa famiglia. I modelli Gemma 3 sono leggeri ma all'avanguardia e sono progettati per essere eseguiti in modo efficiente su una singola GPU o anche su una CPU.

  • Prestazioni e dimensioni: i modelli Gemma 3 sono leggeri ma all'avanguardia, progettati per essere eseguiti in modo efficiente su una singola GPU o anche su una CPU. Offrono una qualità superiore e prestazioni all'avanguardia (SOTA) per le loro dimensioni.
  • Modalità: sono multimodali, in grado di gestire input di testo e immagini per generare output di testo.
  • Funzionalità chiave: Gemma 3 ha un'ampia finestra contestuale di 128.000 e supporta oltre 140 lingue.
  • Casi d'uso: questi modelli sono adatti a una serie di attività, tra cui rispondere a domande, riassumere contenuti ed elaborare ragionamenti.

Terminologia chiave

Quando lavori con modelli aperti, incontrerai alcuni termini comuni:

  • Il preaddestramento prevede l'addestramento di un modello su un set di dati enorme e diversificato per apprendere pattern linguistici generali. Questi modelli sono essenzialmente potenti macchine di completamento automatico.
  • L'ottimizzazione delle istruzioni perfeziona un modello preaddestrato per seguire meglio istruzioni e prompt specifici. Questi sono i modelli che "sanno come chattare".
  • Varianti del modello: i modelli aperti vengono in genere rilasciati in più dimensioni (ad es. Gemma 3 ha versioni con 1 miliardo, 4 miliardi, 12 miliardi e 27 miliardi di parametri e varianti, come quelle ottimizzate per le istruzioni (-it), preaddestrate o quantizzate per l'efficienza.
  • Necessità di risorse: i modelli linguistici di grandi dimensioni sono grandi e richiedono risorse di calcolo significative per l'hosting. Sebbene possano essere eseguiti localmente, il loro deployment nel cloud offre un valore significativo, soprattutto se ottimizzati per le prestazioni e la scalabilità con strumenti come Ollama.

Perché GKE per la pubblicazione di modelli aperti?

Questo lab ti guida dall'esecuzione semplice e locale del modello a un deployment di produzione su larga scala su Google Kubernetes Engine (GKE). Sebbene strumenti come Ollama siano eccellenti per la prototipazione rapida, gli ambienti di produzione hanno una serie di requisiti impegnativi che GKE è in una posizione unica per soddisfare.

Per le applicazioni di AI su larga scala, non è sufficiente un modello in esecuzione, ma è necessaria un'infrastruttura di serving resiliente, scalabile ed efficiente. GKE fornisce queste basi. Ecco quando e perché scegliere GKE:

  • Gestione semplificata con Autopilot: GKE Autopilot gestisce l'infrastruttura di base per te. Ti concentri sulla configurazione dell'applicazione e Autopilot esegue il provisioning e lo scaling dei nodi automaticamente.
  • Prestazioni e scalabilità elevate: gestisci il traffico variabile e impegnativo con la scalabilità automatica di GKE. In questo modo, la tua applicazione può offrire un throughput elevato con una latenza ridotta, scalando verso l'alto o verso il basso in base alle esigenze.
  • Convenienza su larga scala: gestisci le risorse in modo efficiente. GKE può ridurre i carichi di lavoro a zero per evitare di pagare le risorse inattive e puoi sfruttare le VM spot per ridurre significativamente i costi per i carichi di lavoro di inferenza stateless.
  • Portabilità ed ecosistema ricco: evita i vincoli al fornitore con un deployment portatile basato su Kubernetes. GKE fornisce anche l'accesso al vasto ecosistema Cloud Native (CNCF) per strumenti di monitoraggio, logging e sicurezza di prima classe.

In breve, passi a GKE quando la tua applicazione AI è pronta per la produzione e richiede una piattaforma progettata per scalabilità, prestazioni e maturità operativa elevate.

Obiettivi didattici

In questo lab imparerai a:

  • Esegui un modello aperto localmente con Ollama.
  • Esegui il deployment di un modello aperto in Google Kubernetes Engine (GKE) Autopilot con Ollama per la pubblicazione.
  • Comprendere la progressione dai framework di sviluppo locali a un'architettura di pubblicazione di livello di produzione su GKE.

2. Configurazione del progetto

Account Google

Se non hai ancora un Account Google personale, devi crearne uno.

Utilizza un account personale anziché un account di lavoro o della scuola.

Accedi alla console Google Cloud

Accedi a Google Cloud Console utilizzando un Account Google personale.

Abilita fatturazione

Configurare un account di fatturazione personale

Se hai configurato la fatturazione utilizzando i crediti Google Cloud, puoi saltare questo passaggio.

Per configurare un account di fatturazione personale, vai qui per abilitare la fatturazione in Cloud Console.

Alcune note:

  • Il completamento di questo lab dovrebbe costare meno di 1 $in risorse cloud.
  • Per evitare ulteriori addebiti, puoi seguire i passaggi alla fine di questo lab per eliminare le risorse.
  • I nuovi utenti hanno diritto alla prova senza costi di 300$.

Crea un progetto (facoltativo)

Se non hai un progetto attuale che vuoi utilizzare per questa etichetta, creane uno nuovo qui.

3. Apri editor di Cloud Shell

  1. Fai clic su questo link per andare direttamente all'editor di Cloud Shell.
  2. Se ti viene richiesto di concedere l'autorizzazione in qualsiasi momento della giornata, fai clic su Autorizza per continuare.Fai clic per autorizzare Cloud Shell
  3. Se il terminale non viene visualizzato nella parte inferiore dello schermo, aprilo:
    • Fai clic su Visualizza.
    • Fai clic su TerminaleApri un nuovo terminale nell'editor di Cloud Shell.
  4. Nel terminale, imposta il progetto con questo comando:
    gcloud config set project [PROJECT_ID]
    • Esempio:
      gcloud config set project lab-project-id-example
    • Se non ricordi l'ID progetto, puoi elencare tutti i tuoi ID progetto con:
      gcloud projects list
      Imposta l'ID progetto nel terminale dell'editor di Cloud Shell
  5. Dovresti vedere questo messaggio:
    Updated property [core/project].

4. Esegui Gemma con Ollama

Il tuo primo obiettivo è eseguire Gemma 3 il più rapidamente possibile in un ambiente di sviluppo. Utilizzerai Ollama, uno strumento che semplifica notevolmente l'esecuzione locale di modelli linguistici di grandi dimensioni. Questa attività mostra il modo più semplice per iniziare a sperimentare con un modello aperto.

Ollama è uno strumento open source senza costi che consente agli utenti di eseguire modelli generativi (modelli linguistici di grandi dimensioni, modelli di visione-linguaggio e altro ancora) localmente sul proprio computer. Semplifica il processo di accesso e interazione con questi modelli, rendendoli più accessibili e consentendo agli utenti di utilizzarli in privato.

Installa ed esegui Ollama

Ora puoi installare Ollama, scaricare il modello Gemma 3 e interagire con esso dalla riga di comando.

  1. Nel terminale Cloud Shell, scarica e installa Ollama:
    curl -fsSL https://ollama.com/install.sh | sh
    Questo comando scarica Ollama, lo installa e avvia il servizio Ollama.
  2. Avvia il servizio Ollama in background:
    ollama serve &
  3. Esegui il pull (scarica) del modello Gemma 3 1B con Ollama:
    ollama pull gemma3:1b
  4. Esegui il modello localmente:
    ollama run gemma3:1b
    Il comando ollama run presenta un prompt (>>>) per porre domande al modello.
  5. Testare il modello con una domanda. Ad esempio, digita Why is the sky blue? e premi Invio. Dovresti visualizzare una risposta simile alla seguente:
    >>> 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. Per uscire dal prompt di Ollama nel terminale, digita /bye e premi Invio.

Utilizzare l'SDK OpenAI con Ollama

Ora che il servizio Ollama è in esecuzione, puoi interagire con esso a livello di programmazione. Utilizzerai l'SDK Python di OpenAI, compatibile con l'API esposta da Ollama.

  1. Nel terminale Cloud Shell, crea e attiva un ambiente virtuale utilizzando uv. In questo modo, le dipendenze del progetto non entrano in conflitto con Python di sistema.
    uv venv --python 3.14
source .venv/bin/activate
  2. Nel terminale, installa l'SDK OpenAI:
    uv pip install openai
  3. Crea un nuovo file denominato ollama_chat.py inserendo nel terminale:
    cloudshell edit ollama_chat.py
  4. Incolla il seguente codice Python in ollama_chat.py. Questo codice invia una richiesta al server Ollama locale.
    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. Esegui lo script nel terminale:
    python3 ollama_chat.py
    Dopo qualche secondo, vedrai una risposta simile a quella ricevuta dalla riga di comando.
  6. Per provare la modalità di streaming, crea un altro file denominato ollama_stream.py eseguendo il seguente comando nel terminale:
    cloudshell edit ollama_stream.py
  7. Incolla i seguenti contenuti nel file ollama_stream.py. Nota il parametro stream=True nella richiesta. In questo modo, il modello può restituire i token non appena vengono generati.
    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. Esegui lo script di streaming nel terminale:
    python3 ollama_stream.py
    La risposta ora verrà visualizzata token per token.

Lo streaming è una funzionalità utile per creare una buona esperienza utente in applicazioni interattive come i chatbot. Anziché far attendere all'utente la generazione dell'intera risposta, lo streaming mostra la risposta token per token man mano che viene creata. In questo modo, il feedback è immediato e l'applicazione risulta molto più reattiva.

Cosa hai imparato: eseguire modelli aperti con Ollama

Hai eseguito correttamente un modello aperto utilizzando Ollama. Hai visto quanto può essere semplice scaricare un modello potente come Gemma 3 e interagire con esso, sia tramite un'interfaccia a riga di comando sia in modo programmatico con Python. Questo flusso di lavoro è ideale per la prototipazione rapida e lo sviluppo locale. Ora hai una base solida per esplorare opzioni di implementazione più avanzate.

5. Esegui il deployment di Gemma con Ollama su GKE Autopilot

Per i carichi di lavoro di produzione che richiedono operazioni e scalabilità semplificate, Google Kubernetes Engine (GKE) è la piattaforma ideale. In questa attività, eseguirai il deployment di Gemma utilizzando Ollama su un cluster GKE Autopilot.

GKE Autopilot è una modalità operativa in GKE in cui Google gestisce la configurazione del cluster, inclusi nodi, scalabilità, sicurezza e altre impostazioni preconfigurate. Crea un'esperienza Kubernetes veramente "serverless", perfetta per eseguire carichi di lavoro di inferenza senza gestire l'infrastruttura di calcolo sottostante.

Prepara l'ambiente GKE

Per l'ultima attività di deployment su Kubernetes, eseguirai il provisioning di un cluster GKE Autopilot.

  1. Nel terminale Cloud Shell, imposta le variabili di ambiente per il tuo progetto e la regione che preferisci.
    export PROJECT_ID=$(gcloud config get-value project)
export REGION=europe-west1

gcloud config set compute/region $REGION
  2. Abilita l'API GKE per il tuo progetto eseguendo questo comando nel terminale:
    gcloud services enable container.googleapis.com
  3. Crea un cluster GKE Autopilot eseguendo il seguente comando nel terminale: 
    gcloud container clusters create-auto gemma-cluster \
  --region $REGION \
  --release-channel rapid
  4. Recupera le credenziali per il nuovo cluster eseguendo questo comando nel terminale:
    gcloud container clusters get-credentials gemma-cluster \
  --region $REGION

Esegui il deployment di Ollama e Gemma

Ora che hai un cluster GKE Autopilot, puoi eseguire il deployment del server Ollama. Autopilot esegue automaticamente il provisioning delle risorse di calcolo (CPU e memoria) in base ai requisiti definiti nel manifest di deployment.

  1. Crea un nuovo file denominato gemma-deployment.yaml eseguendo il seguente comando nel terminale:
    cloudshell edit gemma-deployment.yaml
  2. Incolla la seguente configurazione YAML in gemma-deployment.yaml. Questa configurazione definisce un deployment che utilizza l'immagine ufficiale di Ollama da eseguire sulla 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
    Di seguito è riportata una spiegazione della configurazione per Autopilot:
    • image: ollama/ollama:latest: specifica l'immagine Docker ufficiale di Ollama.
    • resources: richiediamo esplicitamente 8 vCPU e 8 Gi di memoria. GKE Autopilot utilizza questi valori per eseguire il provisioning del calcolo sottostante. Poiché non utilizziamo le GPU, il modello verrà eseguito sulla CPU. Gli 8 GB di memoria sono sufficienti per contenere il modello Gemma 1B e il relativo contesto.
    • command/args: eseguiamo l'override del comando di avvio per assicurarci che il modello venga estratto all'avvio del pod. Lo script avvia il server in background, attende che sia pronto, recupera il modello gemma3:1b e poi mantiene il server in esecuzione.
    • OLLAMA_HOST: se imposti questo valore su 0.0.0.0, Ollama ascolta tutte le interfacce di rete all'interno del container, rendendolo accessibile al servizio Kubernetes.
  3. Nel terminale, applica il manifest di deployment al cluster:
    kubectl apply -f gemma-deployment.yaml
    Autopilot impiega alcuni minuti per eseguire il provisioning delle risorse e avviare il pod. Puoi monitorarlo con:
    kubectl get pods --watch
    Prima di procedere, attendi che lo stato del pod sia Running e che READY sia 1/1.

Testa l'endpoint GKE

Il servizio Ollama è ora in esecuzione sul tuo cluster GKE Autopilot. Per testarlo dal terminale Cloud Shell, utilizzerai kubectl port-forward.

  1. Apri una nuova scheda del terminale Cloud Shell (fai clic sull'icona + nella finestra del terminale). Il comando port-forward è un processo di blocco, quindi ha bisogno di una propria sessione del terminale.
  2. Nel nuovo terminale, esegui questo comando per inoltrare una porta locale (ad es. 8000) alla porta del servizio (8000):
    kubectl port-forward service/llm-service 8000:8000
    Vedrai un output che indica che l'inoltro è iniziato. Lascia in esecuzione questo terminale.
  3. Torna al terminale originale.
  4. Invia una richiesta al porto locale 8000. Il server Ollama espone un'API compatibile con OpenAI e, grazie all'inoltro della porta, ora puoi accedervi all'indirizzo 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."}
]
}'
    Il servizio restituirà una risposta JSON con il completamento del modello.

6. Eliminazione

Per evitare che al tuo account Google Cloud vengano addebitati costi relativi alle risorse utilizzate in questo lab, segui questi passaggi per eliminare il cluster GKE.

  1. Nel terminale Cloud Shell, elimina il cluster GKE Autopilot:
    gcloud container clusters delete gemma-cluster \
  --region $REGION --quiet
    Questo comando rimuove il cluster e tutte le risorse associate.

7. Conclusione

Ottimo lavoro. In questo lab hai esplorato diversi metodi chiave per il deployment di modelli aperti su Google Cloud. Hai iniziato con la semplicità e la velocità dello sviluppo locale con Ollama. Infine, hai eseguito il deployment di Gemma in un ambiente scalabile e di livello di produzione utilizzando Google Kubernetes Engine Autopilot e il framework Ollama.

Ora hai le conoscenze necessarie per eseguire il deployment di modelli aperti su Google Kubernetes Engine per carichi di lavoro scalabili e impegnativi senza gestire l'infrastruttura sottostante.

Riepilogo

In questo lab hai imparato a:

  • Cosa sono i modelli aperti e perché sono importanti.
  • Come eseguire un modello aperto localmente con Ollama.
  • Come eseguire il deployment di un modello aperto su Google Kubernetes Engine (GKE) Autopilot utilizzando Ollama per l'inferenza.

Scopri di più