Membuat aplikasi web multi-tingkat dengan Redis dan PHP

Autopilot Standard

---

Tutorial ini menunjukkan cara membuat aplikasi web multi-tingkat menggunakan Google Kubernetes Engine (GKE).

Dalam tutorial ini, Anda akan melakukan beberapa hal berikut:

• Menyiapkan aplikasi web dengan alamat IP eksternal dan load balancer.
• Buat cluster Redis dengan satu master (pemimpin) dan beberapa replikas (pengikut).

Contoh berikut menjelaskan konsep Kubernetes berikut:

• Konfigurasi deklaratif menggunakan file manifes YAML
• Deployment, yaitu resource Kubernetes yang menentukan konfigurasi untuk serangkaian Pod yang direplikasi
• Layanan untuk membuat load balancer internal dan eksternal untuk sekumpulan Pod

Tujuan

Untuk men-deploy dan menjalankan aplikasi di GKE:

1. Menyiapkan leader Redis
2. Menyiapkan dua follower Redis
3. Menyiapkan frontend web
4. Buka situs
5. Meningkatkan skala frontend web

Diagram berikut menampilkan ringkasan arsitektur cluster yang Anda buat dengan menyelesaikan tujuan berikut:

Biaya

Dalam dokumen ini, Anda menggunakan komponen Google Cloud yang dapat ditagih berikut:

• GKE

Untuk membuat perkiraan biaya berdasarkan proyeksi penggunaan Anda, gunakan kalkulator harga. Pengguna baru Google Cloud mungkin memenuhi syarat untuk mendapatkan uji coba gratis.

Setelah menyelesaikan tugas yang dijelaskan dalam dokumen ini, Anda dapat menghindari penagihan berkelanjutan dengan menghapus resource yang Anda buat. Untuk mengetahui informasi selengkapnya, lihat Pembersihan.

Sebelum memulai

Cloud Shell telah diinstal dengan software yang Anda perlukan untuk tutorial ini, termasuk kubectl dan gcloud CLI. Jika tidak menggunakan Cloud Shell, Anda harus menginstal gcloud CLI.

1. Login ke akun Google Cloud Anda. Jika Anda baru menggunakan Google Cloud, buat akun untuk mengevaluasi performa produk kami dalam skenario dunia nyata. Pelanggan baru juga mendapatkan kredit gratis senilai $300 untuk menjalankan, menguji, dan men-deploy workload.
2. Menginstal Google Cloud CLI.

3. Untuk initialize gcloud CLI, jalankan perintah berikut:

   gcloud init

   Catatan: Jika Anda telah menginstal gcloud CLI sebelumnya, pastikan Anda memiliki versi baru dengan menjalankan gcloud components update.

4. Buat atau pilih project Google Cloud.

   Catatan: Jika tidak berencana untuk menyimpan resource yang Anda buat dalam prosedur ini, buatlah project, bukan memilih project yang ada. Setelah menyelesaikan langkah ini, Anda dapat menghapus project, yang menghapus semua resource yang terkait dengan project ini.

   • Membuat project Google Cloud:

     gcloud projects create PROJECT_ID

     Ganti PROJECT_ID dengan nama untuk project Google Cloud yang Anda buat.

   • Pilih project Google Cloud yang Anda buat:

     gcloud config set project PROJECT_ID

     Ganti PROJECT_ID dengan nama project Google Cloud Anda.

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

6. Enable the GKE API:

   gcloud services enable container.googleapis.com

7. Menginstal Google Cloud CLI.

8. Untuk initialize gcloud CLI, jalankan perintah berikut:

   gcloud init

   Catatan: Jika Anda telah menginstal gcloud CLI sebelumnya, pastikan Anda memiliki versi baru dengan menjalankan gcloud components update.

9. Buat atau pilih project Google Cloud.

   Catatan: Jika tidak berencana untuk menyimpan resource yang Anda buat dalam prosedur ini, buatlah project, bukan memilih project yang ada. Setelah menyelesaikan langkah ini, Anda dapat menghapus project, yang menghapus semua resource yang terkait dengan project ini.

   • Membuat project Google Cloud:

     gcloud projects create PROJECT_ID

     Ganti PROJECT_ID dengan nama untuk project Google Cloud yang Anda buat.

   • Pilih project Google Cloud yang Anda buat:

     gcloud config set project PROJECT_ID

     Ganti PROJECT_ID dengan nama project Google Cloud Anda.

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

11. Enable the GKE API:

    gcloud services enable container.googleapis.com

Menyiapkan lingkungan

Untuk menyiapkan lingkungan, ikuti langkah-langkah berikut:

1. Menetapkan variabel lingkungan:

   export PROJECT_ID=PROJECT_ID
   export COMPUTE_LOCATION=COMPUTE_LOCATION
   

   Ganti kode berikut:

   • PROJECT_ID: project ID Google Cloud Anda
   • COMPUTE_LOCATION: lokasi Compute Engine, seperti us-central1.

2. Buat clone repositori GitHub:

   git clone https://github.com/GoogleCloudPlatform/kubernetes-engine-samples
   

3. Ubah ke direktori kerja:

   cd kubernetes-engine-samples/quickstarts/guestbook/
   

Membuat cluster GKE

Buat cluster Autopilot atau GKE Standar:

Autopilot

gcloud container clusters create-auto guestbook \
    --location=${COMPUTE_LOCATION} \

Standar

gcloud container clusters create guestbook \
    --location=${COMPUTE_LOCATION} \
    --num-nodes=4

Hubungkan ke cluster

Konfigurasi kubectl untuk berkomunikasi dengan cluster:

gcloud container clusters get-credentials guestbook \
    --location=${COMPUTE_LOCATION}

Menyiapkan leader Redis

Aplikasi tersebut menggunakan Redis untuk menyimpan datanya. Aplikasi tersebut menulis datanya ke instance pemimpin Redis dan membaca data dari beberapa instance pengikut Redis.

1. Manifes berikut menjelaskan Deployment Kubernetes yang menjalankan satu replika Pod pemimpin Redis:

   apiVersion: apps/v1
   kind: Deployment
   metadata:
     name: redis-leader
     labels:
       app: redis
       role: leader
       tier: backend
   spec:
     replicas: 1
     selector:
       matchLabels:
         app: redis
     template:
       metadata:
         labels:
           app: redis
           role: leader
           tier: backend
       spec:
         containers:
         - name: leader
           image: "docker.io/redis:6.0.5"
           resources:
             requests:
               cpu: 100m
               memory: 100Mi
           ports:
           - containerPort: 6379

   Terapkan manifes ke cluster Anda:

   kubectl apply -f redis-leader-deployment.yaml
   

2. Pastikan bahwa Pod leader Redis sedang berjalan:

   kubectl get pods
   

   Outputnya mirip dengan hal berikut ini:

   NAME                           READY     STATUS    RESTARTS   AGE
   redis-leader-343230949-qfvrq   1/1       Running   0          43s
   

   Mungkin perlu waktu beberapa menit bagi STATUS untuk berubah dari Pending menjadi Running.

Membuat Layanan pemimpin Redis

Aplikasi web perlu berkomunikasi dengan pemimpin Redis untuk menulis datanya. Anda dapat membuat Service untuk mengirim proxy traffic ke Pod leader Redis.

Service adalah abstraksi Kubernetes yang menentukan kumpulan logis Pod dan kebijakan untuk mengaktifkan akses ke Pod. Saat membuat Service, Anda perlu menjelaskan Pod mana yang akan di-proxy-kan berdasarkan label Pod.

1. Manifes berikut menjelaskan Layanan untuk pemimpin Redis:

   apiVersion: v1
   kind: Service
   metadata:
     name: redis-leader
     labels:
       app: redis
       role: leader
       tier: backend
   spec:
     ports:
     - port: 6379
       targetPort: 6379
     selector:
       app: redis
       role: leader
       tier: backend

   Manifes ini mencakup sekumpulan pemilih label. Label ini cocok dengan kumpulan label yang diterapkan pada langkah sebelumnya. Oleh karena itu, Service ini akan merutekan traffic jaringan ke Pod pemimpin Redis yang dibuat pada langkah sebelumnya.

   Bagian ports dari manifes mendeklarasikan pemetaan port tunggal. Layanan merutekan traffic di port: 6379 ke targetPort: 6379 penampung yang cocok dengan label selector yang ditentukan. containerPort yang digunakan dalam Deployment harus cocok dengan targetPort untuk mengarahkan traffic ke Deployment.

   Terapkan manifes ke cluster Anda:

   kubectl apply -f redis-leader-service.yaml
   

2. Pastikan GKE membuat Layanan:

   kubectl get service
   

   Outputnya mirip dengan hal berikut ini:

   NAME           CLUSTER-IP      EXTERNAL-IP   PORT(S)    AGE
   kubernetes     10.51.240.1     <none>        443/TCP    42s
   redis-leader   10.51.242.233   <none>        6379/TCP   12s
   

Menyiapkan pengikut Redis

Meskipun leader Redis adalah Pod tunggal, Anda dapat membuatnya sangat tersedia dan memenuhi permintaan traffic dengan menambahkan beberapa follower Redis, atau replika.

1. Manifes berikut menjelaskan Deployment untuk Pod pengikut Redis:

   apiVersion: apps/v1
   kind: Deployment
   metadata:
     name: redis-follower
     labels:
       app: redis
       role: follower
       tier: backend
   spec:
     replicas: 2
     selector:
       matchLabels:
         app: redis
     template:
       metadata:
         labels:
           app: redis
           role: follower
           tier: backend
       spec:
         containers:
         - name: follower
           image: us-docker.pkg.dev/google-samples/containers/gke/gb-redis-follower:v2
           resources:
             requests:
               cpu: 100m
               memory: 100Mi
           ports:
           - containerPort: 6379

2. Terapkan manifes ke cluster Anda:

   kubectl apply -f redis-follower-deployment.yaml
   

3. Pastikan dua replika pengikut Redis berjalan:

   kubectl get pods
   

   Outputnya mirip dengan hal berikut ini:

   NAME                              READY   STATUS    RESTARTS   AGE
   redis-follower-76588f55b7-bnsq6   1/1     Running   0          27s
   redis-follower-76588f55b7-qvtws   1/1     Running   0          27s
   redis-leader-dd446dc55-kl7nl      1/1     Running   0          119s
   

   Mungkin perlu waktu beberapa menit bagi STATUS untuk berubah dari Pending menjadi Running.

Membuat Layanan pengikut Redis

Aplikasi web harus berkomunikasi dengan pengikut Redis untuk membaca data. Agar pengikut Redis dapat ditemukan, Anda harus menyiapkan Layanan.

1. Manifes berikut menjelaskan Layanan untuk pengikut Redis:

   apiVersion: v1
   kind: Service
   metadata:
     name: redis-follower
     labels:
       app: redis
       role: follower
       tier: backend
   spec:
     ports:
       # the port that this service should serve on
     - port: 6379
     selector:
       app: redis
       role: follower
       tier: backend

   Manifes ini menentukan bahwa Layanan berjalan pada port 6379. Kolom selector Layanan cocok dengan Pod pengikut Redis yang dibuat pada langkah sebelumnya.

   Terapkan manifes ke cluster Anda:

   kubectl apply -f redis-follower-service.yaml
   

2. Pastikan GKE membuat Layanan:

   kubectl get service
   

   Outputnya mirip dengan hal berikut ini:

   NAME           CLUSTER-IP      EXTERNAL-IP   PORT(S)    AGE
   kubernetes     10.51.240.1     <none>        443/TCP    1m
   redis-leader   10.51.242.233   <none>        6379/TCP   49s
   redis-follower 10.51.247.238   <none>        6379/TCP   3s
   

Menyiapkan frontend web aplikasi

Setelah Anda memiliki penyimpanan Redis untuk aplikasi Anda, mulai server web. Seperti pengikut Redis, frontend di-deploy menggunakan Deployment Kubernetes.

Aplikasi web menggunakan frontend PHP, yang dikonfigurasi untuk berkomunikasi dengan Layanan pengikut atau pemimpin Redis, bergantung pada apakah permintaannya adalah baca atau tulis. Frontend mengekspos antarmuka JSON dan menayangkan UI berbasis jQuery Ajax.

1. Manifes berikut menjelaskan Deployment untuk server web:

   apiVersion: apps/v1
   kind: Deployment
   metadata:
     name: frontend
   spec:
     replicas: 3
     selector:
       matchLabels:
           app: guestbook
           tier: frontend
     template:
       metadata:
         labels:
           app: guestbook
           tier: frontend
       spec:
         containers:
         - name: php-redis
           image: us-docker.pkg.dev/google-samples/containers/gke/gb-frontend:v5
           env:
           - name: GET_HOSTS_FROM
             value: "dns"
           resources:
             requests:
               cpu: 100m
               memory: 100Mi
           ports:
           - containerPort: 80

   File manifes menentukan variabel lingkungan GET_HOSTS_FROM=dns. Saat Anda memberikan konfigurasi ke aplikasi frontend web, aplikasi frontend akan menggunakan nama host redis-follower dan redis-leader untuk melakukan pencarian DNS. Pencarian DNS akan menemukan alamat IP Layanan yang Anda buat pada langkah sebelumnya. Konsep ini disebut penemuan layanan DNS.

   Terapkan manifes ke cluster Anda:

   kubectl apply -f frontend-deployment.yaml
   

2. Pastikan replika berjalan:

   kubectl get pods -l app=guestbook -l tier=frontend
   

   Outputnya mirip dengan hal berikut ini:

   NAME                        READY   STATUS    RESTARTS   AGE
   frontend-7b78458576-8kp8s   1/1     Running   0          37s
   frontend-7b78458576-gg86q   1/1     Running   0          37s
   frontend-7b78458576-hz87g   1/1     Running   0          37s
   

Menampakkan frontend pada alamat IP eksternal

Dengan konfigurasi saat ini, Layanan redis-follower dan redis-leader yang Anda buat pada langkah sebelumnya hanya dapat diakses dalam cluster GKE karena jenis default untuk Layanan adalah ClusterIP.

Layanan ClusterIP menyediakan satu alamat IP untuk kumpulan Pod tempat Service diarahkan. Alamat IP ini hanya dapat diakses di dalam cluster.

Agar Layanan frontend web dapat diakses secara eksternal, Anda dapat menentukan type: LoadBalancer atau type: NodePort di konfigurasi Layanan, bergantung pada persyaratan Anda.

Manifes berikut menjelaskan Layanan jenis LoadBalancer:

apiVersion: v1
kind: Service
metadata:
  name: frontend
  labels:
    app: guestbook
    tier: frontend
spec:
  type: LoadBalancer
  ports:
    # the port that this service should serve on
  - port: 80
  selector:
    app: guestbook
    tier: frontend

Deklarasi port di bagian ports menentukan port: 80 dan targetPort tidak ditentukan. Jika Anda menghapus properti targetPort, properti tersebut akan ditetapkan secara default ke nilai kolom port. Dalam hal ini, Layanan ini akan merutekan traffic eksternal pada port 80 ke port 80 container di Deployment frontend.

Terapkan manifes ke cluster Anda:

kubectl apply -f frontend-service.yaml

Saat Layanan frontend dibuat, GKE membuat load balancer dan alamat IP eksternal. Resource ini tunduk pada penagihan.

Kunjungi situs aplikasi

Untuk mengakses situs aplikasi, dapatkan alamat IP eksternal Layanan frontend:

kubectl get service frontend

Outputnya mirip dengan hal berikut ini:

NAME       CLUSTER-IP      EXTERNAL-IP        PORT(S)        AGE
frontend   10.51.242.136   109.197.92.229     80:32372/TCP   1m

Kolom EXTERNAL-IP mungkin menampilkan <pending> saat load balancer sedang dibuat. Proses ini mungkin memerlukan waktu beberapa menit. Jika Anda melihat error seperti Does not have minimum availability, tunggu beberapa menit. Error sementara ini terjadi karena GKE membuat ulang node untuk melakukan perubahan.

Salin alamat IP dan buka halaman di browser Anda:

Coba tambahkan beberapa entri dengan mengetik pesan, lalu mengklik Submit. Pesan yang Anda ketik akan muncul di frontend. Pesan ini menunjukkan bahwa data berhasil ditambahkan ke Redis melalui Layanan yang Anda buat.

Meningkatkan skala frontend web

Misalkan aplikasi Anda telah berjalan beberapa saat, dan tiba-tiba mendapatkan publisitas. Anda memutuskan untuk menambahkan lebih banyak server web ke frontend. Anda dapat melakukannya dengan meningkatkan jumlah Pod.

1. Tingkatkan jumlah Pod frontend:

   kubectl scale deployment frontend --replicas=5
   

   Outputnya mirip dengan hal berikut ini:

   deployment.extensions/frontend scaled
   

2. Pastikan jumlah replika yang berjalan:

   kubectl get pods
   

   Outputnya mirip dengan hal berikut ini:

   NAME                             READY     STATUS    RESTARTS   AGE
   frontend-88237173-3s3sc          1/1       Running   0          1s
   frontend-88237173-twgvn          1/1       Running   0          1s
   frontend-88237173-5p257          1/1       Running   0          23m
   frontend-88237173-84036          1/1       Running   0          23m
   frontend-88237173-j3rvr          1/1       Running   0          23m
   redis-leader-343230949-qfvrq     1/1       Running   0          54m
   redis-follower-132015689-dp23k   1/1       Running   0          37m
   redis-follower-132015689-xq9v0   1/1       Running   0          37m
   

   Anda dapat memperkecil jumlah Pod frontend menggunakan perintah yang sama, dengan mengganti 5 dengan 1.

Pembersihan

Agar tidak perlu membayar biaya pada akun Google Cloud Anda untuk resource yang digunakan dalam tutorial ini, hapus project yang berisi resource tersebut, atau simpan project dan hapus setiap resource.

Menghapus project

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.

Menghapus project Google Cloud:

gcloud projects delete PROJECT_ID

Menghapus resource satu per satu

Jika Anda telah menggunakan project yang sudah ada dan tidak ingin menghapusnya, hapus resource individual tersebut.

1. Hapus Layanan frontend:

   kubectl delete service frontend
   

2. Hapus cluster GKE:

   gcloud container clusters delete guestbook
   

Langkah selanjutnya

• Pelajari cara mengonfigurasi penskalaan otomatis Pod horizontal.
• Pelajari cara men-deploy WordPress di GKE dengan Persistent Disk dan Cloud SQL.
• Pelajari cara Mengonfigurasi nama domain dengan alamat IP statis.
• Pelajari tutorial Kubernetes Engine lainnya.