Explication détaillée de Docker dans un article
Qu’est-ce que Docker ?
Docker est une plateforme de conteneurisation open source conçue pour simplifier le processus de déploiement, d'exécution et de gestion des applications. Il est basé sur la technologie de conteneurisation, qui peut regrouper les applications et leurs dépendances dans un conteneur indépendant et portable, permettant ainsi aux applications de s'exécuter de manière cohérente dans différents environnements.
Un conteneur est une unité d'exécution légère et autonome qui contient une application et tous les logiciels, bibliothèques, variables d'environnement et fichiers de configuration dont elle a besoin pour s'exécuter. En utilisant Docker, vous pouvez regrouper une application et ses dépendances dans une image de conteneur, puis déployer et exécuter cette image de conteneur dans n'importe quel environnement prenant en charge Docker sans vous soucier des différences dans l'environnement sous-jacent.
Docker fournit un ensemble d'outils de ligne de commande et d'API pour créer, gérer et exécuter des conteneurs. Il utilise des technologies de virtualisation de la couche du système d'exploitation telles que Linux Containers (LXC) ou des technologies open source plus récentes telles que le moteur de conteneur (containerd) et le runtime de conteneur (container runtime) pour obtenir une conteneurisation efficace.
Grâce à Docker, vous pouvez déployer et étendre rapidement des applications, améliorant ainsi l'efficacité du développement, de l'exploitation et de la maintenance. Il offre isolation, portabilité et réutilisabilité, ce qui rend les applications plus faciles à empaqueter, à fournir et à gérer. De plus, Docker prend également en charge la communication réseau et le montage de volumes de données entre conteneurs, ce qui facilite l'interconnexion et le partage de données entre conteneurs.
En résumé, Docker est une plate-forme de conteneurisation qui fournit des outils et des environnements qui simplifient le déploiement et la gestion des applications, permettant aux applications de s'exécuter de manière cohérente dans différents environnements .
Quels sont les scénarios d’application de Docker ?
Docker propose un large éventail de scénarios d'application. Voici quelques scénarios d'application courants :
- Conditionnement et livraison d'applications : Docker peut regrouper une application et toutes ses dépendances dans une image de conteneur, garantissant ainsi que l'application s'exécute de manière cohérente dans différents environnements. Cela rend le déploiement et la livraison des applications plus faciles et plus fiables.
- Déploiement et mise à l'échelle des applications : grâce à Docker, les applications peuvent être rapidement déployées et mises à l'échelle. En empaquetant votre application dans une image de conteneur, vous pouvez facilement déployer et exécuter votre application dans n'importe quel environnement compatible Docker. Dans le même temps, les applications peuvent être rapidement mises à l’échelle horizontalement selon les besoins pour répondre à la demande croissante.
- Architecture de microservices : Docker est idéal pour créer et gérer des architectures de microservices. Chaque microservice peut être regroupé dans un conteneur indépendant pour réaliser un découplage et un déploiement indépendant entre les services. En utilisant Docker, il est plus facile de gérer et de faire évoluer les microservices, ainsi que de communiquer et de collaborer entre les microservices.
- Intégration continue et déploiement continu (CI/CD) : Docker peut être combiné avec des processus d'intégration continue et de déploiement continu pour réaliser une construction, des tests et un déploiement automatisés. En utilisant des conteneurs Docker, vous pouvez créer un environnement de construction et de test cohérent pour garantir la cohérence de votre application à différentes étapes.
- Isolation et cohérence des environnements de développement : Docker aide les développeurs à créer localement des environnements de développement légers et isolés. Les développeurs peuvent utiliser des conteneurs pour configurer et gérer l'environnement d'exécution des applications sans affecter le système hôte. Cela rend l'installation et la configuration d'un environnement de développement plus simple et plus reproductible.
- Déploiement multiplateforme et cloud hybride : en raison de la nature multiplateforme de Docker, les images de conteneurs peuvent être déployées dans différents systèmes d'exploitation et plateformes cloud. Cela rend les applications plus flexibles pour migrer et évoluer dans différents environnements, tout en facilitant également le déploiement de cloud hybride et la gestion de plates-formes cross-cloud.
En plus des scénarios d'application ci-dessus, Docker peut également être utilisé pour la création d'environnements de test, la construction et le partage rapides d'environnements, l'isolation et la sécurité des ressources, etc. Sa flexibilité et sa portabilité rendent Docker largement utilisé dans le développement et le déploiement d'applications modernes.
Concepts de base de Docker
Avant de comprendre les concepts de base de Docker, plusieurs termes fondamentaux doivent être compris :
- Image : Une image Docker est un modèle en lecture seule qui contient tous les systèmes de fichiers, environnements logiciels, applications et dépendances requis pour exécuter un conteneur. Les images constituent la base de la création de conteneurs. Vous pouvez obtenir des images existantes à partir de Docker Hub ou de référentiels privés, ou créer des images personnalisées via Dockerfiles.
- Conteneur : un conteneur Docker est une instance exécutable d'une image et constitue un environnement d'exécution indépendant et isolé. Un conteneur contient tous les fichiers, variables d'environnement, bibliothèques et configuration requis pour exécuter une application. Vous pouvez exécuter des applications en démarrant un conteneur, et vous pouvez démarrer, arrêter, suspendre, supprimer, etc. des opérations sur le conteneur.
- La relation entre l'image (Image) et le conteneur (Container) est similaire aux classes et aux instances dans la programmation orientée objet . L'image est une définition statique et le conteneur est l'entité lorsque l'image est exécutée.
- Entrepôt (Docker Registry) : Docker Registry fournit un référentiel centralisé et accessible pour stocker et distribuer des images Docker, permettant aux utilisateurs de partager, télécharger et gérer facilement des images.
- Une fois l'image créée, elle peut être facilement exécutée sur l'hôte actuel. Cependant, si nous devons utiliser cette image sur d'autres serveurs, nous avons besoin d'un service centralisé pour stocker et distribuer les images. Docker Registry est un tel service.
- Un Docker Registry peut contenir plusieurs référentiels (Repositories) ; chaque référentiel peut contenir plusieurs balises ; chaque balise correspond à une image.
- Habituellement, un entrepôt contient des images de différentes versions du même logiciel, et des balises sont souvent utilisées pour correspondre à chaque version du logiciel
. Nous pouvons spécifier quelle version de ce logiciel est l'image via le format <warehouse name> :<tag> - Docker fournit officiellement un registre public appelé Docker Hub. Sur Docker Hub, les utilisateurs peuvent trouver un grand nombre d'images publiques qui peuvent être utilisées directement ou comme images de base pour créer leurs propres images.
- En plus de Docker Hub, les utilisateurs peuvent également créer un registre Docker privé pour stocker et gérer leurs propres images afin d'obtenir une sécurité et une contrôlabilité accrues.
- Dockerfile : un Dockerfile est un fichier texte qui définit comment créer une image Docker. Dockerfile contient une série d'instructions et de configurations pour guider les opérations du moteur Docker pendant le processus de construction, telles que la sélection de l'image de base, l'installation du logiciel, la copie de fichiers, la configuration des variables d'environnement, etc. Grâce à Dockerfile, le processus automatisé de création d'images peut être réalisé.
- Docker Compose : Docker Compose est un outil permettant de définir et d'exécuter plusieurs conteneurs Docker. Il utilise un fichier YAML pour configurer les relations et les dépendances entre plusieurs conteneurs et peut démarrer, arrêter et gérer l'ensemble de l'application conteneur avec une seule commande.
Ces concepts de base constituent le cœur de Docker. En les comprenant, vous pouvez mieux utiliser et gérer les environnements conteneurisés Docker.
Installation du menu Docker
Nous citons ici des informations externes pertinentes pour répertorier l'installation de Docker dans l'environnement CenOS7 :
- Tutoriel d'installation détaillé de Vmvare : https://blog.csdn.net/SoulNone/article/details/126681722
- Clé d'activation de la machine virtuelle Vmvare : https://www.bilibili.com/read/cv21151094
- Téléchargement d'images CenterOS7 : https://blog.csdn.net/a350904150/article/details/129833998
- Vmvare et CenterOS7：https://blog.csdn.net/StupidlyGrass/article/details/128646335
- Installez Docker dans l'environnement CenterOS7 : https://blog.csdn.net/Siebert_Angers/article/details/127315542
Image Docker
Docker a besoin que l'image correspondante existe localement avant d'exécuter le conteneur. Si l'image n'existe pas localement, Docker téléchargera l'image depuis l'entrepôt d'images.
Obtenir une image
La commande permettant d'obtenir l'image de l'entrepôt d'images Docker est docker pull. Son format de commande est :
$ docker pull [选项] [Docker Registry 地址[:端口号]] 仓库名[:标签]
- Adresse de l'entrepôt d'images Docker : le format de l'adresse est généralement <nom de domaine/IP>[:numéro de port]. L'adresse par défaut est DockerHub
- Nom de l'entrepôt : comme mentionné précédemment, le nom de l'entrepôt est ici un nom en deux parties, c'est-à-dire <nom d'utilisateur>/<nom du logiciel>. Pour DockerHub, si le nom d'utilisateur n'est pas donné, la valeur par défaut est library, qui est l'image officielle.
[root@localhost snow]# docker pull ubuntu:16.04
16.04: Pulling from library/ubuntu
58690f9b18fc: Pull complete
b51569e7c507: Pull complete
da8ef40b9eca: Pull complete
fb15d46c38dc: Pull complete
Digest: sha256:1f1a2d56de1d604801a9671f301190704c25d604a416f59e03c04f5c6ffee0d6
Status: Downloaded newer image for ubuntu:16.04
docker.io/library/ubuntu:16.04
[root@localhost snow]#
Dans l'exemple ci-dessus, l'adresse de l'entrepôt d'images Docker n'est pas indiquée, l'image sera donc obtenue à partir de Docker Hub. Le nom de l'image est ubuntu:16.04, donc l'image étiquetée 16.04 dans la bibliothèque d'images officielle/l'entrepôt Ubuntu sera obtenue.
À partir du processus de téléchargement, vous pouvez voir le concept de stockage hiérarchisé que nous avons mentionné précédemment. L'image est composée de plusieurs couches de stockage. Le téléchargement se fait également couche par couche, pas un seul fichier.
courir
Une fois que nous avons l'image, nous pouvons démarrer et exécuter un conteneur basé sur cette image. En prenant l'ubuntu:16.04 ci-dessus comme exemple, si nous prévoyons de démarrer bash à l'intérieur et d'effectuer des opérations interactives :
root@localhost snow]# docker run -it --rm ubuntu:16.04 bash
root@3f44186a6166:/# ls -la
total 4
drwxr-xr-x. 1 root root 6 May 27 18:29 .
drwxr-xr-x. 1 root root 6 May 27 18:29 ..
-rwxr-xr-x. 1 root root 0 May 27 18:29 .dockerenv
drwxr-xr-x. 2 root root 4096 Aug 4 2021 bin
drwxr-xr-x. 2 root root 6 Apr 12 2016 boot
docker run est la commande pour exécuter le conteneur. Le format détaillé de la commande sera expliqué dans la section conteneur.
Liste des images
Pour lister les images téléchargées, utilisez la commande docker image ls :
root@3f44186a6166:/# exit
exit
[root@localhost snow]# docker image ls
REPOSITORY TAG IMAGE ID CREATED SIZE
hello-world latest 9c7a54a9a43c 3 weeks ago 13.3kB
ubuntu 16.04 b6f507652425 21 months ago 135MB
Supprimer l'image locale
Si vous souhaitez supprimer l'image locale, vous pouvez utiliser la commande docker image rm, dont le format est :
$ docker image rm [选项] <镜像1> [<镜像2> ...]
Parmi eux, <image> peut être un identifiant court d'image, un identifiant long d'image, un nom d'image ou un résumé d'image.
L'ID court répertorié par docker image ls par défaut est généralement constitué des 3 premiers caractères ou plus, à condition qu'ils soient suffisants pour le distinguer des autres images.
[root@localhost snow]# docker image ls
REPOSITORY TAG IMAGE ID CREATED SIZE
redis latest 0ec8ab59a35f 4 days ago 117MB
hello-world latest 9c7a54a9a43c 3 weeks ago 13.3kB
ubuntu 16.04 b6f507652425 21 months ago 135MB
[root@localhost snow]# docker image rm 0ec
Untagged: redis:latest
Untagged: redis@sha256:f9724694a0b97288d2255ff2b69642dfba7f34c8e41aaf0a59d33d10d8a42687
Deleted: sha256:0ec8ab59a35faa3aaee416630128e11949d44ac82d15d43053f8af5d61182a5d
Deleted: sha256:f89720eafb298773509177d4b8b76a32adda4da1015ca28f52daa03fc6090499
Deleted: sha256:c3b5385e13627e14d553f09a098275d1f1ada0b6228cc30c92e095d669df799c
Deleted: sha256:b830b2806be6a052c6d857f927f72ef18a2539e69fdb6d51cf95d76d7e06c8f1
Deleted: sha256:8de1c0863fac10debb4e19de0cc27639ae97c1111eca0920649b21d97bc8dded
Deleted: sha256:80940c1d5550f3f56f5ab008aa79e899e4d3c9b6b41b9f76077f31dcfb2c482c
Deleted: sha256:8cbe4b54fa88d8fc0198ea0cc3a5432aea41573e6a0ee26eca8c79f9fbfa40e3
[root@localhost snow]#
Si vous observez les informations de sortie des commandes ci-dessus, vous remarquerez que le comportement de suppression est divisé en deux catégories, l'une est Non balisé et l'autre est Supprimé. Comme nous l'avons introduit précédemment, l'identifiant unique d'une image est son identifiant et son résumé, et une image peut avoir plusieurs balises.
Lorsque vous utilisez la commande ci-dessus pour supprimer une image, vous demandez en fait de supprimer l'image d'une certaine balise. La première chose que nous devons faire est donc d'annuler toutes les balises d'image qui répondent à nos exigences. Ce sont les informations non balisées que nous voyons. Lorsque toutes les balises de l'image sont annulées, l'image risque de perdre le sens de son existence, donc le comportement Supprimé sera déclenché.
commit Comprendre la composition de l'image
Remarque : en plus de l'apprentissage, la commande docker commit a également des applications spéciales, telles que la sauvegarde de la scène après avoir été envahie. Cependant, n'utilisez pas docker commit pour personnaliser l'image. La personnalisation de l'image doit être effectuée à l'aide d'un Dockerfile . Si vous souhaitez personnaliser l'image, veuillez consulter la section suivante
Prenons maintenant l'exemple de la personnalisation d'un serveur Web pour expliquer comment l'image est construite :
[root@localhost snow]# docker pull nginx
Using default tag: latest
latest: Pulling from library/nginx
f03b40093957: Pull complete
eed12bbd6494: Pull complete
fa7eb8c8eee8: Pull complete
7ff3b2b12318: Pull complete
0f67c7de5f2c: Pull complete
831f51541d38: Pull complete
Digest: sha256:af296b188c7b7df99ba960ca614439c99cb7cf252ed7bbc23e90cfda59092305
Status: Downloaded newer image for nginx:latest
docker.io/library/nginx:latest
[root@localhost snow]# docker run --name web1.0 -d -p 80:80 nginx
054d1cdcf5cf2de43116697f2a96e0c50a5138cd753580f55f1966364df155f1
[root@localhost snow]#
Cette commande démarrera un conteneur avec l'image nginx, nommé web1.0, et mappera le port 80, afin que nous puissions utiliser le navigateur pour accéder au serveur nginx ;
Si vous exécutez Docker sous Linux, vous pouvez accéder directement : http://localhost ; si vous utilisez Docker installé sur une machine virtuelle ou un serveur cloud, vous devez remplacer localhost par l'adresse de la machine virtuelle ou l'adresse réelle du serveur cloud.
[Échec du transfert de l'image du lien externe. Le site source peut avoir un mécanisme anti-sangsue. Il est recommandé de sauvegarder l'image et de la télécharger directement (img-Licj8a72-1686898089872) (C:\Users\lixuewen\AppData\Roaming\Typora\ typora-user-images\ image-20230527191015639.png)]
Supposons que nous n'aimons pas cette page d'accueil et que nous souhaitions la remplacer par un autre texte. Nous pouvons utiliser la commande docker exec pour entrer dans le conteneur et modifier son contenu.
[root@localhost snow]# docker exec -it web1.0 bash
root@054d1cdcf5cf:/# echo '<h1>Hello,World!</h1>' > /usr/share/nginx/html/index.html
root@054d1cdcf5cf:/# exit
exit
[root@localhost snow]#
Nous sommes entrés dans le conteneur du serveur Web en mode terminal interactif et avons exécuté la commande bash, c'est-à-dire que nous avons obtenu un Shell exploitable ; puis nous avons utilisé
Bonjour le monde!
Couvre le contenu de /usr/share/nginx/html/index.html ;Actualisez le navigateur et la page apparaîtra comme suit :
[Échec du transfert d'image par lien externe. Le site source peut avoir un mécanisme anti-sangsue. Il est recommandé de sauvegarder l'image et de la télécharger directement (img-N2yya1zd-1686898089873) (C:\Users\lixuewen\AppData\Roaming\Typora\ typora-user-images\ image-20230527193042587.png)]
Nous avons modifié les fichiers du conteneur, ce qui signifie que nous avons changé la couche de stockage du conteneur. Nous pouvons voir les changements spécifiques grâce à la commande docker diff
[root@localhost snow]# docker diff web1.0
C /run
A /run/nginx.pid
C /usr
C /usr/share
C /usr/share/nginx
C /usr/share/nginx/html
C /usr/share/nginx/html/index.html
C /root
A /root/.bash_history
C /etc
C /etc/nginx
C /etc/nginx/conf.d
C /etc/nginx/conf.d/default.conf
C /var
C /var/cache
Docker fournit une commande docker commit qui peut enregistrer la couche de stockage du conteneur dans une image. Autrement dit, sur la base de l'image originale, la couche de stockage du conteneur se superpose pour former une nouvelle image . Lorsque nous exécuterons cette nouvelle image à l'avenir, nous aurons les dernières modifications de fichier du conteneur d'origine :
Le format de syntaxe du commit docker est :
$ docker commit [选项] <容器ID或容器名> [<仓库名>[:<标签>]]
[root@localhost snow]# docker commit --author "snow" --message "edit index.html" web1.0 nginx:2.0
sha256:c06e3839c9eb09fee7e4409290e2d51ddeb214fe87a73d9806cd9479ddf2c9ca
[root@localhost snow]# docker image ls nginx
REPOSITORY TAG IMAGE ID CREATED SIZE
nginx 2.0 c06e3839c9eb 28 seconds ago 143MB
nginx latest f9c14fe76d50 2 days ago 143MB
[root@localhost snow]#
–author spécifie l'auteur de la modification, tandis que --message enregistre le contenu de cette modification. Ceci est similaire au contrôle de version git ; nous pouvons voir cette nouvelle image personnalisée dans l'image docker ls.
Une fois la nouvelle image personnalisée, nous pouvons exécuter l'image :
Ici, nous nommons le nouveau service web2.0 et le mappons au port 81. Nous accédons à nouveau directement à http://ip:81 et voyons le résultat : son contenu doit être le même que celui du web1.0 précédemment modifié.
[Échec du transfert de l'image du lien externe. Le site source peut avoir un mécanisme anti-sangsue. Il est recommandé de sauvegarder l'image et de la télécharger directement (img-UdbJXDID-1686898089874) (C:\Users\lixuewen\AppData\Roaming\Typora\ typora-user-images\ image-20230527194357988.png)]
Jusqu'à présent, nous avons terminé l'image personnalisée pour la première fois.Nous avons utilisé la commande docker commit pour ajouter manuellement un nouveau calque à l'ancienne image afin de former une nouvelle image.
Utilisez Docker Commit avec prudence
Bien que l'utilisation de la commande docker commit puisse aider à comprendre intuitivement le concept de stockage hiérarchisé d'images, elle n'est pas utilisée de cette façon dans l'environnement réel.
L'utilisation de docker commit signifie que toutes les opérations sur l'image sont des opérations de boîte noire. L'image générée est également appelée image de boîte noire. En d'autres termes, sauf pour la personne qui a créé l'image qui sait quelles commandes ont été exécutées et comment générer l'image , d'autres n'ont aucun moyen de le savoir.
Image personnalisée Dockerfile
De l'étude de docker commit, j'ai appris que la personnalisation de l'image est en fait la personnalisation de la configuration et des fichiers ajoutés à chaque couche. Si nous pouvons écrire les commandes pour modifier, installer, construire et exploiter chaque couche dans un script, et utiliser ce script pour créer et personnaliser l'image, alors les problèmes mentionnés précédemment ne peuvent pas être répétés, la transparence de la construction de l'image et le volume de Les problèmes seront tous résolus. Ce script est le Dockerfile.
En prenant comme exemple la personnalisation précédente de l'image nginx, cette fois nous utilisons Dockerfile pour la personnaliser.
Dans un répertoire vide, créez un fichier texte et nommez-le Dockerfile :
[root@localhost snow]# mkdir nginxtest
[root@localhost snow]# cd nginxtest
[root@localhost nginxtest]# touch Dockerfile
Ajoutez son contenu via la commande Vim :
FROM nginx
RUN echo '<h1>Hello, EveryDay!</h1>' > /usr/share/nginx/html/index.html
-
FROM spécifie l'image de base
L'image dite personnalisée doit être basée sur une image et personnalisée par-dessus celle-ci. Tout comme nous avons précédemment exécuté un
conteneur avec une image nginx puis l'avons modifié, l'image de base doit être spécifiée. FROM spécifie l'image de base
, donc FROM est une instruction nécessaire dans un Dockerfile et doit être la première instruction . -
Commande d'exécution RUN
L'instruction RUN est utilisée pour exécuter des commandes de ligne de commande.
En raison des puissantes capacités de la ligne de commande, la commande RUN est l'une des commandes les plus couramment utilisées lors de la personnalisation des images . Il existe deux formats :- format shell : RUN <command>, tout comme une commande saisie directement sur la ligne de commande
RUN echo '<h1>Hello, Docker!</h1>' > /usr/share/nginx/html/index.html- format exec : RUN ["fichier exécutable", "paramètre 1", "paramètre 2"], cela ressemble plus au format des appels de fonction
Puisque RUN peut exécuter des commandes comme un script Shell, pouvons-nous mapper chaque
commande à un RUN comme un script Shell ? Par exemple:
FROM debian:jessie
RUN apt-get update
RUN apt-get install -y gcc libc6-dev make
RUN wget -O redis.tar.gz "http://download.redis.io/releases/redis-3.2.5.tar.gz"
RUN mkdir -p /usr/src/redis
RUN tar -xzf redis.tar.gz -C /usr/src/redis --strip-components=1
RUN make -C /usr/src/redis
RUN make -C /usr/src/redis install
La méthode d'écriture ci-dessus crée une image à 7 couches. Cela n’a absolument aucun sens ; une meilleure façon de l’écrire serait la suivante :
FROM debian:jessie
RUN buildDeps='gcc libc6-dev make' \
&& apt-get update \
&& apt-get install -y $buildDeps \
&& wget -O redis.tar.gz "http://download.redis.io/releases/redis-3.2.5.tar.gz" \
&& mkdir -p /usr/src/redis \
&& tar -xzf redis.tar.gz -C /usr/src/redis --strip-components=1 \
&& make -C /usr/src/redis \
&& make -C /usr/src/redis install \
&& rm -rf /var/lib/apt/lists/* \
&& rm redis.tar.gz \
&& rm -r /usr/src/redis \
&& apt-get purge -y --auto-remove $buildDeps
Au lieu d'utiliser plusieurs paires RUN pour correspondre à différentes commandes une par une, une seule instruction RUN est utilisée et && est utilisé pour concaténer les commandes requises. Simplification des 7 couches précédentes en 1 couche. Lorsque vous écrivez un Dockerfile, rappelez-vous toujours que vous n'écrivez pas un script shell, mais que vous définissez comment chaque
couche doit être construite.
Construire une image
Maintenant que nous comprenons le contenu de ce Dockerfile, construisons l'image. Exécuter dans le répertoire où se trouve le fichier Dockerfile :
[root@localhost nginxtest]# docker build -t nginx:3.0 .
[+] Building 0.9s (6/6) FINISHED
=> [internal] load build definition from Dockerfile
=> => transferring dockerfile: 179B
=> [internal] load .dockerignore
=> => transferring context: 2B
=> [internal] load metadata for docker.io/library/nginx:latest
=> [1/2] FROM docker.io/library/nginx
=> [2/2] RUN echo '<h1>Hello, EveryDay!</h1>' > /usr/share/nginx/html/index.html
=> exporting to image
=> => exporting layers
=> => writing image sha256:e899e0dd12df606efc99e3bb62b57d99935db376c9b1760b05ed7352a004c37a
=> => naming to docker.io/library/nginx:3.0
(Remarque : assurez-vous d'ajouter un espace et un point à la fin de la commande de construction ci-dessus , sinon une erreur sera signalée)
Contexte de création d'image (Contexte)
Si vous faites attention, vous verrez qu'il y a un .à la fin de la commande docker build. . représente le répertoire courant et le Dockerfile se trouve dans le répertoire courant ; le format de commande ci-dessus spécifie en fait le chemin du contexte. Alors, qu’est-ce que le contexte ?
Tout d’abord, vous devez comprendre comment fonctionne la construction de Docker. Docker est divisé en moteur Docker (c'est-à-dire démon côté serveur) et outils côté client au moment de l'exécution . Le moteur Docker fournit un ensemble d'API REST, appelé API DockerRemote, et des outils clients tels que les commandes Docker interagissent avec le moteur Docker via cet ensemble d'API pour remplir diverses fonctions. Par conséquent, bien qu'en apparence, il semble que nous exécutons diverses fonctions de Docker localement, en fait, tout est fait côté serveur (moteur Docker) en utilisant l'appel à distance.
Lorsque vous utilisez la commande docker build pour créer une image, vous devez souvent copier certains fichiers locaux dans l'image. Cependant, celle-ci n'est pas construite localement, mais côté serveur, c'est-à-dire dans le moteur Docker. Alors dans cette architecture client/serveur, comment le serveur peut-il obtenir des fichiers locaux ?
Cela introduit la notion de contexte. Lors de la construction, l'utilisateur spécifiera le chemin pour créer le contexte de l'image. Une fois que la commande dockerbuild aura appris ce chemin, elle regroupera tout le contenu sous le chemin, puis le téléchargera sur le moteur Docker. De cette façon, une fois que le moteur Docker aura reçu le package de contexte, il se développera et obtiendra tous les fichiers nécessaires à la création de l'image.
Comprendre le contexte de construction est très important pour la création d'images afin d'éviter de commettre des erreurs inutiles. Par exemple, certains débutants ont constaté que COPY /opt/xxxx /app ne fonctionnait pas, ils ont donc simplement placé le Dockerfile dans le répertoire racine du disque dur à construire. Ils ont constaté qu'après l'exécution de Docker build, l'envoi de dizaines de Go de les choses étaient extrêmement lentes et faciles. La construction a échoué. En effet, cette approche demande à Docker build de regrouper l'intégralité du disque dur, ce qui est évidemment une erreur d'utilisation.
De manière générale, le Dockerfile doit être placé dans un répertoire vide ou dans le répertoire racine du projet. Si les fichiers requis ne sont pas trouvés dans ce répertoire, vous devez copier les fichiers requis. S'il y a des éléments dans le répertoire que vous ne souhaitez vraiment pas transmettre au moteur Docker lors de la construction, vous pouvez écrire un .dockerignore avec la même syntaxe que .gitignore . Ce fichier est utilisé pour éliminer les éléments qui n'ont pas besoin d'être transmis au moteur Docker comme contexte.
Explication détaillée des instructions Dockerfile
-
COPIER Copier les fichiers : COPIER <chemin source>… <chemin de destination>
-
L'instruction COPY copiera les fichiers/répertoires à <chemin source> dans le répertoire de contexte de construction vers l' emplacement <chemin cible> dans l'image de la nouvelle couche . Par exemple:COPY package.json /usr/src/app/ -
<chemin source> peut être multiple, voire un caractère générique
-
<Chemin cible> peut être un chemin absolu dans le conteneur ou un chemin relatif par rapport au répertoire de travail (le répertoire de travail peut être
spécifié à l'aide de la directive WORKDIR) -
À l'aide de l'instruction COPY, diverses métadonnées du fichier source seront conservées. Tels que la lecture, l'écriture, les autorisations d'exécution, l'heure de changement de fichier, etc. Cette fonctionnalité est utile pour la personnalisation des images. Surtout lorsque les fichiers liés à la construction sont gérés à l'aide de Git.
-
-
ADD est un fichier de copie plus avancé : le format et les propriétés de la commande et de COPY sont fondamentalement les mêmes. Mais certaines fonctions sont ajoutées en fonction de COPY
-
Par exemple, <chemin source> peut être une URL. Dans ce cas, le moteur Docker tentera de télécharger le fichier lié et de le placer dans le <chemin cible>.
-
Si <chemin source> est un fichier compressé tar et que le format de compression est gzip, bzip2 et xz, la commande ADD décompressera automatiquement le fichier compressé en <chemin de destination> .
-
Par conséquent, lorsque vous choisissez entre les instructions COPY et ADD, vous pouvez suivre ce principe : utilisez l'instruction COPY pour toutes les copies de fichiers et utilisez ADD uniquement lorsqu'une décompression automatique est requise.
-
-
Commande de démarrage du conteneur CMD :
format du shell : CMD <commande> ;
format d'exécution : CMD ["fichier exécutable", "paramètre 1", "paramètre 2"...]
Lorsque j'ai présenté les conteneurs, j'ai dit un jour que Docker n'était pas une machine virtuelle, mais que les conteneurs étaient des processus. Puisqu'il s'agit d'un processus, lors du démarrage du conteneur, vous devez spécifier le programme et les paramètres à exécuter. L'instruction CMD est utilisée pour spécifier la commande de démarrage par défaut du processus principal du conteneur.
Lors de l'exécution, vous pouvez spécifier une nouvelle commande pour remplacer la commande par défaut dans les paramètres de l'image . Par exemple, le CMD par défaut de l'image Ubuntu est /bin/bash. Si nous exécutons directement -it ubuntu par docker, nous entrerons directement bash. Nous pouvons également spécifier d'autres commandes à exécuter au moment de l'exécution, telles que docker run -it ubuntu cat /etc/os-release. Cela signifie remplacer la commande par défaut /bin/bash par la commande cat /etc/os-release et afficher les informations de version du système.
-
POINT D'ENTRÉEPoint d'entrée
L'objectif d'ENTRYPOINT est le même que celui de CMD, qui consiste à spécifier le programme et les paramètres de démarrage du conteneur. ENTRYPOINT peut également être remplacé au moment de l'exécution, mais il est légèrement plus lourd que CMD et doit être spécifié via le paramètre --entrypoint de docker run.
Lorsque ENTRYPOINT est spécifié, la signification de CMD change. Au lieu d'exécuter sa commande directement, le contenu de CMD est passé à l'instruction ENTRYPOINT en tant que paramètre. En d'autres termes, une fois réellement exécuté, il deviendra : ""
Après avoir eu CMD, pourquoi avons-nous besoin d’ENTRYPOINT ?
-
Laissez l'image être utilisée comme une commande
-
Préparatifs avant d'exécuter l'application
-
-
ENV définit les variables d'environnement : les deux formats sont les suivants :
ENV
ENV = =…Cette commande sert uniquement à définir les variables d'environnement. Qu'il s'agisse d'autres instructions ultérieures, telles que RUN, ou d'applications d'exécution, vous pouvez directement utiliser les variables d'environnement définies ici.
Une fois la variable d'environnement définie, cette variable d'environnement peut être utilisée dans les instructions suivantes.
-
Paramètres de construction ARG : Format : ARG <nom du paramètre>[=<valeur par défaut>]
Les paramètres de construction ont le même effet que ENV, définissant les variables d'environnement. La différence est que les variables d'environnement de l'environnement de construction définies par ARG n'existeront pas lors de l'exécution future du conteneur.
La directive ARG du Dockerfile définit les noms des paramètres et définit leurs valeurs par défaut. Cette valeur par défaut peut être remplacée par --build-arg <argument name>=<value> dans la commande build docker build.
-
VOLUME définit un volume anonyme
Le format est :
VOLUME ["<chemin1>", "<chemin2>"…]
VOLUME <chemin>Nous avons déjà dit que lorsque le conteneur est en cours d'exécution, nous devrions essayer d'empêcher la couche de stockage du conteneur d'écrire des opérations.Pour les applications de base de données qui ont besoin de sauvegarder des données dynamiques, leurs fichiers de base de données doivent être stockés dans des volumes.Nous présenterons plus en détail les volumes Docker dans les chapitres suivants.le concept de.
Afin d'éviter que l'utilisateur n'oublie de monter le répertoire dans lequel les fichiers dynamiques sont enregistrés en tant que volume pendant l'exécution, dans le Dockerfile, nous pouvons spécifier à l'avance certains répertoires à monter en tant que volumes anonymes, de sorte que si l'utilisateur ne spécifie pas le montage au moment de l'exécution, l'application peut fonctionner normalement et s'exécuter sans écrire de grandes quantités de données sur la couche de stockage du conteneur.
VOLUME /dataLe répertoire /data ici sera automatiquement monté en tant que volume anonyme au moment de l'exécution, et toute information écrite dans /data ne sera pas enregistrée dans la couche de stockage du conteneur, garantissant ainsi l'apatridie de la couche de stockage du conteneur.
-
EXPOSE déclarer le port
Le format est : EXPOSE <port1> [<port2>…]
La directive EXPOSE déclare que le conteneur d'exécution fournit un port de service. Il s'agit simplement d'une instruction. L'application n'ouvrira pas le service de ce port au moment de l'exécution à cause de cette instruction.
Écrire une telle déclaration dans le Dockerfile présente deux avantages :
-
La première consiste à aider les utilisateurs d'images à comprendre le port de garde de ce service d'imagerie afin de faciliter le mappage de configuration ;
-
Une autre utilisation consiste à utiliser le mappage de port aléatoire au moment de l'exécution, c'est-à-dire que lorsque Docker exécute -P, le port EXPOSE sera automatiquement et aléatoirement mappé.
-
-
WORKDIR spécifie le répertoire de travail
Le format est : WORKDIR <chemin du répertoire de travail>
Vous pouvez utiliser la commande WORKDIR pour spécifier le répertoire de travail (ou répertoire actuel). À l'avenir, le répertoire actuel de chaque couche sera remplacé par le répertoire spécifié. Si le répertoire n'existe pas, WORKDIR vous aidera à créer le répertoire.
Comme mentionné précédemment, une erreur courante commise par certains débutants est d'écrire Dockerfile en tant que script Shell. Cette mauvaise compréhension
peut également conduire aux erreurs suivantes :RUN cd /app RUN echo "hello" > world.txtSi vous exécutez ce Dockerfile pour créer l'image, vous constaterez que le fichier /app/world.txt est introuvable ou que son contenu n'est pas bonjour. La raison est en réalité très simple : dans le Shell, deux lignes consécutives représentent le même environnement d'exécution du processus, donc l'état mémoire modifié par la commande précédente affectera directement la commande suivante ; dans le Dockerfile, les environnements d'exécution des deux lignes de RUN les commandes sont fondamentalement différentes. , sont deux conteneurs complètement différents . Il s'agit d'une erreur causée par une non-compréhension du concept de création de stockage hiérarchique à l'aide de Dockerfile.
Comme mentionné précédemment, chaque RUN démarre un conteneur, exécute la commande, puis valide les modifications du fichier de couche de stockage.
Exploitation des conteneurs Docker
En termes simples, un conteneur est une application ou un groupe d'applications qui s'exécutent indépendamment, ainsi que leur environnement d'exécution. En conséquence, une machine virtuelle peut être comprise comme un ensemble complet de systèmes d'exploitation qui simulent l'exécution (en fournissant un environnement d'exécution et d'autres environnements système) et des applications qui s'y exécutent.
Démarrer le conteneur
Il existe deux manières de démarrer un conteneur. L'une consiste à créer un nouveau conteneur basé sur l'image et à le démarrer. L'autre consiste à redémarrer le conteneur à l'état terminé (arrêté).
Créer nouveau et commencer
La commande requise est principalement docker run .
Par exemple, la commande suivante génère un « Hello Docker », puis termine le conteneur :
[root@localhost snow]# docker run ubuntu:16.04 /bin/echo 'Hello Docker'
Hello Docker
La commande suivante démarre un terminal bash, permettant l'interaction de l'utilisateur :
[root@localhost snow]# docker run -t -i ubuntu:16.04 /bin/bash
root@d80afe7ea29f:/# ps
PID TTY TIME CMD
1 pts/0 00:00:00 bash
10 pts/0 00:00:00 ps
root@d80afe7ea29f:/# exit
exit
Parmi eux, l'option -t permet à Docker d'attribuer un pseudo-tty (pseudo-tty) et de le lier à l'entrée standard du conteneur, et -i maintient l'entrée standard du conteneur ouverte.
Lorsque vous utilisez Docker Run pour créer un conteneur, les opérations standard exécutées par Docker en arrière-plan incluent :
- Vérifiez si l'image spécifiée existe localement. Si elle n'existe pas, téléchargez-la depuis l'entrepôt public.
- Créer et démarrer un conteneur à l'aide d'une image
- Allouer un système de fichiers et monter une couche en lecture-écriture en dehors de la couche d'image en lecture seule
- Ponter une interface virtuelle de l'interface de pont configurée sur l'hôte hôte vers le conteneur
- Configurer une adresse IP du pool d'adresses vers le conteneur
- Exécuter l'application spécifiée par l'utilisateur
- Après exécution, le conteneur est terminé
Démarrer un conteneur terminé
Vous pouvez utiliser la commande docker containers start pour démarrer directement un conteneur terminé.
Le cœur du conteneur est l'application en cours d'exécution, et les ressources requises sont toutes nécessaires à l'exécution de l'application. En dehors de cela, il n’y a pas d’autres ressources. Vous pouvez utiliser ps ou top dans un pseudo-terminal pour afficher les informations sur le processus.
Processus en arrière-plan
Le plus souvent, il est nécessaire de laisser Docker s'exécuter en arrière-plan au lieu de transmettre directement les résultats de l'exécution de la commande à l'hôte actuel.
À ce stade, cela peut être réalisé en ajoutant le paramètre -d.
Après avoir commencé avec le paramètre -d,un ID unique sera renvoyé. Vous pouvez également afficher les informations sur le conteneur via la commande docker containers ls.
[root@localhost snow]# docker container ls
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
e015f7987776 nginx:2.0 "/docker-entrypoint.…" 6 days ago Up 6 days 0.0.0.0:81->80/tcp, :::81->80/tcp web2.0
054d1cdcf5cf nginx "/docker-entrypoint.…" 6 days ago Up 6 days 0.0.0.0:80->80/tcp, :::80->80/tcp web1.0
Pour obtenir les informations de sortie du conteneur, vous pouvez utiliser la commande docker conteneur logs .
Terminer le conteneur
Vous pouvez utiliser Docker Container Stop pour mettre fin à un conteneur en cours d'exécution.
De plus, lorsque l'application spécifiée dans le conteneur Docker est terminée, le conteneur est automatiquement terminé . Par exemple, pour le conteneur qui n'a démarré qu'un seul terminal dans le chapitre précédent, lorsque l'utilisateur quitte le terminal via la commande exit ou Ctrl+d, le conteneur créé sera immédiatement terminé.
Le conteneur terminé peut être vu à l'aide de la commande docker containers ls -a. Par exemple
[root@localhost snow]# docker container ls -a
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
d80afe7ea29f ubuntu:16.04 "/bin/bash" 9 minutes ago Exited (0) 9 minutes ago bold_saha
626c2066188c ubuntu:16.04 "/bin/bash" 10 minutes ago Exited (127) 10 minutes ago jolly_shockley
791d1f4d5eca ubuntu:16.04 "/bin/bash" 10 minutes ago Exited (127) 10 minutes ago boring_margulis
1280e87e1cae ubuntu:16.04 "/bin/echo 'Hello Do…" 11 minutes ago Exited (0) 11 minutes ago wonderful_saha
Un conteneur dans un état terminé peut être redémarré via la commande docker containers start.
De plus, la commande docker containers restart mettra fin à un conteneur en cours d'exécution, puis le redémarrera.
Entrez dans le conteneur
Lors de l'utilisation du paramètre -d, le conteneur entrera en arrière-plan après le démarrage.
Parfois, vous devez entrer dans le conteneur pour des opérations, notamment à l'aide de la commande docker attach ou de la commande docker exec. Il est recommandé d'utiliser la commande docker exec pour les raisons expliquées ci-dessous.
-
joindre la commande
docker attach est une commande fournie avec Docker. Voici un exemple d'utilisation de cette commande :
[root@localhost snow]# docker container ls CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES 5f6884f826e4 ubuntu "/bin/bash" 23 seconds ago Up 22 seconds practical_payne e015f7987776 nginx:2.0 "/docker-entrypoint.…" 6 days ago Up 6 days 0.0.0.0:81->80/tcp, :::81->80/tcp web2.0 054d1cdcf5cf nginx "/docker-entrypoint.…" 6 days ago Up 6 days 0.0.0.0:80->80/tcp, :::80->80/tcp web1.0 [root@localhost snow]# docker attach 5f6 root@5f6884f826e4:/# exit exit [root@localhost snow]# docker container ls CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES e015f7987776 nginx:2.0 "/docker-entrypoint.…" 6 days ago Up 6 days 0.0.0.0:81->80/tcp, :::81->80/tcp web2.0 054d1cdcf5cf nginx "/docker-entrypoint.…" 6 days ago Up 6 days 0.0.0.0:80->80/tcp, :::80->80/tcp web1.0Remarque : Quitter ce stdin entraînera l'arrêt du conteneur.
-
commande d'exécution
Docker exec peut être suivi de plusieurs paramètres. Ici, nous expliquons principalement les paramètres -i -t.
Lorsque seul le paramètre -i est utilisé, puisqu'aucun pseudo-terminal n'est alloué, l'interface n'a pas l'invite de commande Linux familière, mais les
résultats de l'exécution de la commande peuvent toujours être renvoyés.Lorsque les paramètres -i -t sont utilisés ensemble, vous pouvez voir l'invite de commande Linux familière.
[root@localhost snow]# docker run -dit ubuntu 3a7731e1a8a290b59263e9c73695f0a52e57e009505b4652be57c3fbe88a147e [root@localhost snow]# docker container ls CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES 3a7731e1a8a2 ubuntu "/bin/bash" 3 seconds ago Up 2 seconds hardcore_ptolemy e015f7987776 nginx:2.0 "/docker-entrypoint.…" 6 days ago Up 6 days 0.0.0.0:81->80/tcp, :::81->80/tcp web2.0 054d1cdcf5cf nginx "/docker-entrypoint.…" 6 days ago Up 6 days 0.0.0.0:80->80/tcp, :::80->80/tcp web1.0 [root@localhost snow]# docker exec -it 3a77 bash root@3a7731e1a8a2:/# exit exit [root@localhost snow]# docker container ls CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES 3a7731e1a8a2 ubuntu "/bin/bash" About a minute ago Up About a minute hardcore_ptolemy e015f7987776 nginx:2.0 "/docker-entrypoint.…" 6 days ago Up 6 days 0.0.0.0:81->80/tcp, :::81->80/tcp web2.0 054d1cdcf5cf nginx "/docker-entrypoint.…" 6 days ago Up 6 days 0.0.0.0:80->80/tcp, :::80->80/tcp web1.0Quitter ce stdin n’entraînera pas l’arrêt du conteneur. C'est pourquoi il est recommandé à tout le monde d'utiliser docker exec.
Pour plus de descriptions de paramètres, veuillez utiliser docker exec --help pour afficher
Conteneurs d'exportation et d'importation
Conteneur d'exportation :
Si vous souhaitez exporter un conteneur local, vous pouvez utiliser la commande docker export. (Cela exportera l'instantané du conteneur vers un fichier local)
[root@localhost snow]# docker ps -a
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
3a7731e1a8a2 ubuntu "/bin/bash" 4 minutes ago Up 4 minutes hardcore_ptolemy
[root@localhost snow]# docker export 3a77 > ubuntuBash.tar
Conteneur d'importation :
Vous pouvez utiliser Docker Import pour importer depuis le fichier d'instantané du conteneur vers une image :
[root@localhost snow]# cat ubuntuBash.tar | docker import - test/ubuntu:test2.0
sha256:1f2b949f67cade289f240a22612630363380d95b43d63bc60e032bbff69bc373
[root@localhost snow]# docker image ls
REPOSITORY TAG IMAGE ID CREATED SIZE
test/ubuntu test2.0 1f2b949f67ca 12 seconds ago 77.8MB
nginx 3.0 e899e0dd12df 3 hours ago 143MB
De plus, vous pouvez également importer en spécifiant une URL ou un répertoire.
Remarque : Les utilisateurs peuvent soit utiliser Docker Load pour importer des fichiers de stockage d'images dans la bibliothèque d'images locale, soit utiliser dockerimport pour importer un instantané de conteneur dans la bibliothèque d'images locale. La différence entre les deux est que le fichier d'instantané du conteneur supprime tous les enregistrements historiques et les informations de métadonnées (c'est-à-dire qu'il enregistre uniquement l'état de l'instantané du conteneur à ce moment-là), tandis que le fichier de stockage d'images enregistre les enregistrements complets et est plus grand.
De plus, les informations de métadonnées telles que les balises peuvent être respécifiées lors de l'importation à partir d'un fichier instantané de conteneur.
Supprimer le conteneur
Vous pouvez utiliser Docker Container rm pour supprimer un conteneur qui est dans un état terminé. Par exemple
[root@localhost snow]# docker ps -a
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
3a7731e1a8a2 ubuntu "/bin/bash" 15 minutes ago Up 15 minutes hardcore_ptolemy
5f6884f826e4 ubuntu "/bin/bash" 19 minutes ago Exited (0) 18 minutes ago practical_payne
d80afe7ea29f ubuntu:16.04 "/bin/bash" About an hour ago Exited (0) About an hour ago bold_saha
[root@localhost snow]# docker container rm 5f68
5f68
Si vous souhaitez supprimer un conteneur en cours d'exécution, vous pouvez ajouter le paramètre -f. Docker enverra le signal SIGKILL au conteneur.
Nettoyer tous les conteneurs terminés
Utilisez la commande docker containers ls -a pour afficher tous les conteneurs créés, y compris l'état terminé. S'il y en a trop, il peut être difficile de les supprimer un par un. Utilisez la commande suivante pour nettoyer tous les conteneurs à l'état terminé.
$ docker container prune
Visitez l'entrepôt
Le référentiel est un endroit où les images sont stockées de manière centralisée.
Un concept facile à confondre est celui du serveur d'enregistrement (Registry). En fait, le serveur d'enregistrement est un serveur spécifique qui gère l'entrepôt. Chaque serveur peut avoir plusieurs entrepôts, et chaque entrepôt a plusieurs miroirs. À cet égard, un référentiel peut être considéré comme un projet ou un répertoire spécifique. Par exemple, pour l'adresse de l'entrepôt dl.dockerpool.com/ubuntu, dl.dockerpool.com est l'adresse du serveur d'enregistrement et ubuntu est le nom de l'entrepôt.
Centre Docker
Docker gère officiellement un référentiel public, Docker Hub, qui contient déjà plus de 15 000 images. La plupart des exigences peuvent être satisfaites en téléchargeant l'image directement depuis Docker Hub.
-
Inscription : enregistrez un compte Docker gratuit sur https://cloud.docker.com
-
Connexion : exécutez la connexion Docker pour vous connecter, exécutez la déconnexion Docker pour vous déconnecter.
-
Extrayez l'image : utilisez la commande docker search pour trouver l'image dans l'entrepôt officiel et utilisez la commande docker pull pour
la télécharger localement ;Les ressources miroirs peuvent être divisées en deux catégories selon qu’elles sont officiellement fournies ou non.
- L'une est une image comme centos, appelée image de base ou image racine, qui est officiellement fournie
- Un autre type, tel que l'image tianon/centos, est créé et maintenu par les utilisateurs de Docker et est souvent
préfixé par le nom d'utilisateur.
-
Pousser l'image : utilisez la commande docker push pour transférer votre propre image vers Docker Hub
-
Création automatique : très pratique pour ceux qui ont besoin de mettre à jour fréquemment les programmes dans l'image
Permet aux utilisateurs de spécifier des projets de suivi sur un site Web cible (prenant actuellement en charge GitHub ou BitBucket) via Docker Hub. Une fois qu'une nouvelle soumission se produit dans le projet ou qu'une nouvelle balise est créée, Docker Hub créera automatiquement l'image et la transmettra à Docker Hub.
Entrepôt privé
Pour l'adresse dl.dockerpool.com/ubuntu, dl.dockerpool.com est l'adresse du serveur d'enregistrement et ubuntu est le nom de l'entrepôt.
Centre Docker
Docker gère officiellement un référentiel public, Docker Hub, qui contient déjà plus de 15 000 images. La plupart des exigences peuvent être satisfaites en téléchargeant l'image directement depuis Docker Hub.
-
Inscription : enregistrez un compte Docker gratuit sur https://cloud.docker.com
-
Connexion : exécutez la connexion Docker pour vous connecter, exécutez la déconnexion Docker pour vous déconnecter.
-
Extrayez l'image : utilisez la commande docker search pour trouver l'image dans l'entrepôt officiel et utilisez la commande docker pull pour
la télécharger localement ;Les ressources miroirs peuvent être divisées en deux catégories selon qu’elles sont officiellement fournies ou non.
- L'une est une image comme centos, appelée image de base ou image racine, qui est officiellement fournie
- Un autre type, tel que l'image tianon/centos, est créé et maintenu par les utilisateurs de Docker et est souvent
préfixé par le nom d'utilisateur.
-
Pousser l'image : utilisez la commande docker push pour transférer votre propre image vers Docker Hub
-
Création automatique : très pratique pour ceux qui ont besoin de mettre à jour fréquemment les programmes dans l'image
Permet aux utilisateurs de spécifier des projets de suivi sur un site Web cible (prenant actuellement en charge GitHub ou BitBucket) via Docker Hub. Une fois qu'une nouvelle soumission se produit dans le projet ou qu'une nouvelle balise est créée, Docker Hub créera automatiquement l'image et la transmettra à Docker Hub.