Quelle est la différence entre une image Docker et un conteneur?
Lorsque vous utilisez Docker, nous commençons par une image de base. Nous le démarrons, créons des modifications et ces modifications sont enregistrées dans des calques formant une autre image.
Donc, finalement, j'ai une image pour mon instance PostgreSQL et une image pour mon application Web, les modifications y étant persistantes.
La question est donc: qu'est-ce qu'un conteneur?
Une instance d'une image s'appelle 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 docker images tandis 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).
Ainsi, une instance en cours d'une image est un conteneur.
De mon article sur Automatisation des déploiements de Docker :
Docker Images vs. Containers
Dans Dockerland, il y a images et il y a conteneurs . Les deux sont étroitement liés, mais distincts. Pour moi, comprendre cette dichotomie a énormément clarifié Docker.
Qu'est-ce qu'une image?
Une image est un fichier inerte, immuable, qui est essentiellement un instantané d’un conteneur. Les images sont créées avec la commande build et produisent un conteneur lorsqu’elles sont démarrées avec run . Les images sont stockées dans un registre Docker tel que registry.hub.docker.com . Parce qu'elles peuvent devenir très volumineuses, les images sont conçues pour être composées de couches d'autres images, ce qui permet d'envoyer une quantité infime de données lors du transfert d'images sur le réseau.
Les images locales peuvent être listées en exécutant 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
Quelques points à noter:
- IMAGE ID est les 12 premiers caractères de l'identifiant vrai pour une image. Vous pouvez créer plusieurs tags d'une image donnée, mais leurs identifiants seront les mêmes (comme ci-dessus).
- VIRTUAL SIZE est virtuel car il ajoute les tailles de toutes les couches sous-jacentes distinctes. Cela signifie que la somme de toutes les valeurs de cette colonne est probablement beaucoup plus grande que l'espace disque utilisé par toutes ces images.
- La valeur de la colonne REPOSITORY provient de l'indicateur
-tde la commandedocker buildou dedocker tag- d'une image existante. Vous êtes libre de marquer les images en utilisant une nomenclature qui vous convient, mais sachez que docker utilisera la balise comme emplacement du registre dans undocker Pushoudocker pull. - La forme complète d'une balise est
[REGISTRYHOST/][USERNAME/]NAME[:TAG]. Pourubuntuci-dessus, REGISTRYHOST est supposé êtreregistry.hub.docker.com. Donc, si vous envisagez de stocker votre image appeléemy-applicationdans un registre situé àdocker.example.com, vous devez baliser cette imagedocker.example.com/my-application. - La colonne TAG est simplement la partie [: TAG] de la balise full. C'est une terminologie malheureuse.
- La balise
latestn’est pas magique, c’est simplement la balise par défaut lorsque vous ne spécifiez pas de balise. - Vous pouvez avoir des images non étiquetées uniquement identifiables par leurs ID IMAGE. Ceux-ci auront le
<none>TAG et le REPOSITORY. Il est facile de les oublier.
Plus d'informations sur les images sont disponibles dans les Docker docs et glossaire .
Qu'est-ce qu'un conteneur?
Pour utiliser une métaphore de programmation, si une image est une classe, un conteneur est une instance d'une classe, un objet d'exécution. Les conteneurs sont, espérons-le, pourquoi vous utilisez Docker; Ce sont des encapsulations légères et portables d'un environnement dans lequel exécuter des applications.
Affichez les conteneurs en cours d'exécution locaux avec 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
Ici, je suis en train d’exécuter une version dockerisée du registre de docker afin de disposer d’un emplacement privé pour stocker mes images. Encore une fois, quelques points à noter:
- Comme ID IMAGE, CONTAINER ID est l'identifiant réel du conteneur. Il a la même forme, mais il identifie un type d'objet différent.
docker psne génère que des conteneurs running. Vous pouvez afficher tous les conteneurs (running ou stoppé) avecdocker ps -a.- NAMES peut être utilisé pour identifier un conteneur démarré via l'indicateur
--name.
Comment éviter la formation d'images et de conteneurs?
Une de mes premières frustrations avec Docker a été l'accumulation apparemment constante d'images non étiquetées et de conteneurs arrêtés . À quelques occasions, cette accumulation a eu pour effet de limiter le nombre de disques durs au maximum, ce qui a ralenti mon ordinateur portable ou stoppé mon pipeline de génération automatisée. Parlez de "conteneurs partout"!
Nous pouvons supprimer toutes les images sans étiquette en combinant docker rmi avec la requête récente dangling=true:
docker images -q --filter "dangling=true" | xargs docker rmi
Docker ne pourra pas supprimer les images se trouvant derrière des conteneurs existants. Vous devrez donc peut-être supprimer les conteneurs arrêtés avec docker rm en premier:
docker rm `docker ps --no-trunc -aq`
Ce sont points de douleur connus avec Docker, et pourront être résolus dans les prochaines versions. Cependant, avec une compréhension claire des images et des conteneurs, ces situations peuvent être évitées avec quelques pratiques:
- Supprimez toujours un conteneur arrêté inutile avec
docker rm [CONTAINER_ID]. - Supprimez toujours l'image derrière un conteneur inutile et arrêté avec
docker rmi [IMAGE_ID].
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 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, les identifiants et les limites des 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 exited dans la terminologie de Docker). Un conteneur quitté est pas identique à une image, car il peut être redémarré et conservera ses paramètres et toutes les modifications apportées au système de fichiers.
Dans des mots faciles.
Images -
Le système de fichiers et l'application de configuration (en lecture seule) utilisés pour créer des conteneurs. Plus de détails .
Conteneurs -
Ce sont des instances en cours d'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 en tant que 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 exécuté sur l'hôte qui gère le bâtiment, exécute et distribue les conteneurs Docker.
Client Docker -
Outil de ligne de commande permettant à l'utilisateur d'interagir avec le démon Docker.
Docker Store -
Store est, entre autres, un registre d’images Docker. Vous pouvez considérer le registre comme un répertoire de toutes les images Docker disponibles.
Une image de this blog vaut mille mots.
(Pour une compréhension plus profonde, veuillez lire this .)
Sommaire:
- Extraire image depuis le hub Docker ou créer à partir d'un fichier Docker => Donne une image Docker (non modifiable).
- Exécuter l’image (
docker run image_name:tag_name) => Donne un conteneur d’image en cours d’exécution (modifiable)
Peut-être que l'explication de l'ensemble du flux de travail peut aider.
Tout commence par le Dockerfile . Le Dockerfile est le code source de l'image.
Une fois le fichier Docker créé, vous le créez pour créer l'image du conteneur. L'image est simplement la "version compilée" du "code source" qui est le fichier Docker.
Une fois que vous avez l'image du conteneur, vous devez le redistribuer à l'aide du registre . Le registre est comme un référentiel git - vous pouvez pousser et extraire des images.
Ensuite, vous pouvez utiliser l'image pour exécuter des conteneurs . Un conteneur en cours d'exécution est très similaire, à bien des égards, à une machine virtuelle (mais sans le hyperviseur ).
Cet article explique beaucoup de choses de base sur les conteneurs Docker (il s'agit de Docker et de Puppet, mais de nombreux concepts peuvent être utilisés dans n'importe quel contexte)
Flux de travail
Voici le flux de travail de bout en bout illustrant 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 pouvez exécuter, exécutez:
docker image ls
Pour lister les conteneurs sur lesquels vous pouvez exécuter des commandes:
docker ps
Je ne comprenais pas le concept de image et layer en dépit de la lecture de toutes les questions ici avant de tomber par hasard sur ce excellente documentation de Docker (duh!).
L’exemple présenté ici est vraiment la clé pour comprendre l’ensemble du concept. C'est un long article, alors je résume les points clés qu'il faut bien comprendre pour être plus clair.
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 Docker de l’image.
Example: Le fichier Docker ci-dessous contient quatre commandes, chacune d'elles créant un calque.
D'Ubuntu: 15.04
COPIE ./app
RUN make/app
CMD python /app/app.py
Fait important , chaque calque ne représente qu'un ensemble de différences par rapport au calque précédent.
- Conteneur . Lorsque vous créez un nouveau conteneur, vous ajoutez un nouveau calque inscriptible au-dessus des calques sous-jacents. 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 thin inscriptible.
Par conséquent, la principale différence entre un conteneur et une image est le calque inscriptible supérieur . Toutes les écritures dans le conteneur qui ajoutent de nouvelles données ou modifient des données existantes sont stockées dans cette couche accessible en écriture. Lorsque le conteneur est supprimé, le calque en écriture est également supprimé. L'image sous-jacente reste inchangée.
Comprendre les images cnd Containers du point de vue de la 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 size et virtual size comme deux sorties:
Taille: la quantité de données (sur le disque) utilisée pour la couche en écriture 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 tout ou partie des données d'image en lecture seule. Par conséquent, ils ne sont pas additifs. C'est à dire. vous ne pouvez pas ajouter toutes les tailles virtuelles pour calculer la taille utilisée par l'image sur le disque
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 accessible en écriture) nécessite un accès en lecture, il utilise uniquement le fichier existant. La première fois qu'un autre calque doit modifier le fichier (lors de la création de l'image ou de l'exécution du conteneur), le fichier est copié dans ce calque et modifié.
J'espère que cela aide quelqu'un d'autre comme moi.
Dockerfile> (Construire)> Image> (Exécuter)> Conteneur.
Dockerfile: contient un ensemble d’instructions docker décrivant votre système d’exploitation à votre guise, et installant/configurant tous vos logiciels.
Image: fichier Docker compilé. Vous permet de gagner du temps en reconstruisant le fichier Docker à chaque fois que vous devez 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 y installer SSH et exécuter les commandes de votre choix, comme si c’était un environnement réel. Vous pouvez exécuter plus de 1000 conteneurs à partir de la même image.
Simplement dit, si un image est un classe, alors un conteneur est une instance d'une classe est un runtime objet =.
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 facilite la réutilisation, vous permettant de créer et de déposer facilement des conteneurs.
Les images décrivent l'état d'un conteneur à chaque instant. Le flux de travail de base est donc:
- créer une image
- commencer un conteneur
- apporter des modifications au conteneur
- sauvegarder le conteneur en tant qu'image
Un conteneur est simplement un fichier binaire exécutable 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, un menu fixe) qui sait comment indiquer au système d'exploitation les restrictions à appliquer.
Les restrictions typiques sont liées à l'isolation des processus, à la sécurité (comme l'utilisation de la protection SELinux) et aux ressources système (mémoire, disque, unité centrale, réseau).
Jusqu'à récemment, seuls les noyaux dans les systèmes Unix permettaient d'exécuter des exécutables dans des conditions de restriction strictes. C’est la raison pour laquelle la plupart des discussions de conteneur concernent aujourd’hui principalement Linux ou d’autres distributions Unix.
Docker fait partie de ces applications qui savent comment indiquer au SE (principalement à Linux) les restrictions pour exécuter un exécutable. L'exécutable est contenu dans l'image Docker, qui n'est qu'un fichier compressé. Cet exécutable est généralement une version simplifiée d'une distribution Linux (Ubuntu, Centos, Debian, etc.) préconfigurée pour y exécuter une ou plusieurs applications.
Bien que la plupart des gens utilisent une base Linux comme exécutable, il peut s'agir de toute autre application binaire tant que le système d'exploitation hôte peut l'exécuter. (voir créer une image de base simple en utilisant scratch ). Que le fichier binaire dans l'image du menu fixe 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, d'un processus contenu régi par des limites prédéfinies du système d'exploitation.
Parmi les autres applications qui, comme Docker, peuvent indiquer au système d'exploitation hôte les limites à appliquer à un processus en cours d'exécution, notamment LXC , libvirt et systemd . Docker avait l'habitude d'utiliser ces applications pour interagir indirectement avec le système d'exploitation Linux, mais à présent, Docker interagit directement avec Linux en utilisant sa propre bibliothèque appelée " libcontainer ".
Les conteneurs ne sont donc que des processus fonctionnant dans un mode restreint, similaire à ce que chroot faisait.
IMO Docker se distingue des autres technologies de conteneurs par son référentiel (Docker Hub) et ses outils de gestion qui facilitent grandement l'utilisation des conteneurs.
Voir https://en.m.wikipedia.org/wiki/Docker_ (Linux_container_engine)
Comme beaucoup de réponses l'ont souligné: vous construisez fichier docker pour obtenir un image et vous exécutez image pour obtenir un conteneur .
Cependant, les étapes suivantes m'ont aidé à mieux comprendre l'image et le conteneur de Docker:
1) Construire Dockerfile:
docker build -t my_image dir_with_dockerfile
2) Enregistrez l'image dans le fichier .tar
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 approfondissez chaque couche, vous pouvez voir quelles modifications ont été ajoutées à chaque couche. (Ils devraient être assez proches des commandes dans le fichier Docker).
3) Pour regarder à l'intérieur d'un conteneur, vous pouvez faire:
Sudo docker run -it my_image bash
et vous pouvez voir que cela ressemble beaucoup à un système d'exploitation.
Image est l'équivalent d'une définition de classe dans OOP et les couches sont des méthodes et propriétés différentes de cette classe.
Container est l'instanciation réelle de l'image, exactement comme un objet est une instanciation ou une instance d'une classe.
Comme dans l'aspect programmation,
Image est un code source.
Lorsque code source est compilé et construit, il est appelé application.
Simillar à cela "quand l'instance est créée pour l'image", elle s'appelle "Container"
Une image Docker regroupe l'application et l'environnement requis par l'application à exécuter, et un conteneur est une instance en cours d'exécution de l'image.
Les images font partie intégrante du menu fixe, comme un "code source" ou un "programme". Les conteneurs sont la partie exécution de docker, analogue à un "processus".
Dans la question, seule la partie "programme" est mentionné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 sous la nouvelle image.
En bref:
Le conteneur 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 contient des packages et toutes les dépendances nécessaires pour exécuter le code.
Un conteneur Docker exécute une instance d'une image. Vous pouvez associer une image à un programme et un conteneur à un processus :)
Une image est à une classe en tant que conteneur à un objet.
Un conteneur est une instance d'une image, alors qu'un objet est une instance d'une classe.
Je pense qu'il vaut mieux expliquer au début.
Supposons que vous exécutiez la commande: Docker lance hello-world. ce qui se produit ?
il appelle docker cli qui est chargé de prendre les commandes du menu fixe et de le transformer en appel serveur docker les commandes. dès que serveur fixe obtient la commande à exécuter image, il vérifie la météo cache des images détient un image tel nom. supposons que bonjour le monde n'existe pas. serveur Docker passe à concentrateur de docker (le concentrateur de docker est juste un référentiel d'images gratuit) et demande, hé Hub, avez-vous un image appelé Bonjour le monde ? Réponses Hub - Oui, je le fais. alors donnez-le-moi, s'il vous plaît. et le processus de téléchargement commence. dès que image de docker est téléchargé, serveur de docker le place dans cache d'image.
Avant d’expliquer ce que sont docker image et docker container, commençons par une introduction au système d’exploitation de votre ordinateur et à son utilisation du logiciel.
lorsque vous exécutez, par exemple, chrome sur votre ordinateur, il appelle le système d’exploitation, le système d’exploitation appelle lui-même le noyau et demande: "Hé, je veux exécuter ce programme. Le noyau parvient à exécuter des fichiers à partir de votre disque dur.
imaginez maintenant que vous avez deux programmes chrome et nodejs. chrome nécessite python version 2 pour s'exécuter et nodejs nécessite python version 3 pour s'exécuter. Si vous n'avez installé que python v2 sur votre ordinateur, seul chrome sera exécuté.
pour que les deux cas fonctionnent, vous devez utiliser la fonctionnalité de système opérationnel connue sous le nom d'espacement de nom. L'espace de nommage est une fonctionnalité qui vous permet d'isoler les processus, le disque dur, le réseau, les utilisateurs, les noms d'hôte, etc.
Ainsi, lorsque nous parlons d'un Image, nous parlons en fait d'un instantané du système de fichiers. Un image est un fichier physique qui contient des instructions et des métadonnées pour construire un élément spécifique conteneur. Container est lui-même une instance de image, il isole le disque dur à l'aide du namespacing disponible uniquement pour conteneur. Donc conteneur est un processus ou un ensemble de processus qui regroupe les différentes ressources qui lui sont affectées.
Dockerfile est comme votre script bash qui produit une archive (image Docker).
Les conteneurs Docker sont comme la version extraite de l'archive. Vous pouvez avoir autant de copies que vous le souhaitez dans différents dossiers (les conteneurs).
Pour une analogie de programmation factice, vous pouvez penser à Docker qui a un résumé ImageFactory qui contient ImageFactories dont ils proviennent magasin .
Ensuite, lorsque vous souhaitez créer une application à partir de cette ImageFactory, vous aurez un nouveau conteneur que vous pourrez modifier à votre guise. DotNetImageFactory sera immuable, car il agit comme une classe de fabrique abstraite, où il ne fournit que les instances souhaitées.
IContainer newDotNetApp = ImageFactory.DotNetImageFactory.CreateNew(appOptions);
newDotNetApp.ChangeDescription("I am making changes on this instance");
newDotNetApp.Run();
Image - C'est le bloc de construction d'un conteneur. C’est en fait une sorte d’instantané du virtuel mais plus léger.
Container - Il s'agit d'une méthode de virtualisation du système d'exploitation afin qu'une application et ses dépendances associées puissent être exécutées dans des processus isolés des ressources.
Alors que nous utilisons un menu fixe, nous obtenons une image de base pour le moment. Nous l'amorçons ensuite, faisons les modifications appropriées et sauvegardons ces modifications dans des calques formant une autre image. Un conteneur est fondamentalement une instance d'une image. Cela signifie qu'une image en cours d'exécution est un conteneur. Si une personne commence une image, elle exécute actuellement un conteneur. On peut avoir plusieurs conteneurs en cours d'exécution à la fois de la même image.
On peut voir toutes les images en utilisant le code suivant:
images de menu fixe
Les conteneurs en cours d'exécution peuvent être vus avec:
docker ps
Si on veut voir tous les conteneurs, qu'ils soient en cours d'exécution ou non:
docker ps -a