Cad é an build context agus cén fáth a úsáid comhad .dockerignore?

Question

Accepted Answer

Nuair a bhíonn tú ag rith `docker build`, cuireann Docker an **build context** (na comhaid sa bhreiseán tógála) ar aghaidh chuig an daemon. Eisionna comhad **.dockerignore** comhaid nach bhfuil ag teastáil ón chomhthéacs seo — ag luas suas na tógálacha, ag laghdú méid an íomhá, agus ag seachaint a bheith ag scaipeadh comhad íogair.

## An build context

```bash
docker build -t myapp .     # the "." is the build context — the directory sent to the daemon
# → Docker tarballs the ENTIRE context directory and sends it to the daemon BEFORE building
# → a big context (node_modules, .git, large files) = slow builds, more data transferred
```

Is é an **build context** an tacar comhad a chuireann Docker ar aghaidh chuig an daemon chun an íomhá a thógáil. Áirítear gach rud sa bhreiseán tógála mura bhfuil sé eisiata — mar sin bíonn breiseán ramhar ag moilliú gach tógála.

## .dockerignore — comhaid nach bhfuil ag teastáil a eisiata

```text
# .dockerignore (like .gitignore, for the build context)
node_modules        # don't send local deps (they're installed in the image anyway)
.git                # don't send version history
*.log
.env                # ⚠️ don't send SECRETS into the build context/image
Dockerfile
dist
.vscode
```

Oibríonn `.dockerignore` cosúil le `.gitignore`, ag eisiata comhad ón build context.

## Cén fáth a bhíonn tábhacht ann (trí bhuntáiste)

```text
✓ FASTER builds — a smaller context transfers faster; fewer files to process
  (also helps caching: COPY . . won't be invalidated by irrelevant file changes)
✓ SMALLER images — excluded files (node_modules, .git) don't get COPYed into the image
✓ SECURITY — keep SECRETS (.env, keys, credentials) out of the context AND the image
  (a COPY . . could otherwise copy a .env file into the image — a real leak risk)
```

## Cén fáth a bhíonn tábhacht ann

Is fiúntach an build context agus `.dockerignore` a thuiscint do **tógálacha Docker éifeachtúla agus slán**, ionas gur fiosrúchán úsáideach praiticiúil a thugann sé.

Ní thuigeann go leor forbróirí go gcuireann `docker build .` an **geilleagar iomlán an build-context go dtí an daemon** ar aghaidh sula dtógann sé — mar sin fágann breiseán ramhar (ina bhfuil `node_modules`, `.git`, artefachtaí tógála, comhaid mhóra) gach tógála níos moille (níos mó sonraí a aistriú agus a phróiseáil) agus bíonn baol ann go gcopóir sé comhad nach bhfuil ag teastáil isteach san íomhá.

Tugann an comhad **.dockerignore** (ag gníomhú cosúil le `.gitignore`) deis do seo a réiteach le trí bhuntáiste dhomhanda: **tógálacha níos gasta** (aistrítear breiseán níos lú agus próiseáiltear níos tapa, agus freisin feabhas ar bharrchaighdeán na sraithe de bharr nach mbeidh `COPY . .` neamhbhailí de bharr athruithe ar chomhaid dhíbheirteacha), **íomháanna níos lú** (ní chóipeálfar comhaid eisiata — m.sh. gan `node_modules` áitiúil a bhundúil agus a thógáil arís), agus go tabhachtach **slándáil** (ag coinneáil **rúnda cosúil le comhaid `.env`, eochracha, agus dintiúir as an build context agus íomhá** — de bharr go bhcopóirfeadh `COPY . .` `.env` isteach san íomhá ar shlí eile, baol fíor agus coitianta scéimh-dhíbhirce).

Tá an buntáiste slándála seo go háirithe tábhachtach, agus go minic a bhíonn gealadh ag faillí agus comhaid íogair a bhacadh isteach in íomháanna trí chóip i bhfad róleathan — is dochar is simplí a choisc `.dockerignore` é.

De bharr go dtarlaíonn tógálacha i gcónaí agus go bhfuil éifeachtúlacht tógála, méid íomhá, agus seachaint ar scéimh-dhíbhirc ina chóir, agus de bharr go laghdaíonn tuiscint ar an build context agus úsáid a bhaint as `.dockerignore` go díreach gach ceann de na trí cinn seo, tá fiosrúchán Docker is fiúntach, praiticiúil-iomchuí ann — cleachtas simplí ach tábhachtach do thógálacha tapa, geal, agus slán atá éasca a ligint i ndearmad ach atá bríomhar, go háirithe chun rúnda gan dúil a bheith isteach in íomháanna a sheachaint.