ਬਿਲਡ ਕਨਟੈਕਸਟ ਕੀ ਹੈ ਅਤੇ .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 ਗਿਆਨ ਹੈ — ਤੇਜ਼, ਲਿਆਣ, ਅਤੇ ਸੁਰੱਖਿਅਤ ਬਿਲਡ ਕਰਨ ਲਈ ਇੱਕ ਸਾਦਾ ਪਰ ਮਹੱਤਵਪੂਰਣ ਤਰੀਕਾ ਜੋ ਅਕਸਰ ਭੁੱਲਿਆ ਜਾ ਸਕਦਾ ਹੈ ਪਰ ਬਹੁਤ ਪ੍ਰਭਾਵਸ਼ਾਲੀ ਹੈ, ਖਾਸ ਤੌਰ 'ਤੇ ਇਮੇਜਾਂ ਵਿੱਚ ਬਿਨਾ-ਲਾਸ਼ ਦੀ ਆਨੱਕਣ ਨੂੰ ਰੋਕਣ ਲਈ।