云负载均衡架构实战：云原生负载均衡方案设计、高可用架构与智能流量分发完整解决方案

一、场景分析

1.1 云负载均衡的核心需求

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
云负载均衡的核心需求:
  1. 高可用性:
     - 99.99%可用性
     - 多可用区部署
     - 自动故障转移
  
  2. 高性能:
     - 低延迟
     - 高吞吐量
     - 连接复用
  
  3. 智能流量分发:
     - 多种负载均衡算法
     - 动态权重调整
     - 健康检查
  
  4. 弹性扩展:
     - 自动扩容
     - 弹性伸缩
     - 按需付费
  
  5. 安全性:
     - DDoS防护
     - SSL/TLS卸载
     - WAF集成

1.2 云负载均衡架构层次

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
架构层次:
  1. 四层负载均衡 (L4):
    - TCP/UDP负载均衡
    - 基于IP和端口
    - 低延迟高性能
  
  2. 七层负载均衡 (L7):
    - HTTP/HTTPS负载均衡
    - 基于内容的路由
    - 高级功能支持
  
  3. 全局负载均衡 (GSLB):
    - 多地域部署
    - DNS智能解析
    - 地理路由

二、负载均衡算法实现

2.1 基础负载均衡算法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
// LoadBalancer.java
public interface LoadBalancer {
    /**
     * 选择后端服务器
     */
    Server select(List<Server> servers, Request request);
    
    /**
     * 更新服务器列表
     */
    void updateServers(List<Server> servers);
}

// Server.java
@Data
@Builder
public class Server {
    private String id;
    private String host;
    private int port;
    private int weight; // 权重
    private boolean healthy; // 健康状态
    private long currentConnections; // 当前连接数
    private long totalRequests; // 总请求数
    private double responseTime; // 响应时间
    private long lastHealthCheck; // 上次健康检查时间
}

2.2 轮询算法 (Round Robin)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
// RoundRobinLoadBalancer.java
@Component
public class RoundRobinLoadBalancer implements LoadBalancer {
    
    private List<Server> servers;
    private AtomicInteger currentIndex = new AtomicInteger(0);
    private final Object lock = new Object();
    
    @Override
    public Server select(List<Server> servers, Request request) {
        if (servers == null || servers.isEmpty()) {
            throw new IllegalArgumentException("Servers list is empty");
        }
        
        // 只选择健康的服务器
        List<Server> healthyServers = servers.stream()
            .filter(Server::isHealthy)
            .collect(Collectors.toList());
        
        if (healthyServers.isEmpty()) {
            throw new IllegalStateException("No healthy servers available");
        }
        
        // 轮询选择
        int index = currentIndex.getAndIncrement() % healthyServers.size();
        return healthyServers.get(index);
    }
    
    @Override
    public void updateServers(List<Server> servers) {
        synchronized (lock) {
            this.servers = new ArrayList<>(servers);
        }
    }
}

2.3 加权轮询算法 (Weighted Round Robin)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
// WeightedRoundRobinLoadBalancer.java
@Component
public class WeightedRoundRobinLoadBalancer implements LoadBalancer {
    
    private List<Server> servers;
    private List<Integer> cumulativeWeights;
    private AtomicInteger currentWeight = new AtomicInteger(0);
    
    @Override
    public Server select(List<Server> servers, Request request) {
        List<Server> healthyServers = filterHealthyServers(servers);
        if (healthyServers.isEmpty()) {
            throw new IllegalStateException("No healthy servers available");
        }
        
        // 计算累积权重
        calculateCumulativeWeights(healthyServers);
        
        // 选择服务器
        int totalWeight = cumulativeWeights.get(cumulativeWeights.size() - 1);
        int current = currentWeight.getAndIncrement() % totalWeight;
        
        for (int i = 0; i < healthyServers.size(); i++) {
            if (current < cumulativeWeights.get(i)) {
                return healthyServers.get(i);
            }
        }
        
        return healthyServers.get(0);
    }
    
    private void calculateCumulativeWeights(List<Server> servers) {
        cumulativeWeights = new ArrayList<>();
        int sum = 0;
        for (Server server : servers) {
            sum += server.getWeight();
            cumulativeWeights.add(sum);
        }
    }
    
    private List<Server> filterHealthyServers(List<Server> servers) {
        return servers.stream()
            .filter(Server::isHealthy)
            .collect(Collectors.toList());
    }
    
    @Override
    public void updateServers(List<Server> servers) {
        this.servers = new ArrayList<>(servers);
    }
}

2.4 最小连接算法 (Least Connections)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
// LeastConnectionsLoadBalancer.java
@Component
public class LeastConnectionsLoadBalancer implements LoadBalancer {
    
    private List<Server> servers;
    
    @Override
    public Server select(List<Server> servers, Request request) {
        List<Server> healthyServers = filterHealthyServers(servers);
        if (healthyServers.isEmpty()) {
            throw new IllegalStateException("No healthy servers available");
        }
        
        // 选择连接数最少的服务器
        return healthyServers.stream()
            .min(Comparator.comparingLong(Server::getCurrentConnections))
            .orElse(healthyServers.get(0));
    }
    
    private List<Server> filterHealthyServers(List<Server> servers) {
        return servers.stream()
            .filter(Server::isHealthy)
            .collect(Collectors.toList());
    }
    
    @Override
    public void updateServers(List<Server> servers) {
        this.servers = new ArrayList<>(servers);
    }
}

2.5 加权最小连接算法 (Weighted Least Connections)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
// WeightedLeastConnectionsLoadBalancer.java
@Component
public class WeightedLeastConnectionsLoadBalancer implements LoadBalancer {
    
    @Override
    public Server select(List<Server> servers, Request request) {
        List<Server> healthyServers = filterHealthyServers(servers);
        if (healthyServers.isEmpty()) {
            throw new IllegalStateException("No healthy servers available");
        }
        
        // 计算加权连接数 = 当前连接数 / 权重
        return healthyServers.stream()
            .min(Comparator.comparingDouble(server -> 
                (double) server.getCurrentConnections() / server.getWeight()))
            .orElse(healthyServers.get(0));
    }
    
    private List<Server> filterHealthyServers(List<Server> servers) {
        return servers.stream()
            .filter(Server::isHealthy)
            .collect(Collectors.toList());
    }
    
    @Override
    public void updateServers(List<Server> servers) {
        // 更新服务器列表
    }
}

2.6 响应时间算法 (Response Time Based)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
// ResponseTimeLoadBalancer.java
@Component
public class ResponseTimeLoadBalancer implements LoadBalancer {
    
    @Override
    public Server select(List<Server> servers, Request request) {
        List<Server> healthyServers = filterHealthyServers(servers);
        if (healthyServers.isEmpty()) {
            throw new IllegalStateException("No healthy servers available");
        }
        
        // 选择响应时间最短的服务器
        return healthyServers.stream()
            .min(Comparator.comparingDouble(Server::getResponseTime))
            .orElse(healthyServers.get(0));
    }
    
    private List<Server> filterHealthyServers(List<Server> servers) {
        return servers.stream()
            .filter(Server::isHealthy)
            .collect(Collectors.toList());
    }
    
    @Override
    public void updateServers(List<Server> servers) {
        // 更新服务器列表
    }
}

2.7 IP Hash算法 (Consistent Hash)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
// ConsistentHashLoadBalancer.java
@Component
public class ConsistentHashLoadBalancer implements LoadBalancer {
    
    private TreeMap<Long, Server> hashRing = new TreeMap<>();
    private int virtualNodes = 150; // 虚拟节点数
    
    @Override
    public Server select(List<Server> servers, Request request) {
        if (hashRing.isEmpty()) {
            buildHashRing(servers);
        }
        
        // 获取客户端IP
        String clientIp = getClientIp(request);
        
        // 计算Hash
        long hash = hash(clientIp);
        
        // 查找服务器
        Map.Entry<Long, Server> entry = hashRing.ceilingEntry(hash);
        if (entry == null) {
            entry = hashRing.firstEntry();
        }
        
        Server server = entry.getValue();
        
        // 确保服务器健康
        if (!server.isHealthy()) {
            return findNextHealthyServer(hash);
        }
        
        return server;
    }
    
    private void buildHashRing(List<Server> servers) {
        hashRing.clear();
        
        for (Server server : servers) {
            // 为每个服务器创建虚拟节点
            for (int i = 0; i < virtualNodes; i++) {
                String virtualNodeKey = server.getId() + "#" + i;
                long hash = hash(virtualNodeKey);
                hashRing.put(hash, server);
            }
        }
    }
    
    private Server findNextHealthyServer(long hash) {
        // 找到下一个健康的服务器
        for (int i = 0; i < hashRing.size(); i++) {
            Map.Entry<Long, Server> entry = hashRing.higherEntry(hash);
            if (entry == null) {
                entry = hashRing.firstEntry();
            }
            
            if (entry.getValue().isHealthy()) {
                return entry.getValue();
            }
            
            hash = entry.getKey();
        }
        
        throw new IllegalStateException("No healthy servers available");
    }
    
    private long hash(String key) {
        // 使用MD5或CRC32等Hash算法
        MessageDigest md5;
        try {
            md5 = MessageDigest.getInstance("MD5");
            byte[] keyBytes = md5.digest(key.getBytes(StandardCharsets.UTF_8));
            return ((long) (keyBytes[3] & 0xFF) << 24)
                | ((long) (keyBytes[2] & 0xFF) << 16)
                | ((long) (keyBytes[1] & 0xFF) << 8)
                | (long) (keyBytes[0] & 0xFF);
        } catch (NoSuchAlgorithmException e) {
            throw new RuntimeException(e);
        }
    }
    
    private String getClientIp(Request request) {
        // 从请求中获取客户端IP
        return request.getClientIp();
    }
    
    @Override
    public void updateServers(List<Server> servers) {
        buildHashRing(servers);
    }
}

2.8 负载均衡器工厂

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
// LoadBalancerFactory.java
@Component
public class LoadBalancerFactory {
    
    @Autowired
    private ApplicationContext applicationContext;
    
    /**
     * 创建负载均衡器
     */
    public LoadBalancer createLoadBalancer(LoadBalanceAlgorithm algorithm) {
        switch (algorithm) {
            case ROUND_ROBIN:
                return applicationContext.getBean(RoundRobinLoadBalancer.class);
            case WEIGHTED_ROUND_ROBIN:
                return applicationContext.getBean(WeightedRoundRobinLoadBalancer.class);
            case LEAST_CONNECTIONS:
                return applicationContext.getBean(LeastConnectionsLoadBalancer.class);
            case WEIGHTED_LEAST_CONNECTIONS:
                return applicationContext.getBean(WeightedLeastConnectionsLoadBalancer.class);
            case RESPONSE_TIME:
                return applicationContext.getBean(ResponseTimeLoadBalancer.class);
            case CONSISTENT_HASH:
                return applicationContext.getBean(ConsistentHashLoadBalancer.class);
            default:
                return applicationContext.getBean(RoundRobinLoadBalancer.class);
        }
    }
}

enum LoadBalanceAlgorithm {
    ROUND_ROBIN,
    WEIGHTED_ROUND_ROBIN,
    LEAST_CONNECTIONS,
    WEIGHTED_LEAST_CONNECTIONS,
    RESPONSE_TIME,
    CONSISTENT_HASH
}

三、健康检查机制

3.1 健康检查服务

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
// HealthCheckService.java
@Service
public class HealthCheckService {
    
    private ScheduledExecutorService executorService;
    private Map<String, HealthCheckTask> healthCheckTasks = new ConcurrentHashMap<>();
    
    @PostConstruct
    public void init() {
        executorService = Executors.newScheduledThreadPool(10);
    }
    
    /**
     * 开始健康检查
     */
    public void startHealthCheck(Server server, HealthCheckConfig config) {
        String taskId = server.getId();
        
        if (healthCheckTasks.containsKey(taskId)) {
            stopHealthCheck(taskId);
        }
        
        HealthCheckTask task = new HealthCheckTask(server, config);
        healthCheckTasks.put(taskId, task);
        
        // 定期执行健康检查
        executorService.scheduleAtFixedRate(
            task,
            config.getInitialDelay(),
            config.getInterval(),
            TimeUnit.SECONDS
        );
    }
    
    /**
     * 停止健康检查
     */
    public void stopHealthCheck(String serverId) {
        HealthCheckTask task = healthCheckTasks.remove(serverId);
        if (task != null) {
            task.cancel();
        }
    }
    
    /**
     * 执行健康检查
     */
    private class HealthCheckTask implements Runnable {
        private final Server server;
        private final HealthCheckConfig config;
        private volatile boolean cancelled = false;
        
        public HealthCheckTask(Server server, HealthCheckConfig config) {
            this.server = server;
            this.config = config;
        }
        
        @Override
        public void run() {
            if (cancelled) {
                return;
            }
            
            try {
                boolean healthy = performHealthCheck(server, config);
                server.setHealthy(healthy);
                server.setLastHealthCheck(System.currentTimeMillis());
                
                // 更新服务器状态
                updateServerStatus(server, healthy);
            } catch (Exception e) {
                server.setHealthy(false);
                log.error("Health check failed for server: " + server.getId(), e);
            }
        }
        
        public void cancel() {
            this.cancelled = true;
        }
    }
    
    /**
     * 执行健康检查
     */
    private boolean performHealthCheck(Server server, HealthCheckConfig config) {
        switch (config.getType()) {
            case HTTP:
                return httpHealthCheck(server, config);
            case TCP:
                return tcpHealthCheck(server, config);
            case ICMP:
                return icmpHealthCheck(server, config);
            default:
                return false;
        }
    }
    
    /**
     * HTTP健康检查
     */
    private boolean httpHealthCheck(Server server, HealthCheckConfig config) {
        try {
            String url = String.format("http://%s:%d%s",
                server.getHost(), server.getPort(), config.getPath());
            
            HttpClient client = HttpClient.newHttpClient();
            HttpRequest request = HttpRequest.newBuilder()
                .uri(URI.create(url))
                .timeout(Duration.ofSeconds(config.getTimeout()))
                .GET()
                .build();
            
            HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
            
            // 检查状态码
            return response.statusCode() == config.getExpectedStatus();
        } catch (Exception e) {
            return false;
        }
    }
    
    /**
     * TCP健康检查
     */
    private boolean tcpHealthCheck(Server server, HealthCheckConfig config) {
        try (Socket socket = new Socket()) {
            socket.connect(
                new InetSocketAddress(server.getHost(), server.getPort()),
                config.getTimeout() * 1000
            );
            return socket.isConnected();
        } catch (Exception e) {
            return false;
        }
    }
    
    /**
     * ICMP健康检查
     */
    private boolean icmpHealthCheck(Server server, HealthCheckConfig config) {
        try {
            InetAddress address = InetAddress.getByName(server.getHost());
            return address.isReachable(config.getTimeout() * 1000);
        } catch (Exception e) {
            return false;
        }
    }
    
    private void updateServerStatus(Server server, boolean healthy) {
        // 更新服务器状态到注册中心
        // 通知负载均衡器更新服务器列表
    }
}

@Data
@Builder
class HealthCheckConfig {
    private HealthCheckType type; // HTTP, TCP, ICMP
    private String path; // HTTP路径
    private int timeout; // 超时时间（秒）
    private int interval; // 检查间隔（秒）
    private int initialDelay; // 初始延迟（秒）
    private int successThreshold; // 成功阈值
    private int failureThreshold; // 失败阈值
    private int expectedStatus; // 期望状态码
}

enum HealthCheckType {
    HTTP, TCP, ICMP
}

3.2 健康检查策略

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
// HealthCheckStrategy.java
public interface HealthCheckStrategy {
    /**
     * 判断服务器是否健康
     */
    boolean isHealthy(Server server, List<HealthCheckResult> results);
}

// ThresholdHealthCheckStrategy.java
@Component
public class ThresholdHealthCheckStrategy implements HealthCheckStrategy {
    
    private int successThreshold = 2; // 连续成功2次认为健康
    private int failureThreshold = 3; // 连续失败3次认为不健康
    
    @Override
    public boolean isHealthy(Server server, List<HealthCheckResult> results) {
        if (results.isEmpty()) {
            return false;
        }
        
        // 获取最近的检查结果
        List<HealthCheckResult> recentResults = results.stream()
            .sorted(Comparator.comparingLong(HealthCheckResult::getTimestamp).reversed())
            .limit(Math.max(successThreshold, failureThreshold))
            .collect(Collectors.toList());
        
        // 检查是否连续成功/失败
        boolean lastResult = recentResults.get(0).isSuccess();
        int consecutiveCount = 1;
        
        for (int i = 1; i < recentResults.size(); i++) {
            if (recentResults.get(i).isSuccess() == lastResult) {
                consecutiveCount++;
            } else {
                break;
            }
        }
        
        if (lastResult) {
            return consecutiveCount >= successThreshold;
        } else {
            return consecutiveCount < failureThreshold;
        }
    }
}

@Data
class HealthCheckResult {
    private boolean success;
    private long timestamp;
    private long responseTime;
    private String error;
}

四、云服务商负载均衡方案

4.1 阿里云SLB集成

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
// AliyunSLBService.java
@Service
public class AliyunSLBService {
    
    @Value("${aliyun.access-key-id}")
    private String accessKeyId;
    
    @Value("${aliyun.access-key-secret}")
    private String accessKeySecret;
    
    @Value("${aliyun.region-id}")
    private String regionId;
    
    /**
     * 创建负载均衡实例
     */
    public String createLoadBalancer(CreateLoadBalancerRequest request) {
        IAcsClient client = createClient();
        CreateLoadBalancerRequest createRequest = new CreateLoadBalancerRequest();
        createRequest.setRegionId(regionId);
        createRequest.setLoadBalancerName(request.getLoadBalancerName());
        createRequest.setAddressType(request.getAddressType()); // internet or intranet
        createRequest.setVpcId(request.getVpcId());
        
        try {
            CreateLoadBalancerResponse response = client.getAcsResponse(createRequest);
            return response.getLoadBalancerId();
        } catch (Exception e) {
            throw new RuntimeException("Failed to create load balancer", e);
        }
    }
    
    /**
     * 添加后端服务器
     */
    public void addBackendServers(String loadBalancerId, List<String> serverIds) {
        IAcsClient client = createClient();
        AddBackendServersRequest request = new AddBackendServersRequest();
        request.setLoadBalancerId(loadBalancerId);
        request.setBackendServers(buildBackendServers(serverIds));
        
        try {
            client.getAcsResponse(request);
        } catch (Exception e) {
            throw new RuntimeException("Failed to add backend servers", e);
        }
    }
    
    /**
     * 配置健康检查
     */
    public void configureHealthCheck(String loadBalancerId, HealthCheckConfig config) {
        IAcsClient client = createClient();
        SetLoadBalancerHTTPListenerAttributeRequest request = new SetLoadBalancerHTTPListenerAttributeRequest();
        request.setLoadBalancerId(loadBalancerId);
        request.setListenerPort(config.getPort());
        request.setHealthCheck(config.getHealthCheck());
        request.setHealthCheckURI(config.getHealthCheckURI());
        request.setHealthCheckConnectPort(config.getHealthCheckConnectPort());
        request.setHealthCheckInterval(config.getInterval());
        request.setHealthCheckTimeout(config.getTimeout());
        request.setHealthyThreshold(config.getHealthyThreshold());
        request.setUnhealthyThreshold(config.getUnhealthyThreshold());
        
        try {
            client.getAcsResponse(request);
        } catch (Exception e) {
            throw new RuntimeException("Failed to configure health check", e);
        }
    }
    
    private IAcsClient createClient() {
        IClientProfile profile = DefaultProfile.getProfile(regionId, accessKeyId, accessKeySecret);
        return new DefaultAcsClient(profile);
    }
    
    private String buildBackendServers(List<String> serverIds) {
        // 构建后端服务器JSON
        return serverIds.stream()
            .map(id -> String.format("{\"ServerId\":\"%s\",\"Weight\":100}", id))
            .collect(Collectors.joining(",", "[", "]"));
    }
}

4.2 AWS ELB集成

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
// AWSElbService.java
@Service
public class AWSElbService {
    
    @Value("${aws.region}")
    private String region;
    
    private ElasticLoadBalancingClient elbClient;
    
    @PostConstruct
    public void init() {
        AwsBasicCredentials credentials = AwsBasicCredentials.create(
            System.getenv("AWS_ACCESS_KEY_ID"),
            System.getenv("AWS_SECRET_ACCESS_KEY")
        );
        
        elbClient = ElasticLoadBalancingClient.builder()
            .region(Region.of(region))
            .credentialsProvider(StaticCredentialsProvider.create(credentials))
            .build();
    }
    
    /**
     * 创建Application Load Balancer
     */
    public String createApplicationLoadBalancer(CreateLoadBalancerRequest request) {
        CreateLoadBalancerRequest elbRequest = CreateLoadBalancerRequest.builder()
            .name(request.getName())
            .scheme(request.getScheme()) // internet-facing or internal
            .type(LoadBalancerTypeEnum.APPLICATION)
            .subnets(request.getSubnetIds())
            .securityGroups(request.getSecurityGroupIds())
            .build();
        
        CreateLoadBalancerResponse response = elbClient.createLoadBalancer(elbRequest);
        return response.loadBalancers().get(0).loadBalancerArn();
    }
    
    /**
     * 创建Target Group
     */
    public String createTargetGroup(CreateTargetGroupRequest request) {
        CreateTargetGroupRequest tgRequest = CreateTargetGroupRequest.builder()
            .name(request.getName())
            .protocol(ProtocolEnum.HTTP)
            .port(request.getPort())
            .vpcId(request.getVpcId())
            .healthCheckProtocol(ProtocolEnum.HTTP)
            .healthCheckPath(request.getHealthCheckPath())
            .healthCheckIntervalSeconds(request.getHealthCheckInterval())
            .healthyThresholdCount(request.getHealthyThreshold())
            .unhealthyThresholdCount(request.getUnhealthyThreshold())
            .build();
        
        CreateTargetGroupResponse response = elbClient.createTargetGroup(tgRequest);
        return response.targetGroups().get(0).targetGroupArn();
    }
    
    /**
     * 注册目标
     */
    public void registerTargets(String targetGroupArn, List<String> instanceIds) {
        List<TargetDescription> targets = instanceIds.stream()
            .map(id -> TargetDescription.builder().id(id).port(80).build())
            .collect(Collectors.toList());
        
        RegisterTargetsRequest request = RegisterTargetsRequest.builder()
            .targetGroupArn(targetGroupArn)
            .targets(targets)
            .build();
        
        elbClient.registerTargets(request);
    }
}

4.3 负载均衡抽象层

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
// CloudLoadBalancerService.java
@Service
public class CloudLoadBalancerService {
    
    @Autowired
    private AliyunSLBService aliyunSLBService;
    
    @Autowired
    private AWSElbService awsElbService;
    
    @Value("${cloud.provider}")
    private String cloudProvider;
    
    /**
     * 创建负载均衡器
     */
    public String createLoadBalancer(CreateLoadBalancerRequest request) {
        switch (cloudProvider.toLowerCase()) {
            case "aliyun":
                return aliyunSLBService.createLoadBalancer(request);
            case "aws":
                return awsElbService.createApplicationLoadBalancer(request);
            default:
                throw new IllegalArgumentException("Unsupported cloud provider: " + cloudProvider);
        }
    }
    
    /**
     * 添加后端服务器
     */
    public void addBackendServers(String loadBalancerId, List<String> serverIds) {
        switch (cloudProvider.toLowerCase()) {
            case "aliyun":
                aliyunSLBService.addBackendServers(loadBalancerId, serverIds);
                break;
            case "aws":
                // AWS使用Target Group
                break;
            default:
                throw new IllegalArgumentException("Unsupported cloud provider: " + cloudProvider);
        }
    }
}

五、自建负载均衡架构

5.1 Nginx负载均衡配置

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
# nginx.conf
upstream backend_servers {
    # 加权轮询
    server 192.168.1.10:8080 weight=3 max_fails=3 fail_timeout=30s;
    server 192.168.1.11:8080 weight=2 max_fails=3 fail_timeout=30s;
    server 192.168.1.12:8080 weight=1 max_fails=3 fail_timeout=30s;
    
    # 健康检查
    keepalive 32;
    
    # 负载均衡算法
    # least_conn;  # 最小连接
    # ip_hash;     # IP Hash
}

server {
    listen 80;
    server_name example.com;
    
    # 日志
    access_log /var/log/nginx/access.log;
    error_log /var/log/nginx/error.log;
    
    location / {
        proxy_pass http://backend_servers;
        
        # 代理设置
        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;
        
        # 超时设置
        proxy_connect_timeout 30s;
        proxy_send_timeout 60s;
        proxy_read_timeout 60s;
        
        # 连接复用
        proxy_http_version 1.1;
        proxy_set_header Connection "";
        
        # 健康检查
        proxy_next_upstream error timeout invalid_header http_500 http_502 http_503;
    }
    
    # 健康检查端点
    location /health {
        access_log off;
        return 200 "healthy\n";
        add_header Content-Type text/plain;
    }
}

# 高可用配置
upstream backend_servers_backup {
    server 192.168.1.20:8080;
    server 192.168.1.21:8080;
}

server {
    listen 80;
    server_name example.com;
    
    location / {
        proxy_pass http://backend_servers;
        
        # 故障转移
        error_page 502 503 504 = @fallback;
    }
    
    location @fallback {
        proxy_pass http://backend_servers_backup;
    }
}

5.2 Nginx动态配置管理

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
// NginxConfigManager.java
@Service
public class NginxConfigManager {
    
    @Value("${nginx.config.path}")
    private String nginxConfigPath;
    
    @Value("${nginx.reload.command}")
    private String nginxReloadCommand;
    
    /**
     * 动态添加后端服务器
     */
    public void addBackendServer(String upstream, String server) {
        String config = readNginxConfig();
        
        // 解析并添加服务器
        config = addServerToUpstream(config, upstream, server);
        
        writeNginxConfig(config);
        reloadNginx();
    }
    
    /**
     * 动态移除后端服务器
     */
    public void removeBackendServer(String upstream, String server) {
        String config = readNginxConfig();
        
        // 解析并移除服务器
        config = removeServerFromUpstream(config, upstream, server);
        
        writeNginxConfig(config);
        reloadNginx();
    }
    
    /**
     * 更新服务器权重
     */
    public void updateServerWeight(String upstream, String server, int weight) {
        String config = readNginxConfig();
        
        // 更新权重
        config = updateServerWeightInUpstream(config, upstream, server, weight);
        
        writeNginxConfig(config);
        reloadNginx();
    }
    
    private String readNginxConfig() {
        try {
            return Files.readString(Path.of(nginxConfigPath));
        } catch (IOException e) {
            throw new RuntimeException("Failed to read nginx config", e);
        }
    }
    
    private void writeNginxConfig(String config) {
        try {
            Files.writeString(Path.of(nginxConfigPath), config);
        } catch (IOException e) {
            throw new RuntimeException("Failed to write nginx config", e);
        }
    }
    
    private void reloadNginx() {
        try {
            Process process = Runtime.getRuntime().exec(nginxReloadCommand);
            int exitCode = process.waitFor();
            if (exitCode != 0) {
                throw new RuntimeException("Failed to reload nginx, exit code: " + exitCode);
            }
        } catch (Exception e) {
            throw new RuntimeException("Failed to reload nginx", e);
        }
    }
    
    private String addServerToUpstream(String config, String upstream, String server) {
        // 使用正则表达式添加服务器
        String pattern = String.format("upstream\\s+%s\\s*\\{", upstream);
        String replacement = String.format("upstream %s {\n    server %s;", upstream, server);
        return config.replaceAll(pattern, replacement);
    }
    
    private String removeServerFromUpstream(String config, String upstream, String server) {
        // 移除指定服务器
        String pattern = String.format("server\\s+%s[^;]*;", server);
        return config.replaceAll(pattern, "");
    }
    
    private String updateServerWeightInUpstream(String config, String upstream, String server, int weight) {
        // 更新权重
        String pattern = String.format("server\\s+%s[^;]*;", server);
        String replacement = String.format("server %s weight=%d;", server, weight);
        return config.replaceAll(pattern, replacement);
    }
}

5.3 基于Spring Cloud Gateway的负载均衡

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
// CustomLoadBalancerConfig.java
@Configuration
public class CustomLoadBalancerConfig {
    
    @Bean
    public ReactorLoadBalancer<ServiceInstance> reactorServiceInstanceLoadBalancer(
            Environment environment,
            LoadBalancerClientFactory loadBalancerClientFactory) {
        
        String name = environment.getProperty(LoadBalancerClientFactory.PROPERTY_NAME);
        
        return new RoundRobinLoadBalancer(
            loadBalancerClientFactory.getLazyProvider(name, ServiceInstanceListSupplier.class),
            name
        );
    }
}

// CustomRouteConfig.java
@Configuration
public class CustomRouteConfig {
    
    @Bean
    public RouteLocator customRouteLocator(RouteLocatorBuilder builder) {
        return builder.routes()
            .route("service-a", r -> r
                .path("/api/service-a/**")
                .uri("lb://service-a")
                .filters(f -> f
                    .stripPrefix(1)
                    .requestRateLimiter(config -> config
                        .setRateLimiter(redisRateLimiter())
                        .setKeyResolver(ipKeyResolver())
                    )
                )
            )
            .route("service-b", r -> r
                .path("/api/service-b/**")
                .uri("lb://service-b")
                .filters(f -> f
                    .stripPrefix(1)
                    .retry(config -> config
                        .setRetries(3)
                        .setMethods(HttpMethod.GET, HttpMethod.POST)
                    )
                )
            )
            .build();
    }
    
    @Bean
    public RedisRateLimiter redisRateLimiter() {
        return new RedisRateLimiter(100, 200);
    }
    
    @Bean
    public KeyResolver ipKeyResolver() {
        return exchange -> Mono.just(
            exchange.getRequest().getRemoteAddress().getAddress().getHostAddress()
        );
    }
}

六、高可用架构设计

6.1 负载均衡器高可用

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
// HighAvailabilityLoadBalancer.java
@Service
public class HighAvailabilityLoadBalancer {
    
    @Autowired
    private List<LoadBalancer> primaryLoadBalancers;
    
    @Autowired
    private List<LoadBalancer> backupLoadBalancers;
    
    private volatile boolean primaryHealthy = true;
    
    /**
     * 高可用选择服务器
     */
    public Server select(List<Server> servers, Request request) {
        try {
            if (primaryHealthy) {
                return selectFromPrimary(servers, request);
            } else {
                return selectFromBackup(servers, request);
            }
        } catch (Exception e) {
            // 主负载均衡器故障，切换到备用
            primaryHealthy = false;
            return selectFromBackup(servers, request);
        }
    }
    
    private Server selectFromPrimary(List<Server> servers, Request request) {
        for (LoadBalancer lb : primaryLoadBalancers) {
            try {
                return lb.select(servers, request);
            } catch (Exception e) {
                log.warn("Primary load balancer failed, trying next", e);
            }
        }
        throw new RuntimeException("All primary load balancers failed");
    }
    
    private Server selectFromBackup(List<Server> servers, Request request) {
        for (LoadBalancer lb : backupLoadBalancers) {
            try {
                return lb.select(servers, request);
            } catch (Exception e) {
                log.warn("Backup load balancer failed, trying next", e);
            }
        }
        throw new RuntimeException("All load balancers failed");
    }
    
    /**
     * 健康检查
     */
    @Scheduled(fixedRate = 10000)
    public void checkHealth() {
        boolean healthy = checkPrimaryHealth();
        if (healthy && !primaryHealthy) {
            // 主负载均衡器恢复
            primaryHealthy = true;
            log.info("Primary load balancers recovered");
        } else if (!healthy && primaryHealthy) {
            // 主负载均衡器故障
            primaryHealthy = false;
            log.warn("Primary load balancers failed, switching to backup");
        }
    }
    
    private boolean checkPrimaryHealth() {
        // 检查主负载均衡器健康状态
        return primaryLoadBalancers.stream()
            .anyMatch(this::isLoadBalancerHealthy);
    }
    
    private boolean isLoadBalancerHealthy(LoadBalancer lb) {
        // 健康检查逻辑
        try {
            lb.select(Collections.emptyList(), null);
            return false; // 不应该选择到服务器
        } catch (IllegalArgumentException e) {
            return true; // 负载均衡器正常
        } catch (Exception e) {
            return false;
        }
    }
}

6.2 多可用区部署

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
// MultiAZLoadBalancer.java
@Service
public class MultiAZLoadBalancer implements LoadBalancer {
    
    @Autowired
    private LoadBalancerFactory loadBalancerFactory;
    
    private Map<String, LoadBalancer> azLoadBalancers = new ConcurrentHashMap<>();
    
    @Override
    public Server select(List<Server> servers, Request request) {
        // 1. 按可用区分组
        Map<String, List<Server>> serversByAZ = servers.stream()
            .collect(Collectors.groupingBy(Server::getAvailabilityZone));
        
        // 2. 优先选择本地可用区
        String localAZ = getLocalAvailabilityZone();
        List<Server> localServers = serversByAZ.getOrDefault(localAZ, new ArrayList<>());
        
        if (!localServers.isEmpty()) {
            LoadBalancer lb = getLoadBalancerForAZ(localAZ);
            List<Server> healthyLocalServers = filterHealthyServers(localServers);
            if (!healthyLocalServers.isEmpty()) {
                return lb.select(healthyLocalServers, request);
            }
        }
        
        // 3. 本地可用区无健康服务器，选择其他可用区
        for (Map.Entry<String, List<Server>> entry : serversByAZ.entrySet()) {
            if (entry.getKey().equals(localAZ)) {
                continue;
            }
            
            LoadBalancer lb = getLoadBalancerForAZ(entry.getKey());
            List<Server> healthyServers = filterHealthyServers(entry.getValue());
            if (!healthyServers.isEmpty()) {
                return lb.select(healthyServers, request);
            }
        }
        
        throw new IllegalStateException("No healthy servers available");
    }
    
    private LoadBalancer getLoadBalancerForAZ(String az) {
        return azLoadBalancers.computeIfAbsent(az, k -> 
            loadBalancerFactory.createLoadBalancer(LoadBalanceAlgorithm.WEIGHTED_ROUND_ROBIN)
        );
    }
    
    private String getLocalAvailabilityZone() {
        // 从环境变量或元数据服务获取
        return System.getenv("AVAILABILITY_ZONE");
    }
    
    private List<Server> filterHealthyServers(List<Server> servers) {
        return servers.stream()
            .filter(Server::isHealthy)
            .collect(Collectors.toList());
    }
    
    @Override
    public void updateServers(List<Server> servers) {
        // 更新服务器列表
    }
}

6.3 故障转移机制

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
// FailoverLoadBalancer.java
@Service
public class FailoverLoadBalancer implements LoadBalancer {
    
    @Autowired
    private LoadBalancer primaryLoadBalancer;
    
    @Autowired
    private LoadBalancer backupLoadBalancer;
    
    private volatile boolean primaryAvailable = true;
    
    @Override
    public Server select(List<Server> servers, Request request) {
        try {
            if (primaryAvailable) {
                Server server = primaryLoadBalancer.select(servers, request);
                
                // 验证服务器是否可达
                if (isServerReachable(server)) {
                    return server;
                } else {
                    // 主服务器不可达，切换到备用
                    return selectFromBackup(servers, request);
                }
            } else {
                return selectFromBackup(servers, request);
            }
        } catch (Exception e) {
            // 主负载均衡器故障，切换到备用
            primaryAvailable = false;
            return selectFromBackup(servers, request);
        }
    }
    
    private Server selectFromBackup(List<Server> servers, Request request) {
        try {
            Server server = backupLoadBalancer.select(servers, request);
            
            // 尝试恢复主负载均衡器
            if (primaryAvailable == false && isServerReachable(server)) {
                schedulePrimaryRecovery();
            }
            
            return server;
        } catch (Exception e) {
            throw new RuntimeException("Both primary and backup load balancers failed", e);
        }
    }
    
    private boolean isServerReachable(Server server) {
        try {
            Socket socket = new Socket();
            socket.connect(
                new InetSocketAddress(server.getHost(), server.getPort()),
                1000 // 1秒超时
            );
            socket.close();
            return true;
        } catch (Exception e) {
            return false;
        }
    }
    
    private void schedulePrimaryRecovery() {
        // 延迟恢复主负载均衡器
        CompletableFuture.delayedExecutor(30, TimeUnit.SECONDS)
            .execute(() -> {
                if (testPrimaryLoadBalancer()) {
                    primaryAvailable = true;
                    log.info("Primary load balancer recovered");
                }
            });
    }
    
    private boolean testPrimaryLoadBalancer() {
        // 测试主负载均衡器
        try {
            List<Server> testServers = Collections.singletonList(
                Server.builder().host("127.0.0.1").port(8080).build()
            );
            primaryLoadBalancer.select(testServers, null);
            return false; // 不应该选择到测试服务器
        } catch (Exception e) {
            return true; // 主负载均衡器正常
        }
    }
    
    @Override
    public void updateServers(List<Server> servers) {
        primaryLoadBalancer.updateServers(servers);
        backupLoadBalancer.updateServers(servers);
    }
}

七、智能流量分发

7.1 基于权重的动态调整

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
// WeightAdjustmentService.java
@Service
public class WeightAdjustmentService {
    
    @Autowired
    private ServerMetricsCollector metricsCollector;
    
    /**
     * 根据服务器性能动态调整权重
     */
    public void adjustWeights(List<Server> servers) {
        List<ServerMetrics> metrics = metricsCollector.collectMetrics(servers);
        
        // 计算性能得分
        Map<String, Double> scores = calculatePerformanceScores(metrics);
        
        // 调整权重
        for (Server server : servers) {
            double score = scores.getOrDefault(server.getId(), 1.0);
            int newWeight = calculateWeight(score);
            server.setWeight(newWeight);
        }
    }
    
    private Map<String, Double> calculatePerformanceScores(List<ServerMetrics> metrics) {
        Map<String, Double> scores = new HashMap<>();
        
        for (ServerMetrics m : metrics) {
            // 综合多个指标计算得分
            double cpuScore = 1.0 / (1.0 + m.getCpuUsage());
            double memoryScore = 1.0 / (1.0 + m.getMemoryUsage());
            double responseTimeScore = 1.0 / (1.0 + m.getAvgResponseTime() / 1000.0);
            double errorRateScore = 1.0 - m.getErrorRate();
            
            // 加权平均
            double score = cpuScore * 0.3
                + memoryScore * 0.3
                + responseTimeScore * 0.2
                + errorRateScore * 0.2;
            
            scores.put(m.getServerId(), score);
        }
        
        return scores;
    }
    
    private int calculateWeight(double score) {
        // 将得分转换为权重（1-100）
        return (int) Math.max(1, Math.min(100, score * 100));
    }
}

@Data
class ServerMetrics {
    private String serverId;
    private double cpuUsage;
    private double memoryUsage;
    private double avgResponseTime;
    private double errorRate;
    private long currentConnections;
    private long totalRequests;
}

7.2 基于路径的路由

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
// PathBasedRouter.java
@Component
public class PathBasedRouter {
    
    private Map<String, LoadBalancer> pathLoadBalancers = new ConcurrentHashMap<>();
    
    /**
     * 根据路径选择负载均衡器
     */
    public Server selectServer(String path, List<Server> servers, Request request) {
        // 匹配路径规则
        LoadBalancer lb = findLoadBalancerForPath(path);
        
        if (lb != null) {
            return lb.select(servers, request);
        }
        
        // 默认负载均衡器
        return defaultLoadBalancer().select(servers, request);
    }
    
    private LoadBalancer findLoadBalancerForPath(String path) {
        for (Map.Entry<String, LoadBalancer> entry : pathLoadBalancers.entrySet()) {
            if (path.matches(entry.getKey())) {
                return entry.getValue();
            }
        }
        return null;
    }
    
    /**
     * 注册路径规则
     */
    public void registerPathRule(String pathPattern, LoadBalancer loadBalancer) {
        pathLoadBalancers.put(pathPattern, loadBalancer);
    }
    
    private LoadBalancer defaultLoadBalancer() {
        return new RoundRobinLoadBalancer();
    }
}

7.3 基于地理位置的智能路由

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
// GeoBasedRouter.java
@Component
public class GeoBasedRouter {
    
    @Autowired
    private GeoLocationService geoLocationService;
    
    /**
     * 根据地理位置选择最近的服务器
     */
    public Server selectByGeoLocation(Request request, List<Server> servers) {
        // 获取客户端地理位置
        String clientIp = request.getClientIp();
        GeoLocation clientLocation = geoLocationService.getLocation(clientIp);
        
        // 计算距离并选择最近的服务器
        return servers.stream()
            .filter(Server::isHealthy)
            .min(Comparator.comparingDouble(server -> 
                calculateDistance(clientLocation, server.getLocation())
            ))
            .orElseThrow(() -> new IllegalStateException("No healthy servers available"));
    }
    
    private double calculateDistance(GeoLocation loc1, GeoLocation loc2) {
        // 使用Haversine公式计算两点间距离
        double lat1 = Math.toRadians(loc1.getLatitude());
        double lat2 = Math.toRadians(loc2.getLatitude());
        double lon1 = Math.toRadians(loc1.getLongitude());
        double lon2 = Math.toRadians(loc2.getLongitude());
        
        double dLat = lat2 - lat1;
        double dLon = lon2 - lon1;
        
        double a = Math.sin(dLat / 2) * Math.sin(dLat / 2)
            + Math.cos(lat1) * Math.cos(lat2)
            * Math.sin(dLon / 2) * Math.sin(dLon / 2);
        
        double c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a));
        
        return 6371 * c; // 返回公里数
    }
}

@Data
class GeoLocation {
    private double latitude;
    private double longitude;
}

八、监控与告警

8.1 负载均衡监控

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
// LoadBalancerMonitor.java
@Component
public class LoadBalancerMonitor {
    
    @Autowired
    private MeterRegistry meterRegistry;
    
    /**
     * 监控负载均衡器指标
     */
    public void monitorLoadBalancer(LoadBalancer loadBalancer, Server selectedServer) {
        // 记录选择次数
        Counter.builder("loadbalancer.selections")
            .tag("algorithm", loadBalancer.getClass().getSimpleName())
            .tag("server", selectedServer.getId())
            .register(meterRegistry)
            .increment();
        
        // 记录响应时间
        Timer.builder("loadbalancer.response.time")
            .tag("server", selectedServer.getId())
            .register(meterRegistry)
            .record(selectedServer.getResponseTime(), TimeUnit.MILLISECONDS);
        
        // 记录连接数
        Gauge.builder("loadbalancer.server.connections", selectedServer, Server::getCurrentConnections)
            .tag("server", selectedServer.getId())
            .register(meterRegistry);
    }
    
    /**
     * 监控负载均衡器健康状态
     */
    @Scheduled(fixedRate = 10000)
    public void monitorHealth() {
        List<Server> servers = getAllServers();
        
        long healthyCount = servers.stream()
            .filter(Server::isHealthy)
            .count();
        
        long totalCount = servers.size();
        
        // 记录健康服务器比例
        Gauge.builder("loadbalancer.healthy.ratio")
            .register(meterRegistry, () -> (double) healthyCount / totalCount);
        
        // 告警
        if ((double) healthyCount / totalCount < 0.5) {
            sendAlert("Less than 50% of servers are healthy");
        }
    }
    
    private List<Server> getAllServers() {
        // 获取所有服务器
        return Collections.emptyList();
    }
    
    private void sendAlert(String message) {
        // 发送告警
        log.warn("Alert: " + message);
    }
}

8.2 性能监控Dashboard

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
// LoadBalancerMetricsController.java
@RestController
@RequestMapping("/api/metrics")
public class LoadBalancerMetricsController {
    
    @Autowired
    private LoadBalancerMonitor monitor;
    
    @Autowired
    private ServerMetricsCollector metricsCollector;
    
    /**
     * 获取负载均衡器指标
     */
    @GetMapping("/loadbalancer")
    public LoadBalancerMetrics getLoadBalancerMetrics() {
        // 获取指标数据
        return LoadBalancerMetrics.builder()
            .totalRequests(getTotalRequests())
            .avgResponseTime(getAvgResponseTime())
            .errorRate(getErrorRate())
            .healthyServers(getHealthyServerCount())
            .totalServers(getTotalServerCount())
            .build();
    }
    
    /**
     * 获取服务器指标
     */
    @GetMapping("/servers")
    public List<ServerMetricsDTO> getServerMetrics() {
        List<Server> servers = getAllServers();
        return servers.stream()
            .map(this::convertToDTO)
            .collect(Collectors.toList());
    }
    
    private ServerMetricsDTO convertToDTO(Server server) {
        ServerMetrics metrics = metricsCollector.collectMetrics(Collections.singletonList(server))
            .stream()
            .findFirst()
            .orElse(new ServerMetrics());
        
        return ServerMetricsDTO.builder()
            .serverId(server.getId())
            .host(server.getHost())
            .port(server.getPort())
            .healthy(server.isHealthy())
            .weight(server.getWeight())
            .currentConnections(server.getCurrentConnections())
            .totalRequests(metrics.getTotalRequests())
            .avgResponseTime(metrics.getAvgResponseTime())
            .errorRate(metrics.getErrorRate())
            .cpuUsage(metrics.getCpuUsage())
            .memoryUsage(metrics.getMemoryUsage())
            .build();
    }
    
    private long getTotalRequests() {
        // 从监控系统获取
        return 0;
    }
    
    private double getAvgResponseTime() {
        // 从监控系统获取
        return 0;
    }
    
    private double getErrorRate() {
        // 从监控系统获取
        return 0;
    }
    
    private long getHealthyServerCount() {
        return getAllServers().stream()
            .filter(Server::isHealthy)
            .count();
    }
    
    private long getTotalServerCount() {
        return getAllServers().size();
    }
    
    private List<Server> getAllServers() {
        // 获取所有服务器
        return Collections.emptyList();
    }
}

九、最佳实践总结

9.1 负载均衡架构设计原则

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
设计原则:
  1. 高可用:
    - 多可用区部署
    - 主备冗余
    - 自动故障转移
  
  2. 高性能:
    - 连接复用
    - 长连接
    - 健康检查优化
  
  3. 可扩展:
    - 水平扩展
    - 动态配置
    - 弹性伸缩
  
  4. 可观测:
    - 全面监控
    - 日志记录
    - 告警机制
  
  5. 安全性:
    - DDoS防护
    - SSL/TLS卸载
    - 访问控制

9.2 负载均衡算法选择

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
算法选择指南:
  轮询算法 (Round Robin):
    适用场景: 服务器性能相近，无状态服务
    优点: 简单，负载均匀
    缺点: 不考虑服务器性能差异
  
  加权轮询 (Weighted Round Robin):
    适用场景: 服务器性能差异较大
    优点: 考虑服务器性能
    缺点: 静态权重，不能动态调整
  
  最小连接 (Least Connections):
    适用场景: 长连接，请求处理时间差异大
    优点: 动态负载均衡
    缺点: 需要维护连接数
  
  响应时间 (Response Time):
    适用场景: 对响应时间敏感
    优点: 优先选择快速服务器
    缺点: 需要持续监控响应时间
  
  一致性Hash (Consistent Hash):
    适用场景: 需要会话保持，缓存场景
    优点: 会话保持，负载均衡
    缺点: 服务器变更时部分请求失效

9.3 云负载均衡方案对比

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
云服务商对比:
  阿里云SLB:
    优势:
      - 国内访问速度快
      - 功能丰富
      - 价格相对较低
    适用场景: 国内业务，中小型企业
  
  AWS ELB:
    优势:
      - 全球部署
      - 功能完善
      - 生态系统成熟
    适用场景: 国际化业务，大型企业
  
  Azure Load Balancer:
    优势:
      - 与Microsoft生态集成好
      - 企业级功能
    适用场景: Microsoft生态，企业级应用
  
  自建方案:
    优势:
      - 完全可控
      - 定制化强
      - 成本可控
    适用场景: 对定制化要求高，技术团队强

9.4 架构师级别建议

  1. 选择合适的负载均衡方案: 根据业务需求选择云服务或自建方案
  2. 设计高可用架构: 多可用区部署，主备冗余，自动故障转移
  3. 优化负载均衡算法: 根据业务场景选择合适的算法，支持动态调整
  4. 建立完善的监控体系: 全面监控负载均衡器和后端服务器状态
  5. 定期进行性能测试: 验证负载均衡配置的有效性
  6. 建立故障应急预案: 快速响应故障，最小化业务影响

通过以上方案，可以构建高可用、高性能的云负载均衡架构，确保系统的稳定运行和良好的用户体验。