Docker images અને containers વચ્ચે શું તફાવત છે?

Question

Accepted Answer

એક Docker **image** એક read-only **template** છે (એક packaged application તેની dependencies સાથે); એક **container** એ image નો **running instance** છે। આ સંબંધ ક્લાસ અને 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 સાથે versioned થાય છે (`myapp:1.0`), અને શેર કરવામાં આવે છે। ## 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 inspect કરી શકો છો અથવા તેમમાં exec કરી શકો છો। ## The layered relationship ```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 સાથે કામ કરવાના માટે મૂળભૂત છે, તેથી તે આવશ્યક, જ્ઞાત હોવું જોઇએ. સંબંધ — એક **image** એક read-only **template** છે (packaged application તેની dependencies સાથે, blueprint અથવા ક્લાસ જેવું) જ્યારે એક **container** તે image નો **running instance** છે (ક્લાસ થી બનાવેલ object જેવું, runtime state સાથે) — Docker નું મુખ્ય conceptual model છે, અને બંને બીજાને સાથે ગણતરીમાં લેવો Docker કેવી રીતે કામ કરે છે તેના વિશે ગોંધણ તરફ દોરી જાય છે. યા સમજવું કે **એક image બહુ બધા containers બનાવી શકે છે** (એક જ image એક કરતા વધુ વર્તમાને ચલાવવું) તે Docker કે કેવી રીતે scaling અને consistency સક્ષમ બનાવે છે તેને સમજવાનો ચાવી છે। વ્યવહારિક operations જાણવું — **images** બનાવવું, list કરવું, pull કરવું, push કરવું, અને versioning કરવું (tags જેવા `myapp:1.0` સાથે), અને **containers** ચલાવવું, બંધ કરવું, inspect કરવું (logs), અને exec કરવું (તેમની lifecycle સંચાલન કરવું) — Docker ઉપયોગ કરવાનું રોજિંદું વ્યવહારિક જ્ઞાન છે. **Layered relationship** સમજવું (images cached, shareable layers માં બનાવવામાં આવે છે; એક container image ના read-only layers ને વતી જાય છે જો removal પર persistent ન થાય volumes દ્વારા) બંને Docker ની efficiency (layer sharing/caching) અને એક મહત્વપૂર્ણ gotcha (container changes ephemeral છે volumes વિના) ને સમજાવે છે। જ્યારે image/container distinction Docker માટે foundational mental model છે, અને જ્યારે તેને સમજવું (અને સંલગ્ન operations અને layered structure) Docker workloads યોગ્યતાથી બનાવવા, ચલાવવા, અને સંચાલન કરવા માટે આવશ્યક છે, images અને containers વચ્ચેનો તફાવત સમજવો આવશ્યક, મૂળભૂત Docker જ્ઞાન છે — મુખ્ય ખ્યાલ કે જેના પર બીજું બધું Docker માં નિર્મિત થાય છે, અને એક તફાવત કે જે પ્રત્યેક Docker વપરાશકર્તાને સ્પષ્ટતાથી ગ્રહણ કરવો જોઇએ.