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:
Untuk membuat perkiraan biaya berdasarkan proyeksi penggunaan Anda,
gunakan kalkulator harga.
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:- 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.
-
Di konsol Google Cloud, pada halaman pemilih project, pilih atau buat project Google Cloud.
-
Pastikan penagihan telah diaktifkan untuk project Google Cloud Anda.
-
Aktifkan API Artifact Registry and Google Kubernetes Engine.
-
Di konsol Google Cloud, pada halaman pemilih project, pilih atau buat project Google Cloud.
-
Pastikan penagihan telah diaktifkan untuk project Google Cloud Anda.
-
Aktifkan API Artifact Registry and Google Kubernetes Engine.
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:
Buka Konsol Google Cloud.
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.
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.
Meng-cloning repository
git clone https://github.com/GoogleCloudPlatform/gke-arm
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
Membuat repositori di Artifact Registry untuk menyimpan image Docker:
gcloud artifacts repositories create docker-repo \ --repository-format=docker \ --location=us-central1 \ --description="Docker repository"
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
Membuat versi aplikasi yang kompatibel dengan x86:
docker build -t us-central1-docker.pkg.dev/$PROJECT_ID/docker-repo/x86-hello:v0.0.1 .
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
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
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
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
Deploy Service untuk mengekspos aplikasi ke Internet:
kubectl apply -f k8s/hello-service.yaml
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
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.
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/
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.
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.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
.
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 menetapkanGOOS
karena image dasar pada tahap pertama adalah image Alpine Linux.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.
Periksa
add_arm_support.yaml
dengan menjalankancat 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 menggunakannodeSelector
, 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.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
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.
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.
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
danlinux/arm64
menggunakan tanda--platform
. Untuk setiap platform yang diberikan dengan flag tersebut, Buildx mem-build image di platform target. Saat Buildx mem-build imagelinux/arm64
, Buildx akan mendownload image dasararm64
. Pada tahap pertama, Buildx mem-build biner pada imagearm64 golang:1.18-alpine
untukarm64
. Pada tahap kedua, image Alpine Linuxarm64
didownload dan biner disalin ke lapisan image tersebut.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 untuklinux/amd64
.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 platformamd64
, dan satunya lagi dengan arsitektur platformarm64
.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
Sebelum men-deploy image multi-arch, hapus workload asli:
kubectl delete deploy x86-hello-deployment arm-hello-deployment
Periksa overlay
add_multiarch_support.yaml
kustomisasi dengan menjalankancat 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.
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
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).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.
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:
- Di konsol Google Cloud, buka halaman Manage resource.
- Pada daftar project, pilih project yang ingin Anda hapus, lalu klik Delete.
- 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:
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.
Hapus cluster Anda dengan menjalankan
gcloud container clusters delete
:gcloud container clusters delete $CLUSTER_NAME --zone $ZONE
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.