Storage Cost Optimization — S3 Lifecycle, Azure Blob Tiers, GCP Storage Classes, Archival

{
    "Rules": [
        {
            "Id": "TierByAge",
            "Status": "Enabled",
            "Filter": {"Prefix": "logs/"},
            "Transitions": [
                {
                    "Days": 30,
                    "StorageClass": "STANDARD_IA]
                },
                {
                    "Days": 90,
                    "StorageClass": "GLACIER_INSTANT_RETRIEVAL"
                },
                {
                    "Days": 365,
                    "StorageClass": "DEEP_ARCHIVE"
                }
            ],
            "Expiration": {
                "Days": 2555  // 7 years
            }
        }
    ]
}

aws s3api put-bucket-lifecycle-configuration \
  --bucket my-company-logs \
  --lifecycle-configuration file://lifecycle.json

# Create S3 Intelligent-Tiering archive configuration
aws s3api put-bucket-intelligent-tiering-configuration \
  --bucket my-data \
  --id AutoTier \
  --intelligent-tiering-configuration '{
      "Id": "AutoTier",
      "Status": "Enabled",
      "Tierings": [
        {"Days": 90, "AccessTier": "ARCHIVE_ACCESS"},
        {"Days": 365, "AccessTier": "DEEP_ARCHIVE_ACCESS"}
      ]
  }'

{
    "properties": {
        "policy": {
            "rules": [
                {
                    "name": "TierToCool",
                    "enabled": true,
                    "type": "Lifecycle",
                    "definition": {
                        "filters": {
                            "blobTypes": ["blockBlob"],
                            "prefixMatch": ["backups/"]
                        },
                        "actions": {
                            "baseBlob": {
                                "tierToCool": {"daysAfterModificationGreaterThan": 30},
                                "tierToArchive": {"daysAfterModificationGreaterThan": 180},
                                "delete": {"daysAfterModificationGreaterThan": 2555}
                            }
                        }
                    }
                }
            ]
        }
    }
}

# Apply lifecycle policy
az storage account management-policy create \
  --account-name mystorageaccount \
  --policy @policy.json \
  --resource-group my-rg

# Create lifecycle rule
gcp storage buckets update gs://my-bucket \
  --lifecycle-file=lifecycle.json

# lifecycle.json
{
  "lifecycle": {
    "rule": [
      {
        "action": {"type": "SetStorageClass", "storageClass": "NEARLINE"},
        "condition": {"age": 30}
      },
      {
        "action": {"type": "SetStorageClass", "storageClass": "COLDLINE"},
        "condition": {"age": 90}
      },
      {
        "action": {"type": "SetStorageClass", "storageClass": "ARCHIVE"},
        "condition": {"age": 365}
      },
      {
        "action": {"type": "Delete"},
        "condition": {"age": 2555}
      }
    ]
  }
}

import boto3
import json

s3 = boto3.client('s3')

def lambda_handler(event, context):
    """Auto-archive objects older than 90 days"""

    bucket = event['bucket']
    prefix = event.get('prefix', '')

    paginator = s3.get_paginator('list_objects_v2')
    pages = paginator.paginate(Bucket=bucket, Prefix=prefix)

    archived = 0
    for page in pages:
        for obj in page.get('Contents', []):
            # Check if object is older than 90 days
            age = (datetime.now(obj['LastModified'].tzinfo)
                   - obj['LastModified']).days

            if age > 90 and obj['StorageClass'] not in ['GLACIER', 'DEEP_ARCHIVE']:
                s3.copy_object(
                    Bucket=bucket,
                    Key=obj['Key'],
                    CopySource={'Bucket': bucket, 'Key': obj['Key']},
                    StorageClass='DEEP_ARCHIVE'
                )
                archived += 1

    return {
        'bucket': bucket,
        'archived_objects': archived,
        'timestamp': datetime.now().isoformat()
    }

#!/bin/bash
# archive_old_data.sh — Archive files older than N days to Glacier

BUCKET="my-company-data"
DAYS_OLD=90

echo "Archiving objects in s3://$BUCKET older than $DAYS_OLD days..."

aws s3api list-objects-v2 --bucket "$BUCKET" --query 'Contents[?!IsTruncated]' \
  --output json | jq -c '.[]' | while read obj; do
    key=$(echo "$obj" | jq -r '.Key')
    last_modified=$(echo "$obj" | jq -r '.LastModified')
    storage_class=$(echo "$obj" | jq -r '.StorageClass')

    # Calculate age in days
    age=$(( ($(date +%s) - $(date -d "$last_modified" +%s)) / 86400 ))

    if [ "$age" -gt "$DAYS_OLD" ] && \
       [ "$storage_class" != "GLACIER" ] && \
       [ "$storage_class" != "DEEP_ARCHIVE" ]; then
        echo "Archiving: $key (age: ${age}d, class: ${storage_class})"
        aws s3 cp "s3://$BUCKET/$key" "s3://$BUCKET/$key" \
          --storage-class DEEP_ARCHIVE
    fi
done

#!/bin/bash
# storage_cost_report.sh — Analyze S3 storage costs

echo "=== S3 Storage Cost Report ==="
echo "Generated: $(date)"
echo ""

# List all buckets
for bucket in $(aws s3 ls | awk '{print $3}'); do
    echo "--- Bucket: $bucket ---"

    # Get object count and total size
    total_objects=$(aws s3api list-objects-v2 --bucket "$bucket" \
      --query 'KeyCount' --output text 2>/dev/null || echo "0")

    total_size=$(aws s3api list-objects-v2 --bucket "$bucket" \
      --query 'sum(Contents[].Size)' --output text 2>/dev/null || echo "0")

    size_gb=$(echo "scale=2; $total_size / 1073741824" | bc)

    echo "Objects: ${total_objects:-0}"
    echo "Total size: ${size_gb:-0} GB"

    # Storage class breakdown
    echo "Storage class breakdown:"
    aws s3api list-objects-v2 --bucket "$bucket" \
      --query 'Contents[].StorageClass' --output text 2>/dev/null | \
      tr '\t' '\n' | sort | uniq -c | sort -rn | while read count class; do
        rate=0.023
        case "$class" in
            "STANDARD") rate=0.023 ;;
            "INTELLIGENT_TIERING") rate=0.023 ;;
            "STANDARD_IA") rate=0.0125 ;;
            "ONEZONE_IA") rate=0.01 ;;
            "GLACIER") rate=0.0036 ;;
            "DEEP_ARCHIVE") rate=0.00099 ;;
        esac
        estimated_cost=$(echo "scale=2; $size_gb * $rate" | bc)
        printf "  %-20s %d objects ~$%.2f/month\n" "$class" "$count" "$estimated_cost"
    done
    echo ""
done