Cara install wordpress di Kubernetes Cluster dengan PVC dan Storage terpisah

Pengantar

Dalam implementasi Kubernetes modern, aplikasi seperti WordPress sebaiknya tidak hanya dijalankan sebagai container biasa, tetapi juga dilengkapi dengan sistem penyimpanan persisten yang terpisah dari pod karena pod bersifat ephemeral sehingga data berisiko hilang saat terjadi restart atau perpindahan node. Dengan memanfaatkan PersistentVolumeClaim atau PVC dan storage terpisah seperti Longhorn, data penting WordPress seperti media upload, plugin, tema, dan konfigurasi akan tetap aman meskipun terjadi redeploy. Pada tutorial ini kita akan mempelajari cara menginstal WordPress di Kubernetes menggunakan komponen seperti Deployment, Service, PVC, storage terpisah berbasis Longhorn, serta Ingress untuk akses domain sehingga cocok digunakan untuk pembelajaran Kubernetes storage, kebutuhan lab DevOps, implementasi pada VPS Kubernetes, maupun simulasi high availability sederhana.

Apa Itu PVC ?

PVC digunakan agar data aplikasi tetap tersimpan meskipun pod mengalami restart, reschedule, atau redeploy.

Contoh data WordPress yang disimpan:

Upload gambar dan media
Plugin
Theme
File konfigurasi

Tanpa PVC, seluruh data tersebut akan hilang ketika pod berhenti atau berpindah node karena sifat pod yang ephemeral. Hal ini dapat menyebabkan kehilangan data penting seperti konten website, konfigurasi, maupun aset media yang sudah diunggah.

Arsitektur

Persiapan

Sebelum memulai, pastikan:

Kubernetes cluster sudah berjalan
Ingress NGINX sudah terinstall
Domain/subdomain sudah diarahkan ke IP server
Helm Sudah terinstall
External Database

Install Longhorn

Sebelum menggunakan PVC untuk WordPress, kita perlu menyiapkan storage backend terlebih dahulu. Pada tutorial ini, kita akan menggunakan Longhorn sebagai distributed storage untuk Kubernetes.

Persiapan Sebelum Install Longhorn
Longhorn membutuhkan package iSCSI pada setiap node Kubernetes.
Jalankan perintah berikut di semua node:
```
apt update
apt install -y open-iscsi
```
Enable service iSCSI:
```
systemctl enable iscsid
systemctl start iscsid
```
Cek status service:
```
systemctl status iscsid
```
Pastikan status:
```
active (running)
```
Install Longhorn

Buat namespace Longhorn:
```
kubectl create namespace longhorn-system
```
Install Longhorn:
```
kubectl apply -f https://raw.githubusercontent.com/longhorn/longhorn/master/deploy/longhorn.yaml
```
Perintah ini akan menginstall seluruh komponen Longhorn seperti manager, driver, UI, dan engine storage.
Cek Status Pod Longhorn
```
kubectl get pods -n longhorn-system -w
```
Tunggu hingga semua pod berstatus:
```
Running
```
Cek StorageClass Longhorn

Jalankan perintah berikut:
```
kubectl get storageclass
```
Biasanya akan muncul StorageClass dengan nama:
```
longhorn
```
StorageClass ini nantinya digunakan oleh PVC WordPress dan aplikasi lainnya.
Verifikasi Longhorn

Cek semua pod Longhorn:
```
kubectl get pods -n longhorn-system
```
Cek service Longhorn:
```
kubectl get svc -n longhorn-system
```
Cek PVC yang menggunakan Longhorn:
```
kubectl get pvc
```
Keterangan:
Jika PVC berhasil dibuat dan status pod Longhorn berjalan normal, berarti Longhorn sudah berhasil digunakan sebagai storage backend Kubernetes.

Membuat PVC WordPress

Membuat Namespace WordPress
Namespace digunakan untuk memisahkan resource WordPress dari aplikasi lain di dalam cluster Kubernetes.
```
kubectl create namespace wordpress
```
Membuat PersistentVolumeClaim (PVC)
PVC digunakan untuk menyediakan persistent storage agar data WordPress tetap tersimpan meskipun pod restart atau berpindah node.
Buat file konfigurasi:
```
nano wordpress-pvc.yaml
```
Isi konfigurasi berikut:
```
kind: PersistentVolumeClaim

metadata:
  name: wordpress-pvc
  namespace: wordpress

spec:
  accessModes:
    - ReadWriteMany

  storageClassName: longhorn

  resources:
    requests:
      storage: 10Gi
```
Penjelasan:
- name adalah nama PVC
- namespace menentukan PVC dibuat di namespace wordpress
- accessModes: ReadWriteMany memungkinkan volume diakses banyak pod sekaligus
- storageClassName: longhorn menggunakan StorageClass dari Longhorn
- storage: 10Gi menentukan kapasitas storage yang diminta
Apply PVC
```
kubectl apply -f wordpress-pvc.yaml
```
Cek Status PVC
```
kubectl get pvc -n wordpress
```
Pastikan status PVC menjadi Bound, yang berarti storage berhasil terhubung dengan Longhorn.

Membuat Deployment WordPress

Membuat Deployment WordPress
Deployment digunakan untuk menjalankan container WordPress di Kubernetes sekaligus menghubungkannya dengan database dan persistent storage.

Buat file konfigurasi:

nano wordpress-deployment.yaml

Isi konfigurasi berikut:

apiVersion: apps/v1
      affinity:
        podAntiAffinity:
          requiredDuringSchedulingIgnoredDuringExecution:
          - labelSelector:
              matchExpressions:
              - key: app
                operator: In
                values:
                - wordpress
            topologyKey: kubernetes.io/hostname

      containers:
      - name: wordpress
        image: wordpress:latest

        ports:
        - containerPort: 80

        env:
        - name: WORDPRESS_DB_HOST
          value: db.example.com:3306

        - name: WORDPRESS_DB_USER
          value: wordpress

        - name: WORDPRESS_DB_PASSWORD
          value: password

        - name: WORDPRESS_DB_NAME
          value: wordpress

        resources:
          requests:
            memory: "256Mi"
            cpu: "250m"

          limits:
            memory: "512Mi"
            cpu: "500m"

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

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

        volumeMounts:
        - name: wordpress-storage
          mountPath: /var/www/html/wp-content

      volumes:
      - name: wordpress-storage
        persistentVolumeClaim:
          claimName: wordpress-pvc

Penjelasan:

replicas: 2 menjalankan dua pod WordPress
image: wordpress:latest menggunakan image WordPress terbaru
containerPort: 80 membuka port HTTP WordPress
WORDPRESS_DB_HOST : adalah hostname service MySQL
WORDPRESS_DB_USER : username database WordPress
WORDPRESS_DB_PASSWORD : password database
WORDPRESS_DB_NAME : nama database yang digunakan
volumeMounts : digunakan untuk mount storage ke direktori WordPress
claimName: wordpress-pvc menggunakan PVC yang sebelumnya dibuat

Catatan:
Jika menggunakan database external, pastikan konfigurasi DB_HOST, DB_USER, DB_PASSWORD, dan DB_NAME sudah sesuai dengan informasi database external yang digunakan.

Apply Deployment

kubectl apply -f wordpress-deployment.yaml

Membuat Service WordPress

Membuat Service WordPress

Service digunakan untuk menghubungkan aplikasi WordPress agar dapat diakses oleh resource lain seperti Ingress atau pod lainnya di dalam cluster.

Buat file konfigurasi:
```
nano wordpress-service.yaml
```
Isi konfigurasi berikut:
```
apiVersion: v1
kind: Service
metadata:
  name: wordpress
  namespace: wordpress

spec:
  selector:
    app: wordpress

  ports:
  - port: 80
    targetPort: 80

  type: ClusterIP
```
Penjelasan:
- name: wordpress adalah nama service
- namespace: wordpress service dibuat di namespace wordpress
- selector digunakan untuk menghubungkan service ke pod WordPress
- port: 80 adalah port service di dalam cluster
- targetPort: 80 adalah port container WordPress
- type: ClusterIP membuat service hanya bisa diakses dari dalam cluster
Apply Service
```
kubectl apply -f wordpress-service.yaml
```

Membuat Ingress WordPress

Membuat Ingress WordPress
Ingress digunakan untuk menghubungkan domain ke service WordPress sehingga aplikasi dapat diakses melalui browser menggunakan domain publik.Sebelum melakukan konfigurasi berikut pastikan sudah melakukan konfigurasi ingress dan metallb,jika belum bisa di cek pada artikel berikut disini
Buat file konfigurasi:
```
nano wordpress-ingress.yaml
```
Isi konfigurasi berikut:
```
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: wordpress-ingress
  namespace: wordpress

spec:
  ingressClassName: nginx

  rules:
  - host: wp1.domainkuweb.id
    http:
      paths:
      - path: /
        pathType: Prefix
        backend:
          service:
            name: wordpress
            port:
              number: 80
```
Penjelasan:
- kind: Ingress menandakan resource yang dibuat adalah Ingress
- namespace: wordpress Ingress dibuat di namespace wordpress
- ingressClassName: nginx menggunakan NGINX Ingress Controller
- host adalah domain yang digunakan untuk akses WordPress
- path: / semua request diarahkan ke service WordPress
- service.name adalah nama service tujuan
- port.number: 80 menggunakan port HTTP WordPress
Apply Ingress
```
kubectl apply -f wordpress-ingress.yaml
```

Verifikasi Deployment

Cek Pod
```
kubectl get pods -n wordpress
```
Pastikan pod WordPress berstatus Running.
Cek Service
```
kubectl get svc -n wordpress
```
Pastikan service WordPress berhasil dibuat.
Cek Ingress
```
kubectl get ingress -n wordpress
```
Pastikan domain dan address Ingress sudah muncul.

Mengakses WordPress

Akses WordPress dari Browser

Buka browser dan akses domain berikut:
```
http://wp1.domainku.web.id
```
Jika konfigurasi Ingress, Service, dan Deployment sudah benar, maka halaman instalasi WordPress akan muncul.

Selanjutnya Anda dapat melanjutkan proses setup WordPress seperti:
- Menentukan bahasa
- Membuat akun administrator
- Menentukan nama website
- Menyelesaikan instalasi WordPress

Tips Penting

Gunakan Namespace Terpisah

Gunakan namespace terpisah untuk setiap aplikasi agar resource lebih mudah dikelola dan dimonitor.

Contoh namespace:
```
wordpress
monitoring
longhorn-system
```
Dengan namespace terpisah, manajemen deployment, service, dan storage menjadi lebih rapi.
Gunakan StorageClass Longhorn

Pastikan PVC menggunakan StorageClass Longhorn agar storage dibuat otomatis oleh Longhorn.
```
storageClassName: longhorn
```
Dengan cara ini, volume akan otomatis terhubung ke sistem storage Longhorn.
Backup Longhorn Secara Berkala

Longhorn mendukung berbagai fitur backup seperti:
- Snapshot
- Backup otomatis
- Restore volume
Fitur ini sangat penting untuk menjaga keamanan data pada environment production.

Kesimpulan

Menginstall WordPress di Kubernetes menggunakan PVC dan storage terpisah memberikan keuntungan dalam menjaga persistensi data agar tetap aman meskipun pod mengalami restart, redeploy, maupun perpindahan node. Dengan memanfaatkan Longhorn sebagai storage backend, data WordPress seperti upload media, plugin, tema, dan konfigurasi dapat tersimpan secara persistent dan lebih mudah dikelola di lingkungan Kubernetes.

Pada tutorial ini kita juga mempelajari penggunaan Deployment, Service, Ingress, serta integrasi database baik menggunakan MySQL internal Kubernetes maupun database external seperti cPanel hosting. Selain itu, konfigurasi Ingress memungkinkan WordPress diakses menggunakan domain publik sehingga lebih menyerupai implementasi production.

Dengan memahami konsep PVC, storage terpisah, dan integrasi service Kubernetes, implementasi WordPress di Kubernetes dapat menjadi dasar yang baik untuk pembelajaran container orchestration, DevOps, maupun pengembangan infrastruktur aplikasi modern berbasis cloud native.