Building Highly Available Architectures with AWS ELB and Auto Scaling
AWS

Building Highly Available Architectures with AWS ELB and Auto Scaling

Learn how to design and implement highly available architectures using AWS ELB and Auto Scaling.

January 9, 2024
DevHub Team
6 min read

Building Highly Available Architectures with AWS ELB and Auto Scaling

High availability is crucial for modern applications. This comprehensive guide will show you how to build highly available architectures using AWS Elastic Load Balancing (ELB) and Auto Scaling Groups (ASG).

Understanding High Availability

Core Concepts

  1. Redundancy

    • Multiple availability zones
    • Redundant components
    • No single points of failure
  2. Scalability

    • Horizontal scaling
    • Vertical scaling
    • Auto scaling capabilities
  3. Fault Tolerance

    • Automatic failover
    • Self-healing systems
    • Health monitoring

Architecture Components

1. VPC Configuration

Multi-AZ VPC setup:

resource "aws_vpc" "main" { cidr_block = "10.0.0.0/16" enable_dns_hostnames = true enable_dns_support = true tags = { Name = "ha-vpc" } } resource "aws_subnet" "public" { count = 3 vpc_id = aws_vpc.main.id cidr_block = "10.0.${count.index}.0/24" availability_zone = data.aws_availability_zones.available.names[count.index] tags = { Name = "public-subnet-${count.index + 1}" } }

2. Load Balancer Setup

Application Load Balancer configuration:

{ "Type": "AWS::ElasticLoadBalancingV2::LoadBalancer", "Properties": { "Name": "ha-alb", "Subnets": ["subnet-1", "subnet-2", "subnet-3"], "SecurityGroups": ["sg-123"], "Scheme": "internet-facing", "Type": "application", "IpAddressType": "ipv4" } }

3. Auto Scaling Group

ASG configuration with launch template:

{ "LaunchTemplate": { "ImageId": "ami-123456", "InstanceType": "t3.micro", "SecurityGroups": ["sg-123"], "UserData": { "Fn::Base64": { "Fn::Join": ["", [ "#!/bin/bash\n", "yum update -y\n", "yum install -y httpd\n", "systemctl start httpd\n", "systemctl enable httpd\n" ]] } } }, "AutoScalingGroup": { "MinSize": 2, "MaxSize": 10, "DesiredCapacity": 2, "HealthCheckType": "ELB", "HealthCheckGracePeriod": 300, "VPCZoneIdentifier": ["subnet-1", "subnet-2", "subnet-3"] } }

Implementation Steps

1. Network Setup

Create a resilient network architecture:

# Internet Gateway resource "aws_internet_gateway" "main" { vpc_id = aws_vpc.main.id tags = { Name = "main-igw" } } # Route Tables resource "aws_route_table" "public" { vpc_id = aws_vpc.main.id route { cidr_block = "0.0.0.0/0" gateway_id = aws_internet_gateway.main.id } tags = { Name = "public-rt" } }

2. Security Configuration

Set up security groups:

resource "aws_security_group" "alb" { name = "alb-sg" description = "Security group for ALB" vpc_id = aws_vpc.main.id ingress { from_port = 80 to_port = 80 protocol = "tcp" cidr_blocks = ["0.0.0.0/0"] } ingress { from_port = 443 to_port = 443 protocol = "tcp" cidr_blocks = ["0.0.0.0/0"] } } resource "aws_security_group" "instance" { name = "instance-sg" description = "Security group for EC2 instances" vpc_id = aws_vpc.main.id ingress { from_port = 80 to_port = 80 protocol = "tcp" security_groups = [aws_security_group.alb.id] } }

3. Load Balancer Configuration

Set up Application Load Balancer:

resource "aws_lb" "main" { name = "ha-alb" internal = false load_balancer_type = "application" security_groups = [aws_security_group.alb.id] subnets = aws_subnet.public[*].id enable_deletion_protection = true tags = { Environment = "production" } } resource "aws_lb_listener" "http" { load_balancer_arn = aws_lb.main.arn port = "80" protocol = "HTTP" default_action { type = "forward" target_group_arn = aws_lb_target_group.main.arn } }

4. Auto Scaling Configuration

Configure Auto Scaling Group:

resource "aws_launch_template" "main" { name_prefix = "ha-template" image_id = "ami-123456" instance_type = "t3.micro" network_interfaces { associate_public_ip_address = true security_groups = [aws_security_group.instance.id] } user_data = base64encode(<<-EOF #!/bin/bash yum update -y yum install -y httpd systemctl start httpd systemctl enable httpd EOF ) } resource "aws_autoscaling_group" "main" { desired_capacity = 2 max_size = 10 min_size = 2 target_group_arns = [aws_lb_target_group.main.arn] vpc_zone_identifier = aws_subnet.public[*].id launch_template { id = aws_launch_template.main.id version = "$Latest" } tag { key = "Name" value = "ha-instance" propagate_at_launch = true } }

Monitoring and Health Checks

1. Load Balancer Health Checks

Configure target group health checks:

resource "aws_lb_target_group" "main" { name = "ha-target-group" port = 80 protocol = "HTTP" vpc_id = aws_vpc.main.id health_check { enabled = true healthy_threshold = 2 interval = 30 matcher = "200" path = "/health" port = "traffic-port" protocol = "HTTP" timeout = 5 unhealthy_threshold = 2 } }

2. CloudWatch Alarms

Set up monitoring alarms:

resource "aws_cloudwatch_metric_alarm" "high_cpu" { alarm_name = "high-cpu-utilization" comparison_operator = "GreaterThanThreshold" evaluation_periods = "2" metric_name = "CPUUtilization" namespace = "AWS/EC2" period = "300" statistic = "Average" threshold = "80" alarm_description = "This metric monitors EC2 CPU utilization" alarm_actions = [aws_autoscaling_policy.scale_up.arn] dimensions = { AutoScalingGroupName = aws_autoscaling_group.main.name } }

Scaling Policies

1. Target Tracking Scaling

Configure target tracking:

resource "aws_autoscaling_policy" "target_tracking" { name = "target-tracking-policy" autoscaling_group_name = aws_autoscaling_group.main.name policy_type = "TargetTrackingScaling" target_tracking_configuration { predefined_metric_specification { predefined_metric_type = "ASGAverageCPUUtilization" } target_value = 50.0 } }

2. Step Scaling

Configure step scaling:

resource "aws_autoscaling_policy" "step_scaling" { name = "step-scaling-policy" autoscaling_group_name = aws_autoscaling_group.main.name policy_type = "StepScaling" adjustment_type = "ChangeInCapacity" step_adjustment { scaling_adjustment = 1 metric_interval_lower_bound = 0 metric_interval_upper_bound = 20 } step_adjustment { scaling_adjustment = 2 metric_interval_lower_bound = 20 } }

Disaster Recovery

1. Backup Configuration

Set up AWS Backup:

resource "aws_backup_plan" "main" { name = "ha-backup-plan" rule { rule_name = "daily_backup" target_vault_name = aws_backup_vault.main.name schedule = "cron(0 12 * * ? *)" lifecycle { delete_after = 14 } } }

2. Multi-Region Setup

Configure cross-region replication:

resource "aws_s3_bucket" "backup" { bucket = "ha-backup-bucket" } resource "aws_s3_bucket_replication_configuration" "replication" { role = aws_iam_role.replication.arn bucket = aws_s3_bucket.backup.id rule { id = "backup-replication" status = "Enabled" destination { bucket = aws_s3_bucket.backup_replica.arn storage_class = "STANDARD" } } }

Best Practices

1. Architecture Design

  • Use multiple availability zones
  • Implement redundant components
  • Design for failure

2. Performance Optimization

  • Use appropriate instance types
  • Implement caching
  • Optimize auto scaling thresholds

3. Security Measures

  • Implement security groups
  • Use SSL/TLS
  • Regular security updates

4. Cost Management

  • Use appropriate instance sizes
  • Implement auto scaling
  • Monitor resource utilization

Monitoring and Maintenance

1. CloudWatch Dashboards

Create monitoring dashboards:

resource "aws_cloudwatch_dashboard" "main" { dashboard_name = "ha-dashboard" dashboard_body = jsonencode({ widgets = [ { type = "metric" x = 0 y = 0 width = 12 height = 6 properties = { metrics = [ ["AWS/EC2", "CPUUtilization", "AutoScalingGroupName", aws_autoscaling_group.main.name] ] period = 300 stat = "Average" region = "us-west-2" title = "CPU Utilization" } } ] }) }

2. Logging Configuration

Set up centralized logging:

resource "aws_cloudwatch_log_group" "main" { name = "/aws/ec2/ha-instances" retention_in_days = 14 }

Conclusion

Building highly available architectures requires:

  • Proper planning and design
  • Multiple layers of redundancy
  • Automated scaling and recovery
  • Continuous monitoring and maintenance

Key benefits include:

  • Improved reliability
  • Better user experience
  • Reduced downtime
  • Scalable infrastructure

Additional Resources

ELB
Auto Scaling
High Availability