Apa iku Dockerfile lan piye carane nulis sawijining Dockerfile?

Question

Accepted Answer

A **Dockerfile** iku berkas teks sing duwe instruksi kanggo **membangun Docker image** — iku njlentrehke base image, dependensi, berkas sing kudu disalin, lan cara njalanke aplikasi. Iku gawenke build image bisa diulang lan bisa dikontrol versi.

## A basic Dockerfile

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

## Key instructions

```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 (commonly confused)

```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.
```

## Apa iku pentinge

Pamahaman babagan Dockerfile iku penting banget sebab iku carane Docker image dibangun, dadi nulis sawijining Dockerfile iku keahlian Docker sing fundamental lan sakathah dina.

Sawijining Dockerfile nyedhiyake **build image sing bisa diulang lan bisa dikontrol versi** — njlentrehke ing kode persis carane mbuat image (base image, dependensi, berkas, konfigurasi, lan perintah jalanke), supaya sapa wae bisa membangun image sing padha kanthi konsisten, sing iku pusat saka nilai Docker yaiku reproducibility.

Pamahaman babagan **instruksi kunci** — `FROM` (base image), `WORKDIR`, `COPY` (ngebawa berkas), `RUN` (njalani perintah saat build kayata nginstall dependensi), `ENV`, `EXPOSE`, lan `CMD`/`ENTRYPOINT` (menerangke apa sing dijalanke nalika container mudhun) — iku kudu dingerteni kanggo nulis Dockerfile sing epektif kanggo aplikasi nyata.

Perbedaan sing nomer siji lan akeh sing salah paham iku **`RUN` vs `CMD` vs `ENTRYPOINT`**: `RUN` njalani saat **wektu build** (mbuat image, contone nginstall paket), dene `CMD`/`ENTRYPOINT` nemtokake apa sing dijalanke saat **container mudhun** (perintah aplikasi) — pamahaman iki nyegah kesalahan sing umum.

Ngetung pola praktis (kayata ngsalin berkas dependensi sadurunge kode kanggo layer cache sing luwih apik) nunjukake nulis Dockerfile sing efisien.

Sebab build image iku fundamental kanggo nggunakake Docker (saben Docker workflow melibatke image, lan Dockerfile iku carane custom image dibangun), lan sebab pamahaman babagan instruksi lan perbedaan build-time-vs-runtime iku kudu dingerteni kanggo nggawe image sing bener lan efisien, pamahaman babagan Dockerfile iku penting banget, sering diterapake pengetahuan Docker — keahlian inti kanggo sapa wae sing nggunakake Docker, mekanisme sing gawenke janji reproducibility Docker dadi praktik lan syarat sing meh universal kanggo containerisasi aplikasi.