Apakah itu Dockerfile dan bagaimana anda menulisnya?

Question

Accepted Answer

Sebuah **Dockerfile** ialah fail teks dengan arahan untuk **membina Docker image** — ia menerangkan base image, kebergantungan, fail untuk disalin, dan cara menjalankan aplikasi. Ia menjadikan pembinaan image boleh dihasilkan semula dan boleh dikawal versi.

## Dockerfile asas

```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"]
```

## Arahan utama

```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 dikelirukan)

```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 ia penting

Memahami Dockerfile adalah penting kerana ia merupakan cara Docker image dibina, jadi menulisnya ialah kemahiran Docker asas yang digunakan setiap hari.

Sebuah Dockerfile menyediakan **pembinaan image yang boleh dihasilkan semula dan boleh dikawal versi** — menerangkan dalam bentuk kod dengan tepat cara membina sesuatu image (base image, kebergantungan, fail, konfigurasi, dan arahan run), supaya sesiapa sahaja boleh membina image yang sama secara konsisten, yang merupakan teras kepada nilai kebolehulangan Docker.

Memahami **arahan utama** — `FROM` (base image), `WORKDIR`, `COPY` (membawa masuk fail), `RUN` (menjalankan arahan masa-bina seperti memasang kebergantungan), `ENV`, `EXPOSE`, dan `CMD`/`ENTRYPOINT` (mentakrifkan apa yang berjalan apabila container bermula) — adalah perlu untuk menulis Dockerfile yang berkesan untuk aplikasi sebenar.

Perbezaan yang sangat penting dan sering dikelirukan ialah **`RUN` vs `CMD` vs `ENTRYPOINT`**: `RUN` dilaksanakan pada **masa-bina** (membina image, cth. memasang pakej), manakala `CMD`/`ENTRYPOINT` mentakrifkan apa yang berjalan pada **permulaan container** (arahan aplikasi) — memahami ini mengelakkan kesilapan biasa.

Mengetahui corak praktikal (seperti menyalin fail kebergantungan sebelum kod untuk caching layer yang lebih baik) mencerminkan penulisan Dockerfile yang cekap.

Memandangkan membina image adalah asas kepada penggunaan Docker (setiap aliran kerja Docker melibatkan image, dan Dockerfile ialah cara image tersuai dibina), dan memandangkan memahami arahan serta perbezaan masa-bina-berbanding-runtime adalah perlu untuk mencipta image yang betul dan cekap, memahami Dockerfile ialah pengetahuan Docker yang penting dan kerap digunakan — kemahiran teras untuk sesiapa yang menggunakan Docker, mekanisme yang mengubah janji kebolehulangan Docker menjadi amalan serta keperluan hampir universal untuk men-containerize aplikasi.