Optimalisasi Deployment Codeigniter: Docker & CI/CD Otomatis

Halo, gaes! Pernah ngerasain kan, pas lagi asyik ngoding Codeigniter (CI) di laptop, semua jalan lancar jaya. Eh, pas mau deploy ke server, mulai deh drama: "kok error?", "dependency-nya beda?", "PHP version-nya gak cocok?". Vibes-nya langsung down, ngab! Manual deployment itu emang PR banget dan rawan bikin pusing tujuh keliling.

Nah, di artikel ini, kita bakal spill tuntas gimana caranya bikin proses deployment CI project kamu jadi auto-pilot alias otomatis dan anti-ribet pakai combo maut: Docker dan CI/CD (Continuous Integration/Continuous Deployment). Siap-siap, karena ini bakal jadi game changer buat workflow kamu!

Kenapa Harus Pake Docker dan CI/CD? Emang Sepenting Itu?

Jelas penting banget, gaes! Ini bukan cuma soal gaya-gayaan, tapi emang biar kerjaan kita makin efisien, minim error, dan scalable.

1. Docker: Bikin Project CI-mu Jadi Portable & Konsisten

Bayangin Docker itu kayak kotak ajaib. Kamu masukin semua kebutuhan project CI kamu (PHP, Nginx, library, database, dll) ke dalam kotak itu. Nah, kotak itu namanya container.

• Konsisten di Mana-mana: "It works on my machine" bukan lagi mitos, tapi kenyataan! Karena semua environment udah dibungkus rapi dalam container, di laptop dev, di staging, atau di production, semua bakal jalan sama persis. Anti-drama beda environment!
• Isolasi Aplikasi: Tiap aplikasi punya container sendiri, jadi gak bakal ganggu aplikasi lain di server yang sama. Lebih rapi dan aman.
• Deployment Jadi Ngebut: Tinggal jalanin container, project langsung running. Gak perlu lagi setup ini itu di server secara manual.

2. CI/CD: Otomatisasi Total dari Ngoding Sampai Deployment

CI/CD itu kayak tim superhero yang siap siaga 24/7. Begitu kamu push kode ke repository (misal: GitHub/GitLab), tim ini langsung gerak:

• Continuous Integration (CI): Otomatis ngetes kode kamu, nge-build aplikasi, dan mastiin gak ada yang rusak. Kalau ada error, langsung ketahuan di awal!
• Continuous Deployment (CD): Kalau semua tes udah hijau, aplikasi otomatis di-deploy ke server. Kamu tinggal duduk manis, ngab!
• Minim Human Error: Karena semua otomatis, risiko salah langkah manusia jadi berkurang drastis.
• Release Lebih Sering & Cepat: Fitur baru bisa cepat sampai ke user tanpa perlu nunggu proses deployment yang panjang dan melelahkan.

Kombo Docker + CI/CD ini bikin workflow development jadi smooth banget, kayak jalan tol tanpa macet!

Skuy, Kita Dockerisasi Codeigniter!

Pertama, kita perlu "mewadahi" aplikasi CI kita ke dalam Docker. Kita bakal pake Dockerfile buat instruksi bikin image dan docker-compose.yml buat nge-orkestrasi beberapa service (aplikasi CI, web server, database).

Asumsi: Kamu udah punya project Codeigniter (CI3 atau CI4 sama aja, intinya PHP app), dan udah install Docker Desktop di laptop ya, gaes!

Langkah 1: Bikin Dockerfile untuk Aplikasi Codeigniter

Buat file Dockerfile di root project CI kamu. Ini contohnya (kita pake Nginx & PHP-FPM):

# ---- Base Image PHP-FPM ----
FROM php:8.1-fpm-alpine

# Update & Install PHP Extensions yang Dibutuhkan CI
RUN apk update --no-cache && \
    apk add --no-cache \
    nginx \
    git \
    supervisor \
    openssl \
    oniguruma-dev \
    libxml2-dev \
    pcre-dev \
    ${PHPIZE_DEPS} && \
    docker-php-ext-install pdo pdo_mysql opcache bcmath ctype fileinfo json mbstring tokenizer xml && \
    docker-php-ext-configure gd --with-freetype --with-jpeg && \
    docker-php-ext-install -j$(nproc) gd && \
    rm -rf /var/cache/apk/* && \
    apk del ${PHPIZE_DEPS}

# Konfigurasi Nginx
COPY docker/nginx/default.conf /etc/nginx/conf.d/default.conf
COPY docker/nginx/nginx.conf /etc/nginx/nginx.conf

# Atur hak akses folder cache/log Codeigniter (jika ada)
# Sesuaikan path-nya dengan CI versi kamu (misal: writable untuk CI4)
RUN chown -R www-data:www-data /var/www/html/writable || true && \
    chmod -R 775 /var/www/html/writable || true

# Copy aplikasi Codeigniter ke dalam container
WORKDIR /var/www/html
COPY . /var/www/html

# Bersihkan cache composer jika ada (untuk produksi, bisa dihapus)
# RUN composer install --no-dev --optimize-autoloader --no-scripts

# Expose port PHP-FPM
EXPOSE 9000

# Start supervisor untuk PHP-FPM dan Nginx
COPY docker/supervisord.conf /etc/supervisord.conf
CMD ["/usr/bin/supervisord", "-c", "/etc/supervisord.conf"]

Penjelasan Singkat:

• FROM php:8.1-fpm-alpine: Kita pake PHP 8.1 FPM dengan base image Alpine (lebih kecil).
• RUN apk update...: Install ekstensi PHP yang umumnya dibutuhkan CI dan Nginx.
• COPY docker/nginx/...: Copy konfigurasi Nginx kita (akan kita buat nanti).
• WORKDIR /var/www/html & COPY . /var/www/html: Folder aplikasi kita di dalam container adalah /var/www/html.
• EXPOSE 9000: Port PHP-FPM.
• CMD: Menjalankan supervisord untuk mengelola proses PHP-FPM dan Nginx.

Langkah 2: Konfigurasi Nginx dan Supervisor

Buat folder docker di root project kamu, lalu di dalamnya buat nginx dan supervisord.conf.

docker/nginx/default.conf (Konfigurasi Nginx untuk Codeigniter)

server {
    listen 80;
    server_name localhost;
    root /var/www/html;
    index index.php index.html index.htm;

    location / {
        try_files $uri $uri/ /index.php?$query_string;
    }

    location ~ \.php$ {
        fastcgi_split_path_info ^(.+\.php)(/.+)$;
        fastcgi_pass 127.0.0.1:9000; # Mengarah ke PHP-FPM di dalam container yang sama
        fastcgi_index index.php;
        include fastcgi_params;
        fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name;
        fastcgi_param PATH_INFO $fastcgi_path_info;
    }

    error_log /var/log/nginx/error.log;
    access_log /var/log/nginx/access.log;
}

docker/nginx/nginx.conf (Konfigurasi Nginx utama)

user  nginx;
worker_processes  1;

error_log  /var/log/nginx/error.log warn;
pid        /var/run/nginx.pid;

events {
    worker_connections  1024;
}

http {
    include       /etc/nginx/mime.types;
    default_type  application/octet-stream;

    log_format  main  '$remote_addr - $remote_user [$time_local] "$request" '
                      '$status $body_bytes_sent "$http_referer" '
                      '"$http_user_agent" "$http_x_forwarded_for"';

    access_log  /var/log/nginx/access.log  main;

    sendfile        on;
    tcp_nopush      on;
    tcp_nodelay     on;
    keepalive_timeout  65;
    types_hash_max_size 2048;

    include /etc/nginx/conf.d/*.conf;
}

docker/supervisord.conf (Untuk menjalankan PHP-FPM dan Nginx)

[supervisord]
nodaemon=true

[program:nginx]
command=/usr/sbin/nginx -g "daemon off;"
autostart=true
autorestart=true
priority=10
stdout_logfile=/dev/stdout
stdout_logfile_maxbytes=0
stderr_logfile=/dev/stderr
stderr_logfile_maxbytes=0

[program:php-fpm]
command=php-fpm -F
autostart=true
autorestart=true
priority=5
stdout_logfile=/dev/stdout
stdout_logfile_maxbytes=0
stderr_logfile=/dev/stderr
stderr_logfile_maxbytes=0

Langkah 3: Bikin docker-compose.yml

File ini akan mendefinisikan dan menjalankan multi-container Docker application kamu. Buat docker-compose.yml di root project:

version: '3.8'

services:
  app:
    build:
      context: .
      dockerfile: Dockerfile
    container_name: ci_app
    restart: unless-stopped
    volumes:
      - .:/var/www/html # Mount kode dari host ke container
      # - ./writable:/var/www/html/writable # Jika CI4, pastikan folder writable di-mount terpisah untuk hak akses
    environment:
      # Spill variabel env CI di sini, contoh untuk CI4
      - CI_ENVIRONMENT=development
      - DATABASE_HOST=db
      - DATABASE_NAME=your_db_name
      - DATABASE_USERNAME=your_db_user
      - DATABASE_PASSWORD=your_db_password
      - DATABASE_PORT=3306

  nginx:
    image: nginx:alpine
    container_name: ci_nginx
    restart: unless-stopped
    ports:
      - "80:80" # Map port 80 host ke port 80 container
    volumes:
      - .:/var/www/html # Mount kode yang sama seperti app
      - ./docker/nginx/default.conf:/etc/nginx/conf.d/default.conf # Overwrite default Nginx config
    depends_on:
      - app

  db:
    image: mysql:8.0
    container_name: ci_db
    restart: unless-stopped
    environment:
      MYSQL_DATABASE: your_db_name
      MYSQL_ROOT_PASSWORD: your_db_root_password
      MYSQL_USER: your_db_user
      MYSQL_PASSWORD: your_db_password
    volumes:
      - db_data:/var/lib/mysql # Simpan data database di volume
    ports:
      - "3307:3306" # Opsional: jika mau akses DB dari host

volumes:
  db_data:

Jangan lupa ganti your_db_name, your_db_user, your_db_password, dan your_db_root_password sesuai kebutuhan ya, gaes!

Langkah 4: Tambahkan .dockerignore

Mirip .gitignore, ini biar file-file yang gak perlu gak ikut masuk ke image Docker dan bikin ukuran image bengkak.

.git
.gitignore
.env
vendor/ # Kalau kamu install dependency di dalam container, ini bisa diabaikan
node_modules/
*.log
docker/

Langkah 5: Run It!

Sekarang, dari root project kamu, tinggal jalankan:

docker-compose up -d --build

Voila! Project CI kamu sekarang harusnya bisa diakses di http://localhost. Gokil kan? Semua udah jalan di dalam container.

Otomatisasi dengan CI/CD: Bikin Workflow Super Keren!

Kita bakal pake GitHub Actions sebagai contoh platform CI/CD karena gampang banget disetup dan udah integrated sama GitHub repo.

Konsep Dasar Workflow CI/CD Kita:

1. Push Code: Kamu push kode ke branch main (atau develop).
2. Trigger CI/CD: GitHub Actions mendeteksi push ini dan mulai workflow.
3. Build Docker Image: GitHub Actions akan bikin image Docker aplikasi CI kamu.
4. Test (Opsional tapi Penting!): Jalankan unit test atau integration test.
5. Push Image to Registry: Image yang udah jadi di-push ke Docker Hub atau container registry lainnya.
6. Deploy ke Server: Dari registry, image di-pull ke server production/staging dan container di-update.

Langkah 1: Siapkan Repository dan Secrets

• Pastikan project CI kamu udah ada di GitHub.
• Buka Settings repo kamu -> Secrets and variables -> Actions -> New repository secret. Tambahkan secrets ini:
  • DOCKERHUB_USERNAME: Username Docker Hub kamu.
  • DOCKERHUB_TOKEN: Personal Access Token Docker Hub kamu.
  • SSH_HOST: IP address atau domain server production kamu.
  • SSH_USER: Username SSH server kamu.
  • SSH_KEY: Private key SSH kamu (pakai yang aman ya!).
  • APP_DIR: Path ke folder project kamu di server (misal: /var/www/html/my-ci-app).

Langkah 2: Bikin Workflow GitHub Actions

Buat folder .github/workflows di root project kamu, lalu buat file main.yml di dalamnya.

name: CI/CD Pipeline Codeigniter with Docker

on:
  push:
    branches:
      - main # Workflow akan jalan tiap ada push ke branch main

jobs:
  build-and-deploy:
    runs-on: ubuntu-latest # Jalankan di OS Ubuntu terbaru

    steps:
      - name: Checkout Code # Langkah pertama, ambil kode dari repo
        uses: actions/checkout@v3

      - name: Log in to Docker Hub # Login ke Docker Hub
        uses: docker/login-action@v2
        with:
          username: ${{ secrets.DOCKERHUB_USERNAME }}
          password: ${{ secrets.DOCKERHUB_TOKEN }}

      - name: Build Docker Image # Bikin image Docker
        id: build-image # Beri ID agar bisa di-refer
        uses: docker/build-push-action@v4
        with:
          context: .
          file: ./Dockerfile
          push: true
          tags: ${{ secrets.DOCKERHUB_USERNAME }}/my-ci-app:latest # Tag image kamu
          # Cache agar proses build lebih cepat
          cache-from: type=gha
          cache-to: type=gha,mode=max

      # --- Opsional: Jalankan Test di Sini ---
      # - name: Run PHPUnit Tests
      #   run: |
      #     docker run --rm ${{ secrets.DOCKERHUB_USERNAME }}/my-ci-app:latest php spark test # Contoh untuk CI4

      - name: Deploy to Production Server # Deploy ke server produksi
        uses: appleboy/ssh-action@master
        with:
          host: ${{ secrets.SSH_HOST }}
          username: ${{ secrets.SSH_USER }}
          key: ${{ secrets.SSH_KEY }}
          script: |
            echo "Deploying application..."
            cd ${{ secrets.APP_DIR }}
            # Pastikan kamu punya docker-compose.yml di server yang sudah di-configure
            # dengan image dari Docker Hub. Atau, bisa juga langsung pull dan run
            docker pull ${{ secrets.DOCKERHUB_USERNAME }}/my-ci-app:latest
            docker stop ci_app || true # Hentikan container lama jika ada
            docker rm ci_app || true    # Hapus container lama
            docker run -d \
              --name ci_app \
              -p 80:80 \
              -v ${{ secrets.APP_DIR }}/writable:/var/www/html/writable \
              -e CI_ENVIRONMENT=production \
              -e DATABASE_HOST=${{ secrets.DATABASE_HOST }} \
              -e DATABASE_NAME=${{ secrets.DATABASE_NAME }} \
              -e DATABASE_USERNAME=${{ secrets.DATABASE_USERNAME }} \
              -e DATABASE_PASSWORD=${{ secrets.DATABASE_PASSWORD }} \
              -e DATABASE_PORT=${{ secrets.DATABASE_PORT }} \
              ${{ secrets.DOCKERHUB_USERNAME }}/my-ci-app:latest
            echo "Deployment finished!"

Penjelasan Singkat:

• Workflow ini akan jalan tiap ada push ke branch main.
• Login ke Docker Hub pakai secret yang udah kamu set.
• Build Docker Image: Bikin image dari Dockerfile kamu dan langsung push ke Docker Hub. Ganti my-ci-app dengan nama repo aplikasi Docker kamu.
• Deploy to Production Server: Ini yang paling magic! Setelah image sukses dibuild dan di-push, SSH ke server production. Di sana, dia akan pull image terbaru, stop container lama, hapus, lalu jalankan container baru dengan image yang paling fresh!
• Pastikan konfigurasi DATABASE_* di environment disesuaikan dengan kebutuhan CI kamu dan secrets di GitHub Actions.

Tips Tambahan Biar Makin Gokil!

• Multi-stage Build: Biar ukuran image Docker kamu makin kecil (ini penting banget buat deployment yang ngebut!), pelajari multi-stage build di Dockerfile. Pisahin build stage (install composer dependencies, compile assets) dengan runtime stage.
• .dockerignore: Jangan lupa bikin file .dockerignore untuk ngecualikan file atau folder yang gak perlu masuk ke dalam image Docker. Ini bikin image kamu makin ramping.
• Env Vars & Secrets: Jangan pernah hardcode informasi sensitif (password DB, API Key) di kode atau Dockerfile. Selalu pakai environment variables dan kelola dengan Secrets di platform CI/CD (kayak di GitHub Actions tadi) atau pakai solusi secret management yang lebih advance.
• Monitoring & Logging: Pastikan kamu punya sistem monitoring dan logging yang baik untuk container kamu. Kalau ada apa-apa, kamu bisa langsung tahu dan bertindak.
• Rollback Strategy: Selalu siapkan plan kalau deployment gagal. Dengan Docker, rollback itu gampang banget: tinggal jalankan image versi sebelumnya.
• Testing Otomatis: Integrasikan unit test dan integration test ke dalam pipeline CI/CD kamu. Ini krusial buat mastiin setiap perubahan kode gak ngerusak fungsionalitas yang udah ada.

Kesimpulan: Bye-bye Ribet, Welcome Otomatisasi!

Gaes, pake Docker dan CI/CD buat Codeigniter project kamu itu bukan lagi pilihan, tapi keharusan di era modern ini. Proses deployment yang dulunya bikin males dan stress, sekarang bisa jadi secepat kilat dan minim error. Kamu bisa fokus ngoding fitur baru, dan biarkan "tim superhero" Docker + CI/CD yang ngurusin deployment.

Gimana? Udah siap nge-upgrade workflow deployment Codeigniter kamu ke level dewa? Skuy dicoba, dan rasakan bedanya! Pasti wortel banget!