Mikä on Dockerfile ja kuinka kirjoitat sellaisen?

Question

Accepted Answer

**Dockerfile** on tekstitiedosto, joka sisältää ohjeita **Docker-kuvan rakentamiseen** — se kuvailee perusrakenteen, riippuvuudet, kopioitavat tiedostot ja sovelluksen suoritustavan. Se tekee kuvan rakentamisesta toistettavaa ja versionhallittavaa.

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

## Keskeiset käskyt

```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 (usein sekoitettu)

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

## Miksi sillä on merkitystä

Dockerfile-ymmärrys on olennaista, koska se on tapa, jolla Docker-kuvat rakennetaan, joten sen kirjoittaminen on perustavanlaatuinen, päivittäinen Docker-taito.

Dockerfile tarjoaa **toistettavat, versionhallittavat kuvan rakentamisprosessit** — kuvaa koodissa tarkalleen, kuinka kuva rakennetaan (perusrakenne, riippuvuudet, tiedostot, konfiguraatio ja suorituskäsky), joten kuka tahansa voi rakentaa saman kuvan johdonmukaisesti. Tämä on Dockerin toistettavuusarvon ydin.

**Avainten käskyjen** ymmärtäminen — `FROM` (perusrakenne), `WORKDIR`, `COPY` (tiedostojen tuominen), `RUN` (rakentamisen aikaisten käskyjen suoritus kuten pakettien asentaminen), `ENV`, `EXPOSE` ja `CMD`/`ENTRYPOINT` (määrittävät mitä suoritetaan säiliön käynnistyessä) — on välttämätöntä tehokkaille Dockerfile-tiedostoille oikeissa sovelluksissa.

Erityisen tärkeä ja usein sekoitettu ero on **`RUN` vs `CMD` vs `ENTRYPOINT`**: `RUN` suoritetaan **rakentamisen aikana** (kuvan rakentaminen, esim. pakettien asentaminen), kun taas `CMD`/`ENTRYPOINT` määrittävät mitä suoritetaan **säiliön käynnistyessä** (sovelluksen komento) — tämän ymmärtäminen estää yleisiä virheitä.

Praktisten mallien tuntemus (kuten riippuvuustiedostojen kopioiminen ennen koodia paremman kerroksen välimuistiin ottamisen vuoksi) kuvastaa tehokkaiden Dockerfile-tiedostojen kirjoittamista.

Koska kuvan rakentaminen on perustavanlaatuista Dockerin käyttöä (jokainen Docker-työnkulku sisältää kuvia, ja Dockerfile on tapa, jolla omat kuvat rakennetaan), ja koska käskyjen ja rakentamisen aikana versus suoritusaikana tapahtuvan prosessin ero on välttämätön oikeiden ja tehokkaiden kuvien luomiselle, Dockerfile-ymmärrys on olennaista, usein sovellettavaa Docker-tietoa — ydintyökalua kenelle tahansa Dockeria käyttävälle, mekanismi, joka muuttaa Dockerin toistettavuuden lupauksen käytäntöön ja lähes yleiversaali vaatimus sovellusten containeroimiselle.