AWS EC2 Auto Scaling: Complete Guide for Cloud and DevOps Engineers (2025)

Introduction

Imagine your web application suddenly receives 10x more traffic than usual—maybe you've gone viral, or it's Black Friday and your e-commerce site is getting hammered. Without proper scaling mechanisms, your servers would crash, customers would face downtime, and you'd lose both revenue and reputation. This is where AWS EC2 Auto Scaling becomes your lifesaver.

AWS EC2 Auto Scaling is one of the most critical services every DevOps engineer must master. It automatically adjusts the number of EC2 instances in your application based on demand, ensuring optimal performance while keeping costs under control. Whether you're a junior DevOps engineer looking to understand cloud fundamentals or a seasoned professional wanting to optimize your infrastructure, this comprehensive guide will take you from zero to hero with EC2 Auto Scaling.

In this deep-dive tutorial, you'll learn everything from basic concepts to advanced implementation strategies, complete with real-world examples, code snippets, and best practices that you can implement immediately in your production environments.

What You'll Learn:

• Core concepts and components of EC2 Auto Scaling
• Step-by-step setup and configuration
• Advanced scaling policies and strategies
• Real-world use cases and implementation examples
• Cost optimization techniques
• Troubleshooting common issues
• Best practices for production environments

---

Table of Contents

1. Understanding AWS EC2 Auto Scaling Fundamentals
2. Core Components and Architecture
3. Setting Up Your First Auto Scaling Group
4. Launch Templates vs Launch Configurations
5. Scaling Policies and Strategies
6. Advanced Configuration Options
7. Real-World Implementation Examples
8. Cost Optimization Strategies

---

Understanding AWS EC2 Auto Scaling Fundamentals 

What is AWS EC2 Auto Scaling?

AWS EC2 Auto Scaling is a service that automatically manages the number of EC2 instances in your application fleet. It works by monitoring your applications and automatically adjusting capacity to maintain steady, predictable performance at the lowest possible cost.

Think of it as having an intelligent system administrator who never sleeps, constantly monitoring your application's health and traffic patterns, and making decisions about when to add or remove servers based on predefined rules you set.

Why Auto Scaling Matters in Modern DevOps

In traditional infrastructure management, scaling was a manual, time-consuming process. System administrators had to:

• Monitor server performance manually
• Predict traffic patterns
• Manually provision new servers during peak times
• Remember to shut down unused instances to save costs

This approach led to two major problems:

1. Over-provisioning: Keeping too many servers running "just in case," leading to unnecessary costs
2. Under-provisioning: Not having enough capacity during traffic spikes, causing poor user experience

Auto Scaling solves both problems by providing:

• Elasticity: Automatically scale out during high demand and scale in during low demand
• Cost Efficiency: Pay only for the compute capacity you actually need
• High Availability: Automatically replace unhealthy instances
• Better Performance: Maintain consistent application performance under varying loads

Key Benefits for DevOps Teams

1. Reduced Operational Overhead: Less manual intervention required
2. Improved Reliability: Automatic replacement of failed instances
3. Cost Optimization: Optimal resource utilization
4. Better Sleep: No more 3 AM wake-up calls for scaling issues
5. Predictable Performance: Consistent user experience regardless of load

---

Core Components and Architecture 

Auto Scaling Groups (ASG)

An Auto Scaling Group is the fundamental component that contains a collection of EC2 instances treated as a logical grouping for scaling and management purposes.

Key Properties:

• Minimum Size: The minimum number of instances that must always be running
• Maximum Size: The maximum number of instances that can be launched
• Desired Capacity: The number of instances the group should maintain

# Example ASG Configuration
AutoScalingGroup:
  MinSize: 2
  MaxSize: 10
  DesiredCapacity: 4
  AvailabilityZones: 
    - us-east-1a
    - us-east-1b
    - us-east-1c

Launch Templates and Launch Configurations

These define the instance configuration that Auto Scaling uses when launching new instances.

Launch Template (Recommended):

• Supports multiple instance types
• Supports Spot instances
• Versioning capability
• More advanced networking options

Launch Configuration (Legacy):

• Single instance type only
• Cannot be modified after creation
• Being phased out by AWS

Scaling Policies

Scaling policies define when and how to scale your instances:

1. Target Tracking Scaling: Maintains a specific metric at a target value
2. Step Scaling: Scales based on the size of the alarm breach
3. Simple Scaling: Adds or removes a fixed number of instances
4. Scheduled Scaling: Scales based on time schedules

Health Checks

Auto Scaling continuously monitors instance health using:

• EC2 Health Checks: Basic instance status checks
• ELB Health Checks: Application-level health verification
• Custom Health Checks: Your own health check logic

---

Setting Up Your First Auto Scaling Group 

Let's walk through creating a basic Auto Scaling Group step by step. We'll use both the AWS Console and AWS CLI approaches.

Prerequisites

Before starting, ensure you have:

• AWS CLI configured with appropriate permissions
• A VPC with public/private subnets
• A security group configured for your application
• An AMI (Amazon Machine Image) ready for launching

Step 1: Create a Launch Template

First, let's create a launch template using AWS CLI:

# Create launch template
aws ec2 create-launch-template \
    --launch-template-name my-web-app-template \
    --launch-template-data '{
        "ImageId": "ami-0abcdef1234567890",
        "InstanceType": "t3.micro",
        "KeyName": "my-key-pair",
        "SecurityGroupIds": ["sg-0123456789abcdef0"],
        "UserData": "IyEvYmluL2Jhc2gKZWNobyAiSGVsbG8gV29ybGQiID4
            gaW5kZXguaHRtbApweXRob24zIC1tIGh0dHAuc2VydmVyIDgwODA=",
        "TagSpecification": [
            {
                "ResourceType": "instance",
                "Tags": [
                    {
                        "Key": "Name",
                        "Value": "AutoScaled-WebServer"
                    },
                    {
                        "Key": "Environment",
                        "Value": "Production"
                    }
                ]
            }
        ]
    }'

Step 2: Create the Auto Scaling Group

# Create Auto Scaling Group
aws autoscaling create-auto-scaling-group \
    --auto-scaling-group-name my-web-app-asg \
    --launch-template "LaunchTemplateName=my-web-app-template,Version=1" \
    --min-size 2 \
    --max-size 6 \
    --desired-capacity 3 \
    --vpc-zone-identifier "subnet-12345678,subnet-87654321,subnet-11223344" \
    --health-check-type ELB \
    --health-check-grace-period 300 \
    --tags "Key=Environment,Value=Production,PropagateAtLaunch=true" 
            "Key=Project,Value=WebApp,PropagateAtLaunch=true"

Step 3: Create a Target Tracking Scaling Policy

# Create scaling policy for CPU utilization
aws autoscaling put-scaling-policy \
    --auto-scaling-group-name my-web-app-asg \
    --policy-name cpu-target-tracking-policy \
    --policy-type TargetTrackingScaling \
    --target-tracking-configuration '{
        "TargetValue": 70.0,
        "PredefinedMetricSpecification": {
            "PredefinedMetricType": "ASGAverageCPUUtilization"
        },
        "ScaleOutCooldown": 300,
        "ScaleInCooldown": 300
    }'

Step 4: Verify Your Setup

# Check Auto Scaling Group status
aws autoscaling describe-auto-scaling-groups \
    --auto-scaling-group-names my-web-app-asg

# Check current instances
aws autoscaling describe-auto-scaling-instances \
    --max-records 20

---

Launch Templates vs Launch Configurations 

Understanding the differences between Launch Templates and Launch Configurations is crucial for making the right choice for your infrastructure.

Launch Templates (Recommended)

Launch Templates are the modern, more flexible option:

{
    "LaunchTemplateName": "advanced-web-template",
    "LaunchTemplateData": {
        "ImageId": "ami-0abcdef1234567890",
        "InstanceType": "t3.small",
        "KeyName": "my-key-pair",
        "SecurityGroupIds": ["sg-web-servers"],
        "IamInstanceProfile": {
            "Name": "EC2-CloudWatch-Role"
        },
        "BlockDeviceMappings": [
            {
                "DeviceName": "/dev/xvda",
                "Ebs": {
                    "VolumeSize": 20,
                    "VolumeType": "gp3",
                    "DeleteOnTermination": true,
                    "Encrypted": true
                }
            }
        ],
        "NetworkInterfaces": [
            {
                "DeviceIndex": 0,
                "AssociatePublicIpAddress": true,
                "Groups": ["sg-web-servers"],
                "DeleteOnTermination": true
            }
        ],
        "UserData": "base64-encoded-user-data",
        "TagSpecification": [
            {
                "ResourceType": "instance",
                "Tags": [
                    {"Key": "Name", "Value": "WebServer-${aws:autoscaling:groupName}"},
                    {"Key": "Environment", "Value": "Production"}
                ]
            }
        ]
    }
}

Advantages of Launch Templates:

• Support for multiple instance types (mixed instance types)
• Spot instance integration
• Versioning and default versions
• Advanced networking configurations
• Support for T2/T3 unlimited mode
• Enhanced monitoring capabilities

Mixed Instance Types Configuration

One of the most powerful features of Launch Templates is the ability to use mixed instance types:

aws autoscaling create-auto-scaling-group \
    --auto-scaling-group-name mixed-instance-asg \
    --mixed-instances-policy '{
        "LaunchTemplate": {
            "LaunchTemplateSpecification": {
                "LaunchTemplateName": "my-template",
                "Version": "$Latest"
            },
            "Overrides": [
                {"InstanceType": "t3.small", "WeightedCapacity": "1"},
                {"InstanceType": "t3.medium", "WeightedCapacity": "2"},
                {"InstanceType": "m5.large", "WeightedCapacity": "4"}
            ]
        },
        "InstancesDistribution": {
            "OnDemandBaseCapacity": 2,
            "OnDemandPercentageAboveBaseCapacity": 20,
            "SpotAllocationStrategy": "diversified"
        }
    }' \
    --min-size 4 \
    --max-size 12 \
    --desired-capacity 6

---

Scaling Policies and Strategies

Choosing the right scaling policy is crucial for optimal performance and cost efficiency. Let's explore each type in detail.

Target Tracking Scaling Policies

Target Tracking is the most commonly used and recommended scaling policy. It works like a thermostat—you set a target value, and Auto Scaling automatically adjusts the capacity to maintain that target.

CPU Utilization Target Tracking

# CPU utilization target tracking
aws autoscaling put-scaling-policy \
    --auto-scaling-group-name my-asg \
    --policy-name cpu-target-tracking \
    --policy-type TargetTrackingScaling \
    --target-tracking-configuration '{
        "TargetValue": 60.0,
        "PredefinedMetricSpecification": {
            "PredefinedMetricType": "ASGAverageCPUUtilization"
        },
        "ScaleOutCooldown": 300,
        "ScaleInCooldown": 600,
        "DisableScaleIn": false
    }'

Application Load Balancer Request Count Target Tracking

# ALB request count per target
aws autoscaling put-scaling-policy \
    --auto-scaling-group-name my-asg \
    --policy-name alb-request-count-target \
    --policy-type TargetTrackingScaling \
    --target-tracking-configuration '{
        "TargetValue": 1000.0,
        "PredefinedMetricSpecification": {
            "PredefinedMetricType": "ALBRequestCountPerTarget",
            "ResourceLabel": "app/my-load-balancer/50dc6c495c0c9188/
                                targetgroup/my-targets/73e2d6bc24d8a067"
        }
    }'

Custom Metric Target Tracking

# Custom CloudWatch metric
aws autoscaling put-scaling-policy \
    --auto-scaling-group-name my-asg \
    --policy-name custom-metric-target \
    --policy-type TargetTrackingScaling \
    --target-tracking-configuration '{
        "TargetValue": 40.0,
        "CustomizedMetricSpecification": {
            "MetricName": "QueueLength",
            "Namespace": "MyApp/SQS",
            "Dimensions": [
                {
                    "Name": "QueueName",
                    "Value": "my-processing-queue"
                }
            ],
            "Statistic": "Average"
        }
    }'

Step Scaling Policies

Step Scaling provides more granular control over scaling actions based on the size of the metric breach.

# Create CloudWatch alarm first
aws cloudwatch put-metric-alarm \
    --alarm-name high-cpu-alarm \
    --alarm-description "High CPU utilization alarm" \
    --metric-name CPUUtilization \
    --namespace AWS/EC2 \
    --statistic Average \
    --period 300 \
    --threshold 75 \
    --comparison-operator GreaterThanThreshold \
    --evaluation-periods 2 \
    --alarm-actions arn:aws:autoscaling:us-east-1:123456789012:scalingPolicy:policy-id

# Create step scaling policy
aws autoscaling put-scaling-policy \
    --auto-scaling-group-name my-asg \
    --policy-name step-scale-out \
    --policy-type StepScaling \
    --adjustment-type ChangeInCapacity \
    --step-adjustments '[
        {
            "MetricIntervalLowerBound": 0,
            "MetricIntervalUpperBound": 10,
            "ScalingAdjustment": 1
        },
        {
            "MetricIntervalLowerBound": 10,
            "MetricIntervalUpperBound": 20,
            "ScalingAdjustment": 2
        },
        {
            "MetricIntervalLowerBound": 20,
            "ScalingAdjustment": 3
        }
    ]' \
    --cooldown 300

Scheduled Scaling

Perfect for predictable traffic patterns:

# Scale up for business hours
aws autoscaling put-scheduled-update-group-action \
    --auto-scaling-group-name my-asg \
    --scheduled-action-name scale-up-business-hours \
    --recurrence "0 8 * * MON-FRI" \
    --desired-capacity 6 \
    --min-size 4 \
    --max-size 10

# Scale down for off-hours
aws autoscaling put-scheduled-update-group-action \
    --auto-scaling-group-name my-asg \
    --scheduled-action-name scale-down-off-hours \
    --recurrence "0 18 * * MON-FRI" \
    --desired-capacity 2 \
    --min-size 2 \
    --max-size 10

---

Advanced Configuration Options 

Warm Pools

Warm Pools allow you to pre-initialize instances to reduce the time it takes to scale out:

aws autoscaling put-warm-pool \
    --auto-scaling-group-name my-asg \
    --max-group-prepared-capacity 5 \
    --min-size 2 \
    --pool-state Stopped \
    --instance-reuse-policy '{
        "ReuseOnScaleIn": true
    }'

Instance Refresh

Instance Refresh allows you to update instances in your Auto Scaling Group safely:

aws autoscaling start-instance-refresh \
    --auto-scaling-group-name my-asg \
    --preferences '{
        "InstanceWarmup": 300,
        "MinHealthyPercentage": 50,
        "CheckpointPercentages": [20, 50, 100],
        "CheckpointDelay": 600
    }'

Lifecycle Hooks

Lifecycle hooks let you perform custom actions when instances launch or terminate:

# Create lifecycle hook for instance launch
aws autoscaling put-lifecycle-hook \
    --lifecycle-hook-name launch-hook \
    --auto-scaling-group-name my-asg \
    --lifecycle-transition autoscaling:EC2_INSTANCE_LAUNCHING \
    --heartbeat-timeout 300 \
    --default-result ABANDON \
    --notification-target-arn arn:aws:sqs:us-east-1:123456789012:asg-notifications \
    --role-arn arn:aws:iam::123456789012:role/AutoScaling-NotificationRole

---

Real-World Implementation Examples 

Example 1: E-commerce Website with Predictable Traffic Patterns

This example shows how to configure Auto Scaling for an e-commerce site that experiences regular traffic spikes during business hours and sales events.

#!/bin/bash
# E-commerce Auto Scaling Setup Script

# Variables
ASG_NAME="ecommerce-web-asg"
TEMPLATE_NAME="ecommerce-template"
MIN_SIZE=3
MAX_SIZE=20
DESIRED_CAPACITY=5

# Create launch template for web servers
aws ec2 create-launch-template \
    --launch-template-name $TEMPLATE_NAME \
    --launch-template-data '{
        "ImageId": "ami-0c02fb55956c7d316",
        "InstanceType": "t3.medium",
        "KeyName": "ecommerce-key",
        "SecurityGroupIds": ["sg-web-servers"],
        "IamInstanceProfile": {
            "Name": "EC2-CloudWatch-SSM-Role"
        },
        "UserData": "'$(base64 -w 0 <<EOF
#!/bin/bash
yum update -y
yum install -y docker
systemctl start docker
systemctl enable docker
usermod -a -G docker ec2-user

# Install CloudWatch agent
wget https://s3.amazonaws.com/amazoncloudwatch-agent/amazon_linux
                        /amd64/latest/amazon-cloudwatch-agent.rpm
rpm -U ./amazon-cloudwatch-agent.rpm

# Pull and run application
docker pull myregistry/ecommerce-app:latest
docker run -d -p 80:3000 --name webapp myregistry/ecommerce-app:latest

# Configure CloudWatch agent
cat > /opt/aws/amazon-cloudwatch-agent/etc/amazon-cloudwatch-agent.json << EOL
{
    "metrics": {
        "namespace": "ECommerce/Application",
        "metrics_collected": {
            "cpu": {
                "measurement": ["cpu_usage_idle", "cpu_usage_iowait", 
                                    "cpu_usage_user", "cpu_usage_system"],
                "metrics_collection_interval": 60
            },
            "disk": {
                "measurement": ["used_percent"],
                "metrics_collection_interval": 60,
                "resources": ["*"]
            },
            "mem": {
                "measurement": ["mem_used_percent"],
                "metrics_collection_interval": 60
            }
        }
    }
}
EOL

/opt/aws/amazon-cloudwatch-agent/bin/amazon-cloudwatch-agent-ctl \
    -a fetch-config -m ec2 -c file:/opt/aws/amazon-cloudwatch-agent
                        /etc/amazon-cloudwatch-agent.json -s
EOF
)'",
        "TagSpecification": [
            {
                "ResourceType": "instance",
                "Tags": [
                    {"Key": "Name", "Value": "ECommerce-WebServer"},
                    {"Key": "Environment", "Value": "Production"},
                    {"Key": "Application", "Value": "ECommerce"}
                ]
            }
        ]
    }'

# Create Auto Scaling Group
aws autoscaling create-auto-scaling-group \
    --auto-scaling-group-name $ASG_NAME \
    --launch-template "LaunchTemplateName=$TEMPLATE_NAME,Version=\$Latest" \
    --min-size $MIN_SIZE \
    --max-size $MAX_SIZE \
    --desired-capacity $DESIRED_CAPACITY \
    --target-group-arns "arn:aws:elasticloadbalancing:us-east-1:123456789012:targetgroup/
                            ecommerce-targets/73e2d6bc24d8a067" \
    --health-check-type ELB \
    --health-check-grace-period 300 \
    --vpc-zone-identifier "subnet-12345678,subnet-87654321,subnet-11223344"

# CPU-based target tracking
aws autoscaling put-scaling-policy \
    --auto-scaling-group-name $ASG_NAME \
    --policy-name cpu-target-tracking \
    --policy-type TargetTrackingScaling \
    --target-tracking-configuration '{
        "TargetValue": 65.0,
        "PredefinedMetricSpecification": {
            "PredefinedMetricType": "ASGAverageCPUUtilization"
        },
        "ScaleOutCooldown": 180,
        "ScaleInCooldown": 300
    }'

# ALB request-based target tracking
aws autoscaling put-scaling-policy \
    --auto-scaling-group-name $ASG_NAME \
    --policy-name alb-request-target \
    --policy-type TargetTrackingScaling \
    --target-tracking-configuration '{
        "TargetValue": 800.0,
        "PredefinedMetricSpecification": {
            "PredefinedMetricType": "ALBRequestCountPerTarget",
            "ResourceLabel": "app/ecommerce-alb/50dc6c495c0c9188/targetgroup/
                            ecommerce-targets/73e2d6bc24d8a067"
        }
    }'

# Scheduled scaling for Black Friday preparation
aws autoscaling put-scheduled-update-group-action \
    --auto-scaling-group-name $ASG_NAME \
    --scheduled-action-name black-friday-scale-up \
    --start-time "2025-11-29T06:00:00Z" \
    --end-time "2025-11-30T02:00:00Z" \
    --desired-capacity 15 \
    --min-size 10 \
    --max-size 25

echo "E-commerce Auto Scaling Group created successfully!"

Example 2: Microservices API with Queue-Based Scaling

# Custom CloudWatch metric publisher for queue-based scaling
import boto3
import time
import json
from datetime import datetime

class QueueMetricsPublisher:
    def __init__(self, queue_url, namespace="MyApp/Queue"):
        self.sqs = boto3.client('sqs')
        self.cloudwatch = boto3.client('cloudwatch')
        self.queue_url = queue_url
        self.namespace = namespace
    
    def publish_queue_metrics(self):
        """Publish queue depth metrics to CloudWatch"""
        try:
            # Get queue attributes
            response = self.sqs.get_queue_attributes(
                QueueUrl=self.queue_url,
                AttributeNames=['ApproximateNumberOfMessages', 
                        'ApproximateNumberOfMessagesNotVisible']
            )
            
            visible_messages = int(response['Attributes'].
                            get('ApproximateNumberOfMessages', 0))
            processing_messages = int(response['Attributes'].
                            get('ApproximateNumberOfMessagesNotVisible', 0))
            total_messages = visible_messages + processing_messages
            
            # Publish metrics
            self.cloudwatch.put_metric_data(
                Namespace=self.namespace,
                MetricData=[
                    {
                        'MetricName': 'QueueDepth',
                        'Value': visible_messages,
                        'Unit': 'Count',
                        'Timestamp': datetime.utcnow()
                    },
                    {
                        'MetricName': 'ProcessingMessages',
                        'Value': processing_messages,
                        'Unit': 'Count',
                        'Timestamp': datetime.utcnow()
                    },
                    {
                        'MetricName': 'TotalMessages',
                        'Value': total_messages,
                        'Unit': 'Count',
                        'Timestamp': datetime.utcnow()
                    }
                ]
            )
            
            print(f"Published metrics - Queue: {visible_messages}, 
                        Processing: {processing_messages}")
            
        except Exception as e:
            print(f"Error publishing metrics: {str(e)}")
    
    def run_continuous_monitoring(self, interval=60):
        """Run continuous monitoring loop"""
        while True:
            self.publish_queue_metrics()
            time.sleep(interval)

# Usage
if __name__ == "__main__":
    queue_url = "https://sqs.us-east-1.amazonaws.com/123456789012/processing-queue"
    publisher = QueueMetricsPublisher(queue_url)
    publisher.run_continuous_monitoring()

Corresponding Auto Scaling configuration:

# Create Auto Scaling Group for queue processors
aws autoscaling create-auto-scaling-group \
    --auto-scaling-group-name queue-processor-asg \
    --launch-template "LaunchTemplateName=queue-processor-template,Version=\$Latest" \
    --min-size 2 \
    --max-size 15 \
    --desired-capacity 3 \
    --vpc-zone-identifier "subnet-private-1,subnet-private-2,subnet-private-3"

# Queue depth-based scaling
aws autoscaling put-scaling-policy \
    --auto-scaling-group-name queue-processor-asg \
    --policy-name queue-depth-scaling \
    --policy-type TargetTrackingScaling \
    --target-tracking-configuration '{
        "TargetValue": 10.0,
        "CustomizedMetricSpecification": {
            "MetricName": "QueueDepth",
            "Namespace": "MyApp/Queue",
            "Statistic": "Average"
        },
        "ScaleOutCooldown": 120,
        "ScaleInCooldown": 300
    }'

---

Cost Optimization Strategies 

Spot Instance Integration

Using Spot instances can reduce your costs by up to 90%:

# Mixed instance policy with Spot instances
aws autoscaling create-auto-scaling-group \
    --auto-scaling-group-name cost-optimized-asg \
    --mixed-instances-policy '{
        "LaunchTemplate": {
            "LaunchTemplateSpecification": {
                "LaunchTemplateName": "cost-optimized-template",
                "Version": "$Latest"
            },
            "Overrides": [
                {"InstanceType": "t3.small", "WeightedCapacity": "1"},
                {"InstanceType": "t3.medium", "WeightedCapacity": "2"},
                {"InstanceType": "t3a.small", "WeightedCapacity": "1"},
                {"InstanceType": "t3a.medium", "WeightedCapacity": "2"}
            ]
        },
        "InstancesDistribution": {
            "OnDemandBaseCapacity": 1,
            "OnDemandPercentageAboveBaseCapacity": 25,
            "SpotAllocationStrategy": "price-capacity-optimized",
            "SpotInstancePools": 2,
            "SpotMaxPrice": ""
        }
    }' \
    --min-size 2 \
    --max-size 8 \
    --desired-capacity 4

Right-Sizing Strategies

Use AWS Compute Optimizer recommendations:

import boto3
import json

def get_rightsizing_recommendations():
    """Get EC2 rightsizing recommendations from AWS Compute Optimizer"""
    compute_optimizer = boto3.client('compute-optimizer')
    
    try:
        response = compute_optimizer.get_ec2_instance_recommendations()
        
        recommendations = []
        for rec in response['instanceRecommendations']:
            instance_id = rec['instanceArn'].split('/')[-1]
            current_type = rec['currentInstanceType']
            
            if rec['recommendationOptions']:
                recommended_type = rec['recommendationOptions'][0]['instanceType']
                projected_savings = rec['recommendationOptions'][0].
                                get('projectedUtilizationMetrics', {})
                
                recommendations.append({
                    'instance_id': instance_id,
                    'current_type': current_type,
                    'recommended_type': recommended_type,
                    'projected_savings': projected_savings
                })
        
        return recommendations
    
    except Exception as e:
        print(f"Error getting recommendations: {str(e)}")
        return []

# Get and display recommendations
recommendations = get_rightsizing_recommendations()
for rec in recommendations:
    print(f"Instance {rec['instance_id']}: {rec['current_type']} -> {rec['recommended_type']}")