Cara Membuat Docker Image Aplikasi PHP dan menjalankan di Kubernetes Cluster

Pengantar

Saat ini Docker dan Kubernetes menjadi teknologi yang paling banyak digunakan dalam proses deployment aplikasi modern, di mana Docker digunakan untuk mengemas aplikasi menjadi container yang ringan dan portable, sementara Kubernetes berfungsi untuk mengelola container dalam skala besar secara otomatis. Bagi developer maupun administrator server, memahami cara membuat Docker image aplikasi PHP lalu menjalankannya di Kubernetes merupakan skill penting, terutama untuk kebutuhan deployment modern dan cloud native. Pada artikel ini akan dibahas cara membuat Docker image aplikasi PHP, push image ke Docker Hub, menjalankan aplikasi di Kubernetes Cluster, membuat Deployment dan Service Kubernetes, serta menggunakan Horizontal Pod Autoscaler (HPA).

Mengapa Menggunakan Docker dan Kubernetes?

Sebelum praktik, penting untuk memahami manfaat penggunaan Docker dan Kubernetes. Docker membantu aplikasi berjalan secara konsisten di berbagai server dengan menghilangkan kebutuhan instalasi dependency secara manual, menjaga environment aplikasi tetap seragam, mempercepat proses deployment, memudahkan pemindahan aplikasi antar server, serta mendukung workflow CI/CD modern. Sementara itu, Kubernetes berperan dalam mengelola container dalam jumlah besar secara otomatis dengan fitur auto scaling, high availability, self-healing pod yang dapat memperbaiki container secara otomatis jika terjadi kegagalan, rolling update tanpa downtime, serta kemudahan dalam pengelolaan aplikasi di dalam sebuah cluster.

Topologi Kubernetes Cluster

Pada tutorial ini digunakan cluster sederhana:

Keterangan:
Master Node bertugas mengatur cluster
Worker Node menjalankan aplikasi container

Prasyarat

Disarankan setiap node memiliki:

Ubuntu 24.04
RAM minimal 4 GB
CPU 2 Core
Docker Installed
Internet Connection
Kubernetes Cluster Sudah Berjalan
Docker Sudah Terinstall
Memiliki Akun Docker Hub

Struktur Project PHP

Contoh struktur project:

php-app/
├── Dockerfile
├── deployment.yaml
├── service.yaml
├── hpa.yaml
└── index.php

Menggunakan Database cPanel

Jika menggunakan database dari cPanel hosting, maka akses Remote MySQL perlu diaktifkan agar Kubernetes dapat terhubung ke database external.

Aktifkan Remote MySQL
Masuk ke menu berikut pada cPanel:
```
cPanel → Remote MySQL
```
Fungsi:
- Mengizinkan server external mengakses MySQL
- Membuka akses database dari Kubernetes node
- Diperlukan agar aplikasi container dapat terhubung ke database hosting
Tambahkan IP Kubernetes Node
Masukkan IP public node Kubernetes:
```
103.xxx.xxx.xxx
```
Penjelasan:
- IP ini merupakan IP node Kubernetes yang digunakan aplikasi
- Jika menggunakan multi node, tambahkan seluruh IP node yang diperlukan
- Tanpa whitelist IP, koneksi database akan ditolak
Keterangan:
Pastikan firewall hosting dan provider database mengizinkan akses MySQL dari IP Kubernetes node.

SQL Database Sederhana

Setelah MySQL berhasil dikonfigurasi, langkah berikutnya adalah membuat database dan tabel yang digunakan aplikasi.

Login ke MySQL
Gunakan perintah berikut:
```
mysql -u root -p
```
Fungsi:
- Masuk ke console MySQL sebagai user root
- Digunakan untuk administrasi database
- Memungkinkan pembuatan database dan tabel
Masukkan password root MySQL saat diminta.
Buat Database
Gunakan query berikut:
```
CREATE DATABASE sekolah;
```
Fungsi:
- Membuat database baru bernama sekolah
- Digunakan sebagai tempat penyimpanan data aplikasi
Gunakan Database
Gunakan query berikut:
```
USE sekolah;
```
Fungsi:
- Memilih database aktif
- Semua query berikutnya akan dijalankan pada database sekolah
Buat Tabel
Gunakan query berikut:
```
CREATE TABLE siswa (
  nis INT AUTO_INCREMENT PRIMARY KEY,
  nama VARCHAR(100),
  alamat VARCHAR(100)
);
```
Penjelasan Struktur Tabel:
- nis
  Primary key otomatis bertambah.
- nama
  Menyimpan nama siswa.
- alamat
  Menyimpan alamat siswa.
Keterangan:
Tabel digunakan untuk menyimpan data aplikasi dalam bentuk terstruktur.
Insert Data
Gunakan query berikut:
```
INSERT INTO siswa(nama,alamat)
VALUES
('Robert','Yogyakarta'),
('Budi','Jakarta'),
('Andi','Bandung');
```
Fungsi:
- Menambahkan data awal ke tabel siswa
- Digunakan untuk testing aplikasi dan koneksi database
Contoh data yang berhasil masuk:
```
Robert  | Yogyakarta
Budi    | Jakarta
Andi    | Bandung
```
Keterangan:
Data sample ini dapat digunakan untuk pengujian aplikasi PHP yang terhubung ke database MySQL.

Membuat Aplikasi PHP Sederhana

Buat folder berikut didalam master node k8s:
```
mkdir php-app
```
Masuk kedalam folder pphp-app
```
cd php-app
```
Buat file:
```
nano index.php
```
Isi dengan kode berikut:
Save
Klik CTRL X + Y

Membuat Dockerfile Aplikasi PHP

Dockerfile digunakan untuk membuat Docker image aplikasi.

Buat file:
```
nano Dockerfile
```

Isi konfigurasi berikut:

FROM webdevops/php-nginx:8.3

COPY index.php /app/index.php

Build Docker Image PHP

Masuk ke folder project:
```
cd php-app
```
Build Docker image:
```
docker build -t php-app:v1 .
```
Catatan :
Tunggu proses build hingga selesai.

Verifikasi Docker Image

Cek image yang berhasil dibuat:
```
 docker images
```

Contoh output:

REPOSITORY   TAG   IMAGE ID   SIZE
php-app      v1    xxxxxxx    500MB

Push Docker Image ke Docker Hub

Setelah Docker image berhasil dibuat, langkah berikutnya adalah upload image ke Docker Hub agar dapat digunakan oleh Kubernetes.

Login ke Docker Hub
Gunakan perintah berikut:
```
docker login
```
Fungsi:
- Login ke akun Docker Hub
- Digunakan sebelum melakukan push image
- Memungkinkan upload image ke repository Docker Hub
Masukkan Token yang muncul kedalam link docker hub
Gunakan perintah berikut:
```
docker tag php-app:v1 username/php-app:v1
```
Fungsi:
- Memberikan nama repository Docker Hub pada image lokal
- Mempersiapkan image sebelum upload
- username harus diganti dengan username Docker Hub
Penjelasan:
- php-app:v1
  Image lokal yang sudah dibuat sebelumnya.
- username/php-app:v1
  Nama image tujuan di Docker Hub.
Push Image ke Docker Hub
Gunakan perintah berikut:
```
docker push username/php-app:v1
```
Fungsi:
- Mengupload Docker image ke Docker Hub
- Membuat image dapat diakses Kubernetes
- Digunakan untuk deployment multi node
Jika berhasil biasanya muncul proses upload layer image.

Keterangan:
Setelah image berhasil di-push ke Docker Hub, Kubernetes dapat melakukan pull image secara otomatis pada worker node.

Membuat Deployment Kubernetes

Buat deployment Kubernetes untuk aplikasi PHP yang terhubung ke database external dan memiliki resource limit serta health check.

Buat File Deployment
Gunakan perintah berikut:
```
nano deployment.yaml
```

Isi Konfigurasi Deployment

Isi file dengan konfigurasi berikut:

apiVersion: apps/v1
kind: Deployment

metadata:
  name: app-sederhana

spec:
  replicas: 2

  selector:
    matchLabels:
      app: app-sederhana

  template:
    metadata:
      labels:
        app: app-sederhana

    spec:
      containers:
      - name: app-sederhana
        image: username/php-app:v1

        imagePullPolicy: Always

        ports:
        - containerPort: 80

        env:
        - name: DB_HOST
          value: "103.xxx.xxx.xxx"

        - name: DB_USER
          value: "k8suser"

        - name: DB_PASS
          value: "StrongPassword"

        - name: DB_NAME
          value: "sekolah"

        resources:
          requests:
            cpu: 100m
            memory: 128Mi

          limits:
            cpu: 200m
            memory: 256Mi

        livenessProbe:
          httpGet:
            path: /
            port: 80
          initialDelaySeconds: 10
          periodSeconds: 5

        readinessProbe:
          httpGet:
            path: /
            port: 80
          initialDelaySeconds: 5
          periodSeconds: 3

Penjelasan Konfigurasi:

replicas: 2
Menjalankan 2 pod aplikasi.
imagePullPolicy: Always
Memastikan Kubernetes selalu menarik image terbaru dari Docker Hub.
env:
Digunakan untuk konfigurasi koneksi database external.
resources.requests
Menentukan minimal resource CPU dan memory untuk pod.
resources.limits
Menentukan batas maksimal resource pod.
livenessProbe
Digunakan untuk mengecek apakah aplikasi masih hidup.
readinessProbe
Digunakan untuk memastikan aplikasi siap menerima traffic.

Keterangan:
Health check sangat penting agar Kubernetes dapat mendeteksi aplikasi yang crash atau belum siap digunakan.

Deploy Aplikasi
Gunakan perintah berikut:
```
kubectl apply -f deployment.yaml
```
Fungsi:
- Membuat deployment Kubernetes
- Menjalankan pod aplikasi
- Menerapkan seluruh konfigurasi deployment
Cek Pod
Gunakan perintah berikut:
```
kubectl get pods -o wide
```
Fungsi:
- Melihat status pod
- Melihat node tempat pod berjalan
- Memastikan deployment berhasil
Contoh informasi yang muncul:
```
NAME                              READY   STATUS    NODE
app-sederhana-xxxxx               1/1     Running   worker1
app-sederhana-yyyyy               1/1     Running   worker2
```
Keterangan:
Jika status pod Running dan READY 1/1, berarti aplikasi berhasil berjalan normal di Kubernetes.

Membuat Service Kubernetes

Agar aplikasi dapat diakses dari luar cluster Kubernetes, kita perlu membuat Service Kubernetes.

Buat File Service
Gunakan perintah berikut:
```
nano service.yaml
```
Isi Konfigurasi Service
Isi file dengan konfigurasi berikut:
```
apiVersion: v1
kind: Service

metadata:
  name: php-app-service

spec:
  selector:
    app: php-app

  ports:
  - protocol: TCP
    port: 80
    targetPort: 80
    nodePort: 30080

  type: NodePort
```
Penjelasan Konfigurasi:
- selector:
  Digunakan untuk menghubungkan service dengan pod yang memiliki label app: php-app.
- port: 80
  Port service yang digunakan di dalam cluster Kubernetes.
- targetPort: 80
  Port aplikasi pada container.
- nodePort: 30080
  Port yang dibuka pada node Kubernetes untuk akses dari luar cluster.
- type: NodePort
  Membuka akses aplikasi melalui IP node Kubernetes.
Keterangan:
Service Kubernetes digunakan sebagai load balancer internal agar aplikasi dapat diakses secara stabil meskipun pod berubah.
Deploy Service
Gunakan perintah berikut:
```
kubectl apply -f service.yaml
```
Fungsi:
- Membuat service Kubernetes
- Membuka akses aplikasi ke luar cluster
- Menghubungkan traffic ke pod aplikasi
Cek Service
Gunakan perintah berikut:
```
kubectl get svc
```
Contoh output:
```
NAME               TYPE       CLUSTER-IP      PORT(S)
php-app-service    NodePort   10.96.x.x       80:30080/TCP
```
Penjelasan Output:
- TYPE NodePort
  Service dapat diakses dari luar cluster.
- CLUSTER-IP
  IP internal service di Kubernetes.
- 80:30080/TCP
  Port internal service dan port external node.
Keterangan:
Aplikasi dapat diakses menggunakan IP node Kubernetes dan port NodePort yang telah ditentukan.

Mengakses Aplikasi Kubernetes

Setelah Service Kubernetes berhasil dibuat, aplikasi dapat diakses melalui browser menggunakan IP node Kubernetes dan port NodePort.

Akses Aplikasi
Buka browser kemudian akses:
```
http://IP_NODE:30080
```
Contoh:
```
http://103.151.141.102:30080
```
Penjelasan:
- IP_NODE
  Merupakan IP server Kubernetes node.
- 30080
  Merupakan NodePort yang dibuka oleh Service Kubernetes.
Cara Kerja NodePort
Karena menggunakan tipe service NodePort, aplikasi dapat diakses melalui IP node Kubernetes mana saja.

Karakteristik NodePort:
- Membuka port langsung pada node Kubernetes
- Traffic akan diteruskan ke pod aplikasi
- Dapat diakses menggunakan IP public atau private node
- Kubernetes otomatis melakukan load balancing antar pod
Contoh akses:
```
http://worker1-ip:30080
http://worker2-ip:30080
```
Keterangan:
NodePort cocok digunakan untuk lab, testing, atau akses sederhana tanpa Ingress maupun Load Balancer external.

Membuat Horizontal Pod Autoscaler (HPA)

Horizontal Pod Autoscaler (HPA) digunakan untuk melakukan auto scaling pod berdasarkan penggunaan resource seperti CPU.

Buat File HPA
Gunakan perintah berikut:
```
nano hpa.yaml
```
Isi Konfigurasi HPA
Isi file dengan konfigurasi berikut:
```
apiVersion: autoscaling/v2
kind: HorizontalPodAutoscaler

metadata:
  name: php-app-hpa

spec:
  scaleTargetRef:
    apiVersion: apps/v1
    kind: Deployment
    name: php-app

  minReplicas: 1
  maxReplicas: 5

  metrics:
  - type: Resource

    resource:
      name: cpu

      target:
        type: Utilization
        averageUtilization: 50
```
Penjelasan Konfigurasi:
- scaleTargetRef
  Menentukan deployment yang akan di-auto scaling.
- minReplicas: 1
  Jumlah minimal pod yang selalu berjalan.
- maxReplicas: 5
  Jumlah maksimal pod yang dapat dibuat otomatis.
- averageUtilization: 50
  Auto scaling aktif ketika penggunaan CPU rata-rata mencapai 50%.
- metrics.resource.name: cpu
  Menggunakan CPU sebagai parameter scaling.
Keterangan:
HPA membantu Kubernetes menambah atau mengurangi jumlah pod secara otomatis sesuai beban aplikasi.
Deploy HPA
Gunakan perintah berikut:
```
kubectl apply -f hpa.yaml
```
Fungsi:
- Membuat Horizontal Pod Autoscaler
- Mengaktifkan auto scaling deployment
- Memonitor penggunaan CPU pod
Cek Status HPA
Gunakan perintah berikut:
```
kubectl get hpa
```
Fungsi:
- Melihat status auto scaling
- Melihat penggunaan CPU saat ini
- Melihat jumlah replica aktif
Contoh informasi yang muncul:
```
NAME          REFERENCE            TARGETS   MINPODS   MAXPODS   REPLICAS
php-app-hpa   Deployment/php-app   20%/50%   1         5         2
```
Keterangan:
Jika penggunaan CPU meningkat melewati threshold, Kubernetes otomatis menambah pod. Jika beban turun, pod akan dikurangi kembali.

Verifikasi Resource Kubernetes

Untuk menguji kemampuan auto scaling Kubernetes, kita dapat melakukan load testing pada aplikasi menggunakan Apache Benchmark.

Install Tools Benchmark
Gunakan perintah berikut:
```
apt install apache2-utils -y
```
Fungsi:
- Menginstall tools Apache Benchmark (ab)
- Digunakan untuk simulasi traffic HTTP
- Membantu pengujian performa aplikasi
Lakukan Load Testing
Gunakan perintah berikut:
```
ab -n 1000 -c 100 http://IP_NODE:30080/
```
Penjelasan Parameter:
- -n 1000
  Total request yang dikirim sebanyak 1000 request.
- -c 100
  Mengirim 100 request secara concurrent atau bersamaan.
- http://IP_NODE:30080/
  Alamat aplikasi Kubernetes yang diuji.
Fungsi:
- Meningkatkan beban CPU aplikasi
- Menguji performa deployment Kubernetes
- Memicu Horizontal Pod Autoscaler (HPA)
Keterangan:
Semakin besar nilai concurrent request, semakin tinggi beban resource yang digunakan pod aplikasi.
Monitor HPA
Gunakan perintah berikut:
```
kubectl get hpa -w
```
Fungsi:
- Melihat perubahan penggunaan CPU secara realtime
- Melihat proses auto scaling pod
- Parameter -w digunakan untuk monitoring live
Contoh informasi yang muncul:
```
NAME          REFERENCE            TARGETS   MINPODS   MAXPODS   REPLICAS
php-app-hpa   Deployment/php-app   85%/50%   1         5         4
```
Analisa:
- CPU usage mencapai 85%
- Target HPA hanya 50%
- Kubernetes otomatis menambah replica pod menjadi 4
Monitor Pod
Gunakan perintah berikut:
```
kubectl get pods -w
```
Fungsi:
- Melihat pod baru yang dibuat otomatis
- Memonitor status pod secara realtime
- Memastikan auto scaling berjalan normal
Contoh hasil:
```
php-app-xxxxx   Running
php-app-yyyyy   Running
php-app-zzzzz   Running
```
Keterangan:
Jika penggunaan CPU meningkat melewati threshold HPA, Kubernetes akan otomatis menambah jumlah pod untuk menjaga performa aplikasi tetap stabil.

Kesimpulan

proses deployment aplikasi PHP sederhana menggunakan Docker dan Kubernetes secara end-to-end. Aplikasi terlebih dahulu dikemas menjadi Docker image, kemudian di-push ke Docker Hub agar dapat digunakan oleh Kubernetes cluster. Selanjutnya aplikasi dijalankan menggunakan Deployment dan Service Kubernetes sehingga dapat diakses melalui NodePort dari seluruh worker node. Selain itu, aplikasi juga berhasil terhubung dengan database MySQL external menggunakan environment variable pada Deployment. Proses rolling update, restart deployment, multi-node scheduling, load balancing service, hingga Horizontal Pod Autoscaler (HPA) juga berhasil diuji menggunakan Apache Benchmark sebagai simulasi trafik. Dengan implementasi ini, deployment aplikasi menjadi lebih modern, scalable, portable, dan mudah dikelola pada environment Kubernetes.