Docker எவ்வாறு உள் அமைப்பில் செயல்படுகிறது?

Question

Accepted Answer

Docker Linux kernel features — **namespaces** (isolation), **cgroups** (resource control), மற்றும் **union filesystems** (layered images) — ஆகியவற்றைப் பயன்படுத்தி lightweight containers உருவாக்குகிறது. அடிப்படை வழிமுறைகளைப் புரிந்துகொள்வது containers எவ்வாறு isolation மற்றும் efficiency அடைகிறது என்பதை விளக்குகிறது.

## Namespaces — isolation

```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 — resource control

```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 — layered images

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

## The architecture

```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 எவ்வாறு உள் அமைப்பில் செயல்படுகிறது என்பதைப் புரிந்துகொள்வது மதிப்புமிக்க senior-level அறிவு ஆகும், ஏனெனில் இது **containers ஐ விளக்கிவிடுகிறது** மற்றும் அவற்றின் முக்கிய பண்புகளை (isolation, efficiency, resource control) விளக்குகிறது, containerized systems ஐ பற்றி பகுத்துரைக்கும் திறனை ஆழப்படுத்துகிறது.

முக்கியமான insight என்பது **containers VMs அல்ல — அவை host இல் isolated processes** Linux kernel features ஐ பயன்படுத்தி, இதனால் அவை lightweight மற்றும் வேகமாக இருக்கின்றன (host kernel ஐ பகிர்ந்து கொண்டு தனித்தனி OSes இயக்குவதற்குப் பதிலாக).

**மூன்று முக்கிய mechanisms** ஐ புரிந்துகொள்வது பண்புகளை விளக்குகிறது: **namespaces** ஒரு process என்ன கண்ணாடிக்கு முடியும் என்பதைத் தனிமைப்படுத்துகிறது (அதன் சொந்த process tree, network, filesystem, hostname — இது *ஏன்* ஒரு container kernel ஐ பகிர்ந்து கொண்ட போதிலும் ஒரு தனிப்பட்ட machine போல் உணரப்படுகிறது), **cgroups** resource usage ஐ கட்டுப்படுத்துகிறது மற்றும் கணக்கிடுகிறது (இது *ஏன்* நீ CPU மற்றும் memory limits ஐ அமைக்க முடிகிறது — kernel அவற்றைப் பலவந்தம் செய்கிறது), மற்றும் **union/overlay filesystems** image layers ஐ stack செய்கிறது (இது *ஏன்* images layered, cached, மற்றும் shareable ஆகும், மற்றும் containers lightweight ஆகும் — read-only layers containers முழுவதிலும் பகிரப்பட்டு மேல்புற writable layer உடன்).

**architecture** (CLI → daemon → containerd → runc, daemon எல்லாவற்றையும் நிர்வகிப்பதுடன்) ஐ புரிந்துகொள்வது Docker எவ்வாறு செயல்படுகிறது என்பதற்கான முழு படத்தை வழங்குகிறது.

இந்த ஆழமான புரிதல் isolation boundaries ஐ பற்றி பகுத்துரைக்க உதவுகிறது (மற்றும் அவற்றின் security implications, containers kernel ஐ பகிர்ந்து கொள்ளுவதால்), performance மற்றும் efficiency characteristics ஐ விளக்குகிறது, மற்றும் troubleshooting உதவுகிறது.

অন্তর্নிहित mechanisms (namespaces, cgroups, union filesystems) ஐ புரிந்துகொள்வது containers எவ்வாறு செயல்படுகிறது என்பதை விளக்குகிறது — அவற்றின் isolation, efficiency, resource control, மற்றும் முக்கியமாக அவை host kernel ஐ பகிர்ந்து கொள்ளுதல் (security implications உடன்) — மற்றும் containerized systems உடன் பணிபுரியும் திறனை ஆழப்படுத்துகிறது, Docker ஐ பயன்படுத்துவதிலிருந்து உண்மையில் புரிந்துகொள்வதற்கு ஒருவரை உயர்த்துகிறது, senior roles க்கான தெரிய எதிர்பார்க்கப்படும் ஆழத்தைப் பிரதிபலிக்கும் ஒரு விஷயம் மற்றும் container behavior, security boundaries, மற்றும் performance பற்றி பகுத்துரைப்பதற்கு பயனுள்ளது, Docker எவ்வாறு உள் அமைப்பில் செயல்படுகிறது என்பதைப் புரிந்துகொள்வது மதிப்புமிக்க senior-level அறிவு ஆகும்.