# ワークロード分析の例
workload_analysis = {
    "cpu_utilization": {
        "average": 45,  # %
        "peak": 85,     # %
        "pattern": "burst"  # steady, burst, periodic
    },
    "memory_usage": {
        "average": 4.2,  # GB
        "peak": 6.8,     # GB
        "cache_ratio": 0.6  # データキャッシュ比率
    },
    "network": {
        "throughput": 150,  # Mbps
        "connections": 1000,  # concurrent
        "latency_sensitive": True
    },
    "storage": {
        "iops": 1500,      # IOPS
        "throughput": 50,   # MB/s
        "capacity": 100     # GB
    }
}

# コスト最適化の計算例
def calculate_instance_cost(instance_type, hours_per_month=730):
    prices = {
        "m6i.large": 0.096,
        "m6i.xlarge": 0.192,
        "c6i.large": 0.085,
        "r6i.large": 0.126
    }
    
    monthly_cost = prices[instance_type] * hours_per_month
    return monthly_cost

# 使用例
instances = ["m6i.large", "m6i.xlarge", "c6i.large", "r6i.large"]
for instance in instances:
    cost = calculate_instance_cost(instance)
    print(f"{instance}: ${cost:.2f}/month")

# キャパシティプランニングの例
import math

def calculate_capacity_requirements(business_metrics):
    """
    ビジネスメトリクスからキャパシティ要件を計算
    """
    # 基本メトリクス
    daily_users = business_metrics['daily_active_users']
    peak_concurrency_ratio = business_metrics['peak_concurrency_ratio']
    growth_rate = business_metrics['annual_growth_rate']
    
    # 現在の要件計算
    current_peak_users = daily_users * peak_concurrency_ratio
    
    # 成長を考慮した将来要件
    planning_horizon = 2  # 2年間
    future_peak_users = current_peak_users * (1 + growth_rate) ** planning_horizon
    
    # リソース要件の計算
    cpu_per_user = 0.1  # vCPU/user
    memory_per_user = 0.25  # GB/user
    
    required_vcpu = math.ceil(future_peak_users * cpu_per_user)
    required_memory = math.ceil(future_peak_users * memory_per_user)
    
    # 冗長性とバッファーを考慮
    redundancy_factor = 2.0  # アクティブ-スタンバイ
    buffer_factor = 1.3  # 30%のバッファー
    
    final_vcpu = math.ceil(required_vcpu * redundancy_factor * buffer_factor)
    final_memory = math.ceil(required_memory * redundancy_factor * buffer_factor)
    
    return {
        'current_peak_users': current_peak_users,
        'future_peak_users': future_peak_users,
        'required_vcpu': final_vcpu,
        'required_memory': final_memory,
        'recommended_instances': calculate_instance_mix(final_vcpu, final_memory)
    }

def calculate_instance_mix(total_vcpu, total_memory):
    """
    必要なリソースから最適なインスタンス構成を計算
    """
    instance_types = {
        'm6i.large': {'vcpu': 2, 'memory': 8, 'cost_per_hour': 0.096},
        'm6i.xlarge': {'vcpu': 4, 'memory': 16, 'cost_per_hour': 0.192},
        'm6i.2xlarge': {'vcpu': 8, 'memory': 32, 'cost_per_hour': 0.384},
        'm6i.4xlarge': {'vcpu': 16, 'memory': 64, 'cost_per_hour': 0.768}
    }
    
    # 最適化アルゴリズム（簡略化）
    best_config = None
    min_cost = float('inf')
    
    for instance_type, specs in instance_types.items():
        # 必要なインスタンス数を計算
        instances_for_cpu = math.ceil(total_vcpu / specs['vcpu'])
        instances_for_memory = math.ceil(total_memory / specs['memory'])
        required_instances = max(instances_for_cpu, instances_for_memory)
        
        # コストを計算
        monthly_cost = required_instances * specs['cost_per_hour'] * 730
        
        if monthly_cost < min_cost:
            min_cost = monthly_cost
            best_config = {
                'instance_type': instance_type,
                'count': required_instances,
                'monthly_cost': monthly_cost,
                'total_vcpu': required_instances * specs['vcpu'],
                'total_memory': required_instances * specs['memory']
            }
    
    return best_config

# 使用例
business_metrics = {
    'daily_active_users': 10000,
    'peak_concurrency_ratio': 0.15,
    'annual_growth_rate': 0.25
}

capacity_plan = calculate_capacity_requirements(business_metrics)
print(f"推奨構成: {capacity_plan['recommended_instances']}")

# monitoring_setup.py
import boto3
import json

def setup_comprehensive_monitoring(instance_id, environment):
    """
    包括的な監視設定を行う
    """
    cloudwatch = boto3.client('cloudwatch')
    
    # カスタムメトリクスの設定
    custom_metrics = [
        {
            'MetricName': 'ApplicationResponseTime',
            'Namespace': f'Custom/{environment}',
            'Dimensions': [
                {
                    'Name': 'InstanceId',
                    'Value': instance_id
                }
            ]
        },
        {
            'MetricName': 'ActiveConnections',
            'Namespace': f'Custom/{environment}',
            'Dimensions': [
                {
                    'Name': 'InstanceId',
                    'Value': instance_id
                }
            ]
        }
    ]
    
    # アラームの設定
    alarms = [
        {
            'AlarmName': f'{environment}-{instance_id}-HighCPU',
            'ComparisonOperator': 'GreaterThanThreshold',
            'EvaluationPeriods': 2,
            'MetricName': 'CPUUtilization',
            'Namespace': 'AWS/EC2',
            'Period': 300,
            'Statistic': 'Average',
            'Threshold': 80.0,
            'ActionsEnabled': True,
            'AlarmActions': [
                'arn:aws:sns:us-east-1:123456789012:high-cpu-alarm'
            ],
            'AlarmDescription': 'High CPU utilization detected',
            'Dimensions': [
                {
                    'Name': 'InstanceId',
                    'Value': instance_id
                }
            ]
        },
        {
            'AlarmName': f'{environment}-{instance_id}-HighMemory',
            'ComparisonOperator': 'GreaterThanThreshold',
            'EvaluationPeriods': 2,
            'MetricName': 'MemoryUtilization',
            'Namespace': 'CWAgent',
            'Period': 300,
            'Statistic': 'Average',
            'Threshold': 85.0,
            'ActionsEnabled': True,
            'AlarmActions': [
                'arn:aws:sns:us-east-1:123456789012:high-memory-alarm'
            ],
            'AlarmDescription': 'High memory utilization detected',
            'Dimensions': [
                {
                    'Name': 'InstanceId',
                    'Value': instance_id
                }
            ]
        },
        {
            'AlarmName': f'{environment}-{instance_id}-DiskSpace',
            'ComparisonOperator': 'GreaterThanThreshold',
            'EvaluationPeriods': 1,
            'MetricName': 'DiskSpaceUtilization',
            'Namespace': 'CWAgent',
            'Period': 300,
            'Statistic': 'Average',
            'Threshold': 90.0,
            'ActionsEnabled': True,
            'AlarmActions': [
                'arn:aws:sns:us-east-1:123456789012:disk-space-alarm'
            ],
            'AlarmDescription': 'Low disk space detected',
            'Dimensions': [
                {
                    'Name': 'InstanceId',
                    'Value': instance_id
                }
            ]
        }
    ]
    
    # アラーム作成
    for alarm in alarms:
        try:
            cloudwatch.put_metric_alarm(**alarm)
            print(f"Created alarm: {alarm['AlarmName']}")
        except Exception as e:
            print(f"Failed to create alarm {alarm['AlarmName']}: {e}")
    
    return True

# 実行例
if __name__ == "__main__":
    instance_id = "i-1234567890abcdef0"
    environment = "production"
    setup_comprehensive_monitoring(instance_id, environment)

# auto_scaling_setup.py
import boto3
import json
from datetime import datetime, timedelta

class AutoScalingManager:
    def __init__(self, region='us-east-1'):
        self.autoscaling = boto3.client('autoscaling', region_name=region)
        self.cloudwatch = boto3.client('cloudwatch', region_name=region)
        
    def create_scaling_policy(self, asg_name, policy_name, policy_type='TargetTrackingScaling'):
        """
        スケーリングポリシーを作成
        """
        if policy_type == 'TargetTrackingScaling':
            # ターゲット追跡スケーリング
            response = self.autoscaling.put_scaling_policy(
                AutoScalingGroupName=asg_name,
                PolicyName=policy_name,
                PolicyType='TargetTrackingScaling',
                TargetTrackingConfiguration={
                    'TargetValue': 70.0,
                    'PredefinedMetricSpecification': {
                        'PredefinedMetricType': 'ASGAverageCPUUtilization'
                    },
                    'ScaleOutCooldown': 300,
                    'ScaleInCooldown': 300
                }
            )
        elif policy_type == 'StepScaling':
            # ステップスケーリング
            response = self.autoscaling.put_scaling_policy(
                AutoScalingGroupName=asg_name,
                PolicyName=policy_name,
                PolicyType='StepScaling',
                AdjustmentType='ChangeInCapacity',
                StepAdjustments=[
                    {
                        'MetricIntervalLowerBound': 0.0,
                        'MetricIntervalUpperBound': 50.0,
                        'ScalingAdjustment': 1
                    },
                    {
                        'MetricIntervalLowerBound': 50.0,
                        'ScalingAdjustment': 2
                    }
                ],
                Cooldown=300
            )
        
        return response['PolicyARN']
    
    def create_scheduled_scaling(self, asg_name, schedule_name, recurrence, min_size, max_size, desired_capacity):
        """
        スケジュールベースのスケーリングを作成
        """
        self.autoscaling.put_scheduled_update_group_action(
            AutoScalingGroupName=asg_name,
            ScheduledActionName=schedule_name,
            Recurrence=recurrence,
            MinSize=min_size,
            MaxSize=max_size,
            DesiredCapacity=desired_capacity
        )
    
    def setup_predictive_scaling(self, asg_name):
        """
        予測スケーリングを設定
        """
        self.autoscaling.put_scaling_policy(
            AutoScalingGroupName=asg_name,
            PolicyName='PredictiveScalingPolicy',
            PolicyType='PredictiveScaling',
            PredictiveScalingConfiguration={
                'MetricSpecifications': [
                    {
                        'TargetValue': 70.0,
                        'PredefinedMetricPairSpecification': {
                            'PredefinedMetricType': 'ASGCPUUtilization'
                        }
                    }
                ],
                'Mode': 'ForecastAndScale',
                'SchedulingBufferTime': 300,
                'MaxCapacityBreachBehavior': 'HonorMaxCapacity',
                'MaxCapacityBuffer': 10
            }
        )
    
    def configure_comprehensive_scaling(self, asg_name, environment):
        """
        包括的なスケーリング設定
        """
        # 1. CPU ベースのターゲット追跡
        cpu_policy_arn = self.create_scaling_policy(
            asg_name, 
            f'{environment}-cpu-target-tracking',
            'TargetTrackingScaling'
        )
        
        # 2. メモリベースのターゲット追跡
        memory_policy_arn = self.autoscaling.put_scaling_policy(
            AutoScalingGroupName=asg_name,
            PolicyName=f'{environment}-memory-target-tracking',
            PolicyType='TargetTrackingScaling',
            TargetTrackingConfiguration={
                'TargetValue': 80.0,
                'CustomizedMetricSpecification': {
                    'MetricName': 'MemoryUtilization',
                    'Namespace': 'CWAgent',
                    'Dimensions': [
                        {
                            'Name': 'AutoScalingGroupName',
                            'Value': asg_name
                        }
                    ],
                    'Statistic': 'Average'
                },
                'ScaleOutCooldown': 300,
                'ScaleInCooldown': 300
            }
        )
        
        # 3. ネットワークベースのターゲット追跡
        network_policy_arn = self.autoscaling.put_scaling_policy(
            AutoScalingGroupName=asg_name,
            PolicyName=f'{environment}-network-target-tracking',
            PolicyType='TargetTrackingScaling',
            TargetTrackingConfiguration={
                'TargetValue': 6000000.0,  # 6MB/s
                'PredefinedMetricSpecification': {
                    'PredefinedMetricType': 'ASGAverageNetworkIn'
                },
                'ScaleOutCooldown': 300,
                'ScaleInCooldown': 300
            }
        )
        
        # 4. スケジュールベースのスケーリング
        # 営業時間の開始（平日 9:00）
        self.create_scheduled_scaling(
            asg_name,
            f'{environment}-scale-up-business-hours',
            '0 9 * * 1-5',  # 平日 9:00 AM
            2, 10, 4
        )
        
        # 営業時間の終了（平日 18:00）
        self.create_scheduled_scaling(
            asg_name,
            f'{environment}-scale-down-after-hours',
            '0 18 * * 1-5',  # 平日 6:00 PM
            1, 6, 2
        )
        
        # 週末の最小構成
        self.create_scheduled_scaling(
            asg_name,
            f'{environment}-scale-down-weekend',
            '0 0 * * 6',  # 土曜日 12:00 AM
            1, 4, 1
        )
        
        # 5. 予測スケーリング（本番環境のみ）
        if environment == 'production':
            self.setup_predictive_scaling(asg_name)
        
        return {
            'cpu_policy_arn': cpu_policy_arn,
            'memory_policy_arn': memory_policy_arn['PolicyARN'],
            'network_policy_arn': network_policy_arn['PolicyARN']
        }

# 使用例
if __name__ == "__main__":
    manager = AutoScalingManager()
    
    # スケーリング設定の適用
    policy_arns = manager.configure_comprehensive_scaling(
        'production-web-asg',
        'production'
    )
    
    print(f"Scaling policies created: {policy_arns}")

# instance_decommission.py
import boto3
import json
import time
from datetime import datetime, timedelta

class InstanceDecommissionManager:
    def __init__(self, region='us-east-1'):
        self.ec2 = boto3.client('ec2', region_name=region)
        self.autoscaling = boto3.client('autoscaling', region_name=region)
        self.elb = boto3.client('elbv2', region_name=region)
        self.cloudwatch = boto3.client('cloudwatch', region_name=region)
        self.sns = boto3.client('sns', region_name=region)
        
    def safe_decommission(self, instance_id, reason='planned_retirement'):
        """
        安全なインスタンス廃止プロセス
        """
        try:
            # 1. インスタンス情報の取得
            instance_info = self.get_instance_info(instance_id)
            
            # 2. 事前チェック
            self.pre_decommission_checks(instance_id, instance_info)
            
            # 3. トラフィック排出
            self.drain_traffic(instance_id, instance_info)
            
            # 4. データバックアップ
            self.backup_instance_data(instance_id, instance_info)
            
            # 5. 監視・アラートの無効化
            self.disable_monitoring(instance_id)
            
            # 6. インスタンスの停止
            self.stop_instance(instance_id)
            
            # 7. 最終確認後の削除
            self.terminate_instance(instance_id, instance_info)
            
            # 8. 後処理
            self.post_decommission_cleanup(instance_id, instance_info)
            
            return True
            
        except Exception as e:
            self.send_notification(
                'Decommission Failed',
                f'Failed to decommission instance {instance_id}: {str(e)}'
            )
            return False
    
    def get_instance_info(self, instance_id):
        """
        インスタンス情報を取得
        """
        response = self.ec2.describe_instances(InstanceIds=[instance_id])
        instance = response['Reservations'][0]['Instances'][0]
        
        # Auto Scaling Group の確認
        asg_name = None
        for tag in instance.get('Tags', []):
            if tag['Key'] == 'aws:autoscaling:groupName':
                asg_name = tag['Value']
                break
        
        # Load Balancer の確認
        target_groups = self.find_target_groups(instance_id)
        
        return {
            'instance': instance,
            'asg_name': asg_name,
            'target_groups': target_groups,
            'state': instance['State']['Name'],
            'instance_type': instance['InstanceType'],
            'launch_time': instance['LaunchTime']
        }
    
    def pre_decommission_checks(self, instance_id, instance_info):
        """
        廃止前チェック
        """
        # インスタンスの状態確認
        if instance_info['state'] not in ['running', 'stopped']:
            raise Exception(f"Instance {instance_id} is in {instance_info['state']} state")
        
        # 重要なサービスの確認
        if self.is_critical_instance(instance_id, instance_info):
            raise Exception(f"Instance {instance_id} is marked as critical")
        
        # 最後のバックアップ確認
        last_backup = self.get_last_backup_time(instance_id)
        if last_backup < datetime.now() - timedelta(days=1):
            raise Exception(f"Last backup for {instance_id} is older than 24 hours")
    
    def drain_traffic(self, instance_id, instance_info):
        """
        トラフィックの排出
        """
        # Auto Scaling Group からの除外
        if instance_info['asg_name']:
            self.autoscaling.detach_instances(
                InstanceIds=[instance_id],
                AutoScalingGroupName=instance_info['asg_name'],
                ShouldDecrementDesiredCapacity=True
            )
        
        # Target Group からの除外
        for tg_arn in instance_info['target_groups']:
            self.elb.deregister_targets(
                TargetGroupArn=tg_arn,
                Targets=[{'Id': instance_id}]
            )
            
            # ドレイン完了待機
            self.wait_for_draining(tg_arn, instance_id)
    
    def wait_for_draining(self, target_group_arn, instance_id, timeout=300):
        """
        ドレイン完了まで待機
        """
        start_time = time.time()
        
        while time.time() - start_time < timeout:
            response = self.elb.describe_target_health(
                TargetGroupArn=target_group_arn,
                Targets=[{'Id': instance_id}]
            )
            
            if response['TargetHealthDescriptions']:
                state = response['TargetHealthDescriptions'][0]['TargetHealth']['State']
                if state == 'draining':
                    print(f"Instance {instance_id} is draining...")
                    time.sleep(10)
                    continue
                elif state == 'unused':
                    print(f"Instance {instance_id} drain completed")
                    return
            
            time.sleep(10)
        
        raise Exception(f"Timeout waiting for instance {instance_id} to drain")
    
    def backup_instance_data(self, instance_id, instance_info):
        """
        インスタンスデータのバックアップ
        """
        # EBS スナップショットの作成
        volumes = []
        for bdm in instance_info['instance'].get('BlockDeviceMappings', []):
            if 'Ebs' in bdm:
                volumes.append(bdm['Ebs']['VolumeId'])
        
        snapshot_ids = []
        for volume_id in volumes:
            response = self.ec2.create_snapshot(
                VolumeId=volume_id,
                Description=f"Decommission backup for {instance_id}"
            )
            snapshot_ids.append(response['SnapshotId'])
        
        # タグ付け
        if snapshot_ids:
            self.ec2.create_tags(
                Resources=snapshot_ids,
                Tags=[
                    {'Key': 'Name', 'Value': f'{instance_id}-decommission-backup'},
                    {'Key': 'InstanceId', 'Value': instance_id},
                    {'Key': 'DecommissionDate', 'Value': datetime.now().isoformat()},
                    {'Key': 'RetentionDays', 'Value': '30'}
                ]
            )
        
        return snapshot_ids
    
    def disable_monitoring(self, instance_id):
        """
        監視とアラートの無効化
        """
        # CloudWatch アラームの無効化
        alarms = self.cloudwatch.describe_alarms()
        
        for alarm in alarms['MetricAlarms']:
            for dimension in alarm.get('Dimensions', []):
                if dimension['Name'] == 'InstanceId' and dimension['Value'] == instance_id:
                    self.cloudwatch.disable_alarm_actions(
                        AlarmNames=[alarm['AlarmName']]
                    )
                    print(f"Disabled alarm: {alarm['AlarmName']}")
    
    def stop_instance(self, instance_id):
        """
        インスタンスの停止
        """
        self.ec2.stop_instances(InstanceIds=[instance_id])
        
        # 停止完了待機
        waiter = self.ec2.get_waiter('instance_stopped')
        waiter.wait(InstanceIds=[instance_id])
        
        print(f"Instance {instance_id} stopped successfully")
    
    def terminate_instance(self, instance_id, instance_info):
        """
        インスタンスの削除
        """
        # 最終確認
        confirmation = input(f"Are you sure you want to terminate instance {instance_id}? (yes/no): ")
        if confirmation.lower() != 'yes':
            print("Termination cancelled")
            return
        
        self.ec2.terminate_instances(InstanceIds=[instance_id])
        
        # 削除完了待機
        waiter = self.ec2.get_waiter('instance_terminated')
        waiter.wait(InstanceIds=[instance_id])
        
        print(f"Instance {instance_id} terminated successfully")
    
    def post_decommission_cleanup(self, instance_id, instance_info):
        """
        廃止後の後処理
        """
        # セキュリティグループの未使用確認
        self.check_unused_security_groups(instance_info)
        
        # EIP の解放確認
        self.check_unused_elastic_ips(instance_info)
        
        # 通知送信
        self.send_notification(
            'Instance Decommissioned',
            f'Instance {instance_id} has been successfully decommissioned'
        )
    
    def send_notification(self, subject, message):
        """
        通知の送信
        """
        try:
            self.sns.publish(
                TopicArn='arn:aws:sns:us-east-1:123456789012:decommission-notifications',
                Message=message,
                Subject=subject
            )
        except Exception as e:
            print(f"Failed to send notification: {e}")

# 使用例
if __name__ == "__main__":
    manager = InstanceDecommissionManager()
    
    # インスタンスの安全な廃止
    instance_id = "i-1234567890abcdef0"
    success = manager.safe_decommission(instance_id, reason="planned_retirement")
    
    if success:
        print(f"Instance {instance_id} decommissioned successfully")
    else:
        print(f"Failed to decommission instance {instance_id}")