モノリシックアーキテクチャ — 一枚岩の価値

# app/models/order.rb
class Order < ApplicationRecord
  belongs_to :user
  belongs_to :product
  has_many :order_items
  
  validates :status, inclusion: { in: %w[pending paid shipped delivered] }
  
  # ビジネスロジックがモデルに集約される
  def total_price
    order_items.sum { |item| item.quantity * item.unit_price }
  end
  
  def can_cancel?
    status.in?(%w[pending paid])
  end
end
 
# app/services/order_service.rb
class OrderService
  def create_order(user:, cart:)
    ActiveRecord::Base.transaction do
      order = Order.create!(user: user, status: 'pending')
      
      cart.items.each do |cart_item|
        order.order_items.create!(
          product: cart_item.product,
          quantity: cart_item.quantity,
          unit_price: cart_item.product.price
        )
        
        # 在庫更新も同一トランザクション内
        cart_item.product.decrement!(:stock_count, cart_item.quantity)
      end
      
      order
    end
  end
end

# 新機能を追加するとき、全てのレイヤーを一度に変更できる
# マイグレーション
rails generate migration AddCouponToOrders coupon_code:string discount_amount:decimal
 
# モデル
class Order < ApplicationRecord
  attribute :coupon_code, :string
  attribute :discount_amount, :decimal, default: 0
  
  def final_price
    [total_price - discount_amount, 0].max
  end
end
 
# コントローラ
class OrdersController < ApplicationController
  def create
    result = OrderService.new.create_order(
      user: current_user,
      cart: current_cart,
      coupon_code: params[:coupon_code]
    )
    # ...
  end
end

# 注文・在庫・決済を全て同一トランザクションで処理できる
ActiveRecord::Base.transaction do
  order = Order.create!(...)
  inventory.decrement_stock!(...)
  payment = PaymentRecord.create!(...)
  
  # どこかで例外が起きれば全部ロールバック
  # マイクロサービスでこれをやろうとすると
  # 分散トランザクション（Saga パターン等）が必要になる
end

# ログにリクエストIDを付与するだけで、一連の処理を追える
class ApplicationController < ActionController::Base
  before_action :set_request_id
  
  private
  
  def set_request_id
    RequestStore.store[:request_id] = request.uuid
    Rails.logger.info "[#{request.uuid}] #{request.method} #{request.path}"
  end
end

# RSpecで統合テストが自然に書ける
RSpec.describe 'Order creation flow' do
  it 'creates order, decrements inventory, and sends confirmation email' do
    product = create(:product, stock_count: 10)
    user = create(:user)
    
    # 全部が同一プロセスで動くので、直接確認できる
    expect {
      post '/api/orders', params: { product_id: product.id, quantity: 2 }
    }.to change { Order.count }.by(1)
      .and change { product.reload.stock_count }.by(-2)
      .and have_enqueued_mail(OrderMailer, :confirmation)
  end
end

# AWSでのモノリス構成
# インフラはシンプルでコストも低い
AWSデプロイ構成:
  - EC2 or ECS (単一サービス)
  - RDS (PostgreSQL)
  - ElastiCache (Redis)
  - ALB (ロードバランサー)
  
必要なアラート:
  - CPU使用率
  - メモリ使用率
  - エラーレート
  - レスポンスタイム

# ECSタスク定義（簡略版）
taskDefinition:
  family: mybook-ec-web
  cpu: "512"
  memory: "1024"
  containerDefinitions:
    - name: rails
      image: "123456789.dkr.ecr.ap-northeast-1.amazonaws.com/mybook-ec:latest"
      portMappings:
        - containerPort: 3000
      environment:
        - name: DATABASE_URL
          valueFrom: "arn:aws:secretsmanager:..."
        - name: REDIS_URL
          value: "redis://mybook-redis.xxx.cache.amazonaws.com:6379"
      healthCheck:
        command: ["CMD-SHELL", "curl -f http://localhost:3000/health || exit 1"]

# Rails Engine を使ったモジュール分割
# engines/catalog/app/models/catalog/product.rb
module Catalog
  class Product < ApplicationRecord
    self.table_name = 'catalog_products'
    
    validates :name, presence: true
    validates :price, numericality: { greater_than: 0 }
  end
end
 
# engines/ordering/app/models/ordering/order.rb
module Ordering
  class Order < ApplicationRecord
    self.table_name = 'ordering_orders'
    
    # CatalogモジュールへはAPIを通じてアクセス（直接モデルを触らない）
    def product
      Catalog::ProductFinder.find(product_id)
    end
  end
end