Cluster GKE Autopilot con TPU, GKE managed DRANET e Gemma 4

1. Panoramica

Questo lab introduce l'infrastruttura AI che può essere utilizzata per eseguire carichi di lavoro AI. Lavorerai con i seguenti elementi:

Google Kubernetes Engine (GKE): la piattaforma di orchestrazione dei container di base.

GKE managed DRANET: rete di allocazione dinamica delle risorse che assegna direttamente le strutture di interconnessione ad alta velocità ai tuoi pod TPU.

Tensor Processing Unit (TPU): chip di accelerazione personalizzati di Google.

Per la configurazione, devi eseguire il deployment di un VPC personalizzato e di un cluster GKE Autopilot. Per abilitare DRANET gestito, devi creare una ComputeClass e un modello di richiesta di risorse. Poi, eseguirai il deployment di un workload che utilizza vLLM, Hugging Face, ComputeClass e resource claim template. Infine, testerai la configurazione di rete e la connettività al modello Gemma 4.

Le configurazioni utilizzeranno una combinazione di Terraform, gcloud e kubectl.

In questo lab imparerai a:

• Configura una rete VPC
• Configura un cluster GKE Autopilot
• Crea ComputeClass e ResourceClaimTemplate.
• Crea un deployment che esegua TPU, vLLM, monitoraggio e Gemma 4 tramite Hugging Face
• Testa la connettività al LLM

In questo lab creerai il seguente pattern.

Figura 1.

2. Configurazione dei servizi Google Cloud

Configurazione dell'ambiente autonomo

1. Accedi alla console Google Cloud e crea un nuovo progetto o riutilizzane uno esistente. Se non hai ancora un account Gmail o Google Workspace, devi crearne uno.

• Il nome del progetto è il nome visualizzato per i partecipanti a questo progetto. È una stringa di caratteri non utilizzata dalle API di Google. Puoi sempre aggiornarlo.
• L'ID progetto è univoco in tutti i progetti Google Cloud ed è immutabile (non può essere modificato dopo l'impostazione). La console Cloud genera automaticamente una stringa univoca, di solito non ti interessa di cosa si tratta. Nella maggior parte dei codelab, devi fare riferimento all'ID progetto (in genere identificato come PROJECT_ID). Se non ti piace l'ID generato, puoi generarne un altro casuale. In alternativa, puoi provare a crearne uno e vedere se è disponibile. Non può essere modificato dopo questo passaggio e rimane per tutta la durata del progetto.
• Per tua informazione, esiste un terzo valore, un numero di progetto, utilizzato da alcune API. Scopri di più su tutti e tre questi valori nella documentazione.

Attenzione:un ID progetto è univoco a livello globale e non può essere utilizzato da altri dopo che lo hai selezionato. Sei l'unico utente di questo ID. Anche se un progetto viene eliminato, l'ID non può essere riutilizzato

Nota:se utilizzi un account Gmail, puoi lasciare la località predefinita impostata su Nessuna organizzazione. Se utilizzi un account Google Workspace, scegli una posizione adatta alla tua organizzazione.

2. Successivamente, dovrai abilitare la fatturazione in Cloud Console per utilizzare le risorse/API Cloud. Completare questo codelab non costa molto, se non nulla. Per arrestare le risorse ed evitare addebiti oltre a quelli previsti in questo tutorial, puoi eliminare le risorse che hai creato o il progetto. I nuovi utenti di Google Cloud possono beneficiare del programma prova senza costi di 300$.

Avvia Cloud Shell

Sebbene Google Cloud possa essere gestito da remoto dal tuo laptop, in questo codelab utilizzerai Google Cloud Shell, un ambiente a riga di comando in esecuzione nel cloud.

Nella console Google Cloud, fai clic sull'icona di Cloud Shell nella barra degli strumenti in alto a destra:

Bastano pochi istanti per eseguire il provisioning e connettersi all'ambiente. Al termine, dovresti vedere un risultato simile a questo:

Questa macchina virtuale è caricata con tutti gli strumenti per sviluppatori di cui avrai bisogno. Offre una home directory permanente da 5 GB e viene eseguita su Google Cloud, migliorando notevolmente le prestazioni e l'autenticazione della rete. Tutto il lavoro in questo codelab può essere svolto all'interno di un browser. Non devi installare nulla.

3. Configura l'ambiente con Terraform

Per svolgere questo lab, devi avere accesso alle TPU. La versione esatta utilizzata è TPU v6e.

• Per ottenere l'accesso, devi seguire il documento relativo al piano TPU e abilitare la quota TPU.
• Utilizziamo un piccolo deployment che richiede 4 chip TPU v6e (ct6e-standard-4t)che sarà una slice 2x2 in una singola regione.
• Token Hugging Face: è necessario un token di accesso per scaricare i pesi del modello Gemma

Creeremo un VPC personalizzato con regole firewall, una subnet e poi un cluster Autopilot. Apri la console Cloud e seleziona il progetto che utilizzerai.

1. Apri Cloud Shell in alto a destra nella console, assicurati di visualizzare l'ID progetto corretto in Cloud Shell e conferma le richieste di autorizzazione dell'accesso.
2. Crea una cartella denominata gke-auto-tpu e spostati al suo interno

mkdir -p gke-auto-tpu && cd gke-auto-tpu
export PROJECT_ID=$(gcloud config get-value project)
echo $PROJECT_ID

3. Ora aggiungi alcuni file di configurazione. Verranno creati i seguenti file terraform.tfvars, variables.tf e net.tf.

cat << EOF > terraform.tfvars
project_id = "${PROJECT_ID}"
EOF

cat << 'EOF' > variables.tf
variable "project_id" {
  type = string
}

variable "region" {
  type    = string
  default = "us-east5"
}

variable "network_name" {
  type    = string
  default = "tpu-gke-vpc"
}

variable "subnet_name" {
  type    = string
  default = "tpu-sub1"
}

variable "cluster_name" {
  type    = string
  default = "tpu-auto-dra-cluster"
}
EOF

cat << 'EOF' > net.tf
terraform {
  required_version = ">= 1.5.0"
  required_providers {
    google = {
      source  = "hashicorp/google"
      version = "~> 7.32.0"
    }
  }
}

provider "google" {
  project = var.project_id
  region  = var.region
}

resource "google_compute_network" "tpu_vpc" {
  project                 = var.project_id
  name                    = var.network_name
  auto_create_subnetworks = false
  mtu                     = 8896
}

resource "google_compute_subnetwork" "tpu_subnet" {
  project       = var.project_id
  name          = var.subnet_name
  ip_cidr_range = "192.168.100.0/24"
  region        = var.region
  network       = google_compute_network.tpu_vpc.id
}

resource "google_compute_firewall" "allow_ssh" {
  project     = var.project_id
  name        = "${var.network_name}-allow-ssh"
  network     = google_compute_network.tpu_vpc.id
  direction   = "INGRESS"
  priority    = 1000

  allow {
    protocol = "tcp"
    ports    = ["22"]
  }

  source_ranges = ["0.0.0.0/0"]
}

resource "google_compute_firewall" "allow_internal" {
  project     = var.project_id
  name        = "${var.network_name}-allow-internal"
  network     = google_compute_network.tpu_vpc.id
  direction   = "INGRESS"
  priority    = 1000

  allow {
    protocol = "all"
  }

  source_ranges = ["172.16.0.0/12", "192.168.0.0/16"]
}

resource "google_container_cluster" "tpu_autopilot" {
  project  = var.project_id
  name     = var.cluster_name
  location = var.region

  enable_autopilot = true

  network    = google_compute_network.tpu_vpc.id
  subnetwork = google_compute_subnetwork.tpu_subnet.id

  release_channel {
    channel = "RAPID"
  }

  ip_allocation_policy {}

  deletion_protection = false 
}
EOF

Il file terraform.tfvars acquisisce e inserisce automaticamente l'ID progetto Google Cloud attivo, in modo da non doverlo passare manualmente durante il deployment.

Il file variables.tf aggiunge le informazioni su nome del progetto, regione, rete, subnet e nome del cluster. P.S. Aggiorna la variabile "region", il valore predefinito è "us-east5", con la regione in cui hai la quota TPU. Per ulteriori informazioni, consulta il documento "Convalida della disponibilità di TPU in GKE".

Il file net.tf aggiunge il provider pertinente per supportare Terraform, un nuovo VPC personalizzato nel tuo progetto con una subnet regionale, regole firewall e provisioning del cluster GKE Autopilot sul canale di rilascio RAPIDO.

4. Assicurati di trovarti nella directory gke-auto-tpu ed esegui i seguenti comandi
   terraform init Inizializza la directory di lavoro. Questo è il primo passaggio e scarica i provider richiesti per la configurazione specificata.
   terraform plan -out genera un piano di esecuzione, che mostra le azioni che Terraform eseguirà per eseguire il deployment dell'infrastruttura. -out ti consente di salvare il piano di esecuzione in un file binario denominato. Puoi vedere cosa succederà senza apportare modifiche.
   terraform apply esegue gli aggiornamenti.

terraform init 
terraform plan -out vpc 

5. Ora esegui il deployment dopo aver eseguito terraform apply. Poiché stai applicando il piano di esecuzione salvato, verrà eseguito immediatamente senza richiedere la conferma (potrebbe richiedere 6-10 minuti)

terraform apply vpc

6. Verifica la configurazione

echo -e "\n=== Verifying GKE Autopilot Cluster ==="
gcloud container clusters list --filter="name:tpu-auto-dra-cluster" --project=$PROJECT_ID

echo -e "\n=== Verifying VPC Network ==="
gcloud compute networks list --filter="name:tpu-gke-vpc" --project=$PROJECT_ID

echo -e "\n=== Verifying Subnetwork ==="
gcloud compute networks subnets list --filter="name:tpu-sub1" --project=$PROJECT_ID

echo -e "\n=== Verifying Firewall Rules ==="
gcloud compute firewall-rules list --filter="name~tpu-gke-vpc-allow" --project=$PROJECT_ID

Assicurati di verificare la configurazione al termine.

4. Crea un modello di classe di calcolo e di richiesta di risorse

Dobbiamo creare una risorsa ComputeClass personalizzata per definire la configurazione del pool di nodi. Nel nostro caso, utilizzeremo i chip TPU v6e (ct6e-standard-4t)) e le reti DRANET gestite.

1. Connettiti al cluster che hai creato. (p.s. cambia la regione con quella in cui hai eseguito il deployment del cluster.)

gcloud container clusters get-credentials tpu-auto-dra-cluster --region us-east5 --project=$PROJECT_ID

2. Assicurati di trovarti nella directory gke-auto-tpu ed esegui i seguenti comandi. Viene creato il manifest ComputeClass. Tieni presente che se hai utilizzato una regione diversa, devi modificare le informazioni sulla zona in una zona all'interno della regione del cluster

cat << 'EOF' > computeclass.yaml
apiVersion: cloud.google.com/v1
kind: ComputeClass
metadata:
  name: dranet-auto
spec:
  nodePoolAutoCreation:
    enabled: true
  nodePoolConfig:
    dra:
      networking:
        enabled: true
  priorities:
  - tpu:
      type: tpu-v6e-slice
      count: 4
      topology: "2x2" 
    acceleratorNetworkProfile: auto
    location:
      zones: 
      - us-east5-b
EOF

3. Ora crea ComputeClass.

kubectl apply -f computeclass.yaml

kubectl describe computeclass dranet-auto

4. Nella directory gke-auto-tpu, esegui i seguenti comandi. Viene creato il manifest ResourceClaimTemplate che supporta i dispositivi di rete non RDMA.

cat << 'EOF' > resourceclaimtpu.yaml
apiVersion: resource.k8s.io/v1
kind: ResourceClaimTemplate
metadata:
  name: all-netdev
spec:
  spec:
    devices:
      requests:
      - name: req-netdev
        exactly:
          deviceClassName: netdev.google.com
          allocationMode: All
EOF

5. Ora crea ResourceClaimTemplate.

kubectl apply -f resourceclaimtpu.yaml

kubectl describe resourceclaimtemplate all-netdev

Verificare la configurazione al termine

Crea il tuo segreto

1. Questo lab utilizza google/gemma-4-31B-it , quindi devi creare un token HF. Sostituisci YOUR_ACTUAL_HUGGING_FACE_TOKEN di seguito con il tuo token effettivo.

export HF_TOKEN="YOUR_ACTUAL_HUGGING_FACE_TOKEN"

2. Assicurati di trovarti nella directory gke-auto-tpu ed esegui i seguenti comandi.

kubectl create secret generic hf-secret --from-literal=hf_token=${HF_TOKEN} 

kubectl get secrets hf-secret

5. Esegui il deployment di vLLM e Gemma per il workload

Questa configurazione utilizza ComputeClass per eseguire automaticamente il provisioning dell'hardware e del networking richiesti (TPU v6e e DRANET gestito). Utilizza ResourceClaimTemplate per definire un progetto per richiedere l'accesso a quella rete ad alta velocità e un deployment che li lega insieme generando singole rivendicazioni di rete per ogni pod man mano che vengono scalati.

1. Assicurati di trovarti nella directory gke-auto-tpu ed esegui il comando seguente.

cat << 'EOF' > gem4-auto-dra-tpu.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: gem4-dra-auto
spec:
  replicas: 1
  selector:
    matchLabels:
      app: gemma4-tpu
  template:
    metadata:
      labels:
        app: gemma4-tpu
        ai.gke.io/model: gemma-4-31b-it
        ai.gke.io/inference-server: vllm-tpu
    spec:
      dnsPolicy: Default
      resourceClaims:
      - name: netdev-claim        
        resourceClaimTemplateName: all-netdev
      containers:
      - name: vllm-tpu-inference
        image: vllm/vllm-tpu:latest
        resources:
          requests:
            cpu: "30"
            memory: "240Gi"
            ephemeral-storage: "100Gi"
            google.com/tpu: "4"
          limits:
            cpu: "30"
            memory: "240Gi"
            ephemeral-storage: "100Gi"
            google.com/tpu: "4"
          claims:
          - name: netdev-claim
        command: ["python3", "-m", "vllm.entrypoints.openai.api_server"]
        args:
        - --model=$(MODEL_ID)
        - --tensor-parallel-size=4
        - --host=0.0.0.0
        - --port=8000
        - --max-model-len=32768
        - --max-num-batched-tokens=8192
        env:
        - name: MODEL_ID
          value: google/gemma-4-31B-it
        - name: HUGGING_FACE
          valueFrom:
            secretKeyRef:
              name: hf-secret
              key: hf_token
        - name: HF_TOKEN
          valueFrom:
            secretKeyRef:
              name: hf-secret
              key: hf_token
        volumeMounts:
        - mountPath: /dev/shm
          name: dshm
        startupProbe:
          httpGet:
            path: /health
            port: 8000
          failureThreshold: 240
          periodSeconds: 10
        livenessProbe:
          httpGet:
            path: /health
            port: 8000
          periodSeconds: 10
        readinessProbe:
          httpGet:
            path: /health
            port: 8000
          periodSeconds: 5
      volumes:
      - name: dshm
        emptyDir:
          medium: Memory
      nodeSelector:
        cloud.google.com/compute-class: dranet-auto
---
apiVersion: v1
kind: Service
metadata:
  name: gem4-dra-service
spec:
  selector:
    app: gemma4-tpu
  type: ClusterIP
  ports:
    - protocol: TCP
      port: 8000
      targetPort: 8000
---
apiVersion: monitoring.googleapis.com/v1
kind: PodMonitoring
metadata:
  name: gem4-monitoring
spec:
  selector:
    matchLabels:
      app: gemma4-tpu
  endpoints:
  - port: 8000
    path: /metrics
    interval: 30s
EOF

2. Crea il deployment.

kubectl apply -f gem4-auto-dra-tpu.yaml

Nota:l'applicazione del deployment attiva un evento di scalabilità verticale dei nodi. GKE Autopilot esegue il provisioning dinamico di nuovi nodi in base alle specifiche di ComputeClass e poi pianifica i pod su questo nuovo hardware. Una volta pianificato, il container scarica l'immagine vLLM ed estrae i pesi del modello da Hugging Face.

L'intera procedura di deployment dovrebbe richiedere fino a 30 minuti.

3. Per monitorare lo stato di completamento, esegui i seguenti comandi. I pod attenderanno il provisioning del nodo prima di poter procedere. L'operazione potrebbe richiedere più di 13 minuti.

kubectl get pods

kubectl get deployments

kubectl describe pods -l app=gemma4-tpu

echo "       __|__"
echo "  --@--(_|_)--@--"
echo ""
echo "Waiting for Autopilot to register the TPU node (this takes a few minutes)..."

until kubectl get nodes -l gke.networks.io/accelerator-network-profile=auto -o name | grep -q "node/"; do
  sleep 60
done

echo "TPU Node detected in cluster! Waiting for hardware to provision and become Ready..."

kubectl wait --for=condition=Ready nodes -l gke.networks.io/accelerator-network-profile=auto --timeout=900s

4. Dopo aver creato il nodo e pianificato il pod, puoi eseguire il comando per visualizzare i log dei pod. (P.S. Puoi aggiungere il **-f** flag per lo streaming). Se guardi i log quando vedi la stringa (APIServer pid=1) INFO: 169.254.4.6:44290 - "GET /health HTTP/1.1" 200 OK il modello è pronto per essere pubblicato, il completamento dell'operazione richiederà fino a 15 minuti o più.

kubectl logs -l app=gemma4-tpu -f | sed -u '\,"GET /health HTTP/1.1" 200 OK,q'

5. Una volta disponibile il deployment, puoi verificare che la rete ad alta velocità sia collegata correttamente ai pod TPU. Esegui questo comando:

for pod in $(kubectl get pods -l app=gemma4-tpu -o name); do
  echo "=== Checking Networking for $pod ==="
  kubectl exec $pod -- ls /sys/class/net
  echo ""
done

Cosa cercare: dovresti vedere eth0 standard insieme a interfacce aggiuntive come eth1 fino a ethxx.

Queste interfacce aggiuntive confermano che il fabric DRANET gestito ad alta velocità è collegato correttamente al pod.

6. Interagire con il modello AI utilizzando curl

Per verificare il modello gemma-4-31B che hai eseguito il deployment, configura il port forwarding dal servizio alla tua macchina locale.

1. Esegui questo comando nella sessione Cloud Shell corrente:

kubectl port-forward service/gem4-dra-service 8000:8000 &

2. Ora, apri un'altra finestra di Cloud Shell per lo stesso progetto per chattare con il modello utilizzando curl. Questo comando invia un prompt e trasmette l'output direttamente al terminale.

time curl -sN http://127.0.0.1:8000/v1/chat/completions \
  -X POST \
  -H "Content-Type: application/json" \
  -d '{
    "model": "google/gemma-4-31B-it",
    "messages": [
      {
        "role": "user",
        "content": "How can GKE help deployment of AI workloads? Provide concise information. Keep the explanation under 300 words."
      }
    ],
    "max_tokens": 1024,
    "temperature": 0.7,
    "stream": true,
    "stream_options": {"include_usage": true}
  }' | grep '^data:' | sed 's/^data: //' | grep -v '\[DONE\]' | jq --unbuffered -j '
    (.choices[0].delta.content // empty), 
    if .usage then "\n\n--- Usage ---\nPrompt: \(.usage.prompt_tokens)\nCompletion: \(.usage.completion_tokens)\nTotal: \(.usage.total_tokens)\n" else empty end 
  '

3. Controllare la risposta del modello

Puoi modificare il prompt per vedere come risponde

Osservabilità

Poiché abbiamo applicato la risorsa personalizzata PodMonitoring, Cloud Monitoring eseguirà lo scraping delle metriche dal container vLLM sulla porta 8000. Puoi andare a console Google Cloud Monitoring -> Dashboard per visualizzare in modo nativo metriche come la latenza di generazione dei token, la lunghezza della coda e l'utilizzo della cache KV.

7. Esegui la pulizia

Nota:per evitare costi non necessari, libera spazio nel tuo ambiente

1. Elimina le risorse eseguendo il seguente comando.

cd ~/gke-auto-tpu

kubectl delete -f gem4-auto-dra-tpu.yaml
kubectl delete -f resourceclaimtpu.yaml
kubectl delete -f computeclass.yaml
kubectl delete secret hf-secret

2. Pulisci l'infrastruttura con il seguente comando, digita yes per confermare

terraform destroy

8. Complimenti

Hai eseguito il deployment di un ambiente DRANET gestito su GKE Autopilot, hai eseguito il provisioning dinamico dell'hardware TPU v6e e hai pubblicato il modello Gemma 4 con 31 miliardi di parametri utilizzando vLLM.

Utilizzando GKE Autopilot, consenti a Kubernetes di gestire il provisioning dei nodi e la gestione dell'infrastruttura sottostanti, in modo da poterti concentrare interamente sul deployment del tuo workload di AI.

Prossimi passi/Scopri di più

Puoi scoprire di più sul networking GKE.

Segui il prossimo lab

Continua la Quest con Google Cloud e dai un'occhiata a questi altri lab Google Cloud:

• Crea un gateway di inferenza GKE multicluster con TPU, Cloud Storage FUSE e DRANET gestito
• Infrastruttura AI: tecniche di networking
• Generative AI Explorer - Vertex AI
• Tour di Cloud Networking