Menyiapkan aplikasi untuk Cloud Service Mesh

Cloud Service Mesh adalah alat yang canggih untuk mengelola dan memantau menggunakan berbagai aplikasi obrolan. Untuk mendapatkan hasil maksimal dari Cloud Service Mesh, sebaiknya pahami abstraksi yang mendasarinya, termasuk container dan Kubernetes. Tutorial ini menjelaskan cara menyiapkan aplikasi untuk Cloud Service Mesh dari kode sumber ke container yang berjalan di GKE, sampai saat itu hanya sebelum menginstal Cloud Service Mesh.

Jika sudah memahami Kubernetes dan konsep mesh layanan, Anda dapat lewati tutorial ini dan langsung ke Mesh Layanan Cloud panduan penginstalan kami.

Tujuan

  1. Jelajahi "hello world" multi-layanan sederhana aplikasi.
  2. Menjalankan aplikasi dari sumber
  3. Memasukkan aplikasi ke dalam container.
  4. Membuat cluster Kubernetes.
  5. Men-deploy container ke cluster.

Sebelum memulai

Lakukan langkah-langkah berikut untuk mengaktifkan Cloud Service Mesh API:
  1. Buka halaman Kubernetes Engine di Konsol Google Cloud.
  2. Buat atau pilih project.
  3. Tunggu hingga API dan layanan terkait diaktifkan. Proses ini dapat memerlukan waktu beberapa menit.

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

Tutorial ini menggunakan Cloud Shell, yang menyediakan Virtual machine Compute Engine g1-small (VM) yang menjalankan sistem operasi Linux berbasis Debian.

Menyiapkan Cloud Shell

Keuntungan menggunakan Cloud Shell adalah:

  • Baik lingkungan pengembangan Python 2 maupun Python 3 (termasuk virtualenv) sudah siap.
  • Alat command line gcloud, docker, git, dan kubectl yang digunakan di tutorial sudah diinstal.

  • Anda dapat memilih editor teks:

    • Editor kode, yang Anda akses dengan mengklik di bagian atas di jendela Cloud Shell.

    • Emacs, Vim, atau Nano, yang Anda akses dari baris perintah di yang disebut Cloud Shell.

Di konsol Google Cloud, aktifkan Cloud Shell.

Aktifkan Cloud Shell

Di bagian bawah Google Cloud Console, Cloud Shell sesi akan terbuka dan menampilkan perintah command line. Cloud Shell adalah lingkungan shell dengan Google Cloud CLI yang sudah terinstal, dan dengan nilai yang sudah ditetapkan untuk project Anda saat ini. Diperlukan waktu beberapa detik untuk melakukan inisialisasi sesi.

Mendownload kode contoh

  1. Download kode sumber helloserver:

    git clone https://github.com/GoogleCloudPlatform/anthos-service-mesh-samples

  2. Ubah ke direktori kode contoh:

    cd anthos-service-mesh-samples/docs/helloserver

Menjelajahi aplikasi multi-layanan

Aplikasi contoh ditulis dalam Python, dan memiliki dua komponen yang berkomunikasi menggunakan REST:

  • server: Server sederhana dengan satu endpoint GET, / , yang mencetak "halo dunia" ke konsol.
  • loadgen: Skrip yang mengirim traffic ke server, dengan parameter yang dapat dikonfigurasi jumlah permintaan per detik (RPS).

aplikasi contoh

Menjalankan aplikasi dari sumber

Untuk memahami contoh aplikasi ini, jalankan aplikasi di Cloud Shell.

  1. Dari direktori sample-apps/helloserver, jalankan server:

    python3 server/server.py

    Saat memulai, server akan menampilkan hal berikut:

    INFO:root:Starting server...

  2. Buka jendela terminal lain agar Anda dapat mengirimkan permintaan ke server. Klik untuk membuka sesi lain.

  3. Kirim permintaan ke server:

    curl http://localhost:8080

    server merespons:

    Hello World!

  4. Dari direktori tempat Anda mengunduh kode contoh, ubah ke yang berisi loadgen:

    cd YOUR_WORKING_DIRECTORY/anthos-service-mesh-samples/docs/helloserver/loadgen

  5. Buat variabel lingkungan berikut:

    export SERVER_ADDR=http://localhost:8080
export REQUESTS_PER_SECOND=5

  6. Mulai virtualenv:

    virtualenv --python python3 env

  7. Aktifkan lingkungan virtual:

    source env/bin/activate

  8. Instal persyaratan untuk loadgen:

    pip3 install -r requirements.txt

  9. Jalankan loadgen:

    python3 loadgen.py

    Saat memulai, loadgen akan menampilkan pesan yang mirip dengan berikut ini:

    Starting loadgen: 2019-05-20 10:44:12.448415
5 request(s) complete to http://localhost:8080

    Di jendela terminal lainnya, server menulis pesan ke konsol mirip dengan contoh berikut ini:

    127.0.0.1 - - [21/Jun/2019 14:22:01] "GET / HTTP/1.1" 200 -
INFO:root:GET request,
Path: /
Headers:
Host: localhost:8080
User-Agent: python-requests/2.22.0
Accept-Encoding: gzip, deflate
Accept: */*

    Dari sudut pandang jaringan, seluruh aplikasi sekarang berjalan di {i>host<i} yang sama. Oleh karena itu, Anda dapat menggunakan localhost untuk mengirim permintaan ke server.

  10. Untuk menghentikan loadgen dan server, masukkan Ctrl-c di setiap terminal jendela.

  11. Di jendela terminal loadgen, nonaktifkan lingkungan virtual:

    deactivate

Memasukkan aplikasi ke dalam container

Untuk menjalankan aplikasi di GKE, Anda perlu mengemas sampel aplikasi—server dan loadgen—ke dalam penampung. J container adalah cara mengemas aplikasi sedemikian rupa sehingga terisolasi dari lingkungan yang mendasarinya.

Untuk memasukkan aplikasi ke dalam container, Anda memerlukan Dockerfile. Dockerfile adalah teks file yang mendefinisikan perintah yang diperlukan untuk merakit kode sumber aplikasi dan dependensinya ke dalam Gambar Docker. Setelah Anda membangun Anda menguploadnya ke container registry, seperti Docker Hub atau Container Registry.

Contoh ini dilengkapi dengan Dockerfile untuk server dan loadgen yang berisi semua perintah yang diperlukan untuk membuat image. Berikut adalah Dockerfile untuk server:

FROM python:3.12-slim as base
FROM base as builder
RUN apt-get -qq update \
    && apt-get install -y --no-install-recommends \
        g++ \
    && rm -rf /var/lib/apt/lists/*

# Enable unbuffered logging
FROM base as final
ENV PYTHONUNBUFFERED=1

RUN apt-get -qq update \
    && apt-get install -y --no-install-recommends \
        wget

WORKDIR /helloserver

# Grab packages from builder
COPY --from=builder /usr/local/lib/python3.* /usr/local/lib/

# Add the application
COPY . .

EXPOSE 8080
ENTRYPOINT [ "python", "server.py" ]
  • Perintah FROM python:3-slim as base memberi tahu Docker untuk menggunakan Gambar Python 3 sebagai image dasar.
  • Perintah COPY . . menyalin file sumber di file kerja saat ini (dalam hal ini, cukup server.py) ke dalam file container sistem file.
  • ENTRYPOINT menentukan perintah yang digunakan untuk menjalankan container. Di beberapa dalam hal ini, perintahnya hampir sama dengan yang Anda gunakan untuk menjalankan server.py dari kode sumber.
  • Perintah EXPOSE menentukan bahwa server memproses port 8080. Perintah ini tidak mengekspos port apa pun, tetapi berfungsi sebagai dokumentasi yang diperlukan untuk membuka porta 8080 saat Anda menjalankan container.

Mempersiapkan untuk memasukkan aplikasi ke dalam container

  1. Setel variabel lingkungan berikut. Ganti PROJECT_ID dengan ID project Google Cloud Anda.

    export PROJECT_ID="PROJECT_ID"
     
    export GCR_REPO="asm-ready"

    Anda menggunakan nilai PROJECT_ID dan GCR_REPO untuk memberi tag pada image Docker saat Anda membangun lalu mengirimkannya ke Container Registry pribadi.

  2. Tetapkan project Google Cloud default untuk Google Cloud CLI.

    gcloud config set project $PROJECT_ID

  3. Tetapkan zona default untuk Google Cloud CLI.

    gcloud config set compute/zone us-central1-b

  4. Pastikan layanan Container Registry diaktifkan di project Google Cloud Anda.

    gcloud services enable containerregistry.googleapis.com

Memasukkan server ke dalam container

  1. Ubah ke direktori tempat server contoh berada:

    cd YOUR_WORKING_DIRECTORY/anthos-service-mesh-samples/docs/helloserver/server/

  2. Buat gambar menggunakan Dockerfile dan variabel lingkungan yang Anda didefinisikan sebelumnya:

    docker build -t gcr.io/$PROJECT_ID/$GCR_REPO/helloserver:v0.0.1 .

    Flag -t mewakili tag Docker. Ini adalah nama gambar yang yang Anda gunakan saat men-deploy container.

  3. Kirim image ke Container Registry:

    docker push gcr.io/$PROJECT_ID/$GCR_REPO/helloserver:v0.0.1

Memasukkan loadgen ke dalam container

  1. Ubah ke direktori tempat loadgen contoh berada:

    cd ../loadgen

  2. Buat gambar:

    docker build -t gcr.io/$PROJECT_ID/$GCR_REPO/loadgen:v0.0.1 .

  3. Kirim image ke Container Registry:

    docker push gcr.io/$PROJECT_ID/$GCR_REPO/loadgen:v0.0.1

Menampilkan daftar gambar

Dapatkan daftar image di repositori untuk mengonfirmasi bahwa image dikirim:

gcloud container images list --repository gcr.io/$PROJECT_ID/asm-ready

Perintah ini merespons dengan nama image yang baru saja Anda kirim:

NAME
gcr.io/PROJECT_ID/asm-ready/helloserver
gcr.io/PROJECT_ID/asm-ready/loadgen

Membuat cluster GKE

Anda dapat menjalankan container ini di VM Cloud Shell dengan menggunakan Perintah docker run. Namun dalam produksi, Anda perlu mengorkestrasi container dengan cara yang lebih terpadu. Misalnya, Anda memerlukan sistem yang memastikan bahwa container selalu berjalan, dan Anda memerlukan cara untuk meningkatkan skala dan instance tambahan dari container untuk menangani peningkatan traffic.

Anda dapat menggunakan GKE untuk menjalankan aplikasi dalam container. GKE adalah container platform orkestrasi yang bekerja dengan menghubungkan VM ke dalam cluster. Setiap VM disebut sebagai node. Cluster GKE didukung oleh Sistem pengelolaan cluster open source Kubernetes. Kubernetes menyediakan yang digunakan untuk berinteraksi dengan cluster Anda.

Untuk membuat cluster GKE:

  1. Membuat cluster:

    gcloud container clusters create asm-ready \
  --cluster-version latest \
  --machine-type=n1-standard-4 \
  --num-nodes 4

    Perintah gcloud membuat cluster di Project dan zona Google Cloud yang Anda tetapkan sebelumnya. Untuk menjalankan Cloud Service Mesh, sebaiknya gunakan minimal 4 node dan n1-standard-4 jenis mesin.

    Perintah untuk membuat cluster memerlukan waktu beberapa menit untuk diselesaikan. Jika sudah siap, perintahnya akan menampilkan pesan yang mirip dengan yang berikut ini:

    NAME        LOCATION       MASTER_VERSION  MASTER_IP      MACHINE_TYPE   NODE_VERSION   NUM_NODES  STATUS
asm-ready  us-central1-b  1.13.5-gke.10   203.0.113.1    n1-standard-2  1.13.5-gke.10  4          RUNNING

  2. Berikan kredensial ke kubectl command- sehingga Anda dapat menggunakannya untuk mengelola cluster:

    gcloud container clusters get-credentials asm-ready

  3. Sekarang Anda dapat menggunakan kubectl untuk berkomunikasi dengan Kubernetes. Sebagai contoh, Anda dapat menjalankan perintah berikut untuk mendapatkan status node:

    kubectl get nodes

    Perintah tersebut merespons dengan daftar node, yang mirip dengan berikut ini:

    NAME                                       STATUS   ROLES    AGE    VERSION
gke-asm-ready-default-pool-dbeb23dc-1vg0   Ready    <none>   99s    v1.13.6-gke.13
gke-asm-ready-default-pool-dbeb23dc-36z5   Ready    <none>   100s   v1.13.6-gke.13
gke-asm-ready-default-pool-dbeb23dc-fj7s   Ready    <none>   99s    v1.13.6-gke.13
gke-asm-ready-default-pool-dbeb23dc-wbjw   Ready    <none>   99s    v1.13.6-gke.13

Memahami konsep-konsep utama Kubernetes

Diagram berikut menunjukkan aplikasi yang berjalan di GKE:

aplikasi dalam container

Sebelum men-deploy container ke GKE, Anda mungkin perlu meninjau beberapa konsep utama Kubernetes. Bagian akhir tutorial ini menyediakan link sehingga Anda dapat mempelajari lebih lanjut tentang setiap konsep.

  • Node dan cluster: Di GKE, node adalah VM. Di tempat lain Platform Kubernetes, node dapat berupa mesin fisik atau virtual. Sebuah cluster adalah kumpulan {i>node<i} yang dapat diperlakukan bersama sebagai satu mesin, tempat Anda men-deploy aplikasi dalam container.

  • Pod: Di Kubernetes, container berjalan di dalam Pod. Pod adalah unit atomik di Kubernetes. Sebuah Pod menyimpan satu atau beberapa container. Anda men-deploy server dan loadgen container masing-masing di Pod-nya sendiri. Saat Pod berjalan beberapa penampung (misalnya, server aplikasi dan server proxy), Anda akan container dikelola sebagai entity tunggal dan berbagi resource Pod.

  • Deployment: Deployment adalah objek Kubernetes yang mewakili serangkaian Pod yang identik. Deployment menjalankan beberapa replika dari Pod yang didistribusikan di antara node cluster. Deployment otomatis menggantikan Pod apa pun yang gagal atau menjadi tidak responsif.

  • Layanan Kubernetes: Menjalankan kode aplikasi dalam perubahan GKE jaringan antara loadgen dan server. Saat Anda menjalankan di VM Cloud Shell, Anda dapat mengirim permintaan ke server menggunakan alamat localhost:8080. Setelah Anda men-deploy ke GKE, Pod dijadwalkan untuk dijalankan pada node yang tersedia. Secara {i>default<i}, Anda tidak bisa mengontrol node tempat Pod berjalan, sehingga Pod tidak memiliki alamat IP yang stabil.

    Guna mendapatkan alamat IP untuk server, Anda harus menentukan jaringan abstraksi di atas Pod yang disebut Layanan Kubernetes. Layanan Kubernetes menyediakan endpoint jaringan yang stabil untuk sekumpulan Pod. Ada beberapa jenis Layanan. server menggunakan LoadBalancer, yang mengekspos alamat IP eksternal sehingga Anda dapat menjangkau server dari luar cluster.

    Kubernetes juga memiliki sistem DNS bawaan, yang memberikan nama DNS (untuk misalnya, helloserver.default.cluster.local) ke Layanan. Hal ini memungkinkan Pod di dalam cluster untuk menjangkau Pod lain di cluster dengan alamat yang stabil. Anda tidak dapat menggunakan nama DNS ini di luar cluster, seperti dari yang disebut Cloud Shell.

Manifes Kubernetes

Ketika Anda menjalankan aplikasi dari kode sumber, Anda menggunakan perintah perintah: python3 server.py

Imperatif berarti didorong oleh kata kerja: "melakukan ini".

Sebaliknya, Kubernetes beroperasi pada model deklaratif. Artinya, alih-alih memberi tahu Kubernetes apa yang harus dilakukan, Anda memberikan Kubernetes dengan status yang diinginkan. Misalnya, Kubernetes dimulai dan diakhiri Pod sesuai kebutuhan sehingga status sistem sebenarnya cocok dengan status yang diinginkan.

Anda menentukan status yang diinginkan dalam sekumpulan manifes, atau YAML. File YAML berisi spesifikasi untuk satu atau beberapa objek Kubernetes.

Sampel berisi file YAML untuk server dan loadgen. Setiap YAML menentukan status yang diinginkan untuk objek Deployment Kubernetes dan Layanan.

Server

apiVersion: apps/v1
kind: Deployment
metadata:
  name: helloserver
spec:
  replicas: 1
  selector:
    matchLabels:
      app: helloserver
  template:
    metadata:
      labels:
        app: helloserver
    spec:
      containers:
      - image: gcr.io/google-samples/istio/helloserver:v0.0.1
        imagePullPolicy: Always
        name: main
      restartPolicy: Always
      terminationGracePeriodSeconds: 5
  • kind menunjukkan jenis objek.
  • metadata.name menentukan nama Deployment.
  • Kolom spec pertama berisi deskripsi status yang diinginkan.
  • spec.replicas menentukan jumlah Pod yang diinginkan.
  • Bagian spec.template menentukan template Pod. Disertakan dalam spesifikasi untuk Pod adalah kolom image, yang merupakan nama image yang diambil dari Container Registry.

Layanan ditentukan sebagai berikut:

apiVersion: v1
kind: Service
metadata:
  name: hellosvc
spec:
  ports:
  - name: http
    port: 80
    targetPort: 8080
  selector:
    app: helloserver
  type: LoadBalancer
  • LoadBalancer: Klien mengirim permintaan ke alamat IP beban jaringan , yang memiliki alamat IP stabil dan dapat dijangkau di luar .
  • targetPort: Ingat kembali bahwa perintah EXPOSE 8080 di Dockerfile tidak benar-benar mengekspos porta apa pun. Anda mengekspos port 8080 agar dapat menjangkau container server di luar cluster. Dalam kasus ini, hellosvc.default.cluster.local:80 (nama singkat: hellosvc) dipetakan ke helloserver Port IP Pod 8080.
  • port: Ini adalah nomor port yang digunakan layanan lain di cluster saat mengirim permintaan.

Generator Beban

Objek Deployment di loadgen.yaml mirip dengan server.yaml. Salah satu yang terkenal perbedaannya adalah objek Deployment berisi bagian yang disebut env. Ini menentukan variabel lingkungan yang diperlukan oleh loadgen, yang Anda tetapkan sebelumnya saat Anda menjalankan aplikasi dari sumber.

apiVersion: apps/v1
kind: Deployment
metadata:
  name: loadgenerator
spec:
  replicas: 1
  selector:
    matchLabels:
      app: loadgenerator
  template:
    metadata:
      labels:
        app: loadgenerator
    spec:
      containers:
      - env:
        - name: SERVER_ADDR
          value: http://hellosvc:80/
        - name: REQUESTS_PER_SECOND
          value: '10'
        image: gcr.io/google-samples/istio/loadgen:v0.0.1
        imagePullPolicy: Always
        name: main
        resources:
          limits:
            cpu: 500m
            memory: 512Mi
          requests:
            cpu: 300m
            memory: 256Mi
      restartPolicy: Always
      terminationGracePeriodSeconds: 5

Karena loadgen tidak menerima permintaan masuk, kolom type ditetapkan ke ClusterIP. Jenis ini menyediakan alamat IP stabil yang beroperasi di cluster yang dapat digunakan, tetapi alamat IP tidak diekspos ke klien eksternal.

apiVersion: v1
kind: Service
metadata:
  name: loadgensvc
spec:
  ports:
  - name: http
    port: 80
    targetPort: 8080
  selector:
    app: loadgenerator
  type: ClusterIP

Men-deploy container ke GKE

  1. Ubah ke direktori tempat server contoh berada:

    cd YOUR_WORKING_DIRECTORY/anthos-service-mesh-samples/docs/helloserver/server/

  2. Buka server.yaml di editor teks.

  3. Ganti nama di kolom image dengan nama image Docker Anda.

    image: gcr.io/PROJECT_ID/asm-ready/helloserver:v0.0.1

    Ganti PROJECT_ID dengan ID project Google Cloud Anda.

  4. Simpan dan tutup server.yaml.

  5. Deploy file YAML ke Kubernetes:

    kubectl apply -f server.yaml

    Jika berhasil, perintah akan merespons dengan hal berikut: 

    deployment.apps/helloserver created
service/hellosvc created

  6. Ubah ke direktori tempat loadgen berada.

    cd ../loadgen

  7. Buka loadgen.yaml di editor teks.

  8. Ganti nama di kolom image dengan nama image Docker Anda.

    image: gcr.io/PROJECT_ID/asm-ready/loadgen:v0.0.1

    Ganti PROJECT_ID dengan ID project Google Cloud Anda.

  9. Simpan dan tutup loadgen.yaml, lalu tutup editor teks.

  10. Deploy file YAML ke Kubernetes:

    kubectl apply -f loadgen.yaml

    Jika berhasil, perintah akan merespons dengan hal berikut: 

    deployment.apps/loadgenerator created
service/loadgensvc created

  11. Periksa status Pod:

    kubectl get pods

    Perintah tersebut merespons dengan status yang mirip dengan yang berikut ini:

    NAME                             READY   STATUS    RESTARTS   AGE
helloserver-69b9576d96-mwtcj     1/1     Running   0          58s
loadgenerator-774dbc46fb-gpbrz   1/1     Running   0          57s

  12. Dapatkan log aplikasi dari Pod loadgen. Ganti POD_ID dengan ID dari output sebelumnya.

    kubectl logs loadgenerator-POD_ID

  13. Dapatkan alamat IP eksternal hellosvc:

    kubectl get service

    Respons perintah mirip dengan berikut ini:

    NAME         TYPE           CLUSTER-IP     EXTERNAL-IP     PORT(S)        AGE
hellosvc     LoadBalancer   10.81.15.158   192.0.2.1       80:31127/TCP   33m
kubernetes   ClusterIP      10.81.0.1      <none>          443/TCP        93m
loadgensvc   ClusterIP      10.81.15.155   <none>          80/TCP         4m52s

  14. Kirim permintaan ke hellosvc. Ganti EXTERNAL_IP dengan alamat IP eksternal hellosvc.

    curl http://EXTERNAL_IP

Siap untuk Mesh Layanan Cloud

Sekarang Anda telah memiliki aplikasi yang di-deploy ke GKE. loadgen dapat menggunakan DNS Kubernetes (hellosvc:80) untuk mengirim permintaan ke server, dan Anda dapat mengirim permintaan ke server dengan alamat IP eksternal. Meskipun Kubernetes menyediakan banyak fitur, beberapa informasi terkait layanan ini tidak ada:

  • Bagaimana cara layanan berinteraksi? Apakah hubungan antara layanan IT Anda? Bagaimana traffic mengalir di antara layanan? Anda tahu loadgen mengirim permintaan ke server, tetapi bayangkan Anda tidak terbiasa dengan aplikasi. Anda tidak dapat menjawab pertanyaan ini dengan melihat daftar Pod yang berjalan di GKE.
  • Metrik: Berapa lama waktu yang diperlukan server untuk merespons permintaan masuk? Berapa banyak permintaan per detik (RPS) yang masuk ke server? Apakah ada respons error?
  • Informasi keamanan: Apakah traffic antara loadgen dan server biasa HTTP atau mTLS?

Cloud Service Mesh dapat memberikan jawaban atas pertanyaan ini. Cloud Service Mesh adalah versi project Istio open source yang dikelola Google Cloud. Cloud Service Mesh bekerja dengan menempatkan Proxy file bantuan Envoy di setiap Pod. Proxy Envoy mencegat semua traffic masuk dan keluar ke container aplikasi. Ini berarti bahwa server dan loadgen masing-masing mendapatkan proxy file bantuan Envoy, dan semua traffic dari loadgen ke server dimediasi oleh proxy Envoy. Koneksi antara proxy Envoy ini membentuk mesh layanan. Layanan ini arsitektur mesh menyediakan lapisan kontrol di atas Kubernetes.

mesh layanan

Karena proxy Envoy berjalan di kontainernya sendiri, Anda dapat menginstal Cloud Service Mesh di teratas cluster GKE tanpa perubahan substansial pada pada kode aplikasi Anda. Namun, ada beberapa cara utama di mana Anda mempersiapkan aplikasi yang akan diinstrumentasikan dengan Cloud Service Mesh:

  • Layanan untuk semua container: Deployment server dan loadgen memiliki layanan Kubernetes terkait. Bahkan loadgen, yang tidak menerima permintaan masuk, memiliki layanan.
  • Porta dalam layanan harus diberi nama: Meskipun GKE memungkinkan Anda untuk untuk menentukan port layanan tanpa nama, Cloud Service Mesh mengharuskan Anda nama untuk port yang sesuai dengan protokol porta. Dalam file YAML, port untuk server diberi nama http karena server menggunakan protokol komunikasi HTTP. Jika service menggunakan gRPC, Anda akan memberi nama port grpc.
  • Deployment diberi label: Opsi ini memungkinkan Anda menggunakan pengelolaan traffic Cloud Service Mesh seperti membagi traffic antarversi layanan yang sama.

Menginstal Cloud Service Mesh

Kunjungi panduan penginstalan Cloud Service Mesh dan ikuti petunjuk penginstalan Cloud Service Mesh di cluster Anda.

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.

Untuk membersihkan, hapus cluster GKE. Menghapus cluster akan menghapus semua resource yang membentuk cluster container, seperti instance compute, dan resource jaringan.

gcloud container clusters delete asm-ready

Langkah selanjutnya