როგორ მუშაობს Docker შიგნიდან?

Question

Accepted Answer

Docker იყენებს Linux kernel-ის ფიჩებს — **namespaces** (იზოლაცია), **cgroups** (რესურსების კონტროლი) და **union filesystems** (ფენიანი იმიჯები) — რათა შექმნას მსუბუქი კონტეინერები. ძირითადი მექანიზმების გაგება ხსნის, თუ როგორ მიიღწევა კონტეინერებში იზოლაცია და ეფექტიანობა.

## Namespaces — იზოლაცია

```text
Linux NAMESPACES isolate what a process can SEE — giving each container its own view:
  PID namespace     → its own process tree (container sees only its processes)
  NET namespace     → its own network interfaces, IPs, ports
  MNT namespace     → its own filesystem mounts
  UTS namespace     → its own hostname
  IPC, USER namespaces → isolated IPC, user/group ID mapping
→ Namespaces are WHY a container feels like a separate machine (isolated view),
  while actually sharing the host kernel.
```

## cgroups — რესურსების კონტროლი

```text
Control Groups (CGROUPS) LIMIT and account for resource usage per container:
  → CPU, memory, disk I/O, network bandwidth
→ cgroups are WHY you can set resource limits (-m, --cpus) — the kernel enforces them.
```

## Union filesystem — ფენიანი იმიჯები

```text
UNION/OVERLAY filesystems (overlayfs) stack image LAYERS:
  → read-only image layers + a thin writable container layer on top, merged into one view
  → layers are SHARED between images/containers (one copy on disk) → space-efficient
→ This is WHY images are layered, cached, and shareable, and containers are lightweight.
```

## არქიტექტურა

```text
Docker CLI → Docker DAEMON (dockerd) → containerd → runc (creates containers using
  namespaces + cgroups). The daemon manages images, containers, networks, volumes.
→ Containers are just ISOLATED PROCESSES on the host (not VMs) — using kernel features,
  sharing the host kernel → lightweight and fast.
```

## რატომ არის ეს მნიშვნელოვანი

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

მნიშვნელოვანი აზრი ის არის, რომ **კონტეინერები არ არის VM-ები — ისინი იზოლირებული პროცესები მეწამულ მასზე** Linux kernel-ის ფიჩების გამოყენებით, რის გამოც ისინი მსუბუქი და სწრაფი არიან (მეწამული kernel-ს აზიარებენ, რაც ცალკეული OS-ების გაშვებას აქვეყნებს).

**სამი ძირითადი მექანიზმის** გაგება აქ ეხმარება: **namespaces** იზოლირებს, რა შეუძლია პროცესს დაინახოს (მისი საკუთარი პროცესების ხე, ქსელი, ფაილური სისტემა, hostname — რის გამოც კონტეინერი ცალკე მანქანის მსგავსია მიუხედავად იმისა, რომ kernel-ს აზიარებს), **cgroups** შეზღუდავს და ითვლის რესურსების გამოყენებას (რის გამოც შეგიძლიათ დააწესოთ CPU და მეხსიერების ლიმიტები — kernel ამათ აღსრულებს), და **union/overlay filesystems** აწყობენ იმიჯის ფენებს (რის გამოც იმიჯები ფენიანი, კეშირებული და გაზიარებული არიან, ხოლო კონტეინერები მსუბუქი არიან — წაკითხვის მხოლოდ ფენები აზიარებული კონტეინერებს შორის თხელი დაწერადი ფენით ზემოთ).

**არქიტექტურის** გაგება (CLI → daemon → containerd → runc, daemon-ი ყველაფერს მართავს) გთავაზობთ Docker-ის ოპერაციის სრულ სურათს.

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

ძირითადი მექანიზმების (namespaces, cgroups, union filesystems) გაგება აკმეკებს, თუ რატომ იქცევიან კონტეინერები ისე, როგორც იქცევიან — მათი იზოლაცია, ეფექტიანობა, რესურსების კონტროლი და მნიშვნელოვანი ფაქტი, რომ მეწამული kernel-ს აზიარებენ (უსაფრთხოების გავლენებით) — და აღრმავებს კონტეინერიზებული სისტემების თან მუშაობის უნარს დაჯერებული ხელით, Docker-ის შიგნიდან მუშაობის გაგება არის ძირითადი დონის ღირებული ცოდნა, რომელიც აამაღლებს ერთის Docker-ის გამოყენებიდან მის ჭეშმარიტებაში გაგებამდე, თემა, რომელიც ძველი დონის ფუნქციებისა და კონტეინერის ქცევის, უსაფრთხოების საზღვრების და ფუნქციონირების შესახებ დამტკიცებული მსჯელობის სასარგებლოა.