{
  "Rules": [
    {
      "ID": "DataLakeLifecycle",
      "Status": "Enabled",
      "Filter": { "Prefix": "data-lake/" },
      "Transitions": [
        { "Days": 30, "StorageClass": "STANDARD_IA" },
        { "Days": 90, "StorageClass": "GLACIER" },
        { "Days": 365, "StorageClass": "DEEP_ARCHIVE" }
      ],
      "Expiration": { "Days": 2555 }
    }
  ]
}

import boto3
from datetime import datetime, timedelta
from typing import Dict, List

class CostOptimizer:
    """Production cost monitoring and optimization."""

    def __init__(self, region: str = 'us-east-1'):
        self.ce = boto3.client('cost-explorer', region_name=region)
        self.s3 = boto3.client('s3', region_name=region)
        self.glue = boto3.client('glue', region_name=region)

    def get_service_costs(
        self,
        days: int = 30,
        services: List[str] = None
    ) -> Dict:
        """Get cost breakdown by service."""
        if services is None:
            services = ['AWS Glue', 'Amazon Redshift', 'AWS Lambda', 'Amazon S3']

        end_date = datetime.now().strftime('%Y-%m-%d')
        start_date = (datetime.now() - timedelta(days=days)).strftime('%Y-%m-%d')

        try:
            response = self.ce.get_cost_and_usage(
                TimePeriod={'Start': start_date, 'End': end_date},
                Granularity='MONTHLY',
                Metrics=['BlendedCost'],
                GroupBy=[
                    {'Type': 'DIMENSION', 'Key': 'SERVICE'}
                ]
            )

            costs = {}
            for result in response['ResultsByTime']:
                for group in result['Groups']:
                    service = group['Keys'][0]
                    amount = float(group['Metrics']['BlendedCost']['Amount'])
                    costs[service] = costs.get(service, 0) + amount

            return costs
        except Exception as e:
            print(f"Error getting costs: {e}")
            return {}

    def analyze_s3_storage(self, bucket_name: str) -> Dict:
        """Analyze S3 storage distribution for optimization."""
        try:
            response = self.s3.list_objects_v2(Bucket=bucket_name, MaxKeys=1000)

            storage_classes = {}
            total_size = 0

            for obj in response.get('Contents', []):
                size = obj['Size']
                storage_class = obj['StorageClass']
                total_size += size
                storage_classes[storage_class] = storage_classes.get(storage_class, 0) + size

            return {
                'total_size_gb': total_size / (1024**3),
                'storage_classes': {
                    k: {'bytes': v, 'gb': v / (1024**3)}
                    for k, v in storage_classes.items()
                }
            }
        except Exception as e:
            print(f"Error analyzing S3: {e}")
            return {}

    def get_glue_job_costs(self, days: int = 30) -> List[Dict]:
        """Get Glue job cost breakdown."""
        try:
            response = self.glue.get_jobs()
            jobs = response['Jobs']

            job_costs = []
            for job in jobs:
                name = job['Name']
                # Estimate based on allocated workers
                workers = job.get('NumberOfWorkers', 10)
                worker_type = job.get('WorkerType', 'Standard')
                dpus = workers * 4 if worker_type == 'Standard' else workers

                job_costs.append({
                    'name': name,
                    'workers': workers,
                    'worker_type': worker_type,
                    'estimated_dpus': dpus
                })

            return job_costs
        except Exception as e:
            print(f"Error getting Glue costs: {e}")
            return []

    def create_budget_alert(
        self,
        budget_name: str,
        limit: float,
        email: str
    ) -> bool:
        """Create a budget alert for data engineering costs."""
        budget_client = boto3.client('budgets')

        try:
            budget_client.create_budget(
                AccountId=boto3.client('sts').get_caller_identity()['Account'],
                Budget={
                    'BudgetName': budget_name,
                    'BudgetLimit': {
                        'Amount': str(limit),
                        'Unit': 'USD'
                    },
                    'TimeUnit': 'MONTHLY',
                    'BudgetType': 'COST',
                    'CostFilters': {
                        'TagKeyValue': [
                            'user:Team$DataEngineering'
                        ]
                    }
                },
                NotificationsWithSubscribers=[
                    {
                        'Notification': {
                            'NotificationType': 'ACTUAL',
                            'ComparisonOperator': 'GREATER_THAN',
                            'Threshold': 80,
                            'ThresholdType': 'PERCENTAGE'
                        },
                        'Subscribers': [
                            {
                                'SubscriptionType': 'EMAIL',
                                'Address': email
                            }
                        ]
                    }
                ]
            )
            print(f"Created budget alert: {budget_name}")
            return True
        except Exception as e:
            print(f"Error creating budget: {e}")
            return False


# Usage
if __name__ == '__main__':
    optimizer = CostOptimizer()

    # Get service costs
    costs = optimizer.get_service_costs(days=30)
    for service, cost in sorted(costs.items(), key=lambda x: -x[1]):
        print(f"{service}: ${cost:.2f}")

    # Analyze S3 storage
    s3_analysis = optimizer.analyze_s3_storage('my-data-lake')
    print(f"Total storage: {s3_analysis.get('total_size_gb', 0):.2f} GB")

    # Get Glue job costs
    glue_jobs = optimizer.get_glue_job_costs()
    for job in glue_jobs:
        print(f"{job['name']}: {job['estimated_dpus']} DPUs")

    # Create budget alert
    optimizer.create_budget_alert(
        budget_name='DataEngineering-Monthly',
        limit=10000,
        email='data-team@company.com'
    )