Jalur Pembelajaran: Aplikasi skalabel - Membuat cluster


Rangkaian tutorial ini ditujukan untuk Operator dan administrator IT yang ingin men-deploy, menjalankan, dan mengelola lingkungan aplikasi modern yang berjalan di Google Kubernetes Engine (GKE). Seiring Anda menyelesaikan rangkaian tutorial ini, Anda akan mempelajari cara mengonfigurasi pemantauan dan pemberitahuan, menskalakan beban kerja, dan menyimulasikan kegagalan, semuanya menggunakan aplikasi contoh microservice Cymbal Bank:

  1. Membuat cluster dan men-deploy aplikasi contoh (tutorial ini)
  2. Memantau dengan Google Cloud Managed Service for Prometheus
  3. Menskalakan beban kerja
  4. Menyimulasikan kegagalan

Ringkasan dan tujuan

Cymbal Bank menggunakan Python dan Java untuk menjalankan berbagai layanan, dan menyertakan backend PostgreSQL. Anda tidak memerlukan pengalaman dengan bahasa atau platform database ini untuk menyelesaikan rangkaian tutorial, karena Cymbal Bank hanyalah contoh aplikasi untuk menunjukkan bagaimana GKE dapat mendukung kebutuhan bisnis Anda.

Dalam tutorial ini, Anda akan mempelajari cara membuat satu cluster GKE dan men-deploy contoh aplikasi berbasis microservice bernama Cymbal Bank ke cluster GKE. Anda akan mempelajari cara menyelesaikan tugas-tugas berikut:

  • Buat cluster GKE yang menggunakan Autopilot.

  • Men-deploy contoh aplikasi berbasis microservice bernama Cymbal Bank.

  • Gunakan konsol Google Cloud untuk menjelajahi resource GKE yang digunakan oleh aplikasi contoh Cymbal Bank.

Biaya

Mengaktifkan GKE dan men-deploy aplikasi contoh Cymbal Bank untuk rangkaian tutorial ini berarti Anda akan dikenai biaya per cluster untuk GKE di Google Cloud seperti yang tercantum di halaman Harga kami hingga Anda menonaktifkan GKE atau menghapus project.

Anda juga bertanggung jawab atas biaya Google Cloud lainnya yang timbul saat menjalankan aplikasi contoh Cymbal Bank, seperti tagihan untuk VM Compute Engine dan load balancer.

Sebelum memulai

Dalam tutorial pertama dari seri ini, selesaikan semua langkah penyiapan "Mulai Anda mulai" berikut sebelum memulai. Anda hanya perlu menyelesaikan langkah-langkah "Sebelum memulai" berikut satu kali.

Mengonfigurasi shell dan alat

Dalam rangkaian tutorial ini, Anda akan menggunakan alat berikut untuk men-deploy dan mengelola lingkungan:

  • gcloud CLI: membuat dan mengelola cluster dan fleet GKE, bersama dengan layanan Google Cloud lainnya.
  • kubectl: mengelola Kubernetes, sistem orkestrasi cluster yang digunakan oleh GKE.

Untuk menjalankan perintah di halaman ini, siapkan Google Cloud CLI dan kubectl di salah satu lingkungan pengembangan berikut:

Cloud Shell

Untuk menggunakan terminal online dengan gcloud CLI dan kubectl yang sudah disiapkan, aktifkan Cloud Shell:

Di bagian bawah halaman ini, sesi Cloud Shell akan dimulai dan menampilkan perintah command line. Perlu waktu beberapa detik hingga sesi dimulai.

Shell lokal

Untuk menggunakan lingkungan pengembangan lokal, ikuti langkah-langkah berikut:

Menyiapkan project

Lakukan langkah-langkah berikut untuk menyiapkan project Google Cloud, termasuk mengaktifkan layanan penagihan dan GKE. Ini adalah project tempat Anda akan mengaktifkan GKE.

Anda mungkin memerlukan administrator Google Cloud di organisasi untuk memberi Anda akses untuk membuat atau menggunakan project dan mengaktifkan API.

  1. Di konsol Google Cloud, buka halaman Google Kubernetes Engine:

    Buka halaman Google Kubernetes Engine

  2. Buat atau pilih project. Ini adalah project tempat Anda mengaktifkan GKE.

  3. Jika diminta, Aktifkan GKE API.

  4. Tunggu hingga API dan layanan terkait diaktifkan. Proses ini memerlukan waktu beberapa menit.

  5. Make sure that billing is enabled for your Google Cloud project.

Memberikan peran IAM

Jika Anda adalah pemilik project (misalnya, jika Anda membuat project sendiri), Anda sudah memiliki semua izin yang diperlukan untuk menyelesaikan tutorial ini. Jika Anda bukan pemilik, pastikan akun Google Cloud Anda memiliki peran IAM yang diperlukan untuk project yang dipilih untuk rangkaian tutorial ini. Sekali lagi, Anda mungkin memerlukan administrator Google Cloud di organisasi untuk membantu memberikan peran yang diperlukan.

Dalam perintah berikut, ganti PROJECT_ID dengan ID project yang dibuat atau dipilih secara otomatis yang Anda buat atau pilih di bagian sebelumnya. Project ID sering kali berbeda dengan nama project. Misalnya, project Anda mungkin scalable-apps, tetapi project ID Anda mungkin scalable-apps-567123.

Grant roles to your user account. Run the following command once for each of the following IAM roles: roles/resourcemanager.projectIamAdmin, roles/iam.serviceAccountAdmin, roles/iam.serviceAccountUser, roles/iam.securityAdmin, roles/serviceusage.serviceUsageAdmin, roles/container.admin, roles/logging.logWriter, roles/gkehub.admin, roles/viewer, roles/monitoring.viewer

gcloud projects add-iam-policy-binding PROJECT_ID --member="user:USER_IDENTIFIER" --role=ROLE
  • Replace PROJECT_ID with your project ID.
  • Replace USER_IDENTIFIER with the identifier for your user account. For example, user:myemail@example.com.

  • Replace ROLE with each individual role.

Membuat clone aplikasi contoh

Clone repositori Git yang menyertakan semua manifes contoh untuk Cymbal Bank:

  git clone https://github.com/GoogleCloudPlatform/bank-of-anthos
  cd bank-of-anthos/

Membuat cluster

Setelah semua langkah prasyarat di bagian sebelumnya selesai, Anda kini dapat mulai membuat cluster GKE dan men-deploy aplikasi contoh.

GKE adalah layanan Kubernetes terkelola yang dapat Anda gunakan untuk men-deploy dan mengoperasikan aplikasi dalam container. Lingkungan GKE terdiri dari node, yang merupakan virtual machine (VM) Compute Engine, yang dikelompokkan bersama untuk membentuk cluster.

  • Buat cluster GKE yang akan Anda gunakan di tutorial lainnya dalam seri ini:

    gcloud container clusters create-auto scalable-apps \
      --project=PROJECT_ID \
      --region=REGION
    

    Ganti kode berikut:

    • PROJECT_ID dengan ID project yang dibuat secara otomatis yang Anda buat di bagian sebelumnya. ID project sering kali berbeda dengan nama project. Misalnya, project Anda mungkin scalable-apps, tetapi project ID Anda mungkin scalable-apps-567123.
    • REGION dengan region tempat Anda ingin membuat cluster, seperti us-central1.

    Perlu waktu beberapa menit untuk membuat cluster dan memverifikasi bahwa semuanya berfungsi dengan benar.

Dalam rangkaian tutorial ini, Anda akan menggunakan cluster mode Autopilot dan beberapa rentang alamat IP default saat membuat cluster. Deployment produksi aplikasi Anda sendiri memerlukan perencanaan alamat IP yang lebih cermat. Dalam mode Autopilot, Google mengelola konfigurasi cluster Anda, termasuk penskalaan otomatis, keamanan, dan setelan lainnya yang telah dikonfigurasi sebelumnya. Cluster dalam mode Autopilot dioptimalkan untuk menjalankan sebagian besar workload produksi dan menyediakan resource komputasi berdasarkan manifes Kubernetes Anda.

Men-deploy Cymbal Bank

Anda mengemas aplikasi (juga disebut workload) ke dalam container. Anda men-deploy kumpulan container sebagai Pod ke node Anda.

Dalam rangkaian tutorial ini, Anda akan men-deploy contoh aplikasi berbasis microservice bernama Cymbal Bank ke satu atau beberapa cluster GKE. Cymbal Bank menggunakan Python dan Java untuk menjalankan berbagai layanan, dan menyertakan backend PostgreSQL. Anda tidak memerlukan pengalaman dengan bahasa atau platform database ini untuk menyelesaikan rangkaian tutorial. Cymbal Bank hanyalah contoh aplikasi untuk menunjukkan bagaimana GKE dapat mendukung kebutuhan bisnis Anda.

Saat Anda menggunakan Cymbal Bank sebagai bagian dari rangkaian tutorial ini, layanan berikut akan di-deploy ke cluster GKE Anda:

Layanan Bahasa Deskripsi
frontend Python Mengekspos server HTTP untuk menayangkan situs. Berisi halaman login, halaman pendaftaran, dan halaman beranda.
ledger-writer Java Menerima dan memvalidasi transaksi yang masuk sebelum menuliskannya ke buku besar.
balance-reader Java Menyediakan cache saldo pengguna yang dapat dibaca dan efisien, seperti yang terbaca dari ledger-db.
transaction-history Java Menyediakan cache yang dapat dibaca dan efisien tentang transaksi terdahulu, seperti yang terbaca dari ledger-db.
ledger-db PostgreSQL Buku besar semua transaksi. Opsi untuk mengisi otomatis dengan transaksi untuk pengguna demo.
user-service Python Mengelola akun pengguna dan autentikasi. Menandatangani JWT yang digunakan untuk autentikasi oleh layanan lain.
contacts Python Menyimpan daftar akun lain yang terkait dengan pengguna. Digunakan untuk drop-down di formulir "Send Payment" dan "Deposit".
accounts-db PostgreSQL Database untuk akun pengguna dan data terkait. Opsi untuk mengisi otomatis dengan pengguna demo.
loadgenerator Python / Locust Terus mengirim permintaan yang meniru pengguna ke frontend. Secara berkala membuat akun baru dan menyimulasikan transaksi di antara akun tersebut.

Untuk men-deploy Cymbal Bank ke cluster GKE, selesaikan langkah-langkah berikut:

  1. Cymbal Bank menggunakan Token Web JSON (JWT) untuk menangani autentikasi pengguna. JWT menggunakan pasangan kunci asimetris untuk menandatangani dan memverifikasi token. Di Cymbal Bank, userservice membuat dan menandatangani token dengan kunci pribadi RSA saat pengguna login, dan layanan lainnya menggunakan kunci publik yang sesuai untuk memvalidasi pengguna.

    Buat JWT RS256 dengan kekuatan 4.096 bit:

    openssl genrsa -out jwtRS256.key 4096
    openssl rsa -in jwtRS256.key -outform PEM -pubout -out jwtRS256.key.pub
    

    Jika diperlukan, download dan instal alat OpenSSL untuk platform Anda.

  2. Secret Kubernetes dapat menyimpan data sensitif seperti kunci atau sandi. Workload yang berjalan di cluster Anda kemudian dapat mengakses Secret untuk mendapatkan data sensitif, bukan melakukan hard code di aplikasi.

    Buat Secret Kubernetes dari file kunci yang Anda buat di langkah sebelumnya agar Cymbal Bank dapat menggunakannya dengan permintaan autentikasi:

    kubectl create secret generic jwt-key --from-file=./jwtRS256.key --from-file=./jwtRS256.key.pub
    
  3. Deploy Cymbal Bank ke cluster Anda. Perintah berikut men-deploy semua file manifes di direktori kubernetes-manifests. Setiap file manifes men-deploy dan mengonfigurasi salah satu Layanan:

    kubectl apply -f kubernetes-manifests/accounts-db.yaml
    kubectl apply -f kubernetes-manifests/balance-reader.yaml
    kubectl apply -f kubernetes-manifests/config.yaml
    kubectl apply -f kubernetes-manifests/contacts.yaml
    kubectl apply -f extras/postgres-hpa/kubernetes-manifests/frontend.yaml
    kubectl apply -f kubernetes-manifests/ledger-db.yaml
    kubectl apply -f kubernetes-manifests/ledger-writer.yaml
    kubectl apply -f extras/postgres-hpa/loadgenerator.yaml
    kubectl apply -f kubernetes-manifests/transaction-history.yaml
    kubectl apply -f kubernetes-manifests/userservice.yaml
    

    Anda mungkin melihat pesan di output kubectl saat manifes diterapkan ke cluster Anda tentang batas Autopilot. Autopilot menggunakan permintaan resource yang Anda tentukan dalam konfigurasi workload untuk mengonfigurasi node yang menjalankan workload Anda. Autopilot menerapkan permintaan resource minimum dan maksimum berdasarkan class komputasi atau konfigurasi hardware yang digunakan workload Anda. Jika Anda tidak menentukan permintaan untuk beberapa container, Autopilot akan menetapkan nilai default agar container tersebut berjalan dengan benar.

    Tinjau contoh manifes berikut untuk Layanan frontend:

    # Copyright 2024 Google LLC
    #
    # Licensed under the Apache License, Version 2.0 (the "License");
    # you may not use this file except in compliance with the License.
    # You may obtain a copy of the License at
    #
    #     https://www.apache.org/licenses/LICENSE-2.0
    #
    # Unless required by applicable law or agreed to in writing, software
    # distributed under the License is distributed on an "AS IS" BASIS,
    # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    # See the License for the specific language governing permissions and
    # limitations under the License.
    
    apiVersion: v1
    kind: Service
    metadata:
      labels:
        application: bank-of-anthos
        environment: development
        team: frontend
        tier: web
      name: frontend
    spec:
      ports:
        - name: http
          port: 80
          targetPort: 8080
      selector:
        app: frontend
        application: bank-of-anthos
        environment: development
        team: frontend
        tier: web
      type: LoadBalancer
    ---
    apiVersion: apps/v1
    kind: Deployment
    metadata:
      labels:
        application: bank-of-anthos
        environment: development
        team: frontend
        tier: web
      name: frontend
    spec:
      selector:
        matchLabels:
          app: frontend
          application: bank-of-anthos
          environment: development
          team: frontend
          tier: web
      template:
        metadata:
          annotations:
            proxy.istio.io/config: '{ "holdApplicationUntilProxyStarts": true }'
          labels:
            app: frontend
            application: bank-of-anthos
            environment: development
            team: frontend
            tier: web
        spec:
          containers:
            - env:
                - name: VERSION
                  value: v0.6.6
                - name: PORT
                  value: "8080"
                - name: ENABLE_TRACING
                  value: "true"
                - name: SCHEME
                  value: http
                - name: LOG_LEVEL
                  value: info
                - name: DEFAULT_USERNAME
                  valueFrom:
                    configMapKeyRef:
                      key: DEMO_LOGIN_USERNAME
                      name: demo-data-config
                - name: DEFAULT_PASSWORD
                  valueFrom:
                    configMapKeyRef:
                      key: DEMO_LOGIN_PASSWORD
                      name: demo-data-config
                - name: REGISTERED_OAUTH_CLIENT_ID
                  valueFrom:
                    configMapKeyRef:
                      key: DEMO_OAUTH_CLIENT_ID
                      name: oauth-config
                      optional: true
                - name: ALLOWED_OAUTH_REDIRECT_URI
                  valueFrom:
                    configMapKeyRef:
                      key: DEMO_OAUTH_REDIRECT_URI
                      name: oauth-config
                      optional: true
              envFrom:
                - configMapRef:
                    name: environment-config
                - configMapRef:
                    name: service-api-config
              image: us-central1-docker.pkg.dev/bank-of-anthos-ci/bank-of-anthos/frontend:v0.6.6@sha256:ebf8b320680cd948900a3036733b34ad804e98cf7efe57b7a4c5eac0837fe9e9
              livenessProbe:
                httpGet:
                  path: /ready
                  port: 8080
                initialDelaySeconds: 60
                periodSeconds: 15
                timeoutSeconds: 30
              name: front
              readinessProbe:
                httpGet:
                  path: /ready
                  port: 8080
                initialDelaySeconds: 10
                periodSeconds: 5
                timeoutSeconds: 10
              resources:
                limits:
                  cpu: 250m
                  memory: 128Mi
                requests:
                  cpu: 100m
                  memory: 64Mi
              securityContext:
                allowPrivilegeEscalation: false
                capabilities:
                  drop:
                    - all
                privileged: false
                readOnlyRootFilesystem: true
              volumeMounts:
                - mountPath: /tmp
                  name: tmp
                - mountPath: /tmp/.ssh
                  name: publickey
                  readOnly: true
          securityContext:
            fsGroup: 1000
            runAsGroup: 1000
            runAsNonRoot: true
            runAsUser: 1000
          serviceAccountName: bank-of-anthos
          terminationGracePeriodSeconds: 5
          volumes:
            - emptyDir: {}
              name: tmp
            - name: publickey
              secret:
                items:
                  - key: jwtRS256.key.pub
                    path: publickey
                secretName: jwt-key

    Manifes ini untuk Service frontend meminta 100m CPU dan 64Mi, dan menetapkan batas 250m CPU dan 128Mi per Pod.

    Saat Anda men-deploy workload di cluster Autopilot, GKE memvalidasi konfigurasi workload berdasarkan nilai minimum dan maksimum yang diizinkan untuk konfigurasi hardware atau class komputasi yang dipilih (seperti GPU). Jika permintaan Anda kurang dari jumlah minimum, Autopilot akan otomatis mengubah konfigurasi workload Anda untuk membawa permintaan Anda dalam rentang yang diizinkan. Pesan ini menunjukkan bahwa batas yang sesuai sedang otomatis ditetapkan.

  4. Tunggu hingga Pod siap. Gunakan kubectl untuk memeriksa status Pod:

    kubectl get pods
    

    Kolom STATUS berubah dari Pending menjadi ContainerCreating. Perlu waktu beberapa menit agar semua Pod berada dalam status Running, seperti yang ditunjukkan dalam contoh output berikut:

    NAME                                  READY   STATUS    RESTARTS   AGE
    accounts-db-6f589464bc-6r7b7          1/1     Running   0          99s
    balancereader-797bf6d7c5-8xvp6        1/1     Running   0          99s
    contacts-769c4fb556-25pg2             1/1     Running   0          98s
    frontend-7c96b54f6b-zkdbz             1/1     Running   0          98s
    ledger-db-5b78474d4f-p6xcb            1/1     Running   0          98s
    ledgerwriter-84bf44b95d-65mqf         1/1     Running   0          97s
    loadgenerator-559667b6ff-4zsvb        1/1     Running   0          97s
    transactionhistory-5569754896-z94cn   1/1     Running   0          97s
    userservice-78dc876bff-pdhtl          1/1     Running   0          96s
    

    Jika semua Pod dalam status Running, lanjutkan ke langkah berikutnya. Sekali lagi, perlu waktu beberapa menit hingga semua Pod berada dalam status Running. Beberapa Pod melaporkan status READY 0/1 adalah hal yang wajar hingga Cymbal Bank siap menyalurkan traffic dengan benar.

  5. Layanan frontend mengekspos server HTTP untuk menayangkan situs Cymbal Bank, termasuk halaman login, halaman pendaftaran, dan halaman beranda. Objek Ingress menentukan aturan untuk pemilihan rute traffic HTTP(S) ke aplikasi yang berjalan di cluster menggunakan Load Balancer HTTP(S) Google Cloud.

    Dapatkan alamat IP eksternal untuk Ingress frontend:

    kubectl get ingress frontend | awk '{print $4}'
    
  6. Di jendela browser web, buka alamat IP yang ditampilkan dalam output perintah kubectl get ingress untuk mengakses instance Cymbal Bank Anda.

    Kredensial default diisi secara otomatis, sehingga Anda dapat login ke aplikasi dan menjelajahi beberapa contoh transaksi dan saldo. Tidak ada tindakan khusus yang perlu Anda lakukan, selain untuk mengonfirmasi bahwa Cymbal Bank berhasil berjalan. Mungkin perlu waktu satu atau dua menit agar semua layanan berkomunikasi dengan benar dan mengizinkan Anda login.

Mempelajari deployment Anda

Setelah membuat cluster GKE dan men-deploy workload, Anda mungkin perlu mengubah setelan atau meninjau performa aplikasi. Di bagian ini, Anda akan mempelajari cara menggunakan konsol Google Cloud untuk meninjau resource yang merupakan bagian dari cluster dan aplikasi contoh Cymbal Bank.

Cluster

Dalam tutorial ini, Anda telah membuat satu cluster GKE dan men-deploy workload Cymbal Bank.

  1. Di halaman Google Kubernetes Engine di Konsol Google Cloud, buka halaman Clusters.

    Buka halaman Cluster

  2. Klik cluster scalable-apps yang baru di-deploy. Di halaman detail cluster yang terbuka, Anda dapat melihat detail cluster dasar beserta konfigurasi jaringan dan keamanan cluster. Anda juga dapat melihat fitur GKE yang diaktifkan di cluster ini di bagian Fitur.

Kemampuan observasi

Anda dapat melihat metrik dasar untuk kondisi dan performa cluster. Dalam tutorial berikutnya dalam seri ini, Anda akan mengaktifkan Google Cloud Managed Service for Prometheus untuk pemantauan dan visibilitas yang lebih terperinci.

  1. Pilih cluster Anda dari halaman Cluster Google Kubernetes Engine di Konsol Google Cloud, lalu buka tab Observability.

  2. Periksa beberapa grafik metrik untuk hal-hal seperti CPU dan Memori. Tampilan ini memungkinkan Anda memantau performa berbagai bagian beban kerja cluster tanpa perlu men-deploy kemampuan pemantauan tambahan.

  3. Untuk melihat log yang di-streaming dari cluster, pilih tab Logs. Anda dapat memfilter menurut Keparahan log, atau membuat filter Anda sendiri untuk melihat namespace, Layanan, atau Pod tertentu. Seperti peringatan dan peristiwa Pod, tampilan log yang dikumpulkan dari cluster Anda ini dapat membantu men-debug masalah dengan cepat menggunakan konsol Google Cloud.

    Wajar jika Anda melihat entri log saat Cymbal Bank pertama kali di-deploy saat beberapa layanan belum dapat berkomunikasi.

  4. Pilih tab Error Aplikasi. Saat beban kerja berjalan, Anda dapat melihat peringatan dan peristiwa yang dikumpulkan di konsol Google Cloud. Pendekatan ini dapat membantu men-debug masalah tanpa harus terhubung ke cluster, Node, atau Pod secara terpisah.

    Sekali lagi, wajar jika Anda melihat peristiwa dicatat saat Cymbal Bank pertama kali di-deploy saat beberapa Layanan belum dapat berkomunikasi.

Beban kerja

Halaman GKE di konsol Google Cloud memiliki bagian Workloads yang menampilkan tampilan gabungan workload yang berjalan di semua cluster GKE Anda.

  1. Di halaman Google Kubernetes Engine di konsol Google Cloud, buka halaman Workloads.

    Buka halaman Workload

    Tab Ringkasan menampilkan daftar beban kerja dan namespace dari cluster GKE. Anda dapat memfilter menurut namespace untuk melihat beban kerja yang berjalan di setiap namespace.

Layanan & Ingress

Tampilan Services & Ingress menampilkan resource Service dan Ingress project. Layanan mengekspos sekumpulan Pod sebagai layanan jaringan dengan endpoint, sedangkan Ingress mengelola akses eksternal ke layanan dalam cluster.

  1. Di halaman Google Kubernetes Engine di konsol Google Cloud, buka halaman Gateways, Services & Ingress.

    Buka halaman Gateway, Services & Ingress

  2. Untuk menemukan ingress Cymbal Bank, klik tab Ingress dan temukan ingress dengan nama frontend. Ingress mengelola traffic masuk untuk aplikasi Anda. Anda dapat melihat informasi tentang load balancer, port, dan endpoint eksternal.

  3. Klik IP address untuk ingress frontend, seperti 198.51.100.143:80. Alamat ini akan membuka antarmuka web Cymbal Bank.

Pembersihan

Rangkaian tutorial untuk Cymbal Bank dirancang untuk diselesaikan satu per satu. Seiring Anda menyelesaikan serangkaian tutorial, Anda akan mempelajari keterampilan baru dan menggunakan produk dan layanan Google Cloud tambahan.

Jika Anda ingin beristirahat sebelum melanjutkan ke tutorial berikutnya dan menghindari biaya pada akun Google Cloud Anda untuk resource yang digunakan dalam tutorial ini, hapus project yang Anda buat.

  1. In the Google Cloud console, go to the Manage resources page.

    Go to Manage resources

  2. In the project list, select the project that you want to delete, and then click Delete.
  3. In the dialog, type the project ID, and then click Shut down to delete the project.

Langkah selanjutnya

Pelajari cara memantau beban kerja Anda di GKE menggunakan Google Cloud Managed Service for Prometheus dan Cloud Monitoring dalam tutorial berikutnya.