Une instance d’une image s’appelle un conteneur. Vous avez une image, qui est un ensemble de calques 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 de 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 ).

Ainsi, une instance en cours d’exécution d’une image est un conteneur.

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

Docker Images vs. Conteneurs

A 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 à l’aide de la commande build et elles génèrent 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 très volumineuses, les images sont conçues pour être composées de couches d’autres images, ce qui permet d’envoyer une quantité fictive de données lors du transfert d’images sur le réseau.

Les images locales peuvent être répertoriées en exécutant des 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   4ab0d9120985 3 months ago 486.5 MB 

Quelques points à noter:

1. L’ID IMAGE correspond aux 12 premiers caractères de l’identifiant réel d’une image. Vous pouvez créer plusieurs tags d’une image donnée, mais leurs identifiants seront tous identiques (comme ci-dessus).
2. TAILLE VIRTUELLE est virtuelle car elle ajoute les tailles de toutes les couches sous-jacentes distinctes. Cela signifie que la sum 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 de l’indicateur -t de la commande docker build ou de la docker tag une image existante. Vous êtes libre d’étiqueter des images en utilisant une nomenclature qui a du sens pour vous, mais sachez que docker utilisera la balise comme emplacement de registre dans une docker push docker pull ou une docker pull .
4. La forme complète d’une balise est [REGISTRYHOST/][USERNAME/]NAME[:TAG] . Pour ubuntu ci-dessus, REGISTRYHOST est censé être registry.hub.docker.com . Donc, si vous prévoyez de stocker votre image appelée my-application dans un registre sur docker.example.com , vous devez marquer 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 latest balise 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 marquées identifiables uniquement par leurs ID IMAGE. Ceux-ci obtiendront le TAG et le REPOSITORY. Il est facile de les oublier.

Plus d’informations sur les images sont disponibles dans les documents et le glossaire Docker .

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 object d’exécution. Avec un peu de chance, les conteneurs expliquent 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, je lance une version dockerized du registre de docker, de sorte que j’ai un endroit privé pour stocker mes images. Encore une fois, certaines choses à noter:

1. À l’instar de l’ID D’IMAGE, l’ID CONTAINER est le véritable identifiant du conteneur. Il a la même forme, mais il identifie un type d’object différent.
2. docker ps ne 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. Les NAMES peuvent être utilisés pour identifier un conteneur démarré via l’indicateur --name .

Comment éviter les images et l’accumulation de conteneurs?

Une de mes premières frustrations avec Docker était l’ apparence apparemment constante d’images non étiquetées et de conteneurs arrêtés . À quelques occasions, cette accumulation a entraîné un maximum de disques durs qui ont ralenti mon ordinateur portable ou interrompu mon pipeline de génération automatisée. Parlez de “conteneurs partout”!

Nous pouvons supprimer toutes les images non étiquetées en combinant docker rmi avec la requête récente dangling=true :

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

Docker ne sera pas en mesure de supprimer les images qui se trouvent derrière des conteneurs existants. Vous devrez donc d’abord supprimer les conteneurs arrêtés avec docker rm :

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

Docker connaît des problèmes connus et pourrait être abordé dans les versions ultérieures. Cependant, avec une compréhension claire des images et des conteneurs, ces situations peuvent être évitées avec quelques pratiques:

1. Supprimez toujours un conteneur inutile et arrêté avec docker rm [CONTAINER_ID] .
2. 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 parameters, 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 sorti n’est pas identique à une image, car il peut être redémarré et conservera ses parameters et tout changement de système de fichiers.

Peut-être qu’expliquer tout le stream de travail peut aider.

Tout commence par le Dockerfile . Le fichier 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 juste la “version compilée” du “code source” qui est le fichier Docker.

Une fois que vous avez l’image du conteneur, vous devez le redissortingbuer à l’aide du registre . Le registre est comme un repository 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, à de nombreux égards, à une machine virtuelle (mais sans l’ hyperviseur ).

Cet article explique beaucoup de choses de base sur les conteneurs docker (il s’agit de Docker et Puppet, mais il existe de nombreux concepts qui peuvent être utilisés dans n’importe quel contexte)

C’est assez simple.

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

Images –

L’application de système de fichiers et de configuration (lecture seule) utilisée pour créer des conteneurs. Plus de détails

Conteneurs –

Ces instances exécutent des images Docker. Les conteneurs exécutent les applications réelles. Un conteneur comprend une application et toutes ses dépendances. Il partage le kernel avec d’autres conteneurs et s’exécute en tant que processus isolé dans l’espace utilisateur du système d’exploitation hôte. Plus de détails

Autres termes importants à noter:

Docker daemon –

Le service d’arrière-plan exécuté sur l’hôte qui gère la construction, l’exécution et la dissortingbution 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 vaut mieux que mille mots.

Résumé:

• Extraire l’ image du concentrateur Docker ou créer un fichier Dockerfile => Donne une image Docker (non modifiable).
• Exécutez l’image ( docker run image_name:tag_name ) => Donne une image en cours d’exécution, c.-à-d. Un conteneur (modifiable)

Workflow

Voici le stream de travail 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 pourriez exécuter, exécutez:

 docker image ls 

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

 docker ps 

Je ne pouvais pas comprendre le concept d’ image et de couche en dépit de lire toutes les questions ici et je suis finalement tombé sur cette excellente documentation de Docker (duh!).

L’exemple, il y a vraiment la clé pour comprendre l’ensemble du concept. C’est un long message, alors je résume les points essentiels à saisir pour être clair.

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

• Couche : chaque couche représente une instruction dans le fichier Docker de l’image.

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

À partir de Ubuntu: 15.04

COPIE . / app

RUN make / app

CMD python /app/app.py

Surtout , chaque couche n’est qu’un ensemble de différences par rapport à la couche avant.

• Conteneur Lorsque vous créez un nouveau conteneur, vous ajoutez une nouvelle couche inscriptible au-dessus des couches sous-jacentes . Cette couche est souvent appelée “couche conteneur”. Toutes les modifications apscopes 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 inscriptible mince .

Par conséquent, la différence majeure entre un conteneur et une image est la couche accessible en écriture supérieure . Toutes les écritures dans le conteneur qui ajoutent ou modifient 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 rest inchangée.

Comprendre les images cnd Conteneurs depuis 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: la 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, ils ne sont pas additifs. C’est-à-dire que vous ne pouvez pas append toutes les tailles virtuelles pour calculer la taille de 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 une couche inférieure de l’image et qu’un autre calque (y compris la couche accessible en écriture) doit y être accessible en lecture, il utilise uniquement 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.

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

• Dockerfile : contient un ensemble d’instructions de docker qui alimente 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 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 accéder et lancer les commandes souhaitées, comme s’il s’agissait d’un environnement réel. Vous pouvez exécuter 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 facilite la réutilisation, vous permettant de créer et de déposer des conteneurs en toute simplicité.

Les images décrivent 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

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

Les ressortingctions 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, processeur, mise en réseau).

Jusqu’à récemment, seuls les kernelx dans les systèmes basés sur Unix permettaient d’exécuter des exécutables avec des ressortingctions ssortingctes. C’est pourquoi la plupart des discussions sur les conteneurs concernent principalement Linux ou d’autres dissortingbutions Unix.

Docker est l’une de ces applications qui sait dire au système d’exploitation (Linux principalement) quelles sont les ressortingctions pour exécuter un exécutable sous. L’exécutable est contenu dans l’image Docker, qui n’est qu’un fichier tarfile. Cet exécutable est généralement une version simplifiée d’une dissortingbution Linux (Ubuntu, Centos, Debian, etc.) préconfigurée pour exécuter une ou plusieurs applications.

Bien que la plupart des utilisateurs utilisent une base Linux comme exécutable, il peut s’agir de n’importe quelle autre application binary 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 binary de l’image du docker soit un système d’exploitation ou simplement une application, l’hôte est simplement un autre processus, un processus contenu régi par des limites de système d’exploitation prédéfinies.

D’autres applications, telles que 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 utilisait ces applications pour interagir indirectement avec le système d’exploitation Linux, mais Docker interagit désormais directement avec Linux en utilisant sa propre bibliothèque appelée ” libcontainer “.

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

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

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

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

Une image Docker emballe l’application et l’environnement requirejs par l’application à 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 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 apscopes, c’est comme si le processus modifiait son propre code source et l’enregistrait en tant que nouvelle image.

Image est l’équivalent d’une définition de classe dans la POO et les couches 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 la façon dont un object est une instanciation ou une instance d’une classe.

Comme dans l’aspect programmation,

L’image est un code source.

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

Simillar à celui “quand l’instance est créée pour l’image”, elle s’appelle ” Container ”

En bref:

Container est une division (virtuelle) dans un kernel 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.

Une image est une classe en tant que conteneur pour un object.

Un conteneur est une instance d’une image car un object est une instance d’une classe.

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 avec la programmation factice, vous pouvez penser que Docker a un ImageFactory abstrait qui contient les ImageFactories, ils viennent du magasin .

Une fois que vous souhaitez créer une application à partir d’ImageFactory, vous aurez un nouveau conteneur et vous pourrez le modifier comme vous le souhaitez. DotNetImageFactory sera immuable, car il agit comme une classe de fabrique 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 associer une image à un programme et à un conteneur avec un processus 🙂