將 GKE 上的 x86 應用程式遷移至 Arm 的多架構

啟動 Cloud Shell

在本教學課程中，您將使用 Cloud Shell，這是用來管理Google Cloud上託管資源的殼層環境。

Cloud Shell 已預先安裝 Google Cloud CLI 和 kubectl 指令列工具。gcloud CLI 是 Google Cloud的主要指令列介面，而 kubectl 是用於執行 Kubernetes 叢集相關指令的主要指令列介面。

啟動 Cloud Shell：

1. 前往 Google Cloud 控制台。

   Google Cloud console

2. 按一下主控台右上角的「啟用 Cloud Shell」按鈕：

控制台中會顯示 Cloud Shell 工作階段。您可以使用這個殼層來執行 gcloud 和 kubectl 指令。

準備環境

在本節中，您將準備環境，以便按照本教學課程操作。

設定 gcloud CLI 的預設設定

為專案 ID、可用區和新叢集名稱設定環境變數。

export PROJECT_ID=PROJECT_ID
export ZONE=us-central1-a
export CLUSTER_NAME=my-cluster

將 PROJECT_ID 替換為您在「開始前」一節中，為本教學課程選擇的專案 ID。

在本教學課程中，您會在 us-central1-a 中建立資源。如要查看 C4A 機器系列適用的完整清單，請參閱「可用地區和區域」。

複製 Git 存放區

1. 複製存放區：

   git clone https://github.com/GoogleCloudPlatform/kubernetes-engine-samples
   

2. 將目前的工作目錄變更為上一個步驟中複製的存放區：

   cd kubernetes-engine-samples/workloads/migrate-x86-app-to-multi-arch/
   

   這個存放區包含完成本教學課程所需的檔案。本教學課程使用 Kubernetes 部署。Deployment 是 Kubernetes API 物件，可讓您執行多個 Pod 副本，並將這些副本分散到叢集的節點中。

建立 GKE 叢集並部署 x86 應用程式

在本教學課程的第一部分，您會建立含有 x86 節點的叢集，並部署 x86 應用程式。範例應用程式是一項服務，可回應 HTTP 要求。這項服務是以 Golang 程式設計語言建構而成。

這項設定代表典型的叢集環境，使用與 x86 相容的應用程式和 x86 節點。

建立 GKE 叢集

首先，請使用搭載 x86 處理器的節點建立 GKE。透過這項設定，您可以建立典型的叢集環境來執行 x86 應用程式。

建立叢集：

gcloud container clusters create $CLUSTER_NAME \
    --release-channel=rapid \
    --zone=$ZONE \
    --machine-type=e2-standard-2 \
    --num-nodes=1 \
    --async

這個叢集已停用自動調度資源功能，以便在後續步驟中示範特定功能。

叢集會在幾分鐘內建立完畢。--async 旗標可讓這項作業在背景執行，同時完成後續步驟。

您可以建立僅含 Arm 節點的叢集，但本教學課程會先建立僅含 x86 節點的叢集，以便瞭解如何讓僅含 x86 的應用程式與 Arm 相容。

建立 Artifact Registry Docker 存放區

1. 在 Artifact Registry 中建立存放區，用於儲存 Docker 映像檔：

   gcloud artifacts repositories create docker-repo \
         --repository-format=docker \
         --location=us-central1 \
         --description="Docker repository"
   

2. 設定 Docker 指令列工具，向 Artifact Registry 中的這個存放區進行驗證：

   gcloud auth configure-docker us-central1-docker.pkg.dev
   

建構 x86 映像檔並推送至 Artifact Registry

1. 建構應用程式的 x86 相容版本：

   docker build -t us-central1-docker.pkg.dev/$PROJECT_ID/docker-repo/x86-hello:v0.0.1 . 
   

2. 將映像檔推送至 Artifact Registry：

   docker push us-central1-docker.pkg.dev/$PROJECT_ID/docker-repo/x86-hello:v0.0.1
   

部署 x86 應用程式

1. 執行下列指令碼，確認叢集是否已準備就緒：

   echo
   echo -ne "Waiting for GKE cluster to finish provisioning"
   gke_status=""
   while [ -z $gke_status ]; do
      sleep 2
      echo -ne '.'   
      gke_status=$(gcloud container clusters list --format="value(STATUS)" --filter="NAME=$CLUSTER_NAME AND STATUS=RUNNING")
   done
   echo
   echo "GKE Cluster '$CLUSTER_NAME' is $gke_status" 
   echo
   

   叢集準備就緒時，輸出內容應類似於下列內容：

   GKE Cluster 'my-cluster' is RUNNING
   

2. 擷取叢集憑證，以便 kubectl 連線至叢集的 Kubernetes API：

   gcloud container clusters get-credentials $CLUSTER_NAME --zone $ZONE --project $PROJECT_ID
   

3. 使用 kustomize 更新映像檔， 並部署 x86 應用程式：

   $(cd k8s/overlays/x86 && kustomize edit set image hello=us-central1-docker.pkg.dev/$PROJECT_ID/docker-repo/x86-hello:v0.0.1) 
   kubectl apply -k k8s/overlays/x86
   

4. 部署 Service，將應用程式公開發布到網際網路：

   kubectl apply -f k8s/hello-service.yaml
   

5. 確認服務的外部 IP 位址 hello-service 已完成佈建：

   echo
   echo -ne "Waiting for External IP to be provisioned"
   external_ip=""
   while [ -z $external_ip ]; do
      sleep 2
      echo -ne '.'
      external_ip=$(kubectl get svc hello-service --template="{{range .status.loadBalancer.ingress}}{{.ip}}{{end}}")
   done
   echo
   echo "External IP: $external_ip"
   echo
   

   外部 IP 位址佈建完成後，輸出內容應如下所示：

   External IP: 203.0.113.0
   

6. 發出 HTTP 要求，測試部署作業是否正常運作：

   curl -w '\n' http://$external_ip
   

   輸出結果會與下列內容相似：

   Hello from NODE:gke-my-cluster-default-pool-32019863-b41t, POD:x86-hello-deployment-6b7b456dd5-mwfkd, CPU PLATFORM:linux/amd64
   

   輸出內容顯示，這個與 x86 相容的部署作業是在 amd64 架構上，預設節點集區的節點上執行。叢集預設節點集區中的節點搭載 x86 (Intel 或 AMD) 處理器。

將 Arm 節點新增至叢集

在本教學課程的下一部分，請將 Arm 節點新增至現有叢集。當應用程式重建為在 Arm 上執行時，這些節點會部署與 Arm 相容的版本。

Checkpoint

您目前已完成下列目標：

• 使用 x86 節點建立 GKE 叢集。
• 使用 Docker 將與 x86 相容的容器映像檔儲存在 Artifact Registry 中。
• 將與 x86 相容的工作負載部署至 GKE 叢集。

您已設定叢集環境，其中包含 x86 節點和與 x86 相容的工作負載。如果您目前未使用 Arm 節點和 Arm 相容的工作負載，這項設定與現有的叢集環境類似。

在叢集中新增 Arm 節點集區

將 Arm 節點集區新增至現有叢集：

gcloud container node-pools create arm-pool \
    --cluster $CLUSTER_NAME \
    --zone $ZONE \
    --machine-type=c4a-standard-2 \
    --num-nodes=1

c4a-standard-2 機型是 C4A 系列的 Arm VM。

建立含 Arm 節點的節點集區時，與建立含 x86 節點的節點集區方式相同。建立這個節點集區後，叢集中就會同時執行 x86 節點和 Arm 節點。

如要進一步瞭解如何將 Arm 節點集區新增至現有叢集，請參閱「將 Arm 節點集區新增至 GKE 叢集」。

擴大在 x86 型節點上執行的現有應用程式

多種架構類型的節點可在單一叢集中順暢協作。GKE 不會將 x86 節點上執行的現有工作負載排定至叢集中的 Arm 節點，因為系統會自動在 Arm 節點上放置汙點。您可以擴大現有應用程式的規模，瞭解這項功能。

1. 更新工作負載，將其擴充至 6 個副本：

   $(cd k8s/overlays/x86_increase_replicas && kustomize edit set image hello=us-central1-docker.pkg.dev/$PROJECT_ID/docker-repo/x86-hello:v0.0.1) 
   kubectl apply -k k8s/overlays/x86_increase_replicas/
   

2. 等待 30 秒，然後執行下列指令，檢查部署作業的狀態：

   kubectl get pods -l="app=hello" --field-selector="status.phase=Pending"
   

   輸出內容應如下所示：

   NAME                                    READY   STATUS    RESTARTS   AGE
   x86-hello-deployment-6b7b456dd5-6tkxd   0/1     Pending   0          40s
   x86-hello-deployment-6b7b456dd5-k95b7   0/1     Pending   0          40s
   x86-hello-deployment-6b7b456dd5-kc876   0/1     Pending   0          40s
   

   這項輸出內容顯示 Pod 的狀態為 Pending，因為以 x86 為基礎的節點上已沒有空間。由於叢集自動配置器已停用，且 Arm 節點已遭汙染，因此工作負載不會部署在任何可用的 Arm 節點上。這個汙點可防止 GKE 在 Arm 節點上排定 x86 工作負載。如要部署至 Arm 節點，您必須指出部署作業與 Arm 節點相容。

3. 檢查處於「Running」狀態的 Pod：

   kubectl get pods -l="app=hello" --field-selector="status.phase=Running" -o wide
   

   輸出內容應如下所示：

   NAME                                    READY   STATUS    RESTARTS   AGE   IP            NODE                                        NOMINATED NODE   READINESS GATES
   x86-hello-deployment-6b7b456dd5-cjclz   1/1     Running   0          62s   10.100.0.17   gke-my-cluster-default-pool-32019863-b41t   <none>           <none>
   x86-hello-deployment-6b7b456dd5-mwfkd   1/1     Running   0          34m   10.100.0.11   gke-my-cluster-default-pool-32019863-b41t   <none>           <none>
   x86-hello-deployment-6b7b456dd5-n56rg   1/1     Running   0          62s   10.100.0.16   gke-my-cluster-default-pool-32019863-b41t   <none>           <none>
   

   在這個輸出內容中，NODE 資料欄表示部署作業中的所有 Pod 都只在 default-pool 中執行，也就是說，與 x86 相容的 Pod 只會排程至 x86 節點。在建立 Arm 節點集區之前排定的原始 Pod，仍會在同一節點上執行。

4. 執行下列指令來存取服務並查看輸出內容：

   for i in $(seq 1 6); do curl -w '\n' http://$external_ip; done
   

   輸出結果會與下列內容相似：

   Hello from NODE:gke-my-cluster-default-pool-32019863-b41t, POD:x86-hello-deployment-6b7b456dd5-cjclz, CPU PLATFORM:linux/amd64
   Hello from NODE:gke-my-cluster-default-pool-32019863-b41t, POD:x86-hello-deployment-6b7b456dd5-cjclz, CPU PLATFORM:linux/amd64
   Hello from NODE:gke-my-cluster-default-pool-32019863-b41t, POD:x86-hello-deployment-6b7b456dd5-n56rg, CPU PLATFORM:linux/amd64
   Hello from NODE:gke-my-cluster-default-pool-32019863-b41t, POD:x86-hello-deployment-6b7b456dd5-n56rg, CPU PLATFORM:linux/amd64
   Hello from NODE:gke-my-cluster-default-pool-32019863-b41t, POD:x86-hello-deployment-6b7b456dd5-cjclz, CPU PLATFORM:linux/amd64
   Hello from NODE:gke-my-cluster-default-pool-32019863-b41t, POD:x86-hello-deployment-6b7b456dd5-cjclz, CPU PLATFORM:linux/amd64
   

   這項輸出內容顯示，所有處理要求的 Pod 都在 x86 節點上執行。部分 Pod 仍處於「待處理」狀態，因此無法回應，因為現有的 x86 節點沒有空間，且不會排程至 Arm 節點。

重新建構應用程式，以便在 Arm 上執行

在上一個章節中，您已將 Arm 節點集區新增至現有叢集。 不過，當您擴充現有的 x86 應用程式時，系統並未將任何工作負載排定至 Arm 節點。在本節中，您將重建應用程式，使其與 Arm 相容，以便在叢集的 Arm 節點上執行。

在本範例中，請使用 docker build 完成下列步驟。 這個兩步驟方法包括：

• 第一階段：建構 Arm 的程式碼。
• 第二階段：將可執行檔複製到精簡容器。

完成這些步驟後，您將擁有與 Arm 相容的映像檔，以及與 x86 相容的映像檔。

將可執行檔複製到另一個容器的第二個步驟，遵循了建構容器的最佳做法之一，也就是盡可能建構最小的映像檔。

本教學課程使用以 Golang 程式設計語言建構的範例應用程式。使用 Golang 時，您可以分別提供環境變數 GOOS 和 GOARCH，將應用程式交叉編譯至不同的作業系統和 CPU 平台。

1. 執行 cat Dockerfile_arm，查看為 Arm 編寫的 Dockerfile：

   #
   # Build: 1st stage
   #
   FROM golang:1.18-alpine as builder 
   WORKDIR /app
   COPY go.mod .
   COPY hello.go .
   RUN GOARCH=arm64 go build -o /hello && \
      apk add --update --no-cache file && \
      file /hello
   

   這裡顯示的程式碼片段只會顯示第一階段。檔案中會包含這兩個階段。

   在這個檔案中，設定 GOARCH=arm64 會指示 Go 編譯器為 Arm 指令集建構應用程式。您不需要設定 GOOS，因為第一階段中的基本映像檔是 Linux Alpine 映像檔。

2. 建構 Arm 的程式碼，並推送至 Artifact Registry：

   docker build -t us-central1-docker.pkg.dev/$PROJECT_ID/docker-repo/arm-hello:v0.0.1 -f Dockerfile_arm .
   docker push us-central1-docker.pkg.dev/$PROJECT_ID/docker-repo/arm-hello:v0.0.1
   

部署應用程式的 Arm 版本

應用程式現在已建構完成，可在 Arm 節點上執行，因此您可以將其部署至叢集中的 Arm 節點。

1. 執行 cat k8s/overlays/arm/add_arm_support.yaml 來檢查 add_arm_support.yaml：

   輸出結果會與下列內容相似：

      nodeSelector:
         kubernetes.io/arch: arm64
   

   這項 nodeSelector 指定工作負載只能在 Arm 節點上執行。使用 nodeSelector 時，GKE 會新增容許條件，以符合 Arm 節點上的汙染，讓 GKE 在這些節點上排程工作負載。如要進一步瞭解如何設定這個欄位，請參閱「準備要用於部署的 Arm 工作負載」。

2. 部署應用程式的 Arm 相容版本副本：

   $(cd k8s/overlays/arm && kustomize edit set image hello=us-central1-docker.pkg.dev/$PROJECT_ID/docker-repo/arm-hello:v0.0.1) 
   kubectl apply -k k8s/overlays/arm
   

3. 等待 5 秒，然後檢查 Arm 部署作業是否回應 curl 要求：

   for i in $(seq 1 6); do curl -w '\n' http://$external_ip; done
   

   輸出結果會與下列內容相似：

   Hello from NODE:gke-my-cluster-default-pool-32019863-b41t, POD:x86-hello-deployment-6b7b456dd5-n56rg, CPU PLATFORM:linux/amd64
   Hello from NODE:gke-my-cluster-default-pool-32019863-b41t, POD:x86-hello-deployment-6b7b456dd5-n56rg, CPU PLATFORM:linux/amd64
   Hello from NODE:gke-my-cluster-default-pool-32019863-b41t, POD:x86-hello-deployment-6b7b456dd5-mwfkd, CPU PLATFORM:linux/amd64
   Hello from NODE:gke-my-cluster-default-pool-32019863-b41t, POD:x86-hello-deployment-6b7b456dd5-mwfkd, CPU PLATFORM:linux/amd64
   Hello from NODE:gke-my-cluster-arm-pool-e172cff7-shwc, POD:arm-hello-deployment-69b4b6bdcc-n5l28, CPU PLATFORM:linux/arm64
   Hello from NODE:gke-my-cluster-default-pool-32019863-b41t, POD:x86-hello-deployment-6b7b456dd5-n56rg, CPU PLATFORM:linux/amd64
   

   這項輸出內容應包含 x86 相容和 Arm 相容應用程式對 curl 要求的回應。

建構多架構映像檔，在不同架構中執行工作負載

雖然您可以使用上一節所述的策略，為 x86 和 Arm 部署個別的工作負載，但這樣一來，您就必須維護及整理兩個建構程序和兩個容器映像檔。

最理想的狀況是，您希望在 x86 和 Arm 平台之間順暢地建構及執行應用程式。我們建議採用這種做法。如要在多個架構平台上使用單一資訊清單執行應用程式，您需要使用多重架構 (multi-arch) 映像檔。如要進一步瞭解多架構映像檔，請參閱「為 Arm 工作負載建構多架構映像檔」。

如要使用多架構映像檔，請務必確認應用程式符合下列先決條件：

• 您的應用程式沒有任何架構平台專屬的依附元件。
• 所有依附元件都必須為多重架構或至少是目標平台建構。

本教學課程使用的範例應用程式符合這兩項必要條件。不過，建議您在建構應用程式的多架構映像檔時，先測試自己的應用程式，再將其部署至正式環境。

建構及推送多架構映像檔

如果工作負載符合下列必要條件，您可以使用 Docker Buildx 建構多架構映像檔：

• 基礎映像檔支援多個架構。如要檢查，請在基本映像檔上執行 docker manifest inspect，然後查看架構平台清單。如要查看檢查圖片的範例，請參閱本節結尾。
• 應用程式不需要針對每個架構平台執行特殊的建構步驟。如果需要特殊步驟，Buildx 可能不夠用。您需要為每個平台分別建立 Dockerfile，並使用 docker manifest create 手動建立資訊清單。

範例應用程式的基礎映像檔是 Alpine，支援多種架構。此外，也沒有架構平台專屬步驟，因此您可以使用 Buildx 建構多架構映像檔。

1. 執行 cat Dockerfile 檢查 Dockerfile：

   # This is a multi-stage Dockerfile. 
   # 1st stage builds the app in the target platform
   # 2nd stage create a lean image coping the binary from the 1st stage
   
   #
   # Build: 1st stage
   #
   FROM golang:1.18-alpine as builder 
   ARG BUILDPLATFORM    
   ARG TARGETPLATFORM
   RUN echo "I am running on $BUILDPLATFORM, building for $TARGETPLATFORM"  
   WORKDIR /app
   COPY go.mod .
   COPY hello.go .
   RUN go build -o /hello && \
      apk add --update --no-cache file && \
      file /hello   
   
   #
   # Release: 2nd stage
   #
   FROM alpine
   WORKDIR /
   COPY --from=builder /hello /hello
   CMD [ "/hello" ]
   

   這個 Dockerfile 定義了兩個階段：建構階段和發布階段。您可以使用建構 x86 應用程式時使用的 Dockerfile。

2. 執行下列指令，建立及使用新的 docker buildx 建構工具：

   docker buildx create --name multiarch --use --bootstrap
   

   現在您已建立這個新建構工具，可以使用 --platform 旗標建構及推送與 linux/amd64 和 linux/arm64 相容的映像檔。Buildx 會針對標記提供的每個平台，在目標平台中建構映像檔。Buildx 建構 linux/arm64 映像檔時，會下載 arm64 基礎映像檔。在第一階段中，系統會在 arm64 的 arm64 golang:1.18-alpine 映像檔上建構二進位檔。在第二階段，系統會下載 arm64 Alpine Linux 映像檔，並將二進位檔複製到該映像檔的層。

3. 建構並推送映像檔：

   docker buildx build -t us-central1-docker.pkg.dev/$PROJECT_ID/docker-repo/multiarch-hello:v0.0.1 -f Dockerfile --platform linux/amd64,linux/arm64 --push .
   

   輸出結果會與下列內容相似：

   => [linux/arm64 builder x/x] ..
   => [linux/amd64 builder x/x] ..
   

   這項輸出內容顯示生成了兩張圖片，分別是 linux/arm64 和 linux/amd64。

4. 檢查新多架構映像檔的資訊清單：

   docker manifest inspect us-central1-docker.pkg.dev/$PROJECT_ID/docker-repo/multiarch-hello:v0.0.1
   

   輸出結果會與下列內容相似：

   {
      "schemaVersion": 2,
      "mediaType": "application/vnd.docker.distribution.manifest.list.v2+json",
      "manifests": [
         {
            "mediaType": "application/vnd.docker.distribution.manifest.v2+json",
            "size": 739,
            "digest": "sha256:dfcf8febd94d61809bca8313850a5af9113ad7d4741edec1362099c9b7d423fc",
            "platform": {
               "architecture": "amd64",
               "os": "linux"
            }
         },
         {
            "mediaType": "application/vnd.docker.distribution.manifest.v2+json",
            "size": 739,
            "digest": "sha256:90b637d85a93c3dc03fc7a97d1fd640013c3f98c7c362d1156560bbd01f6a419",
            "platform": {
               "architecture": "arm64",
               "os": "linux"
            }
         }
      ]
   

   在這個輸出內容中，「manifests」部分包含兩個資訊清單，一個具有 amd64 平台架構，另一個具有 arm64 平台架構。

   將這個容器映像檔部署至叢集時，GKE 只會自動下載與節點架構相符的映像檔。

部署應用程式的多架構版本

1. 部署多架構映像檔前，請先刪除原始工作負載：

   kubectl delete deploy x86-hello-deployment arm-hello-deployment
   

2. 執行 cat k8s/overlays/multiarch/add_multiarch_support.yaml，檢查 add_multiarch_support.yaml kustomize 疊加層：

   輸出內容包含下列容許度集：

      tolerations:
         - key: kubernetes.io/arch
            operator: Equal
            value: arm64
            effect: NoSchedule
   

   由於容許度與所有 Arm 節點上設定的汙染相符，因此工作負載可透過這項容許度在叢集的 Arm 節點上執行。由於這項工作負載現在可以在叢集中的任何節點上執行，因此只需要容許度。只要有容許度，GKE 就能將工作負載排定至 x86 和 Arm 節點。如要指定 GKE 可排程工作負載的位置，請使用節點選取器和節點相依性規則。如要進一步瞭解如何設定這些欄位，請參閱「準備要用於部署的 Arm 工作負載」。

3. 部署含有 6 個副本的多架構容器映像檔：

   $(cd k8s/overlays/multiarch && kustomize edit set image hello=us-central1-docker.pkg.dev/$PROJECT_ID/docker-repo/multiarch-hello:v0.0.1) 
   kubectl apply -k k8s/overlays/multiarch
   

4. 等待 10 秒，然後確認應用程式的所有副本都正在執行：

   kubectl get pods -l="app=hello" -o wide
   

   輸出結果會與下列內容相似：

   NAME                                         READY   STATUS    RESTARTS   AGE   IP            NODE                                        NOMINATED NODE   READINESS GATES
   multiarch-hello-deployment-65bfd784d-5xrrr   1/1     Running   0          95s   10.100.1.5    gke-my-cluster-arm-pool-e172cff7-shwc       <none>           <none>
   multiarch-hello-deployment-65bfd784d-7h94b   1/1     Running   0          95s   10.100.1.4    gke-my-cluster-arm-pool-e172cff7-shwc       <none>           <none>
   multiarch-hello-deployment-65bfd784d-7qbkz   1/1     Running   0          95s   10.100.1.7    gke-my-cluster-arm-pool-e172cff7-shwc       <none>           <none>
   multiarch-hello-deployment-65bfd784d-7wqb6   1/1     Running   0          95s   10.100.1.6    gke-my-cluster-arm-pool-e172cff7-shwc       <none>           <none>
   multiarch-hello-deployment-65bfd784d-h2g2k   1/1     Running   0          95s   10.100.0.19   gke-my-cluster-default-pool-32019863-b41t   <none>           <none>
   multiarch-hello-deployment-65bfd784d-lc9dc   1/1     Running   0          95s   10.100.0.18   gke-my-cluster-default-pool-32019863-b41t   <none>           <none>
   

   這項輸出內容包含 NODE 資料欄，指出 Pod 在 Arm 節點集區的節點上執行，也在預設 (x86) 節點集區的節點上執行。

5. 執行下列指令來存取服務並查看輸出內容：

   for i in $(seq 1 6); do curl -w '\n' http://$external_ip; done
   

   輸出結果會與下列內容相似：

   Hello from NODE:gke-my-cluster-arm-pool-e172cff7-shwc, POD:multiarch-hello-deployment-65bfd784d-7qbkz, CPU PLATFORM:linux/arm64
   Hello from NODE:gke-my-cluster-default-pool-32019863-b41t, POD:multiarch-hello-deployment-65bfd784d-lc9dc, CPU PLATFORM:linux/amd64
   Hello from NODE:gke-my-cluster-arm-pool-e172cff7-shwc, POD:multiarch-hello-deployment-65bfd784d-5xrrr, CPU PLATFORM:linux/arm64
   Hello from NODE:gke-my-cluster-arm-pool-e172cff7-shwc, POD:multiarch-hello-deployment-65bfd784d-7wqb6, CPU PLATFORM:linux/arm64
   Hello from NODE:gke-my-cluster-arm-pool-e172cff7-shwc, POD:multiarch-hello-deployment-65bfd784d-7h94b, CPU PLATFORM:linux/arm64
   Hello from NODE:gke-my-cluster-arm-pool-e172cff7-shwc, POD:multiarch-hello-deployment-65bfd784d-7wqb6, CPU PLATFORM:linux/arm64
   

   您應該會看到跨架構平台執行的 Pod 正在回應要求。

您已建構及部署多架構映像檔，在多個架構中順暢執行工作負載。