Docker 是一个开源的容器化平台，通过将应用程序和其依赖打包在一个轻量级、独立的容器中，能够跨平台和环境部署。

1. Docker 基本概念

• 镜像 (Image)：Docker 镜像是一个只读模板，包含运行应用程序所需的代码、库、依赖和环境配置。镜像类似于一个模板，可以用来创建容器。

• 容器 (Container)：容器是镜像的一个运行实例，它可以运行一个或多个进程，且具有隔离性。容器的生命周期短暂，可以随时启动、停止或销毁。

• Dockerfile：Dockerfile 是一组指令文件，用来定义镜像的构建过程。开发者可以通过 Dockerfile 编写应用及其依赖环境的打包脚本。

• 仓库 (Repository)：Docker 镜像的存储位置，类似于代码的版本控制系统。镜像可以推送到仓库中供其他用户下载使用。Docker Hub 是一个公共仓库，提供了大量的官方和社区镜像。

2. Docker 的优势

• 轻量级：Docker 使用系统级别的虚拟化，而非虚拟机，不需要完整的操作系统，容器启动速度更快，占用资源更少。

• 环境一致性：Docker 容器包含应用运行所需的全部环境配置，确保在不同环境中行为一致，减少了环境配置不一致导致的问题。

• 快速部署与扩展：Docker 支持快速部署和缩放，可以在几秒钟内启动多个实例，适合大规模应用的部署和扩展。

• 便于 CI/CD：Docker 与 DevOps 流程无缝集成，支持持续集成、交付和部署。

3. Docker 安装

安装参考Docker官方文档，地址如下：https://docs.docker.com/engine/install/centos/

3.1 卸载旧版

首先如果系统中已经存在旧的Docker，则先卸载：

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

3.2 配置Docker的yum库

首先要安装一个yum工具

sudo yum install -y yum-utils device-mapper-persistent-data lvm2

安装成功后，执行命令，配置Docker的yum源：

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

sudo sed -i 's+download.docker.com+mirrors.aliyun.com/docker-ce+' /etc/yum.repos.d/docker-ce.repo

更新yum，建立缓存

sudo yum makecache fast

3.3 安装Docker

最后，执行命令，安装Docker

yum install -y docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin

3.4 启动和校验

# 启动Docker
systemctl start docker

# 停止Docker
systemctl stop docker

# 重启
systemctl restart docker

# 设置开机自启
systemctl enable docker

# 执行docker ps命令，如果不报错，说明安装启动成功
docker ps

4. Docker 基本使用

Docker本身包含一个后台服务，我们可以利用Docker命令告诉Docker服务，帮助我们快速部署指定的应用。Docker服务部署应用时，首先要去搜索并下载应用对应的镜像，然后根据镜像创建并允许容器，应用就部署完成了。

4.1 Docker 命令

默认情况下，每次重启虚拟机我们都需要手动启动Docker和Docker中的容器。通过命令可以实现开机自启：

# Docker开机自启
systemctl enable docker

# Docker容器开机自启
docker update --restart=always [容器名/容器id]

4.2 Docker部署MySQL服务示例

docker run -d \                                 # 以后台模式启动容器（detached mode）。
  --name mysql \                                # 将容器命名为 "mysql"，便于管理。
  -p 3306:3306 \                                # 将主机的 3306 端口映射到容器的 3306 端口，方便本地主机访问 MySQL 服务。
  -e TZ=Asia/Shanghai \                         # 设置容器的时区为上海时间（Asia/Shanghai），以确保时间一致。
  -e MYSQL_ROOT_PASSWORD=123 \                  # 设置 MySQL root 用户的密码为 "123"（实际环境中应使用复杂密码）。
  -v ./mysql/data:/var/lib/mysql \              # 挂载本地数据目录到容器的 MySQL 数据目录，以持久化存储数据库数据。
  -v ./mysql/conf:/etc/mysql/conf.d \           # 挂载本地配置目录到容器的 MySQL 配置目录，以便加载自定义配置文件。
  -v ./mysql/init:/docker-entrypoint-initdb.d \ # 挂载本地初始化脚本目录到容器，容器启动时将执行目录中的脚本。
  mysql                                         # 使用官方 MySQL 镜像。

镜像的名称不是随意的，而是要到DockerRegistry中寻找，镜像运行时的配置也不是随意的，要参考镜像的帮助文档，这些在DockerHub网站或者软件的官方网站中都能找到。

4.3 Dockerfile制作镜像

镜像的来源有两种：

（1）直接去DockerRegistry下载

（2）基于官方基础镜像自己制作

由于制作镜像的过程中，需要逐层处理和打包，比较复杂，所以Docker就提供了自动打包镜像的功能。我们只需要将打包的过程，每一层要做的事情用固定的语法写下来，交给Docker去执行即可。

而这种记录镜像结构的文件就称为Dockerfile，其对应的语法可以参考官方文档：

https://docs.docker.com/engine/reference/builder/

例如，要基于Ubuntu镜像来构建一个Java应用，其Dockerfile内容如下：

# 基础镜像
FROM openjdk:11.0-jre-buster
# 设定时区
ENV TZ=Asia/Shanghai
RUN ln -snf /usr/share/zoneinfo/$TZ /etc/localtime && echo $TZ > /etc/timezone
# 拷贝jar包
COPY docker-demo.jar /app.jar
# 入口
ENTRYPOINT ["java", "-jar", "/app.jar"]

然后，执行命令，构建镜像：

# 使用 Docker 从指定目录中的 Dockerfile 构建镜像
docker build -t docker-demo:1.0 /root/demo

# 参数说明:
# docker build                # Docker 命令，用于从 Dockerfile 构建镜像
# -t docker-demo:1.0          # 使用 -t 参数为镜像指定名称和标签（版本号）
#   docker-demo               # 镜像的名称，用于标识构建出的镜像
#   1.0                       # 镜像的版本号（tag），用于区分不同版本，格式为 <镜像名>:<版本号>
# /root/demo                  # 指定 Dockerfile 所在的目录路径，Docker 将在该目录中查找名为 Dockerfile 的文件

4.4 网络

Java项目往往需要访问其它各种中间件，例如MySQL、Redis等。放在同一个网络中，我们的容器之间能互相访问。

4.5 Docker Compose

Docker Compose 是一个工具，允许用户定义并运行多个容器服务。通过编写 docker-compose.yml 文件，用户可以轻松地配置应用的多个服务并管理它们。

稍微复杂的项目，会有各种各样的其它中间件，需要部署的东西很多。如果手动的逐一部署，就太麻烦了。

而Docker Compose就可以帮助我们实现多个相互关联的Docker容器的快速部署。它允许用户通过一个单独的 docker-compose.yml 模板文件（YAML 格式）来定义一组相关联的应用容器。

举例来说，用docker run部署MySQL的命令如下：

docker run -d \                                 # 以后台模式启动容器（detached mode）。
  --name mysql \                                # 将容器命名为 "mysql"，便于管理。
  -p 3306:3306 \                                # 将主机的 3306 端口映射到容器的 3306 端口，方便本地主机访问 MySQL 服务。
  -e TZ=Asia/Shanghai \                         # 设置容器的时区为上海时间（Asia/Shanghai），以确保时间一致。
  -e MYSQL_ROOT_PASSWORD=123 \                  # 设置 MySQL root 用户的密码为 "123"（实际环境中应使用复杂密码）。
  -v ./mysql/data:/var/lib/mysql \              # 挂载本地数据目录到容器的 MySQL 数据目录，以持久化存储数据库数据。
  -v ./mysql/conf:/etc/mysql/conf.d \           # 挂载本地配置目录到容器的 MySQL 配置目录，以便加载自定义配置文件。
  -v ./mysql/init:/docker-entrypoint-initdb.d \ # 挂载本地初始化脚本目录到容器，容器启动时将执行目录中的脚本。
  mysql                                         # 使用官方 MySQL 镜像。

如果用docker-compose.yml文件来定义，就是这样：

# Docker Compose 配置文件，版本为 3.8
version: "3.8"

# 定义多个服务
services:
  # 定义 MySQL 服务
  mysql:
    # 使用官方的 MySQL 镜像
    image: mysql
    # 指定容器名称
    container_name: mysql
    # 映射主机和容器的端口
    ports:
      - "3306:3306"  # 将主机的 3306 端口映射到容器的 3306 端口
    # 设置环境变量
    environment:
      TZ: Asia/Shanghai  # 设置容器的时区为亚洲/上海
      MYSQL_ROOT_PASSWORD: 123  # 设置 MySQL 根用户的密码为 123
    # 挂载主机目录到容器中，用于持久化数据和自定义配置
    volumes:
      - "./mysql/conf:/etc/mysql/conf.d"  # 挂载本地的配置文件夹到容器的 MySQL 配置目录
      - "./mysql/data:/var/lib/mysql"     # 挂载本地的数据文件夹到容器的 MySQL 数据目录
    # 指定网络配置
    networks:
      - new  # 将此服务连接到名为 new 的网络

# 定义网络
networks:
  new:
    name: cyt  # 指定网络的名称为 cyt

编写好docker-compose.yml文件，就可以部署项目了。常见的命令：

# 启动所有, -d 参数是后台启动
docker compose up -d

5. 部署示例

项目说明：

• cyt：后端代码

• cyt-portal：用户端的前端代码

• cyt-admin：管理端的前端代码

5.1 逐个部署

5.1.1 部署Java项目

注意：host采用了mysql作为地址，刚好是我们的mysql容器名，只要两者在一个网络，就一定能互相访问。

首先将项目打包；

将项目目录下的Dockerfile和/target目录下的.jar一起上传到虚拟机的root目录。

# 1.首先通过命令创建一个网络
docker network create cytnet

# 1.构建项目镜像，不指定tag，则默认为latest
docker build -t cyt.

# 2.创建并运行容器，并通过--network将其加入hmall网络，这样才能通过容器名访问mysql
docker run -d --name cyt --network cytnet -p 8080:8080 cyt

5.1.2 部署前端

将前端代码拷贝到nginx的html目录下，在nginx.conf配置文件，完成对html下的两个静态资源目录做代理。

将整个nginx目录上传到虚拟机的/root目录下

docker run -d \
  --name nginx \
  -p 18080:18080 \
  -p 18081:18081 \
  -v /root/nginx/html:/usr/share/nginx/html \
  -v /root/nginx/nginx.conf:/etc/nginx/nginx.conf \
  --network hmall \
  nginx

5.2 DockerCompose一键部署

编写docker-compose.yml文件

version: "3.8"  # 定义 Docker Compose 文件的版本

services:
  # MySQL 数据库服务
  mysql:
    image: mysql  # 使用官方 MySQL 镜像
    container_name: mysql  # 设置容器名称为 "mysql"
    ports:
      - "3306:3306"  # 将主机的 3306 端口映射到容器的 3306 端口
    environment:
      TZ: Asia/Shanghai  # 设置容器的时区为亚洲/上海
      MYSQL_ROOT_PASSWORD: 123  # 设置 MySQL 的 root 用户密码
    volumes:
      - "./mysql/conf:/etc/mysql/conf.d"  # 挂载自定义配置文件目录到容器中
      - "./mysql/data:/var/lib/mysql"  # 持久化存储 MySQL 数据库的数据
      - "./mysql/init:/docker-entrypoint-initdb.d"  # 初始化 SQL 脚本目录
    networks:
      - cyt-net  # 连接到名为 "cyt-net" 的自定义网络

  # Java 应用服务（cyt）
  cyt:
    build: 
      context: .  # 设置构建上下文为当前目录
      dockerfile: Dockerfile  # 指定构建 Java 应用的 Dockerfile 文件
    container_name: cyt  # 设置容器名称为 "cyt"
    ports:
      - "8080:8080"  # 将主机的 8080 端口映射到容器的 8080 端口
    networks:
      - cyt-net  # 连接到自定义网络 "cyt-net"
    depends_on:
      - mysql  # 设置依赖关系：确保 MySQL 容器在 cyt 容器之前启动

  # Nginx 反向代理服务
  nginx:
    image: nginx  # 使用官方 Nginx 镜像
    container_name: nginx  # 设置容器名称为 "nginx"
    ports:
      - "18080:18080"  # 将主机的 18080 端口映射到容器的 18080 端口（可以根据需要修改）
      - "18081:18081"  # 将主机的 18081 端口映射到容器的 18081 端口（可以根据需要修改）
    volumes:
      - "./nginx/nginx.conf:/etc/nginx/nginx.conf"  # 挂载自定义 Nginx 配置文件
      - "./nginx/html:/usr/share/nginx/html"  # 挂载静态文件目录到 Nginx 容器中
    depends_on:
      - cyt  # 设置依赖关系：确保 cyt 容器在 nginx 容器之前启动
    networks:
      - cyt-net  # 连接到自定义网络 "cyt-net"

# 定义自定义网络
networks:
  cyt-net:
    name: cyt  # 将自定义网络命名为 "cyt"

在终端中运行以下命令，Docker Compose 会读取 docker-compose.yml 文件并启动配置的服务

# 启动所有, -d 参数是后台启动
docker compose up -d