run Quelle est la différence entre une image Docker et un conteneur?




download docker image (14)

Lorsque vous utilisez docker, nous commençons avec une image de base. Nous l'initialisons, créons des changements et ces changements sont sauvegardés dans des couches formant une autre image.

Donc, éventuellement, j'ai une image pour mon Postgres et une image pour mon application web, changements qui continuent d'être persistants.

Donc la question est: qu'est-ce qu'un conteneur?


Bien qu'il soit plus simple de considérer un conteneur comme une image en cours d'exécution, ce n'est pas tout à fait exact.

Une image est vraiment un modèle qui peut être transformé en un conteneur. Pour transformer une image en conteneur, le moteur Docker prend l'image, ajoute un système de fichiers en lecture-écriture et initialise divers paramètres, notamment les ports réseau, le nom du conteneur, l'ID et les limites de ressources. Un conteneur en cours d'exécution a un processus en cours d'exécution, mais un conteneur peut également être arrêté (ou quitté dans la terminologie de Docker). Un conteneur fermé n'est pas la même chose qu'une image, car il peut être redémarré et conservera ses paramètres et tous les changements apportés au système de fichiers.


En bref:

Container est une division (virtuelle) dans un noyau qui partage un système d'exploitation commun et exécute une image (image Docker).

Un conteneur est une application autonome qui aura des paquets et toutes les dépendances nécessaires pour exécuter le code.


Une instance d'une image est appelée un conteneur. Vous avez une image, qui est un ensemble de couches que vous décrivez. Si vous démarrez cette image, vous avez un conteneur en cours d'exécution de cette image. Vous pouvez avoir plusieurs conteneurs en cours d'exécution de la même image.

Vous pouvez voir toutes vos images avec des images docker images alors que vous pouvez voir vos conteneurs en cours d'exécution avec docker ps (et vous pouvez voir tous les conteneurs avec docker ps -a ).

Une instance en cours d'exécution d'une image est donc un conteneur.


Dockerfile > (Build)> Image > (Exécuter)> Conteneur .

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

  • Image : Dockerfile compilé. Vous gagnez du temps en reconstruisant le Dockerfile chaque fois que vous avez besoin d'exécuter un conteneur. Et c'est un moyen de cacher votre code de provision.

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


Comme dans l'aspect de la programmation,

L'image est un code source.

Lorsque le code source est compilé et construit, il est appelé en tant qu'application.

Simillar à cela "quand l'instance est créée pour l'image", on l'appelle " Container "


Une image Docker conditionne l'application et l'environnement requis par l'application pour s'exécuter et un conteneur est une instance en cours d'exécution de l'image.

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

Dans la question, seule la partie "programme" est référencée et c'est l'image. La partie "en cours d'exécution" de docker est le conteneur. Lorsqu'un conteneur est exécuté et que des modifications sont apportées, c'est comme si le processus modifiait son propre code source et l'enregistrait en tant que nouvelle image.


Un conteneur est simplement un exécutable binaire qui doit être exécuté par le système d'exploitation hôte sous un ensemble de restrictions prédéfinies à l'aide d'une application (par exemple, docker) qui sait comment indiquer au système d'exploitation les restrictions à appliquer.

Les restrictions typiques sont liées à l'isolation des processus, liées à la sécurité (comme l'utilisation de la protection SELinux) et liées aux ressources système (mémoire, disque, processeur, réseau).

Jusqu'à récemment, seuls les noyaux des systèmes basés sur Unix supportaient la possibilité d'exécuter des exécutables sous des restrictions strictes. C'est pourquoi la plupart des discussions sur les conteneurs 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 principalement) quelles sont les restrictions pour exécuter un exécutable. L'exécutable est contenu dans l'image Docker, qui est juste un fichier tar. Cet exécutable est généralement une version allégée d'une distribution Linux (Ubuntu, centos, Debian, etc.) préconfigurée pour exécuter une ou plusieurs applications.

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

D'autres applications qui, comme Docker, peuvent indiquer au système d'exploitation hôte les limites à appliquer à un processus pendant son exécution, notamment LXC , libvirt et systemd . Docker utilisait ces applications pour interagir indirectement avec le système d'exploitation Linux, mais maintenant Docker interagit directement avec Linux en utilisant sa propre bibliothèque appelée " libcontainer ".

Les conteneurs ne sont donc que des processus s'exécutant dans un mode restreint, similaire à ce que le chroot faisait auparavant.

IMO, qui distingue Docker de toute autre technologie de conteneur, est son référentiel (Docker Hub) et ses outils de gestion qui rendent le travail avec des conteneurs extrêmement facile.

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


flux de travail

Voici le workflow de bout en bout montrant les différentes commandes et leurs entrées et sorties associées. Cela 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, vous pouvez exécuter des commandes:

docker ps

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

Container est l'instanciation réelle de l'image, tout comme un objet est une instanciation ou une instance d'une classe.


C'est plutôt droit.

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

Images -

Le système de fichiers et la configuration de notre application qui sont utilisés pour créer des conteneurs. plus de détails..

Conteneurs -

Ce sont des instances en cours d'exécution des images Docker. Les conteneurs exécutent les applications réelles. Un conteneur inclut une application et toutes ses dépendances. Il partage le noyau avec d'autres conteneurs et s'exécute comme un processus isolé dans l'espace utilisateur du système d'exploitation hôte. plus de détails..

Autres termes importants à remarquer:

Démon Docker -

Le service d'arrière-plan s'exécutant sur l'hôte qui gère la construction, l'exécution et la distribution des conteneurs Docker.

Client Docker -

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

Docker Store -

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

Une image vaut mieux que mille mots.

Résumé:

  • Extraire le concentrateur docker de formulaire Image ou construire à partir de Dockerfile => Donne une image docker (non modifiable).
  • Exécuter l'image ( docker run image_name:tag_name ) => Donne une image courante ie conteneur (modifiable)

Pour une analogie de programmation fictive, vous pouvez penser à Docker a une ImageFactory abstraite qui détient ImageFactories qu'ils viennent de store .

Une fois que vous souhaitez créer une application à partir de cette ImageFactory, vous disposez d'un nouveau conteneur et vous pouvez le modifier comme vous le souhaitez. DotNetImageFactory sera immuable, car il agit comme une classe de fabrique abstraite, où il ne fournit que les instances que vous désirez.

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

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

Les conteneurs Docker sont comme une version extraite de l'archive. Vous pouvez avoir autant de copies que vous le souhaitez dans différents dossiers (les conteneurs)


Je ne pouvais pas comprendre le concept de Image et Layer malgré la lecture de toutes les questions ici et puis finalement tombé sur cette excellente documentation de docker (duh!).

L'exemple là est vraiment la clé pour comprendre l'ensemble du concept. C'est un long post, donc je résume les points clés qui doivent être vraiment saisis pour être clairs.

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

  • Calque : Chaque calque représente une instruction dans le fichier Docker de l'image.

Example : Le Dockerfile ci-dessous contient quatre commandes, chacune d'entre elles créant une couche.

DE Ubuntu: 15.04

COPIE . / application

Exécuter make / app

CMD python /app/app.py

Fait important , chaque couche est seulement un ensemble de différences de la couche avant elle.

  • Conteneur Lorsque vous créez un nouveau conteneur, vous ajoutez une nouvelle couche accessible en écriture sur 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 dans cette couche de conteneur inscriptible mince .

Par conséquent, la principale différence entre un conteneur et une image est la couche inscriptible supérieure . Toutes les écritures dans le conteneur pour ajouter ou modifier des données existantes sont stockées dans cette couche accessible en écriture. Lorsque le conteneur est supprimé, la couche accessible en écriture est également supprimée. L'image sous-jacente reste inchangée.

Comprendre les images et les conteneurs à partir d'une perspective de taille sur disque

Pour afficher la taille approximative d'un conteneur en cours d'exécution, vous pouvez utiliser la commande docker ps -s . Vous obtenez la size et virtual size comme deux des sorties

  • Taille: la quantité de données (sur le disque) utilisée pour la couche inscriptible de chaque conteneur

  • Taille virtuelle: quantité de données utilisée 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 que vous ne pouvez pas ajouter toutes les tailles virtuelles pour calculer la taille sur le disque utilisée par l'image

Un autre concept important est la stratégie Copy on Write. 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 accessible en écriture) a besoin d'un accès en lecture, elle utilise simplement le fichier existant. La première fois qu'une autre couche doit modifier le fichier (lors de la création de l'image ou de l'exécution du conteneur), le fichier est copié dans cette couche et modifié.

J'espère que ça aide quelqu'un d'autre comme moi.


Le concept de base du docker est de faciliter la création de "machines" qui dans ce cas peuvent être considérées comme des conteneurs. Le conteneur aide à la réutilisation, ce qui vous permet de créer et de déposer des conteneurs facilement.

Les images représentent l'état d'un conteneur à chaque instant. Donc, le flux de travail de base est:

  1. créer une image
  2. démarrer un conteneur
  3. apporter des modifications au conteneur
  4. sauvegarder le conteneur en tant qu'image




docker-image