AWS RDS Storage Full — Every Fix and Prevention (2026)

# Check current storage
aws rds describe-db-instances \
  --db-instance-identifier my-db \
  --query 'DBInstances[0].AllocatedStorage'
 
# Increase storage (can only increase, not decrease)
aws rds modify-db-instance \
  --db-instance-identifier my-db \
  --allocated-storage 200 \
  --apply-immediately
 
# Monitor the modification
aws rds describe-db-instances \
  --db-instance-identifier my-db \
  --query 'DBInstances[0].PendingModifiedValues'

-- Check table bloat
SELECT
  schemaname,
  tablename,
  pg_size_pretty(pg_total_relation_size(schemaname||'.'||tablename)) AS total_size,
  pg_size_pretty(pg_relation_size(schemaname||'.'||tablename)) AS table_size,
  n_dead_tup
FROM pg_stat_user_tables
ORDER BY pg_total_relation_size(schemaname||'.'||tablename) DESC
LIMIT 10;
 
-- Run VACUUM on bloated tables
VACUUM FULL ANALYZE large_table_name;
 
-- Check WAL archiving isn't stuck (can eat disk fast)
SELECT * FROM pg_stat_archiver;

-- Find largest tables
SELECT
  table_schema,
  table_name,
  ROUND((data_length + index_length) / 1024 / 1024) AS size_mb
FROM information_schema.TABLES
ORDER BY size_mb DESC
LIMIT 10;
 
-- Truncate or delete old data from large tables
DELETE FROM audit_logs WHERE created_at < DATE_SUB(NOW(), INTERVAL 90 DAY);
 
-- Optimize table (reclaims fragmented space)
OPTIMIZE TABLE audit_logs;

-- PostgreSQL: find tables growing fastest
SELECT
  relname,
  pg_size_pretty(pg_total_relation_size(relid)) AS size
FROM pg_catalog.pg_statio_user_tables
ORDER BY pg_total_relation_size(relid) DESC;

-- PostgreSQL: delete old records automatically
DELETE FROM application_logs
WHERE created_at < NOW() - INTERVAL '90 days';
 
-- Or use table partitioning for efficient deletion
CREATE TABLE logs_2026_03 PARTITION OF logs
FOR VALUES FROM ('2026-03-01') TO ('2026-04-01');
 
-- Drop old partition instantly (no lock, no bloat)
DROP TABLE logs_2026_01;

# Check binlog size on RDS
mysql -e "SHOW BINARY LOGS;"
 
# Check RDS parameter for retention
aws rds describe-db-parameters \
  --db-parameter-group-name my-parameter-group \
  --query "Parameters[?ParameterName=='binlog_retention_hours']"

-- Set binlog retention (RDS-specific stored procedure)
CALL mysql.rds_set_configuration('binlog retention hours', 24);

-- Check replication slots (can prevent WAL cleanup)
SELECT slot_name, restart_lsn, pg_size_pretty(
  pg_wal_lsn_diff(pg_current_wal_lsn(), restart_lsn)
) AS retained_wal
FROM pg_replication_slots;
 
-- Drop stale replication slot (if no longer needed)
SELECT pg_drop_replication_slot('stale_slot_name');

-- PostgreSQL: find large unused indexes
SELECT
  schemaname,
  tablename,
  indexname,
  pg_size_pretty(pg_relation_size(indexrelid)) AS index_size,
  idx_scan
FROM pg_stat_user_indexes
WHERE idx_scan = 0
ORDER BY pg_relation_size(indexrelid) DESC;
 
-- Drop unused index
DROP INDEX CONCURRENTLY unused_index_name;

aws rds modify-db-instance \
  --db-instance-identifier my-db \
  --max-allocated-storage 1000 \
  --apply-immediately

resource "aws_db_instance" "main" {
  identifier        = "my-db"
  engine            = "postgres"
  instance_class    = "db.t3.medium"
  allocated_storage = 100
  
  max_allocated_storage = 1000  # Enable autoscaling up to 1TB
  
  # ... other config
}

# Alert at 20% free storage remaining
aws cloudwatch put-metric-alarm \
  --alarm-name "RDS-LowStorage-my-db" \
  --alarm-description "RDS free storage below 20%" \
  --metric-name FreeStorageSpace \
  --namespace AWS/RDS \
  --statistic Average \
  --dimensions Name=DBInstanceIdentifier,Value=my-db \
  --period 300 \
  --evaluation-periods 2 \
  --threshold 21474836480 \
  --comparison-operator LessThanThreshold \
  --alarm-actions arn:aws:sns:ap-south-1:123456789:ops-alerts
 
# 21474836480 bytes = 20GB
# Adjust threshold based on your total storage

resource "aws_cloudwatch_metric_alarm" "rds_low_storage" {
  alarm_name          = "rds-low-storage-${var.db_identifier}"
  comparison_operator = "LessThanThreshold"
  evaluation_periods  = 2
  metric_name         = "FreeStorageSpace"
  namespace           = "AWS/RDS"
  period              = 300
  statistic           = "Average"
  threshold           = 20 * 1024 * 1024 * 1024  # 20GB in bytes
  
  dimensions = {
    DBInstanceIdentifier = var.db_identifier
  }
  
  alarm_actions = [aws_sns_topic.ops_alerts.arn]
}

# Free storage as percentage
(
  aws_rds_free_storage_space_average 
  / 
  (aws_rds_free_storage_space_average + aws_rds_used_storage_space_average)
) * 100

groups:
- name: rds
  rules:
  - alert: RDSLowFreeStorage
    expr: |
      (aws_rds_free_storage_space_average / 
       (aws_rds_free_storage_space_average + aws_rds_used_storage_space_average)) * 100 < 20
    for: 10m
    labels:
      severity: warning
    annotations:
      summary: "RDS {{ $labels.dbinstance_identifier }} free storage < 20%"