Azure Load Balancer: Complete Traffic Distribution Guide

Azure Load Balancer provides high availability and scalability for applications by distributing incoming network traffic across multiple healthy service instances. This guide covers public and internal load balancers, health probes, and traffic distribution strategies.

Understanding Azure Load Balancer

Load Balancer Types

Public Load Balancer: Distributes internet traffic to VMs
Internal Load Balancer: Distributes traffic within virtual networks
Standard Load Balancer: Enhanced features and SLA guarantees
Basic Load Balancer: Simple load balancing for small workloads

Key Features

High Availability: 99.99% SLA for Standard Load Balancer
Health Probes: Automatic health monitoring
Session Persistence: Sticky sessions support
Port Forwarding: Direct access to backend instances
Outbound Rules: Control outbound connectivity

Creating Public Load Balancer

PowerShell Setup

# Install Azure PowerShell module
Install-Module -Name Az -Force

# Connect to Azure
Connect-AzAccount

# Create resource group
New-AzResourceGroup -Name "LoadBalancer-RG" -Location "East US"

# Create public IP for load balancer
$publicIP = New-AzPublicIpAddress `
    -ResourceGroupName "LoadBalancer-RG" `
    -Name "BusinessLB-PublicIP" `
    -Location "East US" `
    -AllocationMethod "Static" `
    -Sku "Standard" `
    -Tier "Regional"

# Create virtual network
$vnet = New-AzVirtualNetwork `
    -ResourceGroupName "LoadBalancer-RG" `
    -Name "BusinessVNet" `
    -Location "East US" `
    -AddressPrefix "10.0.0.0/16"

# Create subnet
$subnet = Add-AzVirtualNetworkSubnetConfig `
    -Name "WebTier" `
    -VirtualNetwork $vnet `
    -AddressPrefix "10.0.1.0/24"

$vnet | Set-AzVirtualNetwork

# Create load balancer
$frontendIP = New-AzLoadBalancerFrontendIpConfig `
    -Name "FrontendIP" `
    -PublicIpAddress $publicIP

$backendPool = New-AzLoadBalancerBackendAddressPoolConfig `
    -Name "BackendPool"

$healthProbe = New-AzLoadBalancerProbeConfig `
    -Name "HealthProbe" `
    -Protocol "Http" `
    -Port 80 `
    -IntervalInSeconds 15 `
    -ProbeCount 2 `
    -RequestPath "/"

$lbrule = New-AzLoadBalancerRuleConfig `
    -Name "HTTPRule" `
    -FrontendIpConfiguration $frontendIP `
    -BackendAddressPool $backendPool `
    -Protocol "Tcp" `
    -FrontendPort 80 `
    -BackendPort 80 `
    -Probe $healthProbe `
    -EnableFloatingIP $false `
    -IdleTimeoutInMinutes 4

$loadBalancer = New-AzLoadBalancer `
    -ResourceGroupName "LoadBalancer-RG" `
    -Name "BusinessLoadBalancer" `
    -Location "East US" `
    -Sku "Standard" `
    -FrontendIpConfiguration $frontendIP `
    -BackendAddressPool $backendPool `
    -Probe $healthProbe `
    -LoadBalancingRule $lbrule

Azure CLI Setup

# Login to Azure
az login

# Create resource group
az group create --name "LoadBalancer-RG" --location "eastus"

# Create public IP
az network public-ip create \
    --resource-group "LoadBalancer-RG" \
    --name "BusinessLB-PublicIP" \
    --sku "Standard" \
    --allocation-method "Static" \
    --location "eastus"

# Create virtual network
az network vnet create \
    --resource-group "LoadBalancer-RG" \
    --name "BusinessVNet" \
    --address-prefix "10.0.0.0/16" \
    --subnet-name "WebTier" \
    --subnet-prefix "10.0.1.0/24" \
    --location "eastus"

# Create load balancer
az network lb create \
    --resource-group "LoadBalancer-RG" \
    --name "BusinessLoadBalancer" \
    --sku "Standard" \
    --public-ip-address "BusinessLB-PublicIP" \
    --frontend-ip-name "FrontendIP" \
    --backend-pool-name "BackendPool" \
    --location "eastus"

# Create health probe
az network lb probe create \
    --resource-group "LoadBalancer-RG" \
    --lb-name "BusinessLoadBalancer" \
    --name "HealthProbe" \
    --protocol "Http" \
    --port 80 \
    --path "/" \
    --interval 15 \
    --threshold 2

# Create load balancing rule
az network lb rule create \
    --resource-group "LoadBalancer-RG" \
    --lb-name "BusinessLoadBalancer" \
    --name "HTTPRule" \
    --protocol "Tcp" \
    --frontend-ip-name "FrontendIP" \
    --backend-pool-name "BackendPool" \
    --frontend-port 80 \
    --backend-port 80 \
    --probe-name "HealthProbe"

Creating Internal Load Balancer

Internal Load Balancer Setup

# Create internal load balancer
$internalVnet = Get-AzVirtualNetwork -ResourceGroupName "LoadBalancer-RG" -Name "BusinessVNet"
$internalSubnet = Get-AzVirtualNetworkSubnetConfig -VirtualNetwork $internalVnet -Name "WebTier"

$internalFrontendIP = New-AzLoadBalancerFrontendIpConfig `
    -Name "InternalFrontendIP" `
    -PrivateIpAddress "10.0.1.10" `
    -Subnet $internalSubnet

$internalBackendPool = New-AzLoadBalancerBackendAddressPoolConfig `
    -Name "InternalBackendPool"

$internalHealthProbe = New-AzLoadBalancerProbeConfig `
    -Name "InternalHealthProbe" `
    -Protocol "Http" `
    -Port 8080 `
    -IntervalInSeconds 15 `
    -ProbeCount 2 `
    -RequestPath "/health"

$internalLBRule = New-AzLoadBalancerRuleConfig `
    -Name "InternalAPIRule" `
    -FrontendIpConfiguration $internalFrontendIP `
    -BackendAddressPool $internalBackendPool `
    -Protocol "Tcp" `
    -FrontendPort 8080 `
    -BackendPort 8080 `
    -Probe $internalHealthProbe `
    -EnableFloatingIP $false `
    -IdleTimeoutInMinutes 4

$internalLoadBalancer = New-AzLoadBalancer `
    -ResourceGroupName "LoadBalancer-RG" `
    -Name "InternalLoadBalancer" `
    -Location "East US" `
    -Sku "Standard" `
    -FrontendIpConfiguration $internalFrontendIP `
    -BackendAddressPool $internalBackendPool `
    -Probe $internalHealthProbe `
    -LoadBalancingRule $internalLBRule

Database Load Balancer

# Create database tier internal load balancer
$dbSubnet = Add-AzVirtualNetworkSubnetConfig `
    -Name "DatabaseTier" `
    -VirtualNetwork $internalVnet `
    -AddressPrefix "10.0.2.0/24"

$internalVnet | Set-AzVirtualNetwork

$dbFrontendIP = New-AzLoadBalancerFrontendIpConfig `
    -Name "DatabaseFrontendIP" `
    -PrivateIpAddress "10.0.2.10" `
    -Subnet $dbSubnet

$dbBackendPool = New-AzLoadBalancerBackendAddressPoolConfig `
    -Name "DatabaseBackendPool"

$dbHealthProbe = New-AzLoadBalancerProbeConfig `
    -Name "DatabaseHealthProbe" `
    -Protocol "Tcp" `
    -Port 1433 `
    -IntervalInSeconds 15 `
    -ProbeCount 2

$dbLBRule = New-AzLoadBalancerRuleConfig `
    -Name "DatabaseRule" `
    -FrontendIpConfiguration $dbFrontendIP `
    -BackendAddressPool $dbBackendPool `
    -Protocol "Tcp" `
    -FrontendPort 1433 `
    -BackendPort 1433 `
    -Probe $dbHealthProbe `
    -EnableFloatingIP $true `
    -IdleTimeoutInMinutes 30

$dbLoadBalancer = New-AzLoadBalancer `
    -ResourceGroupName "LoadBalancer-RG" `
    -Name "DatabaseLoadBalancer" `
    -Location "East US" `
    -Sku "Standard" `
    -FrontendIpConfiguration $dbFrontendIP `
    -BackendAddressPool $dbBackendPool `
    -Probe $dbHealthProbe `
    -LoadBalancingRule $dbLBRule

VM Configuration and Backend Pool

Create Virtual Machines

# Create availability set
$availabilitySet = New-AzAvailabilitySet `
    -ResourceGroupName "LoadBalancer-RG" `
    -Name "WebServerAvailabilitySet" `
    -Location "East US" `
    -PlatformFaultDomainCount 2 `
    -PlatformUpdateDomainCount 5 `
    -Sku "Aligned"

# Create network security group
$nsgRuleHTTP = New-AzNetworkSecurityRuleConfig `
    -Name "HTTP" `
    -Protocol "Tcp" `
    -Direction "Inbound" `
    -Priority 1000 `
    -SourceAddressPrefix "*" `
    -SourcePortRange "*" `
    -DestinationAddressPrefix "*" `
    -DestinationPortRange 80 `
    -Access "Allow"

$nsgRuleSSH = New-AzNetworkSecurityRuleConfig `
    -Name "SSH" `
    -Protocol "Tcp" `
    -Direction "Inbound" `
    -Priority 1001 `
    -SourceAddressPrefix "*" `
    -SourcePortRange "*" `
    -DestinationAddressPrefix "*" `
    -DestinationPortRange 22 `
    -Access "Allow"

$nsg = New-AzNetworkSecurityGroup `
    -ResourceGroupName "LoadBalancer-RG" `
    -Location "East US" `
    -Name "WebServerNSG" `
    -SecurityRules $nsgRuleHTTP, $nsgRuleSSH

# Create VMs and add to backend pool
for ($i = 1; $i -le 3; $i++) {
    # Create public IP for VM
    $vmPublicIP = New-AzPublicIpAddress `
        -ResourceGroupName "LoadBalancer-RG" `
        -Name "WebServer$i-PublicIP" `
        -Location "East US" `
        -AllocationMethod "Dynamic"

    # Create network interface
    $nic = New-AzNetworkInterface `
        -ResourceGroupName "LoadBalancer-RG" `
        -Name "WebServer$i-NIC" `
        -Location "East US" `
        -SubnetId $subnet.Id `
        -PublicIpAddressId $vmPublicIP.Id `
        -NetworkSecurityGroupId $nsg.Id `
        -LoadBalancerBackendAddressPoolId $backendPool.Id

    # Create VM configuration
    $vmConfig = New-AzVMConfig `
        -VMName "WebServer$i" `
        -VMSize "Standard_B2s" `
        -AvailabilitySetId $availabilitySet.Id

    $vmConfig = Set-AzVMOperatingSystem `
        -VM $vmConfig `
        -Linux `
        -ComputerName "WebServer$i" `
        -Credential (Get-Credential) `
        -DisablePasswordAuthentication

    $vmConfig = Set-AzVMSourceImage `
        -VM $vmConfig `
        -PublisherName "Canonical" `
        -Offer "0001-com-ubuntu-server-focal" `
        -Skus "20_04-lts-gen2" `
        -Version "latest"

    $vmConfig = Add-AzVMNetworkInterface `
        -VM $vmConfig `
        -Id $nic.Id

    # Create VM
    New-AzVM `
        -ResourceGroupName "LoadBalancer-RG" `
        -Location "East US" `
        -VM $vmConfig
}

Configure Web Servers

# Install and configure nginx on each VM
#!/bin/bash

# Update package list
sudo apt-get update

# Install nginx
sudo apt-get install -y nginx

# Create custom index page
sudo tee /var/www/html/index.html > /dev/null <<EOF
<!DOCTYPE html>
<html>
<head>
    <title>Web Server $(hostname)</title>
</head>
<body>
    <h1>Welcome to $(hostname)</h1>
    <p>This is web server $(hostname) behind the load balancer.</p>
    <p>Server IP: $(hostname -I | cut -d' ' -f1)</p>
    <p>Timestamp: $(date)</p>
</body>
</html>
EOF

# Create health check endpoint
sudo tee /var/www/html/health > /dev/null <<EOF
OK
EOF

# Configure nginx
sudo tee /etc/nginx/sites-available/default > /dev/null <<EOF
server {
    listen 80 default_server;
    listen [::]:80 default_server;

    root /var/www/html;
    index index.html index.htm;

    server_name _;

    location / {
        try_files \$uri \$uri/ =404;
    }

    location /health {
        access_log off;
        return 200 "OK";
        add_header Content-Type text/plain;
    }
}
EOF

# Start and enable nginx
sudo systemctl start nginx
sudo systemctl enable nginx

# Configure firewall
sudo ufw allow 'Nginx Full'
sudo ufw enable

Health Probes Configuration

HTTP Health Probe

# Create custom HTTP health probe
$customHealthProbe = New-AzLoadBalancerProbeConfig `
    -Name "CustomHealthProbe" `
    -Protocol "Http" `
    -Port 80 `
    -IntervalInSeconds 15 `
    -ProbeCount 2 `
    -RequestPath "/health" `
    -NumberOfProbes 2

# Update load balancer with custom probe
$loadBalancer = Get-AzLoadBalancer -ResourceGroupName "LoadBalancer-RG" -Name "BusinessLoadBalancer"
$loadBalancer | Add-AzLoadBalancerProbeConfig `
    -Name "CustomHealthProbe" `
    -Protocol "Http" `
    -Port 80 `
    -IntervalInSeconds 15 `
    -ProbeCount 2 `
    -RequestPath "/health"

$loadBalancer | Set-AzLoadBalancer

TCP Health Probe

# Create TCP health probe for database
$tcpHealthProbe = New-AzLoadBalancerProbeConfig `
    -Name "DatabaseTCPProbe" `
    -Protocol "Tcp" `
    -Port 1433 `
    -IntervalInSeconds 15 `
    -ProbeCount 2

# HTTPS health probe
$httpsHealthProbe = New-AzLoadBalancerProbeConfig `
    -Name "HTTPSHealthProbe" `
    -Protocol "Https" `
    -Port 443 `
    -IntervalInSeconds 15 `
    -ProbeCount 2 `
    -RequestPath "/api/health"

Load Balancing Rules

Multiple Port Rules

# HTTP rule
$httpRule = New-AzLoadBalancerRuleConfig `
    -Name "HTTPRule" `
    -FrontendIpConfiguration $frontendIP `
    -BackendAddressPool $backendPool `
    -Protocol "Tcp" `
    -FrontendPort 80 `
    -BackendPort 80 `
    -Probe $healthProbe `
    -EnableFloatingIP $false `
    -IdleTimeoutInMinutes 4 `
    -LoadDistribution "Default"

# HTTPS rule
$httpsRule = New-AzLoadBalancerRuleConfig `
    -Name "HTTPSRule" `
    -FrontendIpConfiguration $frontendIP `
    -BackendAddressPool $backendPool `
    -Protocol "Tcp" `
    -FrontendPort 443 `
    -BackendPort 443 `
    -Probe $httpsHealthProbe `
    -EnableFloatingIP $false `
    -IdleTimeoutInMinutes 4 `
    -LoadDistribution "SourceIP"

# Update load balancer
$loadBalancer | Add-AzLoadBalancerRuleConfig -Name "HTTPSRule" -FrontendIpConfiguration $frontendIP -BackendAddressPool $backendPool -Protocol "Tcp" -FrontendPort 443 -BackendPort 443 -Probe $httpsHealthProbe -EnableFloatingIP $false -IdleTimeoutInMinutes 4 -LoadDistribution "SourceIP"
$loadBalancer | Set-AzLoadBalancer

Session Persistence

# Create rule with session persistence
$sessionPersistenceRule = New-AzLoadBalancerRuleConfig `
    -Name "SessionPersistenceRule" `
    -FrontendIpConfiguration $frontendIP `
    -BackendAddressPool $backendPool `
    -Protocol "Tcp" `
    -FrontendPort 8080 `
    -BackendPort 8080 `
    -Probe $healthProbe `
    -EnableFloatingIP $false `
    -IdleTimeoutInMinutes 4 `
    -LoadDistribution "SourceIP"

# Load distribution options:
# - Default: 5-tuple hash (source IP, source port, destination IP, destination port, protocol)
# - SourceIP: 2-tuple hash (source IP, destination IP)
# - SourceIPProtocol: 3-tuple hash (source IP, destination IP, protocol)

NAT Rules and Port Forwarding

Inbound NAT Rules

# Create NAT rules for SSH access
for ($i = 1; $i -le 3; $i++) {
    $natRule = New-AzLoadBalancerInboundNatRuleConfig `
        -Name "SSH-WebServer$i" `
        -FrontendIpConfiguration $frontendIP `
        -Protocol "Tcp" `
        -FrontendPort (2220 + $i) `
        -BackendPort 22 `
        -IdleTimeoutInMinutes 4 `
        -EnableFloatingIP $false

    $loadBalancer | Add-AzLoadBalancerInboundNatRuleConfig `
        -Name "SSH-WebServer$i" `
        -FrontendIpConfiguration $frontendIP `
        -Protocol "Tcp" `
        -FrontendPort (2220 + $i) `
        -BackendPort 22 `
        -IdleTimeoutInMinutes 4 `
        -EnableFloatingIP $false
}

$loadBalancer | Set-AzLoadBalancer

# Associate NAT rules with network interfaces
for ($i = 1; $i -le 3; $i++) {
    $nic = Get-AzNetworkInterface -ResourceGroupName "LoadBalancer-RG" -Name "WebServer$i-NIC"
    $natRule = Get-AzLoadBalancerInboundNatRuleConfig -LoadBalancer $loadBalancer -Name "SSH-WebServer$i"
    $nic.IpConfigurations[0].LoadBalancerInboundNatRules.Add($natRule)
    $nic | Set-AzNetworkInterface
}

Outbound Rules

Outbound Connectivity Configuration

# Create outbound public IP
$outboundPublicIP = New-AzPublicIpAddress `
    -ResourceGroupName "LoadBalancer-RG" `
    -Name "OutboundPublicIP" `
    -Location "East US" `
    -AllocationMethod "Static" `
    -Sku "Standard"

# Create outbound frontend IP configuration
$outboundFrontendIP = New-AzLoadBalancerFrontendIpConfig `
    -Name "OutboundFrontendIP" `
    -PublicIpAddress $outboundPublicIP

# Create outbound rule
$outboundRule = New-AzLoadBalancerOutboundRuleConfig `
    -Name "OutboundRule" `
    -FrontendIpConfiguration $outboundFrontendIP `
    -BackendAddressPool $backendPool `
    -Protocol "All" `
    -IdleTimeoutInMinutes 4 `
    -AllocatedOutboundPort 10000

# Add to load balancer
$loadBalancer | Add-AzLoadBalancerFrontendIpConfig -Name "OutboundFrontendIP" -PublicIpAddress $outboundPublicIP
$loadBalancer | Add-AzLoadBalancerOutboundRuleConfig -Name "OutboundRule" -FrontendIpConfiguration $outboundFrontendIP -BackendAddressPool $backendPool -Protocol "All" -IdleTimeoutInMinutes 4 -AllocatedOutboundPort 10000
$loadBalancer | Set-AzLoadBalancer

High Availability Configuration

Availability Zones

# Create zone-redundant public IP
$zoneRedundantIP = New-AzPublicIpAddress `
    -ResourceGroupName "LoadBalancer-RG" `
    -Name "ZoneRedundantIP" `
    -Location "East US" `
    -AllocationMethod "Static" `
    -Sku "Standard" `
    -Zone @("1", "2", "3")

# Create zone-redundant load balancer
$zoneRedundantLB = New-AzLoadBalancer `
    -ResourceGroupName "LoadBalancer-RG" `
    -Name "ZoneRedundantLoadBalancer" `
    -Location "East US" `
    -Sku "Standard" `
    -FrontendIpConfiguration $frontendIP `
    -BackendAddressPool $backendPool `
    -Probe $healthProbe `
    -LoadBalancingRule $lbrule

# Deploy VMs across availability zones
for ($i = 1; $i -le 3; $i++) {
    $zone = [string]$i

    # Create VM in specific zone
    $vmConfig = New-AzVMConfig `
        -VMName "WebServer$i" `
        -VMSize "Standard_B2s" `
        -Zone $zone

    # Continue with VM creation...
}

Monitoring and Diagnostics

Load Balancer Metrics

# Get load balancer metrics
$lbMetrics = Get-AzMetric `
    -ResourceId $loadBalancer.Id `
    -MetricName "DataPathAvailability" `
    -TimeGrain 00:05:00 `
    -StartTime (Get-Date).AddHours(-1) `
    -EndTime (Get-Date)

# Health probe status
$healthMetrics = Get-AzMetric `
    -ResourceId $loadBalancer.Id `
    -MetricName "HealthProbeStatus" `
    -TimeGrain 00:05:00 `
    -StartTime (Get-Date).AddHours(-1) `
    -EndTime (Get-Date)

# Bytes processed
$bytesMetrics = Get-AzMetric `
    -ResourceId $loadBalancer.Id `
    -MetricName "ByteCount" `
    -TimeGrain 00:05:00 `
    -StartTime (Get-Date).AddHours(-1) `
    -EndTime (Get-Date)

Diagnostic Logs

# Enable diagnostic logging
$logAnalyticsWorkspace = Get-AzOperationalInsightsWorkspace -ResourceGroupName "LoadBalancer-RG" -Name "BusinessLogAnalytics"

Set-AzDiagnosticSetting `
    -ResourceId $loadBalancer.Id `
    -Name "LoadBalancerDiagnostics" `
    -Enabled $true `
    -WorkspaceId $logAnalyticsWorkspace.ResourceId `
    -Log @(
        @{
            "category" = "LoadBalancerAlertEvent"
            "enabled" = $true
            "retentionPolicy" = @{
                "enabled" = $true
                "days" = 30
            }
        },
        @{
            "category" = "LoadBalancerProbeHealthStatus"
            "enabled" = $true
            "retentionPolicy" = @{
                "enabled" = $true
                "days" = 30
            }
        }
    )

Troubleshooting

Health Probe Issues

# Check health probe status
$backendHealth = Get-AzLoadBalancerBackendAddressPoolHealthStatus -LoadBalancer $loadBalancer -BackendAddressPoolName "BackendPool"
$backendHealth | Select-Object PrivateIpAddress, HealthProbeStatus

# Test connectivity to backend instances
$backendAddresses = Get-AzLoadBalancerBackendAddressPoolConfig -LoadBalancer $loadBalancer -Name "BackendPool"
foreach ($address in $backendAddresses.BackendIpConfigurations) {
    $vm = Get-AzVM | Where-Object { $_.NetworkProfile.NetworkInterfaces.Id -eq $address.Id.Split('/')[0..8] -join '/' }
    $vmIP = (Get-AzNetworkInterface -ResourceId $address.Id).IpConfigurations[0].PrivateIpAddress

    Write-Host "Testing connectivity to $vmIP"
    Test-NetConnection -ComputerName $vmIP -Port 80 -InformationLevel Detailed
}

Load Distribution Analysis

# Analyze load distribution
$connectionMetrics = Get-AzMetric `
    -ResourceId $loadBalancer.Id `
    -MetricName "SnatConnectionCount" `
    -TimeGrain 00:05:00 `
    -StartTime (Get-Date).AddHours(-1) `
    -EndTime (Get-Date)

$connectionMetrics.Data | ForEach-Object {
    Write-Host "Time: $($_.TimeStamp) - Connections: $($_.Total)"
}

Security Best Practices

Network Security Groups

# Create restrictive NSG for load balancer subnet
$lbNSGRule = New-AzNetworkSecurityRuleConfig `
    -Name "AllowLoadBalancerHealth" `
    -Protocol "*" `
    -Direction "Inbound" `
    -Priority 100 `
    -SourceAddressPrefix "AzureLoadBalancer" `
    -SourcePortRange "*" `
    -DestinationAddressPrefix "*" `
    -DestinationPortRange "*" `
    -Access "Allow"

$webNSGRule = New-AzNetworkSecurityRuleConfig `
    -Name "AllowWebTraffic" `
    -Protocol "Tcp" `
    -Direction "Inbound" `
    -Priority 200 `
    -SourceAddressPrefix "Internet" `
    -SourcePortRange "*" `
    -DestinationAddressPrefix "*" `
    -DestinationPortRange @("80", "443") `
    -Access "Allow"

$lbNSG = New-AzNetworkSecurityGroup `
    -ResourceGroupName "LoadBalancer-RG" `
    -Location "East US" `
    -Name "LoadBalancerNSG" `
    -SecurityRules $lbNSGRule, $webNSGRule

SSL/TLS Termination

# Configure Application Gateway for SSL termination
$appGateway = New-AzApplicationGateway `
    -ResourceGroupName "LoadBalancer-RG" `
    -Name "BusinessAppGateway" `
    -Location "East US" `
    -BackendAddressPools $backendPool `
    -FrontendIpConfigurations $frontendIP `
    -HttpListeners $httpListener `
    -RequestRoutingRules $requestRoutingRule `
    -Sku @{
        "Name" = "Standard_v2"
        "Tier" = "Standard_v2"
        "Capacity" = 2
    }

# Add SSL certificate
$sslCert = New-AzApplicationGatewaySslCertificate `
    -Name "BusinessSSLCert" `
    -CertificateFile "C:\Certificates\business.pfx" `
    -Password "certificate-password"

$appGateway | Add-AzApplicationGatewaySslCertificate -Name "BusinessSSLCert" -CertificateFile "C:\Certificates\business.pfx" -Password "certificate-password"

Best Practices

Configuration

Use Standard SKU for production workloads
Configure health probes with appropriate intervals
Implement proper session persistence when needed
Use availability zones for high availability

Performance

Distribute VMs across fault domains
Monitor health probe status regularly
Optimize timeout settings for your workload
Use multiple frontend IPs for scale

Security

Implement network security groups
Use private IP addresses for internal load balancers
Enable diagnostic logging
Regular security reviews of rules and configurations

Cost Optimization

Resource Optimization

# Calculate load balancer costs
$lbRules = (Get-AzLoadBalancerRuleConfig -LoadBalancer $loadBalancer).Count
$lbPublicIPs = (Get-AzLoadBalancerFrontendIpConfig -LoadBalancer $loadBalancer | Where-Object { $_.PublicIpAddress -ne $null }).Count

$monthlyCost = ($lbRules * 18.25) + ($lbPublicIPs * 3.65) # Standard LB pricing
Write-Host "Estimated monthly cost: $${monthlyCost:F2}"

Usage Monitoring

# Monitor data processing
$dataProcessed = Get-AzMetric `
    -ResourceId $loadBalancer.Id `
    -MetricName "ByteCount" `
    -TimeGrain 01:00:00 `
    -StartTime (Get-Date).AddDays(-30) `
    -EndTime (Get-Date)

$totalGB = ($dataProcessed.Data | Measure-Object -Property Total -Sum).Sum / 1GB
$dataProcessingCost = $totalGB * 0.005 # Per GB processed
Write-Host "Data processing cost: $${dataProcessingCost:F2}"

Conclusion

Azure Load Balancer provides essential traffic distribution and high availability capabilities for modern applications. Proper configuration of health probes, load balancing rules, and monitoring ensures optimal performance and reliability.

For professional Azure Load Balancer implementation and high availability consulting services in Louisville, contact Tyler on Tech Louisville for expert assistance with your load balancing requirements.

Azure Load Balancer: Complete Traffic Distribution Guide

Need Professional Azure Services?

Azure Load Balancer: Complete Traffic Distribution Guide

Understanding Azure Load Balancer

Load Balancer Types

Key Features

Creating Public Load Balancer

PowerShell Setup

Azure CLI Setup

Creating Internal Load Balancer

Internal Load Balancer Setup

Database Load Balancer

VM Configuration and Backend Pool

Create Virtual Machines

Configure Web Servers

Health Probes Configuration

HTTP Health Probe

TCP Health Probe

Load Balancing Rules

Multiple Port Rules

Session Persistence

NAT Rules and Port Forwarding

Inbound NAT Rules

Outbound Rules

Outbound Connectivity Configuration

High Availability Configuration

Availability Zones

Monitoring and Diagnostics

Load Balancer Metrics

Diagnostic Logs

Troubleshooting

Health Probe Issues

Load Distribution Analysis

Security Best Practices

Network Security Groups

SSL/TLS Termination

Best Practices

Configuration

Performance

Security

Cost Optimization

Resource Optimization

Usage Monitoring

Conclusion