Klastry GKE Autopilot z TPU, zarządzane przez GKE DRANET i Gemma 4

1. Przegląd

W tym module zapoznasz się z infrastrukturą AI, której można używać do uruchamiania zadań AI. Będziesz pracować z tymi elementami:

Google Kubernetes Engine (GKE) – podstawowa platforma do orkiestracji kontenerów.

Zarządzana przez GKE sieć DRANET – dynamiczna alokacja zasobów sieciowych, która bezpośrednio przypisuje szybkie połączenia międzysieciowe do podów TPU.

Jednostka Tensor Processing Unit (TPU) – opracowane przez Google specjalne układy akcelerujące.

Aby skonfigurować wdrożenie niestandardowej sieci VPC i klastra GKE z Autopilotem, Aby włączyć zarządzany DRANET, musisz utworzyć klasę obliczeniową i szablon żądania zasobu. Następnie wdrożysz obciążenie, które korzysta z vLLM, Hugging Face, ComputeClass i szablonu roszczenia o zasoby. Na koniec przetestujesz konfigurację sieci i połączenie z modelem Gemma 4.

Konfiguracje będą wykorzystywać kombinację Terraform, gcloud i kubectl.

Z tego modułu dowiesz się, jak:

• Konfigurowanie sieci VPC
• Konfigurowanie klastra GKE w trybie Autopilota
• Utwórz ComputeClass i ResourceClaimTemplate.
• Tworzenie wdrożenia, które uruchamia TPU, vLLM, monitorowanie i Gemma 4 za pomocą Hugging Face
• Testowanie połączenia z LLM

W tym module utworzysz ten wzór.

Rysunek 1.

2. Konfigurowanie usług Google Cloud

Samodzielne konfigurowanie środowiska

1. Zaloguj się w konsoli Google Cloud i utwórz nowy projekt lub użyj istniejącego. Jeśli nie masz jeszcze konta Gmail lub Google Workspace, musisz je utworzyć.

• Nazwa projektu to wyświetlana nazwa dla uczestników tego projektu. Jest to ciąg znaków, który nie jest używany przez interfejsy API Google. Zawsze możesz ją zaktualizować.
• Identyfikator projektu jest unikalny we wszystkich projektach Google Cloud i nie można go zmienić po ustawieniu. Konsola Cloud automatycznie generuje unikalny ciąg znaków. Zwykle nie musisz się nim przejmować. W większości ćwiczeń z programowania musisz odwoływać się do identyfikatora projektu (zwykle oznaczanego jako PROJECT_ID). Jeśli wygenerowany identyfikator Ci się nie podoba, możesz wygenerować inny losowy identyfikator. Możesz też spróbować własnej nazwy i sprawdzić, czy jest dostępna. Po tym kroku nie można go zmienić i pozostaje on taki przez cały czas trwania projektu.
• Warto wiedzieć, że istnieje jeszcze trzecia wartość, numer projektu, której używają niektóre interfejsy API. Więcej informacji o tych 3 wartościach znajdziesz w dokumentacji.

Ostrzeżenie: identyfikator projektu jest unikalny na całym świecie i po jego wybraniu nie może być używany przez nikogo innego. Jesteś jedynym użytkownikiem tego identyfikatora. Nawet po usunięciu projektu nie można ponownie użyć jego identyfikatora.

Uwaga: jeśli używasz konta Gmail, możesz pozostawić domyślną lokalizację ustawioną na Brak organizacji. Jeśli używasz konta Google Workspace, wybierz lokalizację odpowiednią dla Twojej organizacji.

2. Następnie musisz włączyć płatności w konsoli Cloud, aby korzystać z zasobów i interfejsów API Google Cloud. Wykonanie tego laboratorium nie będzie kosztować dużo, a może nawet nic. Aby wyłączyć zasoby i uniknąć naliczania opłat po zakończeniu tego samouczka, możesz usunąć utworzone zasoby lub projekt. Nowi użytkownicy Google Cloud mogą skorzystać z bezpłatnego okresu próbnego, w którym mają do dyspozycji środki w wysokości 300 USD.

Uruchom Cloud Shell

Z Google Cloud można korzystać zdalnie na laptopie, ale w tym ćwiczeniu użyjesz Google Cloud Shell, czyli środowiska wiersza poleceń działającego w chmurze.

W konsoli Google Cloud kliknij ikonę Cloud Shell na pasku narzędzi w prawym górnym rogu:

Uzyskanie dostępu do środowiska i połączenie się z nim powinno zająć tylko kilka chwil. Po zakończeniu powinno wyświetlić się coś takiego:

Ta maszyna wirtualna zawiera wszystkie potrzebne narzędzia dla programistów. Zawiera również stały katalog domowy o pojemności 5 GB i działa w Google Cloud, co znacznie zwiększa wydajność sieci i usprawnia proces uwierzytelniania. Wszystkie zadania w tym laboratorium możesz wykonać w przeglądarce. Nie musisz niczego instalować.

3. Konfigurowanie środowiska za pomocą Terraform

Aby ukończyć to laboratorium, musisz mieć dostęp do TPU. Używana jest wersja TPU v6e.

• Aby uzyskać dostęp, postępuj zgodnie z dokumentem dotyczącym planu TPU i włącz limit TPU.
• Używamy małego wdrożenia wymagającego 4 chipów TPU v6e (ct6e-standard-4t)które będą wycinkiem 2x2 w jednym regionie).
• Token Hugging Face: do pobrania wag modelu Gemma wymagany jest token dostępu.

Utworzymy niestandardową sieć VPC z regułami zapory sieciowej i podsiecią, a następnie klaster z Autopilotem. Otwórz konsolę Google Cloud i wybierz projekt, którego będziesz używać.

1. Otwórz Cloud Shell w prawym górnym rogu konsoli. Sprawdź, czy w Cloud Shell widzisz prawidłowy identyfikator projektu, i potwierdź wszystkie prośby o przyznanie dostępu.
2. Utwórz folder o nazwie gke-auto-tpu i przenieś do niego plik.

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

3. Teraz dodaj pliki konfiguracji. Spowoduje to utworzenie plików terraform.tfvars, variables.tf i 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

Plik terraform.tfvars automatycznie przechwytuje i wstawia aktywny identyfikator projektu Google Cloud, więc nie musisz go ręcznie przekazywać podczas wdrażania.

Plik variables.tf dodaje informacje o nazwie projektu, regionie, sieci, podsieci i nazwie klastra. p.s. Zaktualizuj zmienną „region”, domyślnie = „us-east5”, podając region, w którym masz limit TPU. Więcej informacji znajdziesz w dokumencie „Sprawdzanie dostępności TPU w GKE”.

Plik net.tf dodaje odpowiedniego aprowizatora, aby obsługiwać Terraform, nową niestandardową sieć VPC w projekcie z podsiecią regionalną, regułami zapory sieciowej i aprowizuje klaster GKE z Autopilotem w kanale wersji RAPID.

4. Upewnij się, że jesteś w katalogu gke-auto-tpu, i uruchom te polecenia:
   terraform init Inicjuje katalog roboczy. To pierwszy krok, który polega na pobraniu dostawców wymaganych w danej konfiguracji.
   terraform plan -out generuje plan wykonania, który pokazuje, jakie działania Terraform podejmie w celu wdrożenia infrastruktury. Polecenie -out umożliwia zapisanie planu wykonania w nazwanym pliku binarnym. Możesz sprawdzić, co się stanie, bez wprowadzania zmian.
   terraform apply przeprowadza aktualizacje.

terraform init 
terraform plan -out vpc 

5. Teraz uruchom wdrożenie po uruchomieniu polecenia terraform apply. Ponieważ stosujesz zapisany plan wykonania, zostanie on wykonany natychmiast bez wyświetlania prośby o potwierdzenie (może to potrwać od 6 do 10 minut).

terraform apply vpc

6. Weryfikacja konfiguracji

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

Po zakończeniu konfiguracji sprawdź, czy wszystko działa prawidłowo.

4. Tworzenie klasy obliczeniowej i szablonu żądania zasobów

Aby zdefiniować konfigurację puli węzłów, musimy utworzyć niestandardowy zasób ComputeClass. W naszym przypadku użyjemy chipów TPU v6e (ct6e-standard-4t)) i zarządzanych sieci DRANET.

1. Połącz się z utworzonym klastrem. (PS Zmień region na ten, w którym wdrożono klaster.)

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

2. Upewnij się, że jesteś w katalogu gke-auto-tpu, i uruchom te polecenia. Spowoduje to utworzenie manifestu ComputeClass. Jeśli używasz innego regionu, musisz zmienić informacje o strefie na strefę w regionie klastra

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. Teraz utwórz ComputeClass.

kubectl apply -f computeclass.yaml

kubectl describe computeclass dranet-auto

4. W katalogu gke-auto-tpu uruchom te polecenia: Spowoduje to utworzenie manifestu ResourceClaimTemplate, który obsługuje urządzenia sieciowe inne niż 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. Teraz utwórz ResourceClaimTemplate.

kubectl apply -f resourceclaimtpu.yaml

kubectl describe resourceclaimtemplate all-netdev

Sprawdź konfigurację po zakończeniu

Tworzenie obiektu tajnego

1. W tym laboratorium używamy modelu google/gemma-4-31B-it , więc musisz utworzyć token HF. Zastąp ciąg YOUR_ACTUAL_HUGGING_FACE_TOKEN poniżej rzeczywistym tokenem.

export HF_TOKEN="YOUR_ACTUAL_HUGGING_FACE_TOKEN"

2. Upewnij się, że jesteś w katalogu gke-auto-tpu, i uruchom te polecenia.

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

kubectl get secrets hf-secret

5. Wdrażanie zadania vLLM i Gemma

Ta konfiguracja korzysta z ComputeClass, aby automatycznie udostępniać wymagany sprzęt i sieć (TPU v6e i zarządzana sieć DRANET). Używa ResourceClaimTemplate do zdefiniowania planu żądania dostępu do tej sieci o dużej szybkości oraz wdrożenia, które wiąże je ze sobą, generując indywidualne roszczenia sieciowe dla każdego poda w miarę ich skalowania.

1. Upewnij się, że jesteś w katalogu gke-auto-tpu, i uruchom to polecenie:

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. Utwórz wdrożenie.

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

Uwaga: zastosowanie wdrożenia powoduje zdarzenie zwiększenia skali węzła. GKE Autopilot dynamicznie udostępnia nowe węzły na podstawie specyfikacji ComputeClass, a następnie planuje w nich pody. Po zaplanowaniu kontener pobiera obraz vLLM i wagi modelu z Hugging Face.

Cały proces wdrażania może potrwać do 30 minut.

3. Aby monitorować stan ukończenia, uruchom te polecenia. Pody będą czekać na udostępnienie węzła, zanim będą mogły kontynuować działanie. Może to potrwać ponad 13 minut.

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. Po utworzeniu węzła i zaplanowaniu poda możesz uruchomić polecenie, aby wyświetlić logi podów. (PS Możesz dodać **-f** flagę do transmisji). Jeśli będziesz obserwować logi, gdy zobaczysz ciąg znaków (APIServer pid=1) INFO: 169.254.4.6:44290 - "GET /health HTTP/1.1" 200 OK, który oznacza, że model jest gotowy do udostępnienia, może to potrwać ponad 15 minut.

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

5. Gdy wdrożenie będzie dostępne, możesz sprawdzić, czy sieć o dużej przepustowości jest prawidłowo podłączona do zasobów TPU. Uruchom to polecenie:

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

Na co zwrócić uwagę: powinny być widoczne standardowe interfejsy eth0 oraz dodatkowe interfejsy, np. eth1–ethxx.

Te dodatkowe interfejsy potwierdzają, że szybka zarządzana sieć DRANET została prawidłowo podłączona do Twojego poda.

6. Interakcja z modelem AI za pomocą curl

Aby zweryfikować wdrożony model gemma-4-31B, skonfiguruj przekierowanie portów z usługi na komputer lokalny.

1. Uruchom to polecenie w bieżącym Cloud Shell:

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

2. Teraz otwórz dodatkowe okno Cloud Shell dla tego samego projektu, aby porozmawiać z modelem za pomocą curl. To polecenie wysyła prompt i przesyła strumieniowo dane wyjściowe bezpośrednio do terminala.

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. Sprawdź odpowiedź modelu

Możesz zmienić prompt, aby sprawdzić, jak zareaguje model

Dostrzegalność

Ponieważ zastosowaliśmy zasób niestandardowy PodMonitoring, Cloud Monitoring będzie pobierać wskaźniki z kontenera vLLM na porcie 8000. Aby wyświetlić natywnie dane, takie jak opóźnienie generowania tokenów, długość kolejki i wykorzystanie pamięci podręcznej KV, otwórz konsolę Google Cloud i kliknij Monitoring –> Panele.

7. Czyszczenie danych

Uwaga: aby uniknąć niepotrzebnych kosztów, wyczyść środowisko.

1. Usuń zasoby, wykonując to polecenie.

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. Zwolnij miejsce w infrastrukturze za pomocą tego polecenia. Aby potwierdzić, wpisz yes.

terraform destroy

8. Gratulacje

Udało Ci się wdrożyć zarządzane środowisko DRANET w GKE Autopilot, dynamicznie udostępnić sprzęt TPU v6e i udostępnić ogromny model Gemma 4 z 31 miliardami parametrów za pomocą vLLM.

Korzystając z Autopilota w GKE, możesz pozwolić Kubernetesowi na obsługę bazowego udostępniania węzłów i zarządzania infrastrukturą, dzięki czemu możesz w pełni skupić się na wdrażaniu zadań AI.

Kolejne kroki / Więcej informacji

Więcej informacji o sieci GKE

Przejdź do kolejnego modułu

Kontynuuj naukę w Google Cloud i zapoznaj się z tymi laboratoriami Google Cloud:

• Tworzenie bramy wnioskowania GKE w wielu klastrach z TPU, Cloud Storage FUSE i zarządzanym DRANET
• Infrastruktura AI: techniki sieciowe
• Generative AI Explorer – Vertex AI
• Prezentacja Cloud Networking