რა არის build context და რატომ გამოვიყენოთ .dockerignore ფайл?

Question

Accepted Answer

როდესაც თქვენ აკმაყოფილებთ `docker build`, Docker აგზავნის **build context**-ს (ფайლებს build დირექტორიაში) daemon-ს. **.dockerignore** ფайল ამ context-ს აირიდებს არასაჭირო ფайლებს — სწრაფი build, უფრო მცირე image size და მგრძნობიარე ფაილების გაჟონვის თავიდან აცილება.

## 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 დირექტორიაში ყველაფერი შედის მხოლოდ რომ გამორიცხული არ იყოს — ამიტომ დიდი context ყოველ build-ს აფერხებს.

## .dockerignore — არასაჭირო ფაილების აირიდება

```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-დან ფაილებს აირიდებს.

## რატომ არის ეს მნიშვნელოვანი (სამი სარგებელი)

```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 build-ებისთვის**, ამიტომ ეს პრაქტიკულად სასარგებლო ცოდნაა.

bევრი დეველოპერი არ ხვდება, რომ `docker build .` აგზავნის **მთელ build-context დირექტორიას daemon-ის წინ** — ამიტომ დიდი context (`node_modules`, `.git`, build artifacts, დიდი ფაილებით) ხდის **ყოველ build-ს 느릴** (მეტი მონაცემი გადასატანი და დამუშავებელი) და რისკავს არასასურველი ფაილების image-ში კოპირებას.

**.dockerignore** ფაილი (`.gitignore`-ის მსგავსად მუშაობს) აღმოფხვრის ამას სამი კონკრეტული სარგებელით: **უფრო სწრაფი build** (უფრო მცირე context უფრო სწრაფად გადაიცემა და დამუშავდება, და ასევე აუმჯობესებს layer caching-ს, რადგან `COPY . .` არ გახდება არასწორი მხოლოდ არაკავშირის ფაილების ცვლილებების გამო), **უფრო მცირე image** (გამორიცხული ფაილები არ კოპირდება — მაგ. ადგილობრივი `node_modules` არ შედის, რომელიც მაინც ხელახლა დაყენდება), და კრიტიკულად **უსაფრთხოება** (ინახავს **საიდენტიფიკაციო ინფორმაციას, როგორიცაა `.env` ფაილები, გასაღებები და სიდან build context-დან და image-დან** — რადგან `COPY . .` სხვა შემთხვევაში `.env`-ს image-ში კოპირებდა, რეალური და გავრცელებული სიდან გაჟონვის რისკი).

ეს უსაფრთხოების სარგებელი განსაკუთრებით მნიშვნელოვანია, რადგან შემთხვევით image-ში საიდენტიფიკაციო ინფორმაცია ან მგრძნობიარე ფაილების შეტანა ზედმეტი copy-დან არის გავრცელებული შეცდომა, რომლის აღმოფხვრაშიც `.dockerignore` ეხმარება.

ვინაიდან build მუდმივად ხდება და build ეფექტურობა, image size და მგრძნობიარე ინფორმაციის გაჟონვის აცილება მნიშვნელოვანია, და რადგან build context-ის გაგება და `.dockerignore`-ის გამოყენება პირდაპირ აუმჯობესებს ამ სამივეს, build context-ის და `.dockerignore`-ის გაგება ღირებული, პრაქტიკულად აქტუალური Docker ცოდნაა — მარტივი მაგრამ მნიშვნელოვანი პრაქტიკა სწრაფი, დახვეწილი და უსაფრთხო build-ებისთვის, რომელიც მარტივია დაგვიანებული, მაგრამ მნიშვნელოვანი გავლენის მომტანი, განსაკუთრებით საიდენტიფიკაციო ინფორმაციის image-ში შემთხვევით შეტანის აღმოფხვრაში.