Cad is Dockerfile ann agus conas a scríobhann tú ceann?

Question

Accepted Answer

Is **Dockerfile** ina bhfail sé ina fhíneáil téacs le treoracha chun **íomhá Docker a thógáil** — déanann sé cur síos ar an bhunímhá, na spleáchais, na comhaid le a chóipeáil, agus conas an feidhmchlár a rith. Déanann sé tógálacha íomhá athcheanúil agus inchreat-rialúil.

## Dockerfile bunúsach

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

## Treoracha eochair

```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 (go minic mearbhaithe)

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

## An fáth a bhfuil tábhacht ann

Is riachtanach a bheith tuigthe ar an Dockerfile toisc gur seo a bhealach atá ag Docker chun íomhánna a thógáil, mar sin is scil bhunúsach, laethúil Docker a bhíonn i scríobh ceann.

Soláthaíonn Dockerfile **tógálacha íomhá athcheanúil, inchreat-rialúil** — cur síos i gcód ar an bhealach ar dhócha duit íomhá a thógáil go beacht (an bunímhá, na spleáchais, na comhaid, cumraitheoireacht, agus an t-ordú rith), ionas gur féidir le duine ar bith an íomhá céanna a thógáil go seasmhach, rud atá lárnach d'fhiúntas Docker maidir le hathoiregacht.

Tá gá a bheith ar an eolas agat na **treoracha eochair** — `FROM` (an bunímhá), `WORKDIR`, `COPY` (ag foluain comhaid isteach), `RUN` (orduithe infhorghníomhaithe ag am tógála a rith, ar nós pacáistí a shuiteáil), `ENV`, `EXPOSE`, agus `CMD`/`ENTRYPOINT` (ag sainmhíniú ar a ritheann nuair a thosnaíonn an coimeádán) — d'fhonn Dockerfiles éifeachtúil a scríobh do fhíorfheidhmchláir.

Is dian-thábhachtach agus go minic mearbhaithe an idirdhealú idir **`RUN` vs `CMD` vs `ENTRYPOINT`**: fhorghníomhaíonn `RUN` ag **am tógála** (an íomhá a thógáil, m.sh. pacáistí a shuiteáil), cé go sainmhíníonn `CMD`/`ENTRYPOINT` ar a ritheann ag **tosú an choimeádáin** (an t-ordú feidhmchláir) — briseann a thuiscint ar seo rian mearbhaill a dhíorthaíonn níos coitianta.

A bheith ar an eolas ar bharpatrúin phraicticiúla (ar nós comhad spleáchais a chóipeáil roimh chód d'fhéarchaching sraithe níos fearr) léiríonn scríobh Dockerfiles éifeachtúil.

Toisc go bhfuil tógáil íomhánna bunúsach do dhul i bhfeidhm Docker (gach fhobair Docker bhaineann le híomhánna, agus is é an Dockerfile an dóigh ar thógtar íomhánna saincheaptha), agus toisc go bhfuil gá le tuiscint ar na treoracha agus an idirdhealú idir am-tógála agus am-reatha d'fhonn íomhánna cearta, éifeachtúil a chruthú, tá tuiscint ar an Dockerfile ríachtanach, eolas Docker a chuirtear i bhfeidhm go rialta — scil bhunúsach d'aon duine ag úsáid Docker, an meicníc a chasann tiomantas athcheanúil Docker í i gcleachtas agus gné-riachtanais fhairsinge beagnach chun feidhmchláir a chur i gcoimeádáin.