How to Cut Your S3 Bill by 70% With 10 Lines of Code

import boto3
from datetime import datetime

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

total_waste = 0
for bucket in s3.list_buckets()['Buckets']:
    name = bucket['Name']
    try:
        s3.get_bucket_lifecycle_configuration(Bucket=name)
    except:
        # Get bucket size from CloudWatch
        metrics = cloudwatch.get_metric_statistics(
            Namespace='AWS/S3',
            MetricName='BucketSizeBytes',
            Dimensions=[{'Name': 'BucketName', 'Value': name},
                       {'Name': 'StorageType', 'Value': 'StandardStorage'}],
            StartTime=datetime.now().replace(day=1),
            EndTime=datetime.now(),
            Period=86400,
            Statistics=['Average']
        )
        if metrics['Datapoints']:
            size_gb = metrics['Datapoints'][-1]['Average'] / 1e9
            monthly_cost = size_gb * 0.023
            potential_savings = monthly_cost * 0.7  # 70% typical savings
            total_waste += potential_savings
            if monthly_cost > 10:  # Only show significant buckets
                print(f"💸 {name}: ${monthly_cost:.0f}/mo → Save ${potential_savings:.0f}/mo")

print(f"\n🔥 TOTAL POTENTIAL SAVINGS: ${total_waste:.0f}/month")

import boto3

def apply_smart_lifecycle(bucket_name):
    s3 = boto3.client('s3')
    
    policy = {
        'Rules': [{
            'ID': 'SmartTiering',
            'Status': 'Enabled',
            'Filter': {},
            'Transitions': [
                {'Days': 30, 'StorageClass': 'STANDARD_IA'},
                {'Days': 90, 'StorageClass': 'GLACIER_IR'},
                {'Days': 180, 'StorageClass': 'DEEP_ARCHIVE'}
            ],
            'NoncurrentVersionTransitions': [
                {'NoncurrentDays': 7, 'StorageClass': 'STANDARD_IA'},
                {'NoncurrentDays': 30, 'StorageClass': 'GLACIER_IR'}
            ],
            'NoncurrentVersionExpiration': {'NoncurrentDays': 90},
            'AbortIncompleteMultipartUpload': {'DaysAfterInitiation': 7}
        }]
    }
    
    s3.put_bucket_lifecycle_configuration(
        Bucket=bucket_name,
        LifecycleConfiguration=policy
    )
    print(f"✅ Applied to {bucket_name} - savings start in 30 days")

# Apply to your bucket
apply_smart_lifecycle('your-bucket-name')

log_policy = {
    'Rules': [{
        'ID': 'LogRotation',
        'Status': 'Enabled',
        'Filter': {'Prefix': 'logs/'},
        'Transitions': [
            {'Days': 7, 'StorageClass': 'STANDARD_IA'},
            {'Days': 30, 'StorageClass': 'GLACIER_IR'}
        ],
        'Expiration': {'Days': 90}
    }]
}

backup_policy = {
    'Rules': [{
        'ID': 'BackupArchive',
        'Status': 'Enabled',
        'Filter': {'Prefix': 'backups/'},
        'Transitions': [
            {'Days': 1, 'StorageClass': 'STANDARD_IA'},
            {'Days': 7, 'StorageClass': 'GLACIER_IR'},
            {'Days': 30, 'StorageClass': 'GLACIER'},
            {'Days': 90, 'StorageClass': 'DEEP_ARCHIVE'}
        ]
    }]
}

user_content_policy = {
    'Rules': [{
        'ID': 'UserContent',
        'Status': 'Enabled',
        'Filter': {'Prefix': 'user-uploads/'},
        'Transitions': [
            {'Days': 60, 'StorageClass': 'STANDARD_IA'},
            {'Days': 180, 'StorageClass': 'GLACIER_IR'},
            {'Days': 365, 'StorageClass': 'DEEP_ARCHIVE'}
        ]
    }]
}

import boto3

s3 = boto3.client('s3')

def bulk_apply_lifecycle(pattern, policy):
    for bucket in s3.list_buckets()['Buckets']:
        if pattern in bucket['Name']:
            try:
                s3.put_bucket_lifecycle_configuration(
                    Bucket=bucket['Name'],
                    LifecycleConfiguration=policy
                )
                print(f"✅ {bucket['Name']}")
            except Exception as e:
                print(f"❌ {bucket['Name']}: {str(e)}")

# Apply to all log buckets
bulk_apply_lifecycle('log', log_policy)
# Apply to all backup buckets  
bulk_apply_lifecycle('backup', backup_policy)

def get_storage_metrics(bucket_name):
    cloudwatch = boto3.client('cloudwatch')
    
    storage_types = ['StandardStorage', 'StandardIAStorage', 
                    'GlacierInstantRetrievalStorage', 'DeepArchiveStorage']
    
    total_saved = 0
    for storage_type in storage_types:
        response = cloudwatch.get_metric_statistics(
            Namespace='AWS/S3',
            MetricName='BucketSizeBytes',
            Dimensions=[
                {'Name': 'BucketName', 'Value': bucket_name},
                {'Name': 'StorageType', 'Value': storage_type}
            ],
            StartTime=datetime.now().replace(day=1),
            EndTime=datetime.now(),
            Period=86400,
            Statistics=['Average']
        )
        
        if response['Datapoints']:
            size_gb = response['Datapoints'][-1]['Average'] / 1e9
            
            # Calculate costs by tier
            if storage_type == 'StandardStorage':
                cost = size_gb * 0.023
            elif storage_type == 'StandardIAStorage':
                cost = size_gb * 0.0125
                total_saved += size_gb * (0.023 - 0.0125)
            elif storage_type == 'GlacierInstantRetrievalStorage':
                cost = size_gb * 0.004
                total_saved += size_gb * (0.023 - 0.004)
            else:  # Deep Archive
                cost = size_gb * 0.00099
                total_saved += size_gb * (0.023 - 0.00099)
                
            print(f"{storage_type}: {size_gb:.1f} GB (${cost:.2f}/mo)")
    
    print(f"\n💰 Monthly Savings: ${total_saved:.2f}")

get_storage_metrics('your-bucket-name')

def remove_lifecycle(bucket_name):
    s3 = boto3.client('s3')
    s3.delete_bucket_lifecycle(Bucket=bucket_name)
    print(f"Lifecycle policy removed from {bucket_name}")

az storage account management-policy create \
  --account-name mystorageaccount \
  --policy @policy.json \
  --resource-group myresourcegroup

gsutil lifecycle set lifecycle.json gs://my-bucket

s3.put_bucket_intelligent_tiering_configuration(
    Bucket='bucket-name',
    Id='EntireBucket',
    IntelligentTieringConfiguration={
        'Status': 'Enabled',
        'Tierings': [
            {'Days': 90, 'AccessTier': 'ARCHIVE_ACCESS'},
            {'Days': 180, 'AccessTier': 'DEEP_ARCHIVE_ACCESS'}
        ]
    }
)

s3.put_object_tagging(
    Bucket='bucket-name',
    Key='critical-file.dat',
    Tagging={'TagSet': [{'Key': 'retain', 'Value': 'permanent'}]}
)

# Quick calculation for your savings
bucket_size_tb = 10  # Change this to your size
monthly_cost_before = bucket_size_tb * 1000 * 0.023

# After lifecycle (typical distribution)
monthly_cost_after = (
    bucket_size_tb * 1000 * 0.20 * 0.023 +  # 20% Standard
    bucket_size_tb * 1000 * 0.30 * 0.0125 + # 30% IA
    bucket_size_tb * 1000 * 0.50 * 0.004    # 50% Glacier
)

print(f"Monthly Savings: ${monthly_cost_before - monthly_cost_after:.0f}")
print(f"Annual Savings: ${(monthly_cost_before - monthly_cost_after) * 12:.0f}")