Java微服务无损发布生产实战案例及验证_Java

1. 背景

项目为spring cloud微服务，注册中心使用nacos。在上线发布过程中发现存在feign调用失败的情况，即发布过程没有做到无损。上线发布采用灰度发布策略，即先发布一台机器，这台机器成功发布后再接着发布其他机器，理论上应该无损。

2. 排查

在上线发布微服务a第xx台机器过程中，a应该处于下线状态，不应该再请求到这台机器，但是从日志看有流量进来并调用a失败了：

3. 方案

借助ai及经验排查项目代码和停机sh脚本后发现代码层面及运维脚本层面都没有实现优雅停机，基于尽量少改动代码考虑，决定采用修改停机sh脚本的方案实现优雅停机。

3.1. 外部脚本控制（运维层面）

这是本案例采用的优雅停机方案，代码无侵入，只需完善停机sh脚本逻辑以支持优雅停机。

3.1.1. 优化前的sh脚本逻辑

停止实例时脚本没有先下线nacos注册中心服务实例，存在被调用方服务b刚停止但nacos还未感知到，此时调用方a从nacos获取到这个已停止的服务b的实例，导致调用失败。

3.1.2. 优化后的sh脚本逻辑

采取主动标记nacos实例下线 + 休眠等待 + 停止java进程方案：先标记nacos实例下线(主动下线而不是被动等待nacos自动检测下线)，再设置一个休眠时间一是为了等待nacos更新，二是让正在处理的业务请求有时间完成。最后再停止java进程，避免请求丢失，实现微服务优雅停机。

#!/bin/bash
# stop.sh - 优雅停机脚本

app_name="provider"
app_port=8082
nacos_server="127.0.0.1:8848"

echo "开始优雅停止 $app_name..."

# 1. 获取服务ip
get_nacos_registered_ip() {
    
    # 调用nacos查询接口
    local response=$(curl -s "http://${nacos_server}/nacos/v1/ns/instance/list?servicename=${app_name}")
    
    if [ $? -ne 0 ] || [ -z "$response" ]; then
        echo "查询nacos服务失败" >&2
        return 1
    fi
    
    # 解析json获取ip（需要jq工具）
    if command -v jq >/dev/null 2>&1; then
        local ip=$(echo "$response" | jq -r '.hosts[0].ip' 2>/dev/null)
        if [ "$ip" != "null" ] && [ -n "$ip" ]; then
            echo $ip
            return 0
        fi
    fi
    
    # 如果没有jq，使用grep/awk解析
    local ip=$(echo "$response" | grep -o '"ip":"[^"]*' | cut -d'"' -f4 | head -1)
    if [ -n "$ip" ]; then
        echo $ip
        return 0
    fi
    
    echo "无法从nacos响应中解析ip" >&2
    return 1
}

local_ip=$(get_nacos_registered_ip)
echo "检测到服务注册ip: $local_ip"

# 2. 从nacos下线服务
echo "从nacos注销服务..."
curl -x delete "${nacos_server}/nacos/v1/ns/instance?servicename=${app_name}&ip=${local_ip}&port=${app_port}"

# 3. 等待流量切换
echo "等待流量切换(15秒)..."
sleep 15

# 4. 根据jar名称查找应用进程，比如provider2
echo "查找应用进程..."
# 更精确的进程查找方式
app_pid=$(ps aux | grep "[j]ava.*provider2" | awk '{print $2}')

if [ -n "$app_pid" ]; then
    echo "找到应用进程，pid: $app_pid"
    
    # 5. 发送优雅停止信号
    echo "发送优雅停止信号..."
    kill -15 $app_pid
    
    # 6. 等待进程停止，最多30秒
    for i in {1..30}; do
        if kill -0 $app_pid 2>/dev/null; then
            echo "等待应用停止...($i/30)"
            sleep 1
        else
            echo "应用已优雅停止"
            exit 0
        fi
    done
    
    # 7. 强制停止
    echo "优雅停止超时，强制停止"
    kill -9 $app_pid
else
    echo "应用未运行"
fi

echo "停止脚本执行完成"

另外，springboot项目配置文件application.yml配置优雅停机：

server:
  shutdown: graceful

3.1.3. 测试结果

脚本运行结果：

应用日志：

3.2. 应用内优雅停机（代码层面）

3.2.1. 优雅停机实现类

package com.example.provider;

import com.alibaba.cloud.nacos.registry.nacosregistration;
import com.alibaba.cloud.nacos.registry.nacosserviceregistry;
import org.apache.catalina.connector.connector;
import org.slf4j.logger;
import org.slf4j.loggerfactory;
import org.springframework.boot.web.embedded.tomcat.tomcatconnectorcustomizer;
import org.springframework.context.applicationlistener;
import org.springframework.context.annotation.lazy;
import org.springframework.context.event.contextclosedevent;
import org.springframework.stereotype.component;

import javax.annotation.resource;
import java.util.concurrent.executor;
import java.util.concurrent.threadpoolexecutor;
import java.util.concurrent.timeunit;

@component
public class tomcatnacosgracefulshutdown implements tomcatconnectorcustomizer,
        applicationlistener<contextclosedevent> {

    private static final logger logger = loggerfactory.getlogger(tomcatnacosgracefulshutdown.class);

    private volatile connector connector;

    @lazy
    @resource
    private nacosserviceregistry nacosserviceregistry;

    @lazy
    @resource
    private nacosregistration nacosregistration;

    @override
    public void customize(connector connector) {
        this.connector = connector;
        logger.info("tomcat连接器自定义配置完成");
    }

    @override
    public void onapplicationevent(contextclosedevent event) {
        logger.info("=== 开始tomcat+nacos优雅停机 ===");
        startgracefulshutdown();
    }

    public void startgracefulshutdown() {
        try {
            // 步骤1: nacos注销
            deregisterfromnacos();

            // 步骤2: 等待注册中心传播
            waitforregistrypropagation();

            // 步骤3: 暂停tomcat接收新请求
            pausetomcat();

            // 步骤4: 等待活跃请求完成
            waitforactiverequests();

            logger.info("=== tomcat+nacos优雅停机完成 ===");

        } catch (exception e) {
            logger.error("优雅停机失败", e);
        }
    }

    private void deregisterfromnacos() {
        if (nacosserviceregistry != null && nacosregistration != null) {
            try {
                logger.info("从nacos注销服务实例...");
                nacosserviceregistry.deregister(nacosregistration);
                logger.info("nacos注销成功: {}", nacosregistration.getserviceid());
            } catch (exception e) {
                logger.error("nacos注销失败", e);
            }
        } else {
            logger.warn("nacos注册组件未找到，跳过注销");
        }
    }

    private void waitforregistrypropagation() {
        try {
            long waittime = 15000;
            logger.info("等待注册中心传播: {}ms", waittime);
            thread.sleep(waittime);
        } catch (interruptedexception e) {
            thread.currentthread().interrupt();
            logger.warn("等待过程被中断");
        }
    }

    private void pausetomcat() {
        if (connector != null) {
            logger.info("暂停tomcat连接器，停止接收新请求");
            connector.pause();
        } else {
            logger.warn("tomcat连接器未找到，无法暂停");
        }
    }

    private void waitforactiverequests() {
        if (connector == null) {
            logger.warn("tomcat连接器未找到，跳过等待");
            return;
        }

        executor executor = connector.getprotocolhandler().getexecutor();
        if (executor instanceof threadpoolexecutor) {
            threadpoolexecutor threadpool = (threadpoolexecutor) executor;

            logger.info("等待活跃请求完成...");
            threadpool.shutdown();

            try {
                long maxwaittime = 30000;
                if (!threadpool.awaittermination(maxwaittime, timeunit.milliseconds)) {
                    logger.warn("等待请求超时，强制关闭线程池");
                    threadpool.shutdownnow();

                    if (!threadpool.awaittermination(5000, timeunit.milliseconds)) {
                        logger.error("线程池未能正常终止");
                    }
                } else {
                    logger.info("所有活跃请求处理完成");
                }
            } catch (interruptedexception e) {
                threadpool.shutdownnow();
                thread.currentthread().interrupt();
                logger.warn("等待过程被中断");
            }
        } else {
            logger.warn("无法获取tomcat线程池，跳过等待");
        }
    }

}