Jalur Pembelajaran: Aplikasi yang skalabel - Membuat cluster

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 atas node, yang merupakan virtual machine (VM) Compute Engine yang dikelompokkan bersama untuk membentuk cluster.

Cluster GKE juga dapat dikelompokkan bersama dalam fleet: kelompok cluster logis 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 telah Anda buat di bagian sebelumnya. Project ID sering kali berbeda dengan nama project. Misalnya, project Anda mungkin berupa scalable-apps, tetapi project ID Anda mungkin adalah scalable-apps-567123.
  • REGION dengan region tempat Anda ingin membuat cluster, misalnya us-central1.

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

Dalam kumpulan tutorial ini, Anda 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 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 yang bernama Cymbal Bank ke satu atau beberapa cluster GKE. Cymbal Bank menggunakan Python dan Java untuk menjalankan berbagai layanan, serta 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 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 Anda:

Untuk men-deploy Cymbal Bank ke cluster GKE Anda, selesaikan 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 login, 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 perlu, download dan instal alat OpenSSL untuk platform Anda.

2. Rahasia Kubernetes dapat menyimpan data sensitif seperti kunci atau sandi. Beban kerja yang berjalan di cluster Anda kemudian dapat mengakses Secret tersebut untuk mendapatkan data sensitif, bukan melakukan hard-coding pada aplikasi.

   Buat Rahasia Kubernetes dari file kunci yang Anda buat pada langkah sebelumnya agar Cymbal Bank dapat digunakan 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 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 tentang batas Autopilot dalam output kubectl saat manifes diterapkan ke cluster Anda. 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 penampung, Autopilot akan menetapkan nilai default agar penampung 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 workload di cluster Autopilot, GKE akan memvalidasi konfigurasi workload berdasarkan nilai minimum dan maksimum yang diizinkan untuk class komputasi atau konfigurasi hardware yang dipilih (seperti GPU). Jika permintaan Anda kurang dari nilai minimum, Autopilot akan otomatis mengubah konfigurasi workload Anda untuk memindahkan permintaan 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. Perlu waktu beberapa menit sampai semua Pod berada dalam status Running, seperti ditunjukkan pada 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 dalam status Running. Beberapa Pod melaporkan status READY dari 0/1 sampai 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 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 akan otomatis diisi, sehingga Anda dapat login ke aplikasi dan mempelajari beberapa contoh transaksi dan saldo. Tidak ada tindakan tertentu yang perlu Anda lakukan selain mengonfirmasi bahwa Cymbal Bank berhasil berjalan. Mungkin butuh waktu satu atau dua menit agar semua layanan berkomunikasi dengan benar dan memungkinkan Anda login.

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 Anda membuat cluster, kemampuan GKE Enterprise dibangun berdasarkan gagasan fleet: pengelompokan logis cluster Kubernetes yang dapat dikelola bersama-sama. Misalnya, Anda mungkin memiliki beberapa cluster yang digunakan oleh tim yang berbeda, menyimpan replika aplikasi di region berbeda untuk tujuan latensi dan keandalan, atau menyegmentasikan workload dengan persyaratan keamanan yang berbeda. Armada membantu mengatur kelompok cluster terkait ini.

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

Untuk melihat informasi GKE Enterprise dan fleet, buka halaman Overview 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 resource fleet Anda, termasuk penggunaan CPU, memori, dan disk, yang digabungkan berdasarkan fleet dan cluster.
• Semua masalah keamanan yang teridentifikasi untuk fleet Anda, cakupan Pengontrol Kebijakan di seluruh fleet, dan status sinkronisasi paket Config Sync Anda. Anda akan menambahkan Pengontrol Kebijakan dan Config Sync ke cluster Anda dalam tutorial mendatang dalam seri ini.

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

Di bagian berikut ini, Anda akan mempelajari resource GKE dari Cymbal Bank.

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 halaman Clusters.

   Buka halaman Clusters

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 mana yang diaktifkan di cluster ini di bagian Fitur.

Kemampuan Observasi

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

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

2. Periksa beberapa grafis metrik untuk hal seperti CPU dan Memori. Dengan tampilan ini, Anda dapat memantau performa berbagai bagian workload cluster tanpa perlu men-deploy kemampuan pemantauan tambahan.

3. Untuk melihat log yang di-streaming dari cluster, pilih tab Logs. Anda dapat memfilter menurut Severity log, atau membuat filter sendiri untuk melihat namespace, Layanan, atau Pod tertentu. Seperti peringatan dan peristiwa Pod, tampilan gabungan log dari cluster Anda 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.

4. Pilih tab Error Aplikasi. Saat workload berjalan, Anda dapat melihat peringatan dan peristiwa 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, adalah hal yang wajar untuk melihat peristiwa yang dicatat ke dalam log karena 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 gabungan workload yang berjalan di semua cluster GKE Anda.

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

   Buka halaman Workloads

   Tab Overview menampilkan daftar workload dan namespace dari cluster GKE. Anda dapat memfilter menurut namespace untuk melihat beban kerja 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.

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

   Buka halaman Gateways, Services & Ingress

2. Untuk menemukan traffic masuk Cymbal Bank, klik tab "Ingress" dan temukan ingress dengan nama frontend. Traffic masuk mengelola traffic 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.