બિલ્ડ કન્ટેક્સ્ટ શું છે અને .dockerignore ફાઇલનો ઉપયોગ શા માટે કરવો?

Question

Accepted Answer

જ્યારે તમે `docker build` ચલાવો છો, Docker **બિલ્ડ કન્ટેક્સ્ટ** (બિલ્ડ ડિરેક્ટરીમાંની ફાઇલો) ડેમનને મોકલે છે. એક **.dockerignore** ફાઇલ આ કન્ટેક્સ્ટમાંથી અનાવશ્યક ફાઇલોને બાકાત કરે છે — બિલ્ડને ઝડપી બનાવે છે, ઇમેજ સાઇઝ ઘટાવે છે, અને સંવેદનશીલ ફાઇલો લીક થવાથી બચાવે છે.

## બિલ્ડ કન્ટેક્સ્ટ

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

**બિલ્ડ કન્ટેક્સ્ટ** એ ફાઇલોનો સમૂહ છે જે Docker ઇમેજ બનાવવા માટે ડેમનને મોકલે છે. બિલ્ડ ડિરેક્ટરીમાંની બધી ફાઇલો શામેલ છે જ્યાં સુધી તેમને બાકાત ન કરવામાં આવે — તેથી એક વધુ કન્ટેક્સ્ટ દરેક બિલ્ડને ધીમું કરે છે.

## .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` જેવું કાર્ય કરે છે, બિલ્ડ કન્ટેક્સ્ટમાંથી ફાઇલોને બાકાત કરે છે.

## શા માટે તે મહત્વપૂર્ણ છે (ત્રણ લાભો)

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

## શા માટે તે મહત્વપૂર્ણ છે

બિલ્ડ કન્ટેક્સ્ટ અને `.dockerignore` સમજવું **કાર્યક્ષમ અને સુરક્ષિત Docker બિલ્ડ્સ** માટે મૂલ્યવાન છે, તેથી તે વ્યવહારીક રીતે ઉપયોગી જ્ઞાન છે.

ઘણા ડેવલપર્સ સમજતા નથી કે `docker build .` બિલ્ડ કરતા પહેલા **સંપૂર્ણ બિલ્ડ-કન્ટેક્સ્ટ ડિરેક્ટરી ડેમનને મોકલે છે** — તેથી એક વધુ કન્ટેક્સ્ટ (`node_modules`, `.git`, બિલ્ડ કલાકૃતિઓ, વધુ ફાઇલો ધરાવતું) **દરેક બિલ્ડને ધીમું** બનાવે છે (વધુ ડેટા સ્થાનાંતર અને પ્રક્રિયા માટે) અને ઇમેજમાં અનિચ્છનીય ફાઇલોનું નકલ કરવાનું જોખમ ધરાવે છે.

**.dockerignore** ફાઇલ (`.gitignore` જેવું કાર્ય કરતું) ત્રણ મૂર્ત લાભો સાથે આને સંબોધિત કરે છે: **ઝડપી બિલ્ડ્સ** (એક નાનો કન્ટેક્સ્ટ ઝડપથી સ્થાનાંતર અને પ્રક્રિયા કરે છે, અને `COPY . .` અપ્રાસંગિક ફાઇલોમાં પરિવર્તનથી અમાન્ય ન થવાથી સ્તરના કેશમાં પણ સુધાર કરે છે), **નાની ઇમેજ્સ** (બાકાત ફાઇલો ઇમેજમાં નકલ થતી નથી — જેમ કે સ્થાનિક `node_modules` બંડલ ન કરવું જે કોઈપણ રીતે પુનઃસ્થાપિત થાય છે), અને નિર્ણાયક રીતે **સુરક્ષા** (**.env ફાઇલો, કી અને ક્રેડેંશિયલ્સ જેવી ગુપ્તસ્તર બિલ્ડ કન્ટેક્સ્ટ અને ઇમેજમાંથી બહાર રાખવી** — કારણ કે `COPY . .` અન્યથા `.env` ને ઇમેજમાં નકલ કરશે, જે વાસ્તવ અને સામાન્ય ક્રેડેંશિયલ-લીક જોખમ છે).

યો સુરક્ષા લાભ ખાસ કરીને મહત્વપૂર્ણ છે, કારણ કે ગુપ્તસ્તર અથવા સંવેદનશીલ ફાઇલોને અતિવ્યાપક નકલ દ્વારા ઇમેજમાં આકસ્મિક રીતે બેક કરવું એ એક વાસ્તવ ભૂલ છે જે `.dockerignore` રોકતું મદદ કરે છે.

ચાલુ બિલ્ડ્સ થતા હોય છે અને બિલ્ડ કાર્યક્ષમતા, ઇમેજ સાઇઝ અને ગુપ્તસ્તર લીક ટાળવા બધું મહત્વપૂર્ણ હોય છે, અને તેથી બિલ્ડ કન્ટેક્સ્ટ અને `.dockerignore` સમજવું અને ઉપયોગ કરવું બધામાં સીધી રીતે સુધાર કરે છે, બિલ્ડ કન્ટેક્સ્ટ અને `.dockerignore` સમજવું મૂલ્યવાન, વ્યવહારીક રીતે સુસંગત Docker જ્ઞાન છે — ઝડપી, પાતળી અને સુરક્ષિત બિલ્ડ્સ માટે એક સરળ પણ મહત્વપૂર્ણ અભ્યાસ જે અવગણવા માટે સરળ છે છતાં સર્થક પ્રભાવશાળી છે, ખાસ કરીને ઇમેજમાં ગુપ્તસ્તરનો આકસ્મિક સમાવેશ રોકવા માટે.