Membuat aplikasi web multi-tingkat dengan Redis dan PHP

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.