import boto3

s3 = boto3.client("s3")

# Apply intelligent tiering to buckets with unpredictable access patterns
s3.put_bucket_intelligent_tiering_configuration(
    Bucket="my-data-bucket",
    Id="EntireS3Bucket",
    IntelligentTieringConfiguration={
        "Id": "EntireS3Bucket",
        "Status": "Enabled",
        "Tierings": [
            {
                "Days": 90,
                "AccessTier": "ARCHIVE_ACCESS"  # 40% cheaper than Standard
            },
            {
                "Days": 180,
                "AccessTier": "DEEP_ARCHIVE_ACCESS"  # 75% cheaper
            }
        ]
    }
)

# Identify RDS instances running > 90 days (reservation candidates)
import boto3
from datetime import datetime, timezone, timedelta

rds = boto3.client('rds')
response = rds.describe_db_instances()

cutoff = datetime.now(timezone.utc) - timedelta(days=90)

candidates = [
    db for db in response['DBInstances']
    if db['InstanceCreateTime'] < cutoff
    and db['DBInstanceStatus'] == 'available'
]

for db in candidates:
    print(f"{db['DBInstanceIdentifier']}: {db['DBInstanceClass']}, "
          f"running since {db['InstanceCreateTime'].date()}")

# Calculate if on-demand or provisioned is cheaper for your pattern
def should_switch_to_provisioned(
    avg_read_capacity: float,
    avg_write_capacity: float,
    peak_multiplier: float = 3.0
) -> dict:
    
    # On-demand pricing (us-east-1, approximate 2026 rates)
    on_demand_read_price = 0.25 / 1_000_000   # per RCU
    on_demand_write_price = 1.25 / 1_000_000  # per WCU
    
    # Provisioned pricing
    provisioned_read_price = 0.00013 / 3600   # per RCU-hour
    provisioned_write_price = 0.00065 / 3600  # per WCU-hour
    
    # Estimate monthly costs
    monthly_rcus = avg_read_capacity * 3600 * 24 * 30
    monthly_wcus = avg_write_capacity * 3600 * 24 * 30
    
    on_demand_monthly = (monthly_rcus * on_demand_read_price + 
                         monthly_wcus * on_demand_write_price)
    
    provisioned_monthly = (
        avg_read_capacity * peak_multiplier * provisioned_read_price * 3600 * 24 * 30 +
        avg_write_capacity * peak_multiplier * provisioned_write_price * 3600 * 24 * 30
    )
    
    return {
        "on_demand_monthly": f"${on_demand_monthly:.2f}",
        "provisioned_monthly": f"${provisioned_monthly:.2f}",
        "recommendation": "provisioned" if provisioned_monthly < on_demand_monthly else "on-demand"
    }

# Use AWS Lambda Power Tuning (open source tool)
# https://github.com/alexcasalboni/aws-lambda-power-tuning

# Rough calculation for your function
def optimal_lambda_memory(
    baseline_ms_at_128mb: float,
    invocations_per_month: int
) -> dict:
    memory_configs = [128, 256, 512, 1024, 2048, 3008]
    # Rough scaling: 2x memory ≈ 0.7x duration for CPU-bound functions
    
    results = []
    for mb in memory_configs:
        scale = (128 / mb) ** 0.6  # empirical scaling factor
        duration = baseline_ms_at_128mb * scale
        # Lambda pricing: $0.0000166667 per GB-second
        gb_seconds = (mb / 1024) * (duration / 1000) * invocations_per_month
        cost = gb_seconds * 0.0000166667
        results.append({"memory_mb": mb, "est_duration_ms": duration, "monthly_cost": cost})
    
    return sorted(results, key=lambda x: x["monthly_cost"])

# Find the sweet spot
print(optimal_lambda_memory(baseline_ms_at_128mb=800, invocations_per_month=1_000_000))

import boto3
from datetime import date, timedelta

ce = boto3.client('cost-explorer', region_name='us-east-1')

# Get cost by service+team for last 30 days
response = ce.get_cost_and_usage(
    TimePeriod={
        'Start': (date.today() - timedelta(days=30)).isoformat(),
        'End': date.today().isoformat()
    },
    Granularity='MONTHLY',
    Filter={
        'Tags': {
            'Key': 'Team',
            'Values': ['platform', 'data', 'frontend']
        }
    },
    GroupBy=[
        {'Type': 'TAG', 'Key': 'Team'},
        {'Type': 'DIMENSION', 'Key': 'SERVICE'}
    ],
    Metrics=['BlendedCost']
)

for result in response['ResultsByTime'][0]['Groups']:
    keys = result['Keys']
    cost = result['Metrics']['BlendedCost']['Amount']
    print(f"{keys[0]} / {keys[1]}: ${float(cost):.2f}")

# Lambda function: alert on cost anomalies
import boto3
import json

def check_cost_anomaly(event, context):
    ce = boto3.client('cost-explorer')
    sns = boto3.client('sns')
    
    anomalies = ce.get_anomalies(
        DateInterval={
            'StartDate': '2026-03-01',
            'EndDate': '2026-03-17'
        },
        TotalImpact={
            'NumericOperator': 'GREATER_THAN',
            'StartValue': 100  # alert on $100+ anomalies
        }
    )
    
    if anomalies['Anomalies']:
        message = "⚠️ Cost Anomalies Detected:\n\n"
        for anomaly in anomalies['Anomalies']:
            impact = anomaly['Impact']['TotalImpact']
            message += f"- {anomaly['RootCauses'][0].get('Service', 'Unknown')}: "
            message += f"${impact:.2f} above expected\n"
        
        sns.publish(
            TopicArn='arn:aws:sns:us-east-1:123456789:cost-alerts',
            Message=message,
            Subject='AWS Cost Anomaly Alert'
        )