0
# Load Balancer Services
1

2
The load balancer service provides a unified interface for load balancer management across multiple cloud providers including AWS ELB/ALB, Azure Load Balancer, Google Load Balancer, Rackspace Load Balancer, and others.
3

4
## Providers
5

6
```python { .api }
7
from libcloud.loadbalancer.types import Provider
8

9
class Provider:
10
    """Enumeration of supported load balancer providers"""
11
    ELB = 'elb'                    # AWS Elastic Load Balancer
12
    ALB = 'alb'                    # AWS Application Load Balancer  
13
    GCE = 'gce'                    # Google Cloud Load Balancer
14
    RACKSPACE = 'rackspace'        # Rackspace Cloud Load Balancers
15
    NINEFOLD = 'ninefold'          # Ninefold Load Balancer
16
    BRIGHTBOX = 'brightbox'        # Brightbox Load Balancer
17
    CLOUDSTACK = 'cloudstack'      # CloudStack Load Balancer
18
    DIMENSIONDATA = 'dimensiondata' # Dimension Data Load Balancer
19
    # ... more providers
20
```
21

22
## Driver Factory
23

24
```python { .api }
25
from libcloud.loadbalancer.providers import get_driver
26

27
def get_driver(provider: Provider) -> type[Driver]
28
```
29

30
Get the driver class for a specific load balancer provider.
31

32
**Parameters:**
33
- `provider`: Provider identifier from the Provider enum
34

35
**Returns:**
36
- Driver class for the specified provider
37

38
**Example:**
39
```python
40
from libcloud.loadbalancer.types import Provider
41
from libcloud.loadbalancer.providers import get_driver
42

43
# Get AWS ELB driver class
44
cls = get_driver(Provider.ELB)
45

46
# Initialize driver with credentials
47
driver = cls('access_key', 'secret_key', region='us-east-1')
48
```
49

50
## Core Classes
51

52
### Driver
53

54
```python { .api }
55
class Driver(BaseDriver):
56
    """Base class for all load balancer drivers"""
57
    
58
    def list_protocols(self) -> List[str]
59
    def list_balancers(self) -> List[LoadBalancer]
60
    def create_balancer(self, name: str, port: int, protocol: str, algorithm: Algorithm, members: List[Member]) -> LoadBalancer
61
    def destroy_balancer(self, balancer: LoadBalancer) -> bool
62
    def get_balancer(self, balancer_id: str) -> LoadBalancer
63
    def update_balancer(self, balancer: LoadBalancer, **kwargs) -> LoadBalancer
64
    def balancer_list_members(self, balancer: LoadBalancer) -> List[Member]
65
    def balancer_attach_member(self, balancer: LoadBalancer, member: Member) -> bool
66
    def balancer_detach_member(self, balancer: LoadBalancer, member: Member) -> bool
67
    def balancer_attach_compute_node(self, balancer: LoadBalancer, node: Node) -> Member
68
    def balancer_detach_compute_node(self, balancer: LoadBalancer, node: Node) -> bool
69
    def ex_list_balancer_health_checks(self, balancer: LoadBalancer) -> List[Dict]
70
    def ex_create_balancer_health_check(self, balancer: LoadBalancer, **kwargs) -> Dict
71
```
72

73
Base class that all load balancer drivers inherit from. Provides methods for managing load balancers and their members.
74

75
**Key Methods:**
76

77
- `list_balancers()`: List all load balancers in the account
78
- `create_balancer()`: Create a new load balancer
79
- `destroy_balancer()`: Delete a load balancer
80
- `balancer_attach_member()`: Add a member to a load balancer
81
- `balancer_detach_member()`: Remove a member from a load balancer
82
- `balancer_attach_compute_node()`: Attach a compute node as a member
83

84
### LoadBalancer
85

86
```python { .api }
87
class LoadBalancer:
88
    """Represents a load balancer"""
89
    
90
    id: str
91
    name: str
92
    state: State
93
    ip: str
94
    port: int
95
    driver: Driver
96
    extra: Dict[str, Any]
97
    
98
    def attach_member(self, member: Member) -> bool
99
    def detach_member(self, member: Member) -> bool  
100
    def list_members(self) -> List[Member]
101
    def destroy(self) -> bool
102
```
103

104
Represents a load balancer instance.
105

106
**Properties:**
107
- `id`: Unique load balancer identifier
108
- `name`: Human-readable name
109
- `state`: Current state (running, pending, unknown, etc.)
110
- `ip`: Load balancer IP address or DNS name
111
- `port`: Port number the load balancer listens on
112
- `extra`: Provider-specific metadata
113

114
**Methods:**
115
- `attach_member()`: Add a member to this load balancer
116
- `detach_member()`: Remove a member from this load balancer
117
- `list_members()`: List all members attached to this load balancer
118
- `destroy()`: Delete this load balancer
119

120
### Member
121

122
```python { .api }
123
class Member:
124
    """Represents a load balancer member/target"""
125
    
126
    id: str
127
    ip: str
128
    port: int
129
    balancer: LoadBalancer
130
    extra: Dict[str, Any]
131
```
132

133
Represents a member (backend server) attached to a load balancer.
134

135
**Properties:**
136
- `id`: Unique member identifier
137
- `ip`: Member IP address
138
- `port`: Port number on the member
139
- `balancer`: Parent load balancer
140
- `extra`: Provider-specific metadata (health status, weight, etc.)
141

142
### Algorithm
143

144
```python { .api }
145
class Algorithm:
146
    """Load balancing algorithms"""
147
    ROUND_ROBIN = 'round_robin'
148
    LEAST_CONNECTIONS = 'least_connections'
149
    RANDOM = 'random'
150
    WEIGHTED_ROUND_ROBIN = 'weighted_round_robin'
151
    WEIGHTED_LEAST_CONNECTIONS = 'weighted_least_connections'
152
    SOURCE_IP = 'source_ip'
153
```
154

155
Enumeration of supported load balancing algorithms.
156

157
### State
158

159
```python { .api }
160
class State:
161
    """Load balancer states"""
162
    RUNNING = 0
163
    PENDING = 1
164
    UNKNOWN = 2
165
    DELETED = 3
166
```
167

168
Enumeration of possible load balancer states.
169

170
### MemberCondition
171

172
```python { .api }
173
class MemberCondition:
174
    """Member health conditions"""
175
    ENABLED = 'enabled'
176
    DISABLED = 'disabled'
177
    DRAINING = 'draining'
178
```
179

180
Enumeration of member health/status conditions.
181

182
### DEFAULT_ALGORITHM
183

184
```python { .api }
185
DEFAULT_ALGORITHM: Algorithm = Algorithm.ROUND_ROBIN
186
```
187

188
Default load balancing algorithm used when none is specified.
189

190
## Usage Examples
191

192
### Basic Load Balancer Management
193

194
```python
195
from libcloud.loadbalancer.types import Provider, Algorithm
196
from libcloud.loadbalancer.providers import get_driver
197

198
# Initialize driver
199
cls = get_driver(Provider.ELB)
200
driver = cls('access_key', 'secret_key', region='us-east-1')
201

202
# List existing load balancers
203
balancers = driver.list_balancers()
204
for balancer in balancers:
205
    print(f"Load Balancer: {balancer.name} ({balancer.state}) - {balancer.ip}:{balancer.port}")
206

207
# Check supported protocols
208
protocols = driver.list_protocols()
209
print(f"Supported protocols: {protocols}")
210

211
# Create members for the load balancer
212
members = [
213
    Member(id=None, ip='10.0.1.10', port=80, balancer=None),
214
    Member(id=None, ip='10.0.1.11', port=80, balancer=None),
215
    Member(id=None, ip='10.0.1.12', port=80, balancer=None)
216
]
217

218
# Create a new load balancer
219
balancer = driver.create_balancer(
220
    name='web-lb',
221
    port=80,
222
    protocol='http',
223
    algorithm=Algorithm.ROUND_ROBIN,
224
    members=members
225
)
226
print(f"Created load balancer: {balancer.name} ({balancer.id})")
227
print(f"Load balancer IP: {balancer.ip}")
228
```
229

230
### Managing Load Balancer Members
231

232
```python
233
# Get an existing load balancer
234
balancer = driver.get_balancer('lb-12345')
235

236
# List current members
237
current_members = balancer.list_members()
238
print(f"Current members: {len(current_members)}")
239

240
for member in current_members:
241
    print(f"  Member: {member.ip}:{member.port} (ID: {member.id})")
242
    if 'condition' in member.extra:
243
        print(f"    Status: {member.extra['condition']}")
244

245
# Add a new member
246
new_member = Member(id=None, ip='10.0.1.13', port=80, balancer=balancer)
247
success = balancer.attach_member(new_member)
248
print(f"Added new member: {success}")
249

250
# Alternative: Add using driver method
251
success = driver.balancer_attach_member(balancer, new_member)
252
print(f"Added member via driver: {success}")
253

254
# Remove a member
255
if current_members:
256
    member_to_remove = current_members[0]
257
    success = balancer.detach_member(member_to_remove)
258
    print(f"Removed member {member_to_remove.ip}: {success}")
259
```
260

261
### Integration with Compute Nodes
262

263
```python
264
from libcloud.compute.types import Provider as ComputeProvider
265
from libcloud.compute.providers import get_driver as get_compute_driver
266

267
# Initialize compute driver
268
compute_cls = get_compute_driver(ComputeProvider.EC2)
269
compute_driver = compute_cls('access_key', 'secret_key', region='us-east-1')
270

271
# Get existing compute nodes
272
nodes = compute_driver.list_nodes()
273
web_servers = [node for node in nodes if 'web' in node.name.lower()]
274

275
print(f"Found {len(web_servers)} web server nodes")
276

277
# Attach compute nodes to load balancer
278
for node in web_servers[:3]:  # Attach first 3 web servers
279
    if node.private_ips:  # Use private IP for internal load balancing
280
        member = driver.balancer_attach_compute_node(balancer, node)
281
        print(f"Attached node {node.name} ({node.private_ips[0]}) as member {member.id}")
282

283
# Alternative: Detach a compute node
284
if web_servers:
285
    node_to_detach = web_servers[0]
286
    success = driver.balancer_detach_compute_node(balancer, node_to_detach)
287
    print(f"Detached node {node_to_detach.name}: {success}")
288
```
289

290
### Advanced Load Balancer Configuration
291

292
```python
293
# Create load balancer with advanced configuration
294
advanced_members = [
295
    Member(id=None, ip='10.0.1.10', port=80, balancer=None),
296
    Member(id=None, ip='10.0.1.11', port=80, balancer=None)
297
]
298

299
# AWS ELB specific configuration
300
elb_balancer = driver.create_balancer(
301
    name='advanced-web-lb',
302
    port=443,  # HTTPS
303
    protocol='https',
304
    algorithm=Algorithm.LEAST_CONNECTIONS,
305
    members=advanced_members
306
)
307

308
print(f"Created HTTPS load balancer: {elb_balancer.name}")
309

310
# Configure health checks (provider specific)
311
try:
312
    health_checks = driver.ex_list_balancer_health_checks(elb_balancer)
313
    print(f"Current health checks: {len(health_checks)}")
314
    
315
    # Create custom health check
316
    health_check = driver.ex_create_balancer_health_check(
317
        balancer=elb_balancer,
318
        target='HTTP:80/health',
319
        interval=30,
320
        timeout=5,
321
        healthy_threshold=2,
322
        unhealthy_threshold=5
323
    )
324
    print(f"Created health check: {health_check}")
325
    
326
except AttributeError:
327
    print("Health check configuration not available for this provider")
328
```
329

330
### Multi-Protocol Load Balancer
331

332
```python
333
# Create load balancer for multiple protocols (if supported)
334
def create_multi_protocol_lb(driver, name, members):
335
    """Create load balancers for different protocols"""
336
    protocols = ['http', 'https', 'tcp']
337
    balancers = {}
338
    
339
    for protocol in protocols:
340
        port = 80 if protocol == 'http' else (443 if protocol == 'https' else 8080)
341
        
342
        try:
343
            balancer = driver.create_balancer(
344
                name=f'{name}-{protocol}',
345
                port=port,
346
                protocol=protocol,
347
                algorithm=Algorithm.ROUND_ROBIN,
348
                members=members
349
            )
350
            balancers[protocol] = balancer
351
            print(f"Created {protocol.upper()} load balancer: {balancer.ip}:{balancer.port}")
352
            
353
        except Exception as e:
354
            print(f"Failed to create {protocol} load balancer: {e}")
355
    
356
    return balancers
357

358
# Usage
359
multi_members = [
360
    Member(id=None, ip='10.0.1.10', port=80, balancer=None),
361
    Member(id=None, ip='10.0.1.11', port=80, balancer=None)
362
]
363

364
protocol_balancers = create_multi_protocol_lb(driver, 'api-lb', multi_members)
365
```
366

367
### Load Balancer Monitoring and Health Management
368

369
```python
370
import time
371
from typing import Dict, List
372

373
def monitor_load_balancer_health(driver, balancer, interval: int = 60):
374
    """Monitor load balancer and member health"""
375
    print(f"Monitoring load balancer: {balancer.name}")
376
    
377
    while True:
378
        try:
379
            # Refresh balancer state
380
            current_balancer = driver.get_balancer(balancer.id)
381
            print(f"Load balancer state: {current_balancer.state}")
382
            
383
            # Check member health
384
            members = driver.balancer_list_members(current_balancer)
385
            healthy_members = 0
386
            
387
            for member in members:
388
                status = member.extra.get('condition', 'unknown')
389
                health = member.extra.get('health_status', 'unknown')
390
                
391
                print(f"  Member {member.ip}:{member.port} - Status: {status}, Health: {health}")
392
                
393
                if status == 'enabled' and health == 'healthy':
394
                    healthy_members += 1
395
            
396
            print(f"Healthy members: {healthy_members}/{len(members)}")
397
            
398
            # Alert if too few healthy members
399
            if healthy_members < 2:
400
                print("WARNING: Less than 2 healthy members!")
401
                # Here you could send alerts, create new instances, etc.
402
            
403
        except Exception as e:
404
            print(f"Error monitoring load balancer: {e}")
405
        
406
        time.sleep(interval)
407

408
def manage_member_weights(driver, balancer, member_weights: Dict[str, int]):
409
    """Update member weights for weighted load balancing"""
410
    members = driver.balancer_list_members(balancer)
411
    
412
    for member in members:
413
        member_key = f"{member.ip}:{member.port}"
414
        if member_key in member_weights:
415
            weight = member_weights[member_key]
416
            
417
            # This is provider-specific - check your provider's documentation
418
            try:
419
                # Update member with new weight (example for providers that support it)
420
                updated_member = driver.ex_update_balancer_member(
421
                    balancer, member, weight=weight
422
                )
423
                print(f"Updated weight for {member_key} to {weight}")
424
            except AttributeError:
425
                print(f"Weight management not supported by this provider")
426

427
# Usage examples
428
balancer = driver.get_balancer('lb-12345')
429

430
# Set different weights for members
431
weights = {
432
    '10.0.1.10:80': 100,  # Full weight
433
    '10.0.1.11:80': 75,   # Reduced weight  
434
    '10.0.1.12:80': 50    # Half weight
435
}
436

437
manage_member_weights(driver, balancer, weights)
438

439
# Start monitoring (run in separate thread/process)
440
# monitor_load_balancer_health(driver, balancer, interval=30)
441
```
442

443
### Auto-Scaling Integration
444

445
```python
446
def auto_scale_load_balancer(compute_driver, lb_driver, balancer, template_node, min_members=2, max_members=10):
447
    """Auto-scale load balancer members based on health"""
448
    
449
    members = lb_driver.balancer_list_members(balancer)
450
    healthy_members = sum(1 for m in members if m.extra.get('health_status') == 'healthy')
451
    
452
    print(f"Current members: {len(members)}, Healthy: {healthy_members}")
453
    
454
    # Scale up if too few healthy members
455
    if healthy_members < min_members and len(members) < max_members:
456
        print("Scaling up: Creating new compute node...")
457
        
458
        # Create new compute node based on template
459
        new_node = compute_driver.create_node(
460
            name=f"auto-web-{int(time.time())}",
461
            size=template_node.size,
462
            image=template_node.image,
463
            location=template_node.extra.get('availability_zone')
464
        )
465
        
466
        # Wait for node to be running
467
        compute_driver.wait_until_running([new_node])
468
        
469
        # Add to load balancer
470
        new_member = lb_driver.balancer_attach_compute_node(balancer, new_node)
471
        print(f"Added new member: {new_member.ip}:{new_member.port}")
472
    
473
    # Scale down if too many healthy members
474
    elif healthy_members > max_members:
475
        print("Scaling down: Removing excess members...")
476
        
477
        # Find oldest member to remove
478
        members_by_age = sorted(members, key=lambda m: m.extra.get('created_time', ''))
479
        member_to_remove = members_by_age[0]
480
        
481
        # Remove from load balancer
482
        success = lb_driver.balancer_detach_member(balancer, member_to_remove)
483
        if success:
484
            print(f"Removed member: {member_to_remove.ip}:{member_to_remove.port}")
485
            
486
            # Optionally terminate the compute node
487
            # node_to_terminate = compute_driver.get_node(member_to_remove.extra.get('node_id'))
488
            # compute_driver.destroy_node(node_to_terminate)
489

490
# Usage
491
template_node = compute_driver.list_nodes()[0]  # Use existing node as template
492
auto_scale_load_balancer(compute_driver, driver, balancer, template_node)
493
```
494

495
### Cross-Provider Load Balancer Management
496

497
```python
498
from libcloud.loadbalancer.types import Provider
499
from libcloud.loadbalancer.providers import get_driver
500

501
# Configure multiple load balancer providers
502
lb_providers = {
503
    'aws_elb': {
504
        'driver': get_driver(Provider.ELB),
505
        'credentials': ('aws_access_key', 'aws_secret_key'),
506
        'region': 'us-east-1'
507
    },
508
    'gce_lb': {
509
        'driver': get_driver(Provider.GCE),
510
        'credentials': ('service_account_email', 'key_file_path'),
511
        'project': 'my-project'
512
    }
513
}
514

515
# Initialize drivers
516
lb_drivers = {}
517
for name, config in lb_providers.items():
518
    cls = config['driver']
519
    if 'region' in config:
520
        lb_drivers[name] = cls(*config['credentials'], region=config['region'])
521
    elif 'project' in config:
522
        lb_drivers[name] = cls(*config['credentials'], project=config['project'])
523

524
# Create similar load balancers across providers for redundancy
525
def create_redundant_load_balancers(providers_config, name, members):
526
    """Create load balancers across multiple providers for redundancy"""
527
    balancers = {}
528
    
529
    for provider_name, driver in lb_drivers.items():
530
        try:
531
            balancer = driver.create_balancer(
532
                name=f'{name}-{provider_name}',
533
                port=80,
534
                protocol='http',
535
                algorithm=Algorithm.ROUND_ROBIN,
536
                members=members
537
            )
538
            balancers[provider_name] = balancer
539
            print(f"Created load balancer on {provider_name}: {balancer.ip}")
540
            
541
        except Exception as e:
542
            print(f"Failed to create load balancer on {provider_name}: {e}")
543
    
544
    return balancers
545

546
# Create members for each provider (adjust IPs as needed)
547
aws_members = [
548
    Member(id=None, ip='10.0.1.10', port=80, balancer=None),
549
    Member(id=None, ip='10.0.1.11', port=80, balancer=None)
550
]
551

552
gce_members = [
553
    Member(id=None, ip='10.1.1.10', port=80, balancer=None),
554
    Member(id=None, ip='10.1.1.11', port=80, balancer=None)
555
]
556

557
# Create redundant load balancers
558
redundant_lbs = create_redundant_load_balancers(lb_providers, 'global-api', aws_members)
559
```
560

561
### Load Balancer Configuration Backup and Restore
562

563
```python
564
import json
565
from datetime import datetime
566

567
def backup_load_balancer_config(driver, balancer) -> Dict:
568
    """Create a backup of load balancer configuration"""
569
    
570
    members = driver.balancer_list_members(balancer)
571
    
572
    backup_data = {
573
        'balancer': {
574
            'name': balancer.name,
575
            'port': balancer.port,
576
            'state': balancer.state,
577
            'extra': balancer.extra
578
        },
579
        'members': [
580
            {
581
                'ip': member.ip,
582
                'port': member.port,
583
                'extra': member.extra
584
            }
585
            for member in members
586
        ],
587
        'backup_timestamp': datetime.now().isoformat()
588
    }
589
    
590
    # Try to get health checks if supported
591
    try:
592
        health_checks = driver.ex_list_balancer_health_checks(balancer)
593
        backup_data['health_checks'] = health_checks
594
    except AttributeError:
595
        pass
596
    
597
    print(f"Backed up load balancer {balancer.name} with {len(members)} members")
598
    return backup_data
599

600
def restore_load_balancer_config(driver, backup_data, new_name=None):
601
    """Restore load balancer from backup"""
602
    
603
    balancer_config = backup_data['balancer']
604
    name = new_name or balancer_config['name']
605
    
606
    # Recreate members
607
    members = [
608
        Member(id=None, ip=m['ip'], port=m['port'], balancer=None)
609
        for m in backup_data['members']
610
    ]
611
    
612
    # Create load balancer
613
    try:
614
        restored_balancer = driver.create_balancer(
615
            name=name,
616
            port=balancer_config['port'],
617
            protocol=balancer_config['extra'].get('protocol', 'http'),
618
            algorithm=Algorithm.ROUND_ROBIN,
619
            members=members
620
        )
621
        
622
        print(f"Restored load balancer: {restored_balancer.name}")
623
        
624
        # Restore health checks if they were backed up
625
        if 'health_checks' in backup_data:
626
            for hc in backup_data['health_checks']:
627
                try:
628
                    driver.ex_create_balancer_health_check(restored_balancer, **hc)
629
                except (AttributeError, Exception) as e:
630
                    print(f"Could not restore health check: {e}")
631
        
632
        return restored_balancer
633
        
634
    except Exception as e:
635
        print(f"Failed to restore load balancer: {e}")
636
        return None
637

638
# Usage
639
balancer = driver.get_balancer('lb-12345')
640

641
# Create backup
642
backup = backup_load_balancer_config(driver, balancer)
643

644
# Save to file
645
with open(f'lb_backup_{balancer.name}_{datetime.now().strftime("%Y%m%d_%H%M%S")}.json', 'w') as f:
646
    json.dump(backup, f, indent=2)
647

648
# Restore from backup
649
restored_lb = restore_load_balancer_config(driver, backup, 'restored-lb')
650
```
651

652
## Exception Handling
653

654
```python
655
from libcloud.loadbalancer.types import LoadBalancerError
656
from libcloud.common.types import LibcloudError, InvalidCredsError
657

658
try:
659
    # Create load balancer
660
    balancer = driver.create_balancer(
661
        name='test-lb',
662
        port=80,
663
        protocol='http',
664
        algorithm=Algorithm.ROUND_ROBIN,
665
        members=members
666
    )
667
except InvalidCredsError:
668
    print("Invalid credentials for load balancer provider")
669
except LoadBalancerError as e:
670
    print(f"Load balancer specific error: {e}")
671
except LibcloudError as e:
672
    print(f"General Libcloud error: {e}")
673

674
# Check balancer state before operations
675
if balancer.state == State.RUNNING:
676
    success = driver.destroy_balancer(balancer)
677
elif balancer.state == State.PENDING:
678
    print("Load balancer is still being created")
679
```
680

681
## Provider-Specific Features
682

683
Different providers offer additional features through the `ex_*` parameter pattern:
684

685
```python
686
# AWS ELB specific features
687
elb_driver = get_driver(Provider.ELB)('access_key', 'secret_key')
688

689
# Create ELB with AWS-specific configuration
690
elb_balancer = elb_driver.create_balancer(
691
    name='aws-elb',
692
    port=80,
693
    protocol='http',
694
    algorithm=Algorithm.ROUND_ROBIN,
695
    members=members,
696
    ex_scheme='internet-facing',      # Internet-facing vs internal
697
    ex_security_groups=['sg-12345'],  # Security groups
698
    ex_subnets=['subnet-12345'],      # VPC subnets
699
    ex_cross_zone=True               # Cross-zone load balancing
700
)
701

702
# Google Cloud Load Balancer specific features
703
gce_driver = get_driver(Provider.GCE)('email', 'key_file', project='my-project')
704

705
# Create GCE load balancer with specific configuration
706
gce_balancer = gce_driver.create_balancer(
707
    name='gce-lb',
708
    port=80,
709
    protocol='http',
710
    algorithm=Algorithm.ROUND_ROBIN,
711
    members=members,
712
    ex_region='us-central1',          # Regional load balancer
713
    ex_session_affinity='CLIENT_IP'   # Session affinity
714
)
715
```
716

717
Check provider-specific documentation for additional capabilities available through the `ex_*` parameters and methods.