რა არის Dockerfile და როგორ წერთ ერთს?

Question

Accepted Answer

**Dockerfile** არის ტექსტური ფайл **Docker სურათის აგებისთან** საჭირო ინსტრუქციებით — ის აღწერს ბაზის სურათს, დამოკიდებულებებს, კოპირების მიზნით ფაილებსა და აპლიკაციის გაშვების მეთოდს. ის სურათის აგებას იმეორებადი და ვერსიის კონტროლში ხელმისაწვდომი ხდის.

## ძირითადი 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 სურათების აგების საშუალება, ამიტომ ერთის დაწერა ფუნდამენტური, ყოველდღიური Docker უნარია.

Dockerfile უზრუნველყოფს **იმეორებადი, ვერსიის კონტროლში ხელმისაწვდომი სურათის აგებას** — აღწერს კოდში ზუსტად თუ როგორ აგებული იქნება სურათა (ბაზის სურათა, დამოკიდებულებებს, ფაილებს, კონფიგურაციას და გაშვების ბრძანებას), ასე რომ ნებისმიერი შეიძლება თანმიმდევრულად აგოს იგივე სურათა, რაც Docker-ის იმეორებადობის ღირებულებაზე ცენტრალურია.

**ძირითადი ინსტრუქციების** გაგება — `FROM` (ბაზის სურათა), `WORKDIR`, `COPY` (ფაილების შემოტანა), `RUN` (აგების დროის ბრძანებების შესრულება, როგორიცაა პაკეტების დაყენება), `ENV`, `EXPOSE` და `CMD`/`ENTRYPOINT` (განსაზღვრავს რა გაშვებული იქნება კონტეინერის დაწყებისას) — აუცილებელია ეფექტური Dockerfile-ების დაწერა რეალური აპლიკაციებისთვის.

особливо მნიშვნელოვანი და ხშირად აბნევდი განსხვავება არის **`RUN` vs `CMD` vs `ENTRYPOINT`**: `RUN` შესრულდება **აგების დროს** (სურათის აგება, მაგ. პაკეტების დაყენება), ხოლო `CMD`/`ENTRYPOINT` განსაზღვრავს რა გაშვებული იქნება **კონტეინერის დაწყებისას** (აპლიკაციის ბრძანება) — ამის გაგება ხშირ შეცდომებს თავს აცილებს.

პრაქტიკული ნიმუშების ცოდნა (როგორიცაა დამოკიდებულების ფაილების კოპირება კოდამდე უკეთესი ფენის ქეშირებისთვის) ასახავს ეფექტური Dockerfile-ების დაწერას.

ვინაიდან სურათების აგება ფუნდამენტური Docker-ის გამოყენებაშია (ყველა Docker სამუშაო დინებას სურათები აქვს დაკავშირებული, და Dockerfile არის როგორ აგებული იქნება მორგებული სურათები), და ვინაიდან ინსტრუქციებისა და აგების დროის წინააღმდეგ გაშვების დროის განსხვავების გაგება აუცილებელია სწორი, ეფექტური სურათების შესაქმნელად, Docker-ის Dockerfile-ის გაგება არის აუცილებელი, ხშირად გამოყენებული Docker ცოდნა — ძირითადი უნარი ნებისმიერი Docker-ის გამოყენებისთვის, მექანიზმი რომელიც Docker-ის იმეორებადობის პირობას პრაქტიკაში აქცევს და პრაქტიკულად უნივერსალური მოთხოვნა აპლიკაციების კონტეინერიზაციისთვის.