import boto3
from datetime import datetime, timedelta

class PostFreeTierOptimizer:
    """AWS免费套餐到期后如何省钱 - 紧急优化器"""

    def __init__(self):
        self.ec2 = boto3.client('ec2')
        self.rds = boto3.client('rds')
        self.s3 = boto3.client('s3')

    def emergency_cleanup(self):
        """紧急清理未使用资源"""

        total_savings = 0

        # 1. 停止闲置EC2实例
        instances = self.ec2.describe_instances(
            Filters=[
                {'Name': 'instance-state-name', 'Values': ['running']}
            ]
        )

        for reservation in instances['Reservations']:
            for instance in reservation['Instances']:
                # 检查CPU利用率（需要CloudWatch）
                if self.is_instance_idle(instance['InstanceId']):
                    self.ec2.stop_instances(InstanceIds=[instance['InstanceId']])
                    print(f"Stopped idle instance: {instance['InstanceId']}")
                    total_savings += 8.35  # t2.micro月度成本

        # 2. 删除未挂载的EBS卷
        volumes = self.ec2.describe_volumes(
            Filters=[
                {'Name': 'status', 'Values': ['available']}
            ]
        )

        for volume in volumes['Volumes']:
            self.ec2.delete_volume(VolumeId=volume['VolumeId'])
            print(f"Deleted unattached volume: {volume['VolumeId']}")
            total_savings += volume['Size'] * 0.10

        # 3. 清理旧快照
        snapshots = self.ec2.describe_snapshots(OwnerIds=['self'])
        cutoff_date = datetime.now() - timedelta(days=30)

        for snapshot in snapshots['Snapshots']:
            if snapshot['StartTime'].replace(tzinfo=None) < cutoff_date:
                self.ec2.delete_snapshot(SnapshotId=snapshot['SnapshotId'])
                print(f"Deleted old snapshot: {snapshot['SnapshotId']}")
                total_savings += 0.05 * snapshot.get('VolumeSize', 0)

        # 4. 释放未使用的弹性IP
        addresses = self.ec2.describe_addresses()

        for address in addresses['Addresses']:
            if 'InstanceId' not in address:
                self.ec2.release_address(AllocationId=address['AllocationId'])
                print(f"Released unused EIP: {address['PublicIp']}")
                total_savings += 3.60

        print(f"n紧急清理完成！预计月度节省: ${total_savings:.2f}")
        return total_savings

    def is_instance_idle(self, instance_id, threshold=5.0):
        """检查实例是否闲置（CPU < 5%）"""
        cw = boto3.client('cloudwatch')

        response = cw.get_metric_statistics(
            Namespace='AWS/EC2',
            MetricName='CPUUtilization',
            Dimensions=[{'Name': 'InstanceId', 'Value': instance_id}],
            StartTime=datetime.now() - timedelta(hours=1),
            EndTime=datetime.now(),
            Period=3600,
            Statistics=['Average']
        )

        if response['Datapoints']:
            avg_cpu = response['Datapoints'][0]['Average']
            return avg_cpu < threshold
        return False

# 执行紧急优化
optimizer = PostFreeTierOptimizer()
optimizer.emergency_cleanup()

def setup_instance_scheduler():
    """AWS免费套餐到期后如何省钱 - 实例调度器"""

    import json

    # Lambda函数代码
    lambda_code = '''
import boto3
from datetime import datetime

def lambda_handler(event, context):
    ec2 = boto3.client('ec2')
    current_hour = datetime.now().hour

    # 工作时间: 9 AM - 6 PM
    if 9 <= current_hour < 18:
        # 启动开发/测试实例
        instances = ec2.describe_instances(
            Filters=[
                {'Name': 'tag:Environment', 'Values': ['Development', 'Testing']},
                {'Name': 'instance-state-name', 'Values': ['stopped']}
            ]
        )

        instance_ids = []
        for r in instances['Reservations']:
            for i in r['Instances']:
                instance_ids.append(i['InstanceId'])

        if instance_ids:
            ec2.start_instances(InstanceIds=instance_ids)
            print(f"Started {len(instance_ids)} instances")
    else:
        # 停止开发/测试实例
        instances = ec2.describe_instances(
            Filters=[
                {'Name': 'tag:Environment', 'Values': ['Development', 'Testing']},
                {'Name': 'instance-state-name', 'Values': ['running']}
            ]
        )

        instance_ids = []
        for r in instances['Reservations']:
            for i in r['Instances']:
                instance_ids.append(i['InstanceId'])

        if instance_ids:
            ec2.stop_instances(InstanceIds=instance_ids)
            print(f"Stopped {len(instance_ids)} instances")

    return {'statusCode': 200}
    '''

    # 创建EventBridge规则（每小时运行）
    events = boto3.client('events')

    rule_response = events.put_rule(
        Name='InstanceScheduler',
        ScheduleExpression='rate(1 hour)',
        State='ENABLED',
        Description='AWS免费套餐到期后省钱 - 自动开关实例'
    )

    print("实例调度器设置完成")
    print("预计节省: 65% 的开发/测试环境成本")

def optimize_s3_storage():
    """AWS免费套餐到期后如何省钱 - S3存储优化"""

    s3 = boto3.client('s3')

    # 获取所有桶
    buckets = s3.list_buckets()

    for bucket in buckets['Buckets']:
        bucket_name = bucket['Name']

        # 配置智能分层
        lifecycle_policy = {
            'Rules': [
                {
                    'Id': 'IntelligentTiering',
                    'Status': 'Enabled',
                    'Transitions': [
                        {
                            'Days': 0,
                            'StorageClass': 'INTELLIGENT_TIERING'
                        }
                    ]
                },
                {
                    'Id': 'ArchiveOldData',
                    'Status': 'Enabled',
                    'Transitions': [
                        {
                            'Days': 90,
                            'StorageClass': 'GLACIER_IR'
                        },
                        {
                            'Days': 180,
                            'StorageClass': 'DEEP_ARCHIVE'
                        }
                    ]
                },
                {
                    'Id': 'DeleteOldData',
                    'Status': 'Enabled',
                    'Expiration': {
                        'Days': 365
                    },
                    'NoncurrentVersionExpiration': {
                        'NoncurrentDays': 30
                    }
                }
            ]
        }

        try:
            s3.put_bucket_lifecycle_configuration(
                Bucket=bucket_name,
                LifecycleConfiguration=lifecycle_policy
            )
            print(f"优化 {bucket_name} 存储策略")
        except Exception as e:
            print(f"Error optimizing {bucket_name}: {e}")

    print("nS3存储优化完成")
    print("预计节省: 40-60% 的存储成本")

def optimize_rds_costs():
    """AWS免费套餐到期后如何省钱 - RDS优化"""

    rds = boto3.client('rds')

    # 获取所有数据库实例
    db_instances = rds.describe_db_instances()

    recommendations = []
    total_savings = 0

    for db in db_instances['DBInstances']:
        db_id = db['DBInstanceIdentifier']
        instance_class = db['DBInstanceClass']
        multi_az = db['MultiAZ']
        engine = db['Engine']

        # 分析并提供建议
        if 'prod' not in db_id.lower() and multi_az:
            recommendations.append({
                'DB': db_id,
                'Action': 'Disable Multi-AZ',
                'Savings': '$12/month'
            })
            total_savings += 12

        if instance_class == 'db.t2.micro' and engine in ['mysql', 'postgres']:
            recommendations.append({
                'DB': db_id,
                'Action': 'Consider Aurora Serverless',
                'Savings': '$8/month'
            })
            total_savings += 8

        # 检查是否可以降级
        if 'dev' in db_id.lower() or 'test' in db_id.lower():
            if instance_class != 'db.t2.micro':
                recommendations.append({
                    'DB': db_id,
                    'Action': f'Downgrade from {instance_class} to db.t3.micro',
                    'Savings': '$20/month'
                })
                total_savings += 20

    # 打印建议
    print("RDS优化建议：")
    for rec in recommendations:
        print(f"- {rec['DB']}: {rec['Action']} (节省 {rec['Savings']})")

    print(f"n总计月度节省: ${total_savings}")

    return recommendations

def setup_cost_monitoring():
    """AWS免费套餐到期后如何省钱 - 成本监控"""

    cw = boto3.client('cloudwatch')
    sns = boto3.client('sns')

    # 创建SNS主题
    topic = sns.create_topic(Name='AWSCostAlerts')
    topic_arn = topic['TopicArn']

    # 订阅邮件通知
    sns.subscribe(
        TopicArn=topic_arn,
        Protocol='email',
        Endpoint='your-email@example.com'
    )

    # 层级1：每日支出警报（超过$5）
    cw.put_metric_alarm(
        AlarmName='DailySpendAlert',
        ComparisonOperator='GreaterThanThreshold',
        EvaluationPeriods=1,
        MetricName='EstimatedCharges',
        Namespace='AWS/Billing',
        Period=86400,
        Statistic='Maximum',
        Threshold=5.0,
        ActionsEnabled=True,
        AlarmActions=[topic_arn],
        AlarmDescription='Alert when daily spend exceeds $5',
        Dimensions=[
            {'Name': 'Currency', 'Value': 'USD'}
        ]
    )

    # 层级2：月度预算警报（80%时）
    budgets = boto3.client('budgets')

    budgets.create_budget(
        AccountId=boto3.client('sts').get_caller_identity()['Account'],
        Budget={
            'BudgetName': 'MonthlyBudget',
            'BudgetLimit': {
                'Amount': '50',
                'Unit': 'USD'
            },
            'TimeUnit': 'MONTHLY',
            'BudgetType': 'COST'
        },
        NotificationsWithSubscribers=[
            {
                'Notification': {
                    'NotificationType': 'ACTUAL',
                    'ComparisonOperator': 'GREATER_THAN',
                    'Threshold': 80,
                    'ThresholdType': 'PERCENTAGE'
                },
                'Subscribers': [
                    {
                        'SubscriptionType': 'EMAIL',
                        'Address': 'your-email@example.com'
                    }
                ]
            }
        ]
    )

    # 层级3：异常检测
    ce = boto3.client('ce')

    ce.create_anomaly_detector(
        AnomalyDetector={
            'DimensionValues': ['SERVICE'],
            'MonitorDimension': 'SERVICE'
        }
    )

    print("成本监控体系建立完成")
    print("- 每日支出警报: >$5")
    print("- 月度预算警报: >80% ($40)")
    print("- 异常检测: 自动识别异常支出")

def migrate_to_serverless():
    """AWS免费套餐到期后如何省钱 - Serverless迁移"""

    # Lambda函数示例（替代EC2 Web服务器）
    lambda_function = '''
import json
import boto3

def lambda_handler(event, context):
    # 处理HTTP请求
    method = event['httpMethod']
    path = event['path']

    if method == 'GET' and path == '/users':
        # 从DynamoDB获取数据
        dynamodb = boto3.resource('dynamodb')
        table = dynamodb.Table('Users')

        response = table.scan()

        return {
            'statusCode': 200,
            'headers': {
                'Content-Type': 'application/json'
            },
            'body': json.dumps(response['Items'])
        }

    return {
        'statusCode': 404,
        'body': json.dumps({'error': 'Not found'})
    }
    '''

    # API Gateway配置
    api_config = {
        'swagger': '2.0',
        'info': {
            'title': 'Serverless API',
            'version': '1.0.0'
        },
        'paths': {
            '/users': {
                'get': {
                    'x-amazon-apigateway-integration': {
                        'uri': 'arn:aws:apigateway:region:lambda:path/functions/arn/invocations',
                        'passthroughBehavior': 'when_no_match',
                        'httpMethod': 'POST',
                        'type': 'aws_proxy'
                    }
                }
            }
        }
    }

    # DynamoDB表配置（按需付费）
    dynamodb_config = {
        'TableName': 'Users',
        'BillingMode': 'PAY_PER_REQUEST',  # 按需付费
        'AttributeDefinitions': [
            {'AttributeName': 'userId', 'AttributeType': 'S'}
        ],
        'KeySchema': [
            {'AttributeName': 'userId', 'KeyType': 'HASH'}
        ]
    }

    print("Serverless架构配置完成")
    print("预计成本: $12.80/月 (vs 传统架构 $59.95/月)")
    print("节省: 79% 或 $47.15/月")

def calculate_discount_options():
    """AWS免费套餐到期后如何省钱 - 折扣计算器"""

    # 假设当前月度支出
    current_monthly_spend = {
        'EC2': 30,
        'RDS': 20,
        'Lambda': 10,
        'Other': 10
    }

    total_monthly = sum(current_monthly_spend.values())

    # 计算不同折扣方案的节省
    options = []

    # 选项1：Compute Savings Plan (1年，全预付)
    compute_sp_discount = 0.30  # 30%折扣
    compute_spend = current_monthly_spend['EC2'] + current_monthly_spend['Lambda']
    compute_savings = compute_spend * compute_sp_discount * 12

    options.append({
        'Plan': 'Compute Savings Plan (1年)',
        'Upfront': compute_spend * 12 * (1 - compute_sp_discount),
        'Annual Savings': compute_savings,
        'ROI': f'{compute_sp_discount * 100:.0f}%'
    })

    # 选项2：EC2 Reserved Instance (1年，无预付)
    ec2_ri_discount = 0.40  # 40%折扣
    ec2_savings = current_monthly_spend['EC2'] * ec2_ri_discount * 12

    options.append({
        'Plan': 'EC2 Reserved Instance (1年)',
        'Upfront': 0,
        'Annual Savings': ec2_savings,
        'ROI': f'{ec2_ri_discount * 100:.0f}%'
    })

    # 选项3：混合策略
    hybrid_savings = (
        current_monthly_spend['EC2'] * 0.40 +  # RI for EC2
        current_monthly_spend['Lambda'] * 0.30 +  # SP for Lambda
        current_monthly_spend['RDS'] * 0.35  # RI for RDS
    ) * 12

    options.append({
        'Plan': '混合策略',
        'Upfront': 'Variable',
        'Annual Savings': hybrid_savings,
        'ROI': f'{(hybrid_savings / (total_monthly * 12)) * 100:.0f}%'
    })

    # 打印分析结果
    print("=" * 60)
    print("AWS免费套餐到期后省钱方案分析")
    print("=" * 60)
    print(f"当前月度支出: ${total_monthly}")
    print(f"年度支出（无优化）: ${total_monthly * 12}")
    print("n折扣方案对比：")

    for option in options:
        print(f"n{option['Plan']}:")
        print(f"  预付: ${option['Upfront']}")
        print(f"  年度节省: ${option['Annual Savings']:.2f}")
        print(f"  投资回报率: {option['ROI']}")

    return options

class AWSGraduationOptimizer:
    """AWS免费套餐到期后如何省钱 - 综合优化器"""

    def __init__(self):
        self.session = boto3.Session()
        self.account_id = self.session.client('sts').get_caller_identity()['Account']

    def run_full_optimization(self):
        """运行完整优化流程"""

        print("=" * 60)
        print("AWS免费套餐毕业优化程序")
        print("=" * 60)

        steps = [
            ("分析当前成本", self.analyze_costs),
            ("清理未使用资源", self.cleanup_unused),
            ("优化实例类型", self.optimize_instances),
            ("配置自动调度", self.setup_scheduling),
            ("优化存储", self.optimize_storage),
            ("设置监控告警", self.setup_monitoring),
            ("生成优化报告", self.generate_report)
        ]

        total_savings = 0

        for step_name, step_function in steps:
            print(f"n执行: {step_name}")
            print("-" * 40)

            try:
                savings = step_function()
                total_savings += savings
                print(f"✓ 完成 - 节省: ${savings:.2f}/月")
            except Exception as e:
                print(f"✗ 错误: {e}")

        print("n" + "=" * 60)
        print(f"优化完成！")
        print(f"预计月度节省: ${total_savings:.2f}")
        print(f"年度节省: ${total_savings * 12:.2f}")
        print("=" * 60)

        return total_savings

    def analyze_costs(self):
        """分析成本构成"""
        ce = self.session.client('ce')

        response = ce.get_cost_and_usage(
            TimePeriod={
                'Start': (datetime.now() - timedelta(days=30)).strftime('%Y-%m-%d'),
                'End': datetime.now().strftime('%Y-%m-%d')
            },
            Granularity='MONTHLY',
            Metrics=['UnblendedCost'],
            GroupBy=[{'Type': 'DIMENSION', 'Key': 'SERVICE'}]
        )

        print("过去30天成本分析：")
        for result in response['ResultsByTime']:
            for group in result['Groups']:
                service = group['Keys'][0]
                cost = float(group['Metrics']['UnblendedCost']['Amount'])
                if cost > 0.01:
                    print(f"  {service}: ${cost:.2f}")

        return 0  # 分析不产生节省

    def cleanup_unused(self):
        """清理未使用资源"""
        # 实现清理逻辑
        return 25.0  # 返回预计节省

    def optimize_instances(self):
        """优化实例配置"""
        # 实现优化逻辑
        return 30.0

    def setup_scheduling(self):
        """设置自动调度"""
        # 实现调度逻辑
        return 40.0

    def optimize_storage(self):
        """优化存储配置"""
        # 实现存储优化
        return 15.0

    def setup_monitoring(self):
        """设置成本监控"""
        # 实现监控设置
        return 0

    def generate_report(self):
        """生成优化报告"""
        report = f"""
AWS免费套餐毕业优化报告
生成时间: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}

优化建议优先级：
1. 立即执行：清理未使用资源
2. 本周完成：实例类型优化和调度设置
3. 本月完成：存储优化和折扣计划评估
4. 持续执行：成本监控和定期审查

下一步行动：
- 每周审查成本报告
- 每月优化一次资源配置
- 每季度评估折扣计划
        """

        with open('optimization_report.txt', 'w') as f:
            f.write(report)

        print("报告已生成: optimization_report.txt")
        return 0

# 运行优化器
if __name__ == "__main__":
    optimizer = AWSGraduationOptimizer()
    total_savings = optimizer.run_full_optimization()

import boto3
import time

ec2 = boto3.client('ec2')

def optimize_ebs_volumes():
    """AWS EC2成本优化 - 自动转换gp2到gp3"""

    # 获取所有gp2卷
    volumes = ec2.describe_volumes(
        Filters=[
            {'Name': 'volume-type', 'Values': ['gp2']},
            {'Name': 'status', 'Values': ['in-use', 'available']}
        ]
    )

    total_savings = 0

    for volume in volumes['Volumes']:
        volume_id = volume['VolumeId']
        size = volume['Size']

        # 计算潜在节省
        gp2_cost = size * 0.10  # $0.10 per GB for gp2
        gp3_cost = size * 0.08  # $0.08 per GB for gp3
        savings = gp2_cost - gp3_cost

        print(f"Converting {volume_id} from gp2 to gp3...")

        # 创建快照（安全备份）
        snapshot = ec2.create_snapshot(
            VolumeId=volume_id,
            Description=f'Backup before gp2 to gp3 conversion'
        )

        # 等待快照完成
        waiter = ec2.get_waiter('snapshot_completed')
        waiter.wait(SnapshotIds=[snapshot['SnapshotId']])

        # 修改卷类型
        ec2.modify_volume(
            VolumeId=volume_id,
            VolumeType='gp3',
            Iops=3000,  # gp3 baseline
            Throughput=125  # gp3 baseline MB/s
        )

        total_savings += savings
        print(f"Converted {volume_id}. Monthly savings: ${savings:.2f}")

    print(f"nTotal monthly savings: ${total_savings:.2f}")
    print(f"Annual savings: ${total_savings * 12:.2f}")

# 执行优化
optimize_ebs_volumes()

def setup_snapshot_lifecycle():
    """AWS EC2成本优化 - 自动化快照管理"""

    dlm = boto3.client('dlm')

    # 创建生命周期策略
    policy = {
        'PolicyType': 'EBS_SNAPSHOT_MANAGEMENT',
        'ResourceTypes': ['VOLUME'],
        'TargetTags': [
            {'Key': 'Environment', 'Value': 'Production'}
        ],
        'Schedules': [
            {
                'Name': 'Daily Snapshots',
                'CreateRule': {
                    'Interval': 24,
                    'IntervalUnit': 'HOURS',
                    'Times': ['03:00']
                },
                'RetainRule': {
                    'Count': 7  # 保留7天
                },
                'CopyTags': True
            },
            {
                'Name': 'Weekly Snapshots',
                'CreateRule': {
                    'CronExpression': 'cron(0 3 ? * 1 *)'  # 每周一
                },
                'RetainRule': {
                    'Count': 4  # 保留4周
                }
            }
        ]
    }

    response = dlm.create_lifecycle_policy(
        ExecutionRoleArn='arn:aws:iam::account:role/AWSDataLifecycleManagerRole',
        Description='Optimized snapshot policy for cost reduction',
        State='ENABLED',
        PolicyDetails=policy
    )

    print(f"Lifecycle policy created: {response['PolicyId']}")

# 清理旧快照
def cleanup_old_snapshots(days_to_keep=30):
    """删除超过指定天数的快照"""

    ec2 = boto3.client('ec2')
    account_id = boto3.client('sts').get_caller_identity()['Account']

    snapshots = ec2.describe_snapshots(
        OwnerIds=[account_id],
        Filters=[
            {'Name': 'status', 'Values': ['completed']}
        ]
    )

    cutoff_date = datetime.now(timezone.utc) - timedelta(days=days_to_keep)
    deleted_count = 0
    saved_gb = 0

    for snapshot in snapshots['Snapshots']:
        if snapshot['StartTime'] < cutoff_date:
            try:
                ec2.delete_snapshot(SnapshotId=snapshot['SnapshotId'])
                deleted_count += 1
                saved_gb += snapshot.get('VolumeSize', 0)
            except Exception as e:
                print(f"Error deleting {snapshot['SnapshotId']}: {e}")

    monthly_savings = saved_gb * 0.05  # $0.05 per GB-month
    print(f"Deleted {deleted_count} snapshots")
    print(f"Freed {saved_gb} GB")
    print(f"Monthly savings: ${monthly_savings:.2f}")

def create_vpc_endpoints():
    """AWS EC2成本优化 - 创建VPC端点避免数据传输费"""

    ec2 = boto3.client('ec2')

    # 获取VPC信息
    vpcs = ec2.describe_vpcs()

    for vpc in vpcs['Vpcs']:
        vpc_id = vpc['VpcId']

        # 创建S3端点（网关端点，免费）
        try:
            s3_endpoint = ec2.create_vpc_endpoint(
                VpcId=vpc_id,
                ServiceName='com.amazonaws.region.s3',
                RouteTableIds=get_route_tables(vpc_id)
            )
            print(f"Created S3 endpoint for VPC {vpc_id}")
        except Exception as e:
            print(f"S3 endpoint may already exist: {e}")

        # 创建其他服务端点
        services = [
            'com.amazonaws.region.ec2',
            'com.amazonaws.region.rds',
            'com.amazonaws.region.lambda'
        ]

        for service in services:
            try:
                endpoint = ec2.create_vpc_endpoint(
                    VpcId=vpc_id,
                    ServiceName=service,
                    VpcEndpointType='Interface',
                    SubnetIds=get_private_subnets(vpc_id),
                    SecurityGroupIds=get_security_groups(vpc_id)
                )
                print(f"Created {service} endpoint for VPC {vpc_id}")
            except Exception as e:
                print(f"Error creating {service} endpoint: {e}")

def optimize_cross_az_traffic():
    """将相关资源迁移到同一可用区"""

    ec2 = boto3.client('ec2')
    elb = boto3.client('elbv2')

    # 分析当前流量模式
    instances = ec2.describe_instances(
        Filters=[
            {'Name': 'instance-state-name', 'Values': ['running']}
        ]
    )

    az_distribution = {}

    for reservation in instances['Reservations']:
        for instance in reservation['Instances']:
            az = instance['Placement']['AvailabilityZone']
            if az not in az_distribution:
                az_distribution[az] = []
            az_distribution[az].append(instance['InstanceId'])

    # 找出最优AZ（实例最多的）
    optimal_az = max(az_distribution, key=lambda x: len(az_distribution[x]))

    print(f"Optimal AZ: {optimal_az}")
    print(f"Current distribution: {az_distribution}")

    # 计算迁移后的节省
    cross_az_gb = estimate_cross_az_traffic()  # 自定义函数
    monthly_savings = cross_az_gb * 0.01

    print(f"Estimated monthly savings: ${monthly_savings:.2f}")

    return optimal_az, az_distribution

def deploy_nat_instance():
    """AWS EC2成本优化 - 部署NAT实例替代NAT网关"""

    ec2 = boto3.client('ec2')

    # 查找最新的Amazon Linux 2 AMI
    ami_response = ec2.describe_images(
        Owners=['amazon'],
        Filters=[
            {'Name': 'name', 'Values': ['amzn2-ami-hvm-*']},
            {'Name': 'architecture', 'Values': ['x86_64']}
        ]
    )

    latest_ami = sorted(
        ami_response['Images'],
        key=lambda x: x['CreationDate'],
        reverse=True
    )[0]['ImageId']

    # NAT实例用户数据脚本
    user_data = '''#!/bin/bash
    yum update -y
    echo "net.ipv4.ip_forward = 1" >> /etc/sysctl.conf
    sysctl -p

    # 配置iptables
    iptables -t nat -A POSTROUTING -o eth0 -j MASQUERADE
    iptables-save > /etc/sysconfig/iptables

    # 禁用源/目标检查
    TOKEN=`curl -X PUT "http://169.254.169.254/latest/api/token" -H "X-aws-ec2-metadata-token-ttl-seconds: 21600"`
    INSTANCE_ID=`curl -H "X-aws-ec2-metadata-token: $TOKEN" http://169.254.169.254/latest/meta-data/instance-id`
    aws ec2 modify-instance-attribute --instance-id $INSTANCE_ID --no-source-dest-check --region us-east-1
    '''

    # 启动NAT实例
    response = ec2.run_instances(
        ImageId=latest_ami,
        InstanceType='t3.medium',  # 可根据流量调整
        MinCount=1,
        MaxCount=1,
        KeyName='your-key-pair',
        SecurityGroupIds=['sg-nat-instance'],
        SubnetId='subnet-public',
        UserData=user_data,
        TagSpecifications=[
            {
                'ResourceType': 'instance',
                'Tags': [
                    {'Key': 'Name', 'Value': 'NAT-Instance'},
                    {'Key': 'Type', 'Value': 'NAT'}
                ]
            }
        ],
        # 使用Spot实例进一步节省
        InstanceMarketOptions={
            'MarketType': 'spot',
            'SpotOptions': {
                'SpotInstanceType': 'persistent',
                'InstanceInterruptionBehavior': 'stop'
            }
        }
    )

    instance_id = response['Instances'][0]['InstanceId']

    # 更新路由表
    update_route_tables_for_nat(instance_id)

    print(f"NAT Instance deployed: {instance_id}")
    print("Estimated monthly savings: $50-100")

    return instance_id

def cleanup_unused_eips():
    """AWS EC2成本优化 - 清理未使用的弹性IP"""

    ec2 = boto3.client('ec2')

    # 获取所有弹性IP
    eips = ec2.describe_addresses()

    unused_eips = []
    total_savings = 0

    for eip in eips['Addresses']:
        if 'InstanceId' not in eip and 'NetworkInterfaceId' not in eip:
            unused_eips.append(eip)
            # 每个未使用的EIP每月费用约$3.6
            total_savings += 3.6

    print(f"Found {len(unused_eips)} unused Elastic IPs")
    print(f"Monthly cost: ${total_savings:.2f}")

    if unused_eips:
        response = input("Release unused EIPs? (yes/no): ")
        if response.lower() == 'yes':
            for eip in unused_eips:
                try:
                    if 'AllocationId' in eip:
                        # VPC EIP
                        ec2.release_address(AllocationId=eip['AllocationId'])
                    else:
                        # EC2-Classic EIP
                        ec2.release_address(PublicIp=eip['PublicIp'])
                    print(f"Released: {eip.get('PublicIp', 'N/A')}")
                except Exception as e:
                    print(f"Error releasing EIP: {e}")

            print(f"nTotal monthly savings: ${total_savings:.2f}")
            print(f"Annual savings: ${total_savings * 12:.2f}")

def consolidate_load_balancers():
    """AWS EC2成本优化 - 整合负载均衡器"""

    elb = boto3.client('elbv2')

    # 获取所有ALB
    load_balancers = elb.describe_load_balancers()

    # 分析使用率
    underutilized_albs = []

    for lb in load_balancers['LoadBalancers']:
        lb_arn = lb['LoadBalancerArn']

        # 获取目标组
        target_groups = elb.describe_target_groups(
            LoadBalancerArn=lb_arn
        )

        total_targets = 0
        for tg in target_groups['TargetGroups']:
            targets = elb.describe_target_health(
                TargetGroupArn=tg['TargetGroupArn']
            )
            total_targets += len(targets['TargetHealthDescriptions'])

        # 如果目标少于3个，标记为未充分利用
        if total_targets < 3:
            underutilized_albs.append({
                'Name': lb['LoadBalancerName'],
                'Targets': total_targets,
                'MonthlyCost': 18  # ALB基础费用
            })

    if underutilized_albs:
        print("Underutilized ALBs found:")
        total_savings = 0
        for alb in underutilized_albs:
            print(f"- {alb['Name']}: {alb['Targets']} targets")
            total_savings += alb['MonthlyCost']

        print(f"nPotential monthly savings by consolidation: ${total_savings:.2f}")

        # 建议整合方案
        print("nRecommendation: Use path-based routing on a single ALB")
        print("Implementation: Create multiple target groups with path patterns")

    return underutilized_albs

class EC2CostOptimizer:
    """AWS EC2成本优化 - EC2-Other综合优化器"""

    def __init__(self):
        self.ec2 = boto3.client('ec2')
        self.cw = boto3.client('cloudwatch')
        self.ce = boto3.client('ce')

    def analyze_ec2_other_costs(self):
        """分析EC2-Other成本构成"""

        end_date = datetime.now().date()
        start_date = end_date - timedelta(days=30)

        response = self.ce.get_cost_and_usage(
            TimePeriod={
                'Start': start_date.isoformat(),
                'End': end_date.isoformat()
            },
            Granularity='MONTHLY',
            Metrics=['UnblendedCost'],
            GroupBy=[
                {'Type': 'DIMENSION', 'Key': 'USAGE_TYPE'}
            ],
            Filter={
                'Dimensions': {
                    'Key': 'SERVICE',
                    'Values': ['Amazon Elastic Compute Cloud - Compute']
                }
            }
        )

        ec2_other_breakdown = {}

        for result in response['ResultsByTime']:
            for group in result['Groups']:
                usage_type = group['Keys'][0]
                cost = float(group['Metrics']['UnblendedCost']['Amount'])

                if 'EBS' in usage_type:
                    category = 'EBS'
                elif 'DataTransfer' in usage_type:
                    category = 'Data Transfer'
                elif 'ElasticIP' in usage_type:
                    category = 'Elastic IP'
                elif 'NatGateway' in usage_type:
                    category = 'NAT Gateway'
                elif 'LoadBalancer' in usage_type:
                    category = 'Load Balancer'
                else:
                    category = 'Other'

                if category not in ec2_other_breakdown:
                    ec2_other_breakdown[category] = 0
                ec2_other_breakdown[category] += cost

        return ec2_other_breakdown

    def generate_optimization_report(self):
        """生成优化报告和建议"""

        costs = self.analyze_ec2_other_costs()
        recommendations = []
        total_savings = 0

        # EBS优化建议
        if costs.get('EBS', 0) > 100:
            savings = costs['EBS'] * 0.3  # 预计节省30%
            recommendations.append({
                'Category': 'EBS',
                'Current Cost': costs['EBS'],
                'Potential Savings': savings,
                'Actions': [
                    'Convert gp2 to gp3',
                    'Delete unattached volumes',
                    'Implement snapshot lifecycle',
                    'Use appropriate volume types'
                ]
            })
            total_savings += savings

        # 数据传输优化建议
        if costs.get('Data Transfer', 0) > 50:
            savings = costs['Data Transfer'] * 0.4
            recommendations.append({
                'Category': 'Data Transfer',
                'Current Cost': costs['Data Transfer'],
                'Potential Savings': savings,
                'Actions': [
                    'Create VPC endpoints',
                    'Optimize cross-AZ traffic',
                    'Use CloudFront for static content',
                    'Implement data compression'
                ]
            })
            total_savings += savings

        # 生成报告
        print("=" * 60)
        print("AWS EC2 COST OPTIMIZATION REPORT - EC2-OTHER ANALYSIS")
        print("=" * 60)
        print(f"nCurrent EC2-Other Monthly Costs:")
        for category, cost in costs.items():
            print(f"  {category}: ${cost:.2f}")

        print(f"nTotal EC2-Other: ${sum(costs.values()):.2f}")

        print("nOptimization Recommendations:")
        for rec in recommendations:
            print(f"n{rec['Category']}:")
            print(f"  Current: ${rec['Current Cost']:.2f}")
            print(f"  Potential Savings: ${rec['Potential Savings']:.2f}")
            print("  Actions:")
            for action in rec['Actions']:
                print(f"    - {action}")

        print(f"n" + "=" * 60)
        print(f"TOTAL POTENTIAL MONTHLY SAVINGS: ${total_savings:.2f}")
        print(f"ANNUAL SAVINGS: ${total_savings * 12:.2f}")
        print("=" * 60)

        return recommendations

    def execute_optimizations(self, auto_apply=False):
        """执行优化操作"""

        optimizations = [
            ('EBS Volume Type Optimization', self.optimize_ebs_volumes),
            ('Unused EIP Cleanup', self.cleanup_unused_eips),
            ('Snapshot Cleanup', self.cleanup_old_snapshots),
            ('VPC Endpoint Creation', self.create_vpc_endpoints),
            ('Load Balancer Consolidation', self.consolidate_load_balancers)
        ]

        for name, func in optimizations:
            print(f"nExecuting: {name}")
            if auto_apply:
                func()
            else:
                response = input(f"Apply {name}? (yes/no): ")
                if response.lower() == 'yes':
                    func()

# 使用示例
if __name__ == "__main__":
    optimizer = EC2CostOptimizer()

    # 生成分析报告
    optimizer.generate_optimization_report()

    # 执行优化
    optimizer.execute_optimizations(auto_apply=False)

def setup_cost_monitoring():
    """设置EC2-Other成本监控"""

    cw = boto3.client('cloudwatch')

    # 创建自定义仪表板
    dashboard_body = {
        "widgets": [
            {
                "type": "metric",
                "properties": {
                    "metrics": [
                        ["AWS/Billing", "EstimatedCharges", 
                         {"stat": "Maximum", "label": "Total Cost"}],
                        ["...", {"stat": "Maximum", "label": "EC2-Other"}]
                    ],
                    "period": 86400,
                    "stat": "Maximum",
                    "region": "us-east-1",
                    "title": "EC2-Other Cost Trend"
                }
            }
        ]
    }

    cw.put_dashboard(
        DashboardName='EC2-Other-Optimization',
        DashboardBody=json.dumps(dashboard_body)
    )

    # 设置成本异常告警
    cw.put_metric_alarm(
        AlarmName='EC2-Other-Cost-Spike',
        ComparisonOperator='GreaterThanThreshold',
        EvaluationPeriods=1,
        MetricName='EstimatedCharges',
        Namespace='AWS/Billing',
        Period=86400,
        Statistic='Maximum',
        Threshold=500.0,  # 根据实际情况调整
        ActionsEnabled=True,
        AlarmActions=['arn:aws:sns:region:account:topic'],
        AlarmDescription='Alert when EC2-Other costs spike'
    )

# Auto-scaling configuration for startups
{
  "AutoScalingGroup": {
    "MinSize": 1,
    "MaxSize": 10,
    "DesiredCapacity": 2,
    "TargetGroupARNs": ["production-target-group"],
    "MixedInstancesPolicy": {
      "InstancesDistribution": {
        "OnDemandPercentageAboveBaseCapacity": 30,
        "SpotAllocationStrategy": "lowest-price"
      }
    }
  }
}
# Result: 60% cost reduction with high availability

# Lambda function for dev environment scheduling
import boto3

def lambda_handler(event, context):
    ec2 = boto3.client('ec2')

    # Stop dev instances at 7 PM
    if event['action'] == 'stop':
        ec2.stop_instances(
            InstanceIds=get_tagged_instances('Environment', 'Development')
        )

    # Start dev instances at 7 AM
    elif event['action'] == 'start':
        ec2.start_instances(
            InstanceIds=get_tagged_instances('Environment', 'Development')
        )

    return {'statusCode': 200}

# Savings: 75% on development environment costs

# Cost optimization automation starter
{
  "CloudFormation": "cost-optimized-templates/",
  "Terraform": "terraform-aws-modules/",
  "Scripts": {
    "unused-resources": "cleanup-script.py",
    "right-sizing": "resize-recommendations.py",
    "scheduling": "start-stop-scheduler.py",
    "reporting": "cost-report-generator.py"
  }
}