Docker如何部署 Web 项目

2023-blog

Spring Boot 项目开发完成之后，就需要进行部署了，部署大概有这三种：

• 用宝塔进行部署，宝塔最方便快捷，但宝塔这个工具本身褒贬不一，最直接的看法是，不安全占用系统资源，在工程化方面还是缺少灵活性，适合入门选手。
• 在 Centos 上安装 nginx, java, mysql 进行裸机部署，优点真实不做作，缺点也很明显，各种环境平台差异问题比较多，需要 Linux 基础
• 在 Centos 安装 Docker，然后用 Docker 进行容器部署，优点独自消化平台差异性，缺点占用系统资源，入门有一定门槛，需要 Linux 基础

今天主要介绍在 Docker 上部署 SpringBoot 应用，本次的环境配置：

1. 一台真实的服务器 4core 8G Memory 80G Disk
2. Centos 7.9 (通过 cat /etc/redhat-release 查看)
3. Java 11
4. Spring Boot 2.7.5
5. Mybatis 2.1.3
6. Mysql 5.7

1. 安装Docker

• SSH 连接之后输入命令，先查看可以安装的版本信息

yum list docker-ce --showduplicates | sort -r

• 选择最新版本安装

yum -y install docker-ce-24.0.2-1.ce

• 启动 Docker 并设置开机自启

systemctl start docker
systemctl enable docker

然后输入 docker version 进行信息验证，正常打印出Client, Server信息说明安装成功，如果没有正常打印，在重新检查安装步骤。

2. Docker中安装Nginx

Nginx 在这个场景通过代理转发的手段来隐藏真实项目的端口，比如：http://www.host.com:8080 让普通用户从默认 80 端口进行业务访问，最后就是： http://www.host.com，简洁明了。

同时分发其它域名的入口，比如一个服务器绑定多个域名时 Nginx 就是最好的工具，就是说 Docker 中运行一个 Nginx 容器就可以服务整个服务器。Mysql 也是同样的道理。

然后，这块业界的其它小伙伴也有不同的看法，因为 Nginx 做为唯一的 Web 服务器且在服务器上以版本稳定而著称。简单说，可以不放在容器当中，现在选择放在容器当中，是为了统一整合发布资源。

1. # 下载最新版Nginx镜像
   docker pull nginx

2. # 查当前所有Docker下载的镜像
   docker images 

3. # 创建挂载目录
   mkdir -p /home/nginx/conf
   mkdir -p /home/nginx/log
   mkdir -p /home/nginx/html

4. # 生成容器
   docker run --name nginx -p 80:80 -d nginx
   # 将容器nginx.conf文件复制到宿主机
   docker cp nginx:/etc/nginx/nginx.conf /home/nginx/conf/nginx.conf
   # 将容器conf.d文件夹下内容复制到宿主机
   docker cp nginx:/etc/nginx/conf.d /home/nginx/conf/conf.d
   # 将容器中的html文件夹复制到宿主机
   docker cp nginx:/usr/share/nginx/html /home/nginx/

5. # 删除Nginx容器
   docker ps -a
   # 关闭该容器
   docker stop nginx
   # 删除该容器
   docker rm nginx
   # 强制删除正在运行的nginx容器
   docker rm -f nginx
   # 这块新建之后又删掉这个容器主要目的是为了复制内部的nginx.conf到宿主容器

6. #创建Nginx新容器并运行，然后修改/home/nginx/conf中的配置重启容器即可生效
   docker run \
   -p 80:80 \
   --name nginx \
   -v /home/nginx/conf/nginx.conf:/etc/nginx/nginx.conf \
   -v /home/nginx/conf/conf.d:/etc/nginx/conf.d \
   -v /home/nginx/log:/var/log/nginx \
   -v /home/nginx/html:/usr/share/nginx/html \
   -d nginx

7. # 增加各个配置
   # 由于 /home/nginx/conf/nginx.conf 中有这样一句话: include /etc/nginx/conf.d/*.conf;
   # 所以，其它站点的 nginx 配置文件放在 /home/nginx/conf/conf.d 目录下，每个文件以域名来命名，比如：vue-admin-cn.conf, react-admin.conf，这样做的好处是配置解耦，那个站点下线，直接删除对应配置重启nginx就可以生效而不影响其它应用
   server {
      listen       80;
      server_name  react-admin.cn www.react-admin.cn;
      root /usr/share/nginx/html/react-admin.cn; # 真实的宿主目录是：/home/nginx/html/vue-admin.cn
      location / {
          proxy_pass http://111.111.111.111:3000/; # 服务器真实IP
          proxy_set_header   X-Real-IP        $remote_addr;
              proxy_set_header   X-Forwarded-For $proxy_add_x_forwarded_for;
          proxy_set_header   Host             $http_host;
          proxy_no_cache 1;
          proxy_cache_bypass 1;
      }
   }

8. # 配置好之后重启 nginx
   docker restart nginx

3. Docker中安装Mysql

Docker中的Mysql有三步，先拉取镜像然后运行导入数据，就可以正常连接了。

1. # 拉取Mysql镜像
   docker pull mysql:5.7

2. # 运行镜像
   docker run \
    -p 3306:3306 \
    --name mysql57 \
    -v ~/mysql/data:/var/lib/mysql \
    -e MYSQL_ROOT_PASSWORD=123456 \
    --privileged=true \
    docker.io/mysql:5.7

3. # 上传sql到用户文件目录
   /home/boot/bootblog.sql
   # 拷贝文件进窗口
   docker cp bootblog.sql mysql:/bootblog.sql

4. # 进入容器内部
   docker exec -it mysql57 bash

5. # 登录Mysql，新建数据库之后导入
   mysql -uroot -p123456
   mysql> create DATABASE bootblog;
   mysql> mysql -uroot -p123456 -D bootblog < bootblog.sql
   mysql> show databases;

4. Docker中部署Java项目

1. 首先Java项目中增加 application.dev.yml, application.prod.yml 配置文件，以此来管理本地开发环境和生产环境的配置区别，不仅仅是数据库连接，还可以包括其它配置。

   • 然后在 application.yml 中设置 spring.profiles.active=dev 激活当前开发环境使用 dev 配置
   • Dockerfile 中增加参数 -Dspring.profiles.active=dev
   • Docker run 时增加参数 SPRING_PROFILES_ACTIVE=dev

2. 编写docker文件

   # 基础镜像
   FROM openjdk:11
   # 挂载目录
   VOLUME /home/bootblog
   # 暴露端口
   EXPOSE 8000
   # 执行命令
   ENTRYPOINT ["java","-Xmx256m","-Xms256m","-Dspring.profiles.active=prod","-jar","/data/java/jar/boot-blog-app.jar"]

3. Maven clean, Meavn package 进行打包

4. Docker 编译

   docker build -t bootblog .

5. 运行容器

   docker run -d -p 8000:8000 -e "SPRING_PROFILES_ACTIVE=prod" --name bootblog -it -v /home/boot/jar:/data/java/jar bootblog
   # -d: 后台运行容器，并返回容器ID
   # -p: 指定端口映射，格式为：主机(宿主)端口:容器端口
   # -e SPRING_PROFILES_ACTIVE=prod: 设置环境变量
   # --name="bootblog": 为容器指定一个名称，后续docker命令操作可以用这个name来识别，比如：docker logs bootblog
   # -it: 以交互模式为容器重新分配一个伪输入终端
   # -v: 挂载一个目录，后续只更新宿主目录（/home/boot/jar）中的.jar文件，而不用删除重新构建 docker

6. 项目更新

   • 只需要更新 /home/boot/jar 中的jar文件
   • 不需要重启 docker

5. Docker中部署Nuxt项目

Docker中部署 Nuxt 有三步，先拉取镜像然后上传打包好的文件最后在 docker 运行。为什么不在服务器上打包，主要服务器内存有限，在服务器上打包需要安装: Git, Node一波下来都是消耗。

1. 上传 .output 到 /home/blog 目录

2. # 编写 Dockerfile
   # 拉取node镜像
   FROM node:16-alpine
   #参数，node的环境为生产环境
   ENV NODE_ENV=production
   #容器内创建目录blog
   RUN mkdir -p /blog
   #复制当前的内容到容器内容部目录portal
   COPY .output/ ./blog
   #切换工作目录到blog
   WORKDIR /blog
   ENV HOST 0.0.0.0
   #RUN npm config set registry https://registry.npmmirror.com
   #设置外部访问端口，Nuxt的默认端口，如果需要转化在 Docker 启动的时候转化
   EXPOSE 3000
   # 运行命令以启动应用程序
   CMD ["node","./server/index.mjs"]

3. # 打包项目镜像
   docker build -t blog .

4. # 运行镜像
   docker run --name blog -d -p 3005:3005 blog

6. Docker中部署Next.js项目

Docker中部署 Next.js 有三步，先上传整个项目到资源目录，然后编写 Dockerfile，然后运行。

1. 上传 next-demo 到 /home/next 目录

2. # 编写 Dockerfile
   # 拉取node镜像
   FROM node:16-alpine
   #容器内创建目录blog
   RUN mkdir -p /app
   #切换工作目录到app
   WORKDIR /app
   #参数，node的环境为生产环境
   ENV NODE_ENV=production
   COPY ./package*.json /app
   # 安装项目的生产依赖，而不安装开发依赖
   RUN npm install
   COPY ./ /app
   EXPOSE 3000
   CMD ["npm", "start"]

3. # 打包项目镜像
   docker build -t nextblog .

4. # 运行镜像
   docker run --name nextblog -d -p 3006:3000 nextblog

7. Docker中部署Nest项目

Docker中的Nest有三步，先拉取镜像然后运行导入数据，就可以正常连接了。

1. # 设定环境
   FROM node:16-alpine
   # 设置时区
   ENV TZ=Asia/Shanghai
   #参数，node的环境为生产环境
   ENV NODE_ENV=production
   #容器内创建目录blog
   RUN mkdir -p /app
   # 指定工作目录
   WORKDIR /app
   # 复制当前代码到/app工作目录
   COPY ./ ./
   # npm 安装依赖
   COPY package.json /app/package.json
   RUN cd /app && rm -rf /app/node_modules &&  npm install
   #设置外部访问端口
   EXPOSE 3000
   # 运行命令以启动应用程序
   CMD [ "node", "dist/main" ]

2. # 打包项目镜像
   docker build -t nestblog .

3. # 运行镜像
   docker run --name nestblog -d -p 9000:3000 nestblog

4. # 进入容器内部
   docker exec -it mysql57 bash

5. # 登录Mysql，新建数据库之后导入
   mysql -uroot -p123456
   mysql> create DATABASE bootblog;
   mysql> mysql -uroot -p123456 -D bootblog < bootblog.sql
   mysql> show databases;

8. Docker中部署Go项目

Docker中的 Go 项目的部署就比较简单。有三步，上传打包好的文件，及相关的配置文件静态文件（如果有的话，go build是不打包静态文件，当然也有办法可以打包静态文件，这儿选择不打包），然后编写 Dockerfile，最后运行。

1. # 定义打包环境 build.sh
   # 然后在命令行运行 build.sh
   GOOS=linux GOARCH=amd64 go build main.go

2. # 定义版本
   FROM golang:1.18 as golang
   #容器内创建目录blog
   RUN mkdir -p /blog
   # 进入工作目录
   WORKDIR /blog
   COPY . .
   # 暴露服务端口
   EXPOSE 4001
   RUN chmod +x main
   # 容器启动时运行的命令
   ENTRYPOINT ["./main"]

3. # 打包项目镜像
   docker build -t goblog .

4. # 运行镜像
   docker run --name goblog -d -p 4001:4001 goblog