en termes simples.

Images -

le système de fichiers et l'application de configuration(en lecture seule) qui est utilisé pour créer des conteneurs. plus de détails .

Conteneurs -

ce sont des instances d'exécution d'images Docker. Conteneurs exécuter l' réel application. Un conteneur comprend une application et toutes ses dépendance. Il partage le noyau avec d'autres conteneurs et fonctionne comme un processus isolé dans l'espace utilisateur sur le système d'exploitation hôte. plus de détails .

autres termes importants à noter:

démon Docker -

le service d'arrière-plan tournant sur l'hôte qui gère le bâtiment, faire fonctionner et distribuer des conteneurs Docker.

Support client -

l'outil en ligne de commande qui permet à l'utilisateur d'interagir avec le Docker démon.

Docker Magasin -

Store est, entre autres, un registre d'images Docker. Vous pouvez penser le registre comme un répertoire de toutes les images Docker.

Une image vaut mille mots.

(pour une compréhension plus approfondie, veuillez lire this .)

résumé:

• Pull image de Docker hub ou construire à partir d'un Dockerfile => Donne une image Docker (non modifiable).
• exécuter l'image ( docker run image_name:tag_name ) = > donne une Image en cours d'exécution i.e. conteneur (modifiable)

Flux de travail

voici le workflow de bout en bout montrant les différentes commandes et leurs entrées et sorties associées. Qui devrait clarifier la relation entre une image et un conteneur.

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

pour lister les images que vous pourriez exécuter, exécutez:

docker image ls

pour lister les conteneurs sur lesquels vous pouvez exécuter des commandes:

docker ps

Je ne pouvais pas comprendre le concept de image et couche en dépit de la lecture de toutes les questions ici et puis éventuellement tombé sur cette excellente documentation de Docker (duh!).

L'exemple n'est vraiment la clé pour comprendre le concept. Il s'agit d'un long billet, c'est pourquoi je résume les points clés qu'il faut vraiment saisir pour obtenir de la clarté.

• Image : une image Docker est construite à partir d'une série de en lecture seule couches

• couche : chaque couche représente une instruction dans le fichier Dockerfile de l'image.

Example : le fichier Dockerfile ci-dessous contient quatre commandes, chacune créant une couche.

de ubuntu: 15.04

bien reçu . / app

RUN /app

CMD python /app/app.py

important , chaque couche n'est qu'un ensemble de différences par rapport à la couche précédente.

• conteneur . Lorsque vous créez un nouveau conteneur, vous ajoutez une nouvelle couche les couches sous-jacentes . Cette couche est souvent appelée "couche conteneur". Toutes les modifications apportées au conteneur en cours d'exécution, telles que l'écriture de nouveaux fichiers, la modification de fichiers existants, et la suppression de fichiers, sont écrites à cette couche mince conteneur writable.

par conséquent, la principale différence entre un conteneur et une image est le top écriture couche . Tout écrit au conteneur qui ajoute nouveau ou modifier les données existantes sont stockées dans cette couche d'écriture. Lorsque l' le conteneur est supprimé, le calque modifiable est également supprimé. Le l'image sous-jacente demeure inchangée.

la Compréhension des images cnd de Conteneurs à partir d'une taille sur disque " point de vue

pour voir la taille approximative d'un conteneur, vous pouvez utiliser la commande docker ps -s . Vous obtenez size et virtual size comme deux des sorties:

• Taille: la quantité de données (sur disque) qui est utilisé pour l'écriture de la couche de chaque conteneur

• taille virtuelle: la quantité de données utilisées pour les données d'image en lecture seule utilisées par le conteneur. Plusieurs conteneurs peuvent partager certaines ou toutes les données d'image en lecture seule. par conséquent ceux-ci ne sont pas additifs. C'est-à-dire: vous ne pouvez pas ajouter toutes les tailles virtuelles pour calculer combien la taille sur le disque est utilisée par l'image

un autre concept important est la stratégie de copie-sur-écriture

si un fichier ou un répertoire existe dans une couche inférieure de l'image, et qu'une autre couche (y compris la couche en écriture) a besoin d'y accéder en lecture, elle utilise simplement le fichier existant. La première fois qu'un autre calque doit modifier le fichier (lors de la construction de l'image ou de l'exécution du conteneur), le fichier est copié dans ce calque et modifier.

j'espère que ça aidera quelqu'un comme moi.

Dockerfile > () > Image > (Run) > Conteneur .

• Dockerfile : contient un ensemble d'instructions docker qui fournit votre système d'exploitation comme vous le souhaitez, et installe/configure tous vos logiciels.

• Image : compiled Dockerfile. Vous fait gagner du temps à partir de reconstruire le fichier Dockerfile chaque fois que vous avez besoin de courir un conteneur. Et c'est une façon de cacher votre disposition du code.

• Container : le système d'exploitation virtuel lui-même, vous pouvez ssh en elle et exécuter toutes les commandes que vous souhaitez, comme si c'est un environnement réel. Vous pouvez lancer plus de 1000 conteneurs à partir de la même Image.

le concept de base de docker est de faciliter la création de" machines " qui, dans ce cas, peuvent être considérées comme des conteneurs. Le conteneur sida dans la réutilisabilité, vous permettant de créer et supprimer des conteneurs avec facilité.

les Images représentent l'état d'un conteneur à chaque moment dans le temps. Ainsi, le flux de travail de base est:

1. créer une image
2. démarrer un conteneur
3. apporter des modifications au conteneur
4. enregistrer le conteneur à l'arrière comme une image

un conteneur est juste un binaire exécutable qui doit être exécuté par L'OS hôte sous un ensemble de restrictions qui sont prédéfinies en utilisant une application (par exemple, docker) qui sait comment dire à L'OS quelles restrictions appliquer.

les restrictions typiques sont liées au processus d'isolation, à la sécurité (comme la protection SELinux) et aux ressources du système (Mémoire, Disque, cpu, réseau).

Jusqu'à récemment seulement les noyaux dans les systèmes basés sur Unix pris en charge la capacité à exécuter des exécutables sous de strictes restrictions. C'est pourquoi la plupart des discussions sur les conteneurs aujourd'hui concernent principalement Linux ou d'autres distributions Unix.

Docker est l'une de ces applications qui sait comment dire au système D'exploitation (Linux surtout) quelles sont les restrictions pour exécuter un exécutable. L'exécutable est contenu dans L'image du Docker, qui n'est qu'un fichier tarfile. Cet exécutable est généralement une version dépouillée d'une distribution Linux (Ubuntu, centos, Debian, etc.).) préconfiguré pour exécuter une ou plusieurs applications.

bien que la plupart des gens utilisent une base Linux comme exécutable, il peut être n'importe quelle autre application binaire aussi longtemps que L'OS hôte peut l'exécuter. (voir créer une image de base simple en utilisant scratch ). Que le binaire dans l'image du docker soit un OS ou simplement une application, pour l'hôte du système D'exploitation, il s'agit simplement d'un autre processus, un processus contenu régi par des limites prédéfinies du système d'exploitation.

autres les applications qui, comme Docker, peuvent indiquer à L'OS hôte quelles limites appliquer à un processus pendant qu'il est en cours d'exécution comprennent LXC , libvirt , et systemd . Docker utilisait ces applications pour interagir indirectement avec L'OS Linux, mais maintenant Docker interagit directement avec Linux en utilisant sa propre bibliothèque appelée " libcontainer ".

donc les conteneurs ne sont que des processus en cours dans un mode restreint, similaire à ce que chroot utilisé pour faire.

IMO ce qui distingue Docker de toute autre technologie de conteneurs est son dépôt (Docker Hub) et ses outils de gestion qui rend le travail avec les conteneurs extrêmement facile.

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

, dit Simplement, si une image est une classe, un conteneur est une instance d'une classe est un objet d'exécution.

une image Docker emballe l'application et l'environnement requis par l'application à exécuter, et un conteneur est une instance de fonctionnement de l'image.

Images sont la partie d'emballage de docker, analogue à" code source "ou un"programme". Les conteneurs sont la partie d'exécution de docker, analogue à un"processus".

dans la question, seule la partie" programme " est mentionnée et c'est l'image. La partie" courante " de docker est le conteneur. Lorsqu'un le conteneur est exécuté et les changements sont faits, c'est comme si le processus de changement dans son propre code source et l'enregistrer comme une nouvelle image.

Image est l'équivalent d'une définition de classe dans OOP et les couches sont différentes méthodes et propriétés de cette classe.

Conteneur est l'instanciation de l'image tout comme la façon dont un objet est une instanciation ou une instance d'une classe.

Comme dans la partie programmation,

Image est un code source.

quand code source est compilé et construit, il est appelé application.

Similaire que "lorsqu'une instance est créée pour l'image", il est appelé comme " Conteneur "

en bref:

conteneur est une division (virtuelle) dans un noyau qui partage un OS commun et exécute une image (image Docker).

un conteneur est une application Auto-soutenable qui aura des paquets et toutes les dépendances nécessaires ensemble pour exécuter le code.

une image est classée comme contenant d'un objet.

Un conteneur est une instance d'une image comme un objet est une instance d'une classe.

Comme beaucoup de réponses a souligné: Vous construire Dockerfile pour obtenir un image et vous exécuter image pour obtenir un conteneur .

cependant, les étapes suivantes m'ont aidé à obtenir une meilleure idée de ce que sont L'image et le conteneur Docker:

1) Construction Fichier Dockerfile:

docker build -t my_image dir_with_dockerfile

2) Enregistrer l'image dans .tar fichier

docker save -o my_file.tar my_image_id

my_file.tar stockera l'image. Ouvrez-le avec tar -xvf my_file.tar , et vous verrez toutes les couches. Si vous plongez plus profondément dans chaque couche, vous pouvez voir quels changements ont été ajoutés dans chaque couche. (Ils devraient être assez proches des commandes dans le fichier Dockerfile).

3) pour jeter un coup d'oeil à l'intérieur d'un conteneur, vous pouvez faire:

sudo docker run -it my_image bash

et vous pouvez voir que c'est comme un OS.

Dockerfile est comme votre script bash qui produit une tarball (image Docker).

Docker containers est comme une version extraite de la tarball. Vous pouvez avoir autant de copies que vous le souhaitez dans les différents dossiers (les conteneurs)

pour une analogie de programmation factice, vous pouvez penser à Docker a un répertoire Imag abstrait qui contient des ImageFactories qu'ils viennent de store .

Puis une fois que vous voulez créer une appli qui ImageFactory, vous aurez un nouveau conteneur, et vous pouvez les modifier comme vous le souhaitez. DotNetImageFactory sera immuable, car il agit comme une classe d'usine abstraite, où il ne délivre que les instances que vous désirez.

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

un conteneur Docker exécute une instance d'une image. Vous pouvez relier une image avec un programme et un conteneur avec un processus:)