Build context என்றால் என்ன மற்றும் .dockerignore file ஐ ஏன் பயன்படுத்த வேண்டும்?

Question

Accepted Answer

`docker build` ஐ இயக்கும்போது, Docker build directory இல் உள்ள files (build context) ஐ daemon க்கு அனுப்புகிறது. **.dockerignore** file இந்த context ஐலிருந்து தேவையற்ற files ஐ除外 செய்கிறது — builds ஐ வேகமாக்கி, image size ஐ குறைத்து, sensitive files ஐ leak ஆவதை தடுக்கிறது.

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

**Build context** என்பது Docker daemon க்கு image ஐ build செய்ய அனுப்பும் files இன் set ஆகும். Build directory இல் உள்ள அனைத்தும் include ஆகிறது நீங்கள் exclude செய்யாவிட்டால் — எனவே bloated context ஐ ஒவ்வொரு build ஐயும் மெதுவாக்குகிறது.

## .dockerignore — தேவையற்ற files ஐ除外 செய்யுங்கள்

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

`.dockerignore` `.gitignore` போல் வேலை செய்து, build context இலிருந்து files ஐ除外 செய்கிறது.

## ஏன் இது முக்கியமாக உள்ளது (மூன்று நன்மைகள்)

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

## ஏன் இது முக்கியமாக உள்ளது

Build context மற்றும் `.dockerignore` ஐ புரிந்துகொள்வது **திறமையான மற்றும் பாதுகாப்பான Docker builds** க்கு மূல்யவானது, எனவே இது நடைமுறைக்குரிய பயனுள்ள அறிவாகும்.

நிறைய developers `docker build .` **முழு build-context directory ஐ daemon க்கு அனுப்புகிறது** என்பதை build செய்வதற்கு முன் உணர்ந்து கொள்ளாதவர்கள் — எனவே bloated context (`node_modules`, `.git`, build artifacts, பெரிய files ஐ கொண்டுள்ளது) **ஒவ்வொரு build ஐயும் மெதுவாக்குகிறது** (அதிக data ஐ transfer மற்றும் process செய்ய வேண்டும்) மற்றும் unwanted files ஐ image ஆக copy செய்யும் ஆபத்து உள்ளது.

**.dockerignore** file (`.gitignore` போல் வேலை செய்து) இதை மூன்று concrete நன்மைகளுடன் தீர்க்கிறது: **வேகமான builds** (சிறிய context வேகமாக transfer மற்றும் process ஆகிறது, மற்றும் layer caching ஐ மேம்படுத்துகிறது `COPY . .` irrelevant files ஆல் invalidate ஆவதை தடுக்கிறது), **சிறிய images** (除外 செய்யப்பட்ட files ஐ copy செய்யப்படாது — உ.தா. locally installed `node_modules` ஐ bundle செய்யாது அது anyways மீண்டும் install ஆகிறது), மற்றும் முக்கியமாக **security** (**.env** files, keys, மற்றும் credentials போன்ற **secrets ஐ build context மற்றும் image ஐ வெளியில் வைப்பது** — `COPY . .` அல்லாமல் `.env` ஐ image ஆக copy செய்யும், நிஜமான மற்றும் பொதுவான credential-leak ஆபத்து).

இந்த security benefit குறிப்பாக முக்கியமாக உள்ளது, secrets அல்லது sensitive files ஐ accidentally build செய்ய image ஆகக் கொள்வது `.dockerignore` தடுக்கும் நிஜமான தவறு.

Builds நிரந்தரமாக நடைபெறுவதால் மற்றும் build efficiency, image size, மற்றும் secret leaks தடுப்பது அனைத்தும் கணக்கு உள்ளது, மற்றும் build context மற்றும் `.dockerignore` ஐ புரிந்துகொள்வது மற்றும் பயன்படுத்துவது அனைத்து மூன்றையும் நேரடியாக மேம்படுத்துகிறது, build context மற்றும் `.dockerignore` ஐ புரிந்துகொள்வது மூல்யவான, நடைமுறைக்குரிய Docker அறிவு — வேகமான, lean, மற்றும் பாதுகாப்பான builds க்கு எளிய ஆனால் முக்கியமான practice ஆகும் அது overlook செய்ய எளிமையாக உள்ளது ஆனால் meaningfully impactful ஆகும், குறிப்பாக secrets ஐ accidentally include செய்வதை தடுப்பது images ல் ஆகும்.