Spring Cloud Nacos 负载均衡应用

一、引言

在微服务架构中，服务的高可用性和动态扩展能力是核心需求。随着服务实例数量的增加，如何高效地分配流量、避免单点过载，成为系统设计的关键挑战。负载均衡（Load Balancing） 技术通过将请求合理分发到多个服务实例，成为解决这一问题的核心手段。

Spring Cloud Alibaba 生态中的 Nacos（Naming and Configuration Service）不仅提供了服务注册与发现、动态配置管理等能力，还深度集成了负载均衡功能。Nacos 的负载均衡机制基于 Spring Cloud LoadBalancer（替代了早期的 Ribbon），支持多种默认策略（如轮询、随机、权重），同时也允许开发者根据业务需求自定义负载均衡逻辑。

---

二、Nacos 负载均衡的核心机制

1. Nacos 的服务注册与发现

Nacos 的核心功能之一是服务注册与发现。其工作流程如下：

• 服务注册：服务实例（Provider）启动时，向 Nacos Server 注册自身信息（IP、端口、健康状态等）。
• 服务发现：服务消费者（Consumer）通过服务名从 Nacos Server 获取可用实例列表。
• 健康检查：Nacos Server 定期向服务实例发送心跳检测，自动剔除不健康的实例。

2. 负载均衡的实现层级

Spring Cloud 的负载均衡分为两个层级：

• 客户端负载均衡：由消费者通过负载均衡器（如 Spring Cloud LoadBalancer）选择目标实例。
• 服务端负载均衡：依赖网关（如 Spring Cloud Gateway）或硬件负载均衡器（如 Nginx）。

本文聚焦于 客户端负载均衡，其优势在于减少中间层开销，提升响应速度。

3. Spring Cloud LoadBalancer 的核心组件

Spring Cloud LoadBalancer 是 Spring Cloud 官方提供的负载均衡器，替代了 Netflix Ribbon，其核心组件包括：

• ServiceInstanceListSupplier：负责从服务注册中心（如 Nacos）获取服务实例列表。
• ReactorLoadBalancer：基于 Reactor 的负载均衡器，支持异步选择实例。
• LoadBalancerClient：客户端接口，用于执行负载均衡请求。

4. 实战应用场景

• 权重动态调整
• 区域感知路由
• 监控集成
• 测试环境调试:
  • 通过负载均衡直接链接到本地，进行代码调试（也可以用远程debgger调试，但是远程debgger需要更新到最新代码，而此方式不用）

---

三、Nacos 默认负载均衡策略

1. 内置策略

Spring Cloud LoadBalancer 默认支持以下策略：

• 轮询（Round Robin）：依次选择每个实例。
• 随机（Random）：随机选择一个实例。
• 加权响应时间（Weighted Response Time）：根据实例的响应时间动态调整权重（需额外配置）。

2. 配置默认策略

在 application.yml 中指定全局负载均衡策略：

spring:
  cloud:
    loadbalancer:
      configurations: round-robin # 可选：random, weighted

3. 为特定服务配置策略

通过 @LoadBalancerClient 注解为特定服务指定策略：

@Configuration
@LoadBalancerClient(
    name = "service-provider",
    configuration = CustomLoadBalancerConfig.class
)
public class LoadBalancerConfig {
}

---

四、自定义负载均衡策略实战

1. 需求场景

假设业务需要实现以下自定义策略：

• 优先选择延迟最低的实例：根据实例的历史响应时间动态选择最优节点。
• 权重动态调整：结合 Nacos 的权重配置，实现流量按比例分配。

2. 实现步骤

步骤 1：定义负载均衡器

实现 ReactorLoadBalancer 接口，自定义实例选择逻辑：

public class LatencyBasedLoadBalancer implements ReactorLoadBalancer<ServiceInstance> {

    private final String serviceId;
    private final ServiceInstanceListSupplier supplier;
    private final Map<ServiceInstance, Long> latencyMap = new ConcurrentHashMap<>();

    public LatencyBasedLoadBalancer(ServiceInstanceListSupplier supplier, String serviceId) {
        this.supplier = supplier;
        this.serviceId = serviceId;
    }

    @Override
    public Mono<Response<ServiceInstance>> choose(Request request) {
        return supplier.get().next()
                .map(instances -> {
                    if (instances.isEmpty()) {
                        return new EmptyResponse();
                    }
                    // 计算延迟最低的实例
                    ServiceInstance bestInstance = instances.stream()
                            .min(Comparator.comparingLong(instance ->
                                    latencyMap.getOrDefault(instance, Long.MAX_VALUE)))
                            .orElseThrow();
                    return new DefaultResponse(bestInstance);
                });
    }

    // 更新实例的延迟数据（可通过拦截器或过滤器实现）
    public void updateLatency(ServiceInstance instance, long latency) {
        latencyMap.put(instance, latency);
    }
}

步骤 2：注册自定义负载均衡器

通过 @Bean 注入自定义实现：

@Configuration
public class LoadBalancerConfiguration {

    @Bean
    public ReactorLoadBalancer<ServiceInstance> customLoadBalancer(
            Environment environment,
            LoadBalancerClientFactory clientFactory) {
        String serviceId = environment.getProperty(LoadBalancerClientFactory.PROPERTY_NAME);
        return new LatencyBasedLoadBalancer(
                clientFactory.getLazyProvider(serviceId, ServiceInstanceListSupplier.class),
                serviceId);
    }
}

步骤 3：集成延迟监控

通过 RestTemplate 拦截器记录请求延迟：

@Bean
public RestTemplate restTemplate() {
    RestTemplate restTemplate = new RestTemplate();
    restTemplate.getInterceptors().add((request, body, execution) -> {
        long startTime = System.currentTimeMillis();
        ClientHttpResponse response = execution.execute(request, body);
        long latency = System.currentTimeMillis() - startTime;
        // 获取目标实例并更新延迟
        URI uri = request.getURI();
        ServiceInstance instance = new DefaultServiceInstance(
                uri.getHost(), uri.getHost(), uri.getPort(), false);
        LoadBalancer loadBalancer = applicationContext.getBean(LoadBalancer.class);
        loadBalancer.updateLatency(instance, latency);
        return response;
    });
    return restTemplate;
}

步骤 4：配置服务消费者

在 application.yml 中指定使用自定义负载均衡器：

spring:
  cloud:
    loadbalancer:
      enabled: true
      clients:
        service-provider:
          configuration: custom-loadbalancer-config

---

五、结合 Nacos 权重的动态负载均衡

1. Nacos 权重配置

在 Nacos 控制台或通过 API 为实例设置权重（0~1）：

curl -X PUT "http://localhost:8848/nacos/v1/ns/instance?serviceName=service-provider&ip=192.168.1.1&port=8081&weight=0.7"

2. 读取权重并应用

在自定义负载均衡器中，结合实例权重分配流量：

public class WeightedLoadBalancer implements ReactorLoadBalancer<ServiceInstance> {

    @Override
    public Mono<Response<ServiceInstance>> choose(Request request) {
        return supplier.get().next()
                .map(instances -> {
                    double totalWeight = instances.stream()
                            .mapToDouble(instance -> instance.getMetadata().getOrDefault("weight", "1.0"))
                            .sum();
                    double random = Math.random() * totalWeight;
                    double current = 0;
                    for (ServiceInstance instance : instances) {
                        double weight = Double.parseDouble(instance.getMetadata().getOrDefault("weight", "1.0"));
                        current += weight;
                        if (random < current) {
                            return new DefaultResponse(instance);
                        }
                    }
                    return new EmptyResponse();
                });
    }
}

---

六、实战案例：点击测试环境调试本地代码。

1. 场景描述

• 为了节省代码调试时间，可以直接链接到测试环境nacos，然后点击测试环境，直接在本地进行调试。

2. 实现代码

2.1 服务实例元数据配置

在服务注册时，通过 Nacos 元数据标记实例所属环境：

# 本地环境服务配置 (application-local.yml)
spring:
  cloud:
    nacos:
      discovery:
        metadata:
          environment: local  # 环境标识
          weight: 5           # 权重值（本地最高）

# 开发环境服务配置 (application-dev.yml)
spring:
  cloud:
    nacos:
      discovery:
        metadata:
          environment: dev
          weight: 3

# 生产环境服务配置 (application-prod.yml)
spring:
  cloud:
    nacos:
      discovery:
        metadata:
          environment: prod
          weight: 1

2.2 自定义负载均衡策略

实现基于环境权重的负载均衡逻辑：

public class EnvironmentWeightedLoadBalancer implements ReactorLoadBalancer<ServiceInstance> {

    // 环境权重映射（本地 > 开发 > 生产）
    private static final Map<String, Integer> ENVIRONMENT_WEIGHTS = Map.of(
        "local", 5,
        "dev", 3,
        "prod", 1
    );

    private final String serviceId;
    private final ServiceInstanceListSupplier supplier;

    public EnvironmentWeightedLoadBalancer(ServiceInstanceListSupplier supplier, String serviceId) {
        this.supplier = supplier;
        this.serviceId = serviceId;
    }

    @Override
    public Mono<Response<ServiceInstance>> choose(Request request) {
        return supplier.get().next()
            .map(instances -> {
                if (instances.isEmpty()) {
                    return new EmptyResponse();
                }
                // 计算总权重
                int totalWeight = instances.stream()
                    .mapToInt(instance -> 
                        ENVIRONMENT_WEIGHTS.getOrDefault(
                            instance.getMetadata().get("environment"), 
                            1 // 默认权重
                        )
                    )
                    .sum();
                // 按权重随机选择
                int randomWeight = new Random().nextInt(totalWeight);
                int current = 0;
                for (ServiceInstance instance : instances) {
                    int weight = ENVIRONMENT_WEIGHTS.getOrDefault(
                        instance.getMetadata().get("environment"), 
                        1
                    );
                    current += weight;
                    if (randomWeight < current) {
                        return new DefaultResponse(instance);
                    }
                }
                return new EmptyResponse();
            });
    }
}

3.1 注册自定义负载均衡器

通过配置类绑定策略到目标服务：

@Configuration
@LoadBalancerClient(
    name = "target-service", // 目标服务名
    configuration = EnvironmentLoadBalancerConfig.class
)
public class EnvironmentLoadBalancerConfig {

    @Bean
    public ReactorLoadBalancer<ServiceInstance> reactorLoadBalancer(
        Environment environment,
        LoadBalancerClientFactory clientFactory
    ) {
        String serviceId = environment.getProperty(LoadBalancerClientFactory.PROPERTY_NAME);
        return new EnvironmentWeightedLoadBalancer(
            clientFactory.getLazyProvider(serviceId, ServiceInstanceListSupplier.class),
            serviceId
        );
    }
}

---

七、常见问题与解决方案

1. 负载均衡不生效

• 检查点：
  • 确保 @LoadBalanced 注解已添加到 RestTemplate 或 WebClient。
  • 验证 Nacos Server 中服务实例已正确注册。

2. 自定义策略未被调用

• 排查步骤：
  • 检查 @LoadBalancerClient 的 configuration 属性是否指向正确配置类。
  • 确保没有其他自动配置类覆盖自定义配置。