スケーリングの基礎 — 垂直 vs 水平

# EchoTaskのPuma設定（垂直スケール後）
# config/puma.rb
workers ENV.fetch("WEB_CONCURRENCY") { 4 }  # CPUコア数に依存
threads_count = ENV.fetch("RAILS_MAX_THREADS") { 5 }
threads threads_count, threads_count
 
# 16コアのサーバーでも、workers を増やせばメモリが枯渇する
# 1 worker ≒ 350〜500 MB のメモリを消費する（Rails + Puma の場合）
# 16コア × 5スレッド = 最大80リクエスト同時処理... しかし
# 16 workers × 450 MB = 7.2 GB のメモリが必要

# 問題のあるコード: ローカルファイルにセッションを保存
# config/initializers/session_store.rb（悪い例）
Rails.application.config.session_store :file_store, "/tmp/sessions"
# ↑ サーバーが複数台になると、サーバー1でログインしても
# サーバー2にリクエストが届いたときに「未ログイン」扱いになる！

# ===== ステートフル（悪い例）=====
# config/initializers/session_store.rb
Rails.application.config.session_store :file_store, "/tmp/sessions"
# /tmp/sessions はそのサーバーだけに存在する。他のサーバーには届かない
 
# ===== ステートレス（良い例）=====
# Gemfile
gem 'redis'
gem 'redis-session-store'
 
# config/initializers/session_store.rb
Rails.application.config.session_store :redis_store,
  servers: [ENV['REDIS_URL']],
  expire_after: 90.minutes,
  key: '_echo_task_session',
  secure: Rails.env.production?

# ===== ステートフル（悪い例）=====
# app/controllers/tasks_controller.rb
def create
  file = params[:attachment]
  path = Rails.root.join("public/uploads", file.original_filename)
  File.write(path, file.read)  # このサーバーのディスクにだけ保存される
  # → 他のサーバーからこのファイルは参照できない
end
 
# ===== ステートレス（良い例）=====
# config/storage.yml
amazon:
  service: S3
  region: ap-northeast-1
  bucket: <%= ENV['S3_BUCKET'] %>
  # アクセスキーは IAM Role（EC2/ECS のインスタンスロール）で自動付与
  # ハードコードしない
 
# config/environments/production.rb
config.active_storage.service = :amazon
 
# app/models/task.rb
class Task < ApplicationRecord
  has_one_attached :attachment
  # Active Storage が S3 への保存・参照を透過的に処理してくれる
end

# ===== ステートフル（悪い例）=====
# config/environments/production.rb
config.cache_store = :file_store, "/tmp/cache"
# → 各サーバーが独自のキャッシュを持つ。キャッシュの内容が一致しない
 
# ===== ステートレス（良い例）=====
config.cache_store = :redis_cache_store, {
  url: ENV['REDIS_URL'],
  expires_in: 1.hour,
  namespace: 'echo_task_cache'
}

# ===== ステートフル（悪い例）=====
# config/cable.yml（デフォルト）
production:
  adapter: async
# → async アダプターはプロセス内のみ。複数台では通知が届かない
 
# ===== ステートレス（良い例）=====
# config/cable.yml
production:
  adapter: redis
  url: <%= ENV['REDIS_URL'] %>
  channel_prefix: echo_task_production
# → Redis の Pub/Sub を通じて全サーバーに通知が届く

# Dockerfile
 
# ===== ステージ1: ビルド =====
FROM ruby:3.3-slim AS builder
 
# ビルドに必要なパッケージ（本番イメージには含めない）
RUN apt-get update && apt-get install -y \
    build-essential \
    libpq-dev \
    git \
    curl \
    && rm -rf /var/lib/apt/lists/*
 
WORKDIR /app
 
# Gemfile だけ先にコピー（キャッシュを活かす）
COPY Gemfile Gemfile.lock ./
RUN bundle config set --local without 'development test' \
    && bundle install --jobs 4 --retry 3
 
# アプリケーションコードをコピー
COPY . .
 
# アセットプリコンパイル
RUN SECRET_KEY_BASE=dummy RAILS_ENV=production bundle exec rails assets:precompile
 
# ===== ステージ2: 本番イメージ =====
FROM ruby:3.3-slim AS production
 
RUN apt-get update && apt-get install -y \
    libpq5 \
    curl \
    && rm -rf /var/lib/apt/lists/*
 
# 非rootユーザーで実行（セキュリティ向上）
RUN groupadd -r app && useradd -r -g app app
 
WORKDIR /app
 
# ビルドステージから成果物だけコピー
COPY --from=builder /usr/local/bundle /usr/local/bundle
COPY --from=builder /app /app
 
RUN chown -R app:app /app
USER app
 
EXPOSE 3000
 
CMD ["bundle", "exec", "puma", "-C", "config/puma.rb"]

# ECR リポジトリを作成（初回のみ）
aws ecr create-repository \
  --repository-name echo-task \
  --region ap-northeast-1
 
# ECR にログイン
aws ecr get-login-password --region ap-northeast-1 \
  | docker login --username AWS \
    --password-stdin 123456789012.dkr.ecr.ap-northeast-1.amazonaws.com
 
# ビルド & タグ付け
docker build -t echo-task:latest .
docker tag echo-task:latest \
  123456789012.dkr.ecr.ap-northeast-1.amazonaws.com/echo-task:latest
 
# プッシュ
docker push 123456789012.dkr.ecr.ap-northeast-1.amazonaws.com/echo-task:latest

# SSM に SecureString（暗号化）でパラメータを登録
aws ssm put-parameter \
  --name "/echo-task/production/DATABASE_URL" \
  --value "postgresql://user:password@rds-endpoint:5432/echo_task_production" \
  --type SecureString \
  --region ap-northeast-1
 
aws ssm put-parameter \
  --name "/echo-task/production/REDIS_URL" \
  --value "redis://elasticache-endpoint:6379/0" \
  --type SecureString \
  --region ap-northeast-1
 
aws ssm put-parameter \
  --name "/echo-task/production/SECRET_KEY_BASE" \
  --value "$(openssl rand -hex 64)" \
  --type SecureString \
  --region ap-northeast-1
 
# 登録済みのパラメータ一覧を確認（値は表示しない）
aws ssm describe-parameters \
  --filters "Key=Path,Values=/echo-task/production" \
  --query "Parameters[*].{Name:Name,Type:Type}" \
  --output table

{
  "family": "echo-task-web",
  "taskRoleArn": "arn:aws:iam::123456789012:role/echo-task-task-role",
  "executionRoleArn": "arn:aws:iam::123456789012:role/echo-task-execution-role",
  "containerDefinitions": [
    {
      "name": "rails",
      "image": "123456789012.dkr.ecr.ap-northeast-1.amazonaws.com/echo-task:latest",
      "memory": 512,
      "cpu": 256,
      "essential": true,
      "portMappings": [
        { "containerPort": 3000, "protocol": "tcp" }
      ],
      "environment": [
        { "name": "RAILS_ENV", "value": "production" },
        { "name": "RAILS_LOG_TO_STDOUT", "value": "true" }
      ],
      "secrets": [
        {
          "name": "DATABASE_URL",
          "valueFrom": "arn:aws:ssm:ap-northeast-1:123456789012:parameter/echo-task/production/DATABASE_URL"
        },
        {
          "name": "REDIS_URL",
          "valueFrom": "arn:aws:ssm:ap-northeast-1:123456789012:parameter/echo-task/production/REDIS_URL"
        },
        {
          "name": "SECRET_KEY_BASE",
          "valueFrom": "arn:aws:ssm:ap-northeast-1:123456789012:parameter/echo-task/production/SECRET_KEY_BASE"
        }
      ],
      "logConfiguration": {
        "logDriver": "awslogs",
        "options": {
          "awslogs-group": "/ecs/echo-task",
          "awslogs-region": "ap-northeast-1",
          "awslogs-stream-prefix": "web"
        }
      }
    }
  ]
}

# cloudformation/autoscaling.yml
 
# --- スケーラブルターゲット（ECS サービス）---
ECSScalableTarget:
  Type: AWS::ApplicationAutoScaling::ScalableTarget
  Properties:
    ServiceNamespace: ecs
    ResourceId: !Sub "service/${ECSCluster}/${ECSService}"
    ScalableDimension: ecs:service:DesiredCount
    MinCapacity: 2   # 最小2タスク（冗長性を確保）
    MaxCapacity: 20  # 最大20タスク
 
# --- CPU 使用率によるスケーリング ---
CPUScalingPolicy:
  Type: AWS::ApplicationAutoScaling::ScalingPolicy
  Properties:
    PolicyName: echo-task-cpu-scaling
    PolicyType: TargetTrackingScaling
    ScalingTargetId: !Ref ECSScalableTarget
    TargetTrackingScalingPolicyConfiguration:
      TargetValue: 60.0   # CPU 60% を維持
      ScaleInCooldown: 300   # スケールイン後、300秒は様子見
      ScaleOutCooldown: 60   # スケールアウトは60秒で素早く
      PredefinedMetricSpecification:
        PredefinedMetricType: ECSServiceAverageCPUUtilization
 
# --- メモリ使用率によるスケーリング ---
MemoryScalingPolicy:
  Type: AWS::ApplicationAutoScaling::ScalingPolicy
  Properties:
    PolicyName: echo-task-memory-scaling
    PolicyType: TargetTrackingScaling
    ScalingTargetId: !Ref ECSScalableTarget
    TargetTrackingScalingPolicyConfiguration:
      TargetValue: 70.0   # メモリ 70% を維持
      ScaleInCooldown: 300
      ScaleOutCooldown: 60
      PredefinedMetricSpecification:
        PredefinedMetricType: ECSServiceAverageMemoryUtilization
 
# --- ALB リクエスト数によるスケーリング ---
RequestCountScalingPolicy:
  Type: AWS::ApplicationAutoScaling::ScalingPolicy
  Properties:
    PolicyName: echo-task-request-scaling
    PolicyType: TargetTrackingScaling
    ScalingTargetId: !Ref ECSScalableTarget
    TargetTrackingScalingPolicyConfiguration:
      TargetValue: 1000.0   # タスク1台あたり1000リクエスト/分
      ScaleInCooldown: 300
      ScaleOutCooldown: 30   # リクエスト急増には即座に対応
      PredefinedMetricSpecification:
        PredefinedMetricType: ALBRequestCountPerTarget
        ResourceLabel: !Sub
          - "${ALBArn}/${TargetGroupArn}"
          - ALBArn: !GetAtt ALB.LoadBalancerFullName
            TargetGroupArn: !GetAtt TargetGroup.TargetGroupFullName

# Sidekiq のキュー長を CloudWatch にプッシュする例
# bin/push-sidekiq-metrics.sh（cronやサイドカーコンテナで定期実行）
 
#!/bin/bash
QUEUE_SIZE=$(redis-cli -u "$REDIS_URL" llen "queue:default")
 
aws cloudwatch put-metric-data \
  --region ap-northeast-1 \
  --namespace "EchoTask/Sidekiq" \
  --metric-data \
    MetricName=QueueDepth,Value="$QUEUE_SIZE",Unit=Count

# キュー長によるワーカースケーリング
SidekiqScalingPolicy:
  Type: AWS::ApplicationAutoScaling::ScalingPolicy
  Properties:
    PolicyName: echo-task-sidekiq-scaling
    PolicyType: TargetTrackingScaling
    ScalingTargetId: !Ref SidekiqScalableTarget
    TargetTrackingScalingPolicyConfiguration:
      TargetValue: 50.0   # ワーカー1台あたりキュー50件
      CustomizedMetricSpecification:
        MetricName: QueueDepth
        Namespace: EchoTask/Sidekiq
        Statistic: Average

// cmd/api/main.go
package main
 
import (
	"encoding/json"
	"log"
	"net/http"
	"os"
	"time"
 
	"github.com/redis/go-redis/v9"
)
 
// すべての状態はリクエストのコンテキストか外部ストレージに持つ
// サーバー自体はメモリに何も保持しない（ステートレス）
 
var redisClient *redis.Client
 
func init() {
	redisURL := os.Getenv("REDIS_URL")
	opts, err := redis.ParseURL(redisURL)
	if err != nil {
		log.Fatalf("Redis URL の解析に失敗: %v", err)
	}
	redisClient = redis.NewClient(opts)
}
 
// ヘルスチェックエンドポイント
// ALB や ECS のヘルスチェックはここを叩く
func healthHandler(w http.ResponseWriter, r *http.Request) {
	ctx := r.Context()
 
	// Redis への疎通確認も含める
	if err := redisClient.Ping(ctx).Err(); err != nil {
		http.Error(w, "Redis connection failed", http.StatusServiceUnavailable)
		return
	}
 
	w.Header().Set("Content-Type", "application/json")
	json.NewEncoder(w).Encode(map[string]string{
		"status": "ok",
		"time":   time.Now().UTC().Format(time.RFC3339),
	})
}
 
// タスク取得エンドポイント
// DB クエリ結果を Redis にキャッシュ（ステートレスなキャッシュ戦略）
func tasksHandler(w http.ResponseWriter, r *http.Request) {
	ctx := r.Context()
	cacheKey := "tasks:list"
 
	// キャッシュから取得を試みる
	cached, err := redisClient.Get(ctx, cacheKey).Bytes()
	if err == nil {
		w.Header().Set("Content-Type", "application/json")
		w.Header().Set("X-Cache", "HIT")
		w.Write(cached)
		return
	}
 
	// キャッシュミス → DB から取得（省略）
	tasks := fetchTasksFromDB()
 
	data, _ := json.Marshal(tasks)
 
	// Redis にキャッシュ（TTL: 60秒）
	redisClient.Set(ctx, cacheKey, data, 60*time.Second)
 
	w.Header().Set("Content-Type", "application/json")
	w.Header().Set("X-Cache", "MISS")
	w.Write(data)
}
 
func main() {
	mux := http.NewServeMux()
	mux.HandleFunc("/health", healthHandler)
	mux.HandleFunc("/api/tasks", tasksHandler)
 
	port := os.Getenv("PORT")
	if port == "" {
		port = "8080"
	}
 
	log.Printf("サーバー起動: :%s", port)
	if err := http.ListenAndServe(":"+port, mux); err != nil {
		log.Fatal(err)
	}
}
 
func fetchTasksFromDB() []map[string]interface{} {
	// 実装省略（database/sql でクエリ）
	return nil
}