Membuat aplikasi web multi-tingkat dengan Redis dan PHP

Autopilot Standard

---

Tutorial ini menunjukkan cara mem-build 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 replika (pengikut).

Contoh ini menjelaskan konsep Kubernetes berikut:

• Konfigurasi deklaratif menggunakan file manifes YAML
• Deployment, yaitu resource Kubernetes yang menentukan konfigurasi untuk serangkaian Pod yang direplikasi
• Service untuk membuat load balancer internal dan eksternal bagi 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 menunjukkan ringkasan arsitektur cluster yang Anda buat dengan menyelesaikan tujuan berikut:

Biaya

Dalam dokumen ini, Anda akan 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. Sign in to your Google Cloud account. If you're new to Google Cloud, create an account to evaluate how our products perform in real-world scenarios. New customers also get $300 in free credits to run, test, and deploy workloads.
2. Install the Google Cloud CLI.

3. To initialize the gcloud CLI, run the following command:

   gcloud init

   Note: If you installed the gcloud CLI previously, make sure you have the latest version by running gcloud components update.

4. Create or select a Google Cloud project.

   Note: If you don't plan to keep the resources that you create in this procedure, create a project instead of selecting an existing project. After you finish these steps, you can delete the project, removing all resources associated with the project.

   • Create a Google Cloud project:

     gcloud projects create PROJECT_ID

     Replace PROJECT_ID with a name for the Google Cloud project you are creating.

   • Select the Google Cloud project that you created:

     gcloud config set project PROJECT_ID

     Replace PROJECT_ID with your Google Cloud project name.

5. Make sure that billing is enabled for your Google Cloud project.

6. Enable the GKE API:

   gcloud services enable container.googleapis.com

7. Install the Google Cloud CLI.

8. To initialize the gcloud CLI, run the following command:

   gcloud init

   Note: If you installed the gcloud CLI previously, make sure you have the latest version by running gcloud components update.

9. Create or select a Google Cloud project.

   Note: If you don't plan to keep the resources that you create in this procedure, create a project instead of selecting an existing project. After you finish these steps, you can delete the project, removing all resources associated with the project.

   • Create a Google Cloud project:

     gcloud projects create PROJECT_ID

     Replace PROJECT_ID with a name for the Google Cloud project you are creating.

   • Select the Google Cloud project that you created:

     gcloud config set project PROJECT_ID

     Replace PROJECT_ID with your Google Cloud project name.

10. Make sure that billing is enabled for your Google Cloud project.

11. Enable the GKE API:

    gcloud services enable container.googleapis.com

Menyiapkan lingkungan

Untuk menyiapkan lingkungan Anda, 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 GKE Autopilot atau Standard:

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 menggunakan Redis untuk menyimpan datanya. Aplikasi menulis datanya ke instance leader Redis dan membaca data dari beberapa instance follower Redis.

1. Manifes berikut menjelaskan Deployment Kubernetes yang menjalankan satu replika Pod leader 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 agar STATUS berubah dari Pending menjadi Running.

Membuat Layanan leader Redis

Aplikasi web perlu berkomunikasi dengan leader 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 memungkinkan akses ke Pod. Saat membuat Service, Anda mendeskripsikan Pod yang akan di-proxy berdasarkan label Pod.

1. Manifes berikut menjelaskan Service untuk leader 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 menyertakan sekumpulan pemilih label. Label ini cocok dengan kumpulan label yang di-deploy di langkah sebelumnya. Oleh karena itu, Service ini merutekan traffic jaringan ke Pod leader 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 merutekan 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 follower 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 follower 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 bahwa kedua replika follower 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 agar STATUS berubah dari Pending menjadi Running.

Membuat Layanan follower Redis

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

1. Manifes berikut menjelaskan Layanan untuk follower 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 Service yang berjalan di port 6379. Kolom selector Service sesuai dengan Pod follower 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, mulai server web. Seperti follower Redis, frontend di-deploy menggunakan Deployment Kubernetes.

Aplikasi web menggunakan frontend PHP, yang dikonfigurasi untuk berkomunikasi dengan Layanan follower atau leader Redis, bergantung pada apakah permintaan tersebut 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 menemukan alamat IP Service 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, Service redis-follower dan redis-leader yang Anda buat di langkah sebelumnya hanya dapat diakses dalam cluster GKE karena jenis default untuk Service adalah ClusterIP.

Layanan ClusterIP menyediakan satu alamat IP untuk kumpulan Pod tempat Layanan mengarah. 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 dalam konfigurasi Layanan, bergantung pada persyaratan Anda.

Manifes berikut menjelaskan Service 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, setelan default-nya ditetapkan ke nilai kolom port. Dalam hal ini, Service ini merutekan traffic eksternal di port 80 ke port 80 container di Deployment frontend.

Terapkan manifes ke cluster Anda:

kubectl apply -f frontend-service.yaml

Saat Service frontend dibuat, GKE akan membuat load balancer dan alamat IP eksternal. Resource ini dikenai biaya.

Buka 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 klik 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

Anggap aplikasi Anda telah berjalan selama beberapa waktu, dan tiba-tiba popularitasnya melonjak. 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 menskalakan jumlah Pod frontend dengan menggunakan perintah yang sama, 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 beberapa arsitektur, tutorial atau panduan memulai, dengan menggunakan kembali project dapat membantu Anda agar tidak melampaui batas kuota project.

Delete a Google Cloud project:

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.