Dockerfile શું છે અને તમે તેને કેવી રીતે લખો છો?

Question

Accepted Answer

**Dockerfile** એ એક ટેક્સ્ટ ફાઈલ છે જેમાં **Docker image બનાવવા** માટેના સૂચનાઓ હોય છે — તે બેઝ image, dependencies, કૉપી કરવાની ફાઈલો અને એપ્લિકેશન કેવી રીતે ચલાવવું તેનું વર્ણન કરે છે. તે image બિલ્ડ્સને પુનરુત્પાદક અને સંસ્કરણ-નિયંત્રિત કરે છે.

## એક મૂળભૂત Dockerfile

```dockerfile
# FROM — the base image to build on
FROM node:20-alpine

# WORKDIR — set the working directory inside the image
WORKDIR /app

# COPY dependency files first (for better layer caching)
COPY package*.json ./
# RUN — execute a command during the BUILD (install dependencies)
RUN npm install

# COPY the rest of the application code
COPY . .

# EXPOSE — document the port the app listens on
EXPOSE 3000

# CMD — the command to run when a CONTAINER starts
CMD ["node", "server.js"]
```

## મુખ્ય સૂચનાઓ

```text
FROM     → the base image (starting point) — REQUIRED, usually first
WORKDIR  → set the working directory for subsequent instructions
COPY/ADD → copy files from the host into the image
RUN      → execute a command at BUILD time (install packages, compile) → creates a layer
ENV      → set environment variables
EXPOSE   → document which port(s) the container listens on
CMD      → the default command to run when the container STARTS (one per Dockerfile)
ENTRYPOINT → the executable that runs (CMD provides default args to it)
ARG      → build-time variables
```

## RUN vs CMD vs ENTRYPOINT (સામાન્ય રીતે મૂંઝવણમાં)

```text
RUN        → runs at BUILD time (builds the image — e.g. install dependencies)
CMD        → runs at CONTAINER START (the default command; overridable at run)
ENTRYPOINT → the main executable at start (CMD becomes its default arguments)
→ RUN builds the image; CMD/ENTRYPOINT define what runs when it starts.
```

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

Dockerfile ને સમજવું આવશ્યક છે કારણ કે તે Docker images કેવી રીતે બનાવવામાં આવે છે તેનો માર્ગ છે, તેથી એક લખવું એ મૌલિક, રોજનો Docker કૌશલ્ય છે.

Dockerfile **પુનરુત્પાદક, સંસ્કરણ-નિયંત્રિત image બિલ્ડ્સ** પ્રદાન કરે છે — કોડમાં બરાબર વર્ણન કરે છે કે image કેવી રીતે બનાવવું (બેઝ image, dependencies, ફાઈલો, configuration, અને રન કમાંડ), તેથી કોઈ પણ સમાન image સતત બનાવી શકે છે, જે Docker ના પુનરુત્પાદકતાના મૂલ્યનું કેન્દ્ર છે.

**મુખ્ય સૂચનાઓ** ને સમજવું — `FROM` (બેઝ image), `WORKDIR`, `COPY` (ફાઈલો અંદર લાવવી), `RUN` (બિલ્ડ-સમય કમાંડ ચલાવવી જેમ કે dependencies સ્થાપિત કરવી), `ENV`, `EXPOSE`, અને `CMD`/`ENTRYPOINT` (કન્ટેનર શરૂ થાય ત્યારે શું ચલે તે વ્યાખ્યાયિત કરવી) — વાસ્તવિક એપ્લિકેશન્સ માટે અસરકારક Dockerfiles લખવા માટે જરૂરી છે.

ખાસ કરીને મહત્વપૂર્ણ અને સામાન્ય રીતે મૂંઝવણમાં આવતો તફાવત **`RUN` vs `CMD` vs `ENTRYPOINT`** છે: `RUN` **બિલ્ડ-સમયે** ચલે છે (image બનાવવું, ઉદાહરણ તરીકે પેકેજ સ્થાપિત કરવું), જ્યારે `CMD`/`ENTRYPOINT` **કન્ટેનર શરૂ** ખાતે શું ચલે તે વ્યાખ્યાયિત કરે છે (એપ્લિકેશન કમાંડ) — તેને સમજવું સામાન્ય ભૂલો રોકે છે.

વ્યવહારુ પેટર્નો જાણવું (જેમ કે આગળના કોડ માટે dependencies ફાઈલો કૉપી કરવી વધુ સારા layer caching માટે) કાર્યક્ષમ Dockerfiles લખવાનો પ્રતિબિંબ છે.

ઓ કે images બનાવવું Docker ને વાપરવા માટે મૌલિક છે (દરેક Docker વર્કફ્લોમાં images શામેલ છે, અને Dockerfile એ કસ્ટમ images કેવી રીતે બનાવવામાં આવે છે તેનો માર્ગ છે), અને સૂચનાઓ અને બિલ્ડ-સમય-વર્સેસ-રનટાઇમ તફાવત સમજવું સાચી, કાર્યક્ષમ images બનાવવા માટે જરૂરી છે, તેથી Dockerfile ને સમજવું આવશ્યક, વારંવાર-લાગુ Docker જ્ञાન છે — Docker ને વાપરનાર દરેક માટે મુખ્ય કૌશલ્ય, તે પદ્ધતિ જે Docker ના પુનરુત્પાદકતાના વચનને વ્યવહારમાં પરિણત કરે છે અને એપ્લિકેશન્સને કન્ટેનરીકરણ કરવા માટે લગભગ સાર્વત્રિક આવશ્યકતા છે.