# オブジェクトストレージの基本構造
class ObjectStorageArchitecture:
    """
    オブジェクトストレージのアーキテクチャ理解
    """
    
    def __init__(self):
        self.s3 = boto3.client('s3')
        
    def demonstrate_flat_namespace(self):
        """
        フラットな名前空間の実証
        """
        # 階層的に見えるが、実際はフラット
        objects = [
            'images/2024/01/photo1.jpg',
            'images/2024/01/photo2.jpg',
            'documents/reports/annual-2024.pdf',
            'logs/application/2024-01-15.log'
        ]
        
        # すべてのオブジェクトは同じレベルに存在
        # '/' は単なるキー名の一部
        for obj_key in objects:
            self.s3.put_object(
                Bucket='my-bucket',
                Key=obj_key,
                Body=b'sample data'
            )
        
        # プレフィックスによる擬似的な階層表現
        response = self.s3.list_objects_v2(
            Bucket='my-bucket',
            Prefix='images/2024/',
            Delimiter='/'
        )
        
        return response

class DurabilityCalculator:
    """
    耐久性の計算と理解
    """
    
    def calculate_data_loss_probability(self, durability, objects_count, years):
        """
        データ損失の確率計算
        """
        # 耐久性を年間損失率に変換
        annual_loss_rate = 1 - (durability / 100)
        
        # 期待される損失オブジェクト数
        expected_loss = objects_count * annual_loss_rate * years
        
        return {
            'durability': f"{durability}%",
            'objects_count': objects_count,
            'years': years,
            'expected_loss': expected_loss,
            'probability_per_object': annual_loss_rate
        }
    
    def compare_durability_levels(self):
        """
        異なる耐久性レベルの比較
        """
        comparisons = []
        objects = 1_000_000_000  # 10億オブジェクト
        
        durability_levels = {
            'S3 Standard': 99.999999999,
            'S3 Standard-IA': 99.999999999,
            'S3 One Zone-IA': 99.999999999,
            'Traditional RAID-1': 99.99,
            'Single Disk': 99.0
        }
        
        for storage_type, durability in durability_levels.items():
            result = self.calculate_data_loss_probability(
                durability, objects, 1  # 1年
            )
            comparisons.append({
                'type': storage_type,
                'expected_annual_loss': result['expected_loss']
            })
        
        return comparisons

class StorageClassOptimizer:
    """
    ストレージクラスの最適化
    """
    
    def __init__(self):
        self.s3 = boto3.client('s3')
        self.cloudwatch = boto3.client('cloudwatch')
    
    def analyze_access_patterns(self, bucket_name, prefix=''):
        """
        アクセスパターンの分析
        """
        # S3 Inventory または CloudWatch メトリクスから
        # アクセス頻度を分析
        
        end_time = datetime.now()
        start_time = end_time - timedelta(days=90)
        
        # オブジェクトごとのアクセス頻度を取得
        response = self.cloudwatch.get_metric_statistics(
            Namespace='AWS/S3',
            MetricName='NumberOfObjects',
            Dimensions=[
                {'Name': 'BucketName', 'Value': bucket_name},
                {'Name': 'StorageType', 'Value': 'AllStorageTypes'}
            ],
            StartTime=start_time,
            EndTime=end_time,
            Period=86400,  # 1日
            Statistics=['Average']
        )
        
        return response
    
    def recommend_storage_class(self, access_frequency, retrieval_urgency):
        """
        アクセスパターンに基づくストレージクラス推奨
        """
        if access_frequency == 'frequent':  # 日次アクセス
            return {
                'class': 'STANDARD',
                'reasoning': '頻繁なアクセスパターン',
                'cost_per_gb_month': 0.023,
                'retrieval_cost': 0
            }
        
        elif access_frequency == 'infrequent' and retrieval_urgency == 'immediate':
            return {
                'class': 'STANDARD_IA',
                'reasoning': '低頻度だが即座のアクセスが必要',
                'cost_per_gb_month': 0.0125,
                'retrieval_cost': 0.01  # per GB
            }
        
        elif access_frequency == 'archive' and retrieval_urgency == 'minutes':
            return {
                'class': 'GLACIER_IR',  # Instant Retrieval
                'reasoning': 'アーカイブだが数分でのアクセス要',
                'cost_per_gb_month': 0.004,
                'retrieval_cost': 0.03  # per GB
            }
        
        elif access_frequency == 'deep_archive':
            return {
                'class': 'DEEP_ARCHIVE',
                'reasoning': '長期保存、アクセスはほぼなし',
                'cost_per_gb_month': 0.00099,
                'retrieval_cost': 0.02,  # per GB
                'retrieval_time': '12-48 hours'
            }
    
    def implement_lifecycle_policy(self, bucket_name):
        """
        ライフサイクルポリシーの実装
        """
        lifecycle_policy = {
            'Rules': [
                {
                    'ID': 'TransitionToIA',
                    'Status': 'Enabled',
                    'Transitions': [
                        {
                            'Days': 30,
                            'StorageClass': 'STANDARD_IA'
                        },
                        {
                            'Days': 90,
                            'StorageClass': 'GLACIER'
                        },
                        {
                            'Days': 365,
                            'StorageClass': 'DEEP_ARCHIVE'
                        }
                    ]
                },
                {
                    'ID': 'DeleteOldVersions',
                    'Status': 'Enabled',
                    'NoncurrentVersionTransitions': [
                        {
                            'NoncurrentDays': 30,
                            'StorageClass': 'GLACIER'
                        }
                    ],
                    'NoncurrentVersionExpiration': {
                        'NoncurrentDays': 90
                    }
                },
                {
                    'ID': 'AbortIncompleteMultipartUploads',
                    'Status': 'Enabled',
                    'AbortIncompleteMultipartUpload': {
                        'DaysAfterInitiation': 7
                    }
                }
            ]
        }
        
        self.s3.put_bucket_lifecycle_configuration(
            Bucket=bucket_name,
            LifecycleConfiguration=lifecycle_policy
        )
        
        return lifecycle_policy

def setup_intelligent_tiering(self, bucket_name):
    """
    自動階層化の設定
    """
    # Intelligent-Tiering の設定
    configuration = {
        'Id': 'EntireObjects',
        'Status': 'Enabled',
        'Tierings': [
            {
                'Days': 90,
                'AccessTier': 'ARCHIVE_ACCESS'
            },
            {
                'Days': 180,
                'AccessTier': 'DEEP_ARCHIVE_ACCESS'
            }
        ]
    }
    
    self.s3.put_bucket_intelligent_tiering_configuration(
        Bucket=bucket_name,
        Id='EntireObjects',
        IntelligentTieringConfiguration=configuration
    )

class S3SecurityManager:
    """
    S3セキュリティの包括的管理
    """
    
    def __init__(self):
        self.s3 = boto3.client('s3')
        self.iam = boto3.client('iam')
    
    def implement_defense_in_depth(self, bucket_name):
        """
        多層防御の実装
        """
        # 1. バケットポリシーの設定
        bucket_policy = {
            "Version": "2012-10-17",
            "Statement": [
                {
                    "Sid": "DenyInsecureConnections",
                    "Effect": "Deny",
                    "Principal": "*",
                    "Action": "s3:*",
                    "Resource": [
                        f"arn:aws:s3:::{bucket_name}/*"
                    ],
                    "Condition": {
                        "Bool": {
                            "aws:SecureTransport": "false"
                        }
                    }
                },
                {
                    "Sid": "DenyUnencryptedObjectUploads",
                    "Effect": "Deny",
                    "Principal": "*",
                    "Action": "s3:PutObject",
                    "Resource": f"arn:aws:s3:::{bucket_name}/*",
                    "Condition": {
                        "StringNotEquals": {
                            "s3:x-amz-server-side-encryption": "AES256"
                        }
                    }
                }
            ]
        }
        
        self.s3.put_bucket_policy(
            Bucket=bucket_name,
            Policy=json.dumps(bucket_policy)
        )
        
        # 2. バケットの暗号化設定
        self.s3.put_bucket_encryption(
            Bucket=bucket_name,
            ServerSideEncryptionConfiguration={
                'Rules': [{
                    'ApplyServerSideEncryptionByDefault': {
                        'SSEAlgorithm': 'aws:kms',
                        'KMSMasterKeyID': 'alias/aws/s3'
                    }
                }]
            }
        )
        
        # 3. バージョニングの有効化
        self.s3.put_bucket_versioning(
            Bucket=bucket_name,
            VersioningConfiguration={
                'Status': 'Enabled'
            }
        )
        
        # 4. MFAデリートの有効化（ルートアカウントが必要）
        # self.s3.put_bucket_versioning(
        #     Bucket=bucket_name,
        #     VersioningConfiguration={
        #         'Status': 'Enabled',
        #         'MFADelete': 'Enabled'
        #     },
        #     MFA='arn:aws:iam::account:mfa/root-account-mfa-device 123456'
        # )
        
        # 5. アクセスログの有効化
        self.s3.put_bucket_logging(
            Bucket=bucket_name,
            BucketLoggingStatus={
                'LoggingEnabled': {
                    'TargetBucket': f'{bucket_name}-logs',
                    'TargetPrefix': 'access-logs/'
                }
            }
        )
        
        # 6. パブリックアクセスブロック
        self.s3.put_public_access_block(
            Bucket=bucket_name,
            PublicAccessBlockConfiguration={
                'BlockPublicAcls': True,
                'IgnorePublicAcls': True,
                'BlockPublicPolicy': True,
                'RestrictPublicBuckets': True
            }
        )
        
        return "Defense in depth implemented successfully"

def generate_presigned_url(self, bucket_name, object_key, expiration=3600):
    """
    時限的なアクセスを提供する署名付きURL
    """
    # アップロード用の署名付きURL
    upload_url = self.s3.generate_presigned_url(
        ClientMethod='put_object',
        Params={
            'Bucket': bucket_name,
            'Key': object_key,
            'ContentType': 'application/pdf',
            'ServerSideEncryption': 'AES256'
        },
        ExpiresIn=expiration
    )
    
    # ダウンロード用の署名付きURL（条件付き）
    download_url = self.s3.generate_presigned_url(
        ClientMethod='get_object',
        Params={
            'Bucket': bucket_name,
            'Key': object_key,
            'ResponseContentDisposition': 'attachment; filename="document.pdf"'
        },
        ExpiresIn=expiration
    )
    
    return {
        'upload_url': upload_url,
        'download_url': download_url,
        'expires_in': expiration
    }

class StaticWebsiteHosting:
    """
    S3での静的ウェブサイトホスティング
    """
    
    def __init__(self):
        self.s3 = boto3.client('s3')
        self.cloudfront = boto3.client('cloudfront')
    
    def setup_static_website(self, bucket_name, domain_name):
        """
        静的ウェブサイトの設定
        """
        # 1. ウェブサイト設定
        website_configuration = {
            'ErrorDocument': {'Key': 'error.html'},
            'IndexDocument': {'Suffix': 'index.html'}
        }
        
        self.s3.put_bucket_website(
            Bucket=bucket_name,
            WebsiteConfiguration=website_configuration
        )
        
        # 2. バケットポリシーで読み取り許可
        policy = {
            "Version": "2012-10-17",
            "Statement": [{
                "Sid": "PublicReadGetObject",
                "Effect": "Allow",
                "Principal": "*",
                "Action": "s3:GetObject",
                "Resource": f"arn:aws:s3:::{bucket_name}/*"
            }]
        }
        
        self.s3.put_bucket_policy(
            Bucket=bucket_name,
            Policy=json.dumps(policy)
        )
        
        # 3. CloudFront ディストリビューションの作成
        cloudfront_config = {
            'CallerReference': str(datetime.now()),
            'DefaultRootObject': 'index.html',
            'Origins': {
                'Quantity': 1,
                'Items': [{
                    'Id': f'{bucket_name}-origin',
                    'DomainName': f'{bucket_name}.s3-website.amazonaws.com',
                    'CustomOriginConfig': {
                        'HTTPPort': 80,
                        'HTTPSPort': 443,
                        'OriginProtocolPolicy': 'http-only'
                    }
                }]
            },
            'DefaultCacheBehavior': {
                'TargetOriginId': f'{bucket_name}-origin',
                'ViewerProtocolPolicy': 'redirect-to-https',
                'AllowedMethods': {
                    'Quantity': 2,
                    'Items': ['GET', 'HEAD'],
                    'CachedMethods': {
                        'Quantity': 2,
                        'Items': ['GET', 'HEAD']
                    }
                },
                'Compress': True,
                'ForwardedValues': {
                    'QueryString': False,
                    'Cookies': {'Forward': 'none'}
                },
                'TrustedSigners': {
                    'Enabled': False,
                    'Quantity': 0
                }
            },
            'Comment': f'CloudFront distribution for {domain_name}',
            'Enabled': True
        }
        
        response = self.cloudfront.create_distribution(
            DistributionConfig=cloudfront_config
        )
        
        return response['Distribution']['DomainName']

class DataLakeArchitecture:
    """
    S3ベースのデータレイクアーキテクチャ
    """
    
    def __init__(self):
        self.s3 = boto3.client('s3')
        self.glue = boto3.client('glue')
        self.athena = boto3.client('athena')
    
    def setup_data_lake_structure(self, lake_bucket):
        """
        データレイクの構造設計
        """
        # 標準的なデータレイク構造
        prefixes = [
            'raw/',                    # 生データ
            'processed/',              # 処理済みデータ
            'curated/',               # キュレートされたデータ
            'archive/',               # アーカイブ
            'temp/',                  # 一時データ
            'metadata/',              # メタデータ
            'scripts/',               # 処理スクリプト
            'logs/'                   # 処理ログ
        ]
        
        # 各レイヤーの設定
        layer_configs = {
            'raw': {
                'lifecycle_days': 90,
                'storage_class': 'STANDARD_IA'
            },
            'processed': {
                'lifecycle_days': 30,
                'storage_class': 'INTELLIGENT_TIERING'
            },
            'archive': {
                'lifecycle_days': 0,
                'storage_class': 'GLACIER'
            }
        }
        
        # データカタログの設定
        for layer, config in layer_configs.items():
            self.create_glue_crawler(lake_bucket, layer)
        
        return prefixes
    
    def create_glue_crawler(self, bucket, prefix):
        """
        AWS Glue クローラーの作成
        """
        crawler_name = f'{bucket}-{prefix}-crawler'
        
        self.glue.create_crawler(
            Name=crawler_name,
            Role='arn:aws:iam::account:role/GlueServiceRole',
            DatabaseName='data_lake',
            Targets={
                'S3Targets': [{
                    'Path': f's3://{bucket}/{prefix}/'
                }]
            },
            Schedule='cron(0 2 * * ? *)',  # 毎日AM2:00
            SchemaChangePolicy={
                'UpdateBehavior': 'UPDATE_IN_DATABASE',
                'DeleteBehavior': 'LOG'
            }
        )
        
        return crawler_name
    
    def query_data_with_athena(self, query):
        """
        Athenaでのデータクエリ
        """
        response = self.athena.start_query_execution(
            QueryString=query,
            QueryExecutionContext={
                'Database': 'data_lake'
            },
            ResultConfiguration={
                'OutputLocation': 's3://query-results-bucket/athena/'
            }
        )
        
        return response['QueryExecutionId']

class S3PerformanceOptimizer:
    """
    S3パフォーマンスの最適化
    """
    
    def __init__(self):
        self.s3 = boto3.client('s3')
    
    def optimize_for_high_request_rate(self, bucket_name):
        """
        高リクエストレート対応の最適化
        """
        # S3は自動的にパーティショニングを行うが、
        # 以下のベストプラクティスで更なる最適化が可能
        
        optimization_strategies = {
            'prefix_randomization': {
                'description': '一時的な高負荷時のプレフィックスランダム化',
                'example': 'hex(hash(key))[:2]/original-key',
                'use_case': '短期間の大量アップロード'
            },
            'multipart_upload': {
                'description': '大きなオブジェクトの並列アップロード',
                'threshold': '100MB以上のファイル',
                'part_size': '10〜100MB'
            },
            'transfer_acceleration': {
                'description': 'エッジロケーションを利用した高速転送',
                'benefit': '最大50%の速度向上',
                'cost': '追加料金あり'
            },
            'request_parallelization': {
                'description': '複数接続での並列リクエスト',
                'concurrent_requests': 100,
                'connection_pool_size': 50
            }
        }
        
        # Transfer Acceleration の有効化
        self.s3.put_bucket_accelerate_configuration(
            Bucket=bucket_name,
            AccelerateConfiguration={'Status': 'Enabled'}
        )
        
        return optimization_strategies
    
    def implement_multipart_upload(self, bucket_name, key, file_path):
        """
        マルチパートアップロードの実装
        """
        import math
        import threading
        from concurrent.futures import ThreadPoolExecutor
        
        # ファイルサイズに基づいてパートサイズを決定
        file_size = os.path.getsize(file_path)
        part_size = max(5 * 1024 * 1024, file_size // 1000)  # 最小5MB
        part_count = math.ceil(file_size / part_size)
        
        # マルチパートアップロードの開始
        response = self.s3.create_multipart_upload(
            Bucket=bucket_name,
            Key=key
        )
        upload_id = response['UploadId']
        
        parts = []
        
        def upload_part(part_number, start_byte, end_byte):
            with open(file_path, 'rb') as f:
                f.seek(start_byte)
                data = f.read(end_byte - start_byte)
                
                response = self.s3.upload_part(
                    Bucket=bucket_name,
                    Key=key,
                    PartNumber=part_number,
                    UploadId=upload_id,
                    Body=data
                )
                
                return {
                    'PartNumber': part_number,
                    'ETag': response['ETag']
                }
        
        # 並列アップロード
        with ThreadPoolExecutor(max_workers=10) as executor:
            futures = []
            for i in range(part_count):
                start_byte = i * part_size
                end_byte = min(start_byte + part_size, file_size)
                future = executor.submit(
                    upload_part, i + 1, start_byte, end_byte
                )
                futures.append(future)
            
            for future in futures:
                parts.append(future.result())
        
        # マルチパートアップロードの完了
        self.s3.complete_multipart_upload(
            Bucket=bucket_name,
            Key=key,
            UploadId=upload_id,
            MultipartUpload={'Parts': parts}
        )
        
        return f"Uploaded {key} in {part_count} parts"

class S3CostOptimizer:
    """
    S3コストの最適化
    """
    
    def __init__(self):
        self.s3 = boto3.client('s3')
        self.cloudwatch = boto3.client('cloudwatch')
    
    def analyze_storage_costs(self, bucket_name):
        """
        ストレージコストの分析
        """
        # S3 Storage Lens を使用した分析
        # （実際の実装では S3 Storage Lens API を使用）
        
        cost_analysis = {
            'storage_breakdown': self.get_storage_class_breakdown(bucket_name),
            'access_patterns': self.analyze_access_patterns(bucket_name),
            'lifecycle_opportunities': self.identify_lifecycle_opportunities(bucket_name),
            'incomplete_multipart': self.find_incomplete_multipart_uploads(bucket_name)
        }
        
        return cost_analysis
    
    def get_storage_class_breakdown(self, bucket_name):
        """
        ストレージクラス別の使用量
        """
        # CloudWatch メトリクスから取得
        storage_types = [
            'StandardStorage',
            'StandardIAStorage', 
            'GlacierStorage',
            'DeepArchiveStorage'
        ]
        
        breakdown = {}
        for storage_type in storage_types:
            response = self.cloudwatch.get_metric_statistics(
                Namespace='AWS/S3',
                MetricName='BucketSizeBytes',
                Dimensions=[
                    {'Name': 'BucketName', 'Value': bucket_name},
                    {'Name': 'StorageType', 'Value': storage_type}
                ],
                StartTime=datetime.now() - timedelta(days=1),
                EndTime=datetime.now(),
                Period=86400,
                Statistics=['Average']
            )
            
            if response['Datapoints']:
                breakdown[storage_type] = response['Datapoints'][0]['Average']
        
        return breakdown
    
    def identify_lifecycle_opportunities(self, bucket_name):
        """
        ライフサイクル最適化の機会を特定
        """
        # S3 Inventory レポートを使用した分析
        # アクセスされていない古いオブジェクトを特定
        
        opportunities = []
        
        # 30日以上アクセスされていないSTANDARDオブジェクト
        opportunities.append({
            'recommendation': 'Move to STANDARD_IA',
            'criteria': 'Objects not accessed for 30+ days',
            'potential_savings': 'Up to 50% storage cost reduction'
        })
        
        # 90日以上アクセスされていないオブジェクト
        opportunities.append({
            'recommendation': 'Move to GLACIER',
            'criteria': 'Objects not accessed for 90+ days',
            'potential_savings': 'Up to 80% storage cost reduction'
        })
        
        return opportunities
    
    def cleanup_incomplete_multipart_uploads(self, bucket_name):
        """
        未完了のマルチパートアップロードのクリーンアップ
        """
        response = self.s3.list_multipart_uploads(Bucket=bucket_name)
        
        cleaned_size = 0
        cleaned_count = 0
        
        for upload in response.get('Uploads', []):
            # 7日以上前の未完了アップロード
            if upload['Initiated'] < datetime.now(timezone.utc) - timedelta(days=7):
                self.s3.abort_multipart_upload(
                    Bucket=bucket_name,
                    Key=upload['Key'],
                    UploadId=upload['UploadId']
                )
                cleaned_count += 1
        
        return {
            'cleaned_uploads': cleaned_count,
            'recommendation': 'Set lifecycle rule for automatic cleanup'
        }

class BlockStorageArchitecture:
    """
    ブロックストレージアーキテクチャの理解と実装
    """
    
    def __init__(self):
        self.ec2 = boto3.client('ec2')
    
    def demonstrate_storage_compute_separation(self):
        """
        ストレージとコンピュートの分離の実証
        """
        # 1. ボリュームの作成（コンピュートとは独立）
        volume = self.ec2.create_volume(
            AvailabilityZone='us-east-1a',
            Size=100,  # GB
            VolumeType='gp3',
            Iops=3000,
            Throughput=125,  # MB/s
            Encrypted=True,
            TagSpecifications=[{
                'ResourceType': 'volume',
                'Tags': [
                    {'Key': 'Name', 'Value': 'data-volume'},
                    {'Key': 'Purpose', 'Value': 'database'}
                ]
            }]
        )
        
        volume_id = volume['VolumeId']
        
        # 2. ボリュームの準備完了待機
        waiter = self.ec2.get_waiter('volume_available')
        waiter.wait(VolumeIds=[volume_id])
        
        # 3. インスタンスへのアタッチ（動的に可能）
        attachment = self.ec2.attach_volume(
            Device='/dev/sdf',
            InstanceId='i-1234567890abcdef0',
            VolumeId=volume_id
        )
        
        # 利点の実証
        benefits = {
            'persistence': 'インスタンス終了後もデータは保持',
            'mobility': '別のインスタンスへの再アタッチ可能',
            'scaling': 'ボリュームサイズの動的変更可能',
            'snapshots': '稼働中のスナップショット取得可能',
            'encryption': 'ボリュームレベルでの暗号化'
        }
        
        return benefits

class StoragePerformanceAnalyzer:
    """
    ストレージパフォーマンスの分析と最適化
    """
    
    def __init__(self):
        self.ec2 = boto3.client('ec2')
        self.cloudwatch = boto3.client('cloudwatch')
    
    def analyze_workload_characteristics(self, volume_id):
        """
        ワークロード特性の分析
        """
        metrics = {
            'iops': self.get_volume_metric(volume_id, 'VolumeReadOps', 'Sum'),
            'throughput': self.get_volume_metric(volume_id, 'VolumeReadBytes', 'Sum'),
            'latency': self.get_volume_metric(volume_id, 'VolumeTotalReadTime', 'Average'),
            'queue_length': self.get_volume_metric(volume_id, 'VolumeQueueLength', 'Average')
        }
        
        # ワークロードパターンの判定
        avg_io_size = metrics['throughput'] / metrics['iops'] if metrics['iops'] > 0 else 0
        
        if avg_io_size < 16 * 1024:  # 16KB未満
            workload_type = 'random_io'
            recommendation = 'IOPS最適化（io2/io1）を推奨'
        elif avg_io_size > 256 * 1024:  # 256KB以上
            workload_type = 'sequential_io'
            recommendation = 'スループット最適化（st1）を推奨'
        else:
            workload_type = 'mixed_io'
            recommendation = 'バランス型（gp3）を推奨'
        
        return {
            'workload_type': workload_type,
            'avg_io_size': avg_io_size,
            'recommendation': recommendation,
            'metrics': metrics
        }
    
    def calculate_required_iops(self, workload_profile):
        """
        必要なIOPSの計算
        """
        # ワークロードプロファイルに基づくIOPS要件
        base_iops = workload_profile.get('baseline_iops', 1000)
        peak_multiplier = workload_profile.get('peak_multiplier', 3)
        
        required_iops = {
            'baseline': base_iops,
            'peak': base_iops * peak_multiplier,
            'recommended': int(base_iops * peak_multiplier * 1.2),  # 20%バッファ
        }
        
        # ボリュームタイプ別の推奨
        if required_iops['recommended'] <= 16000:
            volume_recommendation = {
                'type': 'gp3',
                'iops': required_iops['recommended'],
                'cost_effective': True
            }
        elif required_iops['recommended'] <= 64000:
            volume_recommendation = {
                'type': 'io2',
                'iops': required_iops['recommended'],
                'cost_effective': False
            }
        else:
            volume_recommendation = {
                'type': 'io2 Block Express',
                'iops': required_iops['recommended'],
                'cost_effective': False,
                'note': 'Nitro-based instances required'
            }
        
        return volume_recommendation

class VolumeTypeSelector:
    """
    ボリュームタイプの選択ロジック
    """
    
    def __init__(self):
        self.volume_types = {
            'gp3': {
                'description': '汎用SSD（最新世代）',
                'baseline_iops': 3000,
                'max_iops': 16000,
                'baseline_throughput': 125,  # MB/s
                'max_throughput': 1000,  # MB/s
                'cost_per_gb_month': 0.08,
                'use_cases': ['ブートボリューム', '開発環境', '小規模DB']
            },
            'gp2': {
                'description': '汎用SSD（旧世代）',
                'iops_per_gb': 3,
                'burst_iops': 3000,
                'max_iops': 16000,
                'cost_per_gb_month': 0.10,
                'use_cases': ['レガシー環境', '移行予定なし']
            },
            'io2': {
                'description': 'プロビジョンドIOPS SSD',
                'max_iops': 64000,
                'iops_to_gb_ratio': 500,
                'durability': '99.999%',
                'cost_per_gb_month': 0.125,
                'cost_per_iops_month': 0.065,
                'use_cases': ['ミッションクリティカルDB', '高トランザクション']
            },
            'io2_block_express': {
                'description': '次世代プロビジョンドIOPS',
                'max_iops': 256000,
                'max_throughput': 4000,  # MB/s
                'latency': 'sub-millisecond',
                'cost_per_gb_month': 0.125,
                'use_cases': ['超高性能DB', 'リアルタイム分析']
            },
            'st1': {
                'description': 'スループット最適化HDD',
                'baseline_throughput': 40,  # MB/s per TB
                'burst_throughput': 250,  # MB/s
                'cost_per_gb_month': 0.045,
                'use_cases': ['ビッグデータ', 'ログ処理', 'データウェアハウス']
            },
            'sc1': {
                'description': 'コールドHDD',
                'baseline_throughput': 12,  # MB/s per TB
                'burst_throughput': 80,  # MB/s
                'cost_per_gb_month': 0.015,
                'use_cases': ['アーカイブ', 'バックアップ', '非頻繁アクセス']
            }
        }
    
    def select_volume_type(self, requirements):
        """
        要件に基づくボリュームタイプの選択
        """
        iops_required = requirements.get('iops', 0)
        throughput_required = requirements.get('throughput_mb_s', 0)
        capacity_gb = requirements.get('capacity_gb', 100)
        latency_sensitive = requirements.get('latency_sensitive', False)
        cost_sensitive = requirements.get('cost_sensitive', True)
        
        recommendations = []
        
        for vol_type, specs in self.volume_types.items():
            score = 0
            reason = []
            
            # IOPS要件のチェック
            if 'max_iops' in specs:
                if specs.get('baseline_iops', 0) >= iops_required:
                    score += 2
                    reason.append('IOPS要件を満たす')
                elif specs['max_iops'] >= iops_required:
                    score += 1
                    reason.append('IOPS要件を満たす（追加設定必要）')
            
            # スループット要件のチェック
            if 'max_throughput' in specs:
                if specs.get('baseline_throughput', 0) >= throughput_required:
                    score += 2
                    reason.append('スループット要件を満たす')
            
            # コスト評価
            if cost_sensitive:
                monthly_cost = capacity_gb * specs['cost_per_gb_month']
                if vol_type == 'io2' and iops_required > 0:
                    monthly_cost += iops_required * specs.get('cost_per_iops_month', 0)
                
                if monthly_cost < 50:
                    score += 2
                    reason.append('コスト効率的')
            
            # レイテンシ要件
            if latency_sensitive and 'SSD' in specs['description']:
                score += 1
                reason.append('低レイテンシ')
            
            recommendations.append({
                'type': vol_type,
                'score': score,
                'monthly_cost': monthly_cost if 'monthly_cost' in locals() else 'N/A',
                'reasons': reason
            })
        
        # スコア順にソート
        recommendations.sort(key=lambda x: x['score'], reverse=True)
        
        return recommendations[0] if recommendations else None

class SnapshotManagement:
    """
    スナップショット管理の実装
    """
    
    def __init__(self):
        self.ec2 = boto3.client('ec2')
        self.eventbridge = boto3.client('events')
    
    def create_consistent_snapshot(self, volume_id, instance_id=None):
        """
        整合性のあるスナップショットの作成
        """
        # 1. アプリケーション静止点の作成（可能な場合）
        if instance_id:
            self.create_application_quiesce_point(instance_id)
        
        # 2. スナップショットの作成
        snapshot = self.ec2.create_snapshot(
            VolumeId=volume_id,
            Description=f'Automated snapshot of {volume_id} at {datetime.now()}',
            TagSpecifications=[{
                'ResourceType': 'snapshot',
                'Tags': [
                    {'Key': 'Name', 'Value': f'snap-{volume_id}-{datetime.now().strftime("%Y%m%d%H%M%S")}'},
                    {'Key': 'AutomatedBackup', 'Value': 'true'},
                    {'Key': 'VolumeId', 'Value': volume_id}
                ]
            }]
        )
        
        snapshot_id = snapshot['SnapshotId']
        
        # 3. 完了待機とメタデータ更新
        waiter = self.ec2.get_waiter('snapshot_completed')
        waiter.wait(SnapshotIds=[snapshot_id])
        
        # 4. 増分サイズの計算
        snapshot_info = self.calculate_incremental_size(snapshot_id)
        
        return {
            'snapshot_id': snapshot_id,
            'incremental_size': snapshot_info['incremental_size'],
            'total_size': snapshot_info['total_size']
        }
    
    def calculate_incremental_size(self, snapshot_id):
        """
        増分サイズの計算
        """
        snapshot = self.ec2.describe_snapshots(
            SnapshotIds=[snapshot_id]
        )['Snapshots'][0]
        
        volume_id = snapshot['VolumeId']
        
        # 同じボリュームの前回のスナップショットを検索
        previous_snapshots = self.ec2.describe_snapshots(
            Filters=[
                {'Name': 'volume-id', 'Values': [volume_id]},
                {'Name': 'status', 'Values': ['completed']}
            ],
            OwnerIds=['self']
        )['Snapshots']
        
        # 時系列でソート
        previous_snapshots.sort(key=lambda x: x['StartTime'])
        
        # 増分サイズの推定（実際のAPIではDataUsedInGBが利用可能）
        if len(previous_snapshots) > 1:
            # 前回からの変更ブロックのみが保存される
            incremental_size = snapshot.get('DataUsedInGB', 0)
        else:
            # 初回は全データ
            incremental_size = snapshot['VolumeSize']
        
        return {
            'snapshot_id': snapshot_id,
            'incremental_size': incremental_size,
            'total_size': snapshot['VolumeSize'],
            'is_incremental': len(previous_snapshots) > 1
        }
    
    def setup_automated_snapshots(self, volume_id, schedule='daily'):
        """
        自動スナップショットの設定
        """
        # Data Lifecycle Manager (DLM) ポリシーの作成
        dlm_policy = {
            'Description': f'Automated snapshots for {volume_id}',
            'State': 'ENABLED',
            'ExecutionRoleArn': 'arn:aws:iam::account:role/AWSDataLifecycleManagerDefaultRole',
            'PolicyDetails': {
                'PolicyType': 'EBS_SNAPSHOT_MANAGEMENT',
                'ResourceTypes': ['VOLUME'],
                'TargetTags': [{
                    'Key': 'VolumeId',
                    'Value': volume_id
                }],
                'Schedules': [{
                    'Name': f'{schedule}-snapshot',
                    'CopyTags': True,
                    'CreateRule': {
                        'Interval': 24 if schedule == 'daily' else 168,
                        'IntervalUnit': 'HOURS',
                        'Times': ['03:00']
                    },
                    'RetainRule': {
                        'Count': 7 if schedule == 'daily' else 4,
                        'Interval': 1,
                        'IntervalUnit': 'DAYS' if schedule == 'daily' else 'WEEKS'
                    },
                    'FastRestoreRule': {
                        'Count': 1,
                        'Interval': 1,
                        'IntervalUnit': 'DAYS'
                    }
                }]
            }
        }
        
        # クロスリージョンコピーの設定
        if schedule == 'daily':
            dlm_policy['PolicyDetails']['Schedules'][0]['CrossRegionCopyRules'] = [{
                'TargetRegion': 'us-west-2',
                'Encrypted': True,
                'CopyTags': True,
                'RetainRule': {
                    'Interval': 7,
                    'IntervalUnit': 'DAYS'
                }
            }]
        
        return dlm_policy
    
    def restore_from_snapshot(self, snapshot_id, target_az=None):
        """
        スナップショットからの復元
        """
        # スナップショット情報の取得
        snapshot = self.ec2.describe_snapshots(
            SnapshotIds=[snapshot_id]
        )['Snapshots'][0]
        
        # 新しいボリュームの作成
        volume = self.ec2.create_volume(
            AvailabilityZone=target_az or snapshot['AvailabilityZone'],
            SnapshotId=snapshot_id,
            VolumeType='gp3',
            Iops=3000,
            Throughput=125,
            TagSpecifications=[{
                'ResourceType': 'volume',
                'Tags': [
                    {'Key': 'Name', 'Value': f'restored-from-{snapshot_id}'},
                    {'Key': 'SourceSnapshot', 'Value': snapshot_id},
                    {'Key': 'RestoreDate', 'Value': datetime.now().isoformat()}
                ]
            }]
        )
        
        return volume['VolumeId']

class VolumeEncryption:
    """
    ボリューム暗号化の実装
    """
    
    def __init__(self):
        self.ec2 = boto3.client('ec2')
        self.kms = boto3.client('kms')
    
    def enable_default_encryption(self):
        """
        デフォルト暗号化の有効化
        """
        # アカウント全体でEBSボリュームのデフォルト暗号化を有効化
        self.ec2.enable_ebs_encryption_by_default()
        
        # カスタムKMSキーの作成
        kms_key = self.kms.create_key(
            Description='EBS encryption key',
            KeyUsage='ENCRYPT_DECRYPT',
            Origin='AWS_KMS',
            MultiRegion=False
        )
        
        # デフォルトKMSキーとして設定
        self.ec2.modify_ebs_default_kms_key_id(
            KmsKeyId=kms_key['KeyMetadata']['KeyId']
        )
        
        return kms_key['KeyMetadata']['Arn']
    
    def encrypt_existing_volume(self, volume_id):
        """
        既存ボリュームの暗号化
        """
        # 1. スナップショットの作成
        snapshot = self.ec2.create_snapshot(
            VolumeId=volume_id,
            Description='Snapshot for encryption'
        )
        snapshot_id = snapshot['SnapshotId']
        
        # 2. スナップショット完了待機
        waiter = self.ec2.get_waiter('snapshot_completed')
        waiter.wait(SnapshotIds=[snapshot_id])
        
        # 3. 暗号化されたコピーの作成
        encrypted_snapshot = self.ec2.copy_snapshot(
            SourceSnapshotId=snapshot_id,
            SourceRegion='us-east-1',
            Description='Encrypted copy',
            Encrypted=True,
            KmsKeyId='alias/aws/ebs'
        )
        
        # 4. 暗号化されたボリュームの作成
        encrypted_volume = self.ec2.create_volume(
            AvailabilityZone='us-east-1a',
            SnapshotId=encrypted_snapshot['SnapshotId'],
            VolumeType='gp3'
        )
        
        return encrypted_volume['VolumeId']

class ElasticVolumes:
    """
    Elastic Volumesによる動的変更
    """
    
    def __init__(self):
        self.ec2 = boto3.client('ec2')
    
    def modify_volume_dynamically(self, volume_id, new_size=None, new_iops=None, new_type=None):
        """
        稼働中のボリューム変更
        """
        # 現在のボリューム情報
        current_volume = self.ec2.describe_volumes(
            VolumeIds=[volume_id]
        )['Volumes'][0]
        
        modification_params = {'VolumeId': volume_id}
        
        if new_size and new_size > current_volume['Size']:
            modification_params['Size'] = new_size
        
        if new_type and new_type != current_volume['VolumeType']:
            modification_params['VolumeType'] = new_type
        
        if new_iops and new_type in ['io1', 'io2', 'gp3']:
            modification_params['Iops'] = new_iops
        
        # ボリューム変更の実行
        response = self.ec2.modify_volume(**modification_params)
        
        # 変更の進行状況監視
        modification_id = response['VolumeModification']['ModificationState']
        
        return {
            'modification_id': modification_id,
            'status': 'in-progress',
            'note': 'ファイルシステムの拡張も必要です'
        }
    
    def extend_filesystem(self, device_name, filesystem_type='ext4'):
        """
        ファイルシステムの拡張
        """
        commands = {
            'ext4': [
                f'sudo resize2fs {device_name}'
            ],
            'xfs': [
                f'sudo xfs_growfs -d {device_name}'
            ],
            'ntfs': [
                'Use Windows Disk Management to extend'
            ]
        }
        
        return commands.get(filesystem_type, ['Unknown filesystem type'])

class EBSPerformanceTuning:
    """
    EBSパフォーマンスチューニング
    """
    
    def __init__(self):
        self.ec2 = boto3.client('ec2')
        self.cloudwatch = boto3.client('cloudwatch')
    
    def optimize_for_workload(self, volume_id, workload_type):
        """
        ワークロードに応じた最適化
        """
        optimization_profiles = {
            'database': {
                'volume_type': 'io2',
                'iops': 20000,
                'throughput': None,
                'multi_attach': False,
                'os_settings': {
                    'scheduler': 'noop',
                    'read_ahead': 256,
                    'nr_requests': 256
                }
            },
            'analytics': {
                'volume_type': 'gp3',
                'iops': 10000,
                'throughput': 500,
                'multi_attach': False,
                'os_settings': {
                    'scheduler': 'deadline',
                    'read_ahead': 4096,
                    'nr_requests': 512
                }
            },
            'streaming': {
                'volume_type': 'st1',
                'iops': None,
                'throughput': None,
                'multi_attach': False,
                'os_settings': {
                    'scheduler': 'cfq',
                    'read_ahead': 8192,
                    'nr_requests': 128
                }
            }
        }
        
        profile = optimization_profiles.get(workload_type)
        
        if profile:
            # ボリューム設定の更新
            self.ec2.modify_volume(
                VolumeId=volume_id,
                VolumeType=profile['volume_type'],
                Iops=profile.get('iops'),
                Throughput=profile.get('throughput')
            )
            
            # OS設定のスクリプト生成
            os_commands = self.generate_os_tuning_script(profile['os_settings'])
            
            return {
                'volume_modifications': profile,
                'os_tuning_script': os_commands
            }
    
    def generate_os_tuning_script(self, settings):
        """
        OSチューニングスクリプトの生成
        """
        script = """#!/bin/bash
# EBS Performance Tuning Script

# I/Oスケジューラの設定
echo {scheduler} > /sys/block/xvdf/queue/scheduler

# Read-aheadの設定
blockdev --setra {read_ahead} /dev/xvdf

# リクエストキューの深さ
echo {nr_requests} > /sys/block/xvdf/queue/nr_requests

# 追加の最適化
echo 0 > /sys/block/xvdf/queue/rotational
echo 1 > /sys/block/xvdf/queue/rq_affinity

# 永続化のための設定
cat >> /etc/rc.local << EOF
echo {scheduler} > /sys/block/xvdf/queue/scheduler
blockdev --setra {read_ahead} /dev/xvdf
echo {nr_requests} > /sys/block/xvdf/queue/nr_requests
EOF

chmod +x /etc/rc.local
""".format(**settings)
        
        return script
    
    def monitor_performance_metrics(self, volume_id):
        """
        パフォーマンスメトリクスの監視
        """
        metrics_to_monitor = [
            ('VolumeReadOps', 'Sum', 'Read IOPS'),
            ('VolumeWriteOps', 'Sum', 'Write IOPS'),
            ('VolumeReadBytes', 'Sum', 'Read Throughput'),
            ('VolumeWriteBytes', 'Sum', 'Write Throughput'),
            ('VolumeThroughputPercentage', 'Average', 'Throughput Utilization'),
            ('VolumeConsumedReadWriteOps', 'Sum', 'Consumed IOPS'),
            ('BurstBalance', 'Average', 'Burst Credit Balance')
        ]
        
        performance_data = {}
        
        for metric_name, statistic, description in metrics_to_monitor:
            response = self.cloudwatch.get_metric_statistics(
                Namespace='AWS/EBS',
                MetricName=metric_name,
                Dimensions=[
                    {'Name': 'VolumeId', 'Value': volume_id}
                ],
                StartTime=datetime.now() - timedelta(hours=1),
                EndTime=datetime.now(),
                Period=300,
                Statistics=[statistic]
            )
            
            if response['Datapoints']:
                latest_value = sorted(
                    response['Datapoints'],
                    key=lambda x: x['Timestamp']
                )[-1][statistic]
                
                performance_data[description] = latest_value
        
        return performance_data

class FileStorageArchitecture:
    """
    ファイルストレージアーキテクチャの実装
    """
    
    def __init__(self):
        self.efs = boto3.client('efs')
        self.ec2 = boto3.client('ec2')
    
    def demonstrate_shared_storage_benefits(self):
        """
        共有ストレージの利点を実証
        """
        # EFSファイルシステムの作成
        efs_response = self.efs.create_file_system(
            CreationToken='shared-storage-demo',
            PerformanceMode='generalPurpose',  # または 'maxIO'
            ThroughputMode='elastic',  # 自動スケーリング
            Encrypted=True,
            Tags=[
                {'Key': 'Name', 'Value': 'shared-app-storage'},
                {'Key': 'Purpose', 'Value': 'multi-instance-access'}
            ]
        )
        
        file_system_id = efs_response['FileSystemId']
        
        # マウントターゲットの作成（各AZに）
        subnets = ['subnet-12345', 'subnet-67890']  # 各AZのサブネット
        mount_targets = []
        
        for subnet_id in subnets:
            mt_response = self.efs.create_mount_target(
                FileSystemId=file_system_id,
                SubnetId=subnet_id,
                SecurityGroups=['sg-efs-access']
            )
            mount_targets.append(mt_response['MountTargetId'])
        
        # 利点の実証
        benefits = {
            'concurrent_access': '数千のEC2インスタンスから同時アクセス可能',
            'automatic_scaling': 'ペタバイト規模まで自動拡張',
            'high_availability': 'マルチAZ配置による高可用性',
            'posix_compliance': 'POSIXファイルシステムセマンティクス',
            'no_capacity_planning': '事前のサイズ指定不要'
        }
        
        return {
            'file_system_id': file_system_id,
            'mount_targets': mount_targets,
            'benefits': benefits
        }

class NFSImplementation:
    """
    NFSベースのファイルストレージ実装
    """
    
    def __init__(self):
        self.efs = boto3.client('efs')
    
    def configure_nfs_mount(self, file_system_id, mount_point='/mnt/efs'):
        """
        NFSマウントの設定
        """
        # マウントヘルパーのインストールとマウント
        mount_commands = f"""
#!/bin/bash
# EFS mount helper のインストール
sudo yum install -y amazon-efs-utils

# マウントポイントの作成
sudo mkdir -p {mount_point}

# /etc/fstab への追加（永続化）
echo "{file_system_id}:/ {mount_point} efs _netdev,tls 0 0" | sudo tee -a /etc/fstab

# マウント実行
sudo mount -a

# マウント確認
df -h | grep {mount_point}
"""
        
        # NFSマウントオプションの最適化
        optimized_mount_options = {
            'tls': 'TLS暗号化を有効化',
            'rsize=1048576': '読み取りバッファサイズ（1MB）',
            'wsize=1048576': '書き込みバッファサイズ（1MB）',
            'hard': 'ハードマウント（信頼性重視）',
            'timeo=600': 'タイムアウト値（秒）',
            'retrans=2': '再送信回数',
            '_netdev': 'ネットワークデバイスとして認識'
        }
        
        return {
            'mount_commands': mount_commands,
            'mount_options': optimized_mount_options
        }
    
    def setup_nfs_performance_optimization(self):
        """
        NFSパフォーマンスの最適化
        """
        optimization_settings = {
            'kernel_parameters': {
                'sunrpc.tcp_slot_table_entries': 128,
                'sunrpc.tcp_max_slot_table_entries': 128,
                'net.core.rmem_default': 31457280,
                'net.core.rmem_max': 134217728,
                'net.core.wmem_default': 31457280,
                'net.core.wmem_max': 134217728,
                'net.ipv4.tcp_rmem': '4096 87380 134217728',
                'net.ipv4.tcp_wmem': '4096 65536 134217728'
            },
            'nfs_options': {
                'noresvport': 'より多くの同時接続を許可',
                'nfsvers=4.1': 'NFSv4.1の使用',
                'rsize=1048576': '大きな読み取りサイズ',
                'wsize=1048576': '大きな書き込みサイズ'
            }
        }
        
        # sysctlコマンドの生成
        sysctl_commands = []
        for param, value in optimization_settings['kernel_parameters'].items():
            sysctl_commands.append(f"sudo sysctl -w {param}={value}")
        
        return {
            'sysctl_commands': sysctl_commands,
            'nfs_mount_options': optimization_settings['nfs_options']
        }

class SMBImplementation:
    """
    SMBベースのファイルストレージ実装（Azure Files）
    """
    
    def __init__(self):
        # Azure Files クライアントの初期化
        self.connection_string = os.environ.get('AZURE_STORAGE_CONNECTION_STRING')
    
    def setup_azure_files_share(self, share_name):
        """
        Azure Files共有の設定
        """
        from azure.storage.fileshare import ShareServiceClient
        
        # ファイル共有サービスクライアントの作成
        service_client = ShareServiceClient.from_connection_string(
            self.connection_string
        )
        
        # ファイル共有の作成
        share_client = service_client.create_share(
            share_name,
            quota=5120  # 5TBのクォータ
        )
        
        # SMBマウントスクリプト（Windows）
        windows_mount_script = f"""
# PowerShell script for mounting Azure Files
$connectTestResult = Test-NetConnection -ComputerName <storage-account>.file.core.windows.net -Port 445
if ($connectTestResult.TcpTestSucceeded) {
    # 資格情報の保存
    cmd.exe /C "cmdkey /add:`"<storage-account>.file.core.windows.net`" /user:`"Azure\<storage-account>`" /pass:`"<storage-account-key>`""
    
    # ドライブのマウント
    New-PSDrive -Name Z -PSProvider FileSystem -Root "\\<storage-account>.file.core.windows.net\{share_name}" -Persist
} else {
    Write-Error -Message "Unable to reach the Azure storage account via port 445."
}
"""
        
        # SMBマウントスクリプト（Linux）
        linux_mount_script = f"""
#!/bin/bash
# Linux での Azure Files マウント

# cifs-utils のインストール
sudo apt update
sudo apt install cifs-utils -y

# 資格情報ファイルの作成
sudo mkdir -p /etc/smbcredentials
sudo bash -c 'echo "username=<storage-account>" > /etc/smbcredentials/<storage-account>.cred'
sudo bash -c 'echo "password=<storage-account-key>" >> /etc/smbcredentials/<storage-account>.cred'
sudo chmod 600 /etc/smbcredentials/<storage-account>.cred

# マウントポイントの作成
sudo mkdir -p /mnt/azurefiles

# fstab への追加
echo "//<storage-account>.file.core.windows.net/{share_name} /mnt/azurefiles cifs nofail,vers=3.0,credentials=/etc/smbcredentials/<storage-account>.cred,dir_mode=0777,file_mode=0777,serverino" | sudo tee -a /etc/fstab

# マウント実行
sudo mount -a
"""
        
        return {
            'share_name': share_name,
            'windows_mount': windows_mount_script,
            'linux_mount': linux_mount_script
        }

### パフォーマンスとスケーラビリティ

**スループットのスケーリング**

多くのマネージドファイルストレージは、保存データ量に応じて自動的にスループットをスケールします：

```python
class FileStoragePerformance:
    """
    ファイルストレージのパフォーマンス管理
    """
    
    def __init__(self):
        self.efs = boto3.client('efs')
        self.cloudwatch = boto3.client('cloudwatch')
    
    def configure_performance_mode(self, file_system_id, workload_type):
        """
        ワークロードに応じたパフォーマンスモード設定
        """
        performance_profiles = {
            'general_purpose': {
                'mode': 'generalPurpose',
                'latency': '低レイテンシ（1ms未満）',
                'max_throughput': '3GB/s',
                'operations_per_second': '7,000',
                'use_case': '大部分のワークロード'
            },
            'max_io': {
                'mode': 'maxIO',
                'latency': '若干高いレイテンシ',
                'max_throughput': '5GB/s',
                'operations_per_second': '500,000+',
                'use_case': '大規模並列ワークロード'
            }
        }
        
        # プロビジョンドスループットの設定（必要な場合）
        if workload_type == 'high_throughput':
            self.efs.put_file_system_policy(
                FileSystemId=file_system_id,
                Policy=json.dumps({
                    "Version": "2012-10-17",
                    "Statement": [{
                        "Effect": "Allow",
                        "Principal": {"AWS": "*"},
                        "Action": "elasticfilesystem:ClientMount",
                        "Resource": "*"
                    }]
                })
            )
            
            # プロビジョンドスループットモードへの変更
            self.efs.update_file_system(
                FileSystemId=file_system_id,
                ThroughputMode='provisioned',
                ProvisionedThroughputInMibps=1024  # 1GB/s
            )
        
        return performance_profiles.get(workload_type, performance_profiles['general_purpose'])
    
    def implement_caching_strategy(self):
        """
        キャッシング戦略の実装
        """
        caching_config = {
            'client_side_caching': {
                'nfs_options': {
                    'ac': 'アトリビュートキャッシュを有効化',
                    'actimeo=600': 'キャッシュタイムアウト（秒）',
                    'nocto': '近接オープンの一貫性チェックを無効化'
                },
                'benefits': '読み取り性能の向上',
                'considerations': 'データの一貫性に注意'
            },
            'metadata_caching': {
                'settings': {
                    'acdirmin=60': 'ディレクトリの最小キャッシュ時間',
                    'acdirmax=300': 'ディレクトリの最大キャッシュ時間',
                    'acregmin=60': 'ファイルの最小キャッシュ時間',
                    'acregmax=300': 'ファイルの最大キャッシュ時間'
                }
            }
        }
        
        return caching_config

class ContentManagementSystem:
    """
    CMSのための共有ストレージ設計
    """
    
    def __init__(self):
        self.efs = boto3.client('efs')
        self.autoscaling = boto3.client('autoscaling')
    
    def design_cms_storage_architecture(self):
        """
        CMS向けストレージアーキテクチャの設計
        """
        architecture = {
            'storage_structure': {
                '/shared/media': 'アップロードされた画像・動画',
                '/shared/cache': '生成されたキャッシュファイル',
                '/shared/themes': 'テーマファイル',
                '/shared/plugins': 'プラグインファイル',
                '/shared/uploads': 'ユーザーアップロード'
            },
            'performance_requirements': {
                'read_heavy': True,
                'write_occasional': True,
                'concurrent_access': 'High',
                'file_sizes': 'Mixed (KB to GB)'
            },
            'optimization_strategies': {
                'cdn_integration': 'CloudFront for static assets',
                'local_caching': 'Redis/Memcached for database queries',
                'image_optimization': 'Lambda for on-the-fly resizing'
            }
        }
        
        # Auto Scaling グループのユーザーデータ
        user_data_script = """#!/bin/bash
# EFS マウント
mkdir -p /var/www/shared
mount -t efs -o tls fs-12345678:/ /var/www/shared

# WordPress の設定例
ln -s /var/www/shared/uploads /var/www/html/wp-content/uploads
ln -s /var/www/shared/cache /var/www/html/wp-content/cache

# パーミッション設定
chown -R www-data:www-data /var/www/shared
chmod -R 755 /var/www/shared
"""
        
        return {
            'architecture': architecture,
            'user_data': user_data_script
        }

class HomeDirectoryService:
    """
    エンタープライズホームディレクトリサービス
    """
    
    def __init__(self):
        self.efs = boto3.client('efs')
        self.iam = boto3.client('iam')
    
    def setup_user_home_directories(self):
        """
        ユーザーホームディレクトリの設定
        """
        # EFSアクセスポイントの作成（ユーザーごと）
        def create_user_access_point(file_system_id, username, uid, gid):
            access_point = self.efs.create_access_point(
                FileSystemId=file_system_id,
                PosixUser={
                    'Uid': uid,
                    'Gid': gid
                },
                RootDirectory={
                    'Path': f'/home/{username}',
                    'CreationInfo': {
                        'OwnerUid': uid,
                        'OwnerGid': gid,
                        'Permissions': '750'
                    }
                },
                Tags=[
                    {'Key': 'Name', 'Value': f'{username}-home'},
                    {'Key': 'User', 'Value': username}
                ]
            )
            
            return access_point['AccessPointId']
        
        # ユーザー管理スクリプト
        user_management_script = """#!/bin/bash
# 新規ユーザー作成時のEFSセットアップ

create_efs_user() {
    local username=$1
    local uid=$2
    local gid=$3
    
    # システムユーザーの作成
    useradd -u $uid -g $gid -m -d /home/$username $username
    
    # EFSマウントポイントの作成
    mkdir -p /mnt/efs/home/$username
    
    # アクセスポイント経由でマウント
    mount -t efs -o tls,accesspoint=fsap-xxxx fs-yyyy:/ /home/$username
    
    # .bash_profile の設定
    cat > /home/$username/.bash_profile << EOF
# EFS home directory setup
export HOME=/home/$username
cd $HOME
EOF
    
    chown -R $username:$username /home/$username
}

# 使用例
create_efs_user "john.doe" 1001 1001
"""
        
        # クォータ管理
        quota_policy = {
            "Version": "2012-10-17",
            "Statement": [{
                "Effect": "Deny",
                "Principal": {"AWS": "*"},
                "Action": "elasticfilesystem:ClientWrite",
                "Resource": "*",
                "Condition": {
                    "NumericGreaterThan": {
                        "elasticfilesystem:AccessPointArn": "fsap-*"
                    }
                }
            }]
        }
        
        return {
            'user_script': user_management_script,
            'quota_policy': quota_policy
        }

class DevelopmentEnvironment:
    """
    開発環境向け共有ストレージ
    """
    
    def __init__(self):
        self.efs = boto3.client('efs')
        self.codebuild = boto3.client('codebuild')
    
    def setup_shared_development_storage(self):
        """
        開発チーム向け共有ストレージのセットアップ
        """
        storage_layout = {
            '/shared/repositories': {
                'purpose': 'Gitリポジトリのミラー',
                'permissions': '755',
                'group': 'developers'
            },
            '/shared/artifacts': {
                'purpose': 'ビルド成果物',
                'permissions': '775',
                'group': 'developers'
            },
            '/shared/cache': {
                'purpose': 'ビルドキャッシュ（Maven, npm等）',
                'permissions': '777',
                'group': 'developers'
            },
            '/shared/tools': {
                'purpose': '共通開発ツール',
                'permissions': '755',
                'group': 'developers'
            }
        }
        
        # CodeBuild プロジェクトでのEFS使用
        codebuild_project = {
            'name': 'shared-build-project',
            'environment': {
                'type': 'LINUX_CONTAINER',
                'image': 'aws/codebuild/standard:5.0',
                'computeType': 'BUILD_GENERAL1_LARGE'
            },
            'fileSystemLocations': [{
                'type': 'EFS',
                'location': 'fs-12345678.efs.us-east-1.amazonaws.com:/cache',
                'mountPoint': '/root/.m2',
                'identifier': 'maven_cache'
            }],
            'cache': {
                'type': 'LOCAL',
                'modes': ['LOCAL_SOURCE_CACHE', 'LOCAL_DOCKER_LAYER_CACHE']
            }
        }
        
        # 並行ビルドのための最適化
        concurrent_build_optimization = """
# ファイルロックの管理
flock -n /shared/cache/.lock command || exit 1

# NFSロックの最適化
echo 0 > /proc/sys/fs/leases-enable

# ビルドディレクトリの分離
BUILD_DIR="/shared/artifacts/build-$(date +%s)-$$"
mkdir -p "$BUILD_DIR"
"""
        
        return {
            'storage_layout': storage_layout,
            'codebuild_config': codebuild_project,
            'optimization_script': concurrent_build_optimization
        }