File System & Layer #

Docker sering disebut sebagai teknologi containerization, tetapi salah satu kunci utama yang membuat Docker efisien, cepat, dan hemat storage adalah mekanisme filesystem berlapis (layered filesystem).

Banyak developer menggunakan Docker setiap hari tanpa benar-benar memahami:

• Bagaimana Docker menyimpan file di dalam image
• Mengapa build image bisa cepat
• Mengapa perubahan kecil bisa menghasilkan image baru
• Mengapa urutan instruksi Dockerfile itu penting

Untuk memudahkan pemahaman, perhatikan diagram konseptual berikut:

+---------------------------+
|   Container Writable Layer|  <- Perubahan runtime
+---------------------------+
|   Image Layer (RUN)       |
+---------------------------+
|   Image Layer (COPY)      |
+---------------------------+
|   Image Layer (FROM)      |
+---------------------------+
|   Base OS Filesystem      |
+---------------------------+

Diagram di atas menggambarkan bahwa Docker image terdiri dari banyak layer read-only, dan container menambahkan satu layer writable di paling atas.

Apa Itu Docker Filesystem? #

Docker tidak membuat filesystem baru dari nol. Docker memanfaatkan filesystem Linux yang mendukung:

• Copy-on-Write (CoW)
• Union filesystem

Dengan pendekatan ini, Docker bisa:

• Menggabungkan banyak filesystem menjadi satu tampilan logis
• Menghindari duplikasi file
• Menghemat disk dan mempercepat proses build

Filesystem inilah yang membuat Docker image bersifat immutable dan container bersifat ephemeral.

Konsep Union Filesystem #

Union filesystem memungkinkan beberapa filesystem digabung menjadi satu view.

Contoh sederhana:

Layer A: /app/main.go
Layer B: /app/config.yaml

Union View:
/app/main.go
/app/config.yaml

Docker menggunakan konsep ini untuk:

• Menumpuk layer image
• Menampilkan seolah-olah semua file ada dalam satu filesystem

Beberapa implementasi Union FS yang digunakan Docker:

• overlay2 (paling umum)
• aufs (legacy)
• btrfs
• zfs

Saat ini, overlay2 adalah default dan direkomendasikan.

Apa Itu Layer di Docker? #

Layer adalah snapshot filesystem yang bersifat read-only.

Setiap layer merepresentasikan:

• Satu perubahan filesystem
• Satu instruksi di Dockerfile

Contoh Dockerfile:

FROM alpine
RUN apk add curl
COPY app.sh /app.sh

Layer yang terbentuk:

1. Base layer: Alpine Linux
2. Layer RUN: hasil install curl
3. Layer COPY: file app.sh

Setiap layer:

• Tidak bisa diubah
• Bisa dipakai ulang oleh image lain

Hubungan Dockerfile dan Layer #

Prinsip penting:

Satu instruksi Dockerfile = satu layer baru

Instruksi yang membuat layer filesystem:

• RUN
• COPY
• ADD

Instruksi yang tidak membuat layer filesystem:

• CMD
• ENTRYPOINT
• ENV
• WORKDIR
• EXPOSE

Implikasi langsung:

• Urutan Dockerfile sangat berpengaruh
• Kesalahan urutan bisa membuat image besar
• Cache Docker bekerja per-layer

Copy-on-Write (CoW) #

Docker menggunakan mekanisme Copy-on-Write saat container berjalan.

Alurnya:

1. Container membaca file → langsung dari image layer
2. Container mengubah file → file disalin ke writable layer
3. Perubahan hanya terjadi di container tersebut

Ilustrasi:

Image Layer (read-only)
   |  /etc/config.yaml
   v
Container Writable Layer
   |  /etc/config.yaml (modified)

Hasilnya:

• Image tetap aman
• Container saling terisolasi
• Performa tetap tinggi

Writable Layer pada Container #

Saat container dibuat:

• Docker menambahkan satu writable layer di atas semua image layer

Karakteristik writable layer:

• Bersifat sementara
• Hilang saat container dihapus
• Tidak cocok untuk penyimpanan data permanen

Inilah alasan:

• Data database tidak boleh disimpan di filesystem container
• Volume dan bind mount menjadi solusi

Docker Image Bersifat Immutable #

Karena layer image bersifat read-only:

• Image tidak bisa diubah
• Setiap perubahan menghasilkan image baru

Keuntungan:

• Build reproducible
• Mudah rollback
• Konsisten antar environment

Konsep ini sangat penting dalam:

• CI/CD
• Infrastructure as Code
• Microservices

Layer Sharing dan Efisiensi Storage #

Docker menyimpan layer berdasarkan hash konten.

Jika dua image memiliki layer yang sama:

• Layer hanya disimpan satu kali di disk
• Digunakan bersama oleh banyak image

Contoh:

• 10 image berbasis alpine
• Base layer alpine hanya ada satu di storage

Inilah alasan Docker:

• Hemat storage
• Cepat saat pull image

Dampak Layer terhadap Build Performance #

Cache Docker bekerja berdasarkan layer:

• Jika instruksi dan konteks tidak berubah → layer di-cache
• Jika satu layer berubah → semua layer di bawahnya di-build ulang

Contoh buruk:

COPY . .
RUN npm install

Contoh lebih optimal:

COPY package.json package-lock.json ./
RUN npm install
COPY . .

Urutan ini memaksimalkan cache layer.

Best Practice Terkait Filesystem dan Layer #

Beberapa praktik penting:

1. Minimalkan jumlah layer

   • Gabungkan perintah RUN bila perlu

2. Urutkan instruksi dengan benar

   • Dependency lebih dulu, source code belakangan

3. Hindari menyimpan data di container filesystem

   • Gunakan volume atau external storage

4. Gunakan base image kecil

   • alpine, distroless, scratch

5. Pahami cache layer sebelum optimasi

   • Jangan asal menggabungkan layer tanpa alasan

Penutup #

Filesystem dan layer adalah fondasi utama Docker.

Dengan memahami:

• Union filesystem
• Layer read-only
• Writable layer container
• Copy-on-Write

Anda akan:

• Lebih paham mengapa Docker bekerja sangat efisien
• Bisa menulis Dockerfile yang optimal
• Menghindari image besar dan build lambat