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)]

搜索mysql镜像

docker search mysql

拉取mysql镜像

docker pull mysql:5.6

# 在/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 用户的密码。

进入容器，操作mysql

docker exec –it c_mysql /bin/bash

使用外部机器连接容器中的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

搜索tomcat镜像

docker search tomcat

拉取tomcat镜像

docker pull tomcat

# 在/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

使用外部机器访问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

搜索nginx镜像

docker search nginx

拉取nginx镜像

docker pull nginx

# 在/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。日志目录

使用外部机器访问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

搜索redis镜像

docker search redis

拉取redis镜像

docker pull redis:5.0

创建容器，设置端口映射

docker run -id --name=c_redis -p 6379:6379 redis:5.0

使用外部机器连接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项目

mkdir ~/docker-compose
cd ~/docker-compose

编写 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"

mkdir -p ./nginx/conf.d

在./nginx/conf.d目录下编写itheima.conf文件

server {
    listen 80;
    access_log off;

    location / {
        proxy_pass http://app:8080;
    }
   
}

在~/docker-compose 目录下使用docker-compose 启动容器

docker-compose up

测试访问

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

浏览器访问（出现验证码图片就表示成功，验证码是后端返回的）