当前位置: 首页 > 工具软件 > vue-mb-touch > 使用案例 >

Linux CentoOS7上部署docker到测试分布式项目若依-vue部署及环境搭建

卞轶
2023-12-01

Linux 服务器搭建

环境搭建

一、CentoOS7防火墙及端口

#查看防火墙状态
systemctl status firewalld
表示防火墙开启中 active (running)
表示防火墙关闭中 inactive (dead)
#关闭防火墙
systemctl stop firewalld
#开启防火墙
systemctl start firewalld

1、开放端口
firewall-cmd --zone=public --add-port=3306/tcp --permanent # 开放3306端口
firewall-cmd --zone=public --remove-port=5672/tcp --permanent  #关闭3306端口
firewall-cmd --reload   # 配置立即生效
2、查看防火墙所有开放的端口
firewall-cmd --zone=public --list-ports
3、关闭防火墙
如果要开放的端口太多,嫌麻烦,可以关闭防火墙,安全性自行评估
systemctl stop firewalld.service
4、查看防火墙状态
firewall-cmd --state
5、centos7默认没有 netstat 命令,需要安装 net-tools 工具,yum install -y net-tools
netstat -lnpt 
6、检查端口被哪个进程占用
netstat -lnpt |grep 5672
7、查看进程的详细信息
ps 6832
8、中止进程
kill -9 6832

二、安装Docker

1)Docker命令

1.CentoOS7安装
# 1、yum 包更新到最新 
yum update
# 2、安装需要的软件包, yum-util 提供yum-config-manager功能,另外两个是devicemapper驱动依赖的 
yum install -y yum-utils device-mapper-persistent-data lvm2
# 3、 设置yum源
yum-config-manager --add-repo https://download.docker.com/linux/centos/docker-ce.repo
# 4、 安装docker,出现输入的界面都按 yes 
yum install -y docker-ce
# 5、 查看docker版本,验证是否验证成功
docker -v
2.配置阿里云的镜像加速器
# 复制到黑窗口回车。去阿里云镜像服务里的镜像加速器
sudo mkdir -p /etc/docker
sudo tee /etc/docker/daemon.json <<-'EOF'
{
  "registry-mirrors": ["https://yb6xo92e.mirror.aliyuncs.com"]
}
EOF
sudo systemctl daemon-reload
sudo systemctl restart docker
3.Docker进程相关命令
启动docker服务:
systemctl start docker 
停止docker服务:
systemctl stop docker 
重启docker服务:
systemctl restart docker
查看docker服务状态:
systemctl status docker 
设置开机启动docker服务:
systemctl enable docker
4.Docker镜像相关命令
# 查看镜像: 查看本地所有的镜像
docker images
docker images –q # 查看所用镜像的id
#搜索镜像:从网络中查找需要的镜像
docker search 镜像名称 #docker search redise
#拉取镜像:从Docker仓库下载镜像到本地,镜像名称格式为 名称:版本号,如果版本号不指定则是最新的版本。如果不知道镜像版本,可以去docker hub 搜索对应镜像查看。
docker pull 镜像名称 #docker pull redis:5.0
#删除镜像: 删除本地镜像
docker rmi 镜像id # 删除指定本地镜像docker rmi 15e36694d7df
docker rmi `docker images -q`  # 删除所有本地镜像
5.Docker容器相关命令
#查看容器
docker ps # 查看正在运行的容器
docker ps -a # 查看所有容器
docker ps -aq #查看所有容器id
#创建并启动容器
docker run 参数 
  #eg1: docker run -it --name=cli centos:7 /bin/bash  创建容器并进入退出关闭
  #eg2:docker run -id --name=cli2 centos:7 /bin/bash  创建容器并进入退出容器仍然运行

   参数说明:
    -i:保持容器运行。通常与 -t 同时使用。加入it这两个参数后,容器创建后     自动进入容器中,退出容器后,容器自动关闭。
    -t:为容器重新分配一个伪输入终端,通常与 -i 同时使用。
    -d:以守护(后台)模式运行容器。创建一个容器在后台运行,需要使用         docker exec 进入容器。退出后,容器不会关闭。
    -it 创建的容器一般称为交互式容器,-id 创建的容器一般称为守护式容器
    --name:为创建的容器命名。
#退出容器
exit
#进入容器
docker exec 参数 # docker exec -it cli2 /bin/bash退出容器,容器会关闭
#停止容器
docker stop 容器名称 #docker stop cli2
#启动容器
docker start 容器名称
#删除容器:如果容器是运行状态则删除失败,需要停止容器删除
docker rm 容器名称 #docker rm cli
#删除所有容器
docker rm c1 c2 c3 c4
docker rm `docker ps -aq`
#查看容器信息
docker inspect 容器名称 #docker inspect cli2

2)Docker 容器的数据卷

数据卷持久化
#数据卷
是宿主机中的一个目录或文件
当容器目录和数据卷目录绑定后,对方的修改会立即同步
一个数据卷可以被多个容器同时挂载
一个容器也可以被挂载多个数据卷
#数据卷作用
容器数据持久化
外部机器和容器间接通信
容器之间数据交换
配置数据卷
#创建启动容器时,使用 –v(挂载) 参数 设置数据卷
docker run ... –v 宿主机目录(文件):容器内目录(文件) ... 
  # eg:docker run -it --name=cli -v /root/data:/root/data_container centos:7 /bin/bash 
  注意事项:
        1. 目录必须是绝对路径
        2. 如果目录不存在,会自动创建
        3. 可以挂载多个数据卷
#切换根目录
cd~  #cd data;ll;touch haha.txt 创建文本;echo itcast >a.txt 写内容进入文本;cat a.txt 进入文件查看

#一个容器挂载多个数据卷,\代表没输完换行可以继续
docker run  -it --name=c2 \
> -v ~/data2:/root/data2 \
> -v ~/data3:/root/data3 \
> centos:7
#两个容器挂载一个数据卷
docker run -it --name=c1 -v /root/data:/root/data_container centos:7 /bin/bash 
docker run -it --name=c2 -v /root/data:/root/data_container centos:7 /bin/bash 
数据卷容器

概念:

多容器进行数据交换
       1. 多个容器挂载同一个数据卷
       2. 数据卷容器

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-P9Hom0p6-1631003024663)(D:\个人\小宝库\linux\assets\1630652438051.png)]

配置数据卷容器

#创建启动c3数据卷容器,使用 –v 参数 设置数据卷
docker run -it --name=c3 -v /volume centos:7 /bin/bash #宿主机/volume目录,右边不写自动创建一个
#创建启动 c1 c2 容器,使用 –-volumes-from 参数 设置数据卷
docker run -it --name=c1 --volumes-from c3 centos:7 /bin/bash
docker run -it --name=c2 --volumes-from c3 centos:7 /bin/bash  

Docker 应用部署

一、部署MySQL

MySQL部署

搜索mysql镜像
拉取mysql镜像
创建容器
操作容器中的mysql

容器内的网络服务和外部机器不能直接通信
外部机器和宿主机可以直接通信
宿主机和容器可以直接通信
当容器中的网络服务需要被外部机器访问时,可以将容器中提供服务的端口映射到宿主机的端口上。外部机器访问宿主机的该端口,从而间接访问容器的服务。
这种操作称为:端口映射

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-PCEaioyQ-1631003024665)(D:\个人\小宝库\linux\assets\1630656305763.png)]

  1. 搜索mysql镜像
docker search mysql
  1. 拉取mysql镜像
docker pull mysql:5.6
  1. 创建容器,设置端口映射、目录映射
# 在/root目录下创建mysql目录用于存储mysql数据信息
mkdir ~/mysql
cd ~/mysql
docker run -id \
-p 3307:3306 \
--name=c_mysql \
-v $PWD/conf:/etc/mysql/conf.d \
-v $PWD/logs:/logs \
-v $PWD/data:/var/lib/mysql \
-e MYSQL_ROOT_PASSWORD=123456 \
mysql:5.6
  • 参数说明:
    • -p 3307:3306:将容器的 3306 端口映射到宿主机的 3307 端口。
    • -v $PWD/conf:/etc/mysql/conf.d:将主机当前目录下的 conf/my.cnf 挂载到容器的 /etc/mysql/my.cnf。配置目录
    • -v $PWD/logs:/logs:将主机当前目录下的 logs 目录挂载到容器的 /logs。日志目录
    • -v $PWD/data:/var/lib/mysql :将主机当前目录下的data目录挂载到容器的 /var/lib/mysql 。数据目录
    • **-e MYSQL_ROOT_PASSWORD=123456:**初始化 root 用户的密码。
  1. 进入容器,操作mysql
docker exec –it c_mysql /bin/bash
  1. 使用外部机器连接容器中的mysql

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-lrV9OmcB-1631003024668)(E:/%E7%94%9F%E6%B4%BB%E8%BD%AF%E4%BB%B6%E6%95%B0%E6%8D%AE/%E7%99%BE%E5%BA%A6%E7%BD%91%E7%9B%98%E6%96%87%E4%BB%B6/%E8%B5%84%E6%96%99/imgs/1573636765632.png)]

二、部署Tomcat

  1. 搜索tomcat镜像
docker search tomcat
  1. 拉取tomcat镜像
docker pull tomcat
  1. 创建容器,设置端口映射、目录映射
# 在/root目录下创建tomcat目录用于存储tomcat数据信息
mkdir ~/tomcat
cd ~/tomcat
docker run -id --name=c_tomcat \
-p 8080:8080 \
-v $PWD:/usr/local/tomcat/webapps \
tomcat 
  • 参数说明:

    • **-p 8080:8080:**将容器的8080端口映射到主机的8080端口

      **-v $PWD:/usr/local/tomcat/webapps:**将主机中当前目录挂载到容器的webapps

  1. 使用外部机器访问tomcat

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-hwauTttU-1631003024671)(E:/%E7%94%9F%E6%B4%BB%E8%BD%AF%E4%BB%B6%E6%95%B0%E6%8D%AE/%E7%99%BE%E5%BA%A6%E7%BD%91%E7%9B%98%E6%96%87%E4%BB%B6/%E8%B5%84%E6%96%99/imgs/1573649804623.png)]

三、部署Nginx

  1. 搜索nginx镜像
docker search nginx
  1. 拉取nginx镜像
docker pull nginx
  1. 创建容器,设置端口映射、目录映射
# 在/root目录下创建nginx目录用于存储nginx数据信息
mkdir ~/nginx
cd ~/nginx
mkdir conf
cd conf
# 在~/nginx/conf/下创建nginx.conf文件,粘贴下面内容
vim nginx.conf
user  nginx;
worker_processes  1;

error_log  /var/log/nginx/error.log warn;
pid        /var/run/nginx.pid;


events {
    worker_connections  1024;
}


http {
    include       /etc/nginx/mime.types;
    default_type  application/octet-stream;

    log_format  main  '$remote_addr - $remote_user [$time_local] "$request" '
                      '$status $body_bytes_sent "$http_referer" '
                      '"$http_user_agent" "$http_x_forwarded_for"';

    access_log  /var/log/nginx/access.log  main;

    sendfile        on;
    #tcp_nopush     on;

    keepalive_timeout  65;

    #gzip  on;

    include /etc/nginx/conf.d/*.conf;
}


docker run -id --name=c_nginx \
-p 80:80 \
-v $PWD/conf/nginx.conf:/etc/nginx/nginx.conf \
-v $PWD/logs:/var/log/nginx \
-v $PWD/html:/usr/share/nginx/html \
nginx
  • 参数说明:
    • -p 80:80:将容器的 80端口映射到宿主机的 80 端口。
    • -v $PWD/conf/nginx.conf:/etc/nginx/nginx.conf:将主机当前目录下的 /conf/nginx.conf 挂载到容器的 :/etc/nginx/nginx.conf。配置目录
    • -v $PWD/logs:/var/log/nginx:将主机当前目录下的 logs 目录挂载到容器的/var/log/nginx。日志目录
  1. 使用外部机器访问nginx

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-mQsW2SPw-1631003024674)(E:/%E7%94%9F%E6%B4%BB%E8%BD%AF%E4%BB%B6%E6%95%B0%E6%8D%AE/%E7%99%BE%E5%BA%A6%E7%BD%91%E7%9B%98%E6%96%87%E4%BB%B6/%E8%B5%84%E6%96%99/imgs/1573652396669.png)]

四、部署Redis

  1. 搜索redis镜像
docker search redis
  1. 拉取redis镜像
docker pull redis:5.0
  1. 创建容器,设置端口映射
docker run -id --name=c_redis -p 6379:6379 redis:5.0
  1. 使用外部机器连接redis
./redis-cli.exe -h 192.168.149.135 -p 6379

Dockerfile

Docker镜像原理

Docker镜像是由特殊的文件系统叠加而成
最底端是 bootfs,并使用宿主机的bootfs 
第二层是 root文件系统rootfs,称为base image
然后再往上可以叠加其他的镜像文件
统一文件系统(Union File System)技术能够将不同的层整合成一个文件系统,为这些层提供了一个统一的视角,这样就隐藏了多层的存在,在用户的角度看来,只存在一个文件系统。 
一个镜像可以放在另一个镜像的上面。位于下面的镜像称为父镜像,最底部的镜像成为基础镜像。
当从一个镜像启动容器时,Docker会在最顶层加载一个读写文件系统作为容器

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-VMdlRskh-1631003024679)(D:\个人\小宝库\linux\assets\1630662373706.png)]

关键字作用备注
FROM指定父镜像指定dockerfile基于那个image构建
MAINTAINER作者信息用来标明这个dockerfile谁写的
LABEL标签用来标明dockerfile的标签 可以使用Label代替Maintainer 最终都是在docker image基本信息中可以查看
RUN执行命令执行一段命令 默认是/bin/sh 格式: RUN command 或者 RUN [“command” , “param1”,“param2”]
CMD容器启动命令提供启动容器时候的默认命令 和ENTRYPOINT配合使用.格式 CMD command param1 param2 或者 CMD [“command” , “param1”,“param2”]
ENTRYPOINT入口一般在制作一些执行就关闭的容器中会使用
COPY复制文件build的时候复制文件到image中
ADD添加文件build的时候添加文件到image中 不仅仅局限于当前build上下文 可以来源于远程服务
ENV环境变量指定build时候的环境变量 可以在启动的容器的时候 通过-e覆盖 格式ENV name=value
ARG构建参数构建参数 只在构建的时候使用的参数 如果有ENV 那么ENV的相同名字的值始终覆盖arg的参数
VOLUME定义外部可以挂载的数据卷指定build的image那些目录可以启动的时候挂载到文件系统中 启动容器的时候使用 -v 绑定 格式 VOLUME [“目录”]
EXPOSE暴露端口定义容器运行的时候监听的端口 启动容器的使用-p来绑定暴露端口 格式: EXPOSE 8080 或者 EXPOSE 8080/udp
WORKDIR工作目录指定容器内部的工作目录 如果没有创建则自动创建 如果指定/ 使用的是绝对地址 如果不是/开头那么是在上一条workdir的路径的相对路径
USER指定执行用户指定build或者启动的时候 用户 在RUN CMD ENTRYPONT执行的时候的用户
HEALTHCHECK健康检查指定监测当前容器的健康监测的命令 基本上没用 因为很多时候 应用本身有健康监测机制
ONBUILD触发器当存在ONBUILD关键字的镜像作为基础镜像的时候 当执行FROM完成之后 会执行 ONBUILD的命令 但是不影响当前镜像 用处也不怎么大
STOPSIGNAL发送信号量到宿主机该STOPSIGNAL指令设置将发送到容器的系统调用信号以退出。
SHELL指定执行脚本的shell指定RUN CMD ENTRYPOINT 执行命令的时候 使用的shell

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-8TVPONQe-1631003024683)(D:\个人\小宝库\linux\assets\1630662795299.png)]

Docker Compose

一、安装Docker Compose

# Compose目前已经完全支持Linux、Mac OS和Windows,在我们安装Compose之前,需要先安装Docker。下面我 们以编译好的二进制包方式安装在Linux系统中。 
curl -L https://github.com/docker/compose/releases/download/1.22.0/docker-compose-`uname -s`-`uname -m` -o /usr/local/bin/docker-compose
# 设置文件可执行权限 
chmod +x /usr/local/bin/docker-compose
# 查看版本信息 
docker-compose -version

二、卸载Docker Compose

# 二进制包方式安装的,删除二进制文件即可
rm /usr/local/bin/docker-compose

三、 使用docker compose编排nginx+springboot项目

  1. 创建docker-compose目录
mkdir ~/docker-compose
cd ~/docker-compose
  1. 编写 docker-compose.yml 文件
version: '3.3'
services:
  nginx:
   image: nginx
   ports:
    - 80:80
   links:
    - app
   volumes:
    - ./nginx/conf.d:/etc/nginx/conf.d
  app:
    image: app
    expose:
      - "8080"
  1. 创建./nginx/conf.d目录
mkdir -p ./nginx/conf.d
  1. 在./nginx/conf.d目录下 编写itheima.conf文件
server {
    listen 80;
    access_log off;

    location / {
        proxy_pass http://app:8080;
    }
   
}
  1. 在~/docker-compose 目录下 使用docker-compose 启动容器
docker-compose up
  1. 测试访问
http://192.168.149.135/hello

Docker 私有仓库

一、私有仓库搭建

# 1、拉取私有仓库镜像 
docker pull registry
# 2、启动私有仓库容器 
docker run -id --name=registry -p 5000:5000 registry
# 3、打开浏览器 输入地址http://私有仓库服务器ip:5000/v2/_catalog,看到{"repositories":[]} 表示私有仓库 搭建成功
# 4、修改daemon.json   
vim /etc/docker/daemon.json    
# 在上述文件中添加一个key,保存退出。此步用于让 docker 信任私有仓库地址;注意将私有仓库服务器ip修改为自己私有仓库服务器真实ip 
{"insecure-registries":["私有仓库服务器ip:5000"]} 
# 5、重启docker 服务 
systemctl restart docker
docker start registry

二、将镜像上传至私有仓库

# 1、标记镜像为私有仓库的镜像     
docker tag centos:7 私有仓库服务器IP:5000/centos:7
 
# 2、上传标记的镜像     
docker push 私有仓库服务器IP:5000/centos:7

三、 从私有仓库拉取镜像

#拉取镜像 
docker pull 私有仓库服务器ip:5000/centos:7

镜像上传DockerHub

# commit一个容器
docker commit 容器名ID 仓库名/版本名:版本号 # docker commit dfecf98e9821 xiaofeiwasai/demo:1.0
# 登录一个DockerHub帐号
docker login  #输入账号密码
# push刚才的镜像
docker push xiaofeiwasai/demo:1.0
# 验证一下
docker inspect xiaofeiwasai/demo:1.0

构建初始化后的mysql容器部署springboot后端ruoyi项目

1.思路

我们就是要自己制作个Mysql镜像,命名为ruoyimysql,然后初始化若依项目里面的sql文件。大体思路就是初始化ruoyimysql容器时候,将表结构以及数据导入进去。

2.准备工作

我们在根目录(root)下的 ruoyi文件夹下面创建 docker-mysql 这个文件夹,里面文件如下:

  ruoyi
   |_ 
    |__Dockerfile
    |__ruoyi.jar
    |__
       ├── Dockerfile
       ├── init
       │   ├── quartz.sql
       │   └── ry_20210210.sql
       └── utf8mb4.cnf

打包前注释掉:@PostConstruct

Dockerfile`是构建aap.jar的依据,内容如下:

FROM java:8
# 维护者
MAINTAINER xiuyi<kid0510z@163.com>
# copy jar包 命名为 aap.jar
COPY *.jar /app.jar
# 暴露端口
EXPOSE 8080
# 启动 jar包 可通过 PARAM 配置启动参数
ENTRYPOINT java  ${PARAM} -jar app.jar

Dockerfile`是构建ruoyimysql的依据,内容如下:

FROM mysql
COPY utf8mb4.cnf /etc/mysql/conf.d/utf8mb4.cnf
COPY ./init /docker-entrypoint-initdb.d/

init文件中就是要执行的sql文件,注意,sql语句中如果没有创建数据库语句,必须在构建实例时候指定数据库名称

utf8mb4.cnf就是设置数据库字符编码的,否则会乱码的,内容如下:

init_connect='SET NAMES utf8mb4'
character-set-server=utf8mb4
collation-server = utf8mb4_unicode_ci
default-time_zone = '+8:00'
[mysql]
default-character-set=utf8mb4
[client]
default-character-set=utf8mb4

3. 构建Mysql镜像

然后我们使用docker build -t ruoyimysql . build我们的镜像,记得最后有个点,表示从当前目录找Dockerfile,然后单独测试下我们构建的镜像

4. 单独测试镜像

使用命令启动

docker run -d -p 3306:3306 --name=ruoyimysql -e MYSQL_ROOT_PASSWORD=ROOT -e MYSQL_DATABASE=ry-vue ruoyimysql

5. 调整项目

我们在idea中将flyway相关的东西全部移除掉,这时候我们需要将项目中的初始化操作的逻辑调整下顺序,将这三个@PostConstruct注解都注释掉,然后在启动类里去掉用这三个service的init方法。

上传jar包,我们为了一键部署,我们需要将我们的jar包制作成镜像。在Dockerfile目录执行 docker build -t ruoyiapp . ,别忘了最后有个点,

ruoyiapp服务的build: .需要去掉,因为我们已经构建成docker镜像了。

6. 测试

我们的最终docker-compose.yml文件如下:(只需要修改mysql和ruoyiapp镜像即可)

version: "3.3"
services:
  # mysql服务
  mysql:
    image: ruoyimysql #镜像写成自己构建的名称
    volumes:
      - ./mysql:/var/lib/mysql
    restart: always
    container_name: ruoyi-mysql
    ports:
      - 3306:3306
    environment:
      - MYSQL_ROOT_PASSWORD=songweiwei
      - MYSQL_DATABASE=ry-vue
      - MYSQL_USER=ruoyi
      - MYSQL_PASSWORD=ruoyi
  # redis服务
  redis:
    image: library/redis:alpine
    container_name: ruoyi-redis
    ports:
      - 6379:6379
    # 给redis设置密码
    command: redis-server --requirepass songweiwei --appendonly yes
    volumes:
      - ./redis/data:/data
  # 构建若依后端
  ruoyiapp:
    # 镜像来源 自己构建的
    image: ruoyiapp
    restart: always
    container_name: ruoyi-app
    # 对外暴露端口 8080
    ports:
      - 8080:8080
    # 后端项目需要的配置,可修改
    environment:
      - REDIS_HOST=redis
      - REDIS_PORT=6379
      - REDIS_DATABASE=0
      - REDIS_PASSWORD=songweiwei
      - MYSQL_HOST=mysql
      - MYSQL_PORT=3306
      - MYSQL_DATABASE=ry-vue
      - MYSQL_USERNAME=ruoyi
      - MYSQL_PASSWORD=ruoyi
    depends_on:
      - redis
      - mysql
    links:
      - redis
      - mysql

docker-compose up --build -d,然后我们启动查看日志。

docker-compose down -v关闭容器

使用 curl localhost:8080测试,下图表示成功

构建初始化后的mysql容器部署springboot前端ruoyi项目

1.打包ruoyi-ui文件

下载若依项目,然后进入到ruoyi-ui这个工程,根据文档使用 npm run build:prod打包项目

2.创建目录,并上传

mkdir /ruoyi/docker-nginx -p

目录如下:

├── default.conf #nginx配置
├── dist # ruoyi-ui打包文件
└── Dockerfile

3.Nginx配置文件编写

nginx配置文件:主要配置域名和端口转发,点我查看文档,内容如下:

server {
    listen       80;
    server_name  localhost;

    location / {
            root   /data/dist;
            index  index.html index.htm;
                 try_files $uri $uri/ /index.html;
    }

   location /prod-api/ {
      proxy_pass  http://127.0.0.1:8080/; # 转发规则
      proxy_set_header Host $proxy_host; # 修改转发请求头,让8080端口的应用可以受到真实的请求
      proxy_set_header X-Real-IP $remote_addr;
      proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
    }
}

4.Dockerfile文件编写

FROM nginx
MAINTAINER xiuyi/kid0510z@163.com
ENV RUN_USER nginx
ENV RUN_GROUP nginx
ENV DATA_DIR /data/dist
ENV LOG_DIR /data/log/nginx
RUN mkdir /data/log/nginx -p
RUN chown nginx.nginx -R /data/log/nginx
ADD dist /data/dist
ADD default.conf /etc/nginx/conf.d/default.conf
EXPOSE 80
ENTRYPOINT nginx -g "daemon off;"

5.构建测试

docker build -t ruoyiweb .
docker run -p 8088:80 --name ruoyi-web ruoyiweb

Docker部署若依项目(整合)

我们在ruoyiapp项目连接mysql时候,我们直接写的mysql服务的服务名字(yml文件中services的下一层),nginx也是同理,我们有两种做法:

我们可以在编写yml文件中进行目录挂载,我们需要提前准备好个nginx的配置文件,然后配置下目录挂载,

我们重新构建ruoyiweb这个镜像,里面的转发ip直接写 我们 ruoyiapp的服务名称

这样启动的话,默认会读取我们在ruoyiweb这个镜像里面的nginx配置文件(制作镜像时候copy进去的),那时候转发的ip是127.0.0.1,我们需要修改当时的nginx配置。

这两种做法各有利弊,第一种比较灵活,我们还可以单独配置若依后端服务的端口,第二种的话不用返工了,更加符合一键部署,但是如果后端服务端口变化了,只能使用第一种了。

这里我就采用第一种方式,直接目录挂载,修改nginx配置,覆盖ruoyiweb镜像的nginx配置,我们在/ruoyi/nginx目录创建default.conf文件,内容为如下:

server {
    listen       80;
    server_name  localhost;

    location / {
            root   /data/dist;
            index  index.html index.htm;
                 try_files $uri $uri/ /index.html;
    }

   location /prod-api/ {
      proxy_pass  http://ruoyiapp:8080/; # 转发规则 ip写后端服务名称
      proxy_set_header Host $proxy_host; # 修改转发请求头,让8080端口的应用可以受到真实的请求
      proxy_set_header X-Real-IP $remote_addr;
      proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
    }
}

最终docker-compose.yml文件(注意这个文件用ANSI编码)

version: "3.8"
services:
  # mysql服务
  mysql:
    image: ruoyimysql
    volumes:
      - ./mysql:/var/lib/mysql
    restart: always
    container_name: ruoyi-mysql
    ports:
      - 3306:3306
    environment:
      - MYSQL_ROOT_PASSWORD=songweiwei
      - MYSQL_DATABASE=ry-vue
      - MYSQL_USER=ruoyi
      - MYSQL_PASSWORD=ruoyi
  # redis服务
  redis:
    image: library/redis:alpine
    container_name: ruoyi-redis
    ports:
      - 6379:6379
    # 给redis设置密码
    command: redis-server --requirepass songweiwei --appendonly yes
    volumes:
      - ./redis/data:/data
  # 构建若依后端
  ruoyiapp:
    # 镜像来源 自己构建的
    image: ruoyiapp
    # build值为 . 表示从当前目录找Dockerfile进行构建
    build: .
    container_name: ruoyi-app
    # 对外暴露端口 8080
    ports:
      - 8080:8080
    # 后端项目需要的配置,可修改
    environment:
      - REDIS_HOST=redis
      - REDIS_PORT=6379
      - REDIS_DATABASE=0
      - REDIS_PASSWORD=songweiwei
      - MYSQL_HOST=mysql
      - MYSQL_PORT=3306
      - MYSQL_DATABASE=ry-vue
      - MYSQL_USERNAME=ruoyi
      - MYSQL_PASSWORD=ruoyi
    depends_on:
      - redis
      - mysql
    links:
      - redis
      - mysql

  # 构建若依前端
  ruoyiweb:
    image: ruoyiweb
    container_name: ruoyi-web
    ports:
      - 8088:80
    volumes:
      - /root/ruoyi/nginx/default.conf:/etc/nginx/conf.d/default.conf
    depends_on:
      - ruoyiapp
    links:
      - ruoyiapp

四、启动测试

当前目录结构

├── docker-compose.yml
└── nginx
    └── default.conf

使用docker-compose up -d启动 或 docker-compose up --build -d

浏览器访问 (出现验证码图片就表示成功,验证码是后端返回的)

 类似资料: