Cloud Cost Optimization Guide — Right-Sizing, Reserved Instances, and Storage Tiering

# rightsizing.py
# Analyze compute instance right-sizing opportunities
from collections import namedtuple

Instance = namedtuple('Instance', ['name', 'vcpu', 'memory_gb', 'hourly_cost'])

def find_right_sizing(instances, cpu_threshold=40, memory_threshold=60):
    results = []
    for inst in instances:
        # Simulated utilization metrics
        current = Instance(inst.name, inst.vcpu, inst.memory_gb, inst.hourly_cost)

        # Recommendation based on utilization
        if inst.vcpu >= 8 and inst.vcpu <= 16:  # Large instances
            downsized_cpu = inst.vcpu // 2
            for candidate in instances:
                if candidate.vcpu == downsized_cpu and candidate.memory_gb >= inst.memory_gb * 0.8:
                    savings = (inst.hourly_cost - candidate.hourly_cost) * 24 * 30
                    results.append({
                        "instance": inst.name,
                        "current_cost": f"${inst.hourly_cost:.3f}/hr",
                        "recommended": candidate.name,
                        "recommended_cost": f"${candidate.hourly_cost:.3f}/hr",
                        "monthly_savings": f"${savings:.0f}",
                    })
                    break
    return results

instances = [
    Instance("m5.4xlarge", 16, 64, 0.768),
    Instance("m5.2xlarge", 8, 32, 0.384),
    Instance("m5.xlarge", 4, 16, 0.192),
    Instance("m5.large", 2, 8, 0.096),
    Instance("t3.large", 2, 8, 0.0832),
]

print("=== Right-Sizing Analysis ===")
results = find_right_sizing(instances)
for r in results:
    print(f"\n  {r['instance']} ({r['current_cost']})")
    print(f"  → Recommended: {r['recommended']} ({r['recommended_cost']})")
    print(f"  → Monthly savings: {r['monthly_savings']}")

# Utility: compute monthly cost
def monthly_cost(hourly_rate, hours=730):
    return round(hourly_rate * hours, 2)

print("\n=== Cost Comparison (Monthly) ===")
for inst in [instances[0], instances[1], instances[3]]:
    mc = monthly_cost(inst.hourly_cost)
    print(f"  {inst.name:<15} ${inst.hourly_cost:<6}/hr → ${mc:<8}/month")

# pricing_models.py
# Compare pricing models for different workload types
from datetime import datetime

def compare_models(workload_hours, on_demand_rate):
    reserved_1yr = on_demand_rate * 0.65  # 35% discount
    reserved_3yr = on_demand_rate * 0.45  # 55% discount
    spot_rate = on_demand_rate * 0.20     # 80% discount

    on_demand_cost = on_demand_rate * workload_hours
    reserved_1_cost = reserved_1yr * workload_hours
    reserved_3_cost = reserved_3yr * workload_hours
    spot_cost = spot_rate * workload_hours

    return {
        "on_demand": round(on_demand_cost, 2),
        "reserved_1yr": round(reserved_1_cost, 2),
        "reserved_3yr": round(reserved_3_cost, 2),
        "spot": round(spot_cost, 2),
    }

print("=== Pricing Model Comparison ===")
scenarios = [
    ("Always-on production (8,760 hrs/yr)", 0.384, 8760),
    ("Business hours only (2,080 hrs/yr)", 0.384, 2080),
    ("Batch processing (500 hrs/yr)", 0.768, 500),
]

for desc, rate, hours in scenarios:
    costs = compare_models(hours, rate)
    print(f"\n{desc}:")
    print(f"  On-Demand:    ${costs['on_demand']:>8}")
    print(f"  1yr Reserved: ${costs['reserved_1yr']:>8} (save {int((1 - costs['reserved_1yr']/costs['on_demand'])*100)}%)")
    print(f"  3yr Reserved: ${costs['reserved_3yr']:>8} (save {int((1 - costs['reserved_3yr']/costs['on_demand'])*100)}%)")
    print(f"  Spot:         ${costs['spot']:>8} (save {int((1 - costs['spot']/costs['on_demand'])*100)}%)")

# storage_tiering.py
# Calculate storage cost savings with tiering
class StorageTier:
    def __init__(self, name, cost_per_gb, retrieval_cost_per_gb):
        self.name = name
        self.cost_per_gb = cost_per_gb
        self.retrieval_cost_per_gb = retrieval_cost_per_gb

    def monthly_cost(self, gb):
        return gb * self.cost_per_gb

tiers = [
    StorageTier("S3 Standard", 0.023, 0),
    StorageTier("S3 Standard-IA", 0.0125, 0.01),
    StorageTier("S3 Glacier Instant", 0.004, 0.03),
    StorageTier("S3 Glacier Deep Archive", 0.00099, 0.09),
]

# Scenario: 10TB data, access patterns
total_data_gb = 10000  # 10TB

print("=== Storage Tiering: 10TB Data ===")
scenarios = {
    "100% Standard (no tiering)": [(tiers[0], 1.0)],
    "20% Standard + 80% Deep Archive": [(tiers[0], 0.2), (tiers[3], 0.8)],
    "10% Standard + 20% IA + 70% Glacier": [(tiers[0], 0.1), (tiers[1], 0.2), (tiers[2], 0.7)],
    "Optimized: 5% Std + 15% IA + 30% Glacier + 50% Deep": [(tiers[0], 0.05), (tiers[1], 0.15), (tiers[2], 0.3), (tiers[3], 0.5)],
}

for scenario_name, allocation in scenarios:
    total = 0
    details = []
    for tier, fraction in allocation:
        gb = total_data_gb * fraction
        cost = tier.monthly_cost(gb)
        total += cost
        details.append(f"{tier.name} ({int(fraction*100)}%): ${cost:.0f}")
    print(f"\n  {scenario_name}")
    for d in details:
        print(f"    {d}")
    print(f"    Total: ${total:.0f}/month")

# tagging_strategy.py
# Demonstrate cost allocation with tags
from collections import defaultdict
import json

resources = [
    {"id": "ec2-prod-01", "type": "EC2", "cost": 150.00, "tags": {"env": "prod", "project": "web-app", "team": "backend"}},
    {"id": "ec2-prod-02", "type": "EC2", "cost": 150.00, "tags": {"env": "prod", "project": "web-app", "team": "backend"}},
    {"id": "rds-prod-01", "type": "RDS", "cost": 200.00, "tags": {"env": "prod", "project": "web-app", "team": "backend"}},
    {"id": "s3-analytics", "type": "S3", "cost": 45.00, "tags": {"env": "prod", "project": "analytics", "team": "data"}},
    {"id": "ec2-dev-01", "type": "EC2", "cost": 40.00, "tags": {"env": "dev", "project": "web-app", "team": "backend"}},
    {"id": "ec2-staging", "type": "EC2", "cost": 60.00, "tags": {"env": "staging", "project": "web-app", "team": "backend"}},
    {"id": "ec2-ml-01", "type": "EC2", "cost": 300.00, "tags": {"env": "prod", "project": "ml-training", "team": "ml"}},
    {"id": "lambda-etl", "type": "Lambda", "cost": 25.00, "tags": {"env": "prod", "project": "analytics", "team": "data"}},
]

def cost_by_tag(resources, tag_key):
    allocation = defaultdict(float)
    for r in resources:
        tag_value = r.get("tags", {}).get(tag_key, "untagged")
        allocation[tag_value] += r["cost"]
    return dict(allocation)

print("=== Cost Allocation by Tags ===")
for tag in ["env", "project", "team"]:
    costs = cost_by_tag(resources, tag)
    print(f"\nBy {tag}:")
    for k, v in sorted(costs.items(), key=lambda x: -x[1]):
        print(f"  {k:<15} ${v:>8.2f}")

# cost_optimizer.py
# Analyze and recommend cost optimizations
import random

class CostOptimizer:
    def __init__(self, monthly_budget):
        self.budget = monthly_budget
        self.current_spend = 0
        self.recommendations = []

    def analyze_instance(self, name, instance_type, hourly_cost, cpu_util, memory_util):
        self.current_spend += hourly_cost * 730
        issues = []

        if cpu_util < 20 and memory_util < 30:
            issues.append(f"{name}: Over-provisioned ({cpu_util}% CPU, {memory_util}% RAM) — downsize")
        elif cpu_util < 40 and memory_util < 50:
            issues.append(f"{name}: Could be rightsized ({cpu_util}% CPU, {memory_util}% RAM)")

        if cpu_util == 0 and memory_util == 0:
            issues.append(f"{name}: IDLE — consider stopping")

        for issue in issues:
            self.recommendations.append(issue)

    def report(self):
        savings_opportunities = len([r for r in self.recommendations if "downsize" in r or "rightsize" in r.lower() or "stop" in r.lower()])
        print("=== Cost Optimization Report ===")
        print(f"Monthly budget: ${self.budget:,.0f}")
        print(f"Current spend:  ${self.current_spend:,.0f}")
        print(f"Overspend:      ${max(0, self.current_spend - self.budget):,.0f}\n")
        for r in self.recommendations:
            print(f"  • {r}")
        print(f"\nTotal recommendations: {len(self.recommendations)}")
        print(f"Savings opportunities: {savings_opportunities}")

optimizer = CostOptimizer(monthly_budget=5000)
optimizer.analyze_instance("web-prod-1", "m5.xlarge", 0.192, 15, 22)
optimizer.analyze_instance("web-prod-2", "m5.xlarge", 0.192, 45, 60)
optimizer.analyze_instance("db-prod", "r5.2xlarge", 0.504, 12, 35)
optimizer.analyze_instance("ml-batch", "p3.2xlarge", 0.90, 0, 0)
optimizer.report()