Lorsque vous utilisez Docker, nous commençons avec une image de base. Nous le démarrons, créons des changements et ces changements sont enregistrés dans des couches formant une autre image.

Donc, finalement, j'ai une image pour mon instance PostgreSQL et une image pour mon application Web, dont les modifications persistent.

Qu'est-ce qu'un conteneur?

Une instance d'une image est appelée un conteneur. Vous avez une image, qui est un ensemble de calques comme vous le décrivez. Si vous démarrez cette image, vous disposez d'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 imagestandis 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'exécution d'une image est un conteneur.

De mon article sur l' automatisation des déploiements Docker :

Images Docker vs conteneurs

Dans Dockerland, il y a des images et des conteneurs . Les deux sont étroitement liés, mais distincts. Pour moi, saisir 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 elles produisent un conteneur au démarrage de l' exécution . Les images sont stockées dans un registre Docker tel que registry.hub.docker.com . Parce qu'elles peuvent devenir assez volumineuses, les images sont conçues pour être composées de couches d'autres images, ce qui permet d'envoyer une quantité minimale de données lors du transfert d'images sur le réseau.

Les images locales peuvent être répertorié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:

1. ID D'IMAGE correspond aux 12 premiers caractères de l'identifiant réel d'une image. Vous pouvez créer de nombreuses balises d'une image donnée, mais leurs identifiants seront tous les mêmes (comme ci-dessus).
2. VIRTUAL SIZE est virtuel car il additionne 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.
3. La valeur de la colonne REPOSITORY provient du -tdrapeau de la docker buildcommande ou de docker tag-ing une image existante. Vous êtes libre de baliser les images en utilisant une nomenclature qui vous convient, mais sachez que Docker utilisera la balise comme emplacement de registre dans un docker pushou docker pull.
4. La forme complète d'une balise est [REGISTRYHOST/][USERNAME/]NAME[:TAG]. Pour ubuntuci-dessus, REGISTRYHOST est supposé être registry.hub.docker.com. Donc, si vous prévoyez de stocker votre image appelée my-applicationdans un registre à docker.example.com, vous devez étiqueter cette image docker.example.com/my-application.
5. La colonne TAG n'est que la partie [: TAG] de la balise complète . C'est une terminologie malheureuse.
6. La latestbalise n'est pas magique, c'est simplement la balise par défaut lorsque vous ne spécifiez pas de balise.
7. Vous pouvez avoir des images non balisées uniquement identifiables par leurs ID IMAGE. Ceux-ci obtiendront le <none>TAG et le REPOSITORY. Il est facile de les oublier.

Plus d'informations sur les images sont disponibles dans la documentation et le glossaire Docker .

Qu'est-ce qu'un conteneur?

Pour utiliser une métaphore de programmation, si une image est une classe, alors 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.

Afficher 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, j'exécute une version dockée du registre docker, de sorte que j'ai un endroit privé pour stocker mes images. Encore une fois, certaines choses à noter:

1. Comme l'ID D'IMAGE, l'ID DE CONTENEUR est le véritable identifiant du conteneur. Il a la même forme, mais il identifie un type d'objet différent.
2. docker psne produit que des conteneurs en cours d'exécution . Vous pouvez afficher tous les conteneurs (en cours d'exécution ou arrêtés ) avec docker ps -a.
3. NAMES peut être utilisé pour identifier un conteneur démarré via l' --nameindicateur.

Comment éviter l'accumulation d'images et de conteneurs

L'une de mes premières frustrations avec Docker a été l' accumulation apparemment constante d'images non marquées et de conteneurs arrêtés . À quelques reprises, cette accumulation a entraîné un maximum de disques durs ralentissant mon ordinateur portable ou arrêtant mon pipeline de construction automatisé. Parlez de «conteneurs partout»!

Nous pouvons supprimer toutes les images non marquées en les combinant docker rmiavec la dangling=truerequête récente :

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

Docker ne pourra pas supprimer les images qui se trouvent derrière les conteneurs existants, vous devrez donc peut-être supprimer les conteneurs arrêtés avec d' docker rmabord:

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

Ces problèmes sont 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:

1. Retirez toujours un récipient inutile et arrêté avec docker rm [CONTAINER_ID].
2. Retirez toujours l'image derrière un récipient inutile et arrêté avec docker rmi [IMAGE_ID].

En termes simples.

Images -

Le système de fichiers et l'application de configuration (en lecture seule) qui sont utilisés pour créer des conteneurs. Plus de détails .

Conteneurs -

Ce sont des instances en cours d'exécution d'images Docker. Les conteneurs exécutent les applications réelles. Un conteneur comprend 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 sur le système d'exploitation hôte. Plus de détails .

Autres termes importants à noter:

Démon Docker -

Service d'arrière-plan exécuté 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, un registre d'images Docker. Vous pouvez considérer le registre comme un répertoire de toutes les images Docker disponibles.

Une image de ce billet de blog vaut mille mots.

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

Sommaire:

• Pull image from Docker hub or build from a 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, c'est-à-dire un conteneur (modifiable)

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 sur le dessus 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 quitté n'est pas la même chose qu'une image, car il peut être redémarré et conservera ses paramètres et toutes les modifications du système de fichiers.

Peut-être que l'explication de l'ensemble du flux de travail peut vous aider.

Tout commence par le Dockerfile . Le Dockerfile est le code source de l'image.

Une fois le Dockerfile créé, vous le créez pour créer l' image du conteneur. L'image n'est que la "version compilée" du "code source" qui est le Dockerfile.

Une fois que vous avez l'image du conteneur, vous devez la redistribuer à l'aide du registre . Le registre est comme un référentiel Git - vous pouvez pousser et tirer 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 l' hyperviseur ).

Workflow

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 répertorier les images que vous pouvez exécuter, exécutez:

docker image ls

Pour répertorier les conteneurs sur lesquels vous pouvez exécuter des commandes:

docker ps

Je ne pouvais pas comprendre le concept d' image et de couche malgré la lecture de toutes les questions ici, puis je suis finalement tombé sur cette excellente documentation de Docker (duh!).

L'exemple il y a vraiment la clé pour comprendre tout le concept. C'est un long article, donc je résume les points clés qui doivent être vraiment saisis pour plus de clarté.

• Image : une image Docker est constituée d'une série de calques en lecture seule

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

Example: Le Dockerfile ci-dessous contient quatre commandes, chacune créant un calque.

DE ubuntu: 15.04

COPIE . / app

RUN make / app

CMD python /app/app.py

Surtout , chaque calque n'est 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 accessible en écriture 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 sur cette couche de conteneur accessible en écriture.

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 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é, la couche inscriptible est également supprimée. L'image sous-jacente reste inchangée.

Comprendre les images et les conteneurs dans une perspective de taille sur disque

Pour afficher la taille approximative d'un conteneur en cours d'exécution, vous pouvez utiliser la docker ps -scommande. Vous obtenez sizeet virtual sizecomme deux des sorties:

• Taille: la quantité de données (sur disque) utilisée pour la couche inscriptible 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. Ils ne sont donc pas additifs. C'est-à-dire que vous ne pouvez pas ajouter toutes les tailles virtuelles pour calculer la taille du disque 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 un calque inférieur de l'image et qu'un autre calque (y compris le calque accessible en écriture) doit y accéder en lecture, il utilise simplement 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 → (Build) → Image → (Run) → Container .

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

• Image : Dockerfile compilé. Vous fait gagner du temps de la reconstruction du Dockerfile chaque fois que vous devez exécuter un conteneur. Et c'est un moyen de masquer votre code de mise à disposition.

• Conteneur : le système d'exploitation virtuel lui-même. Vous pouvez y accéder et exécuter toutes les commandes que vous souhaitez, comme s'il s'agissait d'un environnement réel. Vous pouvez exécuter plus de 1000 conteneurs à partir de la même image.

En termes simples, si une image est une classe , un conteneur est une instance d'une classe est un objet d' exécution .

Un conteneur est juste un binaire exécutable qui doit être exécuté par le système d'exploitation hôte sous un ensemble de restrictions qui sont prédéfinies à l'aide d'une application (par exemple, Docker) qui sait dire au système d'exploitation quelles 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, CPU et réseau).

Jusqu'à récemment, seuls les noyaux des systèmes basés sur Unix prenaient en charge la possibilité d'exécuter des exécutables sous des restrictions strictes. C'est pourquoi la plupart des discussions sur les conteneurs impliquent aujourd'hui principalement Linux ou d'autres distributions Unix.

Docker est l'une de ces applications qui sait dire au système d'exploitation (Linux principalement) sous quelles restrictions exécuter un exécutable. L'exécutable est contenu dans l'image Docker, qui n'est qu'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 à l'intérieur.

Bien que la plupart des gens utilisent une base Linux comme exécutable, il peut s'agir de n'importe quelle autre application binaire tant que le système d'exploitation hôte peut l'exécuter (voir créer une image de base simple à l'aide de scratch ). Que le binaire dans l'image 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 contenu 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 en cours d'exécution, incluent 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, semblable à ce que chroot faisait auparavant.

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

Voir Docker (logiciel) .

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éutilisabilité, vous permettant de créer et de déposer des conteneurs en toute simplicité.

Les images représentent l'état d'un conteneur à chaque instant. Le workflow de base est donc:

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

Comme beaucoup de réponses ont souligné ceci: Vous construisez Dockerfile pour obtenir une image de et vous exécutez l' image pour obtenir un conteneur .

Cependant, les étapes suivantes m'ont aidé à mieux comprendre ce que sont l'image et le conteneur Docker:

1) Construisez Dockerfile:

docker build -t my_image dir_with_dockerfile

2) Enregistrez l'image dans un .tarfichier

docker save -o my_file.tar my_image_id

my_file.tarstockera l'image. Ouvrez-le avectar -xvf my_file.tar et vous verrez tous les calques. 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 du Dockerfile).

3) Pour jeter un œil à 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.

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

Le conteneur est l'instanciation réelle de l'image, tout comme la façon dont un objet est une instanciation ou une instance d'une classe.

Je pense qu'il vaut mieux expliquer au début.

Supposons que vous exécutez la commande docker run hello-world. Ce qui se produit?

Il appelle Docker CLI qui est responsable de prendre les commandes Docker et de se transformer pour appeler les commandes du serveur Docker . Dès que le serveur Docker reçoit une commande pour exécuter une image , il vérifie la météo, le cache d'images contient une image avec un tel nom.

Supposons que le monde bonjour n'existe pas. Le serveur Docker va à Docker Hub (Docker Hub est juste un référentiel d'images gratuit) et demande, hey Hub, avez-vous une image appelée hello-world? Réponses du hub - oui, je le fais. Alors donnez-le moi, s'il vous plaît. Et le processus de téléchargement démarre. Dès que l' image Docker est téléchargée, le serveur Docker la place dans le cache d'images .

Donc, avant d'expliquer ce que sont les images Docker et les conteneurs Docker, commençons par une introduction sur le système d'exploitation de votre ordinateur et comment il exécute le logiciel.

Lorsque vous exécutez, par exemple, Chrome sur votre ordinateur, il appelle le système d'exploitation, le système d'exploitation lui-même appelle 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 Node.js. Chrome nécessite Python version 2 pour fonctionner et Node.js nécessite Python version 3 pour s'exécuter. Si vous n'avez installé Python v2 que sur votre ordinateur, seul Chrome sera exécuté.

Pour que les deux cas fonctionnent, vous devez en quelque sorte utiliser une fonctionnalité du système d'exploitation appelée espace de noms. Un espace de noms est une fonctionnalité qui vous donne la possibilité d'isoler les processus, le disque dur, le réseau, les utilisateurs, les noms d'hôte, etc.

Ainsi, lorsque nous parlons d'une image, nous parlons en fait d'un instantané du système de fichiers. Une image est un fichier physique qui contient des instructions et des métadonnées pour créer un conteneur spécifique . Le conteneur lui-même est une instance d'une image ; il isole le disque dur à l'aide d'un espace de noms qui n'est disponible que pour ce conteneur . Un conteneur est donc un processus ou un ensemble de processus qui regroupe différentes ressources qui lui sont affectées.

Une image Docker contient 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 de Docker, analogue au "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 "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.

Comme pour la programmation,

L'image est le code source.

Quand le code source est compilé et généré, il est appelé une application.

Similaire à cela "lorsqu'une instance est créée pour l'image", elle est appelée " conteneur ".

Une image est un "instantané" d'un conteneur . Vous pouvez créer des images à partir d'un conteneur (nouveaux "instantanés"), et vous pouvez également démarrer de nouveaux conteneurs à partir d'une image (instancier l '"instantané").

Par exemple, vous pouvez instancier un nouveau conteneur à partir d'une image de base, exécuter certaines commandes dans le conteneur, puis prendre un instantané en tant que nouvelle image. Ensuite, vous pouvez exécuter 100 conteneurs à partir de cette nouvelle image.

Autres choses à considérer:

• Une image est constituée de calques, et les calques sont des "diffs" instantanés (donc lorsque vous poussez une image, vous n'avez qu'à envoyer le "diff" au registre).
• Un Dockerfile définit certaines commandes au-dessus d'une image de base, qui créent de nouveaux calques ("diffs") qui se traduisent par une nouvelle image ("snapshot").
• Les balises d'image ne sont pas seulement des balises. Ils sont le "nom complet" de l'image ("repository: tag"). Si la même image a plusieurs noms, elle s'affiche plusieurs fois lors de l'exécution docker images.

Je voudrais remplir la partie manquante ici entre docker imageset containers. Docker utilise un système de fichiers union ( UFS ) pour les conteneurs, qui permet de monter plusieurs systèmes de fichiers dans une hiérarchie et d'apparaître comme un seul système de fichiers. Le système de fichiers de l'image a été monté en tant que read-onlycouche, et toutes les modifications apportées au conteneur en cours d'exécution sont apportées à une read-writecouche montée au-dessus de cela. Pour cette raison, Docker n'a qu'à regarder la couche de lecture-écriture la plus haute pour trouver les modifications apportées au système en cours d'exécution.

Pour une analogie de programmation factice, vous pouvez penser à Docker a une ImageFactory abstraite qui contient les ImageFactories dont ils proviennent du magasin .

Ensuite, une fois que vous souhaitez créer une application à partir de cette ImageFactory, vous aurez un nouveau conteneur et vous pourrez le modifier comme vous le souhaitez. DotNetImageFactory sera immuable, car il agit comme une classe d'usine 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();

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 aura 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 avec un programme et un conteneur avec un processus :)

Une image est à une classe comme un conteneur à un objet.

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

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

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