分布式服务发现与负载均衡

一、分布式服务发现概述

分布式服务发现是微服务架构中自动发现和注册服务实例的机制，在数据密集型应用中，高效的服务发现和负载均衡是保障系统高可用和高性能的关键。

二、服务发现模式

2.1 服务发现模式对比

2.2 服务发现架构图

三、服务注册中心实现

3.1 Consul服务发现

public class ConsulServiceDiscovery : IServiceDiscovery
{
    private readonly IConsulClient _consulClient;
    
    public ConsulServiceDiscovery(IConsulClient consulClient)
    {
        _consulClient = consulClient;
    }
    
    public async Task RegisterServiceAsync(ServiceRegistration registration)
    {
        var registrationEntry = new AgentServiceRegistration
        {
            ID = registration.ServiceId,
            Name = registration.ServiceName,
            Address = registration.Host,
            Port = registration.Port,
            Tags = registration.Tags,
            Check = new AgentServiceCheck
            {
                HTTP = $"http://{registration.Host}:{registration.Port}/health",
                Interval = TimeSpan.FromSeconds(10),
                Timeout = TimeSpan.FromSeconds(5),
                DeregisterCriticalServiceAfter = TimeSpan.FromMinutes(1)
            }
        };
        
        await _consulClient.Agent.ServiceRegister(registrationEntry);
    }
    
    public async Task DeregisterServiceAsync(string serviceId)
    {
        await _consulClient.Agent.ServiceDeregister(serviceId);
    }
    
    public async Task> DiscoverServiceAsync(string serviceName)
    {
        var queryResult = await _consulClient.Health.Service(serviceName, string.Empty, true);
        
        return queryResult.Response.Select(s => new ServiceInstance
        {
            ServiceName = s.Service.Service,
            Host = s.Service.Address,
            Port = s.Service.Port,
            Tags = s.Service.Tags
        }).ToList();
    }
    
    public async Task DiscoverOneAsync(string serviceName)
    {
        var instances = await DiscoverServiceAsync(serviceName);
        
        return _loadBalancer.Select(instances);
    }
}

3.2 etcd服务发现

public class EtcdServiceDiscovery : IServiceDiscovery
{
    private readonly IEtcdClient _etcdClient;
    
    public EtcdServiceDiscovery(IEtcdClient etcdClient)
    {
        _etcdClient = etcdClient;
    }
    
    public async Task RegisterServiceAsync(ServiceRegistration registration)
    {
        var key = $"/services/{registration.ServiceName}/{registration.ServiceId}";
        var value = JsonSerializer.Serialize(new
        {
            Host = registration.Host,
            Port = registration.Port,
            Tags = registration.Tags
        });
        
        var leaseResponse = await _etcdClient.LeaseGrantAsync(60);
        
        await _etcdClient.PutAsync(key, value, leaseResponse.ID);
    }
    
    public async Task DeregisterServiceAsync(string serviceId)
    {
        var keys = await _etcdClient.GetPrefixAsync($"/services/*/{serviceId}");
        
        foreach (var kv in keys.Kvs)
        {
            await _etcdClient.DeleteAsync(kv.Key);
        }
    }
    
    public async Task> DiscoverServiceAsync(string serviceName)
    {
        var prefix = $"/services/{serviceName}/";
        var response = await _etcdClient.GetPrefixAsync(prefix);
        
        return response.Kvs.Select(kv =>
        {
            var data = JsonSerializer.Deserialize(kv.Value);
            
            return new ServiceInstance
            {
                ServiceName = serviceName,
                Host = data.Host,
                Port = data.Port,
                Tags = data.Tags
            };
        }).ToList();
    }
}

四、负载均衡策略

4.1 负载均衡策略对比

4.2 负载均衡实现

public class LoadBalancer : ILoadBalancer
{
    private readonly LoadBalancingStrategy _strategy;
    private readonly ConcurrentDictionary _roundRobinIndex = new();
    private readonly ConcurrentDictionary _connectionCounts = new();
    
    public LoadBalancer(LoadBalancingStrategy strategy = LoadBalancingStrategy.RoundRobin)
    {
        _strategy = strategy;
    }
    
    public ServiceInstance Select(List instances)
    {
        if (instances == null || instances.Count == 0)
        {
            throw new NoAvailableServiceException("No available service instances");
        }
        
        return _strategy switch
        {
            LoadBalancingStrategy.RoundRobin => SelectRoundRobin(instances),
            LoadBalancingStrategy.WeightedRoundRobin => SelectWeightedRoundRobin(instances),
            LoadBalancingStrategy.LeastConnections => SelectLeastConnections(instances),
            LoadBalancingStrategy.IpHash => SelectByIpHash(instances),
            LoadBalancingStrategy.Random => SelectRandom(instances),
            LoadBalancingStrategy.MinimumResponseTime => SelectByResponseTime(instances),
            _ => SelectRoundRobin(instances)
        };
    }
    
    private ServiceInstance SelectRoundRobin(List instances)
    {
        var key = instances[0].ServiceName;
        var index = _roundRobinIndex.AddOrUpdate(key, 0, (k, v) => (v + 1) % instances.Count);
        
        return instances[index];
    }
    
    private ServiceInstance SelectWeightedRoundRobin(List instances)
    {
        var totalWeight = instances.Sum(i => i.Weight);
        var random = new Random();
        var randomWeight = random.Next(totalWeight);
        
        foreach (var instance in instances)
        {
            randomWeight -= instance.Weight;
            
            if (randomWeight < 0)
            {
                return instance;
            }
        }
        
        return instances[0];
    }
    
    private ServiceInstance SelectLeastConnections(List instances)
    {
        var minConnections = int.MaxValue;
        ServiceInstance selected = null;
        
        foreach (var instance in instances)
        {
            var connections = _connectionCounts.GetOrAdd(instance.Host, 0);
            
            if (connections < minConnections)
            {
                minConnections = connections;
                selected = instance;
            }
        }
        
        return selected;
    }
    
    private ServiceInstance SelectByIpHash(List instances)
    {
        var ipHash = _httpContextAccessor.HttpContext.Connection.RemoteIpAddress.GetHashCode();
        
        return instances[Math.Abs(ipHash) % instances.Count];
    }
    
    private ServiceInstance SelectRandom(List instances)
    {
        var random = new Random();
        
        return instances[random.Next(instances.Count)];
    }
    
    private ServiceInstance SelectByResponseTime(List instances)
    {
        var minResponseTime = double.MaxValue;
        ServiceInstance selected = null;
        
        foreach (var instance in instances)
        {
            if (instance.ResponseTime < minResponseTime)
            {
                minResponseTime = instance.ResponseTime;
                selected = instance;
            }
        }
        
        return selected;
    }
}

五、服务健康检查

5.1 健康检查机制

public class HealthCheckService
{
    public async Task CheckAsync(ServiceInstance instance)
    {
        try
        {
            using var client = new HttpClient();
            client.Timeout = TimeSpan.FromSeconds(5);
            
            var response = await client.GetAsync($"http://{instance.Host}:{instance.Port}/health");
            
            return new HealthCheckResult
            {
                ServiceName = instance.ServiceName,
                Host = instance.Host,
                Port = instance.Port,
                Healthy = response.IsSuccessStatusCode,
                ResponseTime = response.StatusCode == HttpStatusCode.OK 
                    ? response.Headers.Date.HasValue 
                        ? DateTime.UtcNow - response.Headers.Date.Value.UtcDateTime 
                        : TimeSpan.Zero 
                    : TimeSpan.MaxValue,
                ErrorMessage = response.IsSuccessStatusCode ? null : response.ReasonPhrase
            };
        }
        catch (Exception ex)
        {
            return new HealthCheckResult
            {
                ServiceName = instance.ServiceName,
                Host = instance.Host,
                Port = instance.Port,
                Healthy = false,
                ResponseTime = TimeSpan.MaxValue,
                ErrorMessage = ex.Message
            };
        }
    }
    
    public async Task> CheckAllAsync(List instances)
    {
        var tasks = instances.Select(instance => CheckAsync(instance));
        
        return (await Task.WhenAll(tasks)).ToList();
    }
    
    public async Task MonitorAsync(string serviceName, TimeSpan interval)
    {
        while (true)
        {
            var instances = await _serviceDiscovery.DiscoverServiceAsync(serviceName);
            var results = await CheckAllAsync(instances);
            
            foreach (var result in results.Where(r => !r.Healthy))
            {
                await _alertService.SendAlert("服务健康检查失败", 
                    $"服务: {result.ServiceName}, 地址: {result.Host}:{result.Port}, 错误: {result.ErrorMessage}");
            }
            
            await Task.Delay(interval);
        }
    }
}

5.2 健康检查类型

六、服务发现监控与管理

6.1 服务发现监控

public class ServiceDiscoveryMonitor
{
    public async Task GetMetricsAsync()
    {
        var metrics = new ServiceDiscoveryMetrics();
        
        var services = await _serviceDiscovery.GetAllServicesAsync();
        
        foreach (var service in services)
        {
            metrics.TotalServices++;
            
            var instances = await _serviceDiscovery.DiscoverServiceAsync(service);
            
            metrics.TotalInstances += instances.Count;
            metrics.HealthyInstances += instances.Count(i => i.Healthy);
        }
        
        metrics.UnhealthyInstances = metrics.TotalInstances - metrics.HealthyInstances;
        
        return metrics;
    }
    
    public async Task MonitorAsync()
    {
        var metrics = await GetMetricsAsync();
        
        if (metrics.UnhealthyInstances > 0)
        {
            await _alertService.SendAlert("服务实例不健康", 
                $"不健康实例数: {metrics.UnhealthyInstances}");
        }
        
        if (metrics.TotalServices == 0)
        {
            await _alertService.SendAlert("没有注册的服务", 
                "服务发现中心没有注册任何服务");
        }
    }
}

public class ServiceDiscoveryMetrics
{
    public int TotalServices { get; set; }
    public int TotalInstances { get; set; }
    public int HealthyInstances { get; set; }
    public int UnhealthyInstances { get; set; }
}

6.2 服务管理API

public class ServiceManagementService
{
    public async Task RegisterServiceAsync(ServiceRegistrationRequest request)
    {
        var registration = new ServiceRegistration
        {
            ServiceId = Guid.NewGuid().ToString(),
            ServiceName = request.ServiceName,
            Host = request.Host,
            Port = request.Port,
            Tags = request.Tags,
            Weight = request.Weight ?? 1
        };
        
        await _serviceDiscovery.RegisterServiceAsync(registration);
        
        return registration;
    }
    
    public async Task DeregisterServiceAsync(string serviceId)
    {
        await _serviceDiscovery.DeregisterServiceAsync(serviceId);
    }
    
    public async Task> GetServiceInstancesAsync(string serviceName)
    {
        return await _serviceDiscovery.DiscoverServiceAsync(serviceName);
    }
    
    public async Task> GetAllServicesAsync()
    {
        return await _serviceDiscovery.GetAllServicesAsync();
    }
    
    public async Task UpdateServiceWeightAsync(string serviceId, int weight)
    {
        await _serviceDiscovery.UpdateServiceWeightAsync(serviceId, weight);
    }
}

七、服务发现与负载均衡最佳实践

7.1 服务发现最佳实践

• 选择合适的服务发现模式
• 实现健康检查机制
• 配置合理的TTL
• 实现服务自动注册和注销
• 监控服务状态变化

7.2 负载均衡最佳实践

public class LoadBalancingBestPractices
{
    public LoadBalancingStrategy SelectStrategy(ServiceType serviceType)
    {
        return serviceType switch
        {
            ServiceType.Stateless => LoadBalancingStrategy.RoundRobin,
            ServiceType.Stateful => LoadBalancingStrategy.IpHash,
            ServiceType.ComputeIntensive => LoadBalancingStrategy.LeastConnections,
            ServiceType.LatencySensitive => LoadBalancingStrategy.MinimumResponseTime,
            _ => LoadBalancingStrategy.RoundRobin
        };
    }
    
    public void ConfigureHealthCheck(HealthCheckOptions options)
    {
        options.Interval = TimeSpan.FromSeconds(10);
        options.Timeout = TimeSpan.FromSeconds(5);
        options.FailureThreshold = 3;
        options.SuccessThreshold = 2;
    }
}

7.3 容错与降级

public class ServiceFaultToleranceService
{
    public async Task ExecuteWithRetryAsync(Func> operation, int maxRetries = 3)
    {
        for (int i = 0; i < maxRetries; i++)
        {
            try
            {
                return await operation();
            }
            catch (Exception)
            {
                if (i == maxRetries - 1)
                {
                    throw;
                }
                
                await Task.Delay(TimeSpan.FromSeconds(Math.Pow(2, i)));
            }
        }
        
        throw new Exception("Operation failed after retries");
    }
    
    public async Task ExecuteWithCircuitBreakerAsync(Func> operation, TimeSpan timeout)
    {
        if (_circuitBreaker.IsOpen)
        {
            throw new CircuitBreakerException("Circuit breaker is open");
        }
        
        try
        {
            return await operation();
        }
        catch (Exception)
        {
            _circuitBreaker.IncrementFailureCount();
            
            if (_circuitBreaker.ShouldOpen())
            {
                _circuitBreaker.Open();
                _ = Task.Delay(timeout).ContinueWith(_ => _circuitBreaker.Close());
            }
            
            throw;
        }
    }
}

八、总结

分布式服务发现与负载均衡是微服务架构中保障系统高可用和高性能的关键。通过合理选择服务发现模式、实现多种负载均衡策略、做好健康检查和监控，能够构建可靠的分布式服务发现系统。定期优化配置、实现容错和降级，能够保障系统的稳定运行。