Kas yra Dockerfile ir kaip jį rašyti?

Question

Accepted Answer

**Dockerfile** yra tekstinis failas su instrukcijomis **Docker atvaizdui kurti** — jame aprašomas bazinis atvaizdas, priklausomybės, kopijuotini failai ir kaip paleisti aplikaciją. Tai daro atvaizdų kūrimą pasikartojančiu ir versija kontroliuojamu.

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

## Pagrindinės instrukcijos

```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 (dažnai supainiojama)

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

## Kodėl tai svarbu

Supratimas apie Dockerfile yra esmingas, nes tai yra Docker atvaizdų kūrimo būdas, todėl vieno parašymas yra fundamentalus, kasdieninis Docker įgūdis.

Dockerfile užtikrina **pasikartojančius, versija kontroliuojamus atvaizdų kūrimus** — apibūdinant kodu tiksliai, kaip sukonstruoti atvaizdą (bazinis atvaizdas, priklausomybės, failai, konfigūracija ir paleisties komanda), todėl bet kas gali nuosekliai sukurti tą patį atvaizdą, o tai yra pagrindinė Docker reproduktyvumo vertė.

Supratimas apie **pagrindines instrukcijas** — `FROM` (bazinis atvaizdas), `WORKDIR`, `COPY` (failų atnešimas), `RUN` (kūrimo metu atliekami prikazai, pavyzdžiui, priklausomybių diegimas), `ENV`, `EXPOSE` ir `CMD`/`ENTRYPOINT` (apibrėžiant, kas vyksta paleidžiant konteinerį) — yra būtinas norint parašyti veiksmingus Dockerfiles tikroms aplikacijoms.

Ypač svarbi ir dažnai supainiojama distinkcija yra **`RUN` vs `CMD` vs `ENTRYPOINT`**: `RUN` vykdoma **kūrimo metu** (konstruojant atvaizdą, pvz., diegiant paketus), o `CMD`/`ENTRYPOINT` apibrėžia, kas vykdoma **konteinerio paleisties metu** (aplikacijos komanda) — supratimas apie tai išvengti dažnų klaidų.

Žinant praktinius šablonus (pavyzdžiui, priklausomybės failų kopijavimas prieš kodą siekiant geresnės sluoksnio cache'o) atspindi efektyvių Dockerfiles rašymą.

Kadangi atvaizdų kūrimas yra fundamentalus Docker naudojimui (kiekviename Docker darbo sraute yra atvaizdai, o Dockerfile yra tai, kaip kuriami pasirinktiniai atvaizdai), ir kadangi supratimas apie instrukcijas bei kūrimo laiko ir vykdymo laiko distinkcija yra būtinas norint sukurti teisingus, efektyvius atvaizdus, supratimas apie Dockerfile yra esmingas, dažnai taikomas Docker žinojimas — pagrindinė įgūdžių dalis bet kam, kuris naudoja Docker, mechanizmas, kuris Docker reproduktyvumo pažadą paverčia praktika, ir beveik universalus reikalavimas aplikacijoms kontainerizuoti.