[关闭]
@jikeytang 2023-07-26T14:25:23.000000Z 字数 5789 阅读 694

Docker如何部署 Web 项目

2023-blog

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

今天主要介绍在 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

  1. yum list docker-ce --showduplicates | sort -r
  1. yum -y install docker-ce-24.0.2-1.ce
  1. systemctl start docker
  2. 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 服务器且在服务器上以版本稳定而著称。简单说，可以不放在容器当中，现在选择放在容器当中，是为了统一整合发布资源。

    2. # 下载最新版Nginx镜像
    4. docker pull nginx
    2. # 查当前所有Docker下载的镜像
    4. docker images 
    2. # 创建挂载目录
    4. mkdir -p /home/nginx/conf
    5. mkdir -p /home/nginx/log
    6. mkdir -p /home/nginx/html
    2. # 生成容器
    4. docker run --name nginx -p 80:80 -d nginx
    6. # 将容器nginx.conf文件复制到宿主机
    8. docker cp nginx:/etc/nginx/nginx.conf /home/nginx/conf/nginx.conf
    10. # 将容器conf.d文件夹下内容复制到宿主机
    12. docker cp nginx:/etc/nginx/conf.d /home/nginx/conf/conf.d
    14. # 将容器中的html文件夹复制到宿主机
    16. docker cp nginx:/usr/share/nginx/html /home/nginx/
    2. # 删除Nginx容器
    4. docker ps -a
    6. # 关闭该容器
    8. docker stop nginx
    10. # 删除该容器
    12. docker rm nginx
    15. # 强制删除正在运行的nginx容器
    17. docker rm -f nginx
    19. # 这块新建之后又删掉这个容器主要目的是为了复制内部的nginx.conf到宿主容器
    2. #创建Nginx新容器并运行，然后修改/home/nginx/conf中的配置重启容器即可生效
    4. docker run \
    5. -p 80:80 \
    6. --name nginx \
    7. -v /home/nginx/conf/nginx.conf:/etc/nginx/nginx.conf \
    8. -v /home/nginx/conf/conf.d:/etc/nginx/conf.d \
    9. -v /home/nginx/log:/var/log/nginx \
    10. -v /home/nginx/html:/usr/share/nginx/html \
    11. -d nginx
    2. # 增加各个配置
    5. # 由于 /home/nginx/conf/nginx.conf 中有这样一句话: include /etc/nginx/conf.d/*.conf;
    8. # 所以，其它站点的 nginx 配置文件放在 /home/nginx/conf/conf.d 目录下，每个文件以域名来命名，比如：vue-admin-cn.conf, react-admin.conf，这样做的好处是配置解耦，那个站点下线，直接删除对应配置重启nginx就可以生效而不影响其它应用
    11. server {
    12.    listen       80;
    13.    server_name  react-admin.cn www.react-admin.cn;
    14.    root /usr/share/nginx/html/react-admin.cn; # 真实的宿主目录是：/home/nginx/html/vue-admin.cn
    16.    location / {
    17.        proxy_pass http://111.111.111.111:3000/; # 服务器真实IP
    18.        proxy_set_header   X-Real-IP        $remote_addr;
    19.            proxy_set_header   X-Forwarded-For $proxy_add_x_forwarded_for;
    20.        proxy_set_header   Host             $http_host;
    21.        proxy_no_cache 1;
    22.        proxy_cache_bypass 1;
    23.    }
    24. }
    2. # 配置好之后重启 nginx
    4. docker restart nginx

3. Docker中安装Mysql

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

    2. # 拉取Mysql镜像
    4. docker pull mysql:5.7
    2. # 运行镜像
    4. docker run \
    5.  -p 3306:3306 \
    6.  --name mysql57 \
    7.  -v ~/mysql/data:/var/lib/mysql \
    8.  -e MYSQL_ROOT_PASSWORD=123456 \
    9.  --privileged=true \
    10.  docker.io/mysql:5.7
    2. # 上传sql到用户文件目录
    4. /home/boot/bootblog.sql
    6. # 拷贝文件进窗口
    8. docker cp bootblog.sql mysql:/bootblog.sql
    2. # 进入容器内部
    4. docker exec -it mysql57 bash
    2. # 登录Mysql，新建数据库之后导入
    4. mysql -uroot -p123456
    5. mysql> create DATABASE bootblog;
    6. mysql> mysql -uroot -p123456 -D bootblog < bootblog.sql
    7. 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文件

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

  3. Maven clean, Meavn package 进行打包

  4. Docker 编译

    1. docker build -t bootblog .

  5. 运行容器

    1. docker run -d -p 8000:8000 -e "SPRING_PROFILES_ACTIVE=prod" --name bootblog -it -v /home/boot/jar:/data/java/jar bootblog
    3. # -d: 后台运行容器，并返回容器ID
    6. # -p: 指定端口映射，格式为：主机(宿主)端口:容器端口
    9. # -e SPRING_PROFILES_ACTIVE=prod: 设置环境变量
    12. # --name="bootblog": 为容器指定一个名称，后续docker命令操作可以用这个name来识别，比如：docker logs bootblog
    15. # -it: 以交互模式为容器重新分配一个伪输入终端
    18. # -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
    5. # 拉取node镜像
    7. FROM node:16-alpine
    10. #参数，node的环境为生产环境
    12. ENV NODE_ENV=production
    15. #容器内创建目录blog
    17. RUN mkdir -p /blog
    20. #复制当前的内容到容器内容部目录portal
    22. COPY .output/ ./blog
    25. #切换工作目录到blog
    27. WORKDIR /blog
    28. ENV HOST 0.0.0.0
    31. #RUN npm config set registry https://registry.npmmirror.com
    35. #设置外部访问端口，Nuxt的默认端口，如果需要转化在 Docker 启动的时候转化
    37. EXPOSE 3000
    40. # 运行命令以启动应用程序
    42. CMD ["node","./server/index.mjs"]
    2. # 打包项目镜像
    4. docker build -t blog .
    2. # 运行镜像
    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
    5. # 拉取node镜像
    7. FROM node:16-alpine
    10. #容器内创建目录blog
    12. RUN mkdir -p /app
    15. #切换工作目录到app
    17. WORKDIR /app
    20. #参数，node的环境为生产环境
    22. ENV NODE_ENV=production
    23. COPY ./package*.json /app
    26. # 安装项目的生产依赖，而不安装开发依赖
    28. RUN npm install
    30. COPY ./ /app
    32. EXPOSE 3000
    34. CMD ["npm", "start"]
    2. # 打包项目镜像
    4. docker build -t nextblog .
    2. # 运行镜像
    4. docker run --name nextblog -d -p 3006:3000 nextblog

7. Docker中部署Nest项目

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

    2. # 设定环境
    4. FROM node:16-alpine
    7. # 设置时区
    9. ENV TZ=Asia/Shanghai
    12. #参数，node的环境为生产环境
    14. ENV NODE_ENV=production
    17. #容器内创建目录blog
    19. RUN mkdir -p /app
    22. # 指定工作目录
    24. WORKDIR /app
    27. # 复制当前代码到/app工作目录
    29. COPY ./ ./
    32. # npm 安装依赖
    34. COPY package.json /app/package.json
    35. RUN cd /app && rm -rf /app/node_modules &&  npm install
    38. #设置外部访问端口
    40. EXPOSE 3000
    43. # 运行命令以启动应用程序
    45. CMD [ "node", "dist/main" ]
    2. # 打包项目镜像
    4. docker build -t nestblog .
    2. # 运行镜像
    4. docker run --name nestblog -d -p 9000:3000 nestblog
    2. # 进入容器内部
    4. docker exec -it mysql57 bash
    2. # 登录Mysql，新建数据库之后导入
    4. mysql -uroot -p123456
    5. mysql> create DATABASE bootblog;
    6. mysql> mysql -uroot -p123456 -D bootblog < bootblog.sql
    7. mysql> show databases;

8. Docker中部署Go项目

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

    2. # 定义打包环境 build.sh
    5. # 然后在命令行运行 build.sh
    7. GOOS=linux GOARCH=amd64 go build main.go
    2. # 定义版本
    4. FROM golang:1.18 as golang
    7. #容器内创建目录blog
    9. RUN mkdir -p /blog
    12. # 进入工作目录
    14. WORKDIR /blog
    15. COPY . .
    18. # 暴露服务端口
    20. EXPOSE 4001
    22. RUN chmod +x main
    25. # 容器启动时运行的命令
    27. ENTRYPOINT ["./main"]
    2. # 打包项目镜像
    4. docker build -t goblog .
    2. # 运行镜像
    4. docker run --name goblog -d -p 4001:4001 goblog
添加新批注
在作者公开此批注前，只有你和作者可见。
回复批注