微服务治理在大厂的落地实践：从流量调度到可观测性

# 路由规则：将带有 x-env=gray 的请求全部路由到灰度实例
routes:
  - sources:
      - service: "frontend"
        labels:
          - key: "x-env"
            value: "gray"
    destinations:
      - service: "order-service"
        labels:
          - key: "env"
            value: "gray"
        weight: 100
  - sources:
      - service: "frontend"
    destinations:
      - service: "order-service"
        labels:
          - key: "env"
            value: "prod"
        weight: 100

@RestController
public class OrderController {
    @GetMapping("/order")
    public String order(@RequestHeader(value = "x-env", defaultValue = "prod") String env) {
        // 通过 RestTemplate 调用时，标签会自动透传
        return restTemplate.getForObject("http://payment-service/pay", String.class);
    }
}

// 配置 RestTemplate 拦截器，将请求头中的 env 转为 Polaris 标签
@Component
public class PolarisLabelInterceptor implements ClientHttpRequestInterceptor {
    @Override
    public ClientHttpResponse intercept(HttpRequest request, byte[] body, 
                                        ClientHttpRequestExecution execution) throws IOException {
        String env = request.getHeaders().getFirst("x-env");
        if (env != null) {
            // 放入 Polaris 上下文，SDK 会自动匹配路由规则
            PolarisContext.setLabel("env", env);
        }
        return execution.execute(request, body);
    }
}

import "github.com/polarismesh/polaris-go"

func updateInstanceWeight(host string, port int, weight int) error {
    provider := polaris.NewProviderAPI()
    req := &api.InstanceDeRegisterRequest{}
    req.InstanceID = "order-service-001"  // 可通过元数据查询
    req.Weight = &weight
    return provider.UpdateInstance(req)
}

lifecycle:
  preStop:
    exec:
      command:
        - /bin/sh
        - -c
        - "curl -X POST http://localhost:8081/offline"  # 主动注销 Polaris
readinessProbe:
  httpGet:
    path: /health
    port: 8081
  initialDelaySeconds: 10
  periodSeconds: 5

@PostConstruct
public void initFlowRule() {
    List<CircuitBreakerRule> rules = new ArrayList<>();
    CircuitBreakerRule rule = new CircuitBreakerRule();
    rule.setResource("paymentApi");
    rule.setStrategy(CircuitBreakerStrategy.SLOW_REQUEST_RATIO.getType());
    rule.setSlowRequestThreshold(500); // 500ms 视为慢
    rule.setStatIntervalMs(10000);      // 统计窗口 10s
    rule.setMinRequestAmount(20);       // 最小请求数
    rule.setThreshold(0.6);             // 慢调用比例 > 60% 开启熔断
    rule.setTimeWindow(30);             // 熔断时长 30s
    rules.add(rule);
    CircuitBreakerManager.loadRules(rules);
}

@FeignClient(name = "payment-service", fallback = PaymentFallback.class)
public interface PaymentClient {
    @GetMapping("/pay")
    String pay(@RequestParam("amount") int amount);
}

@Component
public class PaymentFallback implements PaymentClient {
    @Override
    public String pay(int amount) {
        // 降级返回兜底缓存或提示
        return "fallback: payment service unavailable, please retry later";
    }
}

# 对 /order/create 接口，每个用户每秒最多 10 次
rateLimits:
  - resource: "/order/create"
    labels:
      - key: "userId"
        value: "*"
    thresholds:
      - maxAmount: 10
        timeWindow: 1s
        action: "REJECT"

@SentinelResource(value = "createOrder", blockHandler = "handleBlock")
public String createOrder(String userId, int goodsId) {
    // 业务逻辑
}

public String handleBlock(String userId, int goodsId, BlockException ex) {
    return "请求过于频繁，请稍后再试";
}

// 配置热点规则（通过控制台或 API）
ParamFlowRule rule = new ParamFlowRule("createOrder")
    .setParamIdx(0)                // 对第一个参数（userId）限流
    .setCount(5)
    .setDurationInSec(1);
ParamFlowRuleManager.loadRules(Collections.singletonList(rule));

@Retryable(value = {TimeoutException.class}, 
           maxAttempts = 3, 
           backoff = @Backoff(delay = 100, multiplier = 2, maxDelay = 1000))
public String callRemote() {
    // 远程调用
}

@RestController
public class OrderController {
    private final Counter orderCounter = Counter.builder("order.created")
            .tag("env", "prod")
            .description("total created orders")
            .register(Metrics.globalRegistry);

    @PostMapping("/order")
    public Order create(@RequestBody Order order) {
        orderCounter.increment();
        // 业务逻辑
        return order;
    }
}

# 订单服务错误率 > 5% 且 QPS > 10
( sum(rate(http_server_requests_seconds_count{status=~"5..", service="order"}[1m])) 
/ sum(rate(http_server_requests_seconds_count{service="order"}[1m])) ) > 0.05
and
sum(rate(http_server_requests_seconds_count{service="order"}[1m])) > 10

agent.service_name=order-service
collector.backend_service=skywalking-oap:11800
agent.sample_n_per_3_secs=100   # 每 3 秒采样 100 个请求（保证峰值不过载）

@RestController
public class PaymentController {
    @GetMapping("/pay")
    @Trace(operationName = "payment.process", layer = "service")
    public String pay(@Tag("amount") int amount) {
        // 业务逻辑
        ActiveSpan.tag("user_id", "12345");
        return "success";
    }
}

ExecutorService executor = Executors.newFixedThreadPool(4);
Runnable task = () -> {
    // 子线程的 trace 会继承父线程
};
executor.submit(TraceContext.wrap(task));

<pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %X{traceId} %X{spanId} %-5level %logger{36} - %msg%n</pattern>

@Component
public class TraceIdInterceptor implements HandlerInterceptor {
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) {
        String traceId = request.getHeader("X-B3-TraceId");
        if (traceId == null) traceId = UUID.randomUUID().toString();
        MDC.put("traceId", traceId);
        return true;
    }
    @Override
    public void afterCompletion(...) { MDC.clear(); }
}

public class AdaptiveLimiter {
    private double targetLoad = 0.75; // 目标 CPU 使用率
    private double currentPassed;
    private double previousError;

    public double computeNextThreshold(double currentLoad) {
        double error = targetLoad - currentLoad;
        double derivative = (error - previousError) / deltaTime;
        double integral = integral + error * deltaTime;
        double output = kp * error + ki * integral + kd * derivative;
        previousError = error;
        // 将输出转换为 QPS 阈值调整
        return Math.max(10, currentPassed + output * 100);
    }
}

apiVersion: chaos-mesh.org/v1alpha1
kind: NetworkChaos
metadata:
  name: order-service-delay
spec:
  action: delay
  mode: all
  selector:
    namespaces:
      - prod
    labelSelectors:
      app: order-service
  delay:
    latency: "3s"
    correlation: "100"
  duration: "5m"

<!-- pom.xml -->
<dependency>
    <groupId>com.tencent.cloud</groupId>
    <artifactId>spring-cloud-starter-tencent-polaris-discovery</artifactId>
    <version>1.12.0</version>
</dependency>
<dependency>
    <groupId>com.tencent.cloud</groupId>
    <artifactId>spring-cloud-starter-tencent-polaris-ratelimit</artifactId>
</dependency>

# application.yml
spring:
  cloud:
    polaris:
      address: grpc://${POLARIS_SERVER_IP}:8091
      namespace: default
      enabled: true