Docker ఇమేజ్‌లు మరియు కంటైనర్‌ల మధ్య తేడా ఏమిటి?

Question

Accepted Answer

Docker **ఇమేజ్** ఒక read-only **టెంప్లేట్** (దాని డిపెండెన్సీలతో సహా ప్యాకేజ్ చేయబడిన అప్లికేషన్); ఒక **కంటైనర్** ఒక ఇమేజ్ యొక్క **రన్నింగ్ ఇన్‌స్టెన్స్**. సంబంధం class మరియు object లాంటిది: ఒక ఇమేజ్ చాలా కంటైనర్‌లను సృష్టించగలదు. ## ఇమేజ్ vs కంటైనర్ ```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) ``` ## ఇమేజ్‌లతో పని చేయడం ```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 ``` ఇమేజ్‌లు నిర్మించబడతాయి (Dockerfile నుండి), స్థానికంగా లేదా రిజిస్ట్రీలలో నిల్వ చేయబడతాయి, tags (`myapp:1.0`) తో సంస్కరించబడతాయి, మరియు భాగస్వామ్యం చేయబడతాయి. ## కంటైనర్‌లతో పని చేయడం ```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 ``` కంటైనర్‌లు ఇమేజ్‌ల నుండి సృష్టించబడతాయి, జీవనచక్రం కలిగి ఉంటాయి (run, stop, start, remove), మరియు మీరు లాగ్‌లను తనిఖీ చేయవచ్చు లేదా వాటిలోకి exec చేయవచ్చు. ## లేయర్డ్ సంబంధం ```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 ``` ## ఇది ఎందుకు ముఖ్యమైనది Docker ఇమేజ్‌లు మరియు కంటైనర్‌ల మధ్య తేడాను అర్థం చేసుకోవడం Docker పై పని చేయడానికి ఫండమెంటల్, కాబట్టి ఇది అవసరమైనది, తప్పనిసరిగా తెలుసుకోవలసిన జ్ఞానం. సంబంధం — **ఇమేజ్** ఒక read-only **టెంప్లేట్** (డిపెండెన్సీలతో సహా ప్యాకేజ్ చేయబడిన అప్లికేషన్, బ్లూప్రింట్ లేదా class లాంటిది) అయితే **కంటైనర్** ఆ ఇమేజ్ యొక్క **రన్నింగ్ ఇన్‌స్టెన్స్** (class నుండి సృష్టించిన object లాంటిది, runtime state కలిగి ఉంటుంది) — Docker యొక్క కోర్ కాన్సెప్చువల్ మోడల్, మరియు రెండింటిని గందరగోళం చేయడం Docker ఎలా పనిచేస్తుందో గురించిన గందరగోళానికి దారితీస్తుంది. **ఒక ఇమేజ్ చాలా కంటైనర్‌లను సృష్టించగలదు** (ఎకే ఇమేజ్‌ను బహుసార్లు రన్ చేయడం) అని అర్థం చేసుకోవడం Docker స్కేలింగ్ మరియు సাম్యతను ఎలా సక్షమ చేస్తుందో తెలుసుకోవటానికి కీలకమైనది. ప్రాక్టికల్ ఆపరేషన్‌ల గురించి తెలుసుకోవడం — నిర్మాణం, జాబితా, pulling, pushing, మరియు సంస్కరణ **ఇమేజ్‌లు** (`myapp:1.0` వంటి tags తో), మరియు running, stopping, inspecting (logs), మరియు exec-ing into **కంటైనర్‌లు** (వాటి జీవనచక్రాన్ని నిర్వహించడం) — Docker ఉపయోగించేటప్పుడు రోజువారీ ప్రాక్టికల్ జ్ఞానం. **లేయర్డ్ సంబంధం** అర్థం చేసుకోవడం (ఇమేజ్‌లు cached, shareable layers లో నిర్మించబడతాయి; కంటైనర్ ఇమేజ్ యొక్క read-only layers ప్లస్ thin writable layer లేదు ఇక్కడ runtime changes జరుగుతాయి, removal లో కోల్పోతాయి volumes ద్వారా persist చేయకపోతే) Docker యొక్క efficiency (layer sharing/caching) మరియు ఒక ముఖ్యమైన gotcha (కంటైనర్ changes ephemeral ఉంటాయి volumes లేకుండా) రెండింటినీ వివరిస్తుంది. ఇమేజ్/కంటైనర్ తేడా Docker కు foundational mental model కనుక, మరియు దానిని అర్థం చేసుకోవడం (మరియు సంబంధిత operations మరియు layered structure) Docker workloads నిర్మాణం, running, మరియు నిర్వహించడానికి అవసరమైనది కనుక, ఇమేజ్‌లు మరియు కంటైనర్‌ల మధ్య తేడాను అర్థం చేసుకోవడం essential, fundamental Docker knowledge — కోర్ కాన్సెప్ట్ ఇది Docker లో ఇతర సবకీ ఆధారం, మరియు ప్రతిটి Docker యూజర్ స్పష్టంగా గ్రహించాలసిన తేడా.