Apa itu Dockerfile dan bagaimana cara menulisnya?

Question

Accepted Answer

Sebuah **Dockerfile** adalah file teks yang berisi instruksi untuk **membangun Docker image** — file ini mendeskripsikan image dasar, dependensi, file yang akan disalin, dan cara menjalankan aplikasi. File ini membuat pembangunan image reproducible dan dapat dikontrol versinya.

## Dockerfile dasar

```dockerfile
# FROM — the base image to build on
FROM node:20-alpine

# WORKDIR — set the working directory inside the image
WORKDIR /app

# COPY dependency files first (for better layer caching)
COPY package*.json ./
# RUN — execute a command during the BUILD (install dependencies)
RUN npm install

# COPY the rest of the application code
COPY . .

# EXPOSE — document the port the app listens on
EXPOSE 3000

# CMD — the command to run when a CONTAINER starts
CMD ["node", "server.js"]
```

## Instruksi kunci

```text
FROM     → the base image (starting point) — REQUIRED, usually first
WORKDIR  → set the working directory for subsequent instructions
COPY/ADD → copy files from the host into the image
RUN      → execute a command at BUILD time (install packages, compile) → creates a layer
ENV      → set environment variables
EXPOSE   → document which port(s) the container listens on
CMD      → the default command to run when the container STARTS (one per Dockerfile)
ENTRYPOINT → the executable that runs (CMD provides default args to it)
ARG      → build-time variables
```

## RUN vs CMD vs ENTRYPOINT (sering membingungkan)

```text
RUN        → runs at BUILD time (builds the image — e.g. install dependencies)
CMD        → runs at CONTAINER START (the default command; overridable at run)
ENTRYPOINT → the main executable at start (CMD becomes its default arguments)
→ RUN builds the image; CMD/ENTRYPOINT define what runs when it starts.
```

## Mengapa ini penting

Memahami Dockerfile sangat penting karena ini adalah cara Docker image dibangun, sehingga menulisnya adalah skill Docker fundamental yang digunakan sehari-hari.

Sebuah Dockerfile menyediakan **pembangunan image yang reproducible dan dapat dikontrol versinya** — mendeskripsikan dalam kode persis bagaimana cara membangun sebuah image (image dasar, dependensi, file, konfigurasi, dan perintah run), sehingga siapa pun dapat membangun image yang sama secara konsisten, yang merupakan inti dari nilai reproducibility Docker.

Memahami **instruksi kunci** — `FROM` (image dasar), `WORKDIR`, `COPY` (membawa file masuk), `RUN` (menjalankan perintah saat build seperti menginstal dependensi), `ENV`, `EXPOSE`, dan `CMD`/`ENTRYPOINT` (mendefinisikan apa yang dijalankan saat container dimulai) — diperlukan untuk menulis Dockerfile yang efektif untuk aplikasi nyata.

Perbedaan yang sangat penting dan sering membingungkan adalah **`RUN` vs `CMD` vs `ENTRYPOINT`**: `RUN` dieksekusi pada **waktu build** (membangun image, misalnya menginstal paket), sementara `CMD`/`ENTRYPOINT` mendefinisikan apa yang dijalankan pada **saat container dimulai** (perintah aplikasi) — memahami ini mencegah kesalahan umum.

Mengetahui pola praktis (seperti menyalin file dependensi sebelum kode untuk caching layer yang lebih baik) mencerminkan penulisan Dockerfile yang efisien.

Karena membangun image adalah fundamental untuk menggunakan Docker (setiap workflow Docker melibatkan image, dan Dockerfile adalah cara image kustom dibangun), dan karena memahami instruksi dan perbedaan build-time-vs-runtime diperlukan untuk membuat image yang benar dan efisien, memahami Dockerfile adalah essential dan frequently-applied Docker knowledge — core skill untuk siapa pun yang menggunakan Docker, mekanisme yang mengubah janji reproducibility Docker menjadi praktik dan persyaratan yang hampir universal untuk containerizing applications.