How to Cut Your AWS RDS Bill by 40% Without Downtime

# Check CPU utilization
aws cloudwatch get-metric-statistics \
  --namespace AWS/RDS \
  --metric-name CPUUtilization \
  --dimensions Name=DBInstanceIdentifier,Value=production-db \
  --start-time $(date -u -d '30 days ago' +%Y-%m-%dT%H:%M:%S) \
  --end-time $(date -u +%Y-%m-%dT%H:%M:%S) \
  --period 3600 \
  --statistics Average,Maximum
 
# Output:
# P50: 22% CPU
# P95: 38% CPU
# P99: 52% CPU
# Max: 68% CPU

SELECT
  AVG(CPUUtilization) as avg_cpu,
  MAX(CPUUtilization) as max_cpu,
  AVG(FreeableMemory) as avg_free_memory,
  AVG(ReadIOPS) as avg_read_iops,
  AVG(WriteIOPS) as avg_write_iops
FROM SCHEMA("AWS/RDS", DBInstanceIdentifier)
WHERE DBInstanceIdentifier = 'production-db'
GROUP BY DBInstanceIdentifier

import boto3
from datetime import datetime, timedelta
 
cloudwatch = boto3.client('cloudwatch')
 
def analyze_rds_sizing(instance_id, days=30):
    end_time = datetime.utcnow()
    start_time = end_time - timedelta(days=days)
 
    metrics = {
        'CPUUtilization': {'unit': 'Percent'},
        'FreeableMemory': {'unit': 'Bytes'},
        'ReadIOPS': {'unit': 'Count/Second'},
        'WriteIOPS': {'unit': 'Count/Second'}
    }
 
    results = {}
 
    for metric_name, config in metrics.items():
        response = cloudwatch.get_metric_statistics(
            Namespace='AWS/RDS',
            MetricName=metric_name,
            Dimensions=[{'Name': 'DBInstanceIdentifier', 'Value': instance_id}],
            StartTime=start_time,
            EndTime=end_time,
            Period=3600,
            Statistics=['Average', 'Maximum']
        )
 
        datapoints = sorted(response['Datapoints'], key=lambda x: x['Timestamp'])
 
        # Skip metrics with no data
        if not datapoints:
            print(f"Warning: No datapoints for {metric_name}, skipping")
            continue
 
        if metric_name == 'FreeableMemory':
            # Get instance memory size
            rds = boto3.client('rds')
            instance = rds.describe_db_instances(DBInstanceIdentifier=instance_id)
            instance_class = instance['DBInstances'][0]['DBInstanceClass']
 
            # Memory mapping (GB)
            memory_map = {
                'db.r6i.large': 16,
                'db.r6i.xlarge': 32,
                'db.r6i.2xlarge': 64,
                'db.r6i.4xlarge': 128
            }
 
            total_memory_gb = memory_map.get(instance_class, 0)
            if total_memory_gb == 0:
                print(f"Warning: Unknown instance class {instance_class}, skipping memory calc")
                continue
 
            avg_free_gb = sum(d['Average'] for d in datapoints) / len(datapoints) / (1024**3)
            avg_used_gb = total_memory_gb - avg_free_gb
            avg_used_pct = (avg_used_gb / total_memory_gb) * 100
 
            results['memory_used_pct'] = avg_used_pct
        else:
            avg = sum(d['Average'] for d in datapoints) / len(datapoints)
            max_val = max(d['Maximum'] for d in datapoints)
            results[f'{metric_name}_avg'] = avg
            results[f'{metric_name}_max'] = max_val
 
    return results
 
# Analyze
stats = analyze_rds_sizing('production-db')
 
print(f"CPU Average: {stats['CPUUtilization_avg']:.1f}%")
print(f"CPU Max: {stats['CPUUtilization_max']:.1f}%")
print(f"Memory Used: {stats['memory_used_pct']:.1f}%")
print(f"IOPS Average: {stats['ReadIOPS_avg'] + stats['WriteIOPS_avg']:.0f}")
 
# Recommendation logic
if stats['CPUUtilization_avg'] < 40 and stats['memory_used_pct'] < 50:
    print("✅ Recommendation: Downsize by 1 instance class")
elif stats['CPUUtilization_max'] > 80 or stats['memory_used_pct'] > 85:
    print("⚠️ Recommendation: Keep current size or upsize")
else:
    print("✓ Recommendation: Current size is appropriate")

# Terraform configuration with zero-downtime modification
resource "aws_db_instance" "production" {
  identifier     = "production-db"
  instance_class = "db.r6i.xlarge"  # Changed from db.r6i.2xlarge
 
  # Enable Multi-AZ for zero-downtime modifications
  multi_az = true
 
  # Apply immediately during maintenance window
  apply_immediately = false
 
  # Preferred maintenance window (Sunday 3-4 AM)
  maintenance_window = "sun:03:00-sun:04:00"
}

# Step 1: Create read replica on Graviton
resource "aws_db_instance" "graviton_replica" {
  identifier             = "production-db-graviton"
  replicate_source_db    = aws_db_instance.production.identifier
  instance_class         = "db.r6g.2xlarge"  # Graviton
  publicly_accessible    = false
  skip_final_snapshot    = true
 
  # Use same configuration as primary
  multi_az                = true
  backup_retention_period = 7
}
 
# Step 2: Promote replica to primary (via AWS Console or CLI)
# aws rds promote-read-replica --db-instance-identifier production-db-graviton
 
# Step 3: Update application connection string
# OLD: production-db.abc123.us-east-1.rds.amazonaws.com
# NEW: production-db-graviton.xyz789.us-east-1.rds.amazonaws.com
 
# Step 4: Delete old primary after validation
resource "aws_db_instance" "production" {
  # ... delete this resource
}

# 1. Stop application writes (maintenance mode)
# 2. Wait for replica lag to reach zero
aws rds describe-db-instances \
  --db-instance-identifier production-db-graviton \
  --query 'DBInstances[0].StatusInfos[?StatusType==`read replication`].Status'
 
# 3. Promote replica
aws rds promote-read-replica \
  --db-instance-identifier production-db-graviton
 
# 4. Update DNS CNAME or application config
# 5. Resume application writes
 
# Total downtime: 0-5 minutes (DNS propagation)

# 1. Create snapshot of current database
aws rds create-db-snapshot \
  --db-instance-identifier production-db \
  --db-snapshot-identifier production-db-pre-graviton
 
# 2. Restore snapshot to Graviton instance
aws rds restore-db-instance-from-db-snapshot \
  --db-instance-identifier production-db-new \
  --db-snapshot-identifier production-db-pre-graviton \
  --db-instance-class db.r6g.2xlarge \
  --multi-az
 
# 3. Update application connection string
# 4. Delete old instance
 
# Total downtime: 10-15 minutes (restore + DNS)

-- Before migration (Intel)
EXPLAIN ANALYZE SELECT * FROM orders WHERE user_id = 123;
-- Planning Time: 0.125 ms
-- Execution Time: 2.341 ms
 
-- After migration (Graviton)
EXPLAIN ANALYZE SELECT * FROM orders WHERE user_id = 123;
-- Planning Time: 0.098 ms
-- Execution Time: 1.867 ms (20% faster)

# RIs are purchased manually via AWS Console or CLI
# Document in Terraform using tags
 
resource "aws_db_instance" "production" {
  identifier     = "production-db"
  instance_class = "db.r6g.2xlarge"
 
  tags = {
    ReservedInstance = "ri-abc123"
    RIPurchaseDate   = "2025-01-15"
    RIExpirationDate = "2026-01-15"
    RIType           = "1-year-partial-upfront"
  }
}

resource "aws_db_instance" "production" {
  identifier = "production-db"
 
  # Storage configuration
  storage_type          = "gp3"  # Changed from gp2
  allocated_storage     = 1000   # 1TB
  iops                  = 3000   # Customize if needed (default: 3000)
  storage_throughput    = 125    # MB/s (default: 125, max: 1000)
 
  # Apply during maintenance window
  apply_immediately = false
}

# List all snapshots
aws rds describe-db-snapshots \
  --snapshot-type manual \
  --query 'DBSnapshots[?SnapshotCreateTime<`2024-01-01`]'
 
# Result: 50 manual snapshots from 2023-2024
# Cost: 50 × 50GB × $0.095 = $237/month

import boto3
from datetime import datetime, timedelta
 
rds = boto3.client('rds')
 
def cleanup_old_snapshots(retention_days=30):
    """Delete manual snapshots older than retention_days"""
 
    cutoff_date = datetime.now() - timedelta(days=retention_days)
 
    snapshots = rds.describe_db_snapshots(SnapshotType='manual')
 
    for snapshot in snapshots['DBSnapshots']:
        snapshot_time = snapshot['SnapshotCreateTime'].replace(tzinfo=None)
 
        if snapshot_time < cutoff_date:
            print(f"Deleting snapshot: {snapshot['DBSnapshotIdentifier']} ({snapshot_time})")
            rds.delete_db_snapshot(
                DBSnapshotIdentifier=snapshot['DBSnapshotIdentifier']
            )
 
# Run weekly via Lambda
cleanup_old_snapshots(retention_days=30)

resource "aws_rds_cluster" "staging" {
  cluster_identifier = "staging-db"
  engine             = "aurora-postgresql"
  engine_mode        = "provisioned"  # Serverless v2 uses provisioned mode
  engine_version     = "15.3"
 
  database_name   = "staging"
  master_username = var.db_username
  master_password = var.db_password
 
  serverlessv2_scaling_configuration {
    min_capacity = 0.5  # Scales to 1GB RAM when idle
    max_capacity = 16   # Scales to 32GB RAM under load
  }
 
  skip_final_snapshot = true
}
 
resource "aws_rds_cluster_instance" "staging" {
  cluster_identifier = aws_rds_cluster.staging.id
  instance_class     = "db.serverless"
  engine             = aws_rds_cluster.staging.engine
  engine_version     = aws_rds_cluster.staging.engine_version
}

import boto3
import os
 
rds = boto3.client('rds')
 
def lambda_handler(event, context):
    """
    Start dev databases at 8 AM, stop at 7 PM
    Triggered by EventBridge schedule
    """
 
    action = event.get('action')  # 'start' or 'stop'
    cluster_id = os.environ['CLUSTER_ID']
 
    if action == 'start':
        rds.start_db_cluster(DBClusterIdentifier=cluster_id)
        print(f"Started cluster: {cluster_id}")
    elif action == 'stop':
        rds.stop_db_cluster(DBClusterIdentifier=cluster_id)
        print(f"Stopped cluster: {cluster_id}")
 
    return {'statusCode': 200}

resource "aws_cloudwatch_event_rule" "start_dev_db" {
  name                = "start-dev-db"
  schedule_expression = "cron(0 8 ? * MON-FRI *)"  # 8 AM weekdays
}
 
resource "aws_cloudwatch_event_target" "start_dev_db" {
  rule = aws_cloudwatch_event_rule.start_dev_db.name
  arn  = aws_lambda_function.db_scheduler.arn
  input = jsonencode({
    action = "start"
  })
}
 
resource "aws_cloudwatch_event_rule" "stop_dev_db" {
  name                = "stop-dev-db"
  schedule_expression = "cron(0 19 ? * MON-FRI *)"  # 7 PM weekdays
}
 
resource "aws_cloudwatch_event_target" "stop_dev_db" {
  rule = aws_cloudwatch_event_rule.stop_dev_db.name
  arn  = aws_lambda_function.db_scheduler.arn
  input = jsonencode({
    action = "stop"
  })
}

resource "aws_cloudwatch_dashboard" "rds_costs" {
  dashboard_name = "rds-cost-optimization"
 
  dashboard_body = jsonencode({
    widgets = [
      {
        type = "metric"
        properties = {
          metrics = [
            ["AWS/RDS", "CPUUtilization", { stat = "Average" }],
            [".", "DatabaseConnections", { stat = "Sum" }],
            [".", "FreeableMemory", { stat = "Average" }]
          ]
          period = 3600
          stat   = "Average"
          region = "us-east-1"
          title  = "RDS Performance Metrics"
        }
      },
      {
        type = "metric"
        properties = {
          metrics = [
            ["AWS/RDS", "ReadIOPS", { stat = "Average" }],
            [".", "WriteIOPS", { stat = "Average" }]
          ]
          period = 3600
          stat   = "Average"
          region = "us-east-1"
          title  = "IOPS Utilization"
        }
      }
    ]
  })
}