クラウドアーキテクトの面接対策：完全ガイド

# 移行評価ツール
class MigrationAssessment:
    def __init__(self, application):
        self.app = application
        self.score = 0
    
    def assess_cloud_readiness(self):
        factors = {
            'architecture': self.check_architecture(),
            'dependencies': self.check_dependencies(),
            'data_volume': self.check_data_volume(),
            'compliance': self.check_compliance(),
            'performance': self.check_performance_requirements()
        }
        
        # 移行の複雑さを計算する
        complexity = sum(factors.values()) / len(factors)
        
        if complexity < 3:
            return "リホスト - 低い複雑さ"
        elif complexity < 6:
            return "リプラットフォーム - 中程度の複雑さ"
        else:
            return "リファクタリング - 高い複雑さ"
    
    def generate_migration_plan(self):
        return {
            'phase_1': '評価と計画',
            'phase_2': '概念実証',
            'phase_3': 'データ移行',
            'phase_4': 'アプリケーション移行',
            'phase_5': 'テストと検証',
            'phase_6': 'カットオーバーと本番稼働',
            'phase_7': '最適化'
        }

# 例：AWS DMSを使用したデータベース移行
aws dms create-replication-instance \
    --replication-instance-identifier migration-instance \
    --replication-instance-class dms.t2.medium

# 移行タスクの作成
aws dms create-replication-task \
    --replication-task-identifier db-migration \
    --source-endpoint-arn arn:aws:dms:region:account:endpoint/source \
    --target-endpoint-arn arn:aws:dms:region:account:endpoint/target \
    --migration-type full-load-and-cdc

# 同期（REST API）
import requests

def get_user(user_id):
    response = requests.get(f'http://user-service/api/users/{user_id}')
    return response.json()

# 非同期（メッセージキュー）
import pika

def publish_order_event(order_data):
    connection = pika.BlockingConnection(pika.ConnectionParameters('rabbitmq'))
    channel = connection.channel()
    channel.queue_declare(queue='orders')
    channel.basic_publish(
        exchange='',
        routing_key='orders',
        body=json.dumps(order_data)
    )
    connection.close()

# トラフィックルーティングのための仮想サービス
apiVersion: networking.istio.io/v1beta1
kind: VirtualService
metadata:
  name: reviews-route
spec:
  hosts:
  - reviews
  http:
  - match:
    - headers:
        user-type:
          exact: premium
    route:
    - destination:
        host: reviews
        subset: v2
      weight: 100
  - route:
    - destination:
        host: reviews
        subset: v1
      weight: 90
    - destination:
        host: reviews
        subset: v2
      weight: 10

---
# 負荷分散のための宛先ルール
apiVersion: networking.istio.io/v1beta1
kind: DestinationRule
metadata:
  name: reviews-destination
spec:
  host: reviews
  trafficPolicy:
    loadBalancer:
      simple: LEAST_REQUEST
    connectionPool:
      tcp:
        maxConnections: 100
      http:
        http1MaxPendingRequests: 50
        maxRequestsPerConnection: 2
  subsets:
  - name: v1
    labels:
      version: v1
  - name: v2
    labels:
      version: v2

apiVersion: networking.istio.io/v1beta1
kind: DestinationRule
metadata:
  name: circuit-breaker
spec:
  host: payment-service
  trafficPolicy:
    outlierDetection:
      consecutiveErrors: 5
      interval: 30s
      baseEjectionTime: 30s
      maxEjectionPercent: 50

apiVersion: security.istio.io/v1beta1
kind: PeerAuthentication
metadata:
  name: default
  namespace: production
spec:
  mtls:
    mode: STRICT

---
apiVersion: security.istio.io/v1beta1
kind: AuthorizationPolicy
metadata:
  name: allow-read
spec:
  action: ALLOW
  rules:
  - from:
    - source:
        principals: ["cluster.local/ns/default/sa/frontend"]
    to:
    - operation:
        methods: ["GET"]

# 可観測性アドオンを使用してIstioをインストールする
istioctl install --set profile=demo

# Kiali、Prometheus、Grafana、Jaegerをデプロイする
kubectl apply -f samples/addons/

# Kialiダッシュボードにアクセスする
istioctl dashboard kiali

from enum import Enum
import time

class CircuitState(Enum):
    CLOSED = "closed"
    OPEN = "open"
    HALF_OPEN = "half_open"

class CircuitBreaker:
    def __init__(self, failure_threshold=5, timeout=60, success_threshold=2):
        self.failure_threshold = failure_threshold
        self.timeout = timeout
        self.success_threshold = success_threshold
        self.failures = 0
        self.successes = 0
        self.last_failure_time = None
        self.state = CircuitState.CLOSED
    
    def call(self, func, *args, **kwargs):
        if self.state == CircuitState.OPEN:
            if time.time() - self.last_failure_time > self.timeout:
                self.state = CircuitState.HALF_OPEN
                self.successes = 0
            else:
                raise Exception("サーキットブレーカーは開いています")
        
        try:
            result = func(*args, **kwargs)
            self.on_success()
            return result
        except Exception as e:
            self.on_failure()
            raise e
    
    def on_success(self):
        self.failures = 0
        if self.state == CircuitState.HALF_OPEN:
            self.successes += 1
            if self.successes >= self.success_threshold:
                self.state = CircuitState.CLOSED
    
    def on_failure(self):
        self.failures += 1
        self.last_failure_time = time.time()
        if self.failures >= self.failure_threshold:
            self.state = CircuitState.OPEN

# 使用例
breaker = CircuitBreaker()
result = breaker.call(external_api_call, user_id=123)

from kafka import KafkaProducer, KafkaConsumer
import json
from datetime import datetime

# イベントプロデューサー
class OrderEventProducer:
    def __init__(self):
        self.producer = KafkaProducer(
            bootstrap_servers=['localhost:9092'],
            value_serializer=lambda v: json.dumps(v).encode('utf-8')
        )
    
    def publish_order_created(self, order_id, customer_id, items, total):
        event = {
            'event_type': 'OrderCreated',
            'event_id': str(uuid.uuid4()),
            'timestamp': datetime.utcnow().isoformat(),
            'data': {
                'order_id': order_id,
                'customer_id': customer_id,
                'items': items,
                'total': total
            }
        }
        self.producer.send('order-events', value=event)
        self.producer.flush()

# イベントコンシューマー
class InventoryEventConsumer:
    def __init__(self):
        self.consumer = KafkaConsumer(
            'order-events',
            bootstrap_servers=['localhost:9092'],
            value_deserializer=lambda m: json.loads(m.decode('utf-8')),
            group_id='inventory-service'
        )
    
    def process_events(self):
        for message in self.consumer:
            event = message.value
            if event['event_type'] == 'OrderCreated':
                self.reserve_inventory(event['data'])
    
    def reserve_inventory(self, order_data):
        # 在庫予約ロジック
        print(f"注文 {order_data['order_id']} の在庫を予約しています")
        # InventoryReservedイベントを発行する

# 現在の状態ではなくイベントを保存する
class EventStore:
    def __init__(self):
        self.events = []
    
    def append(self, event):
        self.events.append(event)
    
    def get_events(self, aggregate_id):
        return [e for e in self.events if e['aggregate_id'] == aggregate_id]

# イベントから状態を再構築する
class OrderAggregate:
    def __init__(self, order_id):
        self.order_id = order_id
        self.status = 'pending'
        self.items = []
        self.total = 0
    
    def apply_event(self, event):
        if event['type'] == 'OrderCreated':
            self.items = event['data']['items']
            self.total = event['data']['total']
        elif event['type'] == 'OrderPaid':
            self.status = 'paid'
        elif event['type'] == 'OrderShipped':
            self.status = 'shipped'
    
    def rebuild_from_events(self, events):
        for event in events:
            self.apply_event(event)

# 自動フェイルオーバースクリプト
def initiate_failover():
    # 1. プライマリへの書き込みを停止する
    stop_primary_writes()
    
    # 2. セカンダリデータベースを昇格させる
    promote_secondary_to_primary()
    
    # 3. DNSを更新する
    update_route53_failover()
    
    # 4. DRリージョンサービスを開始する
    start_dr_services()
    
    # 5. ヘルスを検証する
    verify_dr_health()
    
    # 6. チームに通知する
    send_alert("DRリージョンへのフェイルオーバーが完了しました")

# 例：条件付きアクセスポリシー
policies:
  - name: "機密アプリにMFAを要求する"
    conditions:
      applications: ["finance-app", "hr-system"]
      users: ["all"]
    controls:
      - require_mfa: true
      - require_compliant_device: true
      - allowed_locations: ["corporate-network", "vpn"]

# コスト比較ツール
def calculate_cost(provider, instance_type, hours):
    pricing = {
        'aws': {'on_demand': 0.10, 'spot': 0.03, 'reserved': 0.06},
        'gcp': {'on_demand': 0.095, 'preemptible': 0.028, 'committed': 0.057},
        'azure': {'on_demand': 0.105, 'spot': 0.032, 'reserved': 0.063}
    }
    
    return {
        'on_demand': pricing[provider]['on_demand'] * hours,
        'spot': pricing[provider]['spot'] * hours,
        'reserved': pricing[provider]['reserved'] * hours
    }