O que Todo Dev Deve Saber sobre Elastic Load Balancing: ALB, NLB e Gateway Load Balancer Já leu

O que é Elastic Load Balancing?

O Elastic Load Balancing (ELB) é um serviço da AWS que distribui automaticamente o tráfego de entrada entre múltiplos destinos, como instâncias EC2, containers e endereços IP. Ele garante alta disponibilidade, escalabilidade e tolerância a falhas. Existem três tipos principais: Application Load Balancer (ALB), Network Load Balancer (NLB) e Gateway Load Balancer (GLB), cada um otimizado para casos de uso específicos. Compreender quando usar cada um é essencial para arquitetar soluções robustas.

O ELB opera em diferentes camadas do modelo OSI e oferece recursos como health checks automáticos, SSL/TLS termination, logging detalhado e integração nativa com Auto Scaling. A escolha correta impacta diretamente a performance, custo e confiabilidade da sua aplicação.

Application Load Balancer (ALB)

Características e Casos de Uso

O ALB opera na camada 7 (Aplicação) e é ideal para aplicações web modernas, microserviços e arquiteturas baseadas em containers. Ele entende HTTP/HTTPS e permite roteamento avançado baseado em hostname, path, headers e query parameters. Use ALB quando precisar de inteligência de roteamento ou trabalhar com múltiplos serviços em um único balanceador.

import boto3

client = boto3.client('elbv2', region_name='us-east-1')

# Criar um ALB
response = client.create_load_balancer(
    Name='meu-alb',
    Subnets=['subnet-12345678', 'subnet-87654321'],
    SecurityGroups=['sg-12345678'],
    Scheme='internet-facing',
    Type='application',
    IpAddressType='ipv4'
)

lb_arn = response['LoadBalancers'][0]['LoadBalancerArn']

# Criar um target group
tg_response = client.create_target_group(
    Name='meu-target-group',
    Protocol='HTTP',
    Port=80,
    VpcId='vpc-12345678',
    TargetType='instance',
    HealthCheckProtocol='HTTP',
    HealthCheckPath='/',
    HealthCheckIntervalSeconds=30,
    HealthCheckTimeoutSeconds=5,
    HealthyThresholdCount=2,
    UnhealthyThresholdCount=2
)

tg_arn = tg_response['TargetGroups'][0]['TargetGroupArn']

# Registrar instâncias
client.register_targets(
    TargetGroupArn=tg_arn,
    Targets=[
        {'Id': 'i-1234567890abcdef0', 'Port': 80},
        {'Id': 'i-0987654321fedcba0', 'Port': 80}
    ]
)

# Criar listener com roteamento por path
client.create_listener(
    LoadBalancerArn=lb_arn,
    Protocol='HTTP',
    Port=80,
    DefaultActions=[
        {
            'Type': 'forward',
            'TargetGroupArn': tg_arn
        }
    ]
)

print(f"ALB criado: {response['LoadBalancers'][0]['DNSName']}")

Network Load Balancer (NLB)

Características e Casos de Uso

O NLB opera na camada 4 (Transporte) e é projetado para throughput ultra-alto, latência extremamente baixa e protocolos não-HTTP (TCP, UDP). Processe milhões de requisições por segundo com latência inferior a 100 microsegundos. Use NLB para gaming em tempo real, IoT, streaming de vídeo ou qualquer aplicação sensível à latência.

O NLB suporta IP fixo, preservação de IP de origem e é compatível com protocolos customizados. Diferentemente do ALB, não realiza inspeção de payload HTTP, apenas roteamento baseado em endereço IP e porta.

import boto3

client = boto3.client('elbv2', region_name='us-east-1')

# Criar um NLB
response = client.create_load_balancer(
    Name='meu-nlb',
    Subnets=['subnet-12345678', 'subnet-87654321'],
    Type='network',
    Scheme='internet-facing',
    IpAddressType='ipv4'
)

lb_arn = response['LoadBalancers'][0]['LoadBalancerArn']

# Criar target group com health check TCP
tg_response = client.create_target_group(
    Name='nlb-targets',
    Protocol='TCP',
    Port=5000,
    VpcId='vpc-12345678',
    TargetType='instance',
    HealthCheckProtocol='TCP',
    HealthCheckPort='5000',
    HealthCheckIntervalSeconds=10,
    HealthyThresholdCount=2,
    UnhealthyThresholdCount=2
)

tg_arn = tg_response['TargetGroups'][0]['TargetGroupArn']

# Registrar targets
client.register_targets(
    TargetGroupArn=tg_arn,
    Targets=[
        {'Id': 'i-1234567890abcdef0', 'Port': 5000},
        {'Id': 'i-0987654321fedcba0', 'Port': 5000}
    ]
)

# Criar listener com preservação de IP de origem
client.create_listener(
    LoadBalancerArn=lb_arn,
    Protocol='TCP',
    Port=5000,
    DefaultActions=[
        {
            'Type': 'forward',
            'TargetGroupArn': tg_arn
        }
    ]
)

print(f"NLB criado: {response['LoadBalancers'][0]['DNSName']}")

Gateway Load Balancer (GLB)

Características e Casos de Uso

O GLB é um tipo especializado que opera entre as camadas 3 e 4, projetado especificamente para distribuir tráfego para appliances virtuais (firewalls, WAF, sistemas de detecção de intrusão). Ele preserva o fluxo de tráfego intacto enquanto distribui a carga entre múltiplas instâncias de appliances usando o protocolo GENEVE.

Use GLB quando precisar de processamento de segurança centralizado, inspeção profunda de pacotes ou quando seus appliances precisam ver o tráfego original sem modificações. É ideal para arquiteturas de segurança em hub-and-spoke.

import boto3

client = boto3.client('elbv2', region_name='us-east-1')

# Criar um GLB
response = client.create_load_balancer(
    Name='meu-glb',
    Subnets=['subnet-12345678', 'subnet-87654321'],
    Type='gateway',
    Scheme='internal',
    IpAddressType='ipv4'
)

lb_arn = response['LoadBalancers'][0]['LoadBalancerArn']

# Criar target group para appliances
tg_response = client.create_target_group(
    Name='glb-appliances',
    Protocol='GENEVE',
    Port=6081,
    VpcId='vpc-12345678',
    TargetType='instance',
    HealthCheckProtocol='TCP',
    HealthCheckPort='6081',
    HealthCheckIntervalSeconds=10,
    HealthyThresholdCount=2,
    UnhealthyThresholdCount=2
)

tg_arn = tg_response['TargetGroups'][0]['TargetGroupArn']

# Registrar appliances virtuais
client.register_targets(
    TargetGroupArn=tg_arn,
    Targets=[
        {'Id': 'i-appliance-001', 'Port': 6081},
        {'Id': 'i-appliance-002', 'Port': 6081}
    ]
)

# Criar listener
client.create_listener(
    LoadBalancerArn=lb_arn,
    Protocol='GENEVE',
    Port=6081,
    DefaultActions=[
        {
            'Type': 'forward',
            'TargetGroupArn': tg_arn
        }
    ]
)

print(f"GLB criado: {response['LoadBalancers'][0]['DNSName']}")

Comparação Prática e Decisão

A escolha depende da natureza do seu tráfego. ALB é a escolha padrão para a maioria das aplicações web. NLB quando performance extrema é crítica. GLB apenas para cenários de segurança especializada. Lembre-se: mais simples não é sempre melhor—escolha com base em requisitos reais.

Conclusão

Os três tipos de load balancers da AWS servem propósitos distintos. ALB oferece inteligência de roteamento em camada de aplicação, ideal para microsserviços. NLB fornece performance extrema em camada 4, essencial para workloads sensíveis à latência. GLB habilita arquiteturas de segurança centralizadas com appliances virtuais. Dominar essas distinções permite arquitetar soluções que balanceiam corretamente custo, performance e confiabilidade. Teste cada um em ambiente de não-produção antes de decidir.

Referências

• AWS Elastic Load Balancing Documentation
• ALB vs NLB: When to Use Each
• Gateway Load Balancer User Guide
• AWS Load Balancing Best Practices
• Boto3 ELBv2 Client Reference