Docker跨平台和环境部署的过程详解_云虚拟主机

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

到此这篇关于docker跨平台和环境部署的文章就介绍到这了,更多相关docker跨平台部署内容请搜索代码网以前的文章或继续浏览下面的相关文章希望大家以后多多支持代码网！

Docker跨平台和环境部署的过程详解

2024年11月26日 • 云虚拟主机 •我要评论