Understanding AWS EC2 Instance States: A Complete Guide

Managing AWS EC2 instances effectively requires understanding their lifecycle states. Whether you're optimizing costs, automating deployments, or troubleshooting issues, knowing how EC2 states work is crucial. Let's dive deep into the world of EC2 instance states.

Why EC2 States Matter

Understanding EC2 states isn't just academic knowledge—it directly impacts:

💰 Your AWS bill - Different states have different billing implications
🚀 Application availability - State transitions affect your running services
🔧 Automation strategies - Proper state management enables efficient DevOps workflows
🛡️ Data persistence - Some states preserve data, others don't

Real-world scenario: A development team left 20 EC2 instances running 24/7 for an entire month, costing $3,600. By properly managing states and stopping instances after hours, they reduced costs to $800/month—a 78% savings!

The EC2 Instance Lifecycle

Here's how EC2 instances transition through different states:

Launch Instance
     │
     ↓
┌─────────┐
│ Pending │ ← Initial state
└────┬────┘
     │
     ↓
┌─────────┐    Stop    ┌──────────┐    Start   ┌─────────┐
│ Running │ ─────────→ │ Stopping │ ─────────→ │ Stopped │
└────┬────┘            └──────────┘            └────┬────┘
     │                                               │
     │ Terminate                        Terminate    │
     ↓                                               ↓
┌──────────────┐      ┌──────────────┐       ┌──────────────┐
│ Shutting-down│ ───→ │  Terminated  │ ←───  │ Shutting-down│
└──────────────┘      └──────────────┘       └──────────────┘

Core EC2 Instance States

Let's explore each state in detail.

1. Pending State

What it means: Your instance is launching and preparing to enter the running state.

What's happening:

AWS is allocating resources
Booting the operating system
Running initialization scripts (user data)
Configuring network interfaces

Duration: Typically 30-60 seconds, but can vary based on:

Instance type
AMI size
User data script complexity

Billing: ⚠️ You start getting billed once it reaches "running" state

What you can do:

Monitor status checks
Wait for state transition

What you cannot do:

Connect to the instance
Stop or modify the instance

bash
# Check instance state
aws ec2 describe-instances \
  --instance-ids i-1234567890abcdef0 \
  --query 'Reservations[0].Instances[0].State.Name'

# Output: "pending"

javascript
// Using AWS SDK for JavaScript
const AWS = require('aws-sdk');
const ec2 = new AWS.EC2({ region: 'us-east-1' });

async function checkInstanceState(instanceId) {
  const params = { InstanceIds: [instanceId] };
  const data = await ec2.describeInstances(params).promise();
  
  const state = data.Reservations[0].Instances[0].State.Name;
  console.log(`Instance ${instanceId} is ${state}`);
  
  return state;
}

// Usage
await checkInstanceState('i-1234567890abcdef0');

2. Running State

What it means: Your instance is fully operational and serving requests.

Characteristics:

All system status checks passed
Network interfaces are active
Applications are accessible
Instance is fully billable

Billing: 💰 You are charged for:

Instance hours (per-second billing after first minute)
EBS volumes attached
Data transfer
Elastic IPs (if not attached to running instance)

What you can do:

Connect via SSH/RDP
Run applications
Create AMIs
Attach/detach volumes
Take snapshots
Modify security groups
Change instance metadata

Monitoring:

bash
# Get instance details
aws ec2 describe-instances \
  --instance-ids i-1234567890abcdef0 \
  --query 'Reservations[0].Instances[0].[InstanceId,State.Name,PublicIpAddress,InstanceType]' \
  --output table

python
# Python SDK example
import boto3

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

def get_running_instances():
    """Get all running instances in the region"""
    response = ec2.describe_instances(
        Filters=[
            {
                'Name': 'instance-state-name',
                'Values': ['running']
            }
        ]
    )
    
    instances = []
    for reservation in response['Reservations']:
        for instance in reservation['Instances']:
            instances.append({
                'InstanceId': instance['InstanceId'],
                'InstanceType': instance['InstanceType'],
                'LaunchTime': instance['LaunchTime'],
                'PrivateIp': instance.get('PrivateIpAddress', 'N/A'),
                'PublicIp': instance.get('PublicIpAddress', 'N/A')
            })
    
    return instances

# Usage
running = get_running_instances()
print(f"Found {len(running)} running instances")
for inst in running:
    print(f"  {inst['InstanceId']}: {inst['InstanceType']} - {inst['PublicIp']}")

3. Stopping State

What it means: The instance is in the process of shutting down gracefully.

What's happening:

Operating system is shutting down
Applications are being terminated
Data in RAM is being flushed (unless hibernation is enabled)
Network connections are being closed

Duration: Usually 30-90 seconds

Billing: 💰 You're still charged until it reaches "stopped" state

Important: Data on instance store volumes is permanently lost!

bash
# Stop an instance
aws ec2 stop-instances --instance-ids i-1234567890abcdef0

# Output:
# {
#     "StoppingInstances": [
#         {
#             "InstanceId": "i-1234567890abcdef0",
#             "CurrentState": {
#                 "Code": 64,
#                 "Name": "stopping"
#             },
#             "PreviousState": {
#                 "Code": 16,
#                 "Name": "running"
#             }
#         }
#     ]
# }

4. Stopped State

What it means: The instance is shut down but not terminated. Think of it as "powered off."

Key characteristics:

Instance is not running
No compute charges
EBS volumes remain attached and are charged
Instance configuration is preserved
Can be started again at any time

Billing: 💰 You are charged for:

✅ EBS volumes (storage costs continue)
✅ Elastic IPs (if allocated but not attached)
❌ NOT charged for instance hours

What you can do:

Start the instance again
Create an AMI
Detach/attach volumes
Change instance type (resizing)
Modify security groups
Take EBS snapshots

What you cannot do:

Connect to the instance
Access applications
Modify instance store data (already lost)

Cost Savings Example:

Running 24/7 for 30 days:
t3.medium: $0.0416/hour × 720 hours = $29.95/month

Running 8 hours/day (business hours):
t3.medium: $0.0416/hour × 240 hours = $9.98/month
EBS (30GB): $0.10/GB × 30 = $3.00/month
Total: $12.98/month

Savings: $16.97/month (57% reduction)

javascript
// Auto-stop instances after business hours
const AWS = require('aws-sdk');
const ec2 = new AWS.EC2({ region: 'us-east-1' });

async function stopDevInstances() {
  // Find instances with tag Environment=dev
  const params = {
    Filters: [
      {
        Name: 'tag:Environment',
        Values: ['dev']
      },
      {
        Name: 'instance-state-name',
        Values: ['running']
      }
    ]
  };
  
  const data = await ec2.describeInstances(params).promise();
  const instanceIds = [];
  
  data.Reservations.forEach(reservation => {
    reservation.Instances.forEach(instance => {
      instanceIds.push(instance.InstanceId);
    });
  });
  
  if (instanceIds.length > 0) {
    console.log(`Stopping ${instanceIds.length} dev instances:`, instanceIds);
    await ec2.stopInstances({ InstanceIds: instanceIds }).promise();
    console.log('Instances stopped successfully');
  } else {
    console.log('No running dev instances found');
  }
}

// Run this as a Lambda function scheduled at 6 PM
exports.handler = async (event) => {
  await stopDevInstances();
  return { statusCode: 200, body: 'Dev instances stopped' };
};

5. Shutting-down State

What it means: The instance is being permanently terminated.

What's happening:

OS is shutting down
All data is being deleted
Network interfaces are being released
Instance will soon be gone forever

Duration: 30-60 seconds

Billing: 💰 Charged until termination completes

⚠️ WARNING: This is irreversible! Ensure you have:

Backups of important data
AMI if you need to recreate the instance
Snapshots of EBS volumes

bash
# Terminate an instance (be careful!)
aws ec2 terminate-instances --instance-ids i-1234567890abcdef0

# Enable termination protection (recommended for production)
aws ec2 modify-instance-attribute \
  --instance-id i-1234567890abcdef0 \
  --disable-api-termination

6. Terminated State

What it means: The instance is permanently deleted.

Characteristics:

Instance no longer exists
All instance store data is lost
EBS volumes are deleted (unless DeleteOnTermination=false)
Public IP address is released
Instance ID remains visible for ~1 hour then disappears

Billing: ❌ No charges (finally!)

Recovery: Impossible! The instance cannot be recovered.

Best Practice:

bash
# Always create an AMI before terminating important instances
aws ec2 create-image \
  --instance-id i-1234567890abcdef0 \
  --name "backup-$(date +%Y%m%d-%H%M%S)" \
  --description "Backup before termination"

# Wait for AMI to be available
aws ec2 wait image-available --image-ids ami-xxx

# Now safe to terminate
aws ec2 terminate-instances --instance-ids i-1234567890abcdef0

State Transition Commands

Starting and Stopping

bash
# Start stopped instances
aws ec2 start-instances --instance-ids i-1234567890abcdef0 i-0987654321fedcba0

# Stop running instances
aws ec2 stop-instances --instance-ids i-1234567890abcdef0

# Reboot instance (stays in running state)
aws ec2 reboot-instances --instance-ids i-1234567890abcdef0

# Terminate instances
aws ec2 terminate-instances --instance-ids i-1234567890abcdef0

Bulk Operations

python
# Python script to manage multiple instances by tag
import boto3
from datetime import datetime

ec2 = boto3.client('ec2')

def manage_instances_by_tag(tag_key, tag_value, action):
    """
    Perform actions on instances with specific tag
    action: 'start', 'stop', 'terminate', 'reboot'
    """
    # Find instances with the tag
    response = ec2.describe_instances(
        Filters=[
            {'Name': f'tag:{tag_key}', 'Values': [tag_value]},
            {'Name': 'instance-state-name', 'Values': ['running', 'stopped']}
        ]
    )
    
    instance_ids = []
    for reservation in response['Reservations']:
        for instance in reservation['Instances']:
            instance_ids.append(instance['InstanceId'])
    
    if not instance_ids:
        print(f"No instances found with {tag_key}={tag_value}")
        return
    
    print(f"Found {len(instance_ids)} instances: {instance_ids}")
    
    # Perform action
    if action == 'start':
        ec2.start_instances(InstanceIds=instance_ids)
        print(f"Starting instances...")
    elif action == 'stop':
        ec2.stop_instances(InstanceIds=instance_ids)
        print(f"Stopping instances...")
    elif action == 'reboot':
        ec2.reboot_instances(InstanceIds=instance_ids)
        print(f"Rebooting instances...")
    elif action == 'terminate':
        confirm = input(f"⚠️  Terminate {len(instance_ids)} instances? (yes/no): ")
        if confirm.lower() == 'yes':
            ec2.terminate_instances(InstanceIds=instance_ids)
            print(f"Terminating instances...")
        else:
            print("Termination cancelled")
    
    return instance_ids

# Usage examples
manage_instances_by_tag('Environment', 'dev', 'stop')
manage_instances_by_tag('Project', 'ml-training', 'start')

Advanced States: Hibernation

Hibernation is a special type of stop that preserves RAM contents to EBS.

Regular Stop vs Hibernation

Feature	Regular Stop	Hibernation
RAM contents	Lost	Preserved to EBS
Boot time	Normal (30-60s)	Fast (few seconds)
Running processes	Terminated	Resumed
EBS requirement	Any	Must be encrypted
Instance types	All	Limited support
Cost while stopped	EBS only	EBS + RAM snapshot

Enable Hibernation

bash
# Launch instance with hibernation enabled
aws ec2 run-instances \
  --image-id ami-0c55b159cbfafe1f0 \
  --instance-type m5.large \
  --hibernation-options Configured=true \
  --block-device-mappings \
    'DeviceName=/dev/xvda,Ebs={VolumeSize=30,Encrypted=true}' \
  --key-name MyKeyPair

# Hibernate an instance (instead of stop)
aws ec2 stop-instances \
  --instance-ids i-1234567890abcdef0 \
  --hibernate

When to use hibernation:

Long-running computations that can't be interrupted
Applications with slow startup times
Preserving in-memory cache
Testing/debugging scenarios

Billing Breakdown

Cost Comparison Table

State	Instance Charges	EBS Charges	Data Transfer	Elastic IP
Pending	❌ No	✅ Yes	❌ No	✅ Yes (if allocated)
Running	✅ Yes	✅ Yes	✅ Yes	❌ No (if attached)
Stopping	✅ Yes	✅ Yes	✅ Yes	✅ Yes (if not attached)
Stopped	❌ No	✅ Yes	❌ No	✅ Yes (if allocated)
Shutting-down	✅ Yes	✅ Yes	❌ No	Releasing
Terminated	❌ No	❌ No (if deleted)	❌ No	❌ No

Real Cost Example

Scenario: 5 t3.medium instances for development

Option 1: Running 24/7
- Instance cost: 5 × $0.0416/hr × 720 hrs = $149.76
- EBS (50GB each): 5 × 50 × $0.10/GB = $25.00
- Total: $174.76/month

Option 2: Running 8 hours/day (weekdays only)
- Instance cost: 5 × $0.0416/hr × 160 hrs = $33.28
- EBS (50GB each): 5 × 50 × $0.10/GB = $25.00
- Total: $58.28/month

💰 Savings: $116.48/month (67% reduction!)

Automation & Scheduling

Lambda Function: Auto Stop/Start

javascript
// Lambda function to start/stop instances on schedule
const AWS = require('aws-sdk');
const ec2 = new AWS.EC2();

exports.handler = async (event) => {
  const action = event.action; // 'start' or 'stop'
  const environment = event.environment; // 'dev', 'staging', 'prod'
  
  try {
    // Find instances by tag
    const describeParams = {
      Filters: [
        {
          Name: 'tag:Environment',
          Values: [environment]
        },
        {
          Name: 'tag:AutoSchedule',
          Values: ['true']
        }
      ]
    };
    
    const instances = await ec2.describeInstances(describeParams).promise();
    const instanceIds = [];
    
    instances.Reservations.forEach(reservation => {
      reservation.Instances.forEach(instance => {
        // Skip terminated instances
        if (instance.State.Name !== 'terminated') {
          instanceIds.push(instance.InstanceId);
        }
      });
    });
    
    if (instanceIds.length === 0) {
      console.log(`No instances found for ${environment}`);
      return {
        statusCode: 200,
        body: JSON.stringify({ message: 'No instances to manage' })
      };
    }
    
    console.log(`Found ${instanceIds.length} instances:`, instanceIds);
    
    // Perform action
    if (action === 'start') {
      await ec2.startInstances({ InstanceIds: instanceIds }).promise();
      console.log(`Started ${instanceIds.length} instances`);
    } else if (action === 'stop') {
      await ec2.stopInstances({ InstanceIds: instanceIds }).promise();
      console.log(`Stopped ${instanceIds.length} instances`);
    }
    
    return {
      statusCode: 200,
      body: JSON.stringify({
        message: `${action} completed`,
        instances: instanceIds
      })
    };
    
  } catch (error) {
    console.error('Error:', error);
    throw error;
  }
};

EventBridge Schedule

json
{
  "schedules": [
    {
      "name": "start-dev-instances",
      "schedule": "cron(0 9 ? * MON-FRI *)",
      "timezone": "America/New_York",
      "target": {
        "lambda": "instance-scheduler",
        "input": {
          "action": "start",
          "environment": "dev"
        }
      }
    },
    {
      "name": "stop-dev-instances",
      "schedule": "cron(0 18 ? * MON-FRI *)",
      "timezone": "America/New_York",
      "target": {
        "lambda": "instance-scheduler",
        "input": {
          "action": "stop",
          "environment": "dev"
        }
      }
    }
  ]
}

CloudFormation Template

yaml
AWSTemplateFormatVersion: '2010-09-09'
Description: 'EC2 Instance Scheduler'

Resources:
  SchedulerFunction:
    Type: AWS::Lambda::Function
    Properties:
      FunctionName: ec2-instance-scheduler
      Runtime: nodejs18.x
      Handler: index.handler
      Role: !GetAtt SchedulerRole.Arn
      Code:
        ZipFile: |
          # (Lambda code from above)
      Timeout: 60
  
  StartDevRule:
    Type: AWS::Events::Rule
    Properties:
      Name: start-dev-instances
      ScheduleExpression: 'cron(0 9 ? * MON-FRI *)'
      State: ENABLED
      Targets:
        - Arn: !GetAtt SchedulerFunction.Arn
          Id: start-dev
          Input: '{"action":"start","environment":"dev"}'
  
  StopDevRule:
    Type: AWS::Events::Rule
    Properties:
      Name: stop-dev-instances
      ScheduleExpression: 'cron(0 18 ? * MON-FRI *)'
      State: ENABLED
      Targets:
        - Arn: !GetAtt SchedulerFunction.Arn
          Id: stop-dev
          Input: '{"action":"stop","environment":"dev"}'
  
  SchedulerRole:
    Type: AWS::IAM::Role
    Properties:
      AssumeRolePolicyDocument:
        Version: '2012-10-17'
        Statement:
          - Effect: Allow
            Principal:
              Service: lambda.amazonaws.com
            Action: 'sts:AssumeRole'
      ManagedPolicyArns:
        - 'arn:aws:iam::aws:policy/service-role/AWSLambdaBasicExecutionRole'
      Policies:
        - PolicyName: EC2InstanceManagement
          PolicyDocument:
            Version: '2012-10-17'
            Statement:
              - Effect: Allow
                Action:
                  - 'ec2:DescribeInstances'
                  - 'ec2:StartInstances'
                  - 'ec2:StopInstances'
                Resource: '*'

Monitoring Instance States

CloudWatch Metrics

python
import boto3
from datetime import datetime, timedelta

cloudwatch = boto3.client('cloudwatch')
ec2 = boto3.client('ec2')

def get_instance_state_changes(instance_id, hours=24):
    """Track state changes over time"""
    end_time = datetime.utcnow()
    start_time = end_time - timedelta(hours=hours)
    
    response = cloudwatch.get_metric_statistics(
        Namespace='AWS/EC2',
        MetricName='StatusCheckFailed',
        Dimensions=[
            {'Name': 'InstanceId', 'Value': instance_id}
        ],
        StartTime=start_time,
        EndTime=end_time,
        Period=300,  # 5 minutes
        Statistics=['Average']
    )
    
    return response['Datapoints']

def monitor_state_transitions(instance_id):
    """Monitor and log state changes"""
    current_state = None
    
    while True:
        response = ec2.describe_instances(InstanceIds=[instance_id])
        new_state = response['Reservations'][0]['Instances'][0]['State']['Name']
        
        if new_state != current_state:
            timestamp = datetime.now().strftime('%Y-%m-%d %H:%M:%S')
            print(f"[{timestamp}] State changed: {current_state} → {new_state}")
            current_state = new_state
            
            # Alert if unexpected state
            if new_state in ['stopping', 'shutting-down']:
                send_alert(instance_id, new_state)
        
        time.sleep(10)  # Check every 10 seconds

SNS Alerts for State Changes

bash
# Create SNS topic
aws sns create-topic --name ec2-state-changes

# Subscribe to email
aws sns subscribe \
  --topic-arn arn:aws:sns:us-east-1:123456789012:ec2-state-changes \
  --protocol email \
  --notification-endpoint your-email@example.com

# Create EventBridge rule to monitor state changes
aws events put-rule \
  --name ec2-state-change-alert \
  --event-pattern '{
    "source": ["aws.ec2"],
    "detail-type": ["EC2 Instance State-change Notification"],
    "detail": {
      "state": ["stopping", "stopped", "shutting-down", "terminated"]
    }
  }'

Common Pitfalls & Troubleshooting

1. Instance Won't Stop

Problem: Instance stuck in "stopping" state

Common causes:

Corrupted OS
Hung processes
EBS volume issues

Solutions:

bash
# Force stop (last resort)
aws ec2 stop-instances \
  --instance-ids i-1234567890abcdef0 \
  --force

# If force stop fails, contact AWS support

2. Data Loss After Stop

Problem: Lost data after stopping instance

Cause: Data was on instance store volumes (ephemeral storage)

Prevention:

bash
# Always use EBS volumes for persistent data
aws ec2 run-instances \
  --image-id ami-xxx \
  --instance-type t3.medium \
  --block-device-mappings \
    'DeviceName=/dev/sdf,Ebs={VolumeSize=100,VolumeType=gp3,DeleteOnTermination=false}'

3. Unexpected Billing

Problem: Still getting charged after stopping

Causes:

EBS volumes still attached
Elastic IPs allocated but not attached
Snapshots not cleaned up

Audit script:

python
def audit_stopped_instances():
    """Find stopped instances and their costs"""
    ec2 = boto3.client('ec2')
    
    response = ec2.describe_instances(
        Filters=[{'Name': 'instance-state-name', 'Values': ['stopped']}]
    )
    
    total_ebs_cost = 0
    
    for reservation in response['Reservations']:
        for instance in reservation['Instances']:
            instance_id = instance['InstanceId']
            print(f"\nInstance: {instance_id}")
            
            # Check EBS volumes
            for bdm in instance['BlockDeviceMappings']:
                volume_id = bdm['Ebs']['VolumeId']
                vol_response = ec2.describe_volumes(VolumeIds=[volume_id])
                volume = vol_response['Volumes'][0]
                size = volume['Size']
                vol_type = volume['VolumeType']
                
                # Rough cost estimate (gp3)
                monthly_cost = size * 0.08
                total_ebs_cost += monthly_cost
                
                print(f"  Volume {volume_id}: {size}GB {vol_type} = ${monthly_cost:.2f}/month")
    
    print(f"\nTotal EBS cost for stopped instances: ${total_ebs_cost:.2f}/month")
    
    # Check unattached Elastic IPs
    eip_response = ec2.describe_addresses()
    unused_eips = [eip for eip in eip_response['Addresses'] if 'InstanceId' not in eip]
    
    if unused_eips:
        eip_cost = len(unused_eips) * 0.005 * 720  # $0.005/hour
        print(f"\nUnused Elastic IPs: {len(unused_eips)} = ${eip_cost:.2f}/month")

audit_stopped_instances()

4. Can't Start Stopped Instance

Problem: Start command fails

Common causes:

Insufficient capacity in AZ
Instance type not available
Account limits reached

Solutions:

bash
# Try different availability zone
aws ec2 modify-instance-placement \
  --instance-id i-1234567890abcdef0 \
  --availability-zone us-east-1b

# Change instance type if needed
aws ec2 modify-instance-attribute \
  --instance-id i-1234567890abcdef0 \
  --instance-type t3.small

# Check limits
aws service-quotas list-service-quotas \
  --service-code ec2 \
  --query 'Quotas[?QuotaName==`Running On-Demand Standard (A, C, D, H, I, M, R, T, Z) instances`]'

Best Practices

Development Environments

✅ DO:

Tag all instances with Environment:dev
Enable auto-stop schedules (stop at 6 PM, start at 9 AM)
Use smaller instance types
Stop instances on weekends
Enable termination protection for critical instances

❌ DON'T:

Leave dev instances running 24/7
Use production-sized instances
Store important data only on instance store

Production Environments

✅ DO:

Use Auto Scaling Groups (handles states automatically)
Enable detailed monitoring
Set up CloudWatch alarms
Use multiple AZs for high availability
Create regular AMI backups
Enable termination protection

❌ DON'T:

Manually stop/start production instances
Make state changes without testing
Skip backups before maintenance

Cost Optimization Checklist

markdown
□ Tag all instances with Environment and Owner
□ Set up automated stop/start schedules for dev
□ Use Spot Instances for non-critical workloads
□ Review stopped instances monthly
□ Delete unused EBS volumes
□ Release unused Elastic IPs
□ Use AWS Compute Optimizer recommendations
□ Set up billing alerts
□ Review instance types quarterly
□ Use Reserved Instances for predictable workloads

Complete Automation Example

Here's a production-ready instance management system:

python
#!/usr/bin/env python3
"""
EC2 Instance State Manager
Handles automated scheduling, monitoring, and cost optimization
"""

import boto3
import json
from datetime import datetime, time
from typing import List, Dict

class EC2StateManager:
    def __init__(self, region='us-east-1'):
        self.ec2 = boto3.client('ec2', region_name=region)
        self.cloudwatch = boto3.client('cloudwatch', region_name=region)
        
    def get_instances_by_schedule(self, schedule_tag='AutoSchedule'):
        """Get instances that should be managed by schedule"""
        response = self.ec2.describe_instances(
            Filters=[
                {'Name': f'tag:{schedule_tag}', 'Values': ['true']},
                {'Name': 'instance-state-name', 'Values': ['running', 'stopped']}
            ]
        )
        
        instances = []
        for reservation in response['Reservations']:
            for instance in reservation['Instances']:
                instances.append({
                    'id': instance['InstanceId'],
                    'state': instance['State']['Name'],
                    'type': instance['InstanceType'],
                    'tags': {tag['Key']: tag['Value'] for tag in instance.get('Tags', [])}
                })
        
        return instances
    
    def should_be_running(self, instance: Dict) -> bool:
        """Determine if instance should be running based on schedule"""
        now = datetime.now()
        current_time = now.time()
        
        # Get schedule from tags
        schedule = instance['tags'].get('Schedule', '9-18')  # Default 9 AM - 6 PM
        start_hour, end_hour = map(int, schedule.split('-'))
        
        # Check if weekday
        if now.weekday() >= 5:  # Saturday = 5, Sunday = 6
            return False
        
        # Check if within hours
        start_time = time(start_hour, 0)
        end_time = time(end_hour, 0)
        
        return start_time <= current_time <= end_time
    
    def apply_schedule(self):
        """Apply schedules to all managed instances"""
        instances = self.get_instances_by_schedule()
        
        actions = {
            'started': [],
            'stopped': [],
            'skipped': []
        }
        
        for instance in instances:
            should_run = self.should_be_running(instance)
            current_state = instance['state']
            instance_id = instance['id']
            
            if should_run and current_state == 'stopped':
                # Start the instance
                self.ec2.start_instances(InstanceIds=[instance_id])
                actions['started'].append(instance_id)
                print(f"✅ Started {instance_id}")
                
            elif not should_run and current_state == 'running':
                # Stop the instance
                self.ec2.stop_instances(InstanceIds=[instance_id])
                actions['stopped'].append(instance_id)
                print(f"⏹️  Stopped {instance_id}")
                
            else:
                actions['skipped'].append(instance_id)
        
        return actions
    
    def get_cost_report(self, days=30):
        """Generate cost report for instance state usage"""
        instances = self.get_instances_by_schedule()
        
        report = {
            'total_instances': len(instances),
            'by_state': {},
            'estimated_monthly_cost': 0
        }
        
        # Price per hour (simplified, actual prices vary)
        pricing = {
            't3.micro': 0.0104,
            't3.small': 0.0208,
            't3.medium': 0.0416,
            't3.large': 0.0832,
            'm5.large': 0.096,
            'm5.xlarge': 0.192
        }
        
        for instance in instances:
            state = instance['state']
            instance_type = instance['type']
            
            report['by_state'][state] = report['by_state'].get(state, 0) + 1
            
            if state == 'running':
                hourly_rate = pricing.get(instance_type, 0.05)
                monthly_cost = hourly_rate * 720  # 30 days * 24 hours
                report['estimated_monthly_cost'] += monthly_cost
        
        return report
    
    def cleanup_stopped_instances(self, days_stopped=30):
        """Find instances stopped for too long"""
        response = self.ec2.describe_instances(
            Filters=[
                {'Name': 'instance-state-name', 'Values': ['stopped']}
            ]
        )
        
        old_instances = []
        cutoff = datetime.now() - timedelta(days=days_stopped)
        
        for reservation in response['Reservations']:
            for instance in reservation['Instances']:
                state_transition = instance['StateTransitionReason']
                # Parse state transition time
                # Format: "User initiated (2024-10-15 12:34:56 GMT)"
                
                old_instances.append({
                    'id': instance['InstanceId'],
                    'stopped_since': state_transition,
                    'type': instance['InstanceType']
                })
        
        return old_instances

# Lambda handler
def lambda_handler(event, context):
    manager = EC2StateManager()
    
    # Apply schedules
    actions = manager.apply_schedule()
    
    # Generate cost report
    report = manager.get_cost_report()
    
    return {
        'statusCode': 200,
        'body': json.dumps({
            'actions': actions,
            'cost_report': report
        })
    }

# CLI usage
if __name__ == '__main__':
    manager = EC2StateManager()
    
    print("🔄 Applying instance schedules...")
    actions = manager.apply_schedule()
    
    print(f"\n📊 Summary:")
    print(f"  Started: {len(actions['started'])}")
    print(f"  Stopped: {len(actions['stopped'])}")
    print(f"  Skipped: {len(actions['skipped'])}")
    
    print("\n💰 Cost Report:")
    report = manager.get_cost_report()
    print(f"  Total instances: {report['total_instances']}")
    print(f"  Estimated monthly cost: ${report['estimated_monthly_cost']:.2f}")
    print(f"  State breakdown: {report['by_state']}")

Conclusion

Understanding EC2 instance states is fundamental to effective AWS cloud management. Here are the key takeaways:

💡 Key Points:

Running state = You're being charged for compute
Stopped state = Only pay for EBS storage (huge savings!)
Terminated state = Gone forever (no recovery)
Automate everything = Use schedules to optimize costs
Tag wisely = Makes automation and tracking easier
Monitor actively = Set up CloudWatch alarms
Test state transitions = Ensure applications handle restarts gracefully

Cost Optimization Formula:

Monthly Savings = (Instance Hours Saved) × (Hourly Rate) - (EBS Storage Cost)

Next Steps:

Audit your current instances
Tag them with Environment and Schedule
Set up automated stop/start
Monitor cost savings
Iterate and optimize

By mastering EC2 instance states, you can reduce your AWS bill by 50-70% while maintaining the flexibility and power of cloud computing. Start small, automate incrementally, and watch your costs drop!

Have questions about EC2 states or want to share your cost-saving strategies? Let's discuss in the comments!

Related Posts:

What is Cloud Computing? A Complete Guide
AWS Lambda vs Traditional Servers (coming soon)
Building Cost-Effective AWS Architectures (coming soon)

Understanding AWS EC2 Instance States: A Complete Guide

Understanding AWS EC2 Instance States: A Complete Guide

Why EC2 States Matter

The EC2 Instance Lifecycle

Core EC2 Instance States

1. Pending State

2. Running State

3. Stopping State

4. Stopped State

5. Shutting-down State

6. Terminated State

State Transition Commands

Starting and Stopping

Bulk Operations

Advanced States: Hibernation

Regular Stop vs Hibernation

Enable Hibernation

Billing Breakdown

Cost Comparison Table

Real Cost Example

Automation & Scheduling

Lambda Function: Auto Stop/Start

EventBridge Schedule

CloudFormation Template

Monitoring Instance States

CloudWatch Metrics

SNS Alerts for State Changes

Common Pitfalls & Troubleshooting

1. Instance Won't Stop

2. Data Loss After Stop

3. Unexpected Billing

4. Can't Start Stopped Instance

Best Practices

Development Environments

Production Environments

Cost Optimization Checklist

Complete Automation Example

Conclusion

Thanks for reading!