cd /d/privategit/gitee/docker-compose/Windows/shenyu-2.6.1
docker compose -f docker-compose-ShenYu.yaml up -d

# application.yml (公共)
server.port: 8080
shenyu:
  client:
    http:
      props:
        contextPath: /http-demo11
        appName: http-demo11
        host: 10.19.236.150
        port: 8080
      serverLists: http://localhost:9096

---

# application-8179.yml
server.port: 8179
shenyu.client.http.props.port: 8179

---

# application-8189.yml
server.port: 8189
shenyu.client.http.props.port: 8189

@RestController
@RequestMapping("/order")
public class OrderController {

    @Value("${server.port:8080}")
    private String serverPort;

    private final String instanceId = UUID.randomUUID().toString().substring(0, 8);

    // 基础接口：返回实例标识
    @GetMapping("/findById")
    public Map<String, Object> findById(@RequestParam String id) {
        Map<String, Object> result = new HashMap<>();
        result.put("id", id);
        result.put("name", "demo-order-" + id);
        result.put("serverPort", serverPort);
        result.put("instanceId", instanceId);
        result.put("timestamp", System.currentTimeMillis());
        return result;
    }

    // 超时模拟
    @GetMapping("/delay")
    public Map<String, Object> delay(@RequestParam(defaultValue = "100") long ms) {
        long start = System.currentTimeMillis();
        try { Thread.sleep(ms); } catch (InterruptedException ignored) {}
        Map<String, Object> result = new HashMap<>();
        result.put("serverPort", serverPort);
        result.put("instanceId", instanceId);
        result.put("sleptMs", ms);
        result.put("actualMs", System.currentTimeMillis() - start);
        return result;
    }

    // 回显请求头 + 估算字节数（验证 headerMaxSize）
    @GetMapping("/echo-headers")
    public Map<String, Object> echoHeaders(HttpServletRequest request) {
        Map<String, Object> result = new HashMap<>();
        result.put("serverPort", serverPort);
        result.put("instanceId", instanceId);

        Map<String, String> headers = new HashMap<>();
        int totalBytes = 0;
        Enumeration<String> names = request.getHeaderNames();
        while (names.hasMoreElements()) {
            String name = names.nextElement();
            String value = request.getHeader(name);
            headers.put(name, value);
            totalBytes += (value != null ? value.getBytes().length : 0);
        }
        result.put("receivedHeaders", headers);
        result.put("headerCount", headers.size());
        result.put("estimatedHeaderBytes", totalBytes);
        return result;
    }

    // 回显请求体字节数（验证 requestMaxSize）
    @PostMapping("/echo-body")
    public Map<String, Object> echoBody(HttpServletRequest request) throws IOException {
        byte[] body = request.getInputStream().readAllBytes();
        Map<String, Object> result = new HashMap<>();
        result.put("serverPort", serverPort);
        result.put("instanceId", instanceId);
        result.put("receivedBodyBytes", body.length);
        result.put("bodyPreview", new String(body, 0, Math.min(body.length, 200)));
        return result;
    }
}

http://localhost:9096 → 插件列表 → Proxy → Divide → 选择器 /http-demo11

-- 查看规则
SELECT id, name, handle FROM shenyu_261.rule WHERE name = '/http-demo11/order/**';

-- 修改
UPDATE shenyu_261.rule SET handle = JSON_SET(handle,
  '$.headerMaxSize', 200,
  '$.requestMaxSize', 500,
  '$.timeout', 1000,
  '$.retry', 1
) WHERE name = '/http-demo11/order/**';

-- 改后重启 bootstrap 使生效
docker restart shenyu-bootstrap-261

登录 http://localhost:9096 (admin / 1qaz!QAZ)
→ 左侧菜单「基础配置」→「插件管理」→ 找到 divide → 确认状态为「开启」
→ 左侧菜单「插件列表」→ Proxy → Divide → 确认存在选择器 /http-demo11

curl -s "http://localhost:9196/http-demo11/order/findById?id=1"
# → {"serverPort":"8179","instanceId":"35d4f0c6",...}

① 登录 http://localhost:9096
② 左侧菜单「插件列表」→ Proxy → Divide → 选择器 /http-demo11
③ 右侧「添加规则」按钮
④ 填写：
   规则名称: /findById-gray
   匹配方式: AND
   条件: 类型=header, 参数名=X-Gray-Version, 运算符==, 参数值=v2
   处理: loadStrategy=roundRobin（保持默认即可）
   排序(sort): 1（比默认规则小，确保优先匹配）
⑤ 点「确认」保存
⑥ 等待 ~1s 让 WebSocket 同步到 bootstrap

# 带灰度 header → 命中灰度规则
curl -s -H "X-Gray-Version: v2" "http://localhost:9196/http-demo11/order/findById?id=1"
# → {"serverPort":"8189",...}

# 不带 header → 走默认规则
curl -s "http://localhost:9196/http-demo11/order/findById?id=1"
# → {"serverPort":"8179",...}

① 登录 → 插件列表 → Proxy → Divide → 选择器 /http-demo11
② 选择器编辑（确认两 upstream 均为开启状态）:
   10.19.236.150:8179  weight=50  status=开启
   10.19.236.150:8189  weight=50  status=开启
③ 点规则列表中的规则 → 编辑 → 处理配置 → 修改 loadStrategy → 点「确认」保存
④ 每次切换策略后等待 ~1s

loadStrategy = roundRobin

for i in $(seq 1 10); do
  curl -s "http://localhost:9196/http-demo11/order/findById?id=$i" | grep -o '"serverPort":"[0-9]*"'
done
# → 8179, 8189, 8179, 8189, ... (严格交替)

loadStrategy = random

for i in $(seq 1 20); do
  curl -s "http://localhost:9196/http-demo11/order/findById?id=$i" | grep -o '"serverPort":"[0-9]*"'
done | sort | uniq -c
# → 各 ~10 次，分布随机

loadStrategy = hash

for i in $(seq 1 10); do
  curl -s "http://localhost:9196/http-demo11/order/findById?id=$i" | grep -o '"serverPort":"[0-9]*"'
done | sort | uniq -c
# → 全部落在同一端口（同 IP 粘性）

① 登录 → 插件列表 → Proxy → Divide → 选择器 /http-demo11 → 编辑
② 在 upstream 列表找到 10.19.236.150:8189 → 修改:
   warmupTime: 60000  (毫秒，60秒)
   startupTime: <B 刚启动的时间戳(毫秒)>   ← 从 B 实例日志第一行获取，或用 date +%s%3N
   weight: 50  (不变)
③ 切换到规则列表 → 规则编辑 → loadStrategy 改回 roundRobin → 保存
④ 在 B 启动后 90s 内执行下方测试脚本

UPDATE shenyu_261.selector SET handle = JSON_SET(handle,
  '$.upstreamHosts[1].warmupTime', 60000,
  '$.upstreamHosts[1].startupTime', <时间戳>
) WHERE name = '/http-demo11';

for i in $(seq 1 30); do
  printf "%s  " "$(date +%H:%M:%S)"
  curl -s "http://localhost:9196/http-demo11/order/findById?id=$i" | grep -o '"serverPort":"[0-9]*"'
  sleep 3
done

① 登录 → 插件列表 → Proxy → Divide → 选择器 /http-demo11
② 找到规则（若 /order/delay** 不存在，demo 启动时自动注册；否则手动添加）
③ 编辑规则 → 处理配置:
   timeout: 1000        (1秒超时)
   retryCount: 1        (重试1次，共2次尝试)
   loadStrategy: roundRobin  (配合 failover 测试观察实例切换)
④ 保存

retryStrategy = current

curl -s "http://localhost:9196/http-demo11/order/delay?ms=3000"
# → 408 Request Timeout
# 观察两个 IDEA 控制台: 实例 A 日志出现 2 次 /order/delay，实例 B 日志 0 次

retryStrategy = failover（页面修改后点确认保存）

curl -s "http://localhost:9196/http-demo11/order/delay?ms=3000"
# → 200 OK，{"serverPort":"8179"}
# A、B 各出现 1 次 /order/delay

① 登录 → 插件列表 → Proxy → Divide → 选择器 /http-demo11
② 找到规则 /order/echo-headers**（若不存在，demo 启动时自动注册）
③ 编辑规则 → 条件配置:
   URI 条件: 运算符=pathPattern, 参数值=/order/echo-headers
   （注意：不要写成 /http-demo11/order/echo-headers，需去掉 contextPath）
④ 处理配置 → headerMaxSize: 200
⑤ 点「确认」保存，等 ~1s

UPDATE shenyu_261.rule SET handle = JSON_SET(handle, '$.headerMaxSize', 200)
WHERE name = '/http-demo11/order/**';

docker restart shenyu-bootstrap-261

# 正常 — 通过
curl -s "http://localhost:9196/http-demo11/order/echo-headers"
# → {"estimatedHeaderBytes":102,...}

# 超限 — 拦截
LARGE=$(printf 'B%.0s' $(seq 1 200))
curl -s -H "X-Big: $LARGE" "http://localhost:9196/http-demo11/order/echo-headers"
# → {"code":431,"message":"Request Header Fields Too Large"}

① 登录 → 插件列表 → Proxy → Divide → 选择器 /http-demo11
② 找到规则 /order/echo-body**（demo 启动自动注册）
③ 编辑规则 → 条件配置:
   URI 条件: 运算符=pathPattern, 参数值=/order/echo-body
④ 处理配置 → requestMaxSize: 500
⑤ 点「确认」保存，等 ~1s

UPDATE shenyu_261.rule SET handle = JSON_SET(handle, '$.requestMaxSize', 500)
WHERE name = '/http-demo11/order/**';

# 正常 — 通过
MED=$(printf 'C%.0s' $(seq 1 400))
curl -s -X POST -d "$MED" "http://localhost:9196/http-demo11/order/echo-body"
# → {"receivedBodyBytes":401,...}

# 超限 — 拦截
LARGE=$(printf 'D%.0s' $(seq 1 600))
curl -s -X POST -d "$LARGE" "http://localhost:9196/http-demo11/order/echo-body"
# → {"code":413,"message":"Request Entity Too Large"}