# S3 Intelligent-Tiering 配置示例
import boto3
from datetime import datetime

s3_client = boto3.client('s3')

def setup_intelligent_tiering(bucket_name):
    # 配置智能分层
    configuration = {
        'Id': 'OptimizeStorage',
        'Status': 'Enabled',
        'Tierings': [
            {
                'Days': 90,
                'AccessTier': 'ARCHIVE_ACCESS'
            },
            {
                'Days': 180,
                'AccessTier': 'DEEP_ARCHIVE_ACCESS'
            }
        ]
    }

    response = s3_client.put_bucket_intelligent_tiering_configuration(
        Bucket=bucket_name,
        Id='OptimizeStorage',
        IntelligentTieringConfiguration=configuration
    )

    return response

# 监控分层效果
def monitor_tiering_metrics(bucket_name):
    cloudwatch = boto3.client('cloudwatch')

    metrics = cloudwatch.get_metric_statistics(
        Namespace='AWS/S3',
        MetricName='IntelligentTieringObjectCount',
        Dimensions=[
            {'Name': 'BucketName', 'Value': bucket_name},
            {'Name': 'StorageClass', 'Value': 'INTELLIGENT_TIERING'}
        ],
        StartTime=datetime.utcnow() - timedelta(days=7),
        EndTime=datetime.utcnow(),
        Period=86400,
        Statistics=['Average']
    )

    return metrics

{
  "Rules": [
    {
      "Id": "LogsArchival",
      "Status": "Enabled",
      "Prefix": "logs/",
      "Transitions": [
        {
          "Days": 30,
          "StorageClass": "STANDARD_IA"
        },
        {
          "Days": 90,
          "StorageClass": "GLACIER"
        }
      ],
      "Expiration": {
        "Days": 365
      },
      "NoncurrentVersionTransitions": [
        {
          "NoncurrentDays": 7,
          "StorageClass": "STANDARD_IA"
        }
      ],
      "NoncurrentVersionExpiration": {
        "NoncurrentDays": 30
      }
    },
    {
      "Id": "DeleteIncompleteMultipartUploads",
      "Status": "Enabled",
      "AbortIncompleteMultipartUpload": {
        "DaysAfterInitiation": 7
      }
    }
  ]
}

# 批量请求优化示例
class S3RequestOptimizer:
    def __init__(self, bucket_name):
        self.s3_client = boto3.client('s3')
        self.bucket_name = bucket_name

    def batch_upload(self, files, batch_size=1000):
        """批量上传，减少PUT请求数量"""
        for i in range(0, len(files), batch_size):
            batch = files[i:i+batch_size]

            # 使用S3 Transfer Manager进行并发上传
            from concurrent.futures import ThreadPoolExecutor
            with ThreadPoolExecutor(max_workers=10) as executor:
                futures = []
                for file_info in batch:
                    future = executor.submit(
                        self.s3_client.upload_file,
                        file_info['local_path'],
                        self.bucket_name,
                        file_info['s3_key']
                    )
                    futures.append(future)

                # 等待所有上传完成
                for future in futures:
                    future.result()

    def batch_delete(self, keys):
        """批量删除，单次请求最多删除1000个对象"""
        for i in range(0, len(keys), 1000):
            batch = keys[i:i+1000]
            delete_objects = {'Objects': [{'Key': k} for k in batch]}

            self.s3_client.delete_objects(
                Bucket=self.bucket_name,
                Delete=delete_objects
            )

def s3_select_optimization(bucket, key, query):
    """使用S3 Select只获取需要的数据"""
    response = s3_client.select_object_content(
        Bucket=bucket,
        Key=key,
        Expression=query,
        ExpressionType='SQL',
        InputSerialization={
            'JSON': {'Type': 'LINES'},
            'CompressionType': 'GZIP'
        },
        OutputSerialization={'JSON': {}}
    )

    # 只传输查询结果，节省85%+的传输成本
    for event in response['Payload']:
        if 'Records' in event:
            return event['Records']['Payload'].decode('utf-8')

def generate_presigned_post(bucket, key, expiration=3600):
    """生成预签名POST URL，让客户端直接上传到S3"""
    response = s3_client.generate_presigned_post(
        Bucket=bucket,
        Key=key,
        ExpiresIn=expiration,
        Conditions=[
            ["content-length-range", 0, 10485760],  # 限制10MB
            ["starts-with", "$Content-Type", "image/"]
        ]
    )
    return response

class MultipartUploadOptimizer:
    def __init__(self, bucket_name):
        self.s3_client = boto3.client('s3')
        self.bucket_name = bucket_name

    def optimized_multipart_upload(self, file_path, key, part_size=10*1024*1024):
        """优化的分片上传，自动清理失败的上传"""
        file_size = os.path.getsize(file_path)

        # 对于小文件直接上传
        if file_size < part_size:
            with open(file_path, 'rb') as f:
                self.s3_client.put_object(
                    Bucket=self.bucket_name,
                    Key=key,
                    Body=f
                )
            return

        # 创建分片上传
        response = self.s3_client.create_multipart_upload(
            Bucket=self.bucket_name,
            Key=key
        )
        upload_id = response['UploadId']

        parts = []
        try:
            with open(file_path, 'rb') as f:
                part_number = 1
                while True:
                    data = f.read(part_size)
                    if not data:
                        break

                    response = self.s3_client.upload_part(
                        Bucket=self.bucket_name,
                        Key=key,
                        PartNumber=part_number,
                        UploadId=upload_id,
                        Body=data
                    )

                    parts.append({
                        'PartNumber': part_number,
                        'ETag': response['ETag']
                    })
                    part_number += 1

            # 完成上传
            self.s3_client.complete_multipart_upload(
                Bucket=self.bucket_name,
                Key=key,
                UploadId=upload_id,
                MultipartUpload={'Parts': parts}
            )

        except Exception as e:
            # 清理失败的上传
            self.s3_client.abort_multipart_upload(
                Bucket=self.bucket_name,
                Key=key,
                UploadId=upload_id
            )
            raise e

def optimize_versioning(bucket_name):
    """优化版本控制设置"""
    s3_client = boto3.client('s3')

    # 配置版本生命周期
    lifecycle_policy = {
        'Rules': [
            {
                'Id': 'DeleteOldVersions',
                'Status': 'Enabled',
                'NoncurrentVersionTransitions': [
                    {
                        'NoncurrentDays': 30,
                        'StorageClass': 'STANDARD_IA'
                    }
                ],
                'NoncurrentVersionExpiration': {
                    'NoncurrentDays': 90
                }
            }
        ]
    }

    s3_client.put_bucket_lifecycle_configuration(
        Bucket=bucket_name,
        LifecycleConfiguration=lifecycle_policy
    )

// CloudFront Functions 示例：优化缓存键
function handler(event) {
    var request = event.request;
    var headers = request.headers;

    // 规范化User-Agent，提高缓存命中率
    if (headers['user-agent']) {
        var ua = headers['user-agent'].value.toLowerCase();
        if (ua.includes('mobile')) {
            headers['user-agent'].value = 'mobile';
        } else {
            headers['user-agent'].value = 'desktop';
        }
    }

    // 移除不必要的查询参数
    var querystring = request.querystring;
    var allowedParams = ['id', 'version', 'lang'];
    var filteredParams = {};

    for (var param in querystring) {
        if (allowedParams.includes(param)) {
            filteredParams[param] = querystring[param];
        }
    }

    request.querystring = filteredParams;

    return request;
}

def configure_origin_shield(distribution_id):
    """配置Origin Shield以减少回源请求"""
    cloudfront = boto3.client('cloudfront')

    # 获取当前配置
    response = cloudfront.get_distribution_config(Id=distribution_id)
    config = response['DistributionConfig']
    etag = response['ETag']

    # 启用Origin Shield
    for origin in config['Origins']['Items']:
        origin['OriginShield'] = {
            'Enabled': True,
            'OriginShieldRegion': 'us-east-1'  # 选择最近的区域
        }

    # 更新配置
    cloudfront.update_distribution(
        Id=distribution_id,
        DistributionConfig=config,
        IfMatch=etag
    )

# 多层缓存架构配置
architecture:
  layers:
    - name: "Browser Cache"
      ttl: 3600
      storage: "Local Storage / Service Worker"

    - name: "CloudFront Edge"
      ttl: 86400
      locations: 200+ edge locations

    - name: "CloudFront Regional Cache"
      ttl: 604800
      locations: 13 regional caches

    - name: "Origin Shield"
      ttl: 2592000
      location: "Single shield per origin"

    - name: "Application Cache"
      ttl: 300
      technology: "Redis/Memcached"

    - name: "Database Cache"
      ttl: 60
      technology: "Query Result Cache"

def enable_compression(distribution_id):
    """启用CloudFront自动压缩"""
    cloudfront = boto3.client('cloudfront')

    response = cloudfront.get_distribution_config(Id=distribution_id)
    config = response['DistributionConfig']
    etag = response['ETag']

    # 为所有缓存行为启用压缩
    if 'CacheBehaviors' in config:
        for behavior in config['CacheBehaviors']['Items']:
            behavior['Compress'] = True

    config['DefaultCacheBehavior']['Compress'] = True

    cloudfront.update_distribution(
        Id=distribution_id,
        DistributionConfig=config,
        IfMatch=etag
    )

// Lambda@Edge 图片优化
'use strict';

const querystring = require('querystring');
const AWS = require('aws-sdk');
const Sharp = require('sharp');

exports.handler = async (event) => {
    const request = event.Records[0].cf.request;
    const response = event.Records[0].cf.response;

    // 检查是否需要优化
    if (response.status !== '200') {
        return response;
    }

    const params = querystring.parse(request.querystring);

    // 根据设备类型优化图片
    const deviceType = request.headers['cloudfront-is-mobile-viewer'] 
        ? 'mobile' : 'desktop';

    if (params.auto === 'compress') {
        const s3 = new AWS.S3();
        const bucket = 'your-bucket';
        const key = request.uri.substring(1);

        // 获取原始图片
        const image = await s3.getObject({
            Bucket: bucket,
            Key: key
        }).promise();

        // 优化图片
        let optimized;
        if (deviceType === 'mobile') {
            optimized = await Sharp(image.Body)
                .resize(800)
                .webp({ quality: 80 })
                .toBuffer();
        } else {
            optimized = await Sharp(image.Body)
                .resize(1920)
                .webp({ quality: 90 })
                .toBuffer();
        }

        // 返回优化后的图片
        response.body = optimized.toString('base64');
        response.bodyEncoding = 'base64';
        response.headers['content-type'] = [
            { key: 'Content-Type', value: 'image/webp' }
        ];
    }

    return response;
};

def setup_cost_monitoring(distribution_id):
    """设置CloudFront成本监控和告警"""
    cloudwatch = boto3.client('cloudwatch')

    # 创建成本异常告警
    cloudwatch.put_metric_alarm(
        AlarmName=f'CloudFront-{distribution_id}-HighCost',
        ComparisonOperator='GreaterThanThreshold',
        EvaluationPeriods=1,
        MetricName='EstimatedCharges',
        Namespace='AWS/Billing',
        Period=86400,
        Statistic='Maximum',
        Threshold=1000.0,  # $1000 USD
        ActionsEnabled=True,
        AlarmActions=['arn:aws:sns:us-east-1:xxx:cost-alerts'],
        AlarmDescription='Alert when CloudFront costs exceed $1000',
        Dimensions=[
            {
                'Name': 'Currency',
                'Value': 'USD'
            },
            {
                'Name': 'ServiceName',
                'Value': 'CloudFront'
            }
        ]
    )

    # 创建请求数量告警
    cloudwatch.put_metric_alarm(
        AlarmName=f'CloudFront-{distribution_id}-HighRequests',
        ComparisonOperator='GreaterThanThreshold',
        EvaluationPeriods=2,
        MetricName='Requests',
        Namespace='AWS/CloudFront',
        Period=300,
        Statistic='Sum',
        Threshold=1000000,  # 1M requests in 5 minutes
        ActionsEnabled=True,
        AlarmActions=['arn:aws:sns:us-east-1:xxx:traffic-alerts'],
        AlarmDescription='Alert on unusual traffic spike',
        Dimensions=[
            {
                'Name': 'DistributionId',
                'Value': distribution_id
            }
        ]
    )

class SaaSOptimizer:
    def __init__(self):
        self.s3 = boto3.client('s3')
        self.cloudfront = boto3.client('cloudfront')

    def optimize_user_content(self, bucket_name):
        """优化用户上传内容存储"""
        # 1. 设置智能分层
        self.s3.put_bucket_intelligent_tiering_configuration(
            Bucket=bucket_name,
            Id='UserContent',
            IntelligentTieringConfiguration={
                'Id': 'UserContent',
                'Status': 'Enabled',
                'Tierings': [
                    {'Days': 90, 'AccessTier': 'ARCHIVE_ACCESS'},
                    {'Days': 180, 'AccessTier': 'DEEP_ARCHIVE_ACCESS'}
                ],
                'Filter': {'Prefix': 'user-uploads/'}
            }
        )

        # 2. 配置生命周期
        self.s3.put_bucket_lifecycle_configuration(
            Bucket=bucket_name,
            LifecycleConfiguration={
                'Rules': [
                    {
                        'Id': 'DeleteTempFiles',
                        'Status': 'Enabled',
                        'Prefix': 'temp/',
                        'Expiration': {'Days': 1}
                    },
                    {
                        'Id': 'ArchiveOldData',
                        'Status': 'Enabled',
                        'Transitions': [
                            {'Days': 30, 'StorageClass': 'STANDARD_IA'},
                            {'Days': 90, 'StorageClass': 'GLACIER'},
                            {'Days': 365, 'StorageClass': 'DEEP_ARCHIVE'}
                        ]
                    }
                ]
            }
        )

    def optimize_api_caching(self, distribution_id):
        """优化API响应缓存"""
        config = {
            'PathPattern': '/api/*',
            'TargetOriginId': 'api-origin',
            'ViewerProtocolPolicy': 'https-only',
            'CachePolicyId': 'custom-api-cache',
            'CacheBehaviors': {
                'Quantity': 1,
                'Items': [
                    {
                        'PathPattern': '/api/static/*',
                        'MinTTL': 86400,
                        'DefaultTTL': 604800,
                        'MaxTTL': 31536000
                    }
                ]
            }
        }

        return config

class S3CloudFrontCostCalculator:
    """S3和CloudFront成本计算器"""

    # 定价（2024年，美东区域）
    PRICING = {
        's3_storage': {
            'STANDARD': 0.023,  # per GB
            'STANDARD_IA': 0.0125,
            'ONEZONE_IA': 0.01,
            'GLACIER_IR': 0.004,
            'GLACIER_FLEXIBLE': 0.0036,
            'GLACIER_DEEP': 0.00099
        },
        's3_requests': {
            'PUT': 0.005,  # per 1000 requests
            'GET': 0.0004,
            'LIST': 0.005,
            'DELETE': 0.0
        },
        'cloudfront_transfer': {
            'first_10tb': 0.085,  # per GB
            'next_40tb': 0.080,
            'next_100tb': 0.060,
            'next_350tb': 0.040,
            'above_500tb': 0.030
        },
        'cloudfront_requests': {
            'http': 0.0075,  # per 10000 requests
            'https': 0.010
        }
    }

    def calculate_s3_cost(self, storage_gb, storage_class='STANDARD', 
                         put_requests=0, get_requests=0):
        """计算S3成本"""
        storage_cost = storage_gb * self.PRICING['s3_storage'][storage_class]
        request_cost = (
            (put_requests / 1000) * self.PRICING['s3_requests']['PUT'] +
            (get_requests / 1000) * self.PRICING['s3_requests']['GET']
        )

        return {
            'storage_cost': storage_cost,
            'request_cost': request_cost,
            'total': storage_cost + request_cost
        }

    def calculate_cloudfront_cost(self, transfer_gb, requests_millions, 
                                 use_https=True):
        """计算CloudFront成本"""
        # 计算传输成本（分层定价）
        transfer_cost = 0
        remaining = transfer_gb

        if remaining > 0:
            tier1 = min(remaining, 10240)  # 10TB
            transfer_cost += tier1 * self.PRICING['cloudfront_transfer']['first_10tb']
            remaining -= tier1

        if remaining > 0:
            tier2 = min(remaining, 40960)  # 40TB
            transfer_cost += tier2 * self.PRICING['cloudfront_transfer']['next_40tb']
            remaining -= tier2

        if remaining > 0:
            tier3 = min(remaining, 102400)  # 100TB
            transfer_cost += tier3 * self.PRICING['cloudfront_transfer']['next_100tb']
            remaining -= tier3

        # 计算请求成本
        request_type = 'https' if use_https else 'http'
        request_cost = (requests_millions * 1000000 / 10000) * \
                      self.PRICING['cloudfront_requests'][request_type]

        return {
            'transfer_cost': transfer_cost,
            'request_cost': request_cost,
            'total': transfer_cost + request_cost
        }

    def optimization_recommendations(self, current_usage):
        """生成优化建议"""
        recommendations = []
        potential_savings = 0

        # 检查存储优化机会
        if current_usage['s3_storage_class'] == 'STANDARD':
            if current_usage['access_frequency'] < 1:  # 每月访问少于1次
                savings = current_usage['s3_storage_gb'] * 0.015  # 约65%节省
                potential_savings += savings
                recommendations.append({
                    'action': '启用Intelligent-Tiering',
                    'savings': f'${savings:.2f}/月',
                    'effort': '低'
                })

        # 检查缓存优化机会
        if current_usage.get('cache_hit_ratio', 0) < 0.8:
            current_transfer = current_usage.get('cloudfront_transfer_gb', 0)
            optimized_transfer = current_transfer * 0.6  # 假设可减少40%
            savings = (current_transfer - optimized_transfer) * 0.085
            potential_savings += savings
            recommendations.append({
                'action': '优化缓存策略',
                'savings': f'${savings:.2f}/月',
                'effort': '中'
            })

        return {
            'recommendations': recommendations,
            'total_potential_savings': f'${potential_savings:.2f}/月'
        }

# 使用示例
calculator = S3CloudFrontCostCalculator()

# 计算当前成本
current_cost = {
    's3': calculator.calculate_s3_cost(
        storage_gb=10000,  # 10TB
        storage_class='STANDARD',
        put_requests=1000000,
        get_requests=10000000
    ),
    'cloudfront': calculator.calculate_cloudfront_cost(
        transfer_gb=5000,  # 5TB
        requests_millions=100,
        use_https=True
    )
}

print(f"当前月度成本：")
print(f"S3: ${current_cost['s3']['total']:.2f}")
print(f"CloudFront: ${current_cost['cloudfront']['total']:.2f}")
print(f"总计: ${current_cost['s3']['total'] + current_cost['cloudfront']['total']:.2f}")

# 获取优化建议
usage_profile = {
    's3_storage_gb': 10000,
    's3_storage_class': 'STANDARD',
    'access_frequency': 0.5,
    'cache_hit_ratio': 0.6,
    'cloudfront_transfer_gb': 5000
}

recommendations = calculator.optimization_recommendations(usage_profile)
print(f"\n优化建议：")
for rec in recommendations['recommendations']:
    print(f"- {rec['action']}: 预计节省 {rec['savings']}")
print(f"\n总潜在节省: {recommendations['total_potential_savings']}")