Z mojego artykułu o Automatyzacja wdrożeń Dockera:

Docker Images vs. Containers

W Dockerland znajdują się obrazy oraz kontenery . Oba są ze sobą blisko spokrewnione, ale odrębne. Dla mnie uchwycenie tej dychotomii bardzo wyjaśniło Dockera.

Co To jest obraz?

Obraz jest obojętnym, niezmiennym plikiem, który jest zasadniczo migawką kontenera. Obrazy są tworzone za pomocą polecenia build , i wyprodukują kontener po uruchomieniu run. Obrazy są przechowywane w rejestrze dokera, takim jak registry.hub.docker.com . ponieważ mogą one stać się dość duże, obrazy są zaprojektowane tak, aby składały się z warstw innych obrazów, umożliwiając wysyłanie mimicznej ilości danych podczas przesyłania obrazów przez sieć.

Local images can be listed by running docker images:

REPOSITORY                TAG                 IMAGE ID            CREATED             VIRTUAL SIZE
ubuntu                    13.10               5e019ab7bf6d        2 months ago        180 MB
ubuntu                    14.04               99ec81b80c55        2 months ago        266 MB
ubuntu                    latest              99ec81b80c55        2 months ago        266 MB
ubuntu                    trusty              99ec81b80c55        2 months ago        266 MB
<none>                    <none>              4ab0d9120985        3 months ago        486.5 MB

Niektóre rzeczy do zapamiętania:

1. ID obrazu to pierwsze 12 znaki prawdziwego identyfikatora obrazu. Możesz utworzyć wiele tagów danego obrazu, ale ich identyfikatory będą takie same (jak powyżej).
2. Rozmiar wirtualny jest wirtualnym , ponieważ sumuje rozmiary wszystkich różnych warstw bazowych. Oznacza to, że suma wszystkich wartości w tej kolumnie jest prawdopodobnie znacznie większa niż przestrzeń dyskowa używana przez wszystkie te obrazy.
3. wartość w kolumnie repozytorium pochodzi z flagi -t polecenia docker build lub z docker tag - Tworzenie istniejącego obrazu. Możesz dowolnie tagować obrazy za pomocą nomenklatury, która ma dla ciebie sens, ale wiedz, że Docker użyje tego znacznika jako lokalizacji rejestru w docker push lub docker pull.
4. pełna forma znacznika to [REGISTRYHOST/][USERNAME/]NAME[:TAG]. Dla ubuntu powyżej, REGISTRYHOST przyjmuje się jako registry.hub.docker.com. Jeśli więc planujesz przechowywać swój obraz o nazwie my-application w rejestrze w docker.example.com, powinieneś oznaczyć ten obraz docker.example.com/my-application.
5. kolumna TAG jest tylko [: TAG] częścią pełnego tagu. To niefortunne. terminologia.
6. znacznik latest nie jest magiczny, jest po prostu domyślnym znacznikiem, gdy nie podasz znacznika.
7. nieoznaczone obrazy można zidentyfikować tylko po ich identyfikatorach. Otrzymają one znacznik <none> i repozytorium. Łatwo o nich zapomnieć.

Więcej informacji na temat zdjęć można znaleźć w Docker docs i glosariusz.

Co to jest kontener?

Aby użyć metafory Programowania, jeśli obraz jest klasą, to kontener jest instancją runtime obiektu klasy-A. Mamy nadzieję, że kontenery są powodem, dla którego używasz Dockera; są lekkimi i przenośnymi enkapsulacjami środowiska, w którym można uruchamiać aplikacje.

Wyświetl lokalne uruchomione kontenery za pomocą docker ps:

CONTAINER ID        IMAGE                               COMMAND                CREATED             STATUS              PORTS                    NAMES
f2ff1af05450        samalba/docker-registry:latest      /bin/sh -c 'exec doc   4 months ago        Up 12 weeks         0.0.0.0:5000->5000/tcp   docker-registry

Tutaj uruchamiam dokowaną wersję rejestru dokerów, dzięki czemu mam prywatne miejsce do przechowywania moich obrazów. Jeszcze raz kilka rzeczy do odnotowania:

1. podobnie jak ID obrazu, ID kontenera jest prawdziwym identyfikatorem dla Pojemnik. Ma tę samą formę, ale identyfikuje inny rodzaj obiektu.
2. docker ps tylko wyjścia uruchomione kontenery. Możesz wyświetlić wszystkie kontenery (uruchomione lub zatrzymane ) za pomocą docker ps -a.
3. nazwy mogą być używane do identyfikacji uruchomionego kontenera za pomocą znacznika --name.

Jak uniknąć nagromadzenia obrazów i kontenerów?

Jedną z moich wczesnych frustracji z Dockerem było pozornie ciągłe nagromadzenie nieoznaczonych obrazów i zatrzymane pojemniki . W kilku przypadkach to nagromadzenie powodowało, że maksymalne dyski twarde spowalniały mój laptop lub zatrzymywały mój zautomatyzowany rurociąg kompilacji. Mów o "kontenerach wszędzie"!

Możemy usunąć wszystkie nieoznaczone obrazy, łącząc {[21] } z ostatnim zapytaniem dangling=true:

docker images -q --filter "dangling=true" | xargs docker rmi

Docker nie będzie w stanie usunąć obrazów znajdujących się za istniejącymi kontenerami, więc może być konieczne usunięcie zatrzymanych kontenerów za pomocą docker rm najpierw:

docker rm `docker ps --no-trunc -aq`

Są to [[116]}znane punkty bólu z Dockerem i mogą być rozwiązane w przyszłych wydaniach. Jednak przy jasnym zrozumieniu obrazów i kontenerów, takich sytuacji można uniknąć za pomocą kilku praktyk: [30]}

1. zawsze Usuń bezużyteczny, zatrzymany Pojemnik za pomocą docker rm [CONTAINER_ID].
2. zawsze Usuń obraz za bezużytecznym, zatrzymanym kontenerem za pomocą docker rmi [IMAGE_ID].

Chociaż najprostsze jest myślenie o kontenerze jako o uruchomionym obrazie, nie jest to dość dokładne .

Obraz jest tak naprawdę szablonem, który można przekształcić w kontener. Aby przekształcić obraz w kontener, silnik Docker pobiera obraz, dodaje system plików do odczytu i zapisu na górze i inicjalizuje różne ustawienia, w tym porty sieciowe, nazwę kontenera, identyfikator i limity zasobów. Uruchomiony kontener ma obecnie wykonujący się proces, ale kontener może być również zatrzymany (lub exited w terminologii Dockera). Exited container is not the same as a image, as it can be restarted and will retain its settings and any filesystem changes.

Może Wyjaśnienie całego przepływu pracy może pomóc.

Wszystko zaczyna się od Dockerfile . Plik Dockerfile jest kodem źródłowym obrazu.

Po utworzeniu pliku Dockerfile tworzysz go tak, aby utworzyć obraz kontenera. Obraz jest tylko "skompilowaną wersją" "kodu źródłowego", który jest plikiem Dokerowym.

Po uzyskaniu obrazu kontenera należy go redystrybuować za pomocą rejestru . Rejestr jest jak git repozytorium - możesz przesuwać i ciągnąć obrazy.

Następnie możesz użyć obrazu do uruchomienia kontenerów . Uruchomiony kontener jest bardzo podobny, pod wieloma względami, do maszyny wirtualnej (ale bez hipernadzorcy ).

Ten post wyjaśnia wiele podstawowych rzeczy na temat kontenerów Dockera (mówi o dockerze i Puppet, ale istnieje wiele pojęć, które można wykorzystać w dowolnym kontekście)

W prostych słowach.

Images-

System plików i konfiguracja(tylko do odczytu) aplikacji, która służy do tworzenie kontenerów. więcej szczegółów .

Pojemniki -

Są to uruchomione instancje obrazów dokera. Kontenery uruchamiają rzeczywiste aplikacje. Kontener zawiera aplikację i wszystkie jej zależności. Dzieli jądro z innymi kontenerami i działa jako izolowany proces w przestrzeni użytkownika na systemie operacyjnym hosta. więcej szczegółów .

Inne ważne warunki, o których należy pamiętać:

Docker daemon-

Usługa w tle działająca na serwerze, który zarządza budynkiem, uruchamianie i dystrybucja kontenerów Docker.

Docker client-

Narzędzie wiersza poleceń, które pozwala użytkownikowi na interakcję z Dokerem daemon.

Docker Sklep-

Sklep to między innymi rejestr obrazów Dokerów. Możesz pomyśl o rejestrze jako o katalogu wszystkich dostępnych obrazów dokera.

Obraz jest wart tysiąca słów.

(dla głębszego zrozumienia proszę przeczytać to .)

Podsumowanie:

• wyciągnij Obraz z Docker hub lub zbuduj z Dockerfile => daje obraz Dockera (nie edytowalny).
• Uruchom obraz (docker run image_name:tag_name) = > daje uruchomiony obraz tj. kontener (edytowalny)

Workflow

Oto całościowy przepływ pracy pokazujący różne polecenia i powiązane z nimi wejścia i wyjścia. Powinno to wyjaśnić związek między obrazem a kontenerem.

+------------+  docker build   +--------------+  docker run -dt   +-----------+  docker exec -it   +------+
| Dockerfile | --------------> |    Image     | --------------->  | Container | -----------------> | Bash |
+------------+                 +--------------+                   +-----------+                    +------+
                                 ^
                                 | docker pull
                                 |
                               +--------------+
                               |   Registry   |
                               +--------------+

Aby wyświetlić listę obrazów, które można uruchomić, wykonaj:

docker image ls

Aby wyświetlić listę kontenerów, na których można wykonać polecenia:

docker ps

Nie mogłem zrozumieć koncepcji obrazu i warstwy pomimo przeczytania wszystkich pytań tutaj i w końcu natknąłem się na tędoskonałą dokumentację z Docker (duh!).

Przykład jest naprawdę kluczem do zrozumienia całej koncepcji. Jest to długi post, więc streszczam kluczowe punkty, które muszą być naprawdę zrozumiałe, aby uzyskać jasność.

• Obraz: obraz dokera zbudowany jest z serii tylko do odczytu warstwy

• Layer : każda warstwa reprezentuje instrukcję w pliku Dokerowym obrazu.

Example: poniższy plik Dockerfile zawiera cztery polecenia, z których każde tworzy warstwę.

Z ubuntu:15.04

Zrozumiałem . / app

Uruchom make / app

CMD python /app/app.py

Co ważne , każda warstwa jest tylko zbiorem różnic od warstwy przed to.

• Pojemnik. Podczas tworzenia nowego kontenera, dodaje się nową warstwę do zapisu na warstwach podstawowych. Warstwa ta jest często nazywana "warstwą kontenera". Wszystkie zmiany wprowadzone w uruchomionym kontenerze, takie jak zapisywanie nowych plików, modyfikowanie istniejących plików i usuwanie plików, są zapisywane w warstwie kontenera thin.

Stąd główna różnica między kontenerem a obrazem jest top writable layer . Wszystkie zapisy do kontenera, które dodają nowe lub Modyfikuj istniejące dane są przechowywane w tej zapisywalnej warstwie. Kiedy kontener jest usuwany, usuwana jest również warstwa nadająca się do zapisu. Na podstawowy obraz pozostaje niezmieniony.

Zrozumienie obrazów kontenerów cnd z perspektywy rozmiaru na dysku

Aby wyświetlić przybliżony rozmiar uruchomionego kontenera, możesz użyć polecenia docker ps -s. Otrzymujemy size i virtual size jako Dwa Wyjścia:

• Rozmiar: ilość danych (na dysku), która jest używana dla zapisywalnej warstwy każdego kontenera

• Rozmiar wirtualny: ilość danych używanych do danych obrazów tylko do odczytu używanych przez kontener. Wiele kontenerów może współdzielić niektóre lub wszystkie dane obrazów tylko do odczytu. stąd nie są one addytywne. Nie możesz dodać wszystkich wirtualnych rozmiarów, aby obliczyć, ile rozmiaru na dysku jest używane przez obraz

Inną ważną koncepcją jest copy-on-write strategia

Jeśli plik lub katalog istnieje w dolnej warstwie obrazu, a inna warstwa (w tym warstwa zapisywalna) wymaga dostępu do odczytu, po prostu używa istniejącego pliku. Gdy po raz pierwszy inna warstwa musi zmodyfikować plik (podczas budowania obrazu lub uruchamiania kontenera), plik jest kopiowany do tej warstwy i modyfikowany.

Dockerfile > (Build) > Image > (Run) > Container.

• Dockerfile: zawiera zestaw instrukcji Dockera, który obsługuje Twój system operacyjny tak, jak chcesz, i instaluje / konfiguruje wszystkie Twoje oprogramowanie.

• Image : skompilowany plik Dockerfile. Oszczędza czas na przebudowie pliku Dockerfile za każdym razem, gdy trzeba uruchomić kontener. I to sposób na ukrycie swojego zaopatrzenia kod.

• Container : wirtualny system operacyjny sam w sobie, można ssh do niego i uruchomić dowolne polecenia, jakby to było prawdziwe środowisko. Z tego samego obrazu można uruchomić ponad 1000 kontenerów.

Podstawową koncepcją Dockera jest ułatwienie tworzenia "maszyn", które w tym przypadku można uznać za kontenery. Pojemnik ułatwia ponowne użycie, umożliwiając łatwe tworzenie i upuszczanie pojemników.

Obrazy przedstawiają stan kontenera w każdym momencie. Tak więc podstawowy przepływ pracy to:

1. Utwórz obraz
2. Uruchom kontener
3. dokonaj zmian w pojemniku
4. Zapisz kontener z powrotem jako obraz

Kontener jest po prostu wykonywalnym plikiem binarnym, który ma być uruchamiany przez system operacyjny hosta pod zestawem ograniczeń, które są ustawione przy użyciu aplikacji (np. docker), która wie, jak powiedzieć systemowi, które ograniczenia mają być stosowane.

Typowe ograniczenia to związane z izolacją procesów, związane z bezpieczeństwem (jak użycie ochrony SELinux) i związane z zasobami systemowymi(pamięć, dysk, procesor, sieć).

Do niedawna tylko jądra w systemach uniksowych obsługiwały możliwość uruchamiania pliki wykonywalne pod ścisłymi ograniczeniami. Dlatego większość dzisiejszych rozmów o kontenerach dotyczy głównie Linuksa lub innych dystrybucji Uniksa.

Docker jest jedną z tych aplikacji, która wie, jak powiedzieć systemowi (głównie Linuksowi), jakie ograniczenia ma uruchamiać program wykonywalny. Plik wykonywalny jest zawarty w obrazie dokera, który jest tylko plikiem tarfile. Ten plik wykonywalny jest zwykle okrojoną wersją dystrybucji Linuksa (Ubuntu, centos, Debian itp.) wstępnie skonfigurowanej do uruchamiania jednej lub więcej aplikacji wewnątrz.

Chociaż większość ludzi używa bazy Linuksa jako pliku wykonywalnego, może to być każda inna aplikacja binarna, o ile system operacyjny hosta może ją uruchomić. (zobacz tworzenie prostego obrazu bazowego za pomocą scratch ). Niezależnie od tego, czy plik binarny w obrazie dokera jest systemem operacyjnym, czy po prostu aplikacją, dla hosta systemu operacyjnego jest to tylko kolejny proces, zamknięty Proces rządzony przez wstępnie ustawione granice systemu operacyjnego.

Inne aplikacje, które, jak Docker, mogą powiedzieć systemowi operacyjnemu hosta, które granice należy zastosować do procesu, gdy jest running include LXC, libvirt i systemd. Docker używał tych aplikacji do pośredniej interakcji z systemem operacyjnym Linux, ale teraz Docker współpracuje bezpośrednio z Linuksem za pomocą własnej biblioteki o nazwie " libcontainer ".

Kontenery są więc tylko procesami pracującymi w trybie ograniczonym, podobnie jak to robiło chroot .

IMO to, co odróżnia Dockera od innych technologii kontenerowych, to jego repozytorium (Docker Hub) i ich narzędzia do zarządzania, które sprawiają, że praca z kontenerami jest niezwykle łatwa.

Zobacz https://en.m.wikipedia.org/wiki/Docker_ (Linux_container_engine)

Mówiąc po prostu, jeśli obraz jest klasą, to kontener jest instancją klasy jest obiektem runtime.

Obraz dokujący pakuje aplikację i środowisko wymagane przez aplikację do uruchomienia, a kontener jest uruchomioną instancją obrazu.

Obrazy są pakującą częścią Dockera, analogicznie do "kodu źródłowego" lub "programu". Kontenery są częścią wykonawczą Dockera, analogiczną do"procesu".

W pytaniu jest mowa tylko o części "program" i to jest obraz. Częścią "działającą" Dockera jest kontener. Gdy kontener jest uruchomiony i wprowadzane są zmiany, to tak, jakby proces dokonał zmiany we własnym kodzie źródłowym i zapisał go jako nowy obraz.

Image jest odpowiednikiem definicji klasy w OOP, a warstwy są różnymi metodami i właściwościami tej klasy.

Kontener jest rzeczywistą instancją obrazu, podobnie jak obiekt jest instancją lub instancją klasy.

Jak w aspekcie programowania,

Obraz jest kodem źródłowym.

Kiedy kod źródłowy jest kompilowany i budowany, jest nazywany aplikacją.

Simillar do tego "gdy instancja jest tworzona dla obrazu", nazywa się ją "Container "

W skrócie:

Kontener jest podziałem (wirtualnym) w jądrze, który dzieli wspólny system operacyjny i uruchamia obraz (obraz dokera).

Kontener jest samowystarczalną aplikacją, która będzie miała pakiety i wszystkie niezbędne zależności do uruchomienia kodu.

Obraz jest do klasy jako kontener do obiektu.

Kontener jest instancją obrazu, ponieważ obiekt jest instancją klasy.

Jak wiele odpowiedzi na to wskazywało: Ty zbuduj Dockerfile aby uzyskać obraz i Ty bieg obraz aby uzyskać kontener.

Jednak poniższe kroki pomogły mi lepiej zrozumieć, czym jest obraz dokera i kontener:

1) Zbuduj Plik Dockerfile:

docker build -t my_image dir_with_dockerfile

2) Zapisz obrazek do pliku .tar

docker save -o my_file.tar my_image_id

my_file.tar zapisze obraz. Otwórz go za pomocą tar -xvf my_file.tar, a otrzymasz aby zobaczyć wszystkie warstwy. Jeśli zanurzysz się głębiej w każdej warstwie, zobaczysz, jakie zmiany zostały dodane w każdej warstwie. (Powinny być bardzo zbliżone do poleceń w pliku Dockerfile).

3) aby zajrzeć do wnętrza pojemnika, możesz zrobić:

sudo docker run -it my_image bash

I widać, że jest bardzo podobny do OS.

Dockerfile jest jak skrypt bash, który tworzy tarball (obraz dokera).

Kontenery Docker są jak wyciągnięta wersja tarballa. Możesz mieć tyle kopii, ile chcesz w różnych folderach (kontenerach)

Dla fałszywej analogii programistycznej, można myśleć o Docker ma abstrakcyjny ImageFactory, który przechowuje ImageFactories pochodzą one z store .

Następnie, gdy chcesz utworzyć aplikację z tej ImageFactory, będziesz miał nowy kontener i możesz go modyfikować, jak chcesz. DotNetImageFactory będzie niezmienny, ponieważ działa jak abstrakcyjna klasa factory, gdzie dostarcza tylko pożądane instancje.

IContainer newDotNetApp = ImageFactory.DotNetImageFactory.CreateNew(appOptions);
newDotNetApp.ChangeDescription("I am making changes on this instance");
newDotNetApp.Run();

Kontener dokujący uruchamia instancję obrazu. Możesz powiązać obraz z programem, a kontener z procesem:)