Load Balancers - Traffic Distribution Components

Tổng quan

Load balancers distribute incoming traffic across multiple servers để improve performance, availability, và scalability.

Types of Load Balancers

Layer 4 (Transport Layer)

class L4LoadBalancer:
    def route_request(self, client_ip, port):
        # Route based on IP và port
        server = self.select_server_round_robin()
        return self.forward_tcp_connection(server, client_ip, port)

Layer 7 (Application Layer)

class L7LoadBalancer:
    def route_request(self, http_request):
        # Route based on HTTP content
        if http_request.path.startswith('/api/'):
            return self.api_servers
        elif http_request.path.startswith('/static/'):
            return self.static_servers
        else:
            return self.web_servers

Load Balancing Algorithms

Round Robin

class RoundRobinBalancer:
    def __init__(self, servers):
        self.servers = servers
        self.current = 0

    def get_server(self):
        server = self.servers[self.current]
        self.current = (self.current + 1) % len(self.servers)
        return server

Weighted Round Robin

class WeightedRoundRobinBalancer:
    def __init__(self, servers_with_weights):
        self.servers = servers_with_weights
        self.current_weights = [0] * len(servers)

    def get_server(self):
        total_weight = sum(weight for _, weight in self.servers)
        best_server = None
        best_weight = -1

        for i, (server, weight) in enumerate(self.servers):
            self.current_weights[i] += weight
            if self.current_weights[i] > best_weight:
                best_weight = self.current_weights[i]
                best_server = i

        self.current_weights[best_server] -= total_weight
        return self.servers[best_server][0]

Least Connections

class LeastConnectionsBalancer:
    def get_server(self):
        return min(self.servers, key=lambda s: s.active_connections)

IP Hash

import hashlib

class IPHashBalancer:
    def get_server(self, client_ip):
        hash_value = int(hashlib.md5(client_ip.encode()).hexdigest(), 16)
        return self.servers[hash_value % len(self.servers)]

Health Checks

Active Health Checks

class HealthChecker:
    def __init__(self, servers):
        self.servers = servers
        self.healthy_servers = set(servers)

    def check_health(self):
        for server in self.servers:
            try:
                response = requests.get(f"http://{server}/health", timeout=5)
                if response.status_code == 200:
                    self.healthy_servers.add(server)
                else:
                    self.healthy_servers.discard(server)
            except requests.RequestException:
                self.healthy_servers.discard(server)

Passive Health Checks

class PassiveHealthChecker:
    def __init__(self):
        self.error_counts = defaultdict(int)
        self.threshold = 5

    def record_response(self, server, success):
        if success:
            self.error_counts[server] = 0
        else:
            self.error_counts[server] += 1

    def is_healthy(self, server):
        return self.error_counts[server] < self.threshold

Session Affinity

Sticky Sessions

class StickySessionBalancer:
    def __init__(self):
        self.session_map = {}

    def get_server(self, session_id):
        if session_id in self.session_map:
            return self.session_map[session_id]

        server = self.select_server()
        self.session_map[session_id] = server
        return server

SSL Termination

SSL Offloading

class SSLTerminatingBalancer:
    def handle_request(self, encrypted_request):
        # Decrypt at load balancer
        decrypted_request = self.ssl_decrypt(encrypted_request)

        # Forward plain HTTP to backend
        server = self.get_server()
        response = self.forward_http(server, decrypted_request)

        # Encrypt response
        return self.ssl_encrypt(response)

Configuration Examples

Nginx Load Balancer

upstream backend {
    server backend1.example.com:8080 weight=3;
    server backend2.example.com:8080 weight=1;
    server backend3.example.com:8080 backup;
}

server {
    listen 80;
    location / {
        proxy_pass http://backend;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
    }
}

HAProxy Configuration

backend webservers
    balance roundrobin
    option httpchk GET /health
    server web1 192.168.1.10:80 check
    server web2 192.168.1.11:80 check
    server web3 192.168.1.12:80 check

AWS Application Load Balancer

Type: AWS::ElasticLoadBalancingV2::LoadBalancer
Properties:
  Type: application
  Scheme: internet-facing
  Subnets:
    - subnet-12345
    - subnet-67890
  SecurityGroups:
    - sg-security-group

High Availability

Multiple Load Balancers

class HALoadBalancerCluster:
    def __init__(self, primary, secondary):
        self.primary = primary
        self.secondary = secondary
        self.is_primary_healthy = True

    def route_request(self, request):
        if self.is_primary_healthy:
            try:
                return self.primary.handle(request)
            except Exception:
                self.is_primary_healthy = False
                return self.secondary.handle(request)
        else:
            return self.secondary.handle(request)

Monitoring

Metrics Collection

class LoadBalancerMetrics:
    def collect_metrics(self):
        return {
            'requests_per_second': self.get_rps(),
            'active_connections': self.get_active_connections(),
            'response_times': self.get_response_times(),
            'error_rate': self.get_error_rate(),
            'server_health': self.get_server_health_status()
        }

Best Practices

Load Balancer Selection

Use L4 cho high performance
Use L7 cho intelligent routing
Implement health checks
Plan for failover
Monitor performance metrics

Security Considerations

DDoS protection
Rate limiting
SSL certificate management
WAF integration
IP whitelisting/blacklisting

Next Steps

📚 Học về Caching Strategies
🎯 Practice load balancer configuration
🏗️ Explore cloud load balancers
💻 Setup monitoring

Content sẽ được expand với advanced load balancing patterns.