Anthos Service Mesh 1.9 telah mencapai akhir siklus proses dan tidak lagi didukung. Lihat Mengupgrade dari versi sebelumnya.

Lihat dokumentasi terbaru atau pilih versi lain yang tersedia:

Versi yang tersedia

1.20 (terbaru)
1.19
1.18
1.17
1.16
1.15
1.14
1.13
1.12
1.12

219}

Menambahkan virtual machine Compute Engine ke Anthos Service Mesh

Pengantar

Anthos Service Mesh memungkinkan Anda mengelola, mengamati, dan mengamankan layanan yang berjalan di Grup Instance Terkelola (MIG) bersama dengan layanan yang berjalan di cluster Google Kubernetes Engine (GKE) di mesh. Dengan begitu, Anda dapat melakukan hal berikut terhadap instance Compute Engine di mesh:

Kelola traffic.
Menerapkan mTLS.
Menerapkan kontrol akses ke traffic layanan.
Akses layanan Google Cloud dengan aman.
Kumpulkan metrik, logging, dan pelacakan data.
Memantau layanan menggunakan Konsol Google Cloud.

Hal ini memungkinkan aplikasi lama yang tidak cocok atau siap untuk containerization memanfaatkan fitur Anthos Service Mesh dan memungkinkan integrasi beban kerja tersebut dengan layanan Anda lainnya.

Cara kerja Duet AI

ASM menyediakan dua Definisi Resource Kustom (CRD) terkait untuk mewakili workload mesin virtual:

WorkloadGroup mewakili grup logis workload virtual machine yang memiliki properti umum. Hal ini mirip dengan Deployment di Kubernetes.
WorkloadEntry mewakili satu instance dari beban kerja virtual machine. Fungsi ini mirip dengan Pod di Kubernetes.
Service kemudian dapat memilih WorkloadGroup dan memiliki traffic rute ASM ke instance VM dengan cara yang sama seperti Pod. Hal ini memungkinkan VM bertindak seperti beban kerja lain di mesh.

Anda membuat template instance Compute Engine untuk setiap grup instance Compute Engine, yang menentukan agen proxy layanan untuk setiap instance Compute Engine dalam grup tersebut. Selama penginstalan, agen melakukan bootstrap pada proxy layanan, menyiapkan intersepsi traffic, dan memantau kondisi proxy layanan selama masa aktif instance Compute Engine. Proxy tersebut terhubung dengan bidang kontrol Anthos Service Mesh, lalu secara otomatis mendaftarkan setiap instance Compute Engine sebagai WorkloadEntry untuk WorkloadGroup terkait. Hal ini memungkinkan Anthos Service Mesh memperlakukan setiap instance sebagai endpoint layanan, seperti pod Kubernetes dalam cluster. Anda juga dapat membuat layanan Kubernetes untuk beban kerja VM, seperti yang Anda lakukan untuk pod Kubernetes.

Untuk meningkatkan atau menurunkan jumlah workload di instance Compute Engine, mulai dari ukuran MIG minimum hingga nol, lihat Penskalaan otomatis grup instance.

Agen proxy layanan mengandalkan pengelola VM untuk memastikan agen diinstal di setiap VM di MIG. Untuk mengetahui informasi selengkapnya tentang grup instance dan pengelolaan VM, lihat Grup instance terkelola (MIG) dan Pengelola VM.

Distribusi Linux yang didukung

Versi OS	didukung
Debian 10
Debian 9
Centos 8
Centos 7

Lihat dukungan Debian atau dukungan CentOS untuk mengetahui informasi selengkapnya tentang distribusi OS.

Batasan

Bidang kontrol mesh harus berupa Anthos Service Mesh 1.9 atau yang lebih baru.
Hanya grup instance terkelola Compute Engine yang dibuat dari template instance Compute Engine yang didukung.
Cluster dan VM harus berada di jaringan yang sama, dalam project yang sama, dan menggunakan satu antarmuka jaringan.
Anda dapat menggunakan fitur ini tanpa langganan GKE Enterprise, tetapi elemen dan fitur UI tertentu di Konsol Google Cloud hanya tersedia untuk pelanggan GKE Enterprise. Untuk mengetahui informasi tentang apa yang tersedia bagi pelanggan dan non-pelanggan, lihat perbedaan UI GKE Enterprise dan Anthos Service Mesh.

Prasyarat

Sebelum memulai, periksa prasyarat berikut.

Cluster

Halaman ini mencakup opsi untuk menginstal Anthos Service Mesh sebagai bagian dari langkah-langkahnya atau mengupdate cluster yang telah menginstal Anthos Service Mesh. Dalam kedua kasus ini, langkah ini memerlukan Anthos Service Mesh 1.9+ dan cluster yang memenuhi persyaratan ini. Selain itu, dukungan VM Anthos Service Mesh memiliki persyaratan lebih lanjut:

Bidang kontrol harus diinstal dalam cluster yang Anda kontrol. Bidang kontrol yang dikelola Google tidak didukung. Untuk informasi selengkapnya, lihat pesawat kontrol yang dikelola Google.
Menggunakan Mesh CA sebagai certificate authority.
Menggunakan Stackdriver untuk telemetri.
Mengaktifkan deployment canonical Service, yang otomatis diaktifkan oleh proses penginstalan Anthos Service Mesh.

Cluster Anda harus terdaftar ke fleet. Namun, jika belum terdaftar, proses penginstalan VM dapat mendaftarkannya untuk Anda dalam project yang Anda tentukan.

Jika Anda adalah pelanggan GKE Enterprise, aktifkan GKE Enterprise API.

Mengaktifkan API

Alat CLI

Proses penginstalan memerlukan alat berikut, yang sudah diinstal jika Anda menggunakan Google Cloud Shell:

gcloud
kubectl
kpt
curl
jq
awk
printf
tr
grep
tail

Mendownload skrip

Bagian ini menjelaskan cara mendownload skrip untuk orientasi VM.

Download skrip VM untuk Anthos Service Mesh 1.9.8 ke direktori kerja saat ini:
```
curl https://storage.googleapis.com/csm-artifacts/asm/asm_vm_1.9 > asm_vm
```

Download file SHA-256 ke direktori kerja saat ini:

curl https://storage.googleapis.com/csm-artifacts/asm/asm_vm_1.9.sha256 > asm_vm.sha256

Dengan kedua file berada di direktori yang sama, verifikasi download:
```
sha256sum -c --ignore-missing asm_vm.sha256
```
Jika verifikasi berhasil, perintah akan menghasilkan output: asm_vm: OK

Untuk kompatibilitas, file asm_vm.sha256 menyertakan checksum dua kali untuk memungkinkan nama versi skrip apa pun diganti menjadi asm_vm. Jika Anda mendapatkan error bahwa --ignore-missing tidak ada, jalankan kembali perintah sebelumnya tanpa flag --ignore-missing.
Buat agar skrip dapat dieksekusi:
```
chmod +x asm_vm
```

Memulai

Bagian ini menjelaskan langkah-langkah untuk menambahkan instance Compute Engine ke Anthos Service Mesh.

Menyiapkan lingkungan Anda

Gunakan gcloud untuk mengonfigurasi alat kubectl agar mengarah ke cluster yang Anda tentukan, karena beberapa langkah di bawah mengharuskan Anda melakukan perubahan langsung pada cluster.

Catatan: Gunakan --region, bukan --zone, jika cluster adalah cluster regional.
```
gcloud container clusters get-credentials CLUSTER_NAME --zone CLUSTER_LOCATION --project PROJECT_ID
```

Menyiapkan cluster Anda

Siapkan cluster Anthos Service Mesh untuk VM, dengan menyiapkan bidang kontrol Anthos Service Mesh 1.9+.

Pilih langkah berikutnya berdasarkan apakah Anthos Service Mesh 1.9+ sudah terinstal di cluster Anda.

Tidak terinstal

Jika Anthos Service Mesh 1.9+ belum diinstal di cluster Anda, contoh berikut menunjukkan cara menambahkan opsi vm dan hub-meshca untuk mengubah langkah-langkah penginstalan Anthos Service Mesh yang biasa disediakan di bagian Penginstalan, migrasi, dan upgrade untuk GKE. Panduan ini juga menjelaskan cara mendownload skrip install_asm yang digunakan dalam contoh berikut.

Setelah mendownload skrip install_asm, Anda dapat menginstal Anthos Service Mesh di cluster dengan menyertakan --option hub-meshca, flag --option vm, dan --enable_all. Untuk mengetahui informasi selengkapnya, lihat mengaktifkan Mesh CA dengan fleet dan tanda Pengaktifan.

./install_asm --project_id PROJECT_ID \
--cluster_name CLUSTER_NAME \
--cluster_location CLUSTER_LOCATION \
--mode install --option vm --option hub-meshca \
--enable_all

Diinstal

Jika Anthos Service Mesh 1.9+ telah diinstal di cluster Anda dan memiliki Mesh CA dengan fleet yang diaktifkan, update bidang kontrol Anthos Service Mesh untuk mendukung workload berbasis VM. Skrip ini juga membantu Anda memverifikasi apakah penginstalan Anthos Service Mesh di cluster siap untuk workload VM. Secara khusus, sub-perintah prepare_cluster akan memperbarui semua revisi di Anthos Service Mesh 1.9+ agar siap untuk workload VM.

Jika Mesh CA dengan fleet tidak diaktifkan di penginstalan Anthos Service Mesh 1.9+, instal ulang atau upgrade penginstalan Anthos Service Mesh 1.9+ dengan menyertakan --option hub-meshca dan flag --option vm dalam skrip install_asm.

./asm_vm prepare_cluster \
--project_id PROJECT_ID \
--cluster_name CLUSTER_NAME \
--cluster_location CLUSTER_LOCATION

Langkah sebelumnya telah melakukan tindakan berikut untuk Anda:

Aktifkan Pendaftaran Otomatis VM: Ini dilakukan dengan menetapkan variabel PILOT_ENABLE_WORKLOAD_ENTRY_AUTOREGISTRATION ke benar (true). Saat fitur ini diaktifkan, instance VM baru akan didaftarkan dengan WorkloadGroup dan CR WorkloadEntry baru akan dibuat untuk mengarahkan traffic ke VM. Semua bidang kontrol Anthos Service Mesh 1.9+ yang diinstal dengan install_asm akan menyertakan ini secara default.
Menginstal gateway Ekspansi: Gateway ini diberi nama gateway eastwest dan ditentukan dalam paket konfigurasi Anthos Service Mesh. Tindakan ini juga akan mengekspos bidang kontrol ke VM.
Instal CRD IdentityProvider dan daftarkan CR Google IdentityProvider agar VM dapat melakukan autentikasi ke bidang kontrol Anthos Service Mesh dan berkomunikasi secara aman dengan mesh layanan lainnya.
Daftarkan cluster ke fleet dan aktifkan identitas workload, jika Anda menggunakan --enable_all atau --enable_registration dalam skrip install_asm.
Aktifkan fitur Service Mesh dalam fleet. Fitur ini akan mengelola kebijakan yang diperlukan agar VM dapat berkomunikasi dengan mesh secara aman.

Tambahkan VM Anda

Di bagian ini, Anda akan menambahkan instance Compute Engine ke mesh berdasarkan template instance yang dibuat dengan skrip asm_vm. Skrip hanya menghasilkan konfigurasi yang diperlukan untuk agen proxy layanan. Untuk menyertakan lebih banyak konfigurasi dalam template instance Anda, buat template instance sumber dan tambahkan ke skrip.

Untuk menambahkan VM ke mesh, lakukan langkah-langkah berikut:

Tetapkan variabel lingkungan berikut untuk digunakan di langkah berikutnya. Tetapkan variabel ini untuk setiap beban kerja VM:
- WORKLOAD_NAME adalah nama beban kerja yang menjadi bagian dari VM, yang harus berupa subdomain DNS-1123 sesuai yang terdiri dari karakter alfanumerik huruf kecil.
- WORKLOAD_VERSION adalah versi beban kerja yang mencakup VM. Opsional.
- WORKLOAD_SERVICE_ACCOUNT adalah layanan Akun Layanan GCP tempat VM berjalan.
- WORKLOAD_NAMESPACE adalah namespace untuk beban kerja.
- ASM_INSTANCE_TEMPLATE adalah nama template instance yang akan dibuat. Nama template instance Compute Engine tidak mengizinkan garis bawah.
- SOURCE_INSTANCE_TEMPLATE adalah nama template yang menjadi dasar template yang dibuat. Opsional.
Buat namespace untuk beban kerja VM jika belum ada:
```
kubectl create ns WORKLOAD_NAMESPACE
```
Beri label namespace dengan revisi bidang kontrol. Untuk contoh cara menemukan revisi bidang kontrol yang ditampilkan sebagai REVISION dalam contoh berikut, lihat Men-deploy dan men-deploy ulang beban kerja.
```
kubectl label ns WORKLOAD_NAMESPACE istio-injection- istio.io/rev=REVISION --overwrite
```

Buat WorkloadGroup untuk VM yang akan didaftarkan:

kubectl apply -f - << EOF
apiVersion: networking.istio.io/v1alpha3
kind: WorkloadGroup
metadata:
 name: WORKLOAD_NAME
 namespace: WORKLOAD_NAMESPACE
spec:
 metadata:
   labels:
     app.kubernetes.io/name: WORKLOAD_NAME
     app.kubernetes.io/version: WORKLOAD_VERSION
   annotations:
     security.cloud.google.com/IdentityProvider: google
 template:
   serviceAccount: WORKLOAD_SERVICE_ACCOUNT
EOF

Kolom	Deskripsi
`name`	Nama beban kerja yang menjadi bagian dari VM.
`namespace`	Namespace tempat beban kerja menjadi bagiannya.
`app.kubernetes.io/name`	Label yang direkomendasikan untuk aplikasi Kubernetes. Anda dapat menggunakan label Anda sendiri untuk workload VM Anda.
`app.kubernetes.io/version`	Label yang direkomendasikan untuk aplikasi Kubernetes. Anda dapat menggunakan label Anda sendiri untuk workload VM Anda.
`serviceAccount`	Identitas akun layanan yang digunakan oleh VM dan project, yang akan digunakan sebagai bagian dari identitas beban kerja dalam format SPIFFE. Untuk mengetahui informasi selengkapnya, lihat Akun layanan.
`security.cloud.google.com/IdentityProvider`	Penyedia identitas yang akan digunakan VM, yang seharusnya sudah terdaftar di cluster Anda. Untuk VM Compute Engine, parameter ini harus ditetapkan ke `google`. `IdentityProvider` memberi tahu bidang kontrol cara mengautentikasi kredensial VM dan tempat mengekstrak akun layanan VM.

Jalankan skrip asm_vm dengan opsi dan flag berikut guna membuat template instance untuk instance Compute Engine Anthos Service Mesh Anda.

Skrip ini memverifikasi prasyarat cluster, menambahkan label VM untuk Anthos Service Mesh, membuat konfigurasi metadata kustom untuk agen proxy layanan, dan membuat template instance baru.

Jika sudah memiliki template instance yang ingin dijadikan dasar skrip, Anda dapat menentukan opsi --source_instance_template. Jika Anda ingin menambahkan VM non-default ke Anthos Service Mesh, buat template instance dengan distribusi OS yang diinginkan dan gunakan template tersebut sebagai nilai untuk flag --source_instance_template dalam skrip asm_vm. Jika template instance yang ada menyertakan skrip startup yang memerlukan konektivitas jaringan, skrip tersebut harus tahan terhadap masalah konektivitas jaringan sementara. Lihat aplikasi demo untuk mengetahui contoh cara menambahkan ketahanan terhadap gangguan jaringan sementara.

./asm_vm create_gce_instance_template \
ASM_INSTANCE_TEMPLATE \
--project_id PROJECT_ID \
--cluster_location CLUSTER_LOCATION \
--cluster_name CLUSTER_NAME \
--workload_name WORKLOAD_NAME \
--workload_namespace WORKLOAD_NAMESPACE \
--source_instance_template SOURCE_INSTANCE_TEMPLATE

Opsi

Opsi	Deskripsi
`-p\|--project_id PROJECT_ID`	Project ID tempat cluster dibuat.
`-n\|--cluster_name CLUSTER_NAME`	Nama cluster.
`-l\|--cluster_location CLUSTER_LOCATION`	Zona (untuk cluster zona tunggal) atau region (untuk cluster regional) tempat cluster dibuat.
`-w\|--workload_name WORKLOAD_NAME`	Nama beban kerja yang diwakili oleh instance Compute Engine.
`--workload_namespace WORKLOAD_NAMESPACE`	Opsional. Namespace beban kerja. Default-nya adalah `default`.
`-s\|--source_instance_template SOURCE_INSTANCE_TEMPLATE_NAME`	Opsional. Template instance yang ada untuk digunakan sebagai dasar untuk template instance Compute Engine Anthos Service Mesh. Jika tidak ditentukan, template instance dengan nilai default akan dibuat.

Tanda

Flag	Deskripsi
`-v\|--verbose`	Cetak perintah sebelum dan sesudah eksekusi.
`--dry_run`	Cetak perintah, tetapi jangan jalankan.
`--only_validate`	Jalankan validasi, tetapi jangan buat template instance Compute Engine baru.
`-h\|--help`	Tampilkan pesan bantuan yang menjelaskan opsi, lalu tanda dan keluar.

Setel variabel lingkungan berikut untuk setiap MIG yang Anda buat:
- INSTANCE_GROUP_NAME adalah nama grup instance Compute Engine yang akan dibuat.
- ASM_INSTANCE_TEMPLATE adalah nama template instance yang akan dibuat. Nama template instance Compute Engine tidak mengizinkan garis bawah.
- INSTANCE_GROUP_ZONE adalah zona grup instance Compute Engine yang akan dibuat.
- PROJECT_ID adalah project ID tempat cluster dibuat.
- SIZE adalah ukuran grup instance yang akan dibuat. Nama ini dapat diubah setelah grup instance dibuat.
- WORKLOAD_NAME adalah nama beban kerja yang menjadi bagian dari VM.
- WORKLOAD_NAMESPACE adalah namespace untuk beban kerja.
Buat Grup Instance Terkelola untuk workload VM menggunakan variabel yang dibuat pada langkah sebelumnya:
```
gcloud compute instance-groups managed create \
INSTANCE_GROUP_NAME \
--template ASM_INSTANCE_TEMPLATE \
--zone=INSTANCE_GROUP_ZONE \
--project=PROJECT_ID \
--size=SIZE
```
Untuk meningkatkan atau menurunkan skala jumlah workload di instance Compute Engine, mulai dari ukuran MIG zona atau regional dari nol, lihat Penskalaan otomatis grup instance. Untuk mengetahui informasi lebih lanjut tentang cara membuat grup, lihat gcloud compute instance-groups managed create.

Saat instance Anda dimulai, instance akan otomatis melakukan autentikasi dengan bidang kontrol Anthos Service Mesh di cluster Anda dan bidang kontrol akan mendaftarkan setiap VM sebagai WorkloadEntry.
Ketika instance VM di MIG selesai dimulai, Anda dapat melihat VM terdaftar di namespace beban kerja menggunakan perintah berikut:
```
   kubectl get workloadentry -n WORKLOAD_NAMESPACE
```
Catatan: Jika Resource Kustom WorkloadGroup atau IdentityProvider dihapus, VM Anda tidak akan dapat berkomunikasi dengan mesh.
Tambahkan Layanan Kubernetes untuk mengekspos beban kerja VM yang ditambahkan di atas. Pastikan layanan memilih label yang sesuai pada WorkloadGroup VM yang terdaftar di atas untuk pemilihan rute traffic yang benar.

Contoh berikut membuat layanan Kubernetes bernama WORKLOAD_NAME dalam namespace WORKLOAD_NAMESPACE yang mengekspos beban kerja VM dengan label app.kubernetes.io/name: WORKLOAD_NAME di port HTTP 80.
```
kubectl apply -f - << EOF
apiVersion: v1
kind: Service
metadata:
 name: WORKLOAD_NAME
 namespace: WORKLOAD_NAMESPACE
 labels:
   asm_resource_type: VM
spec:
 ports:
 - port: 80
   name: http
 selector:
   app.kubernetes.io/name: WORKLOAD_NAME
EOF
```
Untuk detail selengkapnya tentang cara membuat layanan Kubernetes, lihat https://kubernetes.io/docs/concepts/services-networking/service/#defining-a-service.
Untuk menggunakan aplikasi contoh di VM Anda, lihat Men-deploy aplikasi sampel.

Upgrade bidang kontrol Anthos Service Mesh

Upgrade bidang kontrol Anthos Service Mesh ke versi baru menggunakan petunjuk di Mengupgrade Anthos Service Mesh ke versi terbaru. Setelah menginstal versi baru bidang kontrol Anthos Service Mesh, deploy ulang workload Kubernetes Anda menggunakan petunjuk pada Men-deploy dan men-deploy ulang beban kerja.

Untuk workload VM, buat template instance baru dan lakukan update berkelanjutan pada VM di MIG Anda:

Gunakan perintah berikut untuk menemukan label revisi di istiod:
```
kubectl -n istio-system get pods -l app=istiod --show-labels
```
Output dari perintah serupa dengan berikut ini. Perhatikan bahwa output untuk migrasi sedikit berbeda dengan upgrade. Contoh output berikut berasal dari migrasi.
```
NAME                                READY   STATUS    RESTARTS   AGE   LABELS
istiod-7744bc8dd7-qhlss             1/1     Running   0          49m   app=istiod,istio.io/rev=default,istio=pilot,pod-template-hash=7744bc8dd7
istiod-asm-198-6-85d86774f7-flrt2   1/1     Running   0          26m   app=istiod,istio.io/rev=asm-198-6,istio=istiod,pod-template-hash=85d86774f7
istiod-asm-198-6-85d86774f7-tcwtn   1/1     Running   0          26m   app=istiod,istio.io/rev=asm-198-6,istio=istiod,pod-template-hash=85d86774f7
```
1. Pada output, di kolom LABELS, catat nilai dalam label revisi istiod untuk versi baru, yang mengikuti awalan istio.io/rev=. Dalam contoh ini, nilainya adalah asm-198-6.
2. Perhatikan juga nilai dalam label revisi untuk versi istiod lama. Anda memerlukan tindakan ini untuk menghapus versi lama istiod saat selesai memindahkan beban kerja ke versi baru. Dalam contoh output, nilai dalam label revisi untuk istiod versi lama adalah default.
Tambahkan label revisi ke namespace dan hapus label istio-injection (jika ada). Dalam perintah berikut, ubah REVISION ke nilai yang cocok dengan revisi baru istiod.
```
kubectl label namespace NAMESPACE istio.io/rev=REVISION istio-injection- --overwrite
```
Jika melihat "istio-injection not found" pada output, Anda dapat mengabaikannya. Artinya, namespace sebelumnya tidak memiliki label istio-injection. Karena injeksi otomatis gagal jika namespace memiliki istio-injection dan label revisi, semua perintah kubectl label dalam dokumentasi Anthos Service Mesh mencakup penghapusan label istio-injection.
Buat template instance baru menggunakan skrip asm_vm. Pastikan untuk menggunakan nama template instance baru dan menyertakan template instance sumber yang sama jika Anda memilikinya untuk beban kerja yang sama.

Catatan: Flag --source_instance_template bersifat opsional. Jika Anda memiliki template sumber, Anda harus menyertakannya. Jika Anda tidak memiliki template sumber, jangan sertakan flag tersebut.
```
./asm_vm create_gce_instance_template \
NEW_ASM_INSTANCE_TEMPLATE \
--project_id PROJECT_ID \
--cluster_location CLUSTER_LOCATION \
--cluster_name CLUSTER_NAME \
--workload_name WORKLOAD_NAME \
--workload_namespace WORKLOAD_NAMESPACE \
--source_instance_template SOURCE_INSTANCE_TEMPLATE
```

Lakukan update berkelanjutan ke MIG yang ada untuk workload.

Untuk informasi selengkapnya, lihat Memulai update berkelanjutan dasar.

gcloud compute instance-groups managed rolling-action start-update INSTANCE_GROUP_NAME \
--version=template=NEW_ASM_INSTANCE_TEMPLATE \
--zone=INSTANCE_GROUP_ZONE

Uji beban kerja VM untuk memastikannya berfungsi seperti yang diharapkan.

Mengupgrade aplikasi VM

Jika Anda memiliki update pada aplikasi, termasuk perubahan pada WorkloadGroup dan/atau perubahan pada template instance sumber, template instance baru diperlukan untuk mengupdate MIG workload VM Anda.

Saat perubahan WorkloadGroup diterapkan dan/atau template instance sumber baru dibuat, Anda akan membuat template instance baru untuk Anthos Service Mesh dan melakukan update berkelanjutan pada VM di MIG Anda.

Buat template instance baru menggunakan skrip asm_vm. Pastikan untuk menggunakan nama template instance baru dan menyertakan template instance sumber baru jika Anda membuat nama untuk update aplikasi.

./asm_vm create_gce_instance_template \
NEW_ASM_INSTANCE_TEMPLATE \
--project_id PROJECT_ID \
--cluster_location CLUSTER_LOCATION \
--cluster_name CLUSTER_NAME \
--workload_name WORKLOAD_NAME \
--workload_namespace WORKLOAD_NAMESPACE \
--source_instance_template NEW_SOURCE_INSTANCE_TEMPLATE

Lakukan update berkelanjutan ke MIG yang ada untuk workload. Untuk informasi selengkapnya tentang cara menggunakan update berkelanjutan MIG, lihat Memulai update berkelanjutan dasar.
```
gcloud compute instance-groups managed rolling-action start-update INSTANCE_GROUP_NAME \
--version=template=NEW_ASM_INSTANCE_TEMPLATE \
--zone=INSTANCE_GROUP_ZONE
```
Uji beban kerja VM untuk memastikannya berfungsi seperti yang diharapkan.

Menerapkan aplikasi sampel

Untuk menunjukkan bahwa konfigurasi mesh baru Anda berfungsi dengan benar, Anda dapat menginstal aplikasi contoh Bookinfo. Contoh ini menjalankan database MySQL di VM dan layanan rating membaca nilai rating dari database.

Menginstal Bookinfo di cluster

Gunakan langkah-langkah berikut untuk men-deploy layanan aplikasi BookInfo dengan proxy file bantuan yang dimasukkan bersama setiap layanan. Aplikasi BookInfo akan di-deploy di namespace default.

Pada command line di komputer tempat Anda menginstal Anthos Service Mesh, buka root direktori penginstalan Anthos Service Mesh yang Anda buat pada langkah Mendownload skrip.

Untuk mengaktifkan injeksi file bantuan otomatis, gunakan perintah berikut untuk menemukan label di istiod, yang berisi nilai label revisi untuk digunakan di langkah selanjutnya.

kubectl -n istio-system get pods -l app=istiod --show-labels

Outputnya terlihat mirip dengan yang berikut ini:

NAME                                READY   STATUS    RESTARTS   AGE   LABELS
istiod-asm-198-6-5788d57586-bljj4   1/1     Running   0          23h   app=istiod,istio.io/rev=asm-198-6,istio=istiod,pod-template-hash=5788d57586
istiod-asm-198-6-5788d57586-vsklm   1/1     Running   1          23h   app=istiod,istio.io/rev=asm-198-6,istio=istiod,pod-template-hash=5788d57586

Pada output, di kolom LABELS, catat nilai label revisi istiod, yang mengikuti awalan istio.io/rev=. Dalam contoh ini, nilainya adalah asm-198-6.

Terapkan label revisi ke namespace default. Dalam perintah berikut, REVISION adalah nilai label revisi istiod yang Anda catat di langkah sebelumnya.
```
kubectl label namespace default istio-injection- istio.io/rev=REVISION --overwrite
```
Anda dapat mengabaikan pesan "istio-injection not found" di output. Artinya, namespace sebelumnya tidak memiliki label istio-injection, yang akan Anda harapkan dalam penginstalan baru Anthos Service Mesh atau deployment baru. Karena injeksi otomatis gagal jika namespace memiliki istio-injection dan label revisi, semua perintah kubectl label dalam dokumentasi Anthos Service Mesh mencakup penghapusan label istio-injection.

Deploy aplikasi Anda ke namespace default menggunakan kubectl:

kubectl apply -f samples/bookinfo/platform/kube/bookinfo.yaml

Pastikan bahwa aplikasi telah di-deploy dengan benar dengan menjalankan perintah berikut:

kubectl get services

Output yang diharapkan:

NAME                       CLUSTER-IP   EXTERNAL-IP   PORT(S)              AGE
details                    10.0.0.31    <none>        9080/TCP             6m
kubernetes                 10.0.0.1     <none>        443/TCP              7d
productpage                10.0.0.120   <none>        9080/TCP             6m
ratings                    10.0.0.15    <none>        9080/TCP             6m
reviews                    10.0.0.170   <none>        9080/TCP             6m

dan

kubectl get pod

Output yang diharapkan:

NAME                                        READY     STATUS    RESTARTS   AGE
details-v1-1520924117-48z17                 2/2       Running   0          6m
productpage-v1-560495357-jk1lz              2/2       Running   0          6m
ratings-v1-734492171-rnr5l                  2/2       Running   0          6m
reviews-v1-874083890-f0qf0                  2/2       Running   0          6m
reviews-v2-1343845940-b34q5                 2/2       Running   0          6m
reviews-v3-1813607990-8ch52                 2/2       Running   0          6m

Terakhir, tentukan perutean gateway masuk untuk aplikasi:

kubectl apply -f samples/bookinfo/networking/bookinfo-gateway.yaml

Output yang diharapkan:

gateway.networking.istio.io/bookinfo-gateway created
virtualservice.networking.istio.io/bookinfo created

Pastikan halaman produk dapat diakses.

export INGRESS_HOST=$(kubectl -n istio-system get service istio-ingressgateway -o jsonpath='{.status.loadBalancer.ingress[0].ip}')
export INGRESS_PORT=$(kubectl -n istio-system get service istio-ingressgateway -o jsonpath='{.spec.ports[?(@.name=="http2")].port}')
export GATEWAY_URL="${INGRESS_HOST}:${INGRESS_PORT}"
curl -s "http://${GATEWAY_URL}/productpage" | grep -o "<title>.*</title>"

Output yang diharapkan:

<title>Simple Bookstore App</title>

Membuat instance Compute Engine dan menginstal MySQL

Pada langkah ini, Anda akan membuat template instance Compute Engine untuk instance MySQL yang berjalan di VM. Untuk langkah-langkah yang lebih mendetail, lihat Bookinfo dengan Mesin Virtual.

Buat template instance Compute Engine yang menyertakan skrip startup untuk menginstal MySQL dan menambahkan database rating saat startup. Perhatikan bahwa jika Anda menggunakan CentOS, perlu waktu hingga 10 menit hingga server mariadb sudah siap.

Debian

cat << "EOF" > init-mysql
#!/bin/bash

# Wait until Envoy is ready before installing mysql
while true; do
  rt=$(curl -s 127.0.0.1:15000/ready)
  if [[ $? -eq 0 ]] && [[ "${rt}" -eq "LIVE" ]]; then
    echo "envoy is ready"
    break
  fi
  sleep 1
done

sudo apt-get update && sudo apt-get install -y mariadb-server

sudo sed -i '/bind-address/c\bind-address  = 0.0.0.0' /etc/mysql/mariadb.conf.d/50-server.cnf

cat <<EOD | sudo mysql
# Grant access to root
GRANT ALL PRIVILEGES ON *.* TO 'root'@'localhost' IDENTIFIED BY 'password' WITH GRANT OPTION;

# Grant root access to other IPs
CREATE USER 'root'@'%' IDENTIFIED BY 'password';
GRANT ALL PRIVILEGES ON *.* TO 'root'@'%' WITH GRANT OPTION;
FLUSH PRIVILEGES;
quit
EOD

sudo systemctl restart mysql

curl -LO https://raw.githubusercontent.com/istio/istio/release-1.9/samples/bookinfo/src/mysql/mysqldb-init.sql

mysql -u root -ppassword < mysqldb-init.sql
EOF

gcloud compute \
--project=PROJECT_ID \
instance-templates create mysql-instance-template \
--machine-type=e2-medium \
--metadata-from-file=startup-script=init-mysql \
--image=debian-10-buster-v20201014 \
--image-project=debian-cloud \
--boot-disk-size=10GB

CentOS

cat << "EOF" > init-mysql
#!/bin/bash

# Wait until Envoy is ready before installing mysql
while true; do
  rt=$(curl -s 127.0.0.1:15000/ready)
  if [[ $? -eq 0 ]] && [[ "${rt}" -eq "LIVE" ]]; then
    echo "envoy is ready"
    break
  fi
  sleep 1
done

sudo yum update -y && sudo yum install -y mariadb-server

# Wait until mysql is ready
while true; do
  rt=$(which mysql)
  if [[ ! -z "${rt}" ]]; then
    echo "mysql is ready"
    break
  fi
  sleep 1
done

sudo sed -i '/bind-address/c\bind-address  = 0.0.0.0' /etc/my.cnf.d/mariadb-server.cnf

sudo systemctl restart mariadb

cat > grantaccess.sql << EOD

GRANT ALL PRIVILEGES ON *.* TO 'root'@'localhost' IDENTIFIED BY 'password' WITH GRANT OPTION;

CREATE USER 'root'@'%' IDENTIFIED BY 'password';
GRANT ALL PRIVILEGES ON *.* TO 'root'@'%' WITH GRANT OPTION;
FLUSH PRIVILEGES;
EOD

until sudo mysql < grantaccess.sql; do
   sleep 1
done

sudo systemctl restart mariadb

curl -LO https://raw.githubusercontent.com/istio/istio/release-1.9/samples/bookinfo/src/mysql/mysqldb-init.sql

mysql -u root -ppassword < mysqldb-init.sql
EOF

gcloud compute \
--project=PROJECT_ID \
instance-templates create mysql-instance-template \
--machine-type=e2-medium \
--metadata-from-file=startup-script=init-mysql \
--image-project=centos-cloud \
--image-family=centos-8 \
--boot-disk-size=30GB

Membuat WorkloadGroup untuk beban kerja MySQL

kubectl apply -f - << EOF
apiVersion: networking.istio.io/v1alpha3
kind: WorkloadGroup
metadata:
 name: mysql
 namespace: default
spec:
 metadata:
   labels:
     app.kubernetes.io/name: mysql
   annotations:
     security.cloud.google.com/IdentityProvider: google
 template:
   serviceAccount: WORKLOAD_SERVICE_ACCOUNT
EOF

Gunakan skrip VM di atas untuk membuat template instance baru guna menyiapkan instance untuk mesh Anda.

./asm_vm create_gce_instance_template \
asm-mysql-instance-template \
--project_id PROJECT_ID \
--cluster_location CLUSTER_LOCATION \
--cluster_name CLUSTER_NAME \
--workload_name mysql \
--source_instance_template mysql-instance-template

Buat MIG Compute Engine menggunakan template instance yang baru dibuat.

gcloud compute instance-groups managed create mysql-instance \
--template asm-mysql-instance-template \
--zone=us-central1-c \
--project=PROJECT_ID \
--size=1

Membuat service

Membuat layanan Kubernetes untuk layanan MySQL.

Buat layanan Kubernetes menggunakan perintah berikut:

kubectl apply -f - << EOF
apiVersion: v1
kind: Service
metadata:
 name: mysql
 namespace: default
 labels:
   asm_resource_type: VM
spec:
 ports:
 - name: mysql
   port: 3306
   protocol: TCP
   targetPort: 3306
 selector:
   app.kubernetes.io/name: mysql
EOF

Menggunakan dasbor Anthos UI

Untuk melihat layanan berbasis VM baru yang telah Anda buat, klik Anthos > Service Mesh dari menu navigasi sebelah kiri. Tindakan ini akan menampilkan tabel layanan yang berjalan di mesh Anda. Layanan yang Anda tambahkan akan muncul dalam tabel, dengan nilai Type sebesar VM dan beberapa metrik tingkat tinggi. Untuk melihat telemetri lainnya dari layanan berbasis VM Anda, klik nama layanan, yang akan menampilkan dasbor tingkat layanan.

Untuk mengetahui informasi selengkapnya tentang cara menggunakan dasbor UI Anthos, lihat Menjelajahi Anthos Service Mesh di Cloud Console.

Mengelola traffic ke workload VM

Anda dapat mengubah aturan jaringan untuk mengontrol aliran traffic masuk dan keluar dari VM.

Mengontrol traffic ke layanan rating baru (Pod ke VM)

Buat layanan rating lain di Bookinfo yang akan menggunakan instance MySQL yang dibuat di atas sebagai sumber data dan menentukan aturan perutean yang memaksa layanan ulasan menggunakan layanan rating baru.

Buat layanan rating baru untuk menggunakan instance MySQL.

kubectl apply -f - << EOF
apiVersion: apps/v1
kind: Deployment
metadata:
 name: ratings-v2-mysql-vm
 labels:
   app: ratings
   version: v2-mysql-vm
spec:
 replicas: 1
 selector:
   matchLabels:
     app: ratings
     version: v2-mysql-vm
 template:
   metadata:
     labels:
       app: ratings
       version: v2-mysql-vm
   spec:
     serviceAccountName: bookinfo-ratings
     containers:
     - name: ratings
       image: docker.io/istio/examples-bookinfo-ratings-v2:1.16.2
       imagePullPolicy: IfNotPresent
       env:
         - name: DB_TYPE
           value: "mysql"
         - name: MYSQL_DB_HOST
           value: mysql.default.svc.cluster.local
         - name: MYSQL_DB_PORT
           value: "3306"
         - name: MYSQL_DB_USER
           value: root
         - name: MYSQL_DB_PASSWORD
           value: password
       ports:
       - containerPort: 9080
EOF

Buat aturan pemilihan rute.

kubectl apply -f - << EOF
apiVersion: networking.istio.io/v1alpha3
kind: VirtualService
metadata:
 name: reviews
spec:
 hosts:
 - reviews
 http:
 - route:
   - destination:
       host: reviews
       subset: v3
---
apiVersion: networking.istio.io/v1alpha3
kind: VirtualService
metadata:
 name: ratings
spec:
 hosts:
 - ratings
 http:
 - route:
   - destination:
       host: ratings
       subset: v2-mysql-vm
EOF

Terapkan aturan tujuan untuk layanan yang dibuat.

kubectl apply -f - << EOF
apiVersion: networking.istio.io/v1alpha3
kind: DestinationRule
metadata:
 name: reviews
spec:
 host: reviews
 subsets:
 - name: v1
   labels:
     version: v1
 - name: v2
   labels:
     version: v2
 - name: v3
   labels:
     version: v3
---
apiVersion: networking.istio.io/v1alpha3
kind: DestinationRule
metadata:
 name: ratings
spec:
 host: ratings
 subsets:
 - name: v1
   labels:
     version: v1
 - name: v2
   labels:
     version: v2
 - name: v2-mysql
   labels:
     version: v2-mysql
 - name: v2-mysql-vm
   labels:
     version: v2-mysql-vm
EOF

Memvalidasi deployment aplikasi

Untuk melihat apakah aplikasi BookInfo berfungsi, Anda perlu mengirim traffic ke gateway masuk.

Jika Anda menginstal Anthos Service Mesh di GKE, dapatkan alamat IP eksternal gateway masuk yang Anda buat di langkah sebelumnya:

kubectl get svc istio-ingressgateway -n istio-system

Output:

NAME                   TYPE           CLUSTER-IP      EXTERNAL-IP   PORT(S)                                      AGE
istio-ingressgateway   LoadBalancer   10.19.247.233   35.239.7.64   80:31380/TCP,443:31390/TCP,31400:31400/TCP   27m

Dalam contoh ini, alamat IP layanan masuk adalah 35.239.7.64.

Mencoba aplikasi

Pastikan aplikasi BookInfo berjalan dengan curl:
```
curl -I http://EXTERNAL_IP/productpage
```
Jika respons menunjukkan 200, berarti aplikasi berfungsi dengan baik dengan Anthos Service Mesh.
Untuk melihat halaman web BookInfo, masukkan alamat berikut di browser Anda:
```
http://EXTERNAL_IP/productpage
```
Pastikan di halaman beranda aplikasi Bookinfo bahwa aplikasi menampilkan lima bintang dari Reviewer1 dan empat bintang dari Reviewer2.

Menerapkan keamanan pada beban kerja VM

Menerapkan keamanan pada beban kerja VM sama dengan menerapkan keamanan pada beban kerja Kubernetes. Untuk mengetahui informasi selengkapnya, lihat Keamanan Istio.

Setelah menyelesaikan langkah-langkah sebelumnya, VM Compute Engine Anda akan memiliki sertifikat beban kerja yang diterbitkan Google. Dalam sertifikat, nilai SubjectAlternativeName menunjukkan Anthos workload identity VM dalam bentuk spiffe://<workload_identity_pool>/ns/WORKLOAD_NAMESPACE/sa/WORKLOAD_SERVICE_ACCOUNT.

Untuk informasi selengkapnya, lihat kumpulan identitas workload.

Mengaktifkan mode ketat mTLS untuk mesh

Terapkan YAML berikut untuk menerapkan seluruh mesh mTLS yang ketat.

kubectl apply -f - << EOF
apiVersion: security.istio.io/v1beta1
kind: PeerAuthentication
metadata:
  name: default
  namespace: istio-system
spec:
  mtls:
    mode: STRICT
EOF

Otorisasi untuk traffic antarlayanan

Gunakan AuthorizationPolicy untuk mengontrol akses antara aplikasi pada VM Compute Engine Anda dan workload mesh lainnya (misalnya, di cluster GKE).

Contoh: Menolak beban kerja Kubernetes untuk mengakses VM Compute Engine

Kebijakan otorisasi berikut menolak beban kerja Kubernetes ratings untuk mengakses beban kerja VM Compute Engine yang melayani server MySQL ratings.

kubectl apply -f - << EOF
apiVersion: security.istio.io/v1beta1
kind: AuthorizationPolicy
metadata:
  name: mysql-deny
  namespace: default
spec:
  selector:
    matchLabels:
      app.kubernetes.io/name: mysql
  action: DENY
  rules:
  - from:
    - source:
        principals: ["cluster.local/ns/default/sa/bookinfo-ratings"]
EOF

Setelah menerapkan contoh AuthorizationPolicy, Anda akan melihat pesan error Ratings service is currently unavailable di bagian ulasan buku pada halaman produk.

Menginstal Agen Cloud Monitoring

Anda dapat menginstal Agen Cloud Monitoring untuk mengumpulkan dan memantau metrik sistem dan aplikasi dari instance VM. Hal ini memungkinkan Anda memantau metrik utama, misalnya penggunaan CPU dan memori pada agen.

Untuk mengetahui informasi selengkapnya, lihat dokumentasi Agen Cloud Monitoring.

Pemecahan masalah

Untuk tips pemecahan masalah, lihat Memecahkan masalah dukungan VM.