Microservicios de Dark Horse: notas de estudio de la tecnología de contenedores Docker

News 2023-04-09 02:37:17 views: null

escribe primero

Conociendo Docker

¿Qué es Docker?

  • Los microservicios parecen tener varias ventajas, pero la división de los servicios generalmente trae muchos problemas para la implementación.
    • En un sistema distribuido, hay muchos componentes dependientes, y cuando se implementa entre diferentes componentes, a menudo ocurren algunos conflictos.
    • Implementación repetida en cientos o miles de servicios, el entorno no es necesariamente consistente y se encontrarán varios problemas

Problemas ambientales para la implementación de aplicaciones

  • Hay muchos componentes en proyectos a gran escala, y el entorno operativo también es relativamente complejo.Se encontrarán algunos problemas durante la implementación.
    • Las dependencias son complejas y propensas a problemas de compatibilidad.
    • Los entornos de desarrollo, prueba 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 requeridas para la implementación de estos servicios son diferentes y habrá conflictos en la auditoría, que trae grandes dificultades al despliegue dificultad

Docker resuelve problemas de compatibilidad de dependencias

  • Y Docker ha resuelto estos problemas de manera ingeniosa, entonces, ¿cómo lo logra Docker?

  • Para resolver el problema de compatibilidad de las dependencias, Docker adopta dos métodos

    1. Empaquete la biblioteca de funciones de la aplicación (libs), las dependencias (Deps), la configuración y la aplicación juntas
    2. Ejecute cada aplicación de forma aislada 容器para evitar interferencias mutuas

  • Una aplicación empaquetada de este tipo incluye no solo la aplicación en sí, sino también la biblioteca de funciones y las dependencias que necesita la aplicación. Si se instalan en el sistema operativo fuera de servicio, naturalmente no habrá problemas de compatibilidad entre las diferentes aplicaciones.

  • Aunque se ha solucionado el problema de compatibilidad de diferentes aplicaciones, habrá diferencias en el desarrollo, pruebas y otros enlaces, así como diferencias en las versiones del sistema operativo ¿Cómo solucionar estos problemas?

Docker resuelve las diferencias del entorno del sistema operativo

  • Para resolver el problema de las diferencias en el entorno de 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 paquetes que contienen datos son instrucciones del núcleo, que son más convenientes 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 para operar el hardware de la computadora.
    • Hardware informático: como CPU, memoria, disco, etc.

  • El proceso aplicado a la interacción informática es el siguiente

    1. La aplicación llama a la aplicación del sistema operativo (biblioteca de funciones) para realizar varias funciones
    2. La biblioteca de funciones del sistema es la encapsulación del conjunto de instrucciones del núcleo, que llamará a la instrucción del núcleo
    3. Las instrucciones del núcleo 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 instala una versión de Ubuntu de la aplicación MySQL en el sistema CentOS, cuando MySQL llame a la biblioteca de funciones de Ubuntu, encontrará que no puede encontrar o no coincide, e informará un error.

  • ¿Cómo resuelve Docker los problemas de los diferentes entornos del sistema?

    • Docker empaqueta la biblioteca de funciones del sistema (como Ubuntu) requerida por el programa del 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 soluciona Docker los problemas de compatibilidad de dependencias complejas y dependencias de diferentes componentes en proyectos a gran escala?
    • Docker permite que las aplicaciones, las dependencias, las bibliotecas de funciones y las configuraciones 打包formen una imagen portátil durante el desarrollo
    • Las aplicaciones de Docker se ejecutan en contenedores, usan el mecanismo de sandbox e interactúan entre sí隔离
  • ¿Cómo resuelve Docker el problema de las diferencias en los entornos de desarrollo, prueba y producción?
    • La escena Docker contiene un entorno operativo completo, incluida la biblioteca 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, con las siguientes ventajas
    1. El programa, sus dependencias y el entorno operativo se pueden empaquetar en una imagen espejo, que se puede migrar a cualquier sistema operativo Linux.
    2. El mecanismo de sandbox se usa para formar un contenedor aislado durante el tiempo de ejecución, y cada aplicación no interfiere entre sí.
    3. Tanto el inicio como la eliminación se pueden completar con una línea de comandos, lo cual es conveniente y rápido

Diferencia entre Docker y máquina virtual

  • Docker puede hacer que una aplicación se ejecute en cualquier sistema operativo de manera muy conveniente, y la máquina virtual que hemos tocado 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 (virtual machine) es un dispositivo de hardware en un sistema operativo 模拟, y luego ejecuta otro sistema operativo. Por ejemplo, si ejecuta el sistema CentOS en el sistema Windows, puede ejecutar cualquier aplicación CentOS
    • Docker solo encapsula la biblioteca de funciones y no simula un sistema operativo completo
    • A diferencia de
característica Estibador máquina virtual
actuación cerca de nativo bajo rendimiento
uso del disco duro Por lo general MB Generalmente GB
puesta en marcha segundo nivel nivel de minutos
  • Resumen: diferencias 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 velocidad de inicio y buen rendimiento; la máquina virtual es grande en tamaño, lenta en velocidad de inicio y tiene 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, la biblioteca de funciones, el entorno, la configuración y otros archivos juntos, lo que se denomina imagen espejo.
    • 容器(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 es invisible para el mundo exterior.
  • Todas las aplicaciones están compuestas en última instancia por 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 se empaqueta junto con 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 o contamine el archivo de imagen, lo que hace que la imagen no esté disponible, el contenedor copia un archivo de la imagen en su propio espacio para escribir datos)
  • Y 容器es cargar los programas y funciones escritos en estos archivos en la memoria para permitir la formación de procesos, pero necesitan estar aislados. Por lo tanto, una imagen se puede iniciar varias veces para formar varios procesos de contenedores.

DockerHub

  • Hay muchas aplicaciones de código abierto y empaquetar estas aplicaciones suele ser un trabajo repetitivo. Para evitar este trabajo repetitivo, las personas colocan sus propias imágenes de aplicaciones empaquetadas, como imágenes de Redis y MySQL, en Internet para uso compartido, simplemente como compartir código de GitHub Igual

  • Por un lado, podemos compartir nuestra propia imagen en DockerHub, por otro lado, también podemos extraer la imagen de DockerHub

Arquitectura acoplable

  • Si queremos usar Docker para operar imágenes y contenedores, debemos instalar Docker
  • Docker es un programa de arquitectura CS, que consta de dos partes
    • Server (servidor): proceso daemon de Docker, encargado de procesar las instrucciones de Docker, administrar 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

resumen

  • 镜像：
    • Empaquete la aplicación junto con sus dependencias, entorno y configuración
  • 容器：
    • La imagen se ejecuta como un contenedor y una imagen puede ejecutar varios contenedores
  • Docker结构：
    • Servidor: acepte comandos o solicitudes remotas, opere imágenes o contenedores
    • Cliente: envía comandos o solicitudes al servidor Docker
  • DockerHub：
    • Un servidor de alojamiento espejo, similar al servicio espejo de Alibaba Cloud, denominado colectivamente como DockerRegistry

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 stable testen nightlytres canales de actualización y .

  • Hay guías de instalación 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
    {% note warning no-icon %}
    CentOS 7 cumple con los requisitos mínimos del kernel. Este artículo también instala Docker en CentOS 7
    {% endnote % }

desinstalar (opcional)

  • Si ha instalado una versión anterior de Docker anteriormente, puede usar el siguiente comando para desinstalarlo
yum remove docker \
                  docker-client \
                  docker-client-latest \
                  docker-common \
                  docker-latest \
                  docker-latest-logrotate \
                  docker-logrotate \
                  docker-selinux \
                  docker-engine-selinux \
                  docker-engine \
                  docker-ce

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
# 设置Docker镜像源
yum-config-manager \
    --add-repo \
    https://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo
    
sed -i 's/download.docker.com/mirrors.aliyun.com\/docker-ce/g' /etc/yum.repos.d/docker-ce.repo

yum makecache fast
  • Luego instale la versión comunitaria de Docker
yum install -y docker-ce

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
  • Inicie Docker por comando
# 启动docker服务
systemctl start docker 

# 停止docker服务
systemctl stop docker

# 重启docker服务
systemctl restart docker
  • Luego ingrese el comando para ver la versión de la ventana acoplable
docker -v

resultado

[root@localhost ~]# docker -v
Docker version 20.10.21, build baeda1f

Configuración de la aceleración de duplicación

  • La velocidad de la red de la biblioteca espejo oficial de Docker es baja. Se recomienda configurarlo como un servicio espejo doméstico. Consulte el documento de aceleración espejo de Alibaba Cloud: https://cr.console.aliyun.com/cn-hangzhou/instances/mirrors

Funcionamiento básico de Docker

imagen de espejo

nombre del espejo

  • Primero mire la composición del nombre de la imagen:
    • El nombre de la imagen generalmente se divide en dos partes: [repositorio]:[etiqueta]
      {% note info no-icon %}
      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 el Versión 5.7 de la imagen de MySQL
      { % endnote %}
    • Cuando no se especifica ninguna etiqueta, el valor predeterminado es más reciente, que representa la última versión de la imagen, por ejemplomysql:latest

comando de espejo

  • Los comandos comunes de duplicación se muestran en la siguiente figura

Caso número uno

  • En este caso, pongámonos en contacto y verifiquemos la imagen
    {% note info no-icon %}
    Requisitos: extraiga una imagen Nginx de DockerHub y visualice
    {% endnote %}

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

  2. De acuerdo con el nombre de la imagen vista, extraiga la imagen que necesita y use el comando: docker pull nginxextraiga la última imagen de nginx

[root@localhost ~]# docker pull nginx
Using default tag: latest
latest: Pulling from library/nginx
025c56f98b67: Pull complete 
ec0f5d052824: Pull complete 
cc9fb8360807: Pull complete 
defc9ba04d7c: Pull complete 
885556963dad: Pull complete 
f12443e5c9f7: Pull complete 
Digest: sha256:75263be7e5846fc69cb6c42553ff9c93d653d769b94917dbda71d42d3f3c00d3
Status: Downloaded newer image for nginx:latest
docker.io/library/nginx:latest

Desde el registro, también podemos ver que si no se agrega ninguna etiqueta, se usa la última predeterminada, es decir, se extrae la última imagen de la ventana acoplable

  1. docker imagesVer la imagen tirada por comando
[root@localhost ~]# docker images
REPOSITORY   TAG       IMAGE ID       CREATED      SIZE
nginx        latest    3964ce7b8458   4 days ago   142MB

caso dos

  • En este caso, debemos guardar e importar la imagen
    {% note info no-icon %}
    : use docker savela imagen nginx para exportar el disco y luego vuelva docker loada cargarla a través de
    {% endnote %}
  1. Use docker xx --helpel comando para ver docker savey docker loadsintaxis
    {% note info no-icon %}
  • Entrada docker save --help, el resultado es el siguiente
[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 [保存的目标文件名称] [镜像名称]
  • Entrada docker load --help, el resultado es el siguiente
[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 [镜像压缩文件名]

{% nota final %}

  1. 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
  1. Use docker load para cargar la imagen, antes de eso, usamos el comando para eliminar la imagen nginx local
docker rmi nginx:latest # rmi是remove image的缩写

Luego ejecute el comando para cargar el archivo local

docker load -i nginx.tar

práctica

{% note info no-icon %}
Requisito: vaya a DockerHub para buscar y extraer una imagen de Redis

  1. Vaya a DockerHub para buscar la imagen de Redis
  2. Ver el nombre y la versión de la imagen de Redis
  3. Usa docker pullel comando para tirar de la imagen.
  4. Use docker saveel comando para redis:latestempaquetarlo en un redis.tarpaquete
  5. docker rmielimine el local usandoredis:latest
  6. Utilizar el archivo docker loadde recarga {% endnote %}redis.tar

operaciones de contenedores

Comandos relacionados con contenedores

  • El comando de operación del contenedor se muestra en la figura.

  • Tres estados de protección del contenedor

    • en ejecución: el proceso se está ejecutando normalmente
    • Suspendido: el proceso está suspendido, la CPU ya no se ejecuta y la memoria no se libera
    • Detener: se termina el proceso y se recuperan la memoria, la CPU y otros recursos ocupados por el proceso
      {% note info no-icon %}

  • Los sistemas operativos suspendidos y detenidos se manejan de manera diferente. Suspendido significa que el sistema operativo suspende el proceso en el contenedor, almacena temporalmente la memoria asociada con el contenedor y luego la CPU ya no ejecuta el proceso, sino que reanuda con el comando, el espacio de memoria se restaura y el unpauseprograma sigue ejecutándose.

  • Detener es matar directamente el proceso, recuperar la memoria ocupada por el contenedor y guardar solo el sistema de archivos del contenedor, es decir, esos recursos estáticos.

  • docker rmEl sistema de archivos también se elimina por completo, es decir, el contenedor se elimina por completo
    {% endnote %}

  • docker run: Crear y ejecutar un contenedor, en estado de ejecución

  • docker pause: pausa 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 vuelva a ejecutarse

  • docker rm: eliminar un contenedor

Caso número 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 llamado myNginx
    • -p: asigne el puerto de host al puerto de contenedor, el lado izquierdo de los dos puntos es el puerto de host y el lado derecho es el puerto de 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

  • Por defecto el contenedor es un entorno aislado, si accedemos directamente al puerto 80 del host, no debemos poder acceder a nginx en el contenedor.

  • Ahora, el puerto 80 del contenedor está asociado con el puerto 80 del host. Cuando accedemos al puerto 80 del host, se asignará al puerto 80 del contenedor, para que podamos acceder a nginx

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

caso dos

{% note info no-icon %}
Requisito: ingrese el contenedor Nginx, modifique el contenido del archivo HTML y agregue Welcome To My Blog！
una pista: necesita usar docker execcomandos para ingresar al contenedor

[root@localhost ~]# docker exec --help

Usage:  docker exec [OPTIONS] CONTAINER COMMAND [ARG...]

Run a command in a running container

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

{% nota final %}

  1. en el contenedor. Ingrese el contenedor nginx que acabamos de crear
docker exec -it myNginx bash
  • interpretación de comandos
    • docker exec: Ingrese al contenedor y ejecute un comando
    • -it: Crear un terminal de entrada y salida estándar para el contenedor actualmente ingresado, permitiéndonos interactuar con el contenedor
    • myNginx: el nombre del contenedor a ingresar
    • bash: El comando ejecutado después de ingresar al contenedor, bash es un comando interactivo de terminal de Linux

  1. Ingrese el directorio donde se encuentra el HTML de nginx

    • Dentro del contenedor, se simulará un sistema de archivos Linux independiente, que parece un servidor Linux. El entorno, la configuración y los archivos en 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, puede saber que el directorio html de nginx se encuentra en/usr/share/nginx/html
    • Ejecutamos el comando para entrar al directorio
    cd /usr/share/nginx/html

    Ver los archivos en el directorio.

    root@310016c9b413:/usr/share/nginx/html# ls
50x.html  index.html

  2. 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 modificar
    sed -i -e 's#Welcome to nginx#Welcome To My Blog#g' index.html

  3. Visite su propia máquina virtual ip: 80 en el navegador, puede ver el resultado (el puerto 80 no se puede escribir)

resumen

  • docker run¿Cuáles son los parámetros comunes del comando?

    • --name: especifique el nombre del contenedor
    • -p: Especifique la asignación de puertos
    • -d: Deje que el contenedor se ejecute en segundo plano

  • Comandos 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

{% note info no-icon %}
¿Cree que es problemático modificar el archivo ahora, porque no se proporciona el comando vi y no puede editarlo directamente, por lo que usará el volumen de datos que mencionamos a continuación{%
endnote %}

volumen de datos

  • En el caso anterior de nginx, al modificar la página html de nginx, debe ingresar el interior de nginx. Y debido a que no hay un compilador, es muy problemático modificar el archivo. 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 usado directamente buen archivo html con muchos defectos
    1. Inconveniente de modificar: Cuando queremos modificar el contenido html de nginx, necesitamos ingresar al contenedor para modificarlo, lo cual es muy inconveniente
    2. Los datos no se pueden usar: dado que la modificación en el contenedor no es visible para el mundo exterior, todas las modificaciones no son reutilizables para el contenedor recién creado
    3. Difícil de actualizar y mantener: los datos están en el contenedor. Si desea actualizar el contenedor, debe eliminar el contenedor anterior, luego todos los datos en el contenedor anterior también se eliminarán (incluida la página html modificada)
  • Para resolver este problema, los datos y el contenedor deben estar desacoplados, lo que requiere el uso de volúmenes de datos.

¿Qué es un volumen de datos?

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

  • Una vez que se monta el volumen de datos, todas las operaciones en el contenedor se aplicarán al directorio de host correspondiente. De esta forma, operamos el directorio /var/lib/docker/volumes/html de la máquina host, lo que equivale a operar el directorio /usr/share/nginx/html en el contenedor.

Comandos de manipulación de conjuntos de datos

  • La sintaxis básica para las operaciones de volumen de datos es la siguiente
docker volume [COMMAND]
  • docker volumecommandEl comando es una operación de volumen de datos, y el siguiente paso se determina de acuerdo con el siguiente comando
    • create: crear un volumen
    • inspect: Mostrar información sobre uno o más volúmenes
    • ls: enumerar todos los volúmenes
    • prune: eliminar el volumen no utilizado
    • rm: Eliminar uno o más volúmenes especificados

Crear y ver conjuntos de datos

{% note info no-icon %}
Requisito: crear un volumen de datos y ver la ubicación del directorio del volumen de datos en la máquina host
{% endnote %}

  1. Crear volumen de datos
docker volume create html
  1. ver todos los datos
docker volume ls

resultado

[root@localhost ~]# docker volume ls
DRIVER    VOLUME NAME
local     html
  1. Ver detalles del volumen de datos volumen
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

  • resumen:
    • El papel de los volúmenes de datos
      • Separe y desacople el contenedor de los datos, facilite la operación de los datos en el contenedor y garantice la seguridad de los datos
    • Operaciones de volumen de datos:
      • docker volume create: crear volumen de datos
      • docker volume ls: Ver todos los volúmenes de datos
      • docker volume inspect: vea los detalles del volumen de datos, incluida la ubicación del directorio de host asociado
      • docker volume rm: elimina el volumen de datos especificado
      • rocker volume prune: Eliminar todos los volúmenes de datos no utilizados

montar volumen de datos

  • Cuando creamos un contenedor, podemos usar el parámetro -v para montar un volumen de datos en un directorio en un contenedor.El formato del comando es el siguiente
docker run \
    -- name myNginx \
    -v html:/root/html \
    -p 8080:80 \
    nginx \
  • El -v aquí es el comando para montar el volumen de datos
    • -v html:/root/html: monte el volumen de datos html en el directorio /root/html en el contenedor

Caso número uno

{% note info no-icon %}
Requisito: Crear un contenedor nginx y modificar el contenido htmldel directorio en el contenedor Análisis: En el caso anterior, ingresamos al contenedor nginx y ya sabíamos la ubicación del directorio nginx html . para poner esto El directorio está montado en este volumen de datos para facilitar la manipulación de su contenido Sugerencia: cuando ejecute el contenedor, use el parámetro para montar el volumen de datos {% endnote %}index.html
/usr/share/nginx/htmlhtml
-v

  1. Cree un contenedor y monte el volumen de datos en el directorio HTML del contenedor.
docker run --name myNginx -v html:/usr/share/nginx/html -p 80:80 -d nginx
  1. Ingrese 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 dos

  • Los contenedores no solo pueden montar volúmenes de datos, sino también montarlos directamente en el directorio del host, la relación es la siguiente

    • Con el modo de volumen de datos: directorio de host --> volumen de datos --> directorio contenedor
    • Modo de montaje directo: directorio de host --> directorio de contenedor

  • La sintaxis de montaje de directorio y montaje de volumen de datos es similar

    • -v [directorio host]:[directorio contenedor]
    • -v [archivo host]:[archivo en contenedor]

{% note info no-icon %}
Requisito: cree y ejecute un contenedor MySQL, monte el directorio host directamente en el contenedor
{% endnote %}

  1. Extraiga una imagen MySQL de DockerHub
docker pull mysql
  1. crear un directorio/tmp/mysql/data
mkdir -p /tmp/mysql/data
  1. Crea un directorio /tmp/mysql/confy myCnf.cnfsube el archivo a /tmp/mysql/conf
    {% tabs upload cfg file%}
mkdir -p /tmp/mysql/conf

[mysqld]
skip-name-resolve
character_set_server=utf8
datadir=/var/lib/mysql
server-id=1000

{% endtabs %}
4. Vaya a DockerHub para verificar la información y busque la ubicación del directorio conf y el directorio de datos en el contenedor mysql. La ubicación del
directorio conf en el contenedor es: /etc/mysql/conf.d
el directorio donde se almacenan los datos en el contenedor es: /var/lib/mysql
5. Cree y ejecute el contenedor MySQL, que requiere
- Monte /tmp/mysql/data en el directorio de almacenamiento de datos en el contenedor mysql
- Monte /tmp/mysql/conf/myCnf.cnf en el archivo de configuración de el contenedor mysql
: configure la contraseña de MySQL
BASH docker run \ --name mysql \ -e MYSQL_ROOT_PASSWORD=root \ -v /tmp/mysql/conf:/etc/mysql/conf.d \ -v /tmp/mysql/data:/var/lib/mysql \ -p 3306:3306 \ -d \ mysql
6. Intente usar Navicat para conectarse a la base de datos, preste atención a su propia configuración de contraseña para

resumen

  • docker runEn el comando, el archivo o directorio se monta en el contenedor a través del parámetro -v

    • -v [volume名称]:[容器内目录]
    • -v [宿主机文件]:[容器内文件]
    • -v [宿主机目录]:[容器内目录]

  • La diferencia entre el montaje de volumen de datos y el montaje de directorio directo

    • El grado de acoplamiento del montaje del volumen de datos es bajo y el directorio está administrado por docker, pero el directorio es profundo y difícil de encontrar
    • El grado de acoplamiento del montaje de directorios es alto, necesitamos administrar el directorio nosotros mismos, pero el directorio es fácil de encontrar y ver

Imagen personalizada de Dockerfile

  • Las imágenes comunes se pueden encontrar en DockerHub, pero debemos crear imágenes para proyectos escritos por nosotros mismos. Para personalizar el espejo, primero debe conectar la estructura del espejo.

estructura de espejo

  • La duplicación es un paquete de aplicaciones y sus bibliotecas de funciones del sistema, entornos, configuraciones y dependencias requeridas.

  • Tome MySQL como ejemplo para ver su estructura de composición espejo

  • En pocas palabras, la duplicación es un archivo formado al agregar archivos de aplicación, archivos de configuración, archivos dependientes, etc. en función de la biblioteca de funciones del sistema y el entorno operativo, y luego escribir un script de inicio y empaquetarlos juntos.

  • Queremos construir una imagen especular, que es en realidad el proceso de realización del empaque anterior.

Sintaxis del archivo acoplable

  • Al crear una imagen personalizada, no es necesario copiar y empaquetar cada archivo.
  • Solo necesitamos decirle a Docker la composición de nuestra imagen, qué BaseImages se necesitan, qué archivos se deben copiar, qué dependencias se deben instalar y cuál es el script de inicio. En el futuro, Docker nos ayudará a crear imágenes.
  • El que describe la información anterior es el Dockerfile.
  • Un Dockerfile es un archivo de texto que contiene instrucciones (Instrucciones), que se utilizan para describir qué operaciones realizar para crear una imagen reflejada, y cada instrucción formará una capa de Capa.
instrucción ilustrar ejemplo
DE Especificar la imagen base DESDE centos:6
ENV Establecer variables de entorno, que se pueden utilizar en instrucciones posteriores valor clave ENV
COPIAR Copie el archivo local en el directorio especificado del espejo COPIAR ./mysql-5.7.rpm /tmp
CORRER Ejecute el comando de shell de Linux, generalmente el comando del 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

Cree un proyecto Java basado en Ubuntu

{% note info no-icon %}
Requisito: cree una nueva imagen basada en la imagen de Ubuntu y ejecute un proyecto Java
{% endnote %}

  1. Crear una carpeta vacía docker-demo
mkdir /tmp/docker-demo
  1. Copie el archivo docker-demo.jar en el directorio docker-demo
  2. Copie el archivo jdk8.tar.gz en el directorio docker-demo
  3. 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
  1. docker buildUse el comando para construir la imagen en el directorio docker-demo
docker build -t docker_demo:1.0 .
  1. Use el comando de imágenes acoplables 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
  1. Crear y ejecutar un contenedor docker_demo
docker run --name testDemo -p 8090:8090 -d docker_demo:1.0
  1. 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 se modifica)

Cree proyectos Java basados ​​en Java8

  • Aunque podemos agregar cualquier paquete de instalación que necesitemos para construir la imagen basada en la imagen base de Ubuntu, es engorroso. Entonces, en la mayoría de los casos, podemos modificar 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 un JDK que ya haya sido instalado La imagen base, y luego construir la imagen de nuestro proyecto Java sobre la base de ella

{% note info no-icon %}
Requisito: basado en la imagen java:8-alpine, cree un proyecto Java como una imagen
{% endnote %}

  1. Cree un nuevo directorio vacío (o continúe usando /tmp/docker-demoun directorio)
  2. Copie docker-demo.jar a este directorio (no se preocupe por continuar usando el directorio ahora)
  3. Cree un nuevo archivo en el directorio, asígnele el nombre Dockerfile y escriba el archivo (modifíquelo de la siguiente manera)
# 将openjdk:8作为基础镜像
FROM openjdk:8
# 拷贝java项目的包到指定目录下，我这里是/tmp/app.jar
COPY ./docker-demo.jar /tmp/app.jar
# 暴露端口
EXPOSE 8090
# 入口
ENTRYPOINT java -jar /tmp/app.jar
  1. construir imagen
docker build -t docker_demo:2.0 .
  1. 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
  1. Acceda al navegador http://192.168.128.130:8090/hello/count, puede ver el efecto de página

resumen

  1. Dockerfile es esencialmente un archivo que describe el proceso de construcción de la imagen a través de instrucciones
  2. La primera línea del Dockerfile debe ser DESDE para compilar a partir de una imagen base
  3. La imagen básica puede ser el sistema operativo básico, como Ubunut, o una buena imagen hecha por otros, como openjdk:8

Docker-Componer

  • Docker Compose puede ayudarnos a implementar rápidamente el inglés distribuido basado en archivos de Compose sin crear y ejecutar manualmente contenedores uno por uno
  • En el desarrollo de proyectos empresariales reales, puede haber docenas de

Conociendo Docker Compose por primera vez

  • El archivo Compose es un archivo de texto que define cómo se ejecuta cada contenedor en el clúster a través de las 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.25
    mysql:  # 对应docker run中的 --name
      image: mysql:5.7.25 # 对应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 mysql:5.7.25contenedor construido a partir de la imagen y montado con dos proyectos
    • web: un docker buildcontenedor de imágenes construido ad-hoc con puerto asignado a8090
  • Para obtener la 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 Docker Compose

  • Use el comando para descargar bajo 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 base de autocompletado
curl -L https://raw.githubusercontent.com/docker/compose/1.29.1/contrib/completion/bash/docker-compose > /etc/bash_completion.d/docker-compose

Si se produce un error Failed connect to raw.githubusercontent.com:443; Connection refused, debe modificar su propio archivo de hosts

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

Si ocurre un nuevo error TCP connection reset by peer, repita el comando e intente varias veces

Implementar un clúster de microservicios

{% note info no-icon %}
Requisito: implemente el clúster de microservicios de demostración en la nube que aprendió anteriormente mediante DockerCompose
{% endnote %}

  • Ideas de implementación
    1. Escribir archivo docker-compose
    2. Modifique su propio proyecto de demostración en la nube, cambie el nombre de la base de datos y la dirección de nacos al nombre del servicio en docker-compose
    3. Use la herramienta de empaquetado maven para empaquetar cada microservicio en el proyecto como app.jar (el nombre del paquete debe ser el mismo que en el Dockerfile)
    4. Copie el app.jar empaquetado en cada subdirectorio correspondiente en cloud-demo y escriba el Dockerfile
    5. Cargue la demostración en la nube en la máquina virtual y utilícela docker-compose up -dpara implementar

redactar archivo

  • Para la demostración en la nube que escribimos antes, escriba el archivo docker-compose correspondiente
version: "3.2"

services:
  nacos:
    image: nacos/nacos-server
    environment:
      MDOE: standalone
    ports:
      - "8848:8848"
    mysql:
      image: mysql:5.7.25
      environment:
        MYSQL_ROOT_PASSWORD: root
      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: variable de entorno
        • MODO: independiente: inicio en modo de punto único
      • puertos: asignación de puertos, donde se expone el puerto 8848
    2. mysql: base de datos
      • imagen: mysql5.7.25: construido en base a la imagen MySQL de la versión 5.7.25
      • entorno: variable de entorno
        • MYSQL_ROOT_PASSWORD: root: establezca la contraseña de la cuenta raíz de la base de datos en root
      • volumes: monta el volumen de datos, donde 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 del microservicio, si el puerto de servicio de usuario está expuesto, entonces la autenticación de identidad y la verificación de permisos de la puerta de enlace son inútiles
    4. orderservice: construido temporalmente en base a Dockerfile, no es necesario exponer los puertos, el motivo es el mismo que el anterior
    5. puerta de enlace: construido temporalmente en base a Dockerfile, la puerta de enlace necesita exponer el puerto, que es el punto de entrada de otros microservicios

Modificar la configuración del microservicio

  • Al implementar con Docker Compose, todos los servicios pueden acceder entre sí con el nombre del servicio, por lo que debemos modificar el archivo de configuración yml en nuestra demostración en la nube ahora, de la siguiente manera {% tabs modifique el archivo de configuración yml en cloud-deom%
    }
spring:
  cloud:
    nacos:
      # server-addr: localhost:80 #Nacos地址
      server-addr: nacos:8848 # 使用compose中的服务名来互相访问，用nacos替换localhost
      config:
        file-extension: yaml # 文件后缀名

server:
  port: 8081
spring:
  datasource:
    # url: jdbc:mysql://mysql:3306/cloud_user?useSSL=false
    url: jdbc:mysql://mysql:3306/cloud_user?useSSL=false # 这里同理，使用mysql替换localhost
    username: root
    password: root
    driver-class-name: com.mysql.jdbc.Driver

{% pérdida final%}

Embalar

  • Empaquete nuestro código modificado, preste atención para modificar el archivo pom y especifique el nombre del paquete como aplicación
<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

Copie el paquete jar en el directorio de implementación y escriba el Dockerfile

{% tabs escribe tres dockerfile %}

FROM openjdk:8
COPY ./app.jar /tmp/app.jar
ENTERPOINT java -jar /tmp/app.jar

FROM openjdk:8
COPY ./app.jar /tmp/app.jar
ENTERPOINT java -jar /tmp/app.jar

FROM openjdk:8
COPY ./app.jar /tmp/app.jar
ENTERPOINT java -jar /tmp/app.jar

{% pérdida final%}

  • La estructura final del directorio es la siguiente
    • demostración en la nube
      • puerta
        • app.jar
        • Dockerfile.yml
      • servicio de pedidos
        • app.jar
        • Dockerfile.yml
      • servicio de usuario
        • app.jar
        • Dockerfile.yml
      • mysql
        • datos
        • conferencia
      • docker-compose.yml

desplegar

  • Cargue cloud-demo 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 comienza antes que nacos, y nacos comienza demasiado lento, el registro del servicio de usuario falla y no hay un mecanismo de reintento (después de que se complete el inicio de nacos, 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
  • Reinicie el servicio de servicio de pedidos de servicio de usuario de 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 para visitar http://192.168.128.130:10010/user/1?authorization=admin, también puede ver los datos

Almacén espejo Docker

  • La creación de un almacén espejo se puede implementar en función del DockerRegistry proporcionado oficialmente por Docker
  • Dirección del sitio web oficial: https://hub.docker.com/_/registry

Construye un almacén espejo privado

  • Los proyectos que escribimos nosotros mismos obviamente no son adecuados para colocarlos en el almacén compartido de Docker, por lo que necesitamos construir un servidor privado.

Configurar la dirección de confianza de Docker

  • Nuestro servidor privado utiliza el protocolo http, en el que Docker no confía de forma predeterminada, por lo que debemos realizar una configuración:
# 打开要修改的文件
vi /etc/docker/daemon.json
# 添加内容：
"insecure-registries":["http://192.168.128.101:8080"]
# 重加载
systemctl daemon-reload
# 重启docker
systemctl restart docker

Versión con GUI

  • Use DockerCompose para implementar DockerRegistry con una interfaz gráfica, el comando es el siguiente:
version: '3.0'
services:
  registry:
    image: registry
    volumes:
      - ./registry-data:/var/lib/registry
  ui:
    image: joxit/docker-registry-ui:static
    ports:
      - 8080:80
    environment:
      - REGISTRY_TITLE=Kyle's Blog私有仓库
      - REGISTRY_URL=http://registry:5000
    depends_on:
      - registry
  • Luego abra el navegador y visite http://192.168.128.130:8080/, puede ver el almacén espejo con una interfaz gráfica

Empujar y tirar de imágenes

  • Para enviar una imagen a un servicio privado de imágenes, primero debe etiquetarla. Los pasos son los siguientes
    1. Vuelva a etiquetar el espejo local, el prefijo del nombre es la dirección del almacén privado: 192.168.128.130:8080/
    docker tag nginx:latest 192.168.128.130:8080/nginx:1.0
    1. empujar imagen
    docker push 192.168.128.130:8080/nginx:1.0

    3. Tire de la imagen
    docker pull 192.168.128.130:8080/nginx:1.0

Resumir

{% enlace Qué es Docker: programador Xiaohui, https://zhuanlan.zhihu.com/p/187505981, https://static.zhihu.com/heifetz/favicon.ico%}

  • Como programadores debemos怎样理解docker？

    • tecnología de contenedores起源

      • Suponiendo que la empresa está desarrollando en secreto la próxima aplicación "Today's Toutiao", llamémosla Tomorrow's Toutiao, el programador crea un entorno de principio a fin y comienza a escribir el código. Después de escribir el código, el programador debe entregar el código al probador para pruebas. En este momento, los estudiantes de prueba comenzaron a construir este entorno de principio a fin. Los programadores no tienen que preocuparse si hay problemas durante la prueba.

      • Después de que los estudiantes de prueba terminaron la prueba, finalmente pudieron conectarse. En este momento, los estudiantes de operación y mantenimiento tuvieron que construir este entorno de principio a fin nuevamente. Tomó mucho esfuerzo construir el entorno y comenzar a conectarse. Desafortunadamente , el sistema en línea colapsó. Los programadores con buena calidad psicológica pueden mostrar sus habilidades de actuación nuevamente, "obviamente puede funcionar en el entorno de otras personas".

      • De todo el proceso, podemos ver que no solo construimos repetidamente tres conjuntos de entornos, sino que también obligamos a los programadores a cambiar a actores para desperdiciar sus talentos de actuación. Esta es una pérdida típica de tiempo y eficiencia. Los programadores inteligentes nunca estarán satisfechos. con el statu quo, por lo que es hora de que los programadores vuelvan.Es hora de cambiar el mundo, y la tecnología de contenedores surgió.

      • Algunos estudiantes pueden decir: "Espera, no cambies el mundo todavía. Tenemos máquinas virtuales. VMware es muy fácil de usar. Primero configuremos un entorno de máquina virtual y luego clonémoslo para probarlo, operarlo y mantenerlo".

    • Antes de que no haya tecnología de contenedores, esta es de hecho una buena forma, pero esta forma sigue siendo没有那么好。

      • Primero hagamos un poco de ciencia popular. Ahora, la base subyacente de la computación en la nube es la tecnología de máquinas virtuales. Los proveedores de computación en la nube compran un montón de hardware y construyen un centro de datos, y luego usan tecnología de máquinas virtuales para dividir los recursos de hardware. Por ejemplo, 100 unidades pueden ser dividido Máquinas virtuales, para que puedan venderse a muchos usuarios.

    • Entonces, ¿qué pasa con este método 为什么不好?

      • Debido a que el sistema operativo 太笨重está instalado, el sistema operativo necesita consumir muchos recursos para ejecutarse. Todos deben tener un conocimiento profundo de esto. El sistema recién instalado no ha implementado nada. Unos pocos G para empezar.

      • Todo lo que necesitamos es una aplicación simple sin gastar memoria en 无用el sistema operativo para nuestra aplicación.

      • Además, también está el problema del tiempo de inicio, sabemos que el reinicio del sistema operativo es muy lento, porque el sistema operativo tiene que detectar todo lo que necesita ser detectado desde el principio hasta el final, y cargar todo lo que necesita. para ser cargado. minutos, por lo que el sistema operativo sigue siendo demasiado torpe después de todo

  • Entonces, ¿existe una tecnología que nos permita obtener los beneficios de las máquinas virtuales y superar estas deficiencias de una sola vez 实现鱼和熊掌的兼得?

    • La respuesta es sí, es容器技术。

  • 什么是容器

    • La palabra en inglés para la palabra contenedor es contenedor. De hecho, contenedor también significa contenedor. El contenedor es definitivamente un invento notable en la historia del comercio, que reduce en gran medida el costo del comercio marítimo y el transporte. Veamos los beneficios de los contenedores:
      • Los contenedores están aislados unos de otros.
      • uso repetido a largo plazo
      • Carga y descarga rápida
      • Especificaciones estándar, se puede colocar en el puerto y en el barco.
    • Volviendo al contenedor en el software, de hecho, el concepto de contenedor y contenedor es muy similar.
    • Uno de los propósitos principales del desarrollo de software moderno es el aislamiento. Las aplicaciones se ejecutan de forma independiente sin interferir entre sí. Este aislamiento no es fácil de lograr. Una de las soluciones es la tecnología de máquina virtual mencionada anteriormente. Implementada en diferentes máquinas virtuales para lograr el aislamiento. .
    • Pero la tecnología de máquinas virtuales tiene las diversas deficiencias mencionadas anteriormente, entonces, ¿qué pasa con la tecnología de contenedores?
    • A diferencia del aislamiento de máquinas virtuales a través del sistema operativo, la tecnología de contenedores solo aísla el entorno de tiempo de ejecución de la aplicación, pero el mismo sistema operativo puede compartirse entre contenedores. El entorno de tiempo de ejecución aquí se refiere a las diversas bibliotecas y configuraciones de las que depende el programa. .
    • En comparación con la ocupación de memoria del sistema operativo, que ocupa varios gigabytes, la tecnología de contenedores solo necesita unos pocos gigabytes de espacio, por lo que podemos implementar una gran cantidad de contenedores en el hardware de la misma especificación, que es incomparable a las máquinas virtuales, y es diferente del sistema operativo que tarda unos minutos.Tiempo de inicioLos contenedores se inician casi instantáneamente, y la tecnología de contenedores proporciona una forma más eficiente de empaquetar pilas de servicios.

  • 那么我们该怎么使用容器呢？Esto es sobre la ventana acoplable.

    • Tenga en cuenta que los contenedores son una tecnología general y Docker es solo una implementación.

  • 什么是docker

    • Docker es un proyecto de código abierto implementado en lenguaje Go, que nos permite crear y utilizar contenedores de manera conveniente. Docker empaqueta programas y todas las dependencias de los programas en contenedores docker, para que sus programas puedan tener un rendimiento constante en cualquier entorno. Aquí La dependencia del programa la operación es que el contenedor es como un contenedor, y el entorno del sistema operativo donde se encuentra el contenedor es como un barco de carga o un puerto.El rendimiento del programa solo está relacionado con el contenedor (contenedor), y no tiene nada que ver con en qué buque de carga o en qué puerto (sistema operativo) se coloca el contenedor.
    • Por lo tanto, podemos ver que la ventana acoplable puede proteger las diferencias ambientales, es decir, mientras su programa esté empaquetado en la ventana acoplable, el comportamiento del programa será consistente sin importar en qué entorno se esté ejecutando, y los programadores ya no podrán mostrar sus talentos Habrá "correr en mi entorno" nuevamente, y la realización real de "construir una vez, ejecutar en todas partes".
    • Además, otro beneficio de Docker es la implementación rápida, que es el escenario de aplicación más común para las empresas de Internet. Una razón es que el contenedor se inicia muy rápido y la otra razón es que mientras el programa en un contenedor se ejecute correctamente, puede estar seguro de que no importa cuánto se implemente en el entorno de producción, se puede ejecutar correctamente.

  • 如何使用docker

    • Hay varios conceptos en docker:

      • archivo acoplable
      • imagen
      • envase

    • De hecho, simplemente puede entender la imagen como un programa ejecutable y el contenedor es el proceso en ejecución.

    • Luego, escribir un programa requiere un código fuente, luego "escribir" una imagen requiere un dockerfile, un dockerfile es el código fuente de una imagen y docker es un "compilador".

    • Por lo tanto, solo necesitamos especificar en el dockerfile qué programas se necesitan y en qué configuraciones confiar, y luego entregar el dockerfile al "compilador" docker para "compilación", que es el comando de compilación docker.El programa ejecutable generado es image , y luego puede Después de ejecutar esta imagen, este es el comando de ejecución de la ventana acoplable, y después de que la imagen se ejecuta, se convierte en el contenedor de la ventana acoplable.

    • El método específico de uso no se repetirá aquí. Puede consultar la documentación oficial de docker, donde hay explicaciones más detalladas.

  • docker是如何工作的

    • De hecho, Docker utiliza una arquitectura CS común, que es el modelo cliente-servidor. El cliente de Docker es responsable de procesar varios comandos ingresados ​​por los usuarios, como compilación y ejecución de Docker. El trabajo real es en realidad el servidor, que es el docker demon Vale la pena señalar que sí, el cliente docker y el demonio docker pueden ejecutarse en la misma máquina.

  • 接下来我们用几个命令来讲解一下docker的工作流程：

    1. compilación de la ventana acoplable
      • Cuando terminamos de escribir el dockerfile y le damos a docker para "compilar", usamos este comando, luego el cliente lo reenvía al demonio de docker después de recibir la solicitud, y luego el demonio de docker crea una imagen de "programa ejecutable" basada en el archivo acoplable.
    2. ejecución de la ventana acoplable
      • Después de tener la imagen del "programa ejecutable", puede ejecutar el programa. Luego, use el comando docker run. Después de recibir el comando, el demonio docker encuentra la imagen específica y luego la carga en la memoria para comenzar la ejecución. Cuando el se ejecuta la imagen, se llama contenedor.
    3. tirar de la ventana acoplable
      • De hecho, docker build y docker run son los dos comandos principales. Si puede usar estos dos comandos, básicamente puede usar docker, y el resto son algunos complementos.
      • Entonces, ¿qué significa docker pull?
      • Como decíamos antes, el concepto de imagen en docker es similar a “programa ejecutable”, ¿dónde podemos descargar aplicaciones escritas por otros? Muy sencillo, eso es la APP Store, la tienda de aplicaciones. Del mismo modo, dado que la imagen también es un "programa ejecutable", ¿existe una "tienda de imágenes Docker"? La respuesta es sí, esto es Docker Hub, la "tienda de aplicaciones" oficial de docker, donde puede descargar imágenes escritas por otros, para que no tenga que escribir dockerfile usted mismo.
      • El registro de la ventana acoplable se puede usar para almacenar varias imágenes, y el almacén público para que cualquier persona descargue imágenes es el centro de la ventana acoplable. Entonces, cómo descargar la imagen de Docker Hub, ese es el comando docker pull aquí.
      • Por lo tanto, la implementación de este comando también es muy simple, es decir, el usuario envía el comando a través del cliente de la ventana acoplable, y el demonio de la ventana acoplable envía una solicitud de descarga de imagen al registro de la ventana acoplable después de recibir el comando y la almacena localmente después de la descarga. para que podamos usar la imagen.

  • 最后，让我们来看一下docker的底层实现。

    • Docker proporciona varias funciones basadas en el kernel de Linux:
      • NameSpace
        Sabemos que PID, IPC, red y otros recursos en Linux son globales, y el mecanismo de NameSpace es un esquema de aislamiento de recursos. Bajo este mecanismo, estos recursos ya no son globales, sino que pertenecen a un NameSpace específico. Los recursos de cada NameSpace no interfieren entre sí, lo que hace que cada NameSpace parezca un sistema operativo independiente, pero solo el NameSpace no es suficiente.
      • Aunque los grupos de control
        cuentan con tecnología NameSpace para lograr el aislamiento de recursos, los procesos aún pueden acceder a los recursos del sistema sin control, como CPU, memoria, disco, red, etc. Para controlar el acceso de los procesos a los recursos en contenedores, Docker utiliza la tecnología de grupos de control ( Es decir, cgroup). Con cgroup, puede controlar el consumo de recursos del sistema por parte del proceso en el contenedor. Por ejemplo, puede limitar el límite superior de memoria utilizada por un contenedor, en qué CPU puede ejecutarse, etc. .
      • Con estas dos tecnologías, los contenedores realmente parecen sistemas operativos independientes.

  • 总结

    • Docker es una tecnología muy popular en la actualidad, y muchas empresas la utilizan en entornos de producción, pero la tecnología subyacente en la que se basa docker apareció hace mucho tiempo, y ahora se rejuvenece en forma de docker y puede resolver los problemas. se enfrenta muy bien

Supongo que te gusta

Origin blog.csdn.net/qq_33888850/article/details/129770199
Recomendado
Clasificación
Diario
Más
2024-05-18(30)
2024-05-17(4)
2024-05-16(22)
2024-05-15(5)
2024-05-14(10)
2024-05-13(7)
2024-05-12(22)
2024-05-11(31)
2024-05-10(32)
2024-05-09(31)

Code World

© 2018 codetd.com