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:

  1. Membuat cluster dan men-deploy aplikasi contoh (tutorial ini)
  2. Memantau dengan Google Cloud Managed Service for Prometheus
  3. Menskalakan workload
  4. Menyimulasikan kegagalan
  5. 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:

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.

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

    Buka halaman Google Kubernetes Engine

  2. Buat atau pilih project. Di project inilah Anda mengaktifkan GKE Enterprise.

  3. Jika diminta, klik Enable GKE Enterprise API.

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

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

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

  1. Di konsol Google Cloud, buka halaman GKE Enterprise:

    Buka halaman GKE Enterprise

  2. Pilih Pelajari tentang Google Kubernetes Engine (GKE) edisi Enterprise.

  3. Jika memenuhi syarat, Anda dapat mencentang opsi Mulai uji coba gratis 90 hari.

  4. 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:

  1. 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.

  2. 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
    
  3. 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.

  4. 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.

  5. 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}'
    
  6. 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.

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

    Buka halaman Clusters

  2. 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.

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

  2. 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.

  3. 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.

  4. 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.

  1. 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.

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

    Buka Gateways, Services & Halaman masuk

  2. 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.

  3. 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.

  1. Di konsol Google Cloud, buka halaman Manage resource.

    Buka Manage resource

  2. Pada daftar project, pilih project yang ingin Anda hapus, lalu klik Delete.
  3. 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.