Docker untuk Developer: 5 Skenario Praktis untuk Pemula

Dokumentasi Docker hampir 2.000 halaman. Kamu cuma butuh 5 perintah untuk 95% kebutuhan sehari-hari. Artikel ini tidak menjelaskan cara kerja container — hanya 5 skenario langsung pakai: Laravel + MySQL, React + Nginx, Python API + Redis, testing di CI, dan deploy ke VPS.

Docker itu seperti lemari IKEA. Dokumentasi resminya bilang: “Baca manual 200 halaman dulu, pahami perbedaan container dan image, baru rakit.” Tapi kamu cuma ingin lemari yang bisa dipakai malam ini — jadi kamu buka petunjuk gambar, ambil sekrup, dan mulai rakit.

Artikel ini adalah petunjuk gambar versi Docker. Lima skenario yang paling sering dihadapi developer Indonesia — dari fullstack Laravel, React frontend, Python API, testing, sampai deploy. Setiap skenario punya file siap pakai yang bisa kamu copy-paste.

Sebelum Mulai: 3 Istilah yang Perlu Kamu Tahu

Image — cetak biru container. Bayangkan seperti file .ISO installer Windows. Kamu download sekali, bisa dipakai berkali-kali
Container — instance dari image yang sedang berjalan. Seperti VM mini yang ringan — kalau kamu jalankan ISO-nya, itu jadi container
Volume — penyimpanan data yang tidak hilang meskipun container dihapus. Penting untuk database agar data MySQL tidak lenyap saat container di-restart

Dengan 3 istilah di atas, kamu sudah bisa memahami 90% dari apa yang terjadi di skenario-skenario berikut.

Skenario 1: Laravel + MySQL — Stack Paling Umum di Indonesia

# docker-compose.yml
version: '3.8'
services:
  app:
    image: laravel:latest
    build:
      context: .
      dockerfile: Dockerfile
    ports:
      - "8000:8000"
    volumes:
      - .:/var/www/html
    depends_on:
      - db

  db:
    image: mysql:8.0
    environment:
      MYSQL_DATABASE: laravel
      MYSQL_USER: user
      MYSQL_PASSWORD: secret
      MYSQL_ROOT_PASSWORD: root
    ports:
      - "3306:3306"
    volumes:
      - mysql_data:/var/lib/mysql

volumes:
  mysql_data:

Simpan file di atas sebagai docker-compose.yml di root project Laravel kamu. Lalu jalankan:

docker compose up -d          # mulai container di background
docker compose exec app php artisan migrate  # jalankan migrasi database
docker compose exec app php artisan serve --host=0.0.0.0 --port=8000

Buka http://localhost:8000 — aplikasi Laravel kamu sudah jalan dengan database MySQL.

Kenapa ini berguna: Tidak perlu install PHP, Composer, atau MySQL di lokal. Semua beres dalam 1 file YAML dan 2 perintah. Saat project selesai, tinggal docker compose down -v — bersih, tidak ada sisa instalasi.

Skenario 2: React + Nginx — Build dan Sajikan Frontend

# Dockerfile
FROM node:20 AS build
WORKDIR /app
COPY package*.json ./
RUN npm install
COPY . .
RUN npm run build

FROM nginx:alpine
COPY --from=build /app/build /usr/share/nginx/html
COPY nginx.conf /etc/nginx/nginx.conf
EXPOSE 80
CMD ["nginx", "-g", "daemon off;"]

Ini menggunakan teknik multi-stage build: tahap pertama (node) untuk build React, tahap kedua (nginx) untuk serve file statis. Hasilnya adalah image yang super kecil karena tidak mengandung Node.js — hanya nginx dan file build.

docker build -t react-app .   # build image
docker run -d -p 8080:80 react-app  # jalankan container

Buka http://localhost:8080. React app kamu disajikan oleh nginx dengan performa optimal. Ukuran image akhir hanya ~50MB — bandingkan dengan kalau kamu pakai node image yang ukurannya 1GB+.

Skenario 3: Python FastAPI + Redis — API Ringan dengan Cache

# docker-compose.yml
version: '3.8'
services:
  api:
    build: .
    ports:
      - "8000:8000"
    depends_on:
      - redis
    environment:
      REDIS_HOST: redis

  redis:
    image: redis:7-alpine
    ports:
      - "6379:6379"

# Dockerfile
FROM python:3.11-slim
WORKDIR /app
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt
COPY . .
CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "8000"]

Struktur project: main.py berisi aplikasi FastAPI, requirements.txt berisi fastapi[standard] redis uvicorn, dan dua file Docker di atas.

docker compose up -d
curl http://localhost:8000/docs  # Swagger UI otomatis

Dengan setup ini, API kamu langsung terkoneksi dengan Redis untuk caching. Cukup tambahkan redis_client = redis.Redis(host=os.getenv('REDIS_HOST')) di kode Python kamu dan cache siap digunakan.

Skenario 4: Testing di CI/CD — GitHub Actions + Docker

# .github/workflows/test.yml
name: Test
on: [push]

jobs:
  test:
    runs-on: ubuntu-latest
    services:
      db:
        image: mysql:8.0
        env:
          MYSQL_DATABASE: test
          MYSQL_USER: user
          MYSQL_PASSWORD: secret
          MYSQL_ROOT_PASSWORD: root
        ports:
          - 3306:3306
      cache:
        image: redis:7-alpine
        ports:
          - 6379:6379

    steps:
      - uses: actions/checkout@v4
      - uses: shivammathur/setup-php@v2
        with:
          php-version: '8.2'
      - run: composer install
      - run: cp .env.example .env
      - run: php artisan key:generate
      - run: php artisan migrate --env=testing
      - run: php artisan test

File di atas menjalankan test Laravel dengan database MySQL dan Redis sebagai service container. Setiap push ke GitHub akan otomatis menjalankan test suite — tanpa perlu server testing terpisah.

Untuk Python:

# ekstrak dari workflow yang sama
- uses: actions/setup-python@v5
  with:
    python-version: '3.11'
- run: pip install -r requirements.txt
- run: pytest

Dengan setup ini, setiap push kode akan langsung di-test dengan environment yang identik dengan production — tidak ada masalah “tapi di laptop saya jalan”.

Skenario 5: Deploy ke VPS — Simple dengan Docker Compose

Ini skenario paling sederhana dan paling sering dipakai untuk solo developer yang deploy ke VPS Rp100rb/bulan.

# Di lokal — build dan push image
docker build -t myapp:latest .
docker save myapp:latest | gzip > myapp.tar.gz
scp myapp.tar.gz user@vps:~/

# Di VPS
docker load < myapp.tar.gz
docker compose up -d

Atau kalau VPS kamu punya akses internet cepat dan kamu pakai Docker Hub/GitHub Container Registry:

# Di lokal
docker tag myapp:latest ghcr.io/username/myapp:latest
docker push ghcr.io/username/myapp:latest

# Di VPS — pull dan jalan
docker pull ghcr.io/username/myapp:latest
docker compose up -d

# Untuk update
docker compose pull
docker compose up -d

Keuntungan utama: rollback dalam 5 detik. Kalau versi baru bermasalah, tinggal docker compose down && docker compose up -d dengan image versi sebelumnya. Tidak perlu install ulang dependensi atau khawatir versi PHP/Node/Python — semua sudah terbungkus dalam image.

Perintah Penting yang Perlu Kamu Hafal

Perintah	Fungsi
`docker compose up -d`	Mulai semua container
`docker compose down`	Hentikan dan hapus container
`docker compose logs -f`	Lihat log real-time
`docker compose exec app bash`	Masuk ke container app
`docker compose ps`	Lihat status container
`docker compose restart`	Restart semua service
`docker system prune -a`	Bersihkan image/container tidak dipakai

Dengan 7 perintah di atas, kamu sudah bisa menjalankan 95% skenario development sehari-hari. Tidak perlu hafal 200 perintah — cukup 7 ini dan 5 file YAML di atas.

Kesimpulan

Docker bukan tentang memahami cara kerja kernel namespace atau cgroups. Docker adalah tentang: "Bagaimana cara menjalankan aplikasi saya di environment yang sama tanpa install PHP, MySQL, Redis, Node.js di laptop?"

Lima skenario di atas cukup untuk 80% project yang dikerjakan solo developer Indonesia. Copy-paste, ganti nama project, jalankan. Kalau ada masalah, docker compose down && docker compose up -d — reset total, tidak ada sisa instalasi yang mengotori sistem.

Dokumentasi 2.000 halaman bisa kamu baca nanti — saat aplikasi sudah berjalan dan kamu mulai bertanya "bagaimana cara scaling" atau "bagaimana cara orchestrate puluhan container". Sampai saat itu tiba, 5 skenario di atas sudah cukup.

Artikel ini adalah bagian dari seri "Workflow Praktis Developer Indonesia" — tutorial yang bisa langsung dipakai, tanpa teori yang tidak perlu.

Docker untuk Developer yang Males Baca Dokumentasi: Workflow Praktis untuk 5 Skenario Sehari-hari