Capítulo 5

¿Qué es Docker?

• Los microservicios parecen tener varias ventajas, pero la división de servicios suele traer muchos problemas a la implementación.
  • En un sistema distribuido, hay muchos componentes dependientes y, a menudo, se producen conflictos cuando se implementan diferentes componentes.
  • Implementación repetida en cientos o miles de servicios, es posible que el entorno no siempre sea el mismo y se encontrarán varios problemas

Problemas ambientales para la implementación de aplicaciones

• Los proyectos a gran escala tienen muchos componentes y el entorno operativo es relativamente complejo, por lo que pueden surgir algunos problemas durante la implementación.
  • Las dependencias son complejas y es probable que se produzcan problemas de compatibilidad.
  • Los entornos de desarrollo, pruebas y producción son diferentes.

• Por ejemplo, en un proyecto, la implementación debe depender de node.js, Redis, RabbitM, MySQL, etc. Las bibliotecas de funciones y las dependencias necesarias para la implementación de estos servicios son diferentes y habrá conflictos en la revisión, lo que aporta grandes ventajas. dificultades para el despliegue dificultad

Docker resuelve problemas de compatibilidad de dependencias

• De hecho, Docker ha resuelto estos problemas de manera inteligente, entonces, ¿cómo lo logra Docker?
• Para resolver el problema de compatibilidad de dependencias, Docker adopta dos métodos:
  1. Empaquete las bibliotecas de funciones (libs), las dependencias (Deps) y la configuración de la aplicación junto con la aplicación.
  2. Coloque cada aplicación 容器de forma aislada para evitar interferencias mutuas.

Docker resuelve las diferencias del entorno del sistema operativo

• Para resolver el problema de las diferencias ambientales entre diferentes sistemas operativos, primero debe comprender la estructura del sistema operativo. Tomando un sistema operativo Ubuntu como ejemplo, la estructura es la siguiente
  • Aplicaciones del sistema: aplicaciones y bibliotecas de funciones proporcionadas por el propio sistema operativo. Estos datos son una encapsulación de las instrucciones del kernel, lo que los hace más cómodos de usar.
  • Kernel del sistema: El kernel de todas las distribuciones de Linux es Linux, como CentOS, Ubuntu, Fedora, etc. El kernel puede interactuar con el hardware de la computadora y proporcionar instrucciones del kernel al mundo exterior para operar el hardware de la computadora.
  • Hardware de la computadora: como CPU, memoria, disco, etc.

• El proceso aplicado a la interacción con la computadora es el siguiente
  1. Las aplicaciones llaman a aplicaciones del sistema operativo (bibliotecas de funciones) para implementar varias funciones.
  2. La biblioteca de funciones del sistema es una encapsulación del conjunto de instrucciones del núcleo y llamará a las instrucciones del núcleo.
  3. Las instrucciones del kernel operan el hardware de la computadora.
• Tanto Ubuntu como CentOS se basan en el kernel de Linux, pero las aplicaciones del sistema son diferentes y las bibliotecas de funciones proporcionadas son diferentes.
• En este momento, si se instala una versión Ubuntu de la aplicación MySQL en el sistema CentOS, cuando MySQL llame a la biblioteca de funciones de Ubuntu, encontrará que no se puede encontrar o no coincide y se informará un error.
• ¿Cómo resuelve Docker problemas en diferentes entornos de sistemas?
  • Docker empaqueta la biblioteca de funciones del sistema (como Ubuntu) requerida por el programa de usuario
  • Cuando Docker se ejecuta en diferentes sistemas operativos, se basa directamente en la biblioteca de funciones empaquetadas y se ejecuta con la ayuda del kernel de Linux del sistema operativo.

resumen

• ¿Cómo resuelve Docker los problemas de compatibilidad de dependencias complejas y dependencias de diferentes componentes en proyectos grandes?
  • Docker permite combinar aplicaciones, dependencias, bibliotecas de funciones y configuraciones durante el desarrollo 打包para formar una imagen portátil.
  • Las aplicaciones Docker se ejecutan en contenedores y utilizan un mecanismo de espacio aislado para comunicarse entre sí.隔离
• ¿Cómo resuelve Docker el problema de las diferencias entre los entornos de desarrollo, prueba y producción?
  • La imagen de Docker contiene un entorno operativo completo, incluidas las bibliotecas de funciones del sistema, y ​​solo depende del kernel de Linux del sistema, por lo que puede ejecutarse en cualquier sistema operativo Linux.
• Docker es una tecnología para entregar y ejecutar aplicaciones rápidamente y tiene las siguientes ventajas:
  1. El programa, sus dependencias y el entorno operativo se pueden empaquetar en una imagen, que se puede migrar a cualquier sistema operativo Linux.
  2. El mecanismo de espacio aislado se utiliza para formar un contenedor aislado durante el tiempo de ejecución, de modo que cada aplicación no interfiera entre sí.
  3. El inicio y la eliminación se pueden completar con una línea de comandos, lo cual es conveniente y rápido

Docker y máquinas virtuales

• Docker puede hacer que una aplicación se ejecute de manera muy conveniente en cualquier sistema operativo, y la máquina virtual a la que hemos estado expuestos antes también puede ejecutar otro sistema operativo en un sistema operativo para proteger cualquier aplicación en el sistema.
• ¿Cuál es la diferencia entre los dos?
  • Una máquina virtual es 模拟un dispositivo de hardware en un sistema operativo que luego ejecuta otro sistema operativo. Por ejemplo, si ejecuta un sistema CentOS en un sistema Windows, puede ejecutar cualquier aplicación CentOS.
  • Docker solo encapsula la biblioteca de funciones y no simula un sistema operativo completo

característica	Estibador	máquina virtual
actuación	cerca de nativo	Bajo rendimiento
Uso del disco duro	Generalmente MB	Generalmente GB
puesta en marcha	segundo nivel	nivel de minutos

• Resumen: la diferencia entre Docker y máquinas virtuales
  • Docker es un proceso del sistema; la máquina virtual es el sistema operativo en el sistema operativo
  • Docker es pequeño en tamaño, rápido en el inicio y tiene buen rendimiento; las máquinas virtuales son grandes en tamaño, lento en el inicio y tienen un rendimiento promedio.

Arquitectura acoplable

Imágenes y contenedores

• Hay varios conceptos importantes en Docker.
  • 镜像(Image): Docker empaqueta la aplicación y sus dependencias requeridas, bibliotecas de funciones, entorno, configuración y otros archivos juntos, lo que se denomina imagen.
  • 容器(Container): El proceso después de que se forma la aplicación en la imagen es 容器solo que Docker aislará el proceso del contenedor y será invisible para el mundo exterior.
• Todas las aplicaciones se componen en última instancia de código, que es un archivo formado por bytes en el disco duro, solo cuando se está ejecutando se cargará en la memoria para formar un proceso.
• Sin embargo 镜像, es un paquete de archivos que empaqueta un archivo de aplicación en el disco duro, el entorno operativo de la máquina y algunos archivos de biblioteca de funciones del sistema. Este paquete de archivos es de solo lectura (para evitar que modifique/contamine el archivo de imagen, provocando que la imagen quede inutilizable, el contenedor copia un archivo de la imagen a su propio espacio para escribir datos)
• Sin embargo 容器, los programas y funciones escritos en estos archivos se cargan en la memoria para permitirles formar procesos, pero deben estar aislados. Por lo tanto, una imagen se puede iniciar varias veces para formar múltiples procesos contenedores.

Docker Hub

• Hay muchas aplicaciones de código abierto y empaquetar estas aplicaciones es a menudo un trabajo repetitivo. Para evitar estas tareas repetidas, las personas colocarán las imágenes de sus aplicaciones empaquetadas, como las imágenes de Redis y MySQL, en Internet para compartir, al igual que el código compartido de GitHub. .lo mismo
  • DockerHub: DockerHub es una plataforma oficial de alojamiento de imágenes de Docker, dicha plataforma se llama Docker Registry.
  • También existen servicios públicos similares a DockerHub en China, como Netease Cloud Mirror Service , Alibaba Cloud Mirror Library , etc.
• Por un lado, podemos compartir nuestra propia imagen en DockerHub y, por otro lado, también podemos extraer la imagen de DockerHub.

Arquitectura acoplable

• Si queremos utilizar Docker para operar imágenes y contenedores, debemos instalar Docker
• Docker es un programa de arquitectura CS, que consta de dos partes.
  • Servidor: demonio Docker, responsable de procesar instrucciones Docker, gestionar imágenes, contenedores, etc.
  • Cliente (cliente): envía instrucciones al servidor Docker a través de comandos o RestAPI, y puede enviar instrucciones al servidor de forma local o remota

Instalar ventana acoplable

• Docker se divide en dos versiones principales, CE y EE. CE significa Community Edition, gratuita, con un período de soporte de 7 meses; EE significa Enterprise Edition, que enfatiza la seguridad y es de pago, con un período de soporte de 24 meses.

• Docker CE se divide en tres canales de actualización stable testy .nightly

• En el sitio web oficial hay guías de instalación en varios entornos , Aquí presentamos principalmente la instalación de Docker CE en CentOS.

• Docker CE es compatible con la versión de 64 bits de CentOS 7 y requiere una versión del kernel no inferior a 3.10

• CentOS 7 cumple con los requisitos mínimos del kernel; este artículo también instala Docker en CentOS 7

Desinstalar (opcional)

• Si ha instalado una versión antigua de Docker anteriormente, puede usar el siguiente comando para desinstalarla

  sudo yum remove docker \
  	  docker-client \
  	  docker-client-latest \
  	  docker-common \
  	  docker-latest \
  	  docker-latest-logrotate \
  	  docker-logrotate \
  	  docker-engine
  

Instalar ventana acoplable

• Primero instale la herramienta yum

yum install -y yum-utils \
           device-mapper-persistent-data \
           lvm2 --skip-broken

• Luego actualice la fuente del espejo local

sudo yum-config-manager \
    --add-repo \
    https://download.docker.com/linux/centos/docker-ce.repo

• Luego instale la versión comunitaria de Docker.

sudo yum install docker-ce docker-ce-cli containerd.io

Iniciar ventana acoplable

• Las aplicaciones Docker necesitan usar varios puertos y es muy problemático modificar la configuración del firewall uno por uno, por lo que se recomienda cerrar el firewall directamente.

# 关闭
systemctl stop firewalld
# 禁止开机启动防火墙
systemctl disable firewalld
#查看防火墙的状态
systemctl status firewalld

• Inicie Docker mediante comando

# 启动docker服务
systemctl start docker 

# 停止docker服务
systemctl stop docker

# 重启docker服务
systemctl restart docker

#设置docker开机自启动
sudo systemctl enable docker

• Luego ingrese el comando para ver la versión de Docker

[root@lsc1 ~]# docker -v
Docker version 24.0.4, build 3713ee1

Configurar la aceleración de la imagen

sudo mkdir -p /etc/docker
sudo tee /etc/docker/daemon.json <<-'EOF'
{
  "registry-mirrors": ["https://x4ldcyqu.mirror.aliyuncs.com"]
}
EOF
sudo systemctl daemon-reload
sudo systemctl restart docker

• teeEl comando lee datos basándose en la entrada estándar y escribe datos en la salida estándar o en un archivo.

Operaciones básicas de Docker

Nombre de la imágen

• Primero, echemos un vistazo a la composición del nombre de la imagen:

  • El nombre de la imagen generalmente se divide en dos partes: [repositorio]: [etiqueta]

    Por ejemplo mysql:5.7, mysql aquí es el repositorio, 5.7 es la etiqueta y juntos son el nombre de la imagen, que representa la versión 5.7 de la imagen MySQL.

  • Cuando no se especifica ninguna etiqueta, el valor predeterminado es la última, que representa la última versión de la imagen, por ejemplomysql:latest

Comando espejo

• Los comandos de duplicación comunes se muestran a continuación

Caso numero uno

• En este caso, contactemos a pull y veamos la imagen.

  Requisito: extraer una imagen de Nginx de DockerHub y verla

1. Primero, buscamos la imagen de Nginx en el almacén espejo (como DockerHub ).

2. Según el nombre de la imagen vista, extraiga la imagen que necesita y pase el comando: docker pull nginxextraiga la última imagen de nginx

[root@lsc1 ~]#  docker pull nginx
Using default tag: latest
latest: Pulling from library/nginx
a2abf6c4d29d: Already exists 
a9edb18cadd1: Pull complete 
589b7251471a: Pull complete 
186b1aaa4aa6: Pull complete 
b4df32aa5a72: Pull complete 
a0bcbecc962e: Pull complete 
Digest: sha256:0d17b565c37bcbd895e9d92315a05c1c3c9a29f762b011a10c54a66cd53c9b31
Status: Downloaded newer image for nginx:latest
docker.io/library/nginx:latest

docker images3. Vea la imagen extraída a través del comando.

[root@lsc1 ~]# docker images
REPOSITORY           TAG          IMAGE ID       CREATED         SIZE
nginx                latest       605c77e624dd   20 months ago   141MB

Caso 2

• En este caso contactamos para guardar e importar la imagen.
• Requisito: docker saveexportar la imagen nginx al disco y luego docker loadvolver a cargarla

1. Utilice docker xx --helpel comando para ver docker savela docker loadsintaxis de la suma.

[root@localhost ~]# docker save --help
Usage:  docker save [OPTIONS] IMAGE [IMAGE...]
Save one or more images to a tar archive (streamed to STDOUT by default)
Options:
-o, --output string   Write to a file, instead of STDOUT

Formato de comando:

docker save -o [保存的目标文件名称] [镜像名称]

[root@localhost ~]# docker load --help
Usage:  docker load [OPTIONS]
Load an image from a tar archive or STDIN
Options:
-i, --input string   Read from tar archive file, instead of STDIN
-q, --quiet          Suppress the load output

Formato de comando:

docker load -i [镜像压缩文件名]

2 Use Docker Save para exportar la imagen al disco y luego use el comando ls para ver el archivo nginx.tar.

docker save -o nginx.tar nginx:latest

3 Use Docker Load para cargar la imagen, antes de eso, usamos el comando para eliminar la imagen nginx local.

[root@lsc1 tmp]# docker rmi nginx:latest # rmi是remove image的缩写
Untagged: nginx@sha256:0d17b565c37bcbd895e9d92315a05c1c3c9a29f762b011a10c54a66cd53c9b31
Deleted: sha256:605c77e624ddb75e6110f997c58876baa13f8754486b461117934b24a9dc3a85
Deleted: sha256:b625d8e29573fa369e799ca7c5df8b7a902126d2b7cbeb390af59e4b9e1210c5
Deleted: sha256:7850d382fb05e393e211067c5ca0aada2111fcbe550a90fed04d1c634bd31a14
Deleted: sha256:02b80ac2055edd757a996c3d554e6a8906fd3521e14d1227440afd5163a5f1c4
Deleted: sha256:b92aa5824592ecb46e6d169f8e694a99150ccef01a2aabea7b9c02356cdabe7c
Deleted: sha256:780238f18c540007376dd5e904f583896a69fe620876cabc06977a3af4ba4fb5

4 Luego ejecute el comando para cargar el archivo local.

[root@lsc1 tmp]# docker load -i nginx.tar
e379e8aedd4d: Loading layer [==================================================>]     62MB/62MB
b8d6e692a25e: Loading layer [==================================================>]  3.072kB/3.072kB
f1db227348d0: Loading layer [==================================================>]  4.096kB/4.096kB
32ce5f6a5106: Loading layer [==================================================>]  3.584kB/3.584kB
d874fd2bc83b: Loading layer [==================================================>]  7.168kB/7.168kB
Loaded image: nginx:latest

Operaciones de contenedores

• Los contenedores protegen tres estados
  • En ejecución: el proceso se está ejecutando normalmente.
  • Pausa: el proceso se pausa, la CPU ya no se ejecuta y no se libera memoria.
  • Detener: el proceso finaliza y se recuperan la memoria, la CPU y otros recursos ocupados por el proceso.
    • Los métodos de procesamiento de los sistemas operativos suspendidos y detenidos son diferentes. Pausa significa que el sistema operativo suspende el proceso en el contenedor y almacena temporalmente la memoria asociada con el contenedor. Luego, la CPU ya no ejecuta el proceso, sino que usa el comando para reanudarlo. el espacio de memoria se restaura y el unpauseprograma sigue ejecutándose.
    • Detenerlo directamente mata el proceso, recupera la memoria ocupada por el contenedor y guarda solo el sistema de archivos del contenedor, es decir, esos recursos estáticos.
    • docker rmEl sistema de archivos también se elimina por completo, lo que significa que el contenedor se elimina por completo.
• docker run:Crear y ejecutar un contenedor en estado de ejecución
• docker pause: pausar un contenedor en ejecución
• docker unpause: Reanudar un contenedor desde un estado de pausa
• docker stop: detener un contenedor en ejecución
• docker start: Hacer que un contenedor detenido se ejecute nuevamente
• docker rm: Eliminar un contenedor

Caso numero uno

• Comandos para crear y ejecutar contenedores nginx

  docker run --name containerName -p 80:80 -d nginx
  

• Interpretación de comandos

  • docker run: crear y ejecutar un contenedor
  • --name: Asigne un nombre al contenedor, por ejemplo, myNginx.
  • -p: Asigne el puerto host al puerto del contenedor. El lado izquierdo de los dos puntos es el puerto host y el lado derecho es el puerto del contenedor.
  • -d: Ejecutar el contenedor en segundo plano.
  • nginx: nombre del espejo, como nginx

• El parámetro aquí -pes asignar el puerto del contenedor al puerto del host.

  • De forma predeterminada, el contenedor es un entorno aislado. Si accedemos directamente al puerto 80 del host, definitivamente no podremos acceder a nginx en el contenedor.
  • Ahora, el puerto 80 del contenedor está asociado con el puerto 80 del host. Cuando accedamos al puerto 80 del host, se asignará al puerto 80 del contenedor, para que podamos acceder a nginx.

• Luego podemos ingresar la máquina virtual ip:80 en el navegador y ver la página predeterminada de nginx.

Caso 2

Requisitos: ingrese al contenedor Nginx, modifique el contenido del archivo HTML y agregue Consejos: use el comando Welcome To My Blog！
para ingresar al contenedordocker exec

[root@lsc1 ~]# docker exec --help
Usage:  docker exec [OPTIONS] CONTAINER COMMAND [ARG...]
Execute a command in a running container
Aliases:
docker container exec, docker exec
Options:
-d, --detach               Detached mode: run command in the background
   --detach-keys string   Override the key sequence for detaching a container
-e, --env list             Set environment variables
   --env-file list        Read in a file of environment variables
-i, --interactive          Keep STDIN open even if not attached
   --privileged           Give extended privileges to the command
-t, --tty                  Allocate a pseudo-TTY
-u, --user string          Username or UID (format: "<name|uid>[:<group|gid>]")
-w, --workdir string       Working directory inside the container

1 Introduzca el contenedor. Ingrese al contenedor nginx que acabamos de crear

docker exec -it nginx bash

• Interpretación de comandos
  • docker exec: Ingrese dentro del contenedor y ejecute un comando
  • -it: Cree una terminal de entrada y salida estándar para el contenedor ingresado actualmente, lo que nos permitirá interactuar con el contenedor.
  • nginx: El nombre del contenedor a ingresar
  • bash: Comando ejecutado después de ingresar al contenedor.bash es un comando interactivo de terminal de Linux.

2 Ingrese al directorio donde se encuentra el HTML de nginx

• Se simulará un sistema de archivos Linux independiente dentro del contenedor, que parece un servidor Linux. El entorno, la configuración y los archivos de ejecución de nginx están todos en este sistema de archivos, incluido el archivo html que queremos modificar.
• Vea la página de nginx en el sitio web de DockerHub y podrá conocer la ubicación del directorio html de nginx./usr/share/nginx/html
• Ejecutamos el comando para ingresar al directorio

root@e34e51c88698:/# cd /usr/share/nginx/html
root@e34e51c88698:/usr/share/nginx/html# ls
50x.html  index.html

3 Modificar el contenido de index.html

• No hay un comando vi en el contenedor y no se puede modificar directamente, usamos el siguiente comando para modificarlo.

  sed -i -e 's#Welcome to nginx#Welcome To My Blog#g' index.html
  

resumen

• docker run¿Cuáles son los parámetros comunes de los comandos?
  • --name:Especifique el nombre del contenedor
  • -p:Especificar asignación de puertos
  • -d: Deje que el contenedor se ejecute en segundo plano.
• Comando para ver registros de contenedores
  • docker logs
  • Agregue -fparámetros para ver registros continuamente
• Ver el estado del contenedor:
  • docker ps
  • docker ps -aVer todos los contenedores, incluidos los detenidos

volumen de datos

• En el caso anterior de nginx, al modificar la página html de nginx, debe ingresar nginx. Y debido a que no hay un compilador, es muy problemático modificar archivos. Esta es la consecuencia del acoplamiento entre el contenedor y los datos (archivos en el contenedor). Si ejecutamos un nuevo contenedor nginx, entonces este nuevo contenedor nginx no puede ser Modificado directamente por nosotros. Buen archivo html con muchos defectos.
  1. Inconveniente de modificar: cuando queremos modificar el contenido html de nginx, debemos ingresar al contenedor para modificarlo, lo cual es muy inconveniente.
  2. Los datos no se pueden consumir: dado que las modificaciones dentro del contenedor no son visibles para el mundo exterior, no todas las modificaciones son reutilizables para los contenedores recién creados.
  3. Dificultad de actualización y mantenimiento: los datos están en el contenedor, si desea actualizar el contenedor, debe eliminar el contenedor anterior, y luego también se eliminarán todos los datos del contenedor anterior (incluida la página html modificada)
• Para resolver este problema, los datos y los contenedores deben desacoplarse, lo que requiere el uso de volúmenes de datos.

¿Qué es un volumen de datos?

• Un volumen de datos es un directorio virtual que apunta a un directorio en el sistema de archivos del host.

• Una vez montado el volumen de datos, todas las operaciones en el contenedor se aplicarán al directorio de host correspondiente. De esta manera, cuando operamos el directorio /var/lib/docker/volumes/html en el host, es equivalente a operar el directorio /usr/share/nginx/html en el contenedor.

Comandos de operación del conjunto de datos

• La sintaxis básica para operaciones de volumen de datos es la siguiente

  docker volume [COMMAND]
  

• El comando de volumen de Docker es una operación de volumen de datos y el siguiente paso se determina de acuerdo con el comando que sigue al comando

  • create:Crear un volumen
  • inspect: muestra información sobre uno o más volúmenes
  • ls: enumera todos los volúmenes
  • prune: Eliminar volúmenes no utilizados
  • rm: Eliminar uno o más volúmenes especificados

Crear y ver conjuntos de datos

Requisito: crear un volumen de datos y ver la ubicación del directorio del volumen de datos en el host

Crear volumen de datos

docker volume create html

ver todos los datos

docker volume ls

resultado

[root@lsc1 ~]# docker volume ls
DRIVER    VOLUME NAME
local     6a802c9f0640a63873103f2a4e3ee7a97388751bf2ab40a58aff549cb265e9fa
local     a8c27a88d4706628e2012de6f8e5bb5108e9f029936c800fccbda10ba8da59ff
local     html

Ver volumen de detalles del volumen de datos

docker volume inspect html

resultado

[root@localhost ~]# docker volume inspect html
[
    {
    
    
        "CreatedAt": "2022-12-19T12:51:54+08:00",
        "Driver": "local",
        "Labels": {
    
    },
        "Mountpoint": "/var/lib/docker/volumes/html/_data",
        "Name": "html",
        "Options": {
    
    },
        "Scope": "local"
    }
]

Puede ver que el directorio de host asociado con el volumen de datos html que creamos es

/var/lib/docker/volumes/html/_data

Caso numero uno

Requisito: crear un contenedor nginx y modificar el contenido htmldel directorio en el contenedorindex.html

• Análisis: En el último caso, ingresamos al contenedor nginx y ya conocíamos la ubicación del directorio html de nginx.Necesitamos /usr/share/nginx/htmlmontar este directorio en htmleste volumen de datos para facilitar la operación de su contenido.
• Consejo: al ejecutar el contenedor, utilice -vparámetros para montar el volumen de datos

1 Cree un contenedor y monte el volumen de datos en el directorio HTML del contenedor.

[root@lsc1 ~]# docker run --name nginx -v html:/usr/share/nginx/html -p 80:80 -d nginx
7d5098ba11e1e12cfe05cbe1a1e4a75789f25514bbea238b7b42b1b16c43af01

2Ingrese la ubicación del volumen de datos html y modifique el contenido HTML

# 查看数据卷位置
docker volume inspect html
# 进入该目录
cd /var/lib/docker/volumes/html/_data
# 修改文件
vi index.html
# 也可以在FinalShell中使用外部编译器（例如VSCode）来修改文件

Caso 2

• Los contenedores no solo pueden montar volúmenes de datos, sino que también se pueden montar directamente en el directorio del host, la relación es la siguiente
  • Con modo de volumen de datos: directorio de host -> volumen de datos -> directorio en el contenedor
  • Modo de montaje directo: directorio de host -> directorio de contenedor

Requisito: crear y ejecutar un contenedor MySQL, montar el directorio host directamente en el contenedor

• Extraiga una imagen MySQL de DockerHub

sudo docker pull mysql:5.7

• Crear un contenedor para ejecutar

docker run -p 3306:3306 --name mysql \
-v /mydata/mysql/log:/var/log/mysql \
-v /mydata/mysql/data:/var/lib/mysql \
-v /mydata/mysql/conf:/etc/mysql \
-e MYSQL_ROOT_PASSWORD=root \
-d mysql:5.7

• -p 3306:3306: asigna el puerto 3306 del contenedor al puerto 3306 del host
• -v /mydata/mysql/conf:/etc/mysql: monta la carpeta de configuración en el host /etc/mysql
• -v /mydata/mysql/log:/var/log/mysql: monta la carpeta de registro en el host /var/log/mysql:
• -v /mydata/mysql/data:/var/lib/mysql/: monta la carpeta de datos en el host /var/lib/mysql/:
• -e MYSQL_ROOT_PASSWORD=root: Inicializa la contraseña del usuario root

Imagen personalizada de Dockerfile

• Se pueden encontrar imágenes comunes en DockerHub, pero para los proyectos que escribimos nosotros mismos, debemos crear imágenes. Para personalizar la imagen, primero debe conectar la estructura de la imagen.

Estructura de espejo

• La imagen está empaquetada por la aplicación y sus bibliotecas de funciones del sistema, entorno, configuración y dependencias requeridas.
• Tomando MySQL como ejemplo, echemos un vistazo a su estructura reflejada.

• En pocas palabras, una imagen es un archivo formado agregando archivos de aplicación, archivos de configuración, archivos de dependencia, etc. sobre la base de la biblioteca de funciones del sistema y el entorno operativo, y luego escribiendo un script de inicio y empaquetándolos juntos.
• Cuando construimos una imagen, en realidad implementamos el proceso de empaquetado anterior.

Sintaxis del archivo Docker

• Al crear una imagen personalizada, no es necesario copiar ni empaquetar cada archivo.
• Solo necesitamos decirle a Docker la composición de nuestra imagen, qué BaseImage se necesita, qué archivos se deben copiar, qué dependencias se deben instalar y cuál es el script de inicio, Docker nos ayudará a construir la imagen en el futuro.
• El archivo Dockerfile describe la información anterior.
• Dockerfile es un archivo de texto que contiene instrucciones (Instructions). Las instrucciones se utilizan para describir qué operaciones se van a realizar para construir la imagen. Cada instrucción formará una capa.

instrucción	ilustrar	Ejemplo
DE	Especificar imagen base	DESDE centos:6
ENV	Establecer variables de entorno, que se pueden utilizar en instrucciones posteriores.	Valor clave ENV
COPIAR	Copie los archivos locales al directorio especificado de la imagen.	COPIAR ./mysql-5.7.rpm /tmp
CORRER	Ejecutar comandos de shell de Linux, generalmente comandos durante el proceso de instalación.	EJECUTAR yum instalar gcc
EXPONER	Especifique el puerto que escucha el contenedor cuando se ejecuta, que es para que lo vea el usuario de la imagen.	EXPONER 8080
PUNTO DE ENTRADA	El comando de inicio aplicado en la imagen, llamado cuando el contenedor se está ejecutando	PUNTO DE ENTRADAjava -jar xxjar

Construir proyecto Java

Construya un proyecto Java basado en Ubuntu

Requisitos: cree una nueva imagen basada en la imagen de Ubuntu y ejecute un proyecto Java

1. Crea una carpeta vacía docker-demo

   mkdir /tmp/docker-demo
   

2. Copie el archivo docker-demo.jar al directorio docker-demo

3. Copie el archivo jdk8.tar.gz al directorio docker-demo

4. Cree un nuevo Dockerfile en el directorio docker-demo y escriba el siguiente contenido

   # 指定基础镜像
   FROM ubuntu:16.04
   
   # 配置环境变量，JDK的安装目录
   ENV JAVA_DIR=/usr/local
   
   # 拷贝jdk的到JAVA_DIR目录下
   COPY ./jdk8.tar.gz $JAVA_DIR/
   
   # 安装JDK
   RUN cd $JAVA_DIR && tar -xf ./jdk8.tar.gz && mv ./jdk1.8.0_44 ./java8
   
   # 配置环境变量
   ENV JAVA_HOME=$JAVA_DIR/java8
   ENV PATH=$PATH:$JAVA_HOME/bin
   
   # 拷贝java项目的包到指定目录下，我这里是/tmp/app.jar
   COPY ./docker-demo.jar /tmp/app.jar
   
   # 暴露端口，注意这里是8090端口，如果你之前没有关闭防火墙，请关闭防火墙或打开对应端口，云服务器同理
   EXPOSE 8090
   
   # 入口，java项目的启动命令
   ENTERPOINT java -jar /tmp/app.jar
   

5. Usar en el directorio docker-demo

   docker build -t docker_demo:1.0 .
   

6. Utilice el comando Docker Images para ver la imagen.

   [root@localhost docker-demo]# docker images
   REPOSITORY    TAG       IMAGE ID       CREATED              SIZE
   docker_demo   1.0       c8acd2dd02cf   About a minute ago   722MB
   redis         latest    29ab4501eac3   2 days ago           117MB
   nginx         latest    3964ce7b8458   5 days ago           142MB
   ubuntu        16.04     b6f507652425   15 months ago        135MB
   mysql         5.7.25    98455b9624a9   3 years ago          372MB
   

7. Crear y ejecutar un contenedor docker_demo

   docker run --name testDemo -p 8090:8090 -d docker_demo:1.0
   

8. Visite http://192.168.128.130:8090/hello/count con el navegador y podrá ver el efecto de la página (tenga en cuenta que la IP de la máquina virtual está modificada)
   

Construya proyectos Java basados ​​en Java8

• Aunque podemos crear una imagen basada en la imagen base de Ubuntu y agregar los paquetes de instalación que necesitemos, es más problemático. Entonces, en la mayoría de los casos, podemos realizar modificaciones en algunas imágenes básicas con algún software instalado.
• El proyecto Java que acabamos de construir tiene un paso muerto fijo, que es instalar el JDK y configurar las variables de entorno. Necesitamos completar este paso cada vez que construimos la imagen del proyecto Java, para que podamos encontrar uno que ya esté instalado. el JDK. La imagen base, y luego construir la imagen de nuestro proyecto Java sobre la base de ella.

Requisitos: crear un proyecto Java como espejo basado en el espejo java:8-alpine

1. Cree un nuevo directorio vacío (o continúe usando /tmp/docker-demoun directorio)

2. Copie docker-demo.jar a este directorio (continúe usando el directorio ahora e ignórelo)

3. Cree un nuevo archivo en el directorio, asígnele el nombre Dockerfile y escriba el archivo (simplemente modifíquelo para que se parezca a lo siguiente)

   # 将openjdk:8作为基础镜像
   FROM openjdk:8
   # 拷贝java项目的包到指定目录下，我这里是/tmp/app.jar
   COPY ./docker-demo.jar /tmp/app.jar
   # 暴露端口
   EXPOSE 8090
   # 入口
   ENTRYPOINT java -jar /tmp/app.jar
   

4. construir imagen

   docker build -t docker_demo:2.0 .
   

   • Este último punto es muy importante.

5. Cree y ejecute un contenedor docker_demo (detenga el contenedor docker_demo anterior antes de hacer esto)

   docker run --name testDemo02 -p 8090:8090 -d docker_demo:2.0
   

6. Visite http://192.168.200.138:8090/hello/count con su navegador para ver el efecto de la página

resumen

1. Dockerfile es esencialmente un archivo que describe el proceso de creación de imágenes mediante instrucciones.
2. La primera línea de Dockerfile debe ser FROM para compilar a partir de una imagen base.
3. La imagen base puede ser un sistema operativo básico, como Ubunut, o una imagen creada por otros, como openjdk:8

Docker-Componer

• Docker Compose puede ayudarnos a implementar rápidamente proyectos distribuidos basados ​​en archivos Compose sin tener que crear y ejecutar contenedores manualmente uno por uno.
• En el desarrollo de proyectos empresariales reales, puede haber docenas de ellos.

Primera introducción a DockerCompose

• El archivo Compose es un archivo de texto que define cómo se ejecuta cada contenedor en el clúster a través de instrucciones. El formato es el siguiente

  version: "3.8"
    services:
      # docker run --name mysql \
      # -e MYSQL_ROOT_PASSWORD=root \
      # -p 3306:3306 \
     	 # -v /tmp/mysql/data:/var/lib/mysql \
      # -v /tmp/mysql/conf/myCnf.cf:/etc/mysql/conf.d/myCnf.cnf \	
      # -d \
      # mysql:5.7
      mysql:  # 对应docker run中的 --name
        image: mysql:5.7 # 对应docker run中最后声明的镜像
        enviroment:   # 对应docker run中的 -e MYSQL_ROOT_PASSWIRD=root
          MYSQL_ROOT_PASSWORD: root
        volumes: # 对应docker run中的 -v /tmp/mysql/data:/var/lib/mysql
          - "/tmp/mysql/data:/var/lib/mysql"
          - "/tmp/mysql/conf/myCnf.cf:/etc/mysql/conf.d/myCnf.cnf"
      # 这里并不需要-d参数来后台运行，因为此种方法默认就是后台运行
      # 同时也不需要暴露端口，在微服务集群部署中，MySQL仅仅是供给给集群内的服务使用的，所以不需要对外暴露端口
  
      # 临时构建镜像并运行，下面的配置文件包含了docker build和docker run两个步骤
      # docker build -t web:1.0 .
      # docker run --name web -p 8090:8090 -d web:1.0
      web:
        build: .
        ports:
          - "8090:8090"
  

• El archivo Compose anterior describe un proyecto, que contiene dos contenedores:

  • mysql: Un contenedor construido en base a la imagen mysql:5.7 y montado con dos proyectos
  • web: Un docker buildcontenedor de imágenes basado en una compilación temporal, el puerto asignado es8090

• Para obtener una sintaxis detallada de DockerCompose, consulte el sitio web oficial: https://docs.docker.com/compose/compose-file/

• De hecho, se puede considerar que el archivo DockerCompose escribe varios comandos de ejecución de Docker en un archivo, pero la sintaxis es ligeramente diferente.

Instalar DockerCompose

• Descargar usando el comando en Linux

  # 安装
  curl -L https://github.com/docker/compose/releases/download/1.23.1/docker-compose-`uname -s`-`uname -m` > /usr/local/bin/docker-compose
  

• Modificar permisos de archivos

  chmod +x /usr/local/bin/docker-compose
  

• Comando de autocompletar básico

  curl -L https://raw.githubusercontent.com/docker/compose/1.29.1/contrib/completion/bash/docker-compose > /etc/bash_completion.d/docker-compose
  

  Si ocurre un error, debe modificar su archivo de hosts.

  Failed connect to raw.githubusercontent.com:443; Connection refused
  

  echo "199.232.68.133 raw.githubusercontent.com" >> /etc/hosts
  

  Si ocurre un nuevo error, repita el comando e inténtelo varias veces más.

  TCP connection reset by peer
  

Implementar un clúster de microservicios

Requisito: implementar el clúster de microservicios de demostración en la nube aprendido previamente mediante DockerCompose

• Ideas de implementación
  1. Escribir archivo de composición acoplable
  2. Modifique su proyecto de demostración en la nube y cambie el nombre de la base de datos y la dirección de nacos al nombre del servicio en docker-compose
  3. Utilice la herramienta de empaquetado maven para empaquetar cada microservicio en el proyecto como app.jar (el nombre del paquete puede ser coherente con el Dockerfile)
  4. Copie el app.jar empaquetado en cada subdirectorio correspondiente en la demostración en la nube y escriba el Dockerfile
  5. Cargue la demostración de la nube en la máquina virtual y úsela docker-compose up -dpara implementar

componer archivo

• Escriba el archivo docker-compose correspondiente para la demostración en la nube que escribimos antes

  version: "3.2"
  services:
    nacos:
      image: nacos/nacos-server
      environment:
        MDOE: standalone
      ports:
        - "8848:8848"
      mysql:
        image: mysql:5.7
        environment:
          MYSQL_ROOT_PASSWORD: 123456
        volumes:
          - "$PWD/mysql/data:/var/lib/mysql"  # 这里的$PWD是执行linux命令，获取当前目录
          - "$PWD/mysql/conf:/etc/mysql/conf.d"
      userservice:
        build: ./user-service
      orderservice:
        build: ./order-service
      gateway:
        build: ./gateway
        poets:
          - "10010:10010"
  

• Contiene 5 servicios:

  1. nacos: como centro de registro y centro de configuración
     • imagen: nacos/nacos-server: compilación basada en la imagen de nacos/nacos-server
     • entorno: variables de entorno
       • MODO: independiente: inicio en modo independiente
     • puertos: mapeo de puertos, el puerto 8848 se expone aquí
  2. mysql: base de datos
     • imagen: mysql5.7: Construido en base a la imagen de MySQL de la versión 5.7
     • entorno: variables de entorno
       • MYSQL_ROOT_PASSWORD: 123456: establezca la contraseña de la cuenta raíz de la base de datos en 123456
     • Volúmenes: Montaje del volumen de datos, aquí se montan los directorios data y conf de mysql.
  3. servicio de usuario: construido temporalmente en base a Dockerfile, el servicio de usuario no necesita exponer el puerto, la puerta de enlace es la entrada al microservicio. Si el puerto del servicio de usuario está expuesto, la autenticación de identidad y la verificación de permisos de la puerta de enlace serán en vano.
  4. orderservice: construido temporalmente en base a Dockerfile, no es necesario exponer el puerto, el motivo es el mismo que el anterior
  5. puerta de enlace: construida temporalmente en base a Dockerfile. La puerta de enlace necesita exponer el puerto. Es la entrada a otros microservicios.

Modificar la configuración del microservicio

• Al implementar usando Docker Compose, todos los servicios pueden acceder entre sí usando nombres de servicio. Entonces ahora necesitamos modificar el archivo de configuración yml en nuestra demostración en la nube, de la siguiente manera

  • arranque.yml
  • aplicación.yml

  spring:
    cloud:
      nacos:
        # server-addr: localhost:80 #Nacos地址
        server-addr: nacos:8848 # 使用compose中的服务名来互相访问，用nacos替换localhost
        config:
          file-extension: yaml # 文件后缀名
  

Embalar

• Empaquete nuestro código modificado, preste atención para modificar el archivo pom para especificar la aplicación del nombre del paquete

  <build>
      <!-- 服务打包的最终名称 -->
      <finalName>app</finalName>
      <plugins>
          <plugin>
              <groupId>org.springframework.boot</groupId>
              <artifactId>spring-boot-maven-plugin</artifactId>
          </plugin>
      </plugins>
  </build>
  

• Luego use la herramienta maven para empaquetar

• La estructura final del directorio es la siguiente.

  • demostración en la nube
    • puerta
      • aplicación.jar
      • Dockerfile.yml
    • servicio de pedidos
      • aplicación.jar
      • Dockerfile.yml
    • servicio de usuario
      • aplicación.jar
      • Dockerfile.yml
    • MySQL
      • datos
      • confinar
    • docker-compose.yml

desplegar

• Cargue la demostración de la nube en la máquina virtual, ingrese al directorio y ejecute el siguiente comando

  docker-compose up -d
  

• Verifique el registro después del inicio, encontrará un error en el registro

  com.alibaba.nacos.api.exception.NacosException: failed to req API:/nacos/v1/ns/instance/list after all servers([nacos:8848]) tried: java.net.ConnectException: Connection refused (Connection refused)
  

  docker-compose logs -f
  

  La conexión de Alibaba nacos falló. La razón es que el servicio de usuario se inició antes que nacos, y los nacos comenzaron demasiado lento. El registro del servicio de usuario falló y no hay un mecanismo de reintento (espere a que nacos se inicie y vuelva a intentar el registro para evitar este problema)

• Por lo tanto, se recomienda iniciar nacos solo primero y luego iniciar otros servicios. Mi solución aquí es reiniciar los otros tres servicios.

• Reiniciar el servicio de servicio de pedidos del servicio de usuario de la puerta de enlace

  docker-compose restart gateway userservice orderserivce 
  

• Verifique el registro de inicio del servicio de usuario, esta vez no se informará ningún error

  docker-compose logs -f userservice
  

• Abra el navegador y visite http://192.168.128.130:10010/user/1?authorization=admin, también puede ver los datos