Membuat aplikasi web multi-tingkat dengan Redis dan PHP


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:

Arsitektur cluster GKE

Biaya

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

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
  4. Buat atau pilih project Google Cloud.

    • 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. Aktifkan API GKE:

    gcloud services enable container.googleapis.com
  7. Menginstal Google Cloud CLI.
  8. Untuk initialize gcloud CLI, jalankan perintah berikut:

    gcloud init
  9. Buat atau pilih project Google Cloud.

    • 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. Aktifkan API GKE:

    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:

  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:

Aplikasi web yang berjalan di GKE

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

    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