面接対策：システムデザインラウンド — 顧客デプロイを前提とした設計

# app/middleware/tenant_router.rb
class TenantRouter
  ISOLATED_TENANTS = Rails.application.config.isolated_tenants
 
  def initialize(app)
    @app = app
  end
 
  def call(env)
    request = ActionDispatch::Request.new(env)
    tenant_id = extract_tenant_id(request)
 
    if ISOLATED_TENANTS.include?(tenant_id)
      # 専用DBに接続を切り替え
      ActiveRecord::Base.connected_to(
        role: :writing,
        shard: :"tenant_#{tenant_id}"
      ) do
        @app.call(env)
      end
    else
      # 共有DBで行レベル分離
      Current.tenant_id = tenant_id
      @app.call(env)
    end
  end
 
  private
 
  def extract_tenant_id(request)
    request.headers["X-Tenant-ID"] ||
      request.subdomain.presence ||
      raise(TenantNotFoundError)
  end
end

# app/services/migration/cdc_processor.rb
module Migration
  class CdcProcessor
    def initialize(tenant:, source_config:)
      @tenant = tenant
      @source_config = source_config
      @kinesis = Aws::Kinesis::Client.new
    end
 
    def process_change_event(event)
      case event[:operation]
      when "INSERT"
        upsert_record(event[:after])
      when "UPDATE"
        upsert_record(event[:after])
      when "DELETE"
        soft_delete_record(event[:before])
      end
 
      record_checkpoint(event[:lsn])
    end
 
    private
 
    def upsert_record(data)
      transformed = DataTransformer.transform(
        data,
        source_schema: @source_config[:schema],
        target_schema: :current
      )
 
      target_model = transformed[:model].constantize
      target_model.upsert(
        transformed[:attributes],
        unique_by: transformed[:unique_key]
      )
    end
 
    def record_checkpoint(lsn)
      MigrationCheckpoint.upsert(
        { tenant_id: @tenant.id, lsn: lsn, recorded_at: Time.current },
        unique_by: :tenant_id
      )
    end
  end
end

# app/middleware/region_router.rb
class RegionRouter
  REGION_MAP = {
    "eu" => { database: :eu_primary, s3_bucket: "arclight-eu" },
    "ap" => { database: :ap_primary, s3_bucket: "arclight-ap" }
  }.freeze
 
  def initialize(app)
    @app = app
  end
 
  def call(env)
    request = ActionDispatch::Request.new(env)
    region = determine_region(request)
    config = REGION_MAP.fetch(region)
 
    ActiveRecord::Base.connected_to(
      role: :writing,
      shard: config[:database]
    ) do
      Current.region = region
      Current.s3_bucket = config[:s3_bucket]
      @app.call(env)
    end
  end
 
  private
 
  def determine_region(request)
    # 顧客のデータレジデンシー設定を優先
    tenant = Tenant.find_by(
      subdomain: request.subdomain
    )
    tenant&.data_residency_region || "ap"
  end
end

# app/services/ai/inference_router.rb
module AI
  class InferenceRouter
    def initialize(tenant:)
      @tenant = tenant
      @sagemaker = Aws::SageMakerRuntime::Client.new(
        endpoint_url: tenant.sagemaker_endpoint_url
      )
    end
 
    def predict(input)
      variant = select_variant
      response = @sagemaker.invoke_endpoint(
        endpoint_name: @tenant.endpoint_name,
        body: input.to_json,
        content_type: "application/json",
        target_variant: variant.name
      )
 
      result = JSON.parse(response.body.read)
      record_prediction(variant, input, result)
      result
    end
 
    private
 
    def select_variant
      variants = ModelVariant.where(
        tenant: @tenant,
        status: :active
      )
 
      # トラフィック分配に基づいて選択
      roll = SecureRandom.random_number(100)
      cumulative = 0
      variants.find do |v|
        cumulative += v.traffic_percentage
        roll < cumulative
      end
    end
 
    def record_prediction(variant, input, result)
      PredictionLog.create!(tenant: @tenant, variant: variant,
        input_hash: Digest::SHA256.hexdigest(input.to_json),
        latency_ms: result["latency_ms"], model_version: variant.model_version)
    end
  end
end

# app/models/audit_log.rb
class AuditLog < ApplicationRecord
  # 更新・削除を禁止
  def readonly?
    persisted?
  end
 
  before_destroy { raise ActiveRecord::ReadOnlyRecord }
 
  before_create :generate_integrity_hash
  before_create :set_sequence_number
 
  scope :for_tenant, ->(tenant) { where(tenant_id: tenant.id) }
  scope :in_period, ->(from, to) { where(occurred_at: from..to) }
 
  private
 
  def generate_integrity_hash
    previous = AuditLog.where(tenant_id: tenant_id)
                       .order(sequence_number: :desc)
                       .first
 
    payload = {
      tenant_id: tenant_id,
      action: action,
      actor_id: actor_id,
      resource: resource_type,
      resource_id: resource_id,
      changes: changes_json,
      occurred_at: occurred_at.iso8601,
      previous_hash: previous&.integrity_hash || "GENESIS"
    }
 
    self.integrity_hash = OpenSSL::Digest::SHA256.hexdigest(
      payload.to_json
    )
  end
 
  def set_sequence_number
    last_seq = AuditLog.where(tenant_id: tenant_id)
                       .maximum(:sequence_number) || 0
    self.sequence_number = last_seq + 1
  end
end

# config/initializers/omniauth.rb
Rails.application.config.middleware.use OmniAuth::Builder do
  # テナントごとに動的に SAML 設定を読み込む
  provider :saml,
    setup: ->(env) {
      request = Rack::Request.new(env)
      tenant = Tenant.find_by!(
        subdomain: request.subdomain
      )
      sso = tenant.sso_configuration
 
      env["omniauth.strategy"].options.merge!(
        issuer: "https://#{tenant.subdomain}.arclight.ai",
        idp_sso_service_url: sso.idp_sso_url,
        idp_cert_fingerprint: sso.idp_cert_fingerprint,
        name_identifier_format:
          "urn:oasis:names:tc:SAML:1.1:nameid-format:emailAddress",
        attribute_statements: {
          email: [sso.email_attribute || "email"],
          name: [sso.name_attribute || "displayName"],
          groups: [sso.groups_attribute || "memberOf"]
        }
      )
    }
end

# app/services/sso/jit_provisioner.rb
module SSO
  class JitProvisioner
    def initialize(tenant:)
      @tenant = tenant
    end
 
    def provision(auth_hash)
      user = find_or_create_user(auth_hash)
      sync_group_memberships(user, auth_hash)
      sync_permissions(user)
      user
    end
 
    private
 
    def find_or_create_user(auth_hash)
      email = auth_hash.info.email.downcase
      user = @tenant.users.find_by(email: email)
 
      if user
        update_user_attributes(user, auth_hash)
      else
        create_user(auth_hash)
      end
    end
 
    def create_user(auth_hash)
      @tenant.users.create!(
        email: auth_hash.info.email.downcase,
        name: auth_hash.info.name,
        sso_uid: auth_hash.uid,
        sso_provider: "saml",
        password: SecureRandom.hex(32) # SSO専用なので不使用
      )
    end
 
    def sync_group_memberships(user, auth_hash)
      idp_groups = auth_hash.extra.raw_info
                            .attributes["groups"] || []
 
      mappings = @tenant.group_mappings
      mapped_roles = mappings.select { |m|
        idp_groups.include?(m.idp_group_name)
      }.map(&:app_role)
 
      user.update!(roles: mapped_roles)
    end
 
    def sync_permissions(user)
      permissions = user.roles.flat_map { |role|
        RolePermission.where(role: role).pluck(:permission) }.uniq
      user.update!(permissions: permissions)
    end
  end
end