Docker images மற்றும் containers க்கு இடையிலான வேறுபாடு என்ன?

Question

IT Interview Practice · Accepted Answer

ஒரு Docker **image** என்பது ஒரு read-only **template** (அதன் dependencies உடன் packaged பணியமைப்பு); ஒரு **container** என்பது ஒரு image இன் **running instance**. இந்த உறவு ஒரு class மற்றும் object போல் உள்ளது: ஒரு image பல containers களை உருவாக்க முடியும். ## Image vs container ```text IMAGE → a read-only TEMPLATE: the app + dependencies + config, built in layers (like a blueprint/class; stored, shared, versioned) CONTAINER → a RUNNING INSTANCE of an image (with a writable layer on top) (like an object created from a class; has runtime state) One IMAGE → many CONTAINERS (run the same image multiple times) ``` ## Images உடன் பணிபுரிதல் ```bash docker build -t myapp:1.0 . # BUILD an image from a Dockerfile docker images # list local images docker pull nginx # download an image from a registry docker push myapp:1.0 # upload an image to a registry docker rmi myapp:1.0 # remove an image ``` Images பயன்படுத்தப்படும் (ஒரு Dockerfile இலிருந்து), locally அல்லது registries இல் சேமிக்கப்பட்ட, tags (`myapp:1.0`) உடன் versioned, மற்றும் பகிரப்பட்ட. ## Containers உடன் பணிபுரிதல் ```bash docker run -d -p 80:80 nginx # RUN a container from an image (-d = background) docker ps # list RUNNING containers docker ps -a # list all (including stopped) docker stop # stop a container docker start # start a stopped container docker rm # remove a container docker logs # view a container's logs docker exec -it bash # run a command inside a running container ``` Containers images இலிருந்து உருவாக்கப்பட்ட, ஒரு lifecycle (run, stop, start, remove) உள்ளது, மற்றும் நீங்கள் logs inspected செய்யலாம் அல்லது அவற்றிற்குள் exec செய்யலாம். ## Layered உறவு ```text → Images are built in LAYERS (each Dockerfile instruction adds a layer, cached/shared) → A container = the image's read-only layers + a thin WRITABLE layer on top → Changes in a running container go to its writable layer (lost when removed, unless persisted via volumes) — the underlying image is unchanged ``` ## ஏன் இது முக்கியம் Images மற்றும் containers க்கு இடையிலான வேறுபாட்டைப் புரிந்துகொள்வது Docker உடன் பணிபுரிவதற்கு அடிப்படையாகும், எனவே இது அத்தியாவசியமாக, கட்டாய அறிவு. டாக்கர் என்பது ஒரு read-only **template** (packaged பணியமைப்பு dependencies உடன், ஒரு blueprint அல்லது class போல்) ஆக இருக்கும் என்பதும், ஒரு **container** என்பது அந்த image இன் **running instance** (ஒரு class இலிருந்து உருவாக்கப்பட்ட ஒரு object போல், runtime state உடன்) ஆக இருக்கும் என்பதும் — Docker இன் core conceptual model ஆகும், மற்றும் இரண்டையும் குழப்பிக்கொள்ளுவது Docker எப்படி வேலை செய்கிறது என்பது பற்றிய குழப்பத்திற்கு வழிவகுக்கிறது. **ஒரு image பல containers களை உருவாக்க முடியும்** (ஒரே image ஐ பல முறை இயக்குவது) என்பதைப் புரிந்துகொள்வது Docker எப்படி scaling மற்றும் consistency ஐ செயல்படுத்துகிறது என்பதற்கான சாவி. Practical operations ஐ அறிந்திருப்பது — building, listing, pulling, pushing, மற்றும் versioning **images** (`myapp:1.0` போன்ற tags உடன்), மற்றும் running, stopping, inspecting (logs), மற்றும் exec-ing into **containers** (அவற்றின் lifecycle ஐ நிர்வகித்தல்) — Docker ஐ பயன்படுத்துவதற்கான இன்றைய practical அறிவு. **Layered உறவை** புரிந்துகொள்வது (cached, shareable layers இல் images உருவாக்கப்பட்ட; ஒரு container image இன் read-only layers இற்கொடு ஒரு thin writable layer ஆக இருக்கும் இங்கு runtime மாற்றங்கள் செல்கின்றன, removal இல் loss ஆக இருக்கும் volumes மூலம் persist செய்யப்படாவிட்டால்) Docker இன் efficiency (layer sharing/caching) மற்றும் ஒரு முக்கியமான gotcha (container மாற்றங்கள் volumes இல்லாமல் ephemeral ஆக இருக்கும்) ஆகிய இரண்டையும் விளக்குகிறது. Image/container distinction ஆனது Docker இன் foundational mental model ஆக இருக்கும் என்பதும், அதைப் புரிந்துகொள்வது (மற்றும் சம்பந்தப்பட்ட operations மற்றும் layered structure) Docker workloads ஐ சரியாக build, run, மற்றும் manage செய்வதற்கு அவசியம் என்பதும், images மற்றும் containers க்கு இடையிலான வேறுபாட்டைப் புரிந்துகொள்வது அத்தியாவசியமான, fundamental Docker அறிவு — Docker இல் மற்றவற்றை கட்டமைக்கும் core concept, மற்றும் ஒரு வேறுபாடு ஒவ்வொரு Docker user ஐ also தெளிவாக புரிந்துகொள்ள வேண்டும்.

Image vs container

Images உடன் பணிபுரிதல்

Containers உடன் பணிபுரிதல்

Layered உறவு

ஏன் இது முக்கியம்

தொடர்புடைய கேள்விகள்