Obtenga una comprensión profunda de la duplicación de Docker, después de leerlo, será tan competente como Pao Ding Jie Niu

Primero, la superposición de imágenes de Docker

En segundo lugar, la creación de la imagen de Docker.

1. Imagen de Docker

(1) Formato estándar para la versión de la aplicación
(2) Admite el funcionamiento de un contenedor Docker

2. Cómo crear una imagen de Docker

(1) Crear basado en una imagen existente
(2) Crear basado en una plantilla local
(3) Crear basado en Dockerfile

Tres, crea basado en la imagen existente

1. El paquete del programa y el entorno operativo que se ejecuta en el contenedor para generar una imagen nueva
ventana acoplable cometer [Opciones] Nombre de contenedor Identificación / Nombre Almacén: [etiqueta]
-m Descripción información de
información -a Autor
-p detener el funcionamiento del contenedor durante el proceso de generación

2. Operación experimental específica

创建容器
docker create -it centos:7 /bin/bash
docker commit -m "new" -a "daoke" be93f7652231 daoke:test
docker images

Cuarto, crea basado en módulos locales.

1. Genere una nueva imagen importando el archivo de plantilla del sistema operativo.
2. Utilice el comando wget para importar como una imagen local.

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

3. Una vez que la importación se haya realizado correctamente, podrá ver el mensaje espejo local.

docker imagges |grep new

Cinco, crear basado en Dockerfile

1. Dockerfile es un archivo compuesto por un conjunto de instrucciones

2. Cuatro partes de la estructura de Dockerfile

(1) Información de imagen básica
(2) Información de mantenimiento
(3) Instrucciones de operación de espejo
(4) Ejecutar instrucciones cuando se inicia el contenedor
Nota: Cada línea de Dockerfile admite una instrucción, cada instrucción puede contener múltiples parámetros y admite el uso de un "#" El comentario al principio del signo.

3. Instrucciones de funcionamiento de Dockerfile

instrucción	sentido
DESDE el espejo	Especifique la imagen en la que se basa la nueva imagen. La primera instrucción debe ser la instrucción FROM. Cada vez que crea una imagen, necesita una instrucción FROM.
Nombre del MANTENIMIENTO	Describe la información del mantenedor de la nueva imagen.
Comando RUN	Ejecute el comando en el espejo basado en él y envíelo al nuevo espejo
CMD ["programa para ejecutar", "parámetro 1", "parámetro 2"]	El comando o script que se ejecutará cuando la instrucción inicie el contenedor, el Dockerfile solo puede tener un comando CMD, si se especifica más de uno, solo se puede ejecutar el último
EXPONER número de puerto	Especifique el puerto que se abrirá cuando se cargue la nueva imagen en Docker
Valor de la variable de la variable de entorno ENV	Establezca el valor de una variable de entorno, que RUN utilizará más adelante
AÑADIR archivo / directorio de origen archivo / directorio de destino	Copie el archivo de origen en el archivo de destino, el archivo de origen debe estar ubicado en el mismo directorio que Dockerfile o una URL
COPIAR archivo de origen / directorio archivo / directorio de destino	Copie el archivo / directorio en el host local a la ubicación de destino, el archivo / directorio de origen debe estar en el mismo directorio que Dockerfile
VOLUME ["Directorio"]	Crea un punto de montaje en el contenedor.
USUARIO usuario / UID	Especificar el usuario al ejecutar el contenedor
Ruta WORKDIR	Especifique el directorio de trabajo para el siguiente RUN, CMD, ENTRYPOINT
Comando ONBUILD	Especifique el comando que se ejecutará cuando la imagen generada se utilice como imagen base
CHEQUEO DE SALUD	Examen de salud

4. Usa dockerfile para crear un espejo

（1） apache

Crear directorio de apache

mkdir apache
cd apache

Escribir archivo dockerfile

vim dockerfile
#基于基础镜像
From centos:7
#维护镜像的用户信息
MAINTAINER this is test
#镜像的操作指令：安装apache软件
RUN yum -y install httpd
#开启80端口
EXPOSE 80
#复制网站首页文件
ADD index.html /var/www/html/index.html
#执行脚本并复制到镜像中
ADD run.sh /run.sh
RUN chmod 777 /run.sh
#启动容器时执行脚本
CMD ["/run.sh"]

Escriba el script run.sh

vim run.sh
#!/bin/bash
rm -rf /run/httpd/*
exec /usr/sbin/apachectl -D FOREGROUND

Prepara la página de inicio

echo "this is 17team web" >index.html

Generar espejo

docker build -t httpd:centos .				#末尾别忘记“.”

Ejecute un nuevo contenedor de imágenes y compruébelo a través de la página web

docker run -d -P httpd:centos 					#-P随机端口
docker run -d -p 1213 httpd:centos         #-p指定端口

##使用浏览器输入：192.168.177.33:xxxx

(2) Cree una imagen SSH

Crear directorio SSH

mkdir sshd
cd sshd

Crear archivo dockerfile

vim dockerfile
FROM centos:7
MAINTAINER ssh_test
RUN yum -y install openssh* net-tools lsof telnet passwd
RUN echo "123123" | passwd --stdin root
RUN sed -i 's/UsePAM yes/UsePAM no/g' /etc/ssh/sshd_config
RUN ssh-keygen -t rsa -f /etc/ssh/ssh_host_rsa_key
RUN sed -i '/^session\s\+required\s\+pam_loginuid.so/s/^/#/' /etc/pam.d/sshd
RUN mkdir -p /root/.ssh && chown root:root /root && chmod 700 /root/.ssh
EXPOSE 22
CMD ["/usr/sbin/sshd","-D"]

Generar espejo

docker build -t sshd:new .

Inicie el contenedor e inicie sesión

docker run -d -P sshd:new
ssh localhost -p xxxx

(3) Crear imagen systemctl

Crear directorio systemctl

mkdir systemctl
cd systemctl

Crear dockerfile

vim Dockerfile
FROM sshd:new
ENV container docker
RUN (cd /lib/systemd/system/sysinit.target.wants/; for i in *;do [ $i== \
systemd-tmpfiles-setup.service ] || rm -f $i;done);\
rm -f /lib/systemd/system/multi-user.target.wants/*;\
rm -f /etc/systemd/system/*.wants/*;\
rm -f /lib/systemd/system/local-fs.target.wants/*;\
rm -f /lib/systemd/system/sockets.target.wants/*udev*;\
rm -f /lib/systemd/system/sockets.target.wants/*initctl*;\
rm -f /lib/systemd/system/basic.target.wants/*;\
rm -f /lib/systemd/system/anaconda.target.wants/*;
VOLUME ["/sys/fs/cgroup"]
CMD ["/usr/sbin/init"]

Crear imagen

docker build -t systemd:new .

privateged container 内的root拥有真正的root权限，否则，container内的root只是外部的一个普通用户权限
docker run --privateged -it -v /sys/fs/cgroup:/sys/fs/cgroup:ro systemd:new /sbin/init & 

Entrar en el contenedor

docker exec -it 容器id bash

prueba

systemctl status sshd

(4) Hacer espejo nginx

Crear directorio nginx

mkdir nginx
cd nginx

Crear archivo dockerfile

vim Dockerfile
FROM centos:7
MAINTAINER test
RUN yum -y install pcre-devel zlib-devel gcc gcc-c++ make
RUN useradd -M -s /sbin/nologin nginx
ADD nginx-1.12.0.tar.gz /usr/local/src
WORKDIR /usr/local/src/nginx-1.12.0
RUN ./configure \
--prefix=/usr/local/nginx \
--user=nginx \
--group=nginx \
--with-http_stub_status_module && make && make install
ENV PATH /usr/local/nginx/sbin:&PATH
EXPOSE 80
EXPOSE 443
RUN echo "daemon off;" >>/usr/local/nginx/conf/nginx.conf
ADD run.sh /run.sh
RUN chmod 777 /run.sh
CMD ["/run.sh"]

Crear secuencia de comandos de inicio

vim run.sh
#!/bin/bash
/usr/local/nginx/sbin/nginx

Crea una nueva imagen y prueba

docker build -t nginx:new
docker run -d -P nginx:new

192.168.177.8：xxxx

(5) Hacer espejo tomcat

Crear directorio de tomcat

mkdir tomcat
cd tomcat

Crear archivo dockerfile

vim Dockerfile
FROM centos:7
MAINTAINER test
ADD jdk-8u91-linux-x64.tar.gz /opt
ADD apache-tomcat-9.0.16.tar.gz /usr/local/src
RUN mv /opt/jdk1.8.0_91 /usr/local/java
RUN mv /usr/local/src/apache-tomcat-9.0.16 /usr/local/tomcat
ENV JAVA_HOME /usr/local/java
ENV CLASSPATH $JAVA_HOME/lib/tools.jar:$JAVA_HOME/lib/dt.jar
ENV PATH $JAVA_HOME/bin:$PATH
EXPOSE 8080
ENTRYPOINT ["/usr/local/tomcat/bin/catalina.sh","run"]

Hacer un espejo

docker buil -t tomcat:test .

Ejecute el contenedor y visite en el navegador

docker run -d -P tomcat:test
192.168.177.8:49152

(6) Hacer espejo mysql

Crear directorio mysql

mkdir mysql
cd mysql

Crear archivo my.cnf

vim Dockerfile
FROM centos:7
MAINTAINER test
ADD jdk-8u91-linux-x64.tar.gz /opt
ADD apache-tomcat-9.0.16.tar.gz /usr/local/src
RUN mv /opt/jdk1.8.0_91 /usr/local/java
RUN mv /usr/local/src/apache-tomcat-9.0.16 /usr/local/tomcat
ENV JAVA_HOME /usr/local/java
ENV CLASSPATH $JAVA_HOME/lib/tools.jar:$JAVA_HOME/lib/dt.jar
ENV PATH $JAVA_HOME/bin:$PATH
EXPOSE 8080
ENTRYPOINT ["/usr/local/tomcat/bin/catalina.sh","run"]

Crear archivo dockerfile

vim Dockerfile
FROM centos:7
MAINTAINER this is test
RUN yum -y install ncurses ncurses-devel bison cmake gcc gcc-c++ make
RUN useradd -M -s /sbin/nologin mysql
ADD mysql-boost-5.7.20.tar.gz /usr/local/src
WORKDIR /usr/local/src/mysql-5.7.20
RUN cmake \
-DCMAKE_INSTALL_PREFIX=/usr/local/mysql \
-DMYSQL_UNIX_ADDR=/usr/local/mysql/mysql.sock \
-DSYSCONFDIR=/etc \
-DSYSTEMD_PID_DIR=/usr/local/mysql \
-DDEFAULT_CHARSET=utf8  \
-DDEFAULT_COLLATION=utf8_general_ci \
-DWITH_EXTRA_CHARSETS=all \
-DWITH_INNOBASE_STORAGE_ENGINE=1 \
-DWITH_ARCHIVE_STORAGE_ENGINE=1 \
-DWITH_BLACKHOLE_STORAGE_ENGINE=1 \
-DWITH_PERFSCHEMA_STORAGE_ENGINE=1 \
-DMYSQL_DATADIR=/usr/local/mysql/data \
-DWITH_BOOST=boost \
-DWITH_SYSTEMD=1 && make -j2 && make install
RUN chown -R mysql:mysql /usr/local/mysql
RUN rm -rf /etc/my.cnf
ADD my.cnf /etc
RUN chown mysql:mysql /etc/my.cnf
ENV PATH=/usr/local/mysql/bin:/usr/local/mysql/lib:$PATH
WORKDIR /usr/local/mysql
RUN bin/mysqld \
--initialize-insecure \
--user=mysql \
--basedir=/usr/local/mysql \
--datadir=/usr/local/mysql/data
RUN cp /usr/local/mysql/usr/lib/systemd/system/mysqld.service /usr/lib/systemd/system/
EXPOSE 3306
RUN echo -e "#!/bin/sh \nsystemctl enable mysqld" > /run.sh
RUN chmod 755 /run.sh
RUN sh /run.sh
CMD ["init"]

Hacer un espejo

docker build -t mysql:new .

Iniciar el contenedor

docker run --name=mysql_server -d -P --privileged mysql:new

Entrar al contenedor para dar permiso

grant all privileges on *.* 'root' @ '%' identified by 'abc123';
grant all privileges on *.* 'root' @ 'localhost' identified by 'abc123';

Instale el cliente mairadb en el sistema host para conectarse al contenedor mysql

mysql -h 192.168.177.8 -u root -P xxxx -pabc123