Care este diferența dintre imaginile Docker și containerele Docker?

Question

Accepted Answer

O **imagine** Docker este un **șablon** read-only (o aplicație împachetată cu dependențele sale); un **container** este o **instanță în execuție** a unei imagini. Relația este ca între o clasă și un obiect: o singură imagine poate genera mai multe containere. ## Imagine 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) ``` ## Lucrul cu imagini ```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 ``` Imaginile sunt construite (dintr-un Dockerfile), stocate local sau în registre, versionate cu etichete (`myapp:1.0`), și partajate. ## Lucrul cu containere ```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 ``` Containerele sunt create din imagini, au un ciclu de viață (run, stop, start, remove), și puteți inspecta jurnalele sau executa comenzi în ele. ## Relația stratificată ```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 ``` ## De ce contează Înțelegerea distincției dintre imagini și containere este fundamentală pentru lucrul cu Docker, deci este cunoaștere esențială, care trebuie cunoscută. Relația — o **imagine** este un **șablon** read-only (aplicația împachetată cu dependențe, ca o schemă sau clasă) în timp ce un **container** este o **instanță în execuție** a acelei imagini (ca un obiect creat dintr-o clasă, cu stare de rulare) — este modelul conceptual principal al Docker, iar confundarea celor două duce la confuzie cu privire la modul în care funcționează Docker. Înțelegerea că **o imagine poate genera multe containere** (rulând aceeași imagine de mai multe ori) este esențială pentru a înțelege cum Docker permite scalarea și consistența. Cunoașterea operațiilor practice — construirea, listarea, descărcarea, încărcarea și versiunea **imaginilor** (cu etichete ca `myapp:1.0`), și rularea, oprirea, inspecția (jurnale), și exec-ul în **containere** (gestionarea ciclului de viață) — este cunoaștere practică zilnică pentru utilizarea Docker. Înțelegerea **relației stratificate** (imaginile construite în straturi memorate în cache, partajabile; un container fiind straturile read-only ale imaginii plus un strat subțire scris unde merg schimbările de runtime, pierdute la ștergere dacă nu sunt persistate via volume) explică atât eficiența Docker (partajare/cache de straturi) cât și o dificultate importantă (schimbările containerului sunt efemere fără volume). Dintr-o dată ce distincția imagine/container este modelul mental fundamental pentru Docker, și deoarece înțelegerea ei (și operațiunile asociate și structura stratificată) este necesară pentru a construi, rula și gestiona corect sarcinile Docker, înțelegerea diferenței dintre imagini și containere este cunoaștere Docker esențială, fundamentală — conceptul principal pe care construiește totul în Docker, și o distincție pe care fiecare utilizator Docker trebuie s-o înțeleagă clar.