Halaman ini diterjemahkan oleh Cloud Translation API.

Jalur Pembelajaran: Aplikasi yang skalabel - Membuat cluster

Kumpulan tutorial ini ditujukan untuk administrator IT dan Operator yang ingin untuk men-deploy, menjalankan, dan mengelola lingkungan aplikasi modern yang berjalan Edisi Google Kubernetes Engine (GKE) Enterprise. Saat Anda terus mempelajari rangkaian tutorial ini, Anda akan belajar cara mengonfigurasi pemantauan dan pemberitahuan, menskalakan workload, dan melakukan simulasi 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
Pusatkan manajemen perubahan

Ringkasan dan tujuan

Cymbal Bank menggunakan Python dan Java untuk menjalankan beragam layanan, termasuk backend PostgreSQL. Anda tidak memerlukan pengalaman dengan bahasa atau database ini platform untuk menyelesaikan rangkaian tutorial, karena Cymbal Bank hanyalah contoh untuk menunjukkan bagaimana GKE Enterprise 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 cluster GKE. Anda akan mempelajari cara menyelesaikan tugas-tugas berikut:

Membuat cluster GKE yang menggunakan {i>Autopilot<i}.
Men-deploy contoh aplikasi berbasis microservice yang bernama Cymbal Bank.
Gunakan Konsol Google Cloud untuk mempelajari resource GKE yang digunakan oleh aplikasi contoh Cymbal Bank.

Biaya

Mengaktifkan GKE Enterprise dan men-deploy contoh Cymbal Bank untuk rangkaian tutorial ini berarti Anda mengeluarkan biaya per-cluster biaya untuk GKE Enterprise di Google Cloud seperti yang tercantum dalam Halaman harga hingga Anda menonaktifkan GKE Enterprise atau menghapus project.

Anda juga bertanggung jawab atas biaya Google Cloud lainnya yang timbul saat menjalankan Contoh aplikasi Cymbal Bank, seperti biaya untuk VM Compute Engine dan dengan load balancer Jaringan Passthrough Eksternal Regional.

Sebelum memulai

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

Dalam tutorial pertama dalam rangkaian ini, selesaikan semua langkah "Mulai Anda memulai" langkah-langkah pengaturan sebelum Anda memulai. Anda hanya perlu menyelesaikan setelah "Sebelum memulai" langkah sekali.

Mengonfigurasi shell dan alat

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

gcloud CLI: membuat dan mengelola cluster GKE serta fleet, beserta 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 sudah siapkan, aktifkan Cloud Shell:

Di bagian bawah halaman ini, sesi Cloud Shell dimulai dan menampilkan prompt command line. Sesi akan memerlukan waktu beberapa detik melakukan inisialisasi.

Shell lokal

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

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

Menyiapkan project

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

Anda mungkin memerlukan administrator Google Cloud di organisasi untuk memberi Anda 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, klik Enable GKE Enterprise API.
Tunggu hingga API dan layanan terkait diaktifkan. Proses ini dapat memerlukan 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 Pelajari tentang Google Kubernetes Engine (GKE) edisi Enterprise.
Jika memenuhi syarat, Anda dapat mencentang opsi Mulai uji coba gratis 90 hari.
Pilih Enable GKE Enterprise, lalu Confirm.

Memberikan peran IAM

Jika Anda adalah pemilik proyek (misalnya jika Anda membuat proyek sendiri), Anda sudah memiliki semua izin yang diperlukan untuk menyelesaikan tutorial ini. Jika Anda bukan pemilik, pastikan bahwa akun Google Cloud Anda memiliki wajib diisi Peran IAM ke project yang Anda pilih untuk kumpulan tutorial ini. Sekali lagi, Anda mungkin memerlukan administrator Google Cloud di organisasi Anda untuk membantu memberikan peran.

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. Sebagai misalnya, project Anda mungkin adalah scalable-apps, tetapi project ID Anda mungkin 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 contoh

Buat 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

Dengan selesainya semua langkah prasyarat di bagian sebelumnya, Anda dapat sekarang mulailah 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 atas node, yang merupakan virtual machine (VM) Compute Engine, yang yang dikelompokkan untuk membentuk cluster.

Cluster GKE juga dapat dikelompokkan bersama dalam fleet: logis kelompok klaster yang dapat dikelola bersama-sama. Banyak fitur GKE Enterprise, termasuk yang akan Anda gunakan nanti dalam seri tutorial, didasarkan pada perangkat dan prinsip-prinsip kesamaan dan kepercayaan yang diasumsikan oleh armada.

Membuat cluster GKE yang akan Anda gunakan dalam tutorial selanjutnya dalam rangkaian ini:
```
gcloud container clusters create-auto scalable-apps \
  --project=PROJECT_ID \
  --region=REGION \
  --enable-fleet
```
Ganti kode berikut:
- PROJECT_ID dengan ID yang dibuat otomatis dari project yang Anda buat di bagian sebelumnya. Project ID sering kali berbeda dari nama proyek. Misalnya, proyek Anda mungkin scalable-apps, tetapi project ID Anda mungkin adalah scalable-apps-567123.
- REGION dengan wilayah tempat Anda ingin membuat dikelompokkan, seperti us-central1.
Perlu waktu beberapa menit untuk membuat cluster dan memastikan semuanya berfungsi dengan benar.

Dalam set tutorial ini, Anda menggunakan cluster mode Autopilot dan beberapa rentang alamat IP default saat Anda membuat cluster. Deployment produksi aplikasi Anda sendiri memerlukan perencanaan alamat IP yang lebih hati-hati. Di beberapa Mode Autopilot, Google mengelola konfigurasi cluster Anda, termasuk penskalaan otomatis, keamanan, dan setelan sebelumnya yang telah dikonfigurasi sebelumnya. Cluster di Mode {i>Autopilot<i} dioptimalkan untuk menjalankan sebagian besar beban kerja produksi dan menyediakan resource komputasi berdasarkan manifes Kubernetes Anda.

Men-deploy Cymbal Bank

Anda mengemas aplikasi (juga disebut workloads) 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 Cymbal Bank ke satu atau beberapa cluster GKE. Bank Cymbal menggunakan Python dan Java untuk menjalankan berbagai layanan, termasuk PostgreSQL backend. Anda tidak memerlukan pengalaman dengan bahasa atau platform {i>database<i} ini untuk menyelesaikan rangkaian tutorial. Cymbal Bank adalah contoh aplikasi untuk menunjukkan cara edisi Google Kubernetes Engine (GKE) Enterprise dapat mendukung kebutuhan bisnis Anda.

Jika Anda menggunakan Cymbal Bank sebagai bagian dari rangkaian tutorial ini, hal berikut 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 menulisnya ke buku besar.
`balance-reader`	Java	Menyediakan cache saldo pengguna yang dapat dibaca secara efisien, seperti yang dibaca dari `ledger-db`.
`transaction-history`	Java	Menyediakan cache transaksi sebelumnya yang dapat dibaca dan efisien, 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. Menandatangani JWT yang digunakan untuk autentikasi oleh layanan lain.
`contacts`	Python	Daftar penyimpanan akun lain yang terkait dengan pengguna. Digunakan untuk drop-down di "Kirim Pembayaran" dan "Setoran" formulir.
`accounts-db`	PostgreSQL	Database untuk akun pengguna dan data terkait. Opsi untuk mengisi otomatis dengan pengguna demo.
`loadgenerator`	Python / Belai	Terus-menerus mengirimkan permintaan yang meniru pengguna ke frontend. Membuat akun baru secara berkala dan menyimulasikan transaksi di antara akun-akun tersebut.

Untuk men-deploy Cymbal Bank ke cluster GKE Anda, selesaikan langkah 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 {i>login<i}, dan layanan lainnya menggunakan kunci publik yang sesuai untuk memvalidasi pengguna.

Buat JWT RS256 berkekuatan 4.096 bit:
```
openssl genrsa -out jwtRS256.key 4096
openssl rsa -in jwtRS256.key -outform PEM -pubout -out jwtRS256.key.pub
```
Jika diperlukan, mendownload dan menginstal alat OpenSSL untuk platform Anda.
Rahasia Kubernetes dapat menyimpan data sensitif seperti kunci atau sandi. Workload yang berjalan di cluster Anda kemudian dapat mengakses Secret ini untuk mendapatkan data sensitif alih-alih meng-{i>hard-coding<i} dalam aplikasi.

Membuat Secret Kubernetes dari file kunci yang Anda buat di langkah sebelumnya langkah yang akan digunakan Cymbal Bank untuk permintaan otentikasi:
```
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 dalam 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 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 perangkat keras yang digunakan oleh beban kerja Anda. Jika Anda tidak menentukan untuk beberapa kontainer, Autopilot menetapkan nilai default dan membiarkan 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.5
            - 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.5@sha256:d72050f70d12383e4434ad04d189b681dc625f696087ddf0b5df641645c9dafa
          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, dan menetapkan batas 250m CPU dan 128Mi per Pod.

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

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

kubectl get pods

Kolom STATUS berubah dari Pending menjadi ContainerCreating. Dibutuhkan selama beberapa menit hingga semua Pod berada dalam status Running, seperti ditunjukkan di 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, semua Pod memerlukan waktu beberapa menit untuk berada di Running status. Beberapa Pod melaporkan status READY dari 0/1 hingga Cymbal Bank siap melayani traffic dengan benar.

Layanan frontend mengekspos server HTTP untuk menyalurkan Cymbal Bank {i>website<i}, termasuk halaman {i>sign-in<i}, halaman pendaftaran, dan halaman beranda. Ingress menentukan aturan untuk mengarahkan 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 di 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. Ada tidak ada tindakan khusus yang perlu Anda ambil, selain untuk mengonfirmasi bahwa Cymbal Bank berhasil dijalankan. Mungkin perlu waktu satu atau dua menit untuk semua layanan berkomunikasi dengan benar dan memungkinkan Anda masuk.

Mempelajari deployment Anda

Setelah membuat cluster GKE dan men-deploy workload, Anda mungkin perlu mengubah pengaturan atau meninjau kinerja aplikasi Anda. Di sini Anda akan mempelajari cara menggunakan Konsol Google Cloud untuk meninjau resource adalah bagian dari cluster Anda dan aplikasi contoh Cymbal Bank.

Seperti yang diperkenalkan saat Anda membuat cluster, GKE Enterprise kemampuan yang dibangun berdasarkan gagasan tentang armada: pengelompokan yang logis dari Cluster Kubernetes yang dapat dikelola bersama-sama. Sebagai contoh, Anda mungkin memiliki beberapa cluster yang digunakan oleh tim berbeda, menyimpan replika aplikasi di region yang berbeda untuk tujuan latensi dan keandalan, atau untuk menyegmentasikan workload dengan persyaratan keamanan yang berbeda. Armada membantu mengatur kelompok-kelompok ini klaster yang terkait.

Ringkasan GKE Enterprise di Konsol Google Cloud memberikan dengan tampilan tingkat tinggi dari seluruh armada Anda. Saat Anda membuat GKE, layanan tersebut otomatis didaftarkan ke fleet menggunakan parameter --enable-fleet.

Untuk melihat informasi GKE Enterprise dan fleet, buka Halaman Ringkasan di Konsol Google Cloud:

Buka GKE Enterprise Overview

Halaman Ringkasan menampilkan informasi berikut:

Berapa banyak cluster yang ada di fleet Anda, dan apakah cluster tersebut responsif.
Pemanfaatan sumber daya perangkat Anda, termasuk penggunaan CPU, memori, dan {i>disk<i}, digabungkan berdasarkan fleet dan cluster.
Setiap masalah keamanan yang teridentifikasi di seluruh armada dan seluruh armada cakupan Pengontrol Kebijakan, dan status sinkronisasi beberapa paket Config Sync. Anda menambahkan Pengontrol Kebijakan dan Sinkronisasi Konfigurasi ke cluster Anda dalam tutorial mendatang dalam seri ini.

Halaman Clusters GKE menampilkan semua cluster dalam proyek. Armada yang terdaftar di klaster-klaster yang terdaftar di Armada.

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

Cluster

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

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

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

Kemampuan observasi

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

Pilih cluster Anda dari halaman Clusters Google Kubernetes Engine pada Konsol Google Cloud, lalu buka tab Observability.
Periksa beberapa grafis metrik untuk hal seperti CPU dan Memori. Ini memungkinkan Anda memantau performa berbagai bagian cluster workload tanpa perlu men-deploy kemampuan pemantauan tambahan.
Untuk melihat log yang di-streaming dari cluster, pilih tab Logs. Anda dapat filter menurut Severity log, atau buat filter Anda sendiri untuk melihat namespace, Service, atau Pod. Seperti halnya peringatan dan peristiwa Pod, tampilan gabungan log dari cluster Anda dapat membantu men-debug masalah dengan cepat menggunakan konsol Google Cloud.

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

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

Beban kerja

Halaman GKE Konsol Google Cloud memiliki bagian Workloads yang menunjukkan tampilan agregat workload yang berjalan di semua Cluster GKE.

Di halaman Google Kubernetes Engine pada Google Cloud Console, buka Workloads kami.

Buka halaman Workloads

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

Layanan & Ingress

Halaman Layanan & Tampilan Ingress menunjukkan Service dan Ingress project Google Cloud Platform. Service mengekspos kumpulan Pod sebagai layanan jaringan dengan endpoint, sedangkan Ingress mengelola akses eksternal ke layanan di cluster.

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

Buka Gateways, Services & Halaman masuk
Untuk menemukan traffic masuk Cymbal Bank, klik tab "Ingress" dan cari traffic masuk dengan nama frontend. Traffic masuk mengelola lalu lintas masuk untuk aplikasi Anda. Anda dapat melihat informasi tentang load balancer, port, dan endpoint eksternal.
Klik IP address untuk traffic masuk frontend, seperti 198.51.100.143:80. Alamat ini akan membuka antarmuka web Cymbal Bank.

Pembersihan

Kumpulan tutorial untuk Cymbal Bank dirancang untuk diselesaikan satu setelah lainnya. Saat Anda terus mempelajari rangkaian tutorial, Anda belajar keterampilan baru dan menggunakan produk dan layanan Google Cloud tambahan.

Jika Anda ingin istirahat sebelum melanjutkan ke tutorial berikutnya dan menghindari menimbulkan biaya ke akun Google Cloud Anda untuk resource yang digunakan dalam menghapus 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 di tutorial berikutnya.