GKE Autopilot-Cluster mit TPUs, GKE-verwaltetes DRANET und Gemma 4

1. Übersicht

In diesem Lab erhalten Sie eine Einführung in die KI-Infrastruktur, die für die Ausführung von KI-Arbeitslasten verwendet werden kann. Sie arbeiten mit Folgendem:

Google Kubernetes Engine (GKE): Die grundlegende Containerorchestrierungsplattform.

GKE Managed DRANET: Dynamic Resource Allocation Networking, das Ihren TPU-Pods direkt Hochgeschwindigkeits-Interconnect-Fabrics zuweist.

Tensor Processing Unit (TPU): von Google entwickelte Beschleunigerchips.

Sie konfigurieren eine benutzerdefinierte VPC und einen Autopilot-GKE-Cluster für die Bereitstellung. Um verwaltetes DRANET zu aktivieren, erstellen Sie eine ComputeClass und eine ResourceClaimTemplate. Anschließend stellen Sie eine Arbeitslast bereit, die vLLM, Hugging Face, ComputeClass und Ressourcenanspruchsvorlage verwendet. Zum Schluss testen Sie die Netzwerkeinrichtung und die Verbindung zum Gemma 4-Modell.

Für die Konfigurationen wird eine Kombination aus Terraform, gcloud und kubectl verwendet.

In diesem Lab lernen Sie, wie Sie die folgende Aufgabe ausführen:

• VPC-Netzwerk einrichten
• GKE Autopilot-Cluster einrichten
• Erstellen Sie ComputeClass und ResourceClaimTemplate.
• Bereitstellung erstellen, die TPUs, vLLM, Monitoring und Gemma 4 über Hugging Face ausführt
• Verbindung zum LLM testen

In diesem Lab erstellen Sie das folgende Muster.

Abbildung 1.

2. Google Cloud-Dienste einrichten

Umgebung zum selbstbestimmten Lernen einrichten

1. Melden Sie sich in der Google Cloud Console an und erstellen Sie ein neues Projekt oder verwenden Sie ein vorhandenes. Wenn Sie noch kein Gmail- oder Google Workspace-Konto haben, müssen Sie eines erstellen.

• Der Projektname ist der Anzeigename für die Teilnehmer dieses Projekts. Es handelt sich um einen String, der nicht von Google APIs verwendet wird. Sie können sie jederzeit aktualisieren.
• Die Projekt-ID ist für alle Google Cloud-Projekte eindeutig und unveränderlich (kann nach dem Festlegen nicht mehr geändert werden). In der Cloud Console wird automatisch ein eindeutiger String generiert. Normalerweise ist es nicht wichtig, wie dieser String aussieht. In den meisten Codelabs müssen Sie auf Ihre Projekt-ID verweisen (in der Regel als PROJECT_ID angegeben). Wenn Ihnen die generierte ID nicht gefällt, können Sie eine andere zufällige ID generieren. Alternativ können Sie einen eigenen Namen eingeben und prüfen, ob er verfügbar ist. Sie kann nach diesem Schritt nicht mehr geändert werden und bleibt für die Dauer des Projekts bestehen.
• Zur Information: Es gibt einen dritten Wert, die Projektnummer, die von einigen APIs verwendet wird. Weitere Informationen zu diesen drei Werten

Achtung:Eine Projekt-ID ist global eindeutig und kann nach der Auswahl nicht mehr von anderen verwendet werden. Sie sind der einzige Nutzer dieser ID. Auch wenn ein Projekt gelöscht wird, kann die ID nicht wiederverwendet werden.

Hinweis:Wenn Sie ein Gmail-Konto verwenden, können Sie den Standardspeicherort auf Keine Organisation belassen. Wenn Sie ein Google Workspace-Konto verwenden, wählen Sie einen Standort aus, der für Ihre Organisation sinnvoll ist.

2. Als Nächstes müssen Sie die Abrechnung in der Cloud Console aktivieren, um Cloud-Ressourcen/-APIs zu verwenden. Die Durchführung dieses Codelabs kostet wenig oder gar nichts. Wenn Sie Ressourcen herunterfahren möchten, um Kosten zu vermeiden, die über diese Anleitung hinausgehen, können Sie die erstellten Ressourcen oder das Projekt löschen. Neue Google Cloud-Nutzer können am kostenlosen Testzeitraum mit einem Guthaben von 300 $ teilnehmen.

Cloud Shell starten

Während Sie Google Cloud von Ihrem Laptop aus per Fernzugriff nutzen können, wird in diesem Codelab Google Cloud Shell verwendet, eine Befehlszeilenumgebung, die in der Cloud ausgeführt wird.

Klicken Sie in der Google Cloud Console rechts oben in der Symbolleiste auf das Cloud Shell-Symbol:

Die Bereitstellung und Verbindung mit der Umgebung sollte nur wenige Augenblicke dauern. Anschließend sehen Sie in etwa Folgendes:

Diese virtuelle Maschine verfügt über sämtliche Entwicklertools, die Sie benötigen. Sie bietet ein Basisverzeichnis mit 5 GB nichtflüchtigem Speicher und läuft in Google Cloud, was die Netzwerkleistung und Authentifizierung erheblich verbessert. Alle Aufgaben in diesem Codelab können in einem Browser ausgeführt werden. Sie müssen nichts installieren.

3. Umgebung mit Terraform einrichten

Für dieses Lab benötigen Sie Zugriff auf TPUs. Die verwendete Version ist TPU v6e.

• Folgen Sie der Dokumentation zum TPU-Plan und aktivieren Sie das TPU-Kontingent, um Zugriff zu erhalten.
• Wir verwenden eine kleine Bereitstellung mit 4 TPU v6e-Chips (ct6e-standard-4t)), die ein 2 × 2-Slice in einer einzelnen Region ist.
• Hugging Face-Token: Zum Herunterladen der Gemma-Modellgewichte ist ein Zugriffstoken erforderlich.

Wir erstellen eine benutzerdefinierte VPC mit Firewallregeln, ein Subnetz und dann einen Autopilot-Cluster. Öffnen Sie die Cloud Console und wählen Sie das Projekt aus, das Sie verwenden möchten.

1. Öffnen Sie Cloud Shell oben rechts in der Konsole. Prüfen Sie, ob in Cloud Shell die richtige Projekt-ID angezeigt wird, und bestätigen Sie alle Aufforderungen, den Zugriff zuzulassen.
2. Erstellen Sie einen Ordner mit dem Namen gke-auto-tpu und wechseln Sie zu diesem Ordner.

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

3. Fügen Sie nun einige Konfigurationsdateien hinzu. Dadurch werden die folgenden Dateien terraform.tfvars, variables.tf und net.tf erstellt.

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

In der Datei terraform.tfvars wird Ihre aktive Google Cloud-Projekt-ID automatisch erfasst und eingefügt. Sie müssen sie also nicht manuell während der Bereitstellung übergeben.

In der Datei variables.tf werden der Projektname, die Region, das Netzwerk, das Subnetz und der Clustername hinzugefügt. Hinweis: Aktualisieren Sie die Variable region (Standardwert: „us-east5“) mit der Region, in der Sie TPU-Kontingent haben. Weitere Informationen finden Sie in diesem Dokument unter TPU-Verfügbarkeit in GKE prüfen.

Mit der Datei net.tf wird der entsprechende Bereitsteller hinzugefügt, um Terraform zu unterstützen. Außerdem wird eine neue benutzerdefinierte VPC in Ihrem Projekt mit einem regionalen Subnetz und Firewallregeln erstellt und Ihr GKE Autopilot-Cluster in der RAPID-Release-Version bereitgestellt.

4. Achten Sie darauf, dass Sie sich im Verzeichnis gke-auto-tpu befinden, und führen Sie die folgenden Befehle aus.
   terraform init Initialisiert das Arbeitsverzeichnis. Dies ist der erste Schritt. Dabei werden die für die angegebene Konfiguration erforderlichen Anbieter heruntergeladen.
   terraform plan -out generiert einen Ausführungsplan, der zeigt, welche Aktionen Terraform zum Bereitstellen Ihrer Infrastruktur ausführt. Mit -out können Sie den Ausführungsplan in einer benannten Binärdatei speichern. Sie können sehen, was passiert, ohne Änderungen vorzunehmen.
   terraform apply führt die Aktualisierungen aus.

terraform init 
terraform plan -out vpc 

5. Führen Sie die Bereitstellung jetzt austerraform apply. Da Sie den gespeicherten Ausführungsplan anwenden, wird er sofort ausgeführt, ohne dass Sie zur Bestätigung aufgefordert werden. Das kann 6 bis 10 Minuten dauern.

terraform apply vpc

6. Einrichtung überprüfen

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

Prüfen Sie nach Abschluss der Einrichtung, ob alles funktioniert.

4. Compute-Klasse und Vorlage für Ressourcenanspruch erstellen

Wir müssen eine benutzerdefinierte ComputeClass-Ressource erstellen, um die Konfiguration für den Knotenpool zu definieren. In unserem Fall verwenden wir die TPU v6e-Chips (ct6e-standard-4t)) und verwaltete DRANET-Netzwerke.

1. Stellen Sie eine Verbindung zum erstellten Cluster her. Hinweis: Ändern Sie die Region in die Region, in der Sie Ihren Cluster bereitgestellt haben.

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

2. Achten Sie darauf, dass Sie sich im Verzeichnis gke-auto-tpu befinden, und führen Sie die folgenden Befehle aus. Dadurch wird das ComputeClass-Manifest erstellt. Hinweis: Wenn Sie eine andere Region verwendet haben, müssen Sie die Zoneninformationen in eine Zone in der Region Ihres Clusters ändern.

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. Erstellen Sie nun die ComputeClass.

kubectl apply -f computeclass.yaml

kubectl describe computeclass dranet-auto

4. Führen Sie im Verzeichnis gke-auto-tpu die folgenden Befehle aus. Dadurch wird das ResourceClaimTemplate-Manifest erstellt, das Nicht-RDMA-Netzwerkgeräte unterstützt.

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. Erstellen Sie nun die ResourceClaimTemplate.

kubectl apply -f resourceclaimtpu.yaml

kubectl describe resourceclaimtemplate all-netdev

Einrichtung nach Abschluss überprüfen

Secret erstellen

1. In diesem Lab wird google/gemma-4-31B-it verwendet. Sie müssen also ein HF-Token erstellen. Ersetzen Sie YOUR_ACTUAL_HUGGING_FACE_TOKEN unten durch Ihr tatsächliches Token.

export HF_TOKEN="YOUR_ACTUAL_HUGGING_FACE_TOKEN"

2. Achten Sie darauf, dass Sie sich im Verzeichnis gke-auto-tpu befinden, und führen Sie die folgenden Befehle aus.

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

kubectl get secrets hf-secret

5. Workload-vLLM und Gemma bereitstellen

Bei dieser Einrichtung wird ComputeClass verwendet, um die erforderliche Hardware und das erforderliche Netzwerk (TPU v6e und verwaltetes DRANET) automatisch bereitzustellen. Dabei wird ResourceClaimTemplate verwendet, um einen Blueprint für den Zugriff auf dieses Hochgeschwindigkeitsnetzwerk zu definieren, und eine Bereitstellung, die sie miteinander verbindet, indem individuelle Netzwerkansprüche für jeden Pod generiert werden, wenn sie skaliert werden.

1. Achten Sie darauf, dass Sie sich im Verzeichnis gke-auto-tpu befinden, und führen Sie den folgenden Befehl aus.

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. Erstellen Sie das Deployment.

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

Hinweis:Durch das Anwenden des Deployments wird ein Ereignis zum Hochskalieren von Knoten ausgelöst. GKE Autopilot stellt dynamisch neue Knoten basierend auf Ihren ComputeClass-Spezifikationen bereit und plant dann Ihre Pods auf dieser neuen Hardware. Nach der Planung lädt der Container das vLLM-Image herunter und ruft die Modellgewichte von Hugging Face ab.

Der gesamte Bereitstellungsprozess kann bis zu 30 Minuten dauern.

3. Führen Sie die folgenden Befehle aus, um den Abschlussstatus zu überwachen. Die Pods warten, bis der Knoten bereitgestellt ist, bevor sie fortfahren können. Das kann mindestens 13 Minuten dauern.

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. Nachdem der Knoten erstellt und der Pod geplant wurde, können Sie den Befehl ausführen, um die Logs der Pods aufzurufen. (P.S.: Du kannst das **-f** -Flag für Streaming hinzufügen.) Das kann bis zu 15 Minuten dauern. Wenn Sie die Logs beobachten, sehen Sie den String (APIServer pid=1) INFO: 169.254.4.6:44290 - "GET /health HTTP/1.1" 200 OK, wenn das Modell bereit ist.

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

5. Sobald die Bereitstellung verfügbar ist, können Sie prüfen, ob das Hochgeschwindigkeitsnetzwerk ordnungsgemäß an Ihre TPU-Pods angehängt ist. Führen Sie dazu diesen Befehl aus:

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

Worauf Sie achten sollten:Neben den Standardschnittstellen eth0 sollten zusätzliche Schnittstellen wie eth1 bis ethxx angezeigt werden.

Diese zusätzlichen Schnittstellen bestätigen, dass das verwaltete DRANET-Hochgeschwindigkeitsnetzwerk erfolgreich an Ihren Pod angehängt wurde.

6. Mithilfe von curl mit dem KI-Modell interagieren

Wenn Sie das bereitgestellte Modell „gemma-4-31B“ überprüfen möchten, richten Sie die Portweiterleitung vom Dienst zu Ihrem lokalen Computer ein.

1. Führen Sie diesen Befehl in Ihrer aktuellen Cloud Shell aus:

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

2. Öffnen Sie nun ein zusätzliches Cloud Shell-Fenster für dasselbe Projekt, um mit Ihrem Modell zu chatten. Verwenden Sie dazu curl. Mit diesem Befehl wird ein Prompt gesendet und die Ausgabe direkt in Ihr Terminal gestreamt.

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. Antwort des Modells ansehen

Sie können den Prompt ändern, um zu sehen, wie das Modell reagiert.

Beobachtbarkeit

Da wir die benutzerdefinierte Ressource PodMonitoring angewendet haben, ruft Cloud Monitoring Messwerte aus dem vLLM-Container auf Port 8000 ab. Sie können in der Google Cloud Console zu Monitoring > Dashboards navigieren, um Messwerte wie die Latenz bei der Tokengenerierung, die Warteschlangenlänge und die KV-Cache-Nutzung nativ aufzurufen.

7. Bereinigen

Hinweis:Um unnötige Kosten zu vermeiden, sollten Sie Ihre Umgebung bereinigen.

1. Löschen Sie die Ressourcen mit dem folgenden Befehl.

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. Bereinigen Sie die Infrastruktur mit dem folgenden Befehl. Geben Sie yes ein, um die Bereinigung zu bestätigen.

terraform destroy

8. Glückwunsch

Sie haben erfolgreich eine verwaltete DRANET-Umgebung in GKE Autopilot bereitgestellt, TPU v6e-Hardware dynamisch bereitgestellt und das massive Gemma 4-Modell mit 31 Milliarden Parametern mit vLLM bereitgestellt.

Wenn Sie GKE Autopilot verwenden, kann Kubernetes die zugrunde liegende Knotenbereitstellung und Infrastrukturverwaltung übernehmen. So können Sie sich ganz auf die Bereitstellung Ihrer KI-Arbeitslast konzentrieren.

Weitere Informationen

Weitere Informationen zum GKE-Netzwerk

Nächstes Lab absolvieren

Setzen Sie Ihre Aufgabenreihe mit Google Cloud fort und sehen Sie sich diese anderen Google Cloud-Labs an:

• Multi-Cluster-GKE-Inference Gateway mit TPUs, Cloud Storage FUSE und verwaltetem DRANET erstellen
• KI‑Infrastruktur: Netzwerktechniken
• Generative KI kennenlernen – Vertex AI
• Einführung in Cloud-Netzwerke