Cara install wordpress di Kubernetes Cluster

Pengantar

WordPress merupakan salah satu platform website paling populer di dunia yang digunakan untuk membuat blog, company profile, hingga aplikasi web. Dengan menjalankan WordPress di Kubernetes, kamu bisa mendapatkan sistem yang lebih fleksibel, scalable, dan siap menangani traffic tinggi.

Kubernetes memungkinkan aplikasi berjalan dalam container yang dapat di-scale secara otomatis, sehingga WordPress tidak hanya berjalan, tetapi juga dapat menyesuaikan diri dengan beban pengguna secara dinamis.

Pada artikel ini, kamu akan mempelajari cara install WordPress di Kubernetes cluster secara bertahap dan mudah dipahami, mulai dari setup database hingga akses ke website.

Persiapan

Sebelum memulai, pastikan:

Kubernetes cluster sudah berjalan
Memiliki akses kubectl
Memiliki 3 node (1 master, 2 worker)

Arsitektur yang Digunakan

Pada tutorial ini kita akan membuat:

1 Master (control-plane)
1 App Node (WordPress)

master : hanya untuk control-plane
worker1 & worker2 : aplikasi WordPress

Membuat Persistent Volume (PV)

Persistent Volume digunakan untuk menyediakan penyimpanan permanen di Kubernetes, sehingga data tidak hilang meskipun pod dihapus atau restart.

Buat file konfigurasi:
```
nano pv.yaml
```
Isi file dengan konfigurasi berikut:
```
apiVersion: v1
kind: PersistentVolume
metadata:
  name: wordpress-pv
spec:
  capacity:
    storage: 5Gi
  accessModes:
    - ReadWriteOnce
  hostPath:
    path: /mnt/data
```
Penjelasan:
- capacity : Menentukan ukuran storage (5GB)
- accessModes: ReadWriteOnce : Volume hanya bisa di-mount oleh satu node
- hostPath : Menggunakan direktori lokal di node (/mnt/data)
Pastikan direktori /mnt/data sudah ada di node:
```
sudo mkdir -p /mnt/data
```
Apply konfigurasi PV:
```
kubectl apply -f pv.yaml
```
Cek apakah PV berhasil dibuat:
```
kubectl get pv
```
Jika berhasil, status akan muncul sebagai Available.

Dengan PV ini, Anda dapat menyimpan data aplikasi seperti WordPress secara persisten sehingga tidak hilang meskipun pod di-restart.

Membuat Persistent Volume Claim (PVC Wordpres)

Setelah Persistent Volume (PV) dibuat, langkah selanjutnya adalah membuat Persistent Volume Claim (PVC). PVC digunakan oleh pod untuk “meminta” storage dari PV yang tersedia.

Buat file konfigurasi:
```
nano PVC-WordPress.yaml
```
Isi file dengan konfigurasi berikut:
```
apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: wordpress-pvc
spec:
  accessModes:
    - ReadWriteOnce
  resources:
    requests:
      storage: 5Gi
```
Penjelasan:
- accessModes: ReadWriteOnce : Volume hanya bisa digunakan oleh satu node
- requests.storage: 5Gi : Ukuran storage yang diminta harus sesuai atau lebih kecil dari PV
Apply konfigurasi PVC:
```
kubectl apply -f pvc.yaml
```
Cek status PVC:
```
kubectl get pvc
```
Jika berhasil, status akan menjadi Bound, yang berarti PVC sudah terhubung dengan PV.

Deploy MySQL

Setelah PVC dibuat, langkah selanjutnya adalah membuat deployment MySQL yang menggunakan storage tersebut agar data database tetap tersimpan meskipun pod restart.

Buat file konfigurasi:
```
nano mysql.yaml
```

Isi file dengan konfigurasi berikut:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: mysql
spec:
  replicas: 1
  selector:
    matchLabels:
      app: mysql
  template:
    metadata:
      labels:
        app: mysql
    spec:
      containers:
      - name: mysql
        image: mysql:5.7
        env:
        - name: MYSQL_ROOT_PASSWORD
          value: rootpass
        - name: MYSQL_DATABASE
          value: wordpress
        ports:
        - containerPort: 3306
        volumeMounts:
        - name: mysql-storage
          mountPath: /var/lib/mysql
      volumes:
      - name: mysql-storage
        persistentVolumeClaim:
          claimName: wordpress-pvc

Penjelasan:

image: mysql:5.7 : Menggunakan image MySQL versi 5.7
MYSQL_ROOT_PASSWORD : Password root database
MYSQL_DATABASE : Database otomatis dibuat saat container berjalan
volumeMounts : Mount storage ke direktori /var/lib/mysql
PVC (wordpress-pvc) : Digunakan untuk menyimpan data secara persisten

Apply konfigurasi:
```
kubectl apply -f mysql.yaml
```
Cek apakah pod MySQL berjalan:
```
kubectl get pods
```
Jika berhasil, pod MySQL akan berstatus Running.

Service MySQL

Setelah deployment MySQL berjalan, langkah selanjutnya adalah membuat Service agar MySQL dapat diakses oleh pod lain (misalnya WordPress) melalui jaringan internal Kubernetes.

Buat file konfigurasi:
```
nano mysql-service.yaml
```
Isi file dengan konfigurasi berikut:
```
apiVersion: v1
kind: Service
metadata:
  name: mysql
spec:
  ports:
  - port: 3306
  selector:
    app: mysql
```
Penjelasan:
- kind: Service : Digunakan untuk expose aplikasi di dalam cluster
- name: mysql : Nama service (akan digunakan sebagai hostname)
- port: 3306 : Port MySQL
- selector: app: mysql : Menghubungkan service dengan pod MySQL
Dengan service ini, MySQL dapat diakses menggunakan hostname:
```
mysql:3306
```
Apply konfigurasi:
```
kubectl apply -f mysql-service.yaml
```
Cek service:
```
kubectl get svc
```
Service ini bersifat ClusterIP (default), sehingga hanya dapat diakses dari dalam cluster Kubernetes.

Deploy WordPress

Setelah MySQL dan service sudah berjalan, langkah selanjutnya adalah membuat deployment WordPress yang akan terhubung ke database MySQL.

Buat file konfigurasi:
```
nano wordpress.yaml
```

Isi file dengan konfigurasi berikut:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: wordpress
spec:
  replicas: 1
  selector:
    matchLabels:
      app: wordpress
  template:
    metadata:
      labels:
        app: wordpress
    spec:
      containers:
      - name: wordpress
        image: wordpress:latest
        env:
        - name: WORDPRESS_DB_HOST
          value: mysql:3306
        - name: WORDPRESS_DB_USER
          value: root
        - name: WORDPRESS_DB_PASSWORD
          value: rootpass
        - name: WORDPRESS_DB_NAME
          value: wordpress
        ports:
        - containerPort: 80

Penjelasan:

image: wordpress:latest : Menggunakan image WordPress terbaru
WORDPRESS_DB_HOST : Host database (menggunakan nama service: mysql)
WORDPRESS_DB_PASSWORD : Password database (harus sama dengan MySQL)
containerPort: 80 : Port WordPress di dalam container

Apply konfigurasi:
```
kubectl apply -f wordpress.yaml
```
Cek apakah pod WordPress berjalan:
```
kubectl get pods
```
Jika berhasil, pod WordPress akan berstatus Running dan siap diakses melalui service.

Service WordPress

Setelah deployment WordPress berjalan, langkah selanjutnya adalah membuat Service agar WordPress dapat diakses dari luar cluster (browser).

Buat file konfigurasi:
```
nano wordpress-service.yaml
```
Isi file dengan konfigurasi berikut:
```
apiVersion: v1
kind: Service
metadata:
  name: wordpress
spec:
  type: NodePort
  selector:
    app: wordpress
  ports:
  - port: 80
    nodePort: 30007
```
Penjelasan:
- type: NodePort : Service dapat diakses dari luar cluster
- port: 80 : Port service di dalam cluster
- nodePort: 30007 : Port yang dibuka di node (range: 30000–32767)
- selector: app: wordpress : Menghubungkan service dengan pod WordPress
Apply konfigurasi:
```
kubectl apply -f wordpress-service.yaml
```
Cek service:
```
kubectl get svc
```
Untuk mengakses WordPress, gunakan:
```
http://IP_SERVER:30007
```
Output :

Jika berhasil, halaman instalasi WordPress akan muncul di browser.

Tips Tambahan (Best Practice)

Pisahkan Storage : Gunakan PVC terpisah untuk MySQL (database) dan WordPress (media/file)
Tambahkan Resource Limit : Batasi penggunaan CPU dan memory agar pod lebih stabil
Gunakan HPA : Aktifkan autoscaling agar pod menyesuaikan beban traffic
Gunakan Ingress : Untuk production, gunakan domain + SSL (HTTPS), bukan NodePort
Backup Database : Lakukan backup MySQL secara rutin untuk keamanan data
Gunakan Helm : Mempermudah deployment dan manajemen aplikasi secara otomatis

Kesimpulan

Dengan mengikuti prosedur di atas, Anda telah berhasil melakukan deployment WordPress di Kubernetes cluster secara mandiri, yang mencakup pengaturan penyimpanan, database, dan akses ke aplikasi melalui jaringan.

Meskipun konfigurasi ini masih ditujukan untuk penggunaan lab, ide-ide yang digunakan sudah menunjukkan bagaimana aplikasi modern dijalankan di lingkungan Kubernetes. Dengan memahami alur ini, Anda akan lebih siap untuk mengembangkan sistem yang lebih kompleks, scalable, dan siap produksi.

Selanjutnya, Anda dapat melanjutkan implementasi domain menggunakan Ingress, menambah SSL untuk keamanan, dan mengoptimalkan kinerja dengan monitoring dan autoscaling bisa di cek disini.

Semoga artikel ini memberi Anda pemahaman yang lebih baik tentang cara Kubernetes beroperasi secara lebih praktis dan aplikatif.