Halaman ini diterjemahkan oleh Cloud Translation API.

Jalur Pembelajaran: Aplikasi yang skalabel - Membuat cluster

Kumpulan tutorial ini ditujukan untuk admin dan Operator IT yang ingin men-deploy, menjalankan, dan mengelola lingkungan aplikasi modern yang berjalan di edisi Google Kubernetes Engine (GKE) Enterprise. Selama mempelajari serangkaian tutorial ini, Anda akan mempelajari cara mengonfigurasi pemantauan dan pemberitahuan, menskalakan workload, dan menyimulasikan kegagalan, semuanya menggunakan aplikasi microservice contoh Cymbal Bank:

Membuat cluster dan men-deploy aplikasi contoh (tutorial ini)
Memantau dengan Google Cloud Managed Service for Prometheus
Menskalakan workload
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 Enterprise dapat mendukung kebutuhan bisnis Anda.

Dalam tutorial ini, Anda akan mempelajari cara membuat cluster GKE tunggal 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.
Deploy contoh aplikasi berbasis microservice bernama Cymbal Bank.
Gunakan konsol Google Cloud untuk mempelajari resource GKE yang digunakan oleh aplikasi contoh Cymbal Bank.

Biaya

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

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

Sebelum memulai

Tutorial pertama dalam seri ini sebagian besar menggunakan fungsi inti yang tersedia untuk semua pengguna GKE, tetapi seiring dengan kemajuan dalam tutorial, Anda menggunakan lebih banyak fitur tambahan yang hanya tersedia hanya melalui tingkat perusahaan.

Dalam tutorial pertama dalam seri ini, selesaikan semua langkah penyiapan "Mulai Anda" berikut sebelum memulai. Anda hanya perlu menyelesaikan langkah-langkah "Sebelum memulai" berikut sekali.

Mengonfigurasi shell dan alat

Dalam serangkaian 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 Enterprise.

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 dimulai dan menampilkan perintah command line. Perlu waktu beberapa detik hingga sesi diinisialisasi.

Shell lokal

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

Menginstal gcloud CLI.
Melakukan inisialisasi gcloud CLI.
Instal gcloud CLI untuk kubectl:
```
gcloud components install kubectl
```

Menyiapkan project

Lakukan langkah-langkah berikut untuk menyiapkan project Google Cloud, termasuk mengaktifkan penagihan dan layanan GKE. Dalam project ini, Anda akan mengaktifkan GKE Enterprise.

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

Di konsol Google Cloud, buka halaman Google Kubernetes Engine:

Buka halaman Google Kubernetes Engine
Buat atau pilih project. Di project inilah Anda mengaktifkan GKE Enterprise.
Jika diminta, Enable GKE Enterprise API.
Tunggu hingga API dan layanan terkait diaktifkan. Proses ini dapat memerlukan waktu beberapa menit.
Pastikan penagihan telah diaktifkan untuk project Google Cloud Anda.

Setelah GKE diaktifkan, aktifkan edisi Google Kubernetes Engine (GKE) Enterprise:

Di konsol Google Cloud, buka halaman GKE Enterprise:

Buka halaman GKE Enterprise
Pilih Learn about Google Kubernetes Engine (GKE) Enterprise edition.
Jika memenuhi syarat, Anda dapat melihat opsi untuk Mulai uji coba gratis 90 hari.
Pilih Enable GKE Enterprise, lalu Confirm.

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 ke project yang Anda pilih untuk serangkaian 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 secara otomatis yang Anda buat atau pilih di bagian sebelumnya. Project ID sering kali berbeda dari nama project. Misalnya, project Anda mungkin berupa scalable-apps, tetapi project ID Anda mungkin berupa scalable-apps-567123.

Berikan peran ke Akun Google Anda. Jalankan perintah berikut satu kali untuk setiap peran IAM berikut: 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:EMAIL_ADDRESS" --role=ROLE

Ganti PROJECT_ID dengan project ID Anda.
Ganti EMAIL_ADDRESS dengan alamat email Anda.
Ganti ROLE dengan setiap peran individual.

Meng-clone aplikasi sampel

Buat clone repositori Git yang menyertakan semua manifes sampel untuk Cymbal Bank:

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

Membuat cluster

Setelah menyelesaikan semua langkah prasyarat di bagian sebelumnya, Anda kini dapat mulai membuat cluster Google Kubernetes Engine 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.

Cluster GKE juga dapat dikelompokkan dalam fleet: grup logis cluster yang dapat dikelola bersama. Banyak fitur GKE Enterprise, termasuk yang akan Anda gunakan nanti dalam seri tutorial ini, didasarkan pada fleet dan prinsip kesamaan dan kepercayaan yang diasumsikan oleh fleet.

Buat cluster GKE yang akan Anda gunakan dalam tutorial lainnya dalam seri ini:
```
gcloud container clusters create-auto scalable-apps \
  --project=PROJECT_ID \
  --region=REGION \
  --enable-fleet
```
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 berupa scalable-apps, tetapi project ID Anda mungkin berupa scalable-apps-567123.
- REGION dengan region tempat Anda ingin membuat cluster, seperti us-central1.
Perlu waktu beberapa menit untuk membuat cluster dan memastikan semuanya berfungsi dengan benar.

Dalam serangkaian 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 hati-hati. Dalam mode Autopilot, Google akan mengelola konfigurasi cluster Anda, termasuk penskalaan otomatis, keamanan, dan setelan lainnya yang telah dikonfigurasi sebelumnya. Cluster dalam mode Autopilot dioptimalkan untuk menjalankan sebagian besar beban kerja produksi dan menyediakan resource komputasi berdasarkan manifes Kubernetes Anda.

Deploy Bank Cymbal

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

Dalam serangkaian 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 serangkaian tutorial. Cymbal Bank hanyalah contoh aplikasi untuk menunjukkan bagaimana edisi Google Kubernetes Engine (GKE) Enterprise dapat mendukung kebutuhan bisnis Anda.

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

Layanan	Language	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 dibaca dari `ledger-db`.
`transaction-history`	Java	Menyediakan cache yang dapat dibaca dan efisien dari transaksi terdahulu, seperti yang dibaca dari `ledger-db`.
`ledger-db`	PostgreSQL	Buku besar semua transaksi. Opsi untuk mengisi otomatis dengan transaksi bagi pengguna demo.
`user-service`	Python	Mengelola akun pengguna dan autentikasi. Tanda JWT yang digunakan untuk otentikasi oleh layanan lain.
`contacts`	Python	Menyimpan daftar akun lain yang terkait dengan pengguna. Digunakan untuk drop-down di formulir "Kirim Pembayaran" dan "Setoran".
`accounts-db`	PostgreSQL	Database untuk akun pengguna dan data terkait. Opsi untuk mengisi otomatis pengguna demo.
`loadgenerator`	Python / Locust	Terus-menerus mengirimkan permintaan yang meniru pengguna ke frontend. Membuat akun baru secara berkala dan menyimulasikan transaksi di antara akun tersebut.

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

Cymbal Bank menggunakan JSON Web Token (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, sementara layanan lainnya menggunakan kunci publik yang sesuai untuk memvalidasi pengguna tersebut.

Buat RS256 JWT yang kekuatannya 4.096 bit:
```
openssl genrsa -out jwtRS256.key 4096
openssl rsa -in jwtRS256.key -outform PEM -pubout -out jwtRS256.key.pub
```
Jika perlu, download dan instal alat OpenSSL untuk platform Anda.
Secret Kubernetes dapat menyimpan data sensitif seperti kunci atau sandi. Selanjutnya, beban kerja yang dijalankan di cluster Anda dapat mengakses Secret tersebut untuk mendapatkan data sensitif, bukan melakukan hard-coding terhadap data tersebut dalam aplikasi.

Buat Secret Kubernetes dari file kunci yang Anda buat pada langkah sebelumnya untuk digunakan oleh Cymbal Bank dengan permintaan autentikasi:
```
kubectl create secret generic jwt-key --from-file=./jwtRS256.key --from-file=./jwtRS256.key.pub
```

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 dalam output kubectl saat manifes diterapkan ke cluster Anda tentang batasan Autopilot. Autopilot menggunakan permintaan resource yang Anda tentukan dalam konfigurasi workload untuk mengonfigurasi node yang menjalankan workload Anda. Autopilot memberlakukan 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.4
            - 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.4@sha256:f25db63509515fb6caf98c8c76e906f3c2868e345767d12565ab3750e52963f0
          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 untuk Layanan frontend ini meminta 100m CPU dan 64Mi, serta menetapkan batas 250m CPU dan 128Mi per Pod.

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

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

kubectl get pods

Kolom STATUS berubah dari Pending menjadi ContainerCreating. Diperlukan waktu beberapa menit agar semua Pod berada dalam status Running, seperti 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

Saat semua Pod berada dalam status Running, lanjutkan ke langkah berikutnya. Sekali lagi, perlu waktu beberapa menit agar semua Pod berada dalam status Running. Wajar jika beberapa Pod melaporkan status READY dari 0/1 hingga Cymbal Bank siap menyalurkan traffic dengan benar.

Layanan frontend mengekspos server HTTP untuk menayangkan situs Cymbal Bank, termasuk halaman login, halaman pendaftaran, dan halaman beranda. Objek Ingress menentukan aturan untuk merutekan 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}'
```
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 mempelajari beberapa contoh transaksi dan saldo. Tidak ada tindakan spesifik yang perlu Anda lakukan, selain mengonfirmasi bahwa Cymbal Bank berhasil dijalankan. Mungkin perlu waktu satu atau dua menit hingga semua layanan berkomunikasi dengan benar dan Anda dapat masuk.

Mempelajari deployment Anda

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

Seperti yang diperkenalkan saat membuat cluster, kemampuan GKE Enterprise dibangun berdasarkan ide fleet: pengelompokan logis cluster Kubernetes yang dapat dikelola bersama. Ringkasan GKE Enterprise di Konsol Google Cloud memberi Anda tampilan umum tentang seluruh fleet Anda. Saat Anda membuat cluster GKE, cluster tersebut otomatis terdaftar ke fleet menggunakan parameter --enable-fleet.

Untuk melihat informasi GKE Enterprise dan fleet, buka halaman Overview di Konsol Google Cloud:

Buka Ringkasan GKE Enterprise

Halaman Ringkasan menampilkan informasi berikut:

Jumlah cluster yang ada di armada Anda, dan apakah cluster tersebut sehat.
Pemakaian resource fleet Anda, termasuk penggunaan CPU, memori, dan disk, yang digabungkan berdasarkan fleet dan cluster.
Setiap masalah keamanan yang teridentifikasi untuk fleet Anda, cakupan Pengontrol Kebijakan di seluruh fleet, dan status sinkronisasi paket Config Sync Anda. Anda dapat menambahkan Pengontrol Kebijakan dan Config Sync ke cluster dalam tutorial mendatang dalam rangkaian ini.

Halaman Clusters GKE akan menampilkan semua cluster di project Anda. Cluster yang terdaftar ke suatu fleet akan mencantumkan fleet-nya di kolom Armada.

Di bagian berikut, Anda akan mempelajari lebih lanjut resource GKE Cymbal Bank.

Cluster

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

Di halaman Google Kubernetes Engine pada Konsol Google Cloud, buka halaman Clusters.

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

Kemampuan observasi

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

Pilih cluster Anda dari halaman Clusters Google Kubernetes Engine di Google Cloud Console, lalu buka tab Observability.
Periksa beberapa grafis metrik untuk mengetahui hal-hal seperti CPU dan Memory. Tampilan ini memungkinkan Anda memantau performa berbagai bagian workload cluster tanpa perlu men-deploy kemampuan pemantauan tambahan.
Untuk melihat log yang di-streaming dari cluster Anda, pilih tab Logs. Anda dapat memfilter berdasarkan Severity log, atau membuat filter sendiri untuk melihat namespace, Layanan, atau Pod tertentu. Seperti pada peringatan dan peristiwa Pod, tampilan log yang disusun dari cluster ini dapat membantu men-debug masalah dengan cepat menggunakan Konsol Google Cloud.

Anda dapat melihat entri log karena Cymbal Bank pertama kali di-deploy saat beberapa layanan belum dapat berkomunikasi.
Pilih tab Error Aplikasi. Saat beban kerja berjalan, Anda dapat melihat peringatan dan peristiwa yang tersusun di konsol Google Cloud. Pendekatan ini dapat membantu men-debug masalah tanpa harus terhubung ke cluster, Node, atau Pod satu per satu.

Sekali lagi, peristiwa yang dicatat ke dalam log adalah hal yang wajar karena Cymbal Bank pertama kali di-deploy saat beberapa Layanan belum dapat berkomunikasi.

Beban kerja

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

Di halaman Google Kubernetes Engine pada Konsol Google Cloud, buka halaman Workloads.

Buka halaman Workloads

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

Layanan & Ingress

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

Di halaman Google Kubernetes Engine pada Konsol Google Cloud, buka halaman Gateways, Services & Ingress.

Buka halaman Gateways, Services & Ingress
Untuk menemukan ingress Cymbal Bank, klik tab untuk "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.
Klik Alamat IP untuk traffic masuk frontend, seperti 198.51.100.143:80. Alamat ini akan mengarah ke antarmuka web Cymbal Bank.

Pembersihan

Kumpulan tutorial untuk Cymbal Bank dirancang untuk diselesaikan satu per satu. Seiring progres Anda dalam mengikuti serangkaian tutorial, Anda akan mempelajari keterampilan baru dan menggunakan produk serta layanan Google Cloud tambahan.

Jika ingin berhenti sejenak sebelum melanjutkan ke tutorial berikutnya dan agar tidak menimbulkan tagihan ke akun Google Cloud Anda untuk resource yang digunakan dalam tutorial ini, hapus project yang Anda buat.

Perhatian: Menghapus project memiliki efek berikut:

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

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

Di konsol Google Cloud, buka halaman Manage resource.
Buka 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.

Langkah selanjutnya

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