Mengenal Docker dan Apa Fungsinya

Docker adalah platform open-source yang memungkinkan developer untuk mengemas aplikasi beserta seluruh dependensinya—mulai dari library, konfigurasi, hingga sistem operasi dasar—ke dalam sebuah unit standar yang disebut container. Dengan pendekatan ini, aplikasi dapat berjalan secara konsisten di mana saja: di laptop developer, di server staging, maupun di environment production, tanpa mengalami masalah klasik "di komputer saya berjalan normal." Docker pertama kali dirilis pada tahun 2013 oleh Solomon Hykes dan sejak itu menjadi salah satu teknologi paling transformasif di dunia pengembangan perangkat lunak modern.

Untuk memahami Docker secara intuitif, bayangkan Anda pindah rumah. Jika Anda memindahkan barang-barang satu per satu—meja, kursi, piring, buku—maka besar kemungkinan ada yang tertinggal atau rusak di jalan. Namun, jika Anda memasukkan semua barang ke dalam sebuah kontainer pengiriman yang terstandarisasi, maka pengiriman menjadi aman, rapi, dan bisa dipindahkan dari truk ke kapal ke gudang tanpa perlu membongkar isiannya. Docker bekerja dengan cara yang sama: alih-alih memindahkan kode, library, dan konfigurasi secara terpisah antar environment, Docker memasukkan semuanya ke dalam satu kontainer digital yang utuh dan portabel.

Kenapa Docker begitu penting di era saat ini? Pertama, fenomena "works on my machine" telah menjadi mimpi buruk selama puluhan tahun di industri software. Sebuah aplikasi mungkin berjalan sempurna di laptop developer yang menggunakan Python 3.9, namun crash di server production yang masih menggunakan Python 3.7. Docker menghilangkan persoalan ini sepenuhnya karena container yang berjalan di laptop dan di server adalah identik—persis sama, byte per byte. Kedua, Docker memungkinkan isolasi yang bersih. Beberapa aplikasi yang membutuhkan versi berbeda dari library yang sama bisa berjalan berdampingan tanpa konflik, masing-masing di dalam container terpisah. Ketiga, Docker mempercepat proses deployment secara dramatis. Yang sebelumnya membutuhkan hari untuk mengonfigurasi server, kini bisa diselesaikan dalam hitungan detik dengan menjalankan container dari image yang sudah jadi. Keempat, ekosistem Docker Hub menyediakan ratusan ribu image siap pakai yang bisa langsung di-pull dan dijalankan, menghemat waktu setup yang luar biasa. Kelima, arsitektur microservice yang menjadi tren saat ini nyaris mustahil diimplementasikan secara efisien tanpa containerisasi, dan Docker adalah fondasi utamanya.

Cara Kerja

Untuk memahami cara kerja Docker, kita perlu menguasai beberapa konsep inti yang menjadi fondasi seluruh ekosistemnya. Konsep pertama dan paling fundamental adalah containerization—teknik mengemas aplikasi ke dalam container yang terisolasi. Berbeda dengan virtual machine yang mengemulasikan seluruh sistem operasi termasuk kernel-nya, container Docker berbagi kernel host operating system sehingga jauh lebih ringan dan cepat. Container hanya berisi aplikasi dan dependensinya, tanpa beban OS penuh, sehingga ukurannya bisa hanya puluhan megabyte dibanding gigabyte untuk VM.

Konsep kedua adalah layering, yaitu sistem berlapis pada image Docker. Setiap instruksi dalam Dockerfile menciptakan satu layer baru yang bersifat read-only. Ketika container berjalan, Docker menambahkan satu layer writable di atasnya. Sistem ini membuat distribusi image menjadi sangat efisien karena layer yang identik bisa di-share antar image, menghemat bandwidth dan penyimpanan.

Konsep ketiga adalah immutability. Image Docker bersifat immutable—setelah dibuat, ia tidak bisa diubah. Jika Anda ingin melakukan modifikasi, Anda membuat image baru di atasnya. Prinsip ini menjamin konsistensi dan reproducibility, dua hal yang sangat bernilai dalam operasional software.

Komponen utama dalam arsitektur Docker terdiri dari beberapa bagian yang saling bekerja sama:

  • Docker Daemon (dockerd): Proses background yang berjalan di host machine, bertanggung jawab membangun, menjalankan, dan mendistribusikan container. Daemon inilah "otak" yang sesungguhnya menjalankan semua operasi Docker.
  • Docker Client (docker): Command-line interface yang digunakan developer untuk berkomunikasi dengan Docker Daemon melalui REST API. Ketika Anda mengetik docker run, client mengirim permintaan ke daemon yang kemudian mengeksekusinya.
  • Docker Image: Template read-only yang berisi instruksi untuk membuat container. Image bersifat statis dan bisa dibagikan melalui registry.
  • Docker Container: Instance running dari sebuah image. Container adalah entitas hidup yang bisa di-start, di-stop, di-pause, dan di-remove.
  • Docker Registry: Repositori penyimpanan dan distribusi image. Docker Hub adalah registry publik terbesar, namun organisasi juga bisa menjalankan private registry sendiri.
  • Dockerfile: File teks berisi serangkaian instruksi untuk membangun image secara otomatis dan reproducible.

Menggunakan konteks konkret: bayangkan Anda ingin menjalankan aplikasi web Node.js. Tanpa Docker, Anda harus menginstal Node.js versi tertentu, menginstal npm packages, mengonfigurasi environment variable, dan memastikan kompatibilitas dengan sistem operasi. Dengan Docker, seluruh proses ini dirangkum dalam sebuah Dockerfile. Ketika Anda menjalankan docker build, Docker membaca Dockerfile layer per layer—mengunduh base image, menyalin kode sumber, menginstal dependensi, dan menghasilkan sebuah image utuh. Ketika Anda menjalankan docker run, Docker membuat container dari image tersebut, mengisolasi prosesnya, dan aplikasi pun berjalan dalam environment yang sepenuhnya terkontrol dan konsisten.

Aturan Penulisan

Penulisan Dockerfile mengikuti sintaks deklaratif yang terdiri dari instruksi-instruksi standar. Setiap instruksi ditulis dalam format INSTRUCTION arguments, dan Docker akan membacanya secara sekuensial dari atas ke bawah untuk membangun image layer per layer. File ini harus bernama Dockerfile (tanpa ekstensi) dan ditempatkan di root direktori proyek. Penulisan yang benar dan mengikuti Kebiasaan yang baik sangat menentukan efisiensi, keamanan, dan performa image yang dihasilkan.

Berikut adalah instruksi-instruksi utama dalam Dockerfile beserta penjelasannya:

Instruksi Fungsi Contoh Penggunaan Catatan Penting
FROM Menentukan base image FROM python:3.11-slim Harus sebagai instruksi pertama
WORKDIR Mengatur direktori kerja WORKDIR /app Membuat direktori jika belum ada
COPY Menyalin file dari host ke image COPY . /app Lebih disarankan daripada ADD
RUN Mengeksekusi perintah saat build RUN pip install -r requirements.txt Setiap RUN membuat layer baru
CMD Perintah default saat container run CMD ["python", "app.py"] Hanya satu CMD per Dockerfile
ENTRYPOINT Mengatur executable utama ENTRYPOINT ["python"] Tidak bisa di-override mudah
ENV Mengatur environment variable ENV NODE_ENV=production Persisten di dalam container
EXPOSE Mendokumentasikan port EXPOSE 8080 Hanya dokumentasi, tidak publish
ARG Variabel hanya saat build time ARG VERSION=1.0 Tidak tersedia di running container
VOLUME Membuat mount point VOLUME ["/data"] Untuk data persisten

Saat menulis Dockerfile, beberapa aturan penting harus diperhatikan. Pertama, selalu gunakan image base yang spesifik—hindari tag latest karena bisa berubah tanpa kendali dan merusak reproducibility image. Kedua, manfaatkan multi-stage build untuk mengurangi ukuran image final. Ketiga, urutkan instruksi dari yang paling jarang berubah ke yang paling sering berubah agar layer cache bisa dimanfaatkan secara optimal. Keempat, gabungkan perintah RUN yang berkaitan menggunakan && untuk mengurangi jumlah layer yang dihasilkan. Kelima, selalu tambahkan .dockerignore untuk mengecualikan file yang tidak diperlukan seperti node_modules, .git, dan file log.

Berikut contoh Dockerfile yang mengikuti Praktik terbaik untuk aplikasi Python:

# Stage 1: Build dependencies
FROM python:3.11-slim AS builder

WORKDIR /build

COPY requirements.txt .
RUN pip install --no-cache-dir --user -r requirements.txt

# Stage 2: Production image
FROM python:3.11-slim

WORKDIR /app

# Salin package dari stage builder
COPY --from=builder /root/.local /root/.local
COPY . .

# Pastikan script di PATH
ENV PATH=/root/.local/bin:$PATH
ENV PYTHONUNBUFFERED=1

EXPOSE 8000

CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "8000"]

Perhatikan bagaimana multi-stage build digunakan di atas: stage pertama (builder) menginstal semua dependensi Python, sementara stage kedua hanya menyalin hasil instalasi tanpa membawa seluruh toolchain build. Hasilnya adalah image final yang jauh lebih kecil dan lebih aman karena tidak mengandung compiler dan tool build yang tidak diperlukan saat runtime.

Perbandingan antara pendekatan penulisan Dockerfile yang kurang optimal dan yang sudah mengikuti Praktik terbaik:

Aspek Dockerfile Kurang Optimal Dockerfile Cara yang disarankan
Base Image FROM ubuntu:latest (~400MB) FROM python:3.11-slim (~130MB)
Layer RUN Setiap instalasi di RUN terpisah Digabung dengan && dalam satu RUN
Cache COPY . . sebelum pip install COPY requirements.txt dulu, baru kode
Build Stage Single-stage saja Multi-stage build
Security Berjalan sebagai root Menggunakan user non-root
Cleanup Tidak menghapus cache apt/pip --no-cache-dir dan rm -rf
Ukuran Akhir ~1.2 GB ~180 MB

Contoh Penggunaan Sehari-hari

Dalam aktivitas pengembangan sehari-hari, Docker digunakan dalam berbagai skenario yang sangat praktis dan langsung memberikan dampak produktivitas. Berikut adalah lima skenario penggunaan yang paling umum dijumpai oleh developer, lengkap dengan perintah dan penjelasan output yang dihasilkan.

Skenario 1: Menjalankan database MySQL untuk development lokal

Tanpa Docker, Anda harus menginstal MySQL server di komputer, mengonfigurasi user dan password, dan mengelola versi yang mungkin berbeda-beda antar proyek. Dengan Docker, seluruh database bisa berjalan dalam container terisolasi yang bisa dihancurkan dan dibangun kembali kapan saja.

# Menjalankan MySQL 8.0 dengan password dan port mapping
docker run -d \
  --name mysql-dev \
  -e MYSQL_ROOT_PASSWORD=secret123 \
  -e MYSQL_DATABASE=app_db \
  -p 3306:3306 \
  mysql:8.0

# Output:
# a7f3e2b1c9d4... (container ID yang di-generate)
# Memverifikasi container berjalan
docker ps

# Output:
# CONTAINER ID   IMAGE       COMMAND                  STATUS         PORTS                    NAMES
# a7f3e2b1c9d4   mysql:8.0   "docker-entrypoint.s…"   Up 12 seconds  0.0.0.0:3306->3306/tcp   mysql-dev

Container ini bisa dihubungkan dari aplikasi Anda menggunakan localhost:3306, persis seperti MySQL yang terinstal langsung di mesin. Ketika selesai development, cukup jalankan docker rm -f mysql-dev dan seluruh jejak database hilang tanpa meninggalkan sisa.

Skenario 2: Mengembangkan aplikasi web dengan hot-reload menggunakan volume mounting

Docker tidak hanya untuk deployment—ia juga sangat powerful untuk development. Dengan teknik volume binding, kode di host disinkronkan langsung ke dalam container sehingga setiap perubahan langsung tercermin tanpa perlu rebuild image.

# Menjalankan aplikasi Next.js dengan volume mount
docker run -d \
  --name nextjs-dev \
  -v $(pwd):/app \
  -p 3000:3000 \
  node:18-alpine \
  sh -c "cd /app && npm install && npm run dev"

# Output:
# ed42f8a91bc3... (container ID)

Setiap file yang Anda edit di editor lokal akan langsung terlihat oleh container karena direktori kerja di-mount ke dalam /app, dan hot-reload dari Next.js akan memperbarui browser secara otomatis.

Skenario 3: Menjalankan stack aplikasi lengkap dengan Docker Compose

Untuk aplikasi yang membutuhkan beberapa service sekaligus—misalnya web server, database, dan cache—Docker Compose memungkinkan seluruh stack didefinisikan dalam satu file YAML dan dijalankan dengan satu perintah.

# docker-compose.yml
version: "3.9"
services:
  web:
    build: .
    ports:
      - "5000:5000"
    depends_on:
      - db
      - redis
    environment:
      - DB_HOST=db
      - REDIS_HOST=redis

  db:
    image: postgres:15-alpine
    environment:
      POSTGRES_PASSWORD: postgres
      POSTGRES_DB: myapp
    volumes:
      - pgdata:/var/lib/postgresql/data

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

volumes:
  pgdata:
# Menjalankan seluruh stack
docker compose up -d

# Output:
# [+] Running 4/4
#  ✔ Network myapp_default      Created
#  ✔ Container myapp-web-1      Started
#  ✔ Container myapp-db-1       Started
#  ✔ Container myapp-redis-1    Started

Satu perintah, dan seluruh infrastruktur aplikasi—web, database, cache—berjalan bersamaan dengan networking yang sudah terkonfigurasi secara otomatis. Service web bisa mengakses db cukup dengan hostname db karena Docker Compose secara otomatis mengatur DNS resolution internal.

Skenario 4: Menjalankan testing CI/CD dalam container yang terisolasi

Dalam pipeline CI/CD, setiap test run harus berjalan di environment yang bersih dan terisolasi. Docker memungkinkan ini dengan menjalankan test suite di dalam container yang dibuang setelah selesai.

# Menjalankan test suite dan menghapus container setelah selesai
docker run --rm \
  -v $(pwd):/app \
  -w /app \
  python:3.11-slim \
  sh -c "pip install -q pytest && pytest tests/ -v"

# Output:
# ======================== test session starts ========================
# platform linux -- Python 3.11.x, pytest-7.x.x
# collected 42 items
#
# tests/test_auth.py::test_login_success PASSED                     [  2%]
# tests/test_auth.py::test_login_invalid_password PASSED            [  4%]
# ...
# tests/test_api.py::test_get_users PASSED                         [ 95%]
# tests/test_api.py::test_create_user PASSED                       [100%]
#
# ======================== 42 passed in 8.23s ========================

Flag --rm memastikan container otomatis dihapus setelah proses selesai, sehingga tidak ada sisa yang mengotori sistem. Ini adalah pola yang sangat ideal untuk GitHub Actions, GitLab CI, atau Jenkins.

Skenario 5: Menginspeksi dan debugging container yang bermasalah

Ketika container berperilaku tidak sesuai harapan, Docker menyediakan berbagai alat untuk menginspeksi keadaan internal container tanpa perlu menghentikannya.

# Melihat log container yang bermasalah
docker logs --tail 50 myapp-web-1

# Output:
# [2024-01-15 08:32:11] INFO: Starting server on 0.0.0.0:5000
# [2024-01-15 08:32:15] ERROR: Cannot connect to database at db:5432
# [2024-01-15 08:32:16] WARNING: Retrying connection in 5 seconds...
# [2024-01-15 08:32:21] ERROR: Connection timeout after 3 attempts
# Masuk ke dalam container untuk debugging interaktif
docker exec -it myapp-web-1 sh

# Di dalam container:
# /app $ ls
# Dockerfile  main.py  requirements.txt  templates/
# /app $ cat /etc/os-release
# NAME="Alpine Linux"
# VERSION_ID=3.18.4
# /app $ ping db
# PING db (172.18.0.2): 56 data bytes
# 64 bytes from 172.18.0.2: seq=0 ttl=64 time=0.123 ms
# /app $ exit

Perintah docker exec -it membuka shell interaktif di dalam container, memungkinkan Anda memeriksa filesystem, environment variable, konektivitas jaringan, dan proses yang berjalan—persis seperti SSH ke server tradisional, namun jauh lebih cepat dan aman.

Kesalahan Umum

Meskipun Docker dirancang untuk menyederhanakan proses deployment, terdapat sejumlah kesalahan umum yang sering dilakukan oleh developer terutama yang baru mengenal teknologi ini. Kesalahan-kesalahan ini tidak hanya menyebabkan image menjadi besar dan lambat, tetapi juga bisa membuka celah keamanan yang serius di environment production.

Kesalahan 1: Menjalankan container sebagai root user

Secara default, Docker menjalankan semua proses di dalam container sebagai user root. Banyak developer tidak menyadari ini dan membiarkan konfigurasi default, padahal jika penyerang berhasil menemukan vulnerability di aplikasi yang berjalan di container, mereka akan memiliki akses root di dalam container tersebut. Meskipun container terisolasi dari host, kombinasi dengan vulnerability container escape bisa memberikan akses root ke seluruh mesin host. Ini bukan skenario teoretis—beberapa CVE serius di masa lalu memungkinkan escape dari container dengan akses root.

Koreksi yang benar adalah selalu membuat dan menggunakan user non-root di Dockerfile:

# SALAH - berjalan sebagai root (default)
FROM node:18-alpine
WORKDIR /app
COPY . .
RUN npm install
CMD ["node", "server.js"]

# BENAR - membuat dan menggunakan user non-root
FROM node:18-alpine
WORKDIR /app
COPY . .
RUN npm install && \
    addgroup -S appgroup && \
    adduser -S appuser -G appgroup
USER appuser
CMD ["node", "server.js"]

Perhatikan bahwa USER appuser ditempatkan setelah semua operasi yang membutuhkan akses root (seperti npm install yang menulis ke direktori sistem) dan sebelum CMD yang menjalankan aplikasi. Pendekatan ini memastikan proses aplikasi berjalan dengan privilege minimal yang diperlukan.

Kesalahan 2: Tidak memanfaatkan build cache secara optimal

Docker menyimpan cache dari setiap layer yang berhasil dibangun dan akan menggunakan ulang cache tersebut jika instruksi dan konteksnya tidak berubah. Namun, banyak developer menempatkan COPY . . di awal Dockerfile sebelum instruksi yang menginstal dependensi. Akibatnya, setiap kali ada perubahan kecil pada kode sumber—bahkan hanya mengubah satu baris komentar—seluruh layer instalasi dependensi harus dibangun ulang dari awal. Untuk proyek dengan ratusan dependensi, ini bisa memakan waktu 10 hingga 30 menit untuk setiap build.

Koreksi yang benar adalah menyalin file dependensi terlebih dahulu, menjalankan instalasi, baru kemudian menyalin kode sumber:

# SALAH - setiap perubahan kode memicu reinstall seluruh dependensi
FROM python:3.11-slim
WORKDIR /app
COPY . .
RUN pip install -r requirements.txt
CMD ["python", "app.py"]

# BENAR - layer pip install di-cache selama requirements.txt tidak berubah
FROM python:3.11-slim
WORKDIR /app
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt
COPY . .
CMD ["python", "app.py"]

Dengan struktur ini, jika Anda memodifikasi app.py tanpa mengubah requirements.txt, Docker akan menggunakan cache untuk layer pip install dan hanya membangun ulang layer COPY . . yang memakan waktu beberapa detik. Perbedaan waktu build bisa sangat dramatis—dari 20 menit menjadi 5 detik untuk perubahan kode kecil.

Tips Debugging Docker yang Efektif

Ketika menghadapi masalah dengan Docker, pendekatan sistematis akan menghemat waktu dan frustrasi yang signifikan. Pertama, selalu periksa log container dengan docker logs <container> sebelum melakukan apapun. Log seringkali mengandung pesan error yang langsung menunjuk ke akar masalah. Jika container langsung exit setelah dijalankan, tambahkan flag --restart=no dan gunakan docker logs pada container yang sudah berhenti—Docker tetap menyimpan log meskipun container tidak berjalan.

Kedua, gunakan docker inspect <container> untuk melihat konfigurasi lengkap container termasuk environment variable, volume mount, dan network setting. Seringkali masalah disebabkan oleh environment variable yang salah atau volume yang tidak_termount dengan benar, dan docker inspect akan menunjukkan hal ini secara eksplisit.

Ketiga, jika build gagal di layer tertentu, Anda bisa menjalankan container interaktif dari layer sebelumnya menggunakan docker run -it <image_id> sh di mana image_id adalah ID layer yang berhasil terakhir kali dibangun. Dari dalam container, Anda bisa menjalankan perintah yang gagal secara manual dan melihat pesan error lengkap tanpa terpotong oleh proses build Docker.

Keempat, untuk masalah networking antar container, pastikan kedua container berada di network yang sama. Jalankan docker network ls untuk melihat daftar network dan docker network inspect <network> untuk memastikan container terdaftar di network tersebut. Jika container tidak bisa saling berkomunikasi, kemungkinan besar mereka berada di network yang berbeda.

Kelima, untuk masalah ukuran image yang membengkak, gunakan docker history <image> untuk melihat kontribusi setiap layer terhadap ukuran total. Tool seperti dive juga sangat membantu untuk menganalisis setiap layer image secara visual. Seringkali, file sementara atau cache yang tidak dibersihkan pada layer RUN menyebabkan ukuran image tidak perlu besar—solusinya adalah menggabungkan perintah instalasi dan pembersihan dalam satu instruksi RUN sehingga file sementara tidak tersimpan di layer terpisah.