Apa itu Docker? #

Docker adalah salah satu teknologi yang paling berpengaruh dalam dunia software engineering modern. Hampir semua engineer backend, DevOps, dan cloud engineer pernah — atau sedang — bekerja dengan Docker setiap hari. Ia menjadi pondasi untuk microservices, fondasi untuk Kubernetes, dan standar de facto untuk packaging aplikasi di era cloud-native.

Pertanyaan yang sering muncul dari pemula biasanya bukan “Docker itu apa?” — karena jawabannya mudah dicari. Pertanyaan yang lebih penting adalah: mengapa Docker muncul, masalah apa yang dipecahkannya, dan bagaimana konsep intinya benar-benar bekerja? Tanpa pemahaman itu, Docker hanya terasa seperti tool ajaib yang memunculkan container di layar terminal. Dengan pemahaman itu, Docker menjadi alat yang bisa kamu rancang, debug, dan optimalkan sesuai kebutuhan.

Artikel ini adalah pondasi untuk seluruh pembahasan di section Basic. Setelah membaca artikel ini, kamu akan memahami apa itu containerization, apa bedanya dengan pendekatan tradisional, apa saja komponen Docker, dan bagaimana alur kerja Docker dari kode di laptop sampai aplikasi berjalan di server production.

Containerization Sebelum Docker #

Untuk memahami Docker, kamu perlu memahami dulu masalah yang ingin dipecahkannya. Masalah itu bernama dependency hell dan environment drift.

Pada pendekatan tradisional, aplikasi dijalankan langsung di atas sistem operasi server. Library di-install global, versi runtime ditentukan oleh admin server, dan konfigurasi environment tersebar di banyak tempat. Hasilnya, aplikasi yang berjalan sempurna di laptop developer sering kali gagal di server staging, dan lebih sering lagi gagal di production.

Istilah legendaris yang muncul dari situasi ini adalah:

“Works on my machine.”

Containerization adalah pendekatan untuk mengemas aplikasi beserta seluruh dependency-nya ke dalam satu unit terisolasi yang portabel. Unit itu bisa dijalankan konsisten di mana pun — laptop developer, server internal, VM cloud, atau kluster Kubernetes.

flowchart LR
    A[Aplikasi Tradisional] --> B[Server: OS + Lib Global]
    C[Aplikasi Container] --> D[Container: App + Deps + Runtime]
    B --> E[Konflik dependency]
    D --> F[Konsisten di mana pun]

Wadah (container) bukan konsep baru. Unix sudah punya konsep chroot sejak 1979, dan FreeBSD punya jails di tahun 2000. Tapi containerization baru menjadi praktis dan populer ketika Docker hadir di tahun 2013, menyatukan teknologi Linux yang sudah ada (cgroups, namespaces, union filesystem) ke dalam tool yang mudah digunakan developer.

Definisi Docker #

Docker adalah platform open-source untuk membangun, mengemas, dan menjalankan aplikasi di dalam container. Docker menyediakan tiga hal utama:

• Build — alat untuk membuat image aplikasi dari sebuah recipe bernama Dockerfile.
• Ship — cara standar untuk mendistribusikan image melalui registry (Docker Hub, GHCR, ECR, dll).
• Run — runtime untuk menjalankan image menjadi container yang terisolasi di atas host.

Dalam satu kalimat yang ringkas:

Docker = cara standar untuk mengemas aplikasi + dependency menjadi image portabel, lalu menjalankannya sebagai container di mana pun.

Yang membuat Docker revolusioner bukan teknologi container-nya (itu sudah ada), tapi developer experience-nya. Sebelum Docker, membuat container berarti compile kernel patch, menulis script namespace manual, dan memahami internal Linux. Dengan Docker, cukup tulis docker run nginx dan container jalan dalam hitungan detik.

Sejarah Singkat Docker #

Docker pertama kali diperkenalkan pada tahun 2013 di acara PyCon US oleh Solomon Hykes, saat itu CTO dotCloud (perusahaan PaaS). Peluncuran Docker 0.1.0 terjadi di bulan Maret 2013, dan sejak itu pertumbuhannya eksponensial.

Latar belakangnya sederhana: dotCloud memiliki internal tool untuk mengemas dan menjalankan aplikasi di infrastruktur PaaS mereka. Tool itu bekerja sangat baik untuk tim internal, tapi tidak pernah diperluas keluar. Solomon dan tim memutuskan untuk open-source teknologi itu — itulah Docker.

timeline
    1979 : chroot - isolasi filesystem pertama di Unix
    2000 : FreeBSD Jails - konsep jail untuk proses
    2008 : LXC - Linux Containers, gabungkan cgroups + namespaces
    2013 : Docker 0.1.0 - dirilis di PyCon US
    2014 : Docker 1.0 - stabil, adopsi industri mulai
    2015 : OCI terbentuk - standar container terbuka
    2016 : Kubernetes 1.4 + Docker - orkestrasi mainstream
    2020 : Docker Compose v2, BuildKit - toolchain modern
    2023 : Docker 25+ - fokus keamanan, rootless, multi-arch

Docker tidak sendirian. Tahun 2015, Open Container Initiative (OCI) didirikan di bawah Linux Foundation untuk menstandarkan format container — image spec dan runtime spec. Hasilnya, image yang dibuat Docker bisa dijalankan oleh containerd, CRI-O, Podman, dan runtime lain yang compliant dengan OCI.

Ini penting untuk dipahami: Docker adalah produk (tool dengan CLI dan daemon), bukan standar. Standarnya adalah OCI. Docker hanya implementasi yang paling populer.

Catatan sejarah:

• Logo Docker (moby whale + container) terinspirasi dari konsep “container shipping” di dunia logistik. Metafora-nya sama: container Docker mengemas barang dengan format standar yang bisa diangkut oleh kapal (server) apa pun.
• Nama “Moby” adalah nama maskot Docker (paus). Beberapa sub-project Docker menggunakan nama ini, misalnya Moby Project untuk komponen open-source-nya.

Cara Kerja Docker di Tingkat Sistem #

Sebelum masuk ke komponen, pahami dulu alur besarnya. Docker bekerja dalam tiga tahap utama.

flowchart LR
    A[Dockerfile] -->|docker build| B[Docker Image]
    B -->|docker push| C[Registry]
    C -->|docker pull| D[Host Docker]
    B -->|docker run| D
    D --> E[Container]
    E --> F[App berjalan]

1. Build — Developer menulis Dockerfile, lalu menjalankan docker build. Docker menghasilkan image yang bersifat read-only dan layered.
2. Ship — Image di-push ke registry (Docker Hub, GHCR, ECR, dll) agar bisa dibagikan ke tim atau environment lain.
3. Run — Di host manapun yang punya Docker Engine, image di-pull dan dijalankan dengan docker run. Image menjadi container — proses yang berjalan di atas kernel host dengan isolasi namespace dan cgroups.

Yang perlu kamu garis bawahi: image dan container adalah dua hal berbeda. Image adalah blueprint (file). Container adalah proses runtime (instance) yang dibuat dari image.

Komponen Inti Docker #

Docker terdiri dari lima komponen utama yang harus kamu pahami. Setelah memahami semuanya, semua perintah Docker terasa masuk akal.

Image #

Image adalah template read-only yang berisi semua yang dibutuhkan untuk menjalankan aplikasi: base OS, runtime, library, kode, dan konfigurasi default.

Karakteristik image:

• Read-only — image tidak bisa dimodifikasi setelah dibuat. Perubahan disimpan di container layer yang terpisah.
• Layered — image tersusun dari layer-layer yang di-cache. Setiap instruksi di Dockerfile menghasilkan satu layer. Ini yang membuat build Docker cepat.
• Reusable — satu image bisa menjadi base untuk image lain (multi-stage build).

Bayangkan image seperti foto aplikasi pada satu titik waktu. Aplikasi yang sedang jalan bukan image — itu container.

flowchart TB
    subgraph Image["Docker Image"]
        L1[Layer 1: Base OS]
        L2[Layer 2: Runtime]
        L3[Layer 3: Library]
        L4[Layer 4: App Code]
    end
    L1 --> L2 --> L3 --> L4

Container #

Container adalah instance runtime dari sebuah image. Ia adalah proses Linux yang berjalan dengan namespace dan cgroups sendiri, sehingga terisolasi dari host dan container lain.

Karakteristik container:

• Ringan — berbagi kernel dengan host, tidak membawa OS sendiri.
• Terisolasi — punya filesystem, network, PID, dan user namespace sendiri.
• Ephemeral — idealnya sekali pakai. Data persisten harus disimpan di volume.
• Immutable — perubahan runtime ditulis di layer terpisah, bukan di image.

Satu container idealnya menjalankan satu proses utama. Misalnya satu container untuk web server, satu container untuk database, satu container untuk worker. Prinsip ini dikenal sebagai single concern atau one process per container.

Dockerfile #

Dockerfile adalah file teks berisi instruksi untuk membangun image. Ini adalah source of truth dari image — siapa pun bisa mereproduksi image yang sama persis dari Dockerfile yang sama.

Contoh Dockerfile minimal:

FROM golang:1.22-alpine
WORKDIR /app
COPY . .
RUN go build -o server
CMD ["./server"]

Setiap baris (FROM, WORKDIR, COPY, RUN, CMD) menghasilkan satu layer. Urutan baris menentukan cache hit — baris yang sering berubah sebaiknya disimpan di bawah.

// ANTI-PATTERN: COPY seluruh konteks build di awal, cache invalidated setiap ada perubahan kode
FROM node:20
WORKDIR /app
COPY . .
RUN npm install

// BENAR: COPY dependency definition dulu agar npm install bisa di-cache
FROM node:20
WORKDIR /app
COPY package*.json ./
RUN npm install
COPY . .

Prinsip ini akan dibahas mendalam di section Dockerfile, tapi intinya: urutan instruksi Dockerfile menentukan kecepatan build.

Docker Engine #

Docker Engine adalah runtime yang menjalankan container di sebuah host. Ia terdiri dari tiga bagian:

• Docker Daemon (dockerd) — proses background yang mengelola image, container, network, dan volume.
• REST API — antarmuka yang dipakai Docker CLI untuk berkomunikasi dengan daemon.
• Docker CLI (docker) — tool command line yang kamu ketik di terminal.

flowchart LR
    User -->|docker ...| CLI[Docker CLI]
    CLI -->|REST API| Daemon[Docker Daemon]
    Daemon -->|manage| Containers[(Containers)]
    Daemon -->|manage| Images[(Images)]
    Daemon -->|manage| Networks[(Networks)]
    Daemon -->|manage| Volumes[(Volumes)]

Saat ini, Docker Engine juga menyertakan containerd dan runc di dalamnya. Containerd adalah runtime tingkat tinggi yang mengelola lifecycle container; runc adalah runtime tingkat rendah yang benar-benar membuat proses container sesuai standar OCI.

Docker Registry #

Registry adalah tempat menyimpan dan mendistribusikan image. Registry bisa publik (siapa pun bisa akses) atau privat (terbatas untuk tim/organisasi).

Registry populer:

Alur kerja registry:

sequenceDiagram
    participant Dev as Developer
    participant Reg as Registry
    participant CI as CI Server
    participant Prod as Production
    
    Dev->>Dev: docker build -t app:1.0
    Dev->>Reg: docker push app:1.0
    CI->>Reg: docker pull app:1.0
    CI->>CI: run tests
    CI->>Reg: docker push app:1.1
    Prod->>Reg: docker pull app:1.1
    Prod->>Prod: docker run app:1.1

Image yang sama persis yang diuji di CI akan di-deploy ke production. Tidak ada “tapi di production pakai library yang berbeda”. Inilah yang disebut immutable artifact — image adalah kontrak tunggal antara developer, CI, dan production.

Workflow Docker End-to-End #

Untuk melihat bagaimana semua komponen bekerja bersama, perhatikan workflow lengkap berikut.

flowchart TD
    A[Developer tulis kode] --> B[Tulis/Update Dockerfile]
    B --> C[docker build]
    C --> D{Tests pass?}
    D -- Tidak --> E[Fix kode]
    E --> B
    D -- Ya --> F[docker push ke Registry]
    F --> G[CI/CD pipeline trigger]
    G --> H[Deploy ke Staging]
    H --> I{Staging OK?}
    I -- Tidak --> E
    I -- Ya --> J[Deploy ke Production]
    J --> K[Container jalan di server/cloud]

Pada praktiknya, kamu tidak menjalankan langkah-langkah ini secara manual. Semuanya diotomasi oleh CI/CD pipeline (GitHub Actions, GitLab CI, Jenkins, dll). Developer cukup push kode ke Git, dan pipeline mengambil alih: build image, jalankan test, push ke registry, deploy.

Kesalahan umum: Banyak tim yang menjalankan Docker di laptop tapi deploy masih manual SSH ke server. Ini setengah-setengah. Docker tanpa otomasi CI/CD hanya menyelesaikan masalah “konsistensi environment” tapi tidak masalah “kecepatan dan keandalan deployment”. Untuk nilai penuh Docker, otomasi deployment adalah wajib, bukan opsional.

Mengapa Docker Begitu Berpengaruh #

Docker bukan sekadar tool — ia mengubah cara industri software bekerja. Ada beberapa faktor yang membuat Docker menjadi standar de facto.

Konsistensi total. Image yang sama berjalan di laptop, staging, dan production. Tidak ada lagi perbedaan OS host, versi library, atau konfigurasi lokal yang lolos.

Onboarding cepat. Developer baru bisa menjalankan seluruh stack aplikasi dengan satu perintah (docker compose up) tanpa install dependency satu per satu. Yang dibutuhkan hanya Docker.

Resource efisien. Container jauh lebih ringan dari VM. Satu host bisa menjalankan puluhan container tanpa overhead guest OS.

Ekosistem yang matang. Docker bukan berdiri sendiri — ia bagian dari ekosistem besar: Docker Compose untuk multi-container, Kubernetes untuk orkestrasi, Helm untuk templating, registry untuk distribusi, dll.

Standar industri. Hampir semua cloud provider (AWS, GCP, Azure) menawarkan layanan container yang kompatibel dengan image Docker OCI. Bahasa pemrograman, framework, dan tool modern sudah container-first.

mindmap
  root((Docker))
    Build
      Dockerfile
      BuildKit
      Multi-stage
    Ship
      Docker Hub
      GHCR
      ECR
    Run
      Docker Engine
      containerd
      Podman alt
    Orchestrate
      Compose
      Swarm
      Kubernetes
    Monitor
      cAdvisor
      Prometheus
      Grafana

Docker vs Pendekatan Tradisional #

Untuk memperjelas posisi Docker, bandingkan dengan dua pendekatan yang umum sebelum-nya: bare metal dan virtual machine.

Docker bukan pengganti VM di semua situasi. VM masih unggul untuk:

• Menjalankan OS berbeda di satu host (Windows di host Linux, misalnya).
• Workload yang butuh isolasi keamanan sangat ketat (regulated environment, multi-tenant).
• Aplikasi legacy yang tidak kompatibel dengan kernel host.

Container unggul di hampir semua workload modern: web service, API, worker, job processor, microservice, batch processing. Karena itulah kombinasi VM + Container adalah pola paling umum di production — VM menjadi infrastructure boundary, container menjadi application unit.

Ekosistem di Sekitar Docker #

Docker adalah titik masuk, bukan tujuan akhir. Setelah paham Docker, kamu akan menemukan tool lain yang bekerja di atas atau di sampingnya.

Untuk pemula: Jangan coba pelajari semuanya sekaligus. Pahami Docker dulu, lalu Docker Compose, baru mulai lihat Kubernetes saat kamu benar-benar butuh orkestrasi multi-host. Urutan ini mencerminkan learning curve yang sehat.

Istilah yang Wajib Kamu Tahu #

Sebelum lanjut ke artikel berikutnya, pastikan kamu familiar dengan istilah-istilah ini. Mereka akan muncul di seluruh section Docker.

• Image — template read-only berisi aplikasi + dependency.
• Container — instance runtime dari image.
• Dockerfile — recipe untuk membangun image.
• Layer — bagian dari image yang dihasilkan tiap instruksi Dockerfile.
• Registry — tempat menyimpan image.
• Tag — penanda versi image (misal nginx:1.25).
• Volume — tempat menyimpan data persisten di luar container.
• Network — mekanisme komunikasi antar container dan host.
• Docker Compose — tool untuk mendefinisikan dan menjalankan multi-container.
• Orchestrator — tool untuk mengelola banyak container di banyak host (Kubernetes, Swarm).

Ringkasan #

• Docker adalah platform open-source untuk membangun, mengemas, dan menjalankan aplikasi di dalam container. Ia muncul tahun 2013 dan menjadi standar industri untuk containerization.
• Container adalah unit terisolasi di level proses OS, bukan emulasi hardware seperti VM. Ia ringan, portabel, dan konsisten.
• Image adalah blueprint read-only; Container adalah instance runtime dari image. Perbedaan ini fundamental dan sering keliru dipahami pemula.
• Dockerfile adalah source of truth untuk image. Urutan instruksi menentukan kecepatan build karena Docker menggunakan layer cache.
• Docker Engine = daemon + CLI + API. Ia bukan standar — standarnya adalah OCI (Open Container Initiative).
• Registry adalah distribusi image: Docker Hub, GHCR, ECR, dll. Image yang sama yang dites di CI harus sama dengan yang dideploy ke production.
• Docker ≠ VM. VM mengisolasi di level hardware dengan guest OS. Container mengisolasi di level kernel dengan namespace + cgroups. Keduanya saling melengkapi, bukan saling menggantikan.
• Ekosistem Docker luas: Compose, BuildKit, containerd, Kubernetes, dll. Pahami Docker dulu, baru naik ke tool di atasnya.