რა განსხვავებაა Docker-ის გამოსახულებებსა და კონტეინერებს შორის?

Question

Accepted Answer

Docker-ის **გამოსახულება** არის მხოლოდ-კითხვადი **შაბლონი** (პაკეტირებული აპლიკაცია მის დამოკიდებულებებთან); **კონტეინერი** არის **მუშაობის რეჟიმში არსებული ინსტანცია** გამოსახულებიდან. ურთიერთობა მსგავსია კლასისა და ობიექტის: ერთი გამოსახულება შეიძლება შექმნას მრავალი კონტეინერი. ## გამოსახულება მაპ კონტეინერი ```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-დან), შენახულია ლოკალურად ან რეგისტრებში, ვერსიებული ტეგებით (`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 ``` კონტეინერები შექმნილი გამოსახულებებიდან, აქვთ ცხოვრების ციკლი (გაშვება, შეჩერება, დაწყება, წაშლა) და თქვენ შეგიძლიათ ინსპექტირება გააკეთოთ ლოგებისა ან 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-ის ცენტრალური კონცეპტუალური მოდელი, და ორივის აღრეულობა იწვევს დაბნეულობას იმის შესახებ, თუ როგორ მუშაობს Docker. იმის ესმა, რომ **ერთი გამოსახულება შეიძლება შექმნას მრავალი კონტეინერი** (ერთი და იგივე გამოსახულების მრავალჯერ გაშვება) არის მთავარი იმისთვის, თუ როგორ საშუალებას აძლევს Docker მასშტაბირებას და თანმიმდევრობას. პრაქტიკული ოპერაციების ცოდნა — **გამოსახულებების** აშენება, სია, დახლებოთი, თავის დატოვება და ვერსიონება (ტეგებით მაგ. `myapp:1.0`) და **კონტეინერების** გაშვება, შეჩერება, ინსპექტირება (ლოგები) და exec-ში შესვლა (მათი ცხოვრების ციკლის მართვა) — არის ყოველდღიური პრაქტიკული ცოდნა Docker-ის გამოყენების დროს. **ფენიანი ურთიერთობის** ესმა (გამოსახულებები აშენებულია კეშირებული, გაზიარებული ფენებით; კონტეინერი სახელმწიფოა გამოსახულების მხოლოდ-კითხვადი ფენებისა პლუს თხელი ჩაწერადი ფენა სადაც გაშვების დროის ცვლილებები ხდება, დაკარგული წაშლაზე თუ პერსისტენციული არ არის ვოლიუმების საშუალებით) ხსნის Docker-ის ეფექტიანობას (ფენის გაზიარება/კეშირება) და მნიშვნელოვან უბედურობას (კონტეინერის ცვლილებები მცირე სიცოცხლისუნარიანია ვოლიუმების გარეშე). ვინაიდან გამოსახულება/კონტეინერ განსხვავება არის Docker-ის საფუძველი მენტალური მოდელი, და რადგან მისი გაგება (და ასოცირებული ოპერაციები და ფენიანი სტრუქტურა) აუცილებელია Docker-ის სამუშაოს სწორად აშენებისთვის, გაშვებისთვის და მართვისთვის, გამოსახულებებსა და კონტეინერებს შორის განსხვავების გაგება არის აუცილებელი, ფუნდამენტური Docker-ის ცოდნა — ბირთვი კონცეფცია, რომელზეც Docker-ის ყველაფერი აგებულია, და განსხვავება რომელიც ყველა Docker-ის მომხმარებელმა 분명히უნდა გაიაზროს.