springboot前后端分离、一键无感更新、优雅停机、感知启动完成；maven、git、java17、若依、nginx、docker、docker-compose、jenkins、linux、sh

小小猿JiaHao

968人浏览 · 2025-03-18 15:51:16

小小猿JiaHao · 2025-03-18 15:51:16 发布

springboot前后端分离、优雅停机、感知启动完成、一键无感更新、maven、git、java17、若依、nginx、docker、docker-compose、jenkins、linux、sh 教程

若依前后端分离项目,一键无感优雅更新部署方案

1、大体思路

1.1相关中间件

一台linux服务器，安装docker、安装docker-compose

使用docker容器部署，1个容器网关nginx转发端口控制，2个容器nginx部署前端，2个容器jdk17部署后端

使用git客户端拉取，

使用网关nginx配置ssl，做前端端口（80到82、83）和后端端口（8080到8082、8083）的转发，负载

使用maven打包后端jar，

其中springboot配置优雅停机、配置健康检查，

server:
  shutdown: graceful #优雅停

#健康检查
management:
  endpoints:
    web:
      exposure:
        include: health #readiness,health,info
  health:
    rabbit:
      enabled: false

使用node打包前端，2个前端nginx也配置优雅停机

使用tomcat jenkins.war执行sh脚本，一键无感更新部署,（如果可以直连服务器，使用bat脚本，结合winscp等客户端工具连接服务器，一键执行脚本）

1.2相关逻辑

使用sh脚本实现相关逻辑

前端逻辑

git拉取代码，node打包，重新打包前端docker镜像, 切换nginx只能访问前端2，停止前端1（优雅停机），启动前端1，检查前端1等待就绪，切换nginx只能访问前端1，停止前端2（优雅停机），启动前端2，检查前端2等待就绪，切换nginx可访问前端1和前端2

后端逻辑

git拉取代码，maven打包，重新打包后端docker镜像, 切换nginx只能访问后端2，停止后端1（优雅停机），启动后端1，检查后端1等待就绪，切换nginx只能访问后端1，停止后端2（优雅停机），启动后端2，检查后端2等待就绪，切换nginx可访问后端1和后端2

2、相关配置和部署脚本

2.1 docker-compose启动

/home/deploy/docker-compose-double/docker-compose.yml

version: '3.8'

services:
  projectnginx:
    build:
      context: /home/deploy/dockerFile/projectnginx
      dockerfile: Dockerfile
    image: projectnginx:latest
    container_name: projectnginx
    restart: unless-stopped
    environment:
      - TZ=Asia/Shanghai
    ports:
      - "80:80"
      - "8080:8080"
    volumes:
      - /home/deploy/dockerFile/projectnginx/conf:/etc/nginx/conf.d


  project1:
    build:
      context: /home/deploy/dockerFile/project1
      dockerfile: Dockerfile
    image: project1:latest
    container_name: project1
    restart: unless-stopped
    environment:
      - TZ=Asia/Shanghai
    ports:
      - "8082:8080"
    volumes:
      - /home/deploy/dockerFile/project1/myproject:/usr/myproject

  project2:
    build:
      context: /home/deploy/dockerFile/project2
      dockerfile: Dockerfile
    image: project2:latest
    container_name: project2
    restart: unless-stopped
    environment:
      - TZ=Asia/Shanghai
    ports:
      - "8083:8080"
    volumes:
      - /home/deploy/dockerFile/project2/myproject:/usr/myproject

  projectui1:
    build:
      context: /home/deploy/dockerFile/projectui1
      dockerfile: Dockerfile
    image: projectui1:latest
    container_name: projectui1
    restart: unless-stopped
    environment:
      - TZ=Asia/Shanghai
    ports:
      - "82:80"
    volumes:
      - /home/deploy/dockerFile/projectui1/conf/nginx.conf:/etc/nginx/nginx.conf
      - /home/deploy/dockerFile/projectui1/conf/default.conf:/etc/nginx/conf.d/default.conf
      - /home/deploy/dockerFile/projectui1/project_ui:/usr/project_ui

  projectui2:
    build:
      context: /home/deploy/dockerFile/projectui2
      dockerfile: Dockerfile
    image: projectui2:latest
    container_name: projectui2
    restart: unless-stopped
    environment:
      - TZ=Asia/Shanghai
    ports:
      - "83:80"
    volumes:
      - /home/deploy/dockerFile/projectui2/conf/nginx.conf:/etc/nginx/nginx.conf
      - /home/deploy/dockerFile/projectui2/conf/default.conf:/etc/nginx/conf.d/default.conf
      - /home/deploy/dockerFile/projectui2/project_ui:/usr/project_ui

/home/deploy/docker-compose-double/docker-compose.sh

cd /home/deploy/docker-compose-double
#1、删除
docker-compose down
#2、构建启动
docker-compose up -d --build

2.2 dockerFile与conf

2.2.1 projectnginx

2.2.1.1dockerFile

/home/deploy/dockerFile/projectnginx/dockerFile

FROM nginx:1.21.3
LABEL maintainer=zhong
ENV TZ=Asia/Shanghai
RUN ln -snf /usr/share/zoneinfo/$TZ /etc/localtime && echo $TZ > /etc/timezone
WORKDIR  /usr
EXPOSE 80 443

2.2.1.2前端配置

前端80端口转发 /home/deploy/dockerFile/projectnginx/conf/default.conf

#前端80端口配置
upstream backend80 {
    server 你的IP:82;
    server 你的IP:83;
}

server {
    listen 80;

    location / {
        proxy_pass http://backend80/;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;
    }
}

允许访问2个后端服务 /home/deploy/dockerFile/projectnginx/conf/projectui/allowall/default.conf

同上

只允许访问后端1 /home/deploy/dockerFile/projectnginx/conf/projectui/onlyallowprojectui1/default.conf

#前端80端口配置
upstream backend80 {
    server 你的IP:82;
}

server {
    listen 80;

    location / {
        proxy_pass http://backend80/;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;
    }
}

只允许访问后端2 /home/deploy/dockerFile/projectnginx/conf/projectui/onlyallowprojectui2/default.conf

#前端80端口配置
upstream backend80 {
    server 你的IP:83;
}

server {
    listen 80;

    location / {
        proxy_pass http://backend80/;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;
    }
}

2.2.1.3后端配置

后端8080端口转发 /home/deploy/dockerFile/projectnginx/conf/default8080.conf

#后端8080端口配置
upstream backend8080 {
    server 你的IP:8082;
    server 你的IP:8083;
}

server {
    listen 8080;

    location / {
        proxy_pass http://backend8080/;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;
    }
}

允许访问2个前端 /home/deploy/dockerFile/projectnginx/conf/project/allowall/default8080.conf

同上

只允许访问后端1 /home/deploy/dockerFile/projectnginx/conf/project/onlyallowproject1/default8080.conf

#后端8080端口配置
upstream backend8080 {
    server 你的IP:8082;
}

server {
    listen 8080;

    location / {
        proxy_pass http://backend8080/;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;
    }
}

只允许访问后端2 /home/deploy/dockerFile/projectnginx/conf/project/onlyallowproject2/default8080.conf

#后端8080端口配置
upstream backend8080 {
    server 你的IP:8083;
}

server {
    listen 8080;

    location / {
        proxy_pass http://backend8080/;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;
    }
}

2.2.2 project1 后端1

/home/deploy/dockerFile/project1/dockerFile

FROM eclipse-temurin:17
LABEL maintainer=zhong
ENV TZ=Asia/Shanghai
WORKDIR  /usr
RUN  mkdir /usr/myproject
#COPY arial.ttf Dengb.ttf Dengl.ttf Deng.ttf fonts.dir fonts.scale msyhbd.ttc msyhl.ttc msyh.ttc simfang.ttf simhei.ttf simkai.ttf simsunb.ttf simsun.ttc /usr/share/fonts/
EXPOSE 8080
#ENTRYPOINT ["nohup","java","-jar","/usr/myproject/ruoyi-admin.jar",">","/usr/myproject/mylog.log","2>&1","&"]  
ENTRYPOINT ["java", "-jar", "/usr/myproject/ruoyi-admin.jar"]

2.2.2 project2 后端2

/home/deploy/dockerFile/project2/dockerFile

FROM eclipse-temurin:17
LABEL maintainer=zhong
ENV TZ=Asia/Shanghai
WORKDIR  /usr
RUN  mkdir /usr/myproject
#COPY arial.ttf Dengb.ttf Dengl.ttf Deng.ttf fonts.dir fonts.scale msyhbd.ttc msyhl.ttc msyh.ttc simfang.ttf simhei.ttf simkai.ttf simsunb.ttf simsun.ttc /usr/share/fonts/
EXPOSE 8080
#ENTRYPOINT ["nohup","java","-jar","/usr/myproject/ruoyi-admin.jar",">","/usr/myproject/mylog.log","2>&1","&"]  
ENTRYPOINT ["java", "-jar", "/usr/myproject/ruoyi-admin.jar"]

2.2.2 projectui1 前端1

/home/deploy/dockerFile/projectui1/dockerFile

FROM nginx:1.21.3
LABEL maintainer=zhong
ENV TZ=Asia/Shanghai
WORKDIR  /usr
RUN  mkdir /usr/project_ui
# 设置STOPSIGNAL为SIGQUIT
STOPSIGNAL SIGQUIT
#COPY arial.ttf Dengb.ttf Dengl.ttf Deng.ttf fonts.dir fonts.scale msyhbd.ttc msyhl.ttc msyh.ttc simfang.ttf simhei.ttf simkai.ttf simsunb.ttf simsun.ttc /usr/share/fonts/
EXPOSE 80
#ENTRYPOINT ["nohup","java","-jar","/usr/myproject/ruoyi-admin.jar",">","/usr/myproject/mylog.log","2>&1","&"]  
#ENTRYPOINT ["java", "-jar", "/usr/myproject/ruoyi-admin.jar"]

/home/deploy/dockerFile/projectui1/conf/nginx.conf

#upstream backend8080 {
    #server 你的IP:8082;
    #server 你的IP:8083;
#}

server {
                listen       80;
                server_name  localhost;
        
                location / {
                    root   /usr/project_ui;
                    try_files $uri $uri/ /index.html;
                    index  index.html index.htm;
                }
        
                location /prod-api/{
                    proxy_set_header Host $http_host;
                    proxy_set_header X-Real-IP $remote_addr;
                    proxy_set_header REMOTE-HOST $remote_addr;
                    proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
                    proxy_pass http://你的IP:8080/;
		    #proxy_pass http://backend8080/;
                }

		      
                # 避免actuator暴露
                if ($request_uri ~ "/actuator") {
                    return 403;
                }
        
                error_page   500 502 503 504  /50x.html;
                location = /50x.html {
                    root   html;
  		}
        }

/home/deploy/dockerFile/projectui1/conf/default.conf


user  nginx;
worker_processes  auto;

error_log  /var/log/nginx/error.log notice;
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;
        server {
                listen       80;
                server_name  localhost;
        
                location / {
                    root   /usr/project_ui;
                    try_files $uri $uri/ /index.html;
                    index  index.html index.htm;
                }
        
                location /prod-api/{
                    proxy_set_header Host $http_host;
                    proxy_set_header X-Real-IP $remote_addr;
                    proxy_set_header REMOTE-HOST $remote_addr;
                    proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
                    proxy_pass http://你的IP:8080/;
                }
        
                # 避免actuator暴露
                if ($request_uri ~ "/actuator") {
                    return 403;
                }
        
                error_page   500 502 503 504  /50x.html;
                location = /50x.html {
                    root   html;
  		}
        }

}

2.2.2 projectui2 前端2

/home/deploy/dockerFile/projectui2/dockerFile

同projectui1

/home/deploy/dockerFile/projectui2/conf/nginx.conf

同projectui1

/home/deploy/dockerFile/projectui2/conf/default.conf

同projectui1

2.2脚本

进入目录：/home/deploy/onekeystartshdouble

2.2.1一键部署前端和后端

onekeystartprojectall.sh

#前端
#后端
cd /home/deploy/onekeystartshdouble && sh onekeystartprojectui.sh && sh onekeystartproject.sh

2.2.2一键部署后端

onekeystartproject.sh

#后端
#1、nginx关闭应用一，修改nginx配置，reload配置文件（这时只允许访问应用二,83和8083端口），瞬间完成  
#&& sh nginxreloadprojectonlyallow2.sh 
#改为 && sh nginxprojectui1projectui2reloadprojectonlyallow2.sh 
#弃用2、等待一小段时间，让 应用一的业务请求处理完成  && sleep 5
#3、停止应用一   && sh project1stop.sh
#4、部署应用一  && sh project1copy.sh && sh project1start.sh
#(弃用)5、等待一小段时间，让 应用一的部署就绪    && sleep 30
#6、nginx打开应用一，关闭应用二，应用一正常部署后，修改nginx配置，reload配置文件（这时只允许访问应用一的82和8082），这个时候瞬间切换成新版的应用，使用的就是最新的代码逻辑了    
#&& sh nginxreloadprojectonlyallow1.sh 
#改为 && sh nginxprojectui1projectui2reloadprojectonlyallow1.sh 
#8、停止应用二  && sh project2stop.sh
#9、部署应用二  && sh project2copy.sh && sh project2start.sh
#10、等待一小段时间，让 应用一的部署就绪   && sleep 30
#11、修改nginx配置，reload配置文件（这时允许访问应用一的82和8082端口、和应用二的83和8083端口），这个时候集群都切换成新版的应用，使用的都是最新的代码逻辑  
#&& sh nginxreloadprojectallowall.sh 
#改为 && sh nginxprojectui1projectui2reloadprojectallowall.sh 
#cd /home/deploy/onekeystartshdouble  && sh projectpullcode.sh && sh projectpackage.sh && sh nginxreloadprojectonlyallow2.sh && sh projectui1reloadprojectonlyallow2.sh && sh projectui2reloadprojectonlyallow2.sh && sleep 5 && sh project1stop.sh  && sh project1copy.sh && sh project1start.sh && sleep 30 && sh nginxreloadprojectonlyallow1.sh && sh projectui1reloadprojectonlyallow1.sh && sh projectui2reloadprojectonlyallow1.sh && sleep 5 && sh project2stop.sh && sh project2copy.sh && sh project2start.sh && sleep 30 && sh nginxreloadprojectallowall.sh && sh projectui1reloadprojectallowall.sh && sh projectui2reloadprojectallowall.sh
#cd /home/deploy/onekeystartshdouble  && sh projectpullcode.sh && sh projectpackage.sh && sh nginxprojectui1projectui2reloadprojectonlyallow2.sh && sleep 5 && sh project1stop.sh  && sh project1copy.sh && sh project1start.sh && sleep 30 && sh nginxprojectui1projectui2reloadprojectonlyallow1.sh && sleep 5 && sh project2stop.sh && sh project2copy.sh && sh project2start.sh && sleep 30 && sh nginxprojectui1projectui2reloadprojectallowall.sh
#前面注释忽略，串行执行以下脚本
cd /home/deploy/onekeystartshdouble  && sh projectpullcode.sh && sh projectpackage.sh && sh nginxreloadprojectonlyallow2.sh && sleep 3 && sh project1stop.sh  && sh project1copy.sh && sh project1start.sh && sh nginxreloadprojectonlyallow1.sh && sleep 3 && sh project2stop.sh && sh project2copy.sh && sh project2start.sh && sh nginxreloadprojectallowall.sh

projectpullcode.sh

cd /root/.jenkins/workspace/workspaces/project_wms/project_wms/project && git pull
echo "projectpullcode"

projectpackage.sh

cd /root/.jenkins/workspace/workspaces/project_wms/project_wms/project && /usr/bin/mvn clean package  
echo "projectpackage"

nginxreloadprojectonlyallow2.sh

#1、nginx关闭应用一，修改nginx配置，reload配置文件（这时只允许访问应用二,83和8083端口），瞬间完成
#复制覆盖配置
\cp -r /home/deploy/dockerFile/projectnginx/conf/project/onlyallowproject2/default8080.conf  /home/deploy/dockerFile/projectnginx/conf/default8080.conf
#reload nginx配置
docker exec projectnginx bash -c "nginx -s reload"
echo "nginxreloadprojectonlyallow2"

project1stop.sh

docker stop project1
echo "project1stop"

project1copy.sh

#\cp -rf /root/.jenkins/workspace/workspaces/project_wms/project_wms/project/ruoyi-admin/target/ruoyi-admin.jar /home/deploy/project_wms/ruoyi-admin.jar
\cp -rf /root/.jenkins/workspace/workspaces/project_wms/project_wms/project/ruoyi-admin/target/ruoyi-admin.jar /home/deploy/dockerFile/project1/myproject/ruoyi-admin.jar
echo "project1copy"

project1start.sh

#nohup java -jar /home/deploy/project_wms/ruoyi-admin.jar > output.log 2>&1 &
docker start project1
echo "project1start"
# 等待 /actuator/health 返回 {"status":"UP"}
health_url="http://你的IP:8082/actuator/health"
max_retries=15
retry_interval=5  # seconds
retry_count=0

while [[ $retry_count -lt $max_retries ]]; do
  response=$(curl -s -o /dev/null -w "%{http_code}" $health_url)
  
  if [[ $response -eq 200 ]]; then
    health_status=$(curl -s $health_url | jq -r '.status')
    
    if [[ $health_status == "UP" ]]; then
      echo "Spring Boot application is up and running."
      break
    fi
  fi
  
  echo "Waiting for Spring Boot application to start ($retry_count/$max_retries)..."
  sleep $retry_interval
  ((retry_count++))
done

if [[ $retry_count -ge $max_retries ]]; then
  echo "Failed to start Spring Boot application within the maximum number of retries."
  exit 1
fi

注意在SecurityConfig放开/actuator/health访问

nginxreloadprojectonlyallow1.sh

#6、nginx打开应用一，关闭应用二，应用一正常部署后，修改nginx配置，reload配置文件（这时只允许访问应用一的82和8082），这个时候瞬间切换成新版的应用，使用的就是最新的代码逻辑了
#复制覆盖配置
\cp -r /home/deploy/dockerFile/projectnginx/conf/project/onlyallowproject1/default8080.conf  /home/deploy/dockerFile/projectnginx/conf/default8080.conf
#reload nginx配置
docker exec projectnginx bash -c "nginx -s reload"
echo "nginxreloadprojectonlyallow1"

project2stop.sh

docker stop project2
echo "project2stop"

project2copy.sh

#\cp -rf /root/.jenkins/workspace/workspaces/project_wms/project_wms/project/ruoyi-admin/target/ruoyi-admin.jar /home/deploy/project_wms/ruoyi-admin.jar
\cp -rf /root/.jenkins/workspace/workspaces/project_wms/project_wms/project/ruoyi-admin/target/ruoyi-admin.jar /home/deploy/dockerFile/project2/myproject/ruoyi-admin.jar
echo "project2copy"

project2start.sh

#nohup java -jar /home/deploy/project_wms/ruoyi-admin.jar > output.log 2>&1 &
docker start project2
echo "project2start"
# 等待 /actuator/health 返回 {"status":"UP"}
health_url="http://你的IP:8083/actuator/health"
max_retries=15
retry_interval=5  # seconds
retry_count=0

while [[ $retry_count -lt $max_retries ]]; do
  response=$(curl -s -o /dev/null -w "%{http_code}" $health_url)
  
  if [[ $response -eq 200 ]]; then
    health_status=$(curl -s $health_url | jq -r '.status')
    
    if [[ $health_status == "UP" ]]; then
      echo "Spring Boot application is up and running."
      break
    fi
  fi
  
  echo "Waiting for Spring Boot application to start ($retry_count/$max_retries)..."
  sleep $retry_interval
  ((retry_count++))
done

if [[ $retry_count -ge $max_retries ]]; then
  echo "Failed to start Spring Boot application within the maximum number of retries."
  exit 1
fi

nginxreloadprojectallowall.sh

#11、修改nginx配置，reload配置文件（这时允许访问应用一的82和8082端口、和应用二的83和8083端口），这个时候集群都切换成新版的应用，使用的都是最新的代码逻辑
\cp -r /home/deploy/dockerFile/projectnginx/conf/project/allowall/default8080.conf  /home/deploy/dockerFile/projectnginx/conf/default8080.conf
#reload nginx配置
docker exec projectnginx bash -c "nginx -s reload"
echo "nginxreloadprojectallowall"

2.2.3一键部署前端

onekeystartprojectui.sh


#1、nginx关闭应用一，修改nginx配置，reload配置文件（这时只允许访问应用二,83和8083端口），瞬间完成  && sh nginxreloadprojectuionlyallow2.sh
#2、等待一小段时间，让 应用一的业务请求处理完成  && sleep 5
#3、停止应用一   && sh projectui1stop.sh
#4、部署应用一  && sh projectui1copy.sh && sh projectui1start.sh
#5、等待一小段时间，让 应用一的部署就绪    && sleep 15
#6、nginx打开应用一，关闭应用二，应用一正常部署后，修改nginx配置，reload配置文件（这时只允许访问应用一的82和8082），这个时候瞬间切换成新版的应用，使用的就是最新的代码逻辑了    && sh nginxreloadprojectuionlyallow1.sh
#7、等待一小段时间，让 应用二的业务请求处理完成   && sleep 5
#8、停止应用二  && sh projectui2stop.sh
#9、部署应用二  && sh projectui2copy.sh && sh projectui2start.sh
#10、等待一小段时间，让 应用一的部署就绪   && sleep 15
#11、修改nginx配置，reload配置文件（这时允许访问应用一的82和8082端口、和应用二的83和8083端口），这个时候集群都切换成新版的应用，使用的都是最新的代码逻辑  && sh nginxreloadprojectuiallowall.sh

cd /home/deploy/onekeystartshdouble  && sh projectuipullcode.sh && sh projectuipackage.sh && sh nginxreloadprojectuionlyallow2.sh && sleep 5 && sh projectui1stop.sh  && sh projectui1copy.sh && sh projectui1start.sh && sleep 15 && sh nginxreloadprojectuionlyallow1.sh && sleep 5 && sh projectui2stop.sh && sh projectui2copy.sh && sh projectui2start.sh && sleep 15 && sh nginxreloadprojectuiallowall.sh

projectuipullcode.sh

cd /root/.jenkins/workspace/workspaces/project_wms/project_ui/project_ui && git pull
echo "projectuipullcode"

projectuipackage.sh

cd /root/.jenkins/workspace/workspaces/project_wms/project_ui/project_ui && rm -rf package-lock.json  && npm run build:prod  
echo "projectuipackage"

nginxreloadprojectuionlyallow2.sh

#1、nginx关闭应用一，修改nginx配置，reload配置文件（这时只允许访问应用二,83和8083端口），瞬间完成
#复制覆盖配置
\cp -r /home/deploy/dockerFile/projectnginx/conf/projectui/onlyallowprojectui2/default.conf  /home/deploy/dockerFile/projectnginx/conf/default.conf
#reload nginx配置
docker exec projectnginx bash -c "nginx -s reload"
echo "nginxreloadprojectuionlyallow2"

projectui1stop.sh

docker stop projectui1
echo "projectui1stop"

projectui1copy.sh

cd /home/deploy/dockerFile/projectui1/project_ui  && rm -rf *  && cp -prf  /root/.jenkins/workspace/workspaces/project_wms/project_ui/project_ui/dist/* /home/deploy/dockerFile/projectui1/project_ui  && sudo chown -R nginx:nginx /home/deploy/dockerFile/projectui1/project_ui  &&  sudo chmod -R 755  /home/deploy/dockerFile/projectui1/project_ui
# && docker exec projectui bash -c "chown -R nginx:nginx /usr/project_ui  && chmod -R 755  /usr/project_ui"
echo "projectui1copy"

projectui1start.sh

docker restart projectui1 && docker exec projectui1 bash -c "chown -R nginx:nginx /usr/project_ui  && chmod -R 755  /usr/project_ui"
echo "projectui1start"
# 等待 Nginx 启动成功,调取获取验证码
health_url="http://你的IP:82/health.json"
max_retries=10
retry_interval=2  # seconds
retry_count=0

while [[ $retry_count -lt $max_retries ]]; do
  response=$(curl -s -o /dev/null -w "%{http_code}" $health_url)
  
  if [[ $response -eq 200 ]]; then
    health_status=$(curl -s $health_url | jq -r '.code')
    
    if [[ $health_status == 200 ]]; then
      echo "Nginx is up and running."
      break
    fi
  fi
  
  echo "Waiting for Nginx to start ($retry_count/$max_retries)..."
  sleep $retry_interval
  ((retry_count++))
done

if [[ $retry_count -ge $max_retries ]]; then
  echo "Failed to start Nginx within the maximum number of retries."
  exit 1
fi

其中前端健康检查配置

nginxreloadprojectuionlyallow1.sh

#6、nginx打开应用一，关闭应用二，应用一正常部署后，修改nginx配置，reload配置文件（这时只允许访问应用一的82和8082），这个时候瞬间切换成新版的应用，使用的就是最新的代码逻辑了
#复制覆盖配置
\cp -r /home/deploy/dockerFile/projectnginx/conf/projectui/onlyallowprojectui1/default.conf  /home/deploy/dockerFile/projectnginx/conf/default.conf
#reload nginx配置
docker exec projectnginx bash -c "nginx -s reload"
echo "nginxreloadprojectuionlyallow1"

projectui2stop.sh

docker stop projectui2
echo "projectui2stop"

projectui2copy.sh

cd /home/deploy/dockerFile/projectui2/project_ui  && rm -rf *  && cp -prf /root/.jenkins/workspace/workspaces/project_wms/project_ui/project_ui/dist/* /home/deploy/dockerFile/projectui2/project_ui  && sudo chown -R nginx:nginx /home/deploy/dockerFile/projectui2/project_ui  &&  sudo chmod -R 755  /home/deploy/dockerFile/projectui2/project_ui
# && docker exec projectui2 bash -c "chown -R nginx:nginx /usr/project_ui  && chmod -R 755  /usr/project_ui"
echo "projectui2copy"

projectui2start.sh

docker restart projectui2 && docker exec projectui2 bash -c "chown -R nginx:nginx /usr/project_ui  && chmod -R 755  /usr/project_ui"
echo "projectui2start"
# 等待 Nginx 启动成功,调取获取验证码 （）
health_url="http://你的IP:83/health.json"
max_retries=10
retry_interval=2  # seconds
retry_count=0

while [[ $retry_count -lt $max_retries ]]; do
  response=$(curl -s -o /dev/null -w "%{http_code}" $health_url)
  
  if [[ $response -eq 200 ]]; then
    health_status=$(curl -s $health_url | jq -r '.code')
    
    if [[ $health_status == 200 ]]; then
      echo "Nginx is up and running."
      break
    fi
  fi
  
  echo "Waiting for Nginx to start ($retry_count/$max_retries)..."
  sleep $retry_interval
  ((retry_count++))
done

if [[ $retry_count -ge $max_retries ]]; then
  echo "Failed to start Nginx within the maximum number of retries."
  exit 1
fi

nginxreloadprojectuiallowall.sh

#11、修改nginx配置，reload配置文件（这时允许访问应用一的82和8082端口、和应用二的83和8083端口），这个时候集群都切换成新版的应用，使用的都是最新的代码逻辑
\cp -r /home/deploy/dockerFile/projectnginx/conf/projectui/allowall/default.conf  /home/deploy/dockerFile/projectnginx/conf/default.conf
#reload nginx配置
docker exec projectnginx bash -c "nginx -s reload"
echo "nginxreloadprojectuiallowall"

腾讯云开发者社区

腾讯云面向开发者汇聚海量精品云计算使用和开发经验，营造开放的云计算技术生态圈。

更多推荐

Elasticsearch复杂数据类型终极指南：从入门到精通

Elasticsearch作为功能强大的搜索引擎，支持多种复杂数据类型，让开发者能够灵活处理各种结构化和非结构化数据。本文将带你全面了解Elasticsearch中的复杂数据类型，从基础概念到实际应用，助你轻松掌握数据建模的核心技巧。## 内部对象：构建层级化数据结构在Elasticsearch中，对象类型（Object）是最基础的复杂数据类型之一，用于表示具有嵌套关系的数据。例如，我们可

腾讯云开发者社区

终极指南：Flink SQL连接器版本管理从混乱到有序的升级之路

Apache Flink作为流处理领域的佼佼者，其SQL连接器的版本管理一直是开发者面临的核心挑战。本文将系统讲解Flink SQL连接器版本管理的最佳实践，帮助你轻松应对版本兼容性问题，实现从混乱到有序的升级之旅。## 连接器版本管理的常见痛点 😫在Flink应用开发中，连接器版本管理常常让开发者头疼不已。不同版本的连接器可能导致各种兼容性问题，例如API变更、功能差异甚至运行时错误。

腾讯云开发者社区

如何快速搭建Neon无服务器PostgreSQL：面向初学者的完整指南

Neon是一款革命性的无服务器PostgreSQL解决方案，它通过分离存储和计算层，实现了自动扩缩容、类代码式数据库分支以及零级扩展能力。本指南将帮助你从零开始搭建Neon开发环境，体验这款创新数据库的强大功能。## 准备工作：环境要求与依赖项在开始搭建Neon环境前，请确保你的系统满足以下要求：- Linux操作系统（推荐Ubuntu 20.04+或Debian 11+）- Git