Un volume de données est un répertoire spécial utilisé par les conteneurs et situé à l'intérieur du conteneur. Le répertoire de l'hôte peut être monté sur le volume de données. Les modifications apportées au volume de données sont immédiatement visibles et les données mises à jour n'affecteront pas le miroir, permettant ainsi la migration des données entre l'hôte et le conteneur. L'utilisation de volumes de données est similaire à l'opération de montage de répertoires sous Linux.

docker pull centos:7

#宿主机目录/var/www 挂载到容器中的/data1。
注意：宿主机本地目录的路径必须是使用绝对路径。如果路径不存在，Docker会自动创建相应的路径。
docker run -v /var/www:/data1 --name c1 -it centos:7 /bin/bash			#-v 选项可以在容器内创建数据卷
ls
echo "HELLO" > /data1/abc.txt
exit

#返回宿主机进行查看
cat  /var/www/abc.txt

#在宿主机写入数据
echo "world" > 123.txt
#进入容器查看挂载目录
docker exec -it c1 bash
cd /data1/
cat 123.txt

#宿主机共享目录可被多个容器挂载
docker run -it -v /var/www:/data2 --name c2 nginx:latest bash
cd /data2 
cat 123.txt
cat abc.txt

docker run -it -v /var/www:/data2:ro --name c3 nginx:latest bash
cd /data2
echo 123 > qwe.txt
bash: qwe.txt: Read-only file system

2. Conteneur de volumes de données

Si vous devez partager certaines données entre conteneurs, le moyen le plus simple consiste à utiliser un conteneur de volume de données. Le conteneur de volumes de données est un conteneur ordinaire qui fournit spécifiquement des volumes de données que d'autres conteneurs peuvent monter et utiliser.

#创建一个容器作为数据卷容器
docker run --name c1 -v /data1 -v /data2 -it centos:7 /bin/bash
echo "this is web2" > /data1/abc.txt
echo "THIS IS WEB2" > /data2/ABC.txt

#使用 --volumes-from 来挂载 c1 容器中的数据卷到新的容器
docker run -it --volumes-from c1 --name c2 centos:7 /bin/bash
cat /data1/abc.txt
cat /data2/ABC.txt

2. Interconnexion des conteneurs (en utilisant l'image centos)

L'interconnexion des conteneurs consiste à établir un tunnel de communication réseau dédié entre les conteneurs via le nom du conteneur. Pour faire simple, un tunnel est établi entre le conteneur source et le conteneur récepteur, et le conteneur récepteur peut voir les informations spécifiées par le conteneur source.

#创建并运行源容器取名web1
docker run -itd -P --name web1 centos:7 /bin/bash	
	
#创建并运行接收容器取名web2，使用--link选项指定连接容器以实现容器互联
docker run -itd -P --name web2 --link web1:web1 centos:7 /bin/bash			#--link 容器名:连接的别名

#进web2 容器， ping web1
docker exec -it web2 bash
ping web1

3. Création d'une image Docker

Il existe trois façons de créer une image, à savoir la création basée sur une image existante, la création basée sur un modèle local et la création basée sur un Dockerfile.

1. Créer en fonction d'une image existante

1.1 Commencez par démarrer une image et modifiez-la dans le conteneur

docker create -it centos:7 /bin/bash
docker ps -a
#进入容器，安装apache服务
yum -y install httpd
#容器中没有root权限，无法使用systemctl管理服务
apachectl -D FOREGROUND   #使用apache前台启动命令启动服务
或
apachectl  #直接启动

1.2 Pour soumettre le conteneur modifié en tant que nouvelle image, vous devez utiliser le numéro d'identification du conteneur pour créer une nouvelle image.

docker commit -m "new" -a "centos-apache" 891853a88a38 centos7:httpd
#常用选项：
-m 说明信息；
-a 作者信息；
-p 生成过程中停止容器的运行。

docker images

docker run -itd --name c2 centos7:httpd apachectl -D FOREGROUND
rpm -qa httpd

2. Créer sur la base d'un modèle local

L'image peut être générée en important le fichier modèle du système d'exploitation. Le modèle peut être téléchargé à partir du projet open source OPENVZ. L'adresse de téléchargement est http://openvz.org/Download/template/precreated

2.1 Téléchargez le fichier modèle pour générer l'image

wget http://download.openvz.org/template/precreated/debian-7.0-x86-minimal.tar.gz

#导入为镜像
cat debian-7.0-x86-minimal.tar.gz | docker import - debian:test

2.2 Exportez le conteneur local en tant que fichier modèle et importez-le pour générer une image

docker export -o apache.tar 891853a88a38

docker import apache.tar -- apache:centos

3. Créer basé sur Dockerfile

3.1 Système de fichiers Union (UnionFS)

UnionFS (Union File System) : Union File System (UnionFS) est un système de fichiers hiérarchique, léger et hautes performances. Il prend en charge les modifications du système de fichiers à superposer couche par couche en une seule soumission, et peut également combiner différents répertoires montés. au même système de fichiers virtuel. AUFS, OverlayFS et Devicemapper sont tous des types d'UnionFS.
Le système de fichiers Union est la base des images Docker. Les images peuvent être héritées par superposition. Sur la base de l'image de base (sans image parent), diverses images d'application spécifiques peuvent être produites.
Caractéristiques : Chargez plusieurs systèmes de fichiers en même temps, mais de l'extérieur, un seul système de fichiers est visible. Le chargement conjoint superposera chaque couche de systèmes de fichiers, de sorte que le système de fichiers final contiendra tous les fichiers et répertoires sous-jacents.
Les couches que nous voyons lors du téléchargement sont les systèmes de fichiers communs.

3.2 Principe de chargement des images

L'image de Docker consiste en fait en un système de fichiers couche par couche, et cette couche de système de fichiers est UnionFS.

bootfs comprend principalement le chargeur de démarrage et le noyau. Le chargeur de démarrage charge principalement le noyau. Le système de fichiers bootfs sera chargé au premier démarrage de Linux.

La couche inférieure de l'image Docker est bootfs. Cette couche est la même que celle de notre système Linux/Unix typique, y compris le chargeur de démarrage et le noyau. Une fois le démarrage terminé, l'intégralité du noyau est dans la mémoire. À ce moment, le droit d'utiliser la mémoire a été transféré de bootfs au noyau. À ce moment, le système désinstallera également bootfs.

rootfs, au-dessus de bootfs. Contient des répertoires et des fichiers standard tels que /dev, /proc, /bin, /etc, etc. dans un système Linux typique. Rootfs fait référence à diverses distributions de systèmes d'exploitation, telles que Ubuntu, Centos, etc.

On peut comprendre qu'il n'y a rien dans le noyau au début. Si vous lancez une commande pour télécharger Debian, une image de base sera ajoutée au noyau, puis installez un emacs, et une couche d'image se superposera à l'image de base. ; puis installez un autre Apache qui superposera une autre couche d'images au-dessus des images. En fin de compte, ils ressemblent à un système de fichiers, c'est-à-dire au rootfs du conteneur. Dans le système Docker, ces rootfs sont appelés images Docker. Cependant, chaque couche de rootfs est actuellement en lecture seule et nous ne pouvons pas l'exploiter pour le moment. Lorsque nous créons un conteneur, c'est-à-dire instancions une image Docker, le système alloue une couche vide de rootfs en lecture-écriture au-dessus d'une ou plusieurs couches de rootfs en lecture seule.

3.3 Pourquoi la taille des centos dans Docker n'est-elle que de 200 M ?

Parce que pour un système d'exploitation simplifié, le rootfs peut être très petit et ne doit contenir que les commandes, les outils et les bibliothèques de programmes les plus basiques. Étant donné que la couche sous-jacente utilise directement le noyau de la machine hôte, il vous suffit de fournir le rootfs. On peut voir que pour différentes distributions Linux, les bootfs sont fondamentalement les mêmes et les rootfs seront différents, donc différentes distributions peuvent partager les bootfs.

3.4Fichier Docker

L'image Docker est un système de fichiers spécial.En plus de fournir des programmes, des bibliothèques, des ressources, des fichiers de configuration et d'autres fichiers requis pour l'exécution du conteneur, il contient également certains paramètres de configuration préparés pour l'exécution (tels que des volumes anonymes, des variables d'environnement, des utilisateurs, etc.) . L'image ne contient aucune donnée dynamique et son contenu ne sera pas modifié une fois créée.
La personnalisation du miroir consiste en fait à personnaliser la configuration et les 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 de transparence et de volume de construction de l'image seront résolus. Ce script est le Dockerfile.
Dockerfile est un fichier texte qui contient des instructions (Instructions). Chaque instruction construit une couche, donc le contenu de chaque instruction décrit comment la couche doit être construite. Avec Dockerfile, lorsque nous devons personnaliser nos propres exigences supplémentaires, il nous suffit d'ajouter ou de modifier des instructions sur le Dockerfile et de régénérer l'image, ce qui nous évite d'avoir à taper des commandes.
En plus de générer manuellement des images Docker, vous pouvez utiliser Dockerfile pour générer automatiquement des images. Un Dockerfile est un fichier composé de plusieurs instructions, chacune correspondant à une commande sous Linux, et le programme Docker lira les instructions dans le Dockerfile pour générer une image spécifiée.
La structure Dockerfile est grossièrement divisée en quatre parties : informations de base sur l'image, informations sur le responsable, instructions d'opération sur l'image et instructions d'exécution au démarrage du conteneur. Dockerfile prend en charge une instruction par ligne, chaque instruction peut transporter plusieurs paramètres et prend en charge l'utilisation de commentaires commençant par "#".

3.4.1Superposition de la structure de l'image Docker

Une image n’est pas un fichier unique, mais se compose de plusieurs calques. Le conteneur ajoute en fait une couche de lecture-écriture au-dessus de l'image. Toute modification de fichier effectuée dans le conteneur en cours d'exécution sera écrite sur cette couche de lecture-écriture. Si vous supprimez un conteneur, sa couche supérieure en lecture-écriture est supprimée et les modifications apportées aux fichiers sont perdues. Docker utilise des pilotes de stockage pour gérer le contenu de chaque couche de l'image et la couche conteneur de la couche lecture-écriture.

Chaque instruction du Dockerfile crée un nouveau calque d'image ;
La couche d'image sera mise en cache et réutilisée ;
Lorsque les instructions Dockerfile sont modifiées, les fichiers copiés changent ou les variables spécifiées lors de la construction de l'image sont différentes, le cache de la couche d'image correspondant deviendra invalide ;
Si le cache d'images d'un certain calque devient invalide, le cache des calques d'images suivants deviendra invalide ;
Les calques d'image sont immuables. Si vous ajoutez un fichier à un certain calque puis le supprimez dans le calque suivant, le fichier sera toujours inclus dans l'image, mais le fichier ne sera pas visible dans le conteneur Docker.

3.4.2Instructions couramment utilisées pour les opérations Dockerfile

1.À PARTIR de l'image

Spécifiez l'image de base sur laquelle la nouvelle image est basée. La première instruction doit être une instruction FROM. Chaque image créée nécessite une instruction FROM.

2. Nom du MAINTENANT

Décrire les informations du responsable de la nouvelle image

3. Commande EXÉCUTER

Exécutez la commande sur l'image basée et soumettez-la à la nouvelle image

4.ENTRYPOINT ["Programme à exécuter", "Paramètre 1", "Paramètre 2"]

Définissez la première commande à exécuter au démarrage du conteneur et ses paramètres.
Vous pouvez écraser le contenu de l'instruction ENTRYPOINT dans l'image à l'aide de la commande docker run --entrypoint.

5. CMD ["Programme à exécuter", "Paramètre 1", "Paramètre 2"]

Ce qui précède est sous forme d'exécution, sous forme de shell : le paramètre 1 de la commande CMD, le paramètre 2 est
la commande ou le script qui est exécuté par défaut lors du démarrage du conteneur. Dockerfile ne peut avoir qu'une seule commande CMD. Si plusieurs commandes sont spécifiées, seule la dernière commande sera exécutée.
Si une commande est spécifiée lors de l'exécution du docker ou s'il y a ENTRYPOINT dans l'image, CMD sera écrasé.
CMD peut fournir des paramètres par défaut pour l'instruction ENTRYPOINT.

6. EXPOSER le numéro de port

Spécifiez le port à ouvrir lorsque la nouvelle image est chargée dans Docker

7. Valeur variable de la variable d'environnement ENV

Définir la valeur d'une variable d'environnement, qui sera utilisée par les RUN suivants

linxu PATH=$PATH:/opt
CHEMIN ENV $CHEMIN :/opt

8.AJOUTER un fichier/répertoire source fichier/répertoire cible

Copiez le fichier source dans l'image. Le fichier source doit se trouver dans le même répertoire que le Dockerfile, ou il doit s'agir d'une URL.

Il existe les précautions suivantes :
1. Si le chemin source est un fichier et que le chemin cible se termine par /, Docker traitera le chemin cible comme un répertoire et copiera le fichier source dans le répertoire.
Si le chemin cible n'existe pas, il sera automatiquement créé.

2. Si le chemin source est un fichier et que le chemin cible ne se termine pas par /, Docker traitera le chemin cible comme un fichier.
Si le chemin cible n'existe pas, un fichier sera créé avec le nom du chemin cible et le contenu sera le même que celui du fichier.
Si le fichier cible est un fichier existant, il sera écrasé par le fichier source. Bien sûr, seul le contenu sera écrasé et le nom du fichier sera toujours le nom du fichier cible.
Si le fichier cible existe réellement dans un répertoire existant, le fichier source sera copié dans ce répertoire. Notez que dans ce cas il est préférable de terminer l’affichage par / pour éviter toute confusion.

3. Si le chemin source est un répertoire et que le chemin cible n'existe pas, Docker créera automatiquement un répertoire avec le chemin cible et copiera les fichiers dans le répertoire du chemin source.
Si le chemin cible est un répertoire existant, Docker copiera les fichiers du répertoire du chemin source dans le répertoire.

4. Si le fichier source est un fichier d'archive (fichier compressé), Docker le décompressera automatiquement.
Les fonctionnalités de téléchargement d’URL et de décompression ne peuvent pas être utilisées ensemble. Tout fichier compressé copié via une URL ne sera pas automatiquement décompressé.

9.COPY fichier/répertoire source fichier/répertoire cible

Copiez uniquement les fichiers/répertoires de l'hôte local vers l'emplacement cible. Les fichiers/répertoires sources doivent se trouver dans le même répertoire que le Dockerfile.

10. VOLUME ["Répertoire"]

Créer un point de montage dans le conteneur

11. Nom d'utilisateur/UID UTILISATEUR

Spécifier l'utilisateur lors de l'exécution du conteneur

12.Chemin WORKDIR

Spécifiez le répertoire de travail pour les RUN, CMD, ENTRYPOINT suivants

13. Commande ONBUILD

Spécifie la commande à exécuter lorsque l'image générée est utilisée comme image de base.
Lorsque l'instruction ONBUILD est ajoutée à un Dockerfile, l'instruction n'aura pas d'impact substantiel sur l'utilisation du Dockerfile pour créer une image (telle qu'une image A).
Mais lors de l'écriture d'un nouveau Dockerfile pour construire un miroir basé sur le miroir A (comme un miroir B), la commande ONBUILD dans le Dockerfile qui construit le miroir A prendra effet à ce moment-là. il s'exécutera en premier. Seules les instructions spécifiées par l'instruction ONBUILD seront exécutées avant les autres instructions.

Remarque : si vous avez d'autres fichiers Docker en production, veuillez les étudier et les lire par vous-même, sinon vous devrez en payer les conséquences.

14.AGR

Définir les paramètres ajoutés lors de la compilation de l'image

Les variables d'environnement définies à l'aide de la directive ENV remplaceront toujours la directive ARG du même nom, quel que soit l'ordre.

15. BILAN DE SANTÉ

Examen de santé

Lors de l'écriture d'un Dockerfile, il y a un format strict à suivre :

La première ligne doit utiliser l'instruction FROM pour indiquer le nom de l'image sur laquelle elle est basée ;
Utilisez ensuite l'instruction MAINTAINER pour décrire les informations utilisateur qui maintiennent l'image ;
Il existe ensuite des instructions liées aux opérations de mise en miroir, telles que l'instruction RUN. Chaque fois qu'une commande est exécutée, un nouveau calque est ajouté à l'image de base.
Enfin, utilisez l'instruction CMD pour spécifier l'opération de commande à exécuter lors du démarrage du conteneur.

3.5Cas Dockerfile

3.5.1 Établir un répertoire de travail

mkdir  /opt/apache
cd  /opt/apache

vim Dockerfile
#基于的基础镜像
FROM centos:7
#维护镜像的用户信息
MAINTAINER this is apache image 
#镜像操作指令安装apache软件
RUN yum -y install httpd
#开启 80 端口
EXPOSE 80
#复制配置文件到容器
COPY httpd.conf /etc/httpd/conf/httpd.conf

##启动apache服务
CMD ["/usr/sbin/apachectl",""-D", "FOREGROUND"]

##方法二：
#将执行脚本复制到镜像中
ADD run.sh /run.sh
RUN chmod 755 /run.sh
#启动容器时执行脚本
CMD ["/run.sh"]


准备执行脚本
vim run.sh
#!/bin/bash
rm -rf /run/httpd/*							#清理httpd的缓存
/usr/sbin/apachectl -D FOREGROUND			#指定为前台运行
#因为Docker容器仅在它的1号进程（PID为1）运行时，会保持运行。如果1号进程退出了，Docker容器也就退出了。

3.5.2 Générer une image

docker build -t httpd:centos .   		#注意别忘了末尾有"."

3.5.3 Préparer les pages du site Web

mkdir /opt/apache/html
cd /opt/apache/html
echo "this is test web" > index.html

3.5.4 Nouveau conteneur d'exécution d'image

#将容器/var/www/html与宿主机/opt/apache/html目录共享
docker run -d -P -v /opt/apache/html:/var/www/html httpd:centos

#验证
curl http://192.168.88.60:32769

Gestion des données de Docker, interconnexion des conteneurs et création d'images

1. Gestion des données

1. Volume de données