Memigrasikan aplikasi x86 di GKE ke multi-arch dengan Arm

Standard

---

Catatan: Tutorial ini memberikan petunjuk untuk menggunakan aplikasi ini: Docker. Petunjuk mungkin tidak merepresentasikan versi aplikasi yang lebih baru. Untuk informasi selengkapnya, lihat dokumentasi: Docker.

Tutorial ini menjelaskan cara memigrasikan aplikasi yang dibuat untuk node menggunakan prosesor x86 (Intel atau AMD) di cluster Google Kubernetes Engine (GKE) ke aplikasi multi-arsitektur (multi-arch) yang berjalan pada salah satu node, yaitu node x86 atau Arm. Audiens yang dituju untuk tutorial ini adalah Admin Platform, Operator Aplikasi, dan Developer Aplikasi yang ingin menjalankan workload yang kompatibel dengan x86 yang ada di Arm.

Dengan cluster GKE, Anda dapat menjalankan workload pada node Arm menggunakan rangkaian mesin Tau T2A Arm. Node T2A dapat berjalan di cluster GKE Anda sama seperti node lainnya yang menggunakan prosesor x86 (Intel atau AMD). Opsi ini adalah pilihan yang baik untuk workload yang memerlukan penyebaran skala dan intensif komputasi.

Untuk mempelajari lebih lanjut, lihat Workload Arm di GKE.

Tutorial ini mengasumsikan bahwa Anda sudah memahami Kubernetes dan Docker. Tutorial ini menggunakan Google Kubernetes Engine dan Artifact Registry.

Tujuan

Di tutorial ini, Anda akan menyelesaikan tugas-tugas berikut:

• Menyimpan image container dengan Docker di Artifact Registry.
• Men-deploy workload yang kompatibel dengan x86 ke cluster GKE.
• Mem-build ulang workload yang kompatibel dengan x86 untuk dijalankan di Arm.
• Menambahkan node pool Arm ke cluster yang ada.
• Men-deploy workload yang kompatibel dengan Arm untuk dijalankan di node Arm.
• Mem-build image multi-arch untuk menjalankan workload di beberapa arsitektur.
• Menjalankan workload di beberapa arsitektur dalam satu cluster GKE.

Biaya

Dalam dokumen ini, Anda menggunakan komponen Google Cloud yang dapat ditagih berikut:

• GKE
• Artifact Registry

Untuk membuat perkiraan biaya berdasarkan proyeksi penggunaan Anda, gunakan kalkulator harga. Pengguna baru Google Cloud mungkin memenuhi syarat untuk mendapatkan uji coba gratis.

Setelah menyelesaikan tugas yang dijelaskan dalam dokumen ini, Anda dapat menghindari penagihan berkelanjutan dengan menghapus resource yang Anda buat. Untuk mengetahui informasi selengkapnya, lihat Pembersihan.

Sebelum memulai

Lakukan langkah-langkah berikut untuk mengaktifkan Kubernetes Engine API:

1. Login ke akun Google Cloud Anda. Jika Anda baru menggunakan Google Cloud, buat akun untuk mengevaluasi performa produk kami dalam skenario dunia nyata. Pelanggan baru juga mendapatkan kredit gratis senilai $300 untuk menjalankan, menguji, dan men-deploy workload.

2. Di konsol Google Cloud, pada halaman pemilih project, pilih atau buat project Google Cloud.

   Catatan: Jika tidak berencana untuk menyimpan resource yang Anda buat dalam prosedur ini, buatlah project, bukan memilih project yang ada. Setelah menyelesaikan langkah ini, Anda dapat menghapus project, yang menghapus semua resource yang terkait dengan project ini.

   Buka pemilih project

3. Pastikan penagihan telah diaktifkan untuk project Google Cloud Anda.

4. Enable the Artifact Registry and Google Kubernetes Engine APIs.

   Enable the APIs

5. Di konsol Google Cloud, pada halaman pemilih project, pilih atau buat project Google Cloud.

   Catatan: Jika tidak berencana untuk menyimpan resource yang Anda buat dalam prosedur ini, buatlah project, bukan memilih project yang ada. Setelah menyelesaikan langkah ini, Anda dapat menghapus project, yang menghapus semua resource yang terkait dengan project ini.

   Buka pemilih project

6. Pastikan penagihan telah diaktifkan untuk project Google Cloud Anda.

7. Enable the Artifact Registry and Google Kubernetes Engine APIs.

   Enable the APIs

Setelah menyelesaikan tutorial ini, Anda dapat menghindari penagihan berkelanjutan dengan menghapus resource yang Anda buat. Lihat Clean up untuk detail selengkapnya.

Meluncurkan Cloud Shell

Dalam tutorial ini, Anda akan menggunakan Cloud Shell, yang merupakan lingkungan shell untuk mengelola resource yang dihosting di Google Cloud.

Cloud Shell telah diinstal lebih dulu dengan alat command line Google Cloud CLI dan kubectl. Gcloud CLI menyediakan antarmuka command line utama untuk Google Cloud, dan kubectl menyediakan antarmuka command line utama untuk menjalankan perintah terhadap cluster Kubernetes.

Meluncurkan Cloud Shell:

1. Buka Konsol Google Cloud.

   Google Cloud console

2. Dari pojok kanan atas konsol, klik tombol Activate Cloud Shell:

Sesi Cloud Shell akan muncul di dalam konsol. Anda menggunakan shell ini untuk menjalankan perintah gcloud dan kubectl.

Menyiapkan lingkungan Anda

Di bagian ini, Anda akan menyiapkan lingkungan untuk mengikuti tutorial.

Menetapkan setelan default untuk gcloud CLI

Tetapkan variabel lingkungan untuk project ID, zona, dan nama cluster baru Anda.

Perhatian: Variabel lingkungan berikut digunakan di seluruh perintah tutorial ini. Anda mungkin perlu menetapkan variabel lingkungan lagi jika menutup Cloud Shell.

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

Ganti PROJECT_ID dengan project ID yang Anda pilih untuk tutorial ini di bagian Sebelum memulai.

Dalam tutorial ini, Anda akan membuat resource di us-central1-a. Untuk melihat daftar lengkap tempat rangkaian mesin Tau T2A tersedia, lihat Region dan zona yang tersedia.

Meng-clone repositori git

Tutorial ini menggunakan resource dari repositori GitHub Arm on GKE.

1. Meng-cloning repository

   git clone https://github.com/GoogleCloudPlatform/gke-arm
   

2. Ubah direktori tugas Anda saat ini ke gke-arm/migrate-x86-app-to-multi-arch/ dari repositori yang di-clone pada langkah sebelumnya:

   cd gke-arm/migrate-x86-app-to-multi-arch/
   

Membuat cluster GKE dan men-deploy aplikasi x86

Di bagian pertama tutorial ini, Anda akan membuat cluster dengan node x86 dan men-deploy aplikasi x86. Aplikasi contoh adalah layanan yang merespons permintaan HTTP. Aplikasi ini dibuat dengan bahasa pemrograman Golang.

Penyiapan ini merepresentasikan tampilan lingkungan cluster pada umumnya, dengan menggunakan aplikasi yang kompatibel dengan x86 dan node x86.

Membuat cluster GKE

Pertama, buat GKE menggunakan node dengan prosesor x86. Dengan konfigurasi ini, Anda akan membuat lingkungan cluster standar untuk menjalankan aplikasi x86.

Membuat cluster:

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

Penskalaan otomatis pada cluster ini dinonaktifkan untuk mendemonstrasikan fungsi tertentu pada langkah-langkah berikutnya.

Proses pembuatan cluster ini memerlukan waktu beberapa menit. Flag --async memungkinkan operasi ini berjalan di latar belakang saat Anda menyelesaikan langkah berikutnya.

Anda dapat membuat cluster hanya dengan node Arm, tetapi dalam tutorial ini, Anda akan membuat cluster dengan hanya node x86 terlebih dahulu untuk mempelajari proses membuat aplikasi khusus x86 yang kompatibel dengan Arm.

Membuat repositori Docker Artifact Registry

1. Membuat repositori di Artifact Registry untuk menyimpan image Docker:

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

2. Mengonfigurasi alat command line Docker untuk mengautentikasi ke repositori ini di Artifact Registry:

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

Mem-build image x86 dan mengirimnya ke Artifact Registry

1. Membuat versi aplikasi yang kompatibel dengan x86:

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

2. Mengirim image ke Artifact Registry:

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

Men-deploy aplikasi x86

1. Periksa kesiapan cluster dengan menjalankan skrip berikut:

   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
   

   Jika cluster sudah siap, output-nya akan terlihat seperti berikut:

   GKE Cluster 'my-cluster' is RUNNING
   

2. Ambil kredensial cluster agar kubectl dapat terhubung ke Kubernetes API untuk cluster tersebut:

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

3. Update image menggunakan kustomize dan deploy aplikasi 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. Deploy Service untuk mengekspos aplikasi ke Internet:

   kubectl apply -f k8s/hello-service.yaml
   

5. Pastikan alamat IP eksternal untuk Service, hello-service, telah selesai disediakan:

   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
   

   Setelah alamat IP eksternal disediakan, output-nya akan mirip dengan berikut ini:

   External IP: 203.0.113.0
   

6. Buat permintaan HTTP untuk menguji berfungsi atau tidaknya deployment seperti yang diharapkan:

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

   Outputnya mirip dengan hal berikut ini:

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

   Output menunjukkan bahwa deployment yang kompatibel dengan x86 ini berjalan di node dalam node pool default pada arsitektur amd64. Node di node pool default cluster Anda memiliki prosesor x86 (Intel maupun AMD).

Menambahkan node Arm ke cluster

Di bagian selanjutnya dari tutorial ini, tambahkan node Arm ke cluster yang ada. Node ini adalah tempat versi aplikasi Anda yang kompatibel dengan Arm di-deploy saat di-build ulang untuk berjalan di Arm.

Checkpoint

Sejauh ini Anda telah mencapai tujuan berikut:

• membuat cluster GKE menggunakan node x86.
• menyimpan image container yang kompatibel dengan x86 dengan Docker di Artifact Registry.
• men-deploy workload yang kompatibel dengan x86 ke cluster GKE.

Anda telah mengonfigurasi lingkungan cluster dengan node x86 dan workload yang kompatibel dengan x86. Konfigurasi ini mirip dengan lingkungan cluster yang ada jika saat ini Anda tidak menggunakan node Arm dan workload yang kompatibel dengan Arm.

Menambahkan node pool Arm ke cluster

Tambahkan node pool Arm ke cluster yang ada:

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

Jenis mesin t2a-standard-2 adalah Arm VM dari rangkaian mesin Tau T2A (Pratinjau).

Anda membuat node pool dengan node Arm dengan cara yang sama seperti membuat node pool dengan node x86. Setelah node pool ini dibuat, Anda akan memiliki node x86 dan node Arm yang berjalan di cluster ini.

Untuk mempelajari lebih lanjut cara menambahkan node pool Arm ke cluster yang ada, lihat artikel Menambahkan node pool Arm ke cluster GKE.

Meningkatkan skala aplikasi yang ada yang berjalan di node berbasis x86

Node dari beberapa jenis arsitektur dapat bekerja sama dengan lancar dalam satu cluster. GKE tidak menjadwalkan workload yang ada yang berjalan pada node x86 ke node Arm dalam cluster karena taint secara otomatis ditempatkan pada node Arm. Anda dapat melihatnya dengan meningkatkan skala aplikasi yang sudah ada.

1. Update workload, dengan menskalakan hingga 6 replika:

   $(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. Tunggu 30 detik, lalu jalankan perintah berikut untuk memeriksa status deployment:

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

   Output-nya akan terlihat seperti berikut:

   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
   

   Output ini menampilkan Pod dengan status Tertunda karena tidak ada ruang tersisa di node berbasis x86. Karena Autoscaler Cluster dinonaktifkan dan node Arm di-taint, workload tidak akan di-deploy di node Arm yang tersedia. Taint ini mencegah GKE agar tidak menjadwalkan workload x86 pada node Arm. Untuk men-deploy ke node Arm, Anda harus menunjukkan bahwa deployment tersebut kompatibel dengan node Arm.

3. Periksa Pod yang ada dalam status Berjalan:

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

   Output-nya akan terlihat seperti berikut:

   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>
   

   Dalam output ini, kolom NODE menunjukkan bahwa semua Pod dari deployment hanya berjalan di pool default, yang berarti bahwa Pod yang kompatibel dengan x86 hanya dijadwalkan ke node x86. Pod asli yang sudah dijadwalkan sebelum pembuatan node pool Arm masih berjalan di node yang sama.

4. Jalankan perintah berikut untuk mengakses layanan dan melihat output-nya:

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

   Outputnya mirip dengan yang berikut ini:

   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
   

   Output ini menunjukkan bahwa semua Pod yang menyajikan permintaan berjalan pada node x86. Beberapa Pod tidak dapat merespons karena masih dalam status Tertunda sebab tidak ada ruang pada node x86 yang ada dan tidak akan dijadwalkan ke node Arm.

Mem-build ulang aplikasi Anda untuk berjalan di Arm

Di bagian sebelumnya, Anda telah menambahkan node pool Arm ke cluster yang ada. Namun, ketika Anda meningkatkan skala aplikasi x86 yang sudah ada, aplikasi tersebut tidak menjadwalkan workload apa pun ke node Arm. Di bagian ini, Anda akan mem-build ulang aplikasi agar kompatibel dengan Arm, sehingga aplikasi ini dapat berjalan di node Arm di cluster.

Untuk contoh ini, selesaikan langkah-langkah ini menggunakan docker build. Pendekatan dua langkah ini meliputi:

• Tahap pertama: Buat kode untuk Arm.
• Tahap kedua: Salin file yang dapat dieksekusi ke container yang efisien.

Setelah mengikuti langkah-langkah ini, Anda akan memiliki image yang kompatibel dengan Arm selain image yang kompatibel dengan x86.

Langkah kedua untuk menyalin file yang dapat dieksekusi ke container lain adalah mengikuti salah satu praktik terbaik untuk mem-build container, yaitu mem-build image sekecil mungkin.

Tutorial ini menggunakan aplikasi contoh yang dibuat dengan bahasa pemrograman Golang. Dengan Golang, Anda dapat melakukan kompilasi silang aplikasi ke berbagai sistem operasi dan platform CPU dengan memberikan variabel lingkungan, GOOS dan GOARCH.

1. Jalankan cat Dockerfile_arm untuk melihat Dockerfile ditulis untuk Arm:

   #
   # 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
   

   Cuplikan yang ditampilkan di sini hanya menampilkan tahap pertama. Kedua tahap disertakan dalam file tersebut.

   Dalam file ini, menyetel GOARCH=arm64 akan menginstruksikan compiler Go guna mem-build aplikasi untuk kumpulan petunjuk Arm. Anda tidak perlu menetapkan GOOS karena image dasar pada tahap pertama adalah image Alpine Linux.

2. Build kode untuk Arm, dan kirim ke 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
   

Men-deploy versi Arm aplikasi Anda

Setelah aplikasi di-build untuk berjalan di node Arm, Anda dapat men-deploy aplikasi tersebut ke node Arm di cluster Anda.

1. Periksa add_arm_support.yaml dengan menjalankan cat k8s/overlays/arm/add_arm_support.yaml:

   Outputnya mirip dengan hal berikut ini:

      nodeSelector:
         kubernetes.io/arch: arm64
   

   nodeSelector ini menentukan bahwa workload hanya boleh berjalan pada node Arm. Saat Anda menggunakan nodeSelector, GKE menambahkan toleransi yang cocok dengan taint pada node Arm, sehingga GKE menjadwalkan workload pada node tersebut. Untuk mempelajari lebih lanjut cara menetapkan kolom ini, lihat Menyiapkan workload Arm untuk deployment.

2. Deploy satu replika versi aplikasi yang kompatibel dengan 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. Tunggu 5 detik, lalu pastikan deployment Arm menjawab permintaan curl:

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

   Outputnya mirip dengan hal berikut ini:

   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
   

   Output ini harus mencakup respons dari aplikasi yang kompatibel dengan x86 dan yang kompatibel dengan Arm yang merespons permintaan curl.

Mem-build image multi-arsitektur untuk menjalankan workload di seluruh arsitektur

Meskipun Anda dapat menggunakan strategi yang dijelaskan di bagian sebelumnya dan men-deploy workload terpisah untuk x86 dan Arm, hal ini mengharuskan Anda mengelola dan menjaga dua proses build dan dua image container tetap terorganisir.

Idealnya, Anda ingin mem-build dan menjalankan aplikasi dengan lancar di seluruh platform x86 dan Arm. Kami merekomendasikan pendekatan ini. Untuk menjalankan aplikasi dengan satu manifes di beberapa platform arsitektur, Anda perlu menggunakan image multi-arsitektur (multi-arch). Untuk mempelajari image multi-arsitektur lebih lanjut, lihat Mem-build image multi-arch untuk workload Arm.

Untuk menggunakan image multi-arsitektur, Anda harus memastikan bahwa aplikasi Anda memenuhi prasyarat berikut:

• Aplikasi Anda tidak memiliki dependensi khusus platform arsitektur.
• Semua dependensi harus dibuat untuk multi-arsitektur atau, setidaknya, platform yang ditargetkan.

Aplikasi contoh yang digunakan dalam tutorial ini memenuhi kedua prasyarat tersebut. Namun, sebaiknya uji aplikasi Anda sendiri saat mem-build image multi-arch sebelum men-deploy-nya ke produksi.

Mem-build dan mengirim image multi-arsitektur

Anda dapat mem-build image multi-arch dengan Docker Buildx jika workload Anda memenuhi prasyarat berikut:

• Image dasar mendukung beberapa arsitektur. Periksa hal ini dengan menjalankan docker manifest inspect pada image dasar dan memeriksa daftar platform arsitektur. Lihat contoh cara memeriksa image pada akhir bagian ini.
• Aplikasi tidak memerlukan langkah-langkah build khusus untuk setiap platform arsitektur. Jika langkah-langkah khusus diperlukan, Buildx mungkin tidak cukup. Anda harus memiliki Dockerfile terpisah untuk setiap platform dan membuat manifes secara manual dengan docker manifest create.

Contoh image dasar aplikasi adalah Alpine, yang mendukung beberapa arsitektur. Tidak ada juga langkah-langkah arsitektur khusus platform, sehingga Anda dapat mem-build image multi-arch dengan Buildx.

1. Periksa Dockerfile dengan menjalankan cat 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 ini menentukan dua tahap: tahap build dan tahap rilis. Anda menggunakan Dockerfile yang sama dengan yang digunakan untuk mem-build aplikasi x86. Jika mengikuti praktik terbaik untuk mem-build container, Anda mungkin dapat mem-build ulang image container sendiri tanpa mengubah apa pun.

2. Jalankan perintah berikut untuk membuat dan menggunakan builder docker buildx baru:

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

   Setelah membuat builder baru ini, Anda dapat mem-build dan mengirim image yang kompatibel dengan linux/amd64 dan linux/arm64 menggunakan tanda --platform. Untuk setiap platform yang diberikan dengan flag tersebut, Buildx mem-build image di platform target. Saat Buildx mem-build image linux/arm64, Buildx akan mendownload image dasar arm64. Pada tahap pertama, Buildx mem-build biner pada image arm64 golang:1.18-alpine untuk arm64. Pada tahap kedua, image Alpine Linux arm64 didownload dan biner disalin ke lapisan image tersebut.

3. Build dan kirim image:

   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 .
   

   Outputnya mirip dengan hal berikut ini:

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

   Output ini menunjukkan bahwa dua image telah dibuat, satu untuk linux/arm64 dan satu untuk linux/amd64.

4. Periksa manifes image multi-arch Anda yang baru:

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

   Outputnya mirip dengan hal berikut ini:

   {
      "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"
            }
         }
      ]
   

   Dalam output ini, bagian manifests menyertakan dua manifes, satu dengan arsitektur platform amd64, dan satunya lagi dengan arsitektur platform arm64.

   Saat Anda men-deploy image container ini ke cluster, GKE secara otomatis hanya mendownload image yang sesuai dengan arsitektur node.

Men-deploy versi multi-arch aplikasi Anda

1. Sebelum men-deploy image multi-arch, hapus workload asli:

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

2. Periksa overlay add_multiarch_support.yaml kustomisasi dengan menjalankan cat k8s/overlays/multiarch/add_multiarch_support.yaml:

   Outputnya mencakup set toleransi berikut:

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

   Toleransi ini memungkinkan workload berjalan di node Arm di cluster Anda, karena toleransi cocok dengan taint yang ditetapkan di semua node Arm. Karena workload ini kini dapat berjalan pada node mana pun di cluster, hanya toleransi yang diperlukan. Hanya dengan toleransi, GKE dapat menjadwalkan workload ke node x86 dan Arm. Jika Anda ingin menentukan tempat GKE dapat menjadwalkan workload, gunakan pemilih node dan aturan afinitas node. Untuk mempelajari lebih lanjut cara menetapkan kolom ini, lihat Menyiapkan workload Arm untuk deployment.

3. Deploy image container multi-arch dengan 6 replika:

   $(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. Tunggu selama 10 detik, lalu konfirmasi bahwa semua replika aplikasi sedang berjalan:

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

   Outputnya mirip dengan hal berikut ini:

   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>
   

   Output ini mencakup kolom NODE yang menunjukkan bahwa Pod berjalan di kedua node dalam node pool Arm dan yang lainnya di node pool default (x86).

5. Jalankan perintah berikut untuk mengakses layanan dan melihat output-nya:

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

   Outputnya mirip dengan hal berikut ini:

   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
   

   Anda akan melihat bahwa Pod yang berjalan di berbagai platform arsitektur menjawab permintaan.

   Catatan: Anda dapat menjalankan perintah ini dan hanya menerima respons dari Pod yang berjalan di satu platform arsitektur. Jika hal ini terjadi, jalankan perintah sekali atau dua kali lagi dan Anda harus merespons dari kedua platform arsitektur.

Anda telah mem-build dan men-deploy image multi-arch untuk menjalankan workload di beberapa arsitektur dengan lancar.

Pembersihan

Agar tidak perlu membayar biaya pada akun Google Cloud Anda untuk resource yang digunakan dalam tutorial ini, hapus project yang berisi resource tersebut, atau simpan project dan hapus setiap resource.

Setelah menyelesaikan tutorial, Anda dapat membersihkan resource yang dibuat untuk mengurangi penggunaan kuota dan menghentikan biaya penagihan. Bagian berikut menjelaskan cara menghapus atau menonaktifkan resource ini.

Menghapus project

Cara termudah untuk menghilangkan penagihan adalah dengan menghapus project yang Anda buat untuk tutorial.

Untuk menghapus project:

Perhatian: Menghapus project memiliki efek berikut:

• Semua hal dalam project akan dihapus. Jika menggunakan project yang sudah ada untuk tugas dalam dokumen ini, saat Anda menghapusnya, pekerjaan lain yang telah Anda lakukan dalam project tersebut juga akan terhapus.
• Project ID kustom hilang. Saat membuat project ini, Anda mungkin telah membuat project ID kustom yang ingin digunakan di masa mendatang. Untuk mempertahankan URL yang menggunakan project ID, seperti URL appspot.com, hapus resource yang dipilih di dalam project, bukan menghapus seluruh project.

Jika Anda berencana mempelajari berbagai arsitektur, tutorial, atau panduan memulai, menggunakan kembali project dapat membantu agar Anda tidak melampaui batas kuota project.

1. Di konsol Google Cloud, buka halaman Manage resource.

   Buka Manage resource

2. Pada daftar project, pilih project yang ingin Anda hapus, lalu klik Delete.
3. Pada dialog, ketik project ID, lalu klik Shut down untuk menghapus project.

Menghapus layanan, cluster, dan repositori

Jika Anda tidak ingin menghapus seluruh project, hapus cluster dan repositori yang Anda buat untuk tutorial:

1. Hapus Service aplikasi dengan menjalankan kubectl delete:

   kubectl delete service hello-service
   

   Perintah ini menghapus load balancer Compute Engine yang Anda buat saat mengekspos Deployment.

2. Hapus cluster Anda dengan menjalankan gcloud container clusters delete:

   gcloud container clusters delete $CLUSTER_NAME --zone $ZONE
   

3. Hapus repositori:

   gcloud artifacts repositories delete docker-repo —location=us-central1 --async
   

Langkah selanjutnya

• Workload Arm di GKE
• Membuat cluster dan node pool dengan node Arm
• Mem-build image multi-arsitektur untuk workload Arm
• Menyiapkan workload Arm untuk deployment
• Menyiapkan workload Autopilot pada arsitektur Arm
• Praktik terbaik untuk menjalankan aplikasi Kubernetes hemat biaya di GKE
• Pelajari arsitektur referensi, diagram, dan praktik terbaik tentang Google Cloud. Lihat Cloud Architecture Center kami.