Docker (cuatro) creación de imágenes

Primero, la creación de imágenes Docker

Hay tres formas de crear una imagen, a saber, en base a una imagen existente, en base a una plantilla local y en base a un Dockerfile.

1. Crear a partir de una imagen existente

(1) Primero cree un contenedor e inicie sesión

docker run -itd centos:7 bash
docker exec -it 82f1d79ff26c bash

(2) Crear un directorio recursivo y escribir un archivo

mkdir aa/bb -p
echo 'this is test docker file' > test.txt

(3) Cerrar sesión y crear uno basado en la imagen existente

docker commit -m "new a image" -a "zz" 82f1d79ff26c centos:a

##-m:指定名称，-a:指定作者名称  后面跟旧镜像id名称 和标签（自定义）
docker run -itd centos:a bash
docker exec -it d68283712ed2 bash
cat aa/bb/test.txt

2. Crear basado en plantilla local

La imagen se puede generar importando el archivo de plantilla del sistema operativo. La plantilla se puede descargar desde el proyecto de código abierto OPENVZ. La dirección de descarga es

http://openvz.org/Download/template/precreated

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

importar como espejo

cat debian-7.0-x86-minimal.tar.gz | docker import - debian:test

3. Crear basado en Dockerfile

Antes de crear un Dockerfile, primero comprenda los principios de UnionFS y la carga de imágenes

UnionFS

UnionFS (Union File System): Union File System (UnionFS) es un sistema de archivos en capas, liviano y de alto rendimiento
que admite cambios en el sistema de archivos como un compromiso para apilar capa por capa, mientras que se pueden montar diferentes directorios en el mismo sistema de archivos virtual. AUFS, OverlayFS y Devicemapper son una especie de UnionFS.
El sistema de archivos Union es la base de las imágenes de Docker. Las imágenes se pueden heredar a través de capas. Basándose en la imagen base (sin imagen principal), se pueden crear varias imágenes de aplicaciones específicas. Características: cargue varios sistemas de archivos al mismo tiempo, pero desde el exterior, solo se puede ver un sistema de archivos. La carga conjunta superpondrá cada capa de sistemas de archivos, de modo que el sistema de archivos final contendrá todos los archivos y directorios subyacentes.

Las capas que vemos cuando descargamos son el sistema de archivos conjuntos

Principio de carga del espejo

La imagen de Docker en realidad está compuesta por un sistema de archivos capa por capa, y esta capa del sistema de archivos es UnionFS.
El bootfs incluye principalmente el gestor de arranque y el kernel. El gestor de arranque principalmente arranca y carga el kernel. Cuando se inicia Linux, se carga el sistema de archivos bootfs.

En la parte inferior de la imagen de Docker está bootfs, que es la misma capa que nuestro sistema Linux/Unix típico, incluido el cargador de arranque y el kernel. Cuando se carga el arranque, todo el kernel está en la memoria. En este momento, el derecho a usar la memoria se ha transferido del bootfs al kernel, y el sistema también descargará el bootfs.

rootfs, encima de bootfs. Contiene registros y archivos estándar como /dev, /proc, /bin, /etc en un sistema Linux típico. rootfs es la distribución de varios sistemas operativos, como IUbuntu, Centos, etc.

Podemos entender que no hay nada en el kernel al principio, operando un comando para descargar debian, luego se agregará una imagen base al kernel; al instalar otro apache se superpondrá una capa de imagen en la imagen base; luego instale otro apache , y otra capa de imágenes se superpondrá a las imágenes. Al final parecen un sistema de archivos, el rootfs del contenedor. En el sistema Docker, estos rootfs se denominan imágenes Docker. Sin embargo, cada capa de rootfs en este momento es de solo lectura y no podemos operarla en este momento. Cuando creamos un contenedor, es decir, instanciamos una imagen de Docker, el sistema asigna un rootfs vacío de lectura y escritura encima de una o más capas de rootfs de solo lectura.

¿Por qué el tamaño de centos en Docker es de solo 200M?

Debido a que para un sistema operativo optimizado, el rootfs puede ser muy pequeño y solo necesita incluir los comandos, las herramientas y las bibliotecas de programas más básicos. Debido a que la capa subyacente usa directamente el kernel del host, solo necesita proporcionar el rootfs. Se puede ver que para diferentes distribuciones de Linux, el bootfs es básicamente el mismo y el rootfs será diferente, por lo que diferentes distribuciones pueden compartir el bootfs.

Dockerfile

La imagen de Docker es un sistema de archivos especial. Además de proporcionar programas, bibliotecas, recursos, configuración y otros archivos necesarios para el tiempo de ejecución del contenedor, también contiene algunos parámetros de configuración preparados para el tiempo de ejecución (como volúmenes anónimos, variables de entorno, usuarios, etc.) . La imagen no contiene datos dinámicos y su contenido no cambiará después de la construcción.

La personalización de la imagen es en realidad para personalizar la configuración y los archivos agregados a cada capa. Si podemos escribir cada capa de comandos de modificación, instalación, construcción y operación en un script, y usar este script para construir y personalizar la imagen, entonces se resolverá el problema de la transparencia y el volumen de la construcción de la imagen. Este script es el Dockerfile.

Dockerfile es un archivo de texto que contiene instrucciones (Instrucción), cada instrucción crea una capa, por lo que el contenido de cada instrucción es describir cómo se debe construir la capa. Con Dockerfile, cuando necesitamos personalizar nuestros propios requisitos adicionales, solo necesitamos agregar o modificar instrucciones en el Dockerfile.Regenerar la imagen, ahorrando la molestia de escribir comandos.

Además de generar imágenes de Docker manualmente, las imágenes se pueden generar automáticamente mediante un Dockerfile. Dockerfile es un archivo compuesto por múltiples instrucciones, cada una de las cuales corresponde a un comando en Linux, y el programa Docker leerá las instrucciones en el Dockerfile para generar la imagen especificada.

La estructura de Dockerfile se divide aproximadamente en cuatro partes: información básica de la imagen , información del mantenedor , instrucciones de operación de la imagen e instrucciones de ejecución cuando se inicia el contenedor . Dockerfile admite una instrucción por línea, cada instrucción puede contener varios parámetros y admite el uso de comentarios que comienzan con "#".

Capas de estructura de imagen de Docker

Una imagen no es un único archivo, sino que consta de varias capas. El contenedor en realidad agrega una capa de lectura y escritura encima de la imagen, y cualquier cambio de archivo realizado en el contenedor en ejecución se escribirá en esta capa de lectura y escritura. Si se elimina el contenedor, también se elimina su capa superior de lectura y escritura y se pierden los cambios del archivo. Docker utiliza controladores de almacenamiento para administrar el contenido de cada capa de la imagen y la capa contenedora de la capa de lectura y escritura.

(1) Cada instrucción en el Dockerfile crea una nueva capa de imagen;

(2) La capa de espejo se almacenará en caché y se reutilizará;

(3) Cuando se modifican las instrucciones del Dockerfile, se cambian los archivos copiados o las variables especificadas al crear la imagen son diferentes, la caché de la capa de imagen correspondiente no será válida;

(4) La memoria caché de espejo de una determinada capa no es válida, y la memoria caché de la capa de espejo posterior no será válida;

(5) La capa de la imagen es inmutable. Si agrega un archivo en una capa y lo elimina en la capa siguiente, el archivo aún se incluirá en la imagen, pero el archivo no será visible en el contenedor de Docker.

Instrucciones de uso común para las operaciones de Dockerfile:

（1）FROM镜像
指定新镜像所基于的基础镜像，第一条指令必须为FROM指令，每创建一个镜像就需要一条FROM指令

(2)MAINTAINER名字
说明新镜像的维护人信息

(3) RUN命令
在所基于的镜像上执行命令，并提交到新的镜像中

(4）ENTRYPOINT["要运行的程序"，"参数1"，"参数2"]设定容器启动时第一个运行的命令及其参数。
可以通过使用命令docker run --entrypoint来覆盖镜像中的ENTRYPOINT指令的内容。

(5) CMD["要运行的程序"，"参数1"，"参数2""]
上面的是exec形式，shell形式:CMD命令参数1参数2
启动容器时默认执行的命令或者脚本，Dockerfile只能有一条CMD命令。如果指定多条命令，只执行最后一条命令。如果在docker run时指定了命令或者镜像中有ENTRYPOINT，那么CDM就会被覆盖。
CMD可以为ENTRYPOINT指令提供默认参数。

(6)EXPOSE端口号
指定新镜像加载到Docker时要开启的端口

(7)ENV环境变量变量值
设置一个环境变量的值，会被后面的RUN使用

(8）ADD 源文件/目录 目标文件/目录
将源文件复制到镜像中，源文件要与 Dockerfile位于相同目录中，或者是一个URL
有如下注意事项:
1、如果源路径是个文件，且目标路径是以/结尾，则docker会把目标路径当作一个目录，会把源文件拷贝到该目录下。如果目标路径不存在，则会自动创建目标路径。
2、如果源路径是个文件，且目标路径是不以/结尾，则docker会把目标路径当作一个文件。如果目标路径不存在，会以目标路径为名创建一个文件，内容同源文件;
   如果目标文件是个存在的文件，会用源文件覆盖它，当然只是内容覆盖，文件名还是目标文件名。
    如果目标文件实际是个存在的目录，则会源文件拷贝到该目录下。注意，这种情况下，最好显示的以/结尾，以避免混淆。
3、如果源路径是个目录，且目标路径不存在，则docker会自动以目标路径创建一个目录，把源路径目录下的文件拷贝进来。如果目标路径是个已经存在的目录，则docker会把源路径目录下的文件拷贝到该目录下。
4、如果源文件是个归档文件（压缩文件），则docker会自动帮解压。
URL下载和解压特性不能一起使用。任何压缩文件通过URL拷贝，都不会自动解压。

(9) COPY 源文件/目录目标文件/目录
只复制本地主机上的文件/目录复制到目标地点，源文件/目录要与Dockerfile在相同的目录中

(10) vOLUME["目录"]
在容器中创建一个挂载点

(11) USER用户名/UID指定运行容器时的用户

(12)WORKDIR路径
为后续的RUN、CMD、ENTRYPOINT指定工作目录

(13)ONBUILD命令
指定所生成的镜像作为一个基础镜像时所要运行的命令。
当在一个Dockerfile文件中加上ONBUILD指令，该指令对利用该Dockerfile构建镜像（比如为A镜像）不会产生实质性影响。
但是当编写一个新的Dockerfile文件来基于A镜像构建一个镜像（比如为B镜像〉时，这时构造A镜像的Dockerfile文件中的ONBUILD指令就生效了，在构建B镜像的过程中，首先会执行ONBUILD指令指定的指令，然后才会执行其它指令

(14)HEALTHCHECK
健康检查

Al escribir un Dockerfile, hay formatos estrictos a seguir:

La primera línea debe usar la directiva FROM para indicar el nombre de la imagen en la que se basará;

Luego use el comando MAINTAINER para describir la información del usuario para mantener la imagen;

Luego están las instrucciones relacionadas con la operación del espejo, como la instrucción RUN. Cada vez que se ejecuta una instrucción, se agrega una nueva capa a la imagen base

Finalmente, use la directiva CMD para especificar la acción del comando que se ejecutará cuando se inicie el contenedor.

Demostración de ejemplo de Dockerfile:

(1) Cambie al directorio opt, cree el directorio apache para preparar los archivos de la página web

 cd /opt/
 mkdir apache
 cd apache/
 vim index.html
 <h1>this is my first dockerfile</h1>
 cat index.html
 <h1>this is my first dockerfile</h1>

(2) Escribir un script de archivo acoplable

vim Dockerfile 

(3) Cree una nueva imagen y ejecute el script Dockerfile

docker build -t apache:centos7 .

docker run -itd -p 1314:80 apache:centos7 bash

(4) Verificación de página web abierta

4. Construye un almacén privado local

(1) Primero descargue la imagen de registro

docker pull registry

(2) Agregue la dirección del almacén espejo privado en el archivo daemon.json

vim /etc/docker/daemon.json

(3) Reinicie el servicio docker

systemctl restart docker

(4) Ejecute el contenedor de registro

docker run -itd -v /data/registry:/var/lib/registry -p 5000:5000 --restart=always --name registry registry:latest

####
-itd:在容器中打开一个伪终端进行交互操作，并在后台运行

-v把宿主机的/data/registry目录绑定到容器/var/lib/registry目录(这个目录是registry容器中存放镜像文件的目录)，来实现数据的持久化;

-p:映射端口;访问宿主机的5000端口就访问到registry容器的服务了--restart=always:这是重启的策略，在容器退出时总是重启容器

--name registry:创建容器命名为registry

registry : latest:这个是刚才pull下来的镜像

##########
Docker容器的重启策略如下:
no:默认策略，在容器退出时不重启容器
on-failure:在容器非正常退出时（退出状态非0），才会重启容器
on-failure:3 :在容器非正常退出时重启容器，最多重启3次
always:在容器退出时总是重启容器
unless-stopped:在容器退出时总是重启容器，但是不考虑在Docker守护进程启动时就已经停止了的容器

(5) Etiquete la imagen y envíela al almacén local

docker tag centos:7 192.168.100.140:5000/centos:v1
docker push 192.168.100.140:5000/centos:v1 
docker tag nginx:1.14 192.168.100.140:5000/nginx:v1
docker push 192.168.100.140:5000/nginx:v1

(6) Verifique qué imágenes y etiquetas hay en su biblioteca

curl http://192.168.100.140:5000/v2/_catalog
curl http://192.168.100.140:5000/v2/centos/tags/list

(7) Eliminar la imagen nginx

docker rmi 295c7be07902 -f

(8) Extraiga la imagen de la biblioteca local

 docker pull 192.168.100.140:5000/nginx:v1