見積もりの技術 — バックオブエンベロープ計算

# 時間換算（覚えておくべき数字）
1分   = 60秒
1時間 = 3,600秒  ≒ 4,000秒（丸めてOK）
1日   = 86,400秒 ≒ 10万秒（最重要！）
1週間 = 約60万秒
1ヶ月 = 約260万秒
1年   = 約3,000万秒（3 × 10^7）

# データ量の単位
1 KB = 1,024 バイト ≒ 10^3 バイト
1 MB = 1,024 KB    ≒ 10^6 バイト
1 GB = 1,024 MB    ≒ 10^9 バイト
1 TB = 1,024 GB    ≒ 10^12 バイト
1 PB = 1,024 TB    ≒ 10^15 バイト
 
# データ型別サイズ（概算）
文字1文字         = 1〜2バイト（ASCII/UTF-8）
整数(int)        = 4バイト
Long型           = 8バイト
UUID/GUID        = 36バイト（文字列）/ 16バイト（バイナリ）
日時(timestamp)  = 8バイト
ユーザーレコード   = 約1KB
Twitterツイート   = 約300バイト
画像（サムネイル） = 約300KB
フルサイズ画像    = 約3MB
動画（1分/1080p） = 約150MB

# SLA（Service Level Agreement）
可用性99%    → 年間ダウン時間 約88時間
可用性99.9%  → 年間ダウン時間 約9時間  （"スリーナイン"）
可用性99.99% → 年間ダウン時間 約1時間  （"フォーナイン"）
可用性99.999%→ 年間ダウン時間 約5分   （"ファイブナイン"）

# EC2 インスタンス別スループット（Railsアプリ）
c5.large:
  CPU: 2 vCPU
  メモリ: 4GB
  ネットワーク: 最大 10Gbps
  Railsアプリ目安: 500〜1,000 req/sec
 
c5.4xlarge:
  CPU: 16 vCPU
  メモリ: 32GB
  ネットワーク: 最大 10Gbps
  Railsアプリ目安: 4,000〜8,000 req/sec
 
c5.18xlarge:
  CPU: 72 vCPU
  メモリ: 144GB
  ネットワーク: 最大 25Gbps
  Railsアプリ目安: 20,000〜40,000 req/sec
 
# RDS PostgreSQL（db.r6g.large）
RDS_r6g_large:
  接続数: 最大 1,000
  読み込みQPS: 約 10,000
  書き込みQPS: 約 5,000
  ストレージ: 最大 64TB
 
# ElastiCache Redis（cache.r6g.large）
ElastiCache_r6g_large:
  操作: 100,000+ ops/sec
  レイテンシ: < 1ms
  メモリ: 13.07GB
 
# CloudFront（CDN）
CloudFront:
  エッジロケーション: 400+
  スループット: 数百Tbps
  レイテンシ低減: オリジンの1/10以下

# config/initializers/request_counter.rb
# Redis を使って1分間のリクエスト数をカウントする
 
class RequestCounter
  REDIS = Redis.new(url: ENV.fetch("REDIS_URL"))
 
  def self.increment
    key = "qps:#{Time.current.strftime('%Y%m%d%H%M')}"
    REDIS.incr(key)
    REDIS.expire(key, 120) # 2分後に期限切れ
  end
 
  def self.current_qps
    key = "qps:#{1.minute.ago.strftime('%Y%m%d%H%M')}"
    count = REDIS.get(key).to_i
    count / 60.0 # 1分間のカウントを秒換算
  end
end
 
# application_controller.rb に追記
before_action { RequestCounter.increment }

# app/models/article.rb
class Article < ApplicationRecord
  # ランキングは ElastiCache (Redis) にキャッシュ
  # TTL: 5分（300秒）
  def self.popular_cached
    Rails.cache.fetch("articles:popular", expires_in: 5.minutes) do
      # このブロックはキャッシュミス時だけ実行される（DBアクセス）
      order(view_count: :desc).limit(20).to_a
    end
  end
 
  # キャッシュヒット率をログに記録してモニタリング
  def self.popular_with_metrics
    hit = true
    result = Rails.cache.fetch("articles:popular", expires_in: 5.minutes) do
      hit = false
      order(view_count: :desc).limit(20).to_a
    end
 
    Rails.logger.info(
      event: "cache_access",
      key: "articles:popular",
      hit: hit
    )
    result
  end
end

# lib/tasks/capacity.rake
namespace :capacity do
  desc "現在のストレージ使用量と増加ペースを概算する"
  task estimate: :environment do
    week_ago    = 7.days.ago
 
    posts_week  = Post.where(created_at: week_ago..)
    daily_posts = posts_week.count / 7.0
 
    avg_size_bytes = 500 # 1投稿の平均サイズ（バイト）
 
    daily_storage_gb = (daily_posts * avg_size_bytes) / 1.0e9
    yearly_storage_tb = daily_storage_gb * 365 / 1000
 
    puts "=== ストレージ概算レポート ==="
    puts "直近7日間の日次投稿数: #{daily_posts.round} posts/day"
    puts "1日のストレージ増加: #{daily_storage_gb.round(2)} GB/day"
    puts "1年間の見込み増加量: #{yearly_storage_tb.round(2)} TB/year"
    puts "5年間の見込み増加量: #{(yearly_storage_tb * 5).round(2)} TB"
  end
end

// capacity/estimator.go
package capacity
 
import "fmt"
 
// Estimate はシステムの概算値を計算して出力する
type Estimate struct {
	DAU            int64   // 日次アクティブユーザー数
	ActionsPerUser float64 // 1ユーザーあたりの日次アクション数
	DataSizeBytes  int64   // 1アクションあたりのデータサイズ（バイト）
	ReadWriteRatio float64 // 読み書き比（読み込みが何倍多いか）
	PeakMultiplier float64 // ピーク係数（通常の何倍か）
	RetentionYears int     // データ保持年数
}
 
func (e *Estimate) Calculate() {
	const secondsPerDay = 86_400
 
	// QPS 計算
	writeQPS     := float64(e.DAU) * e.ActionsPerUser / secondsPerDay
	readQPS      := writeQPS * e.ReadWriteRatio
	peakWriteQPS := writeQPS * e.PeakMultiplier
	peakReadQPS  := readQPS * e.PeakMultiplier
 
	// ストレージ計算
	dailyWriteCount := float64(e.DAU) * e.ActionsPerUser
	dailyStorageGB  := dailyWriteCount * float64(e.DataSizeBytes) / 1e9
	totalStorageTB  := dailyStorageGB * 365 * float64(e.RetentionYears) / 1000
 
	// 帯域計算（レスポンスサイズはリクエストの5倍と仮定）
	bandwidthMbps := readQPS * float64(e.DataSizeBytes) * 5 * 8 / 1e6
 
	fmt.Println("=== システム概算 ===")
	fmt.Printf("書き込みQPS（通常）:   %.0f req/sec\n", writeQPS)
	fmt.Printf("読み込みQPS（通常）:   %.0f req/sec\n", readQPS)
	fmt.Printf("書き込みQPS（ピーク）: %.0f req/sec\n", peakWriteQPS)
	fmt.Printf("読み込みQPS（ピーク）: %.0f req/sec\n", peakReadQPS)
	fmt.Printf("1日のストレージ増加:   %.2f GB/day\n", dailyStorageGB)
	fmt.Printf("%d年後の総ストレージ:  %.2f TB\n", e.RetentionYears, totalStorageTB)
	fmt.Printf("必要帯域幅:            %.0f Mbps\n", bandwidthMbps)
}

// main.go での使用例
package main
 
import "myapp/capacity"
 
func main() {
	e := &capacity.Estimate{
		DAU:            10_000_000, // 1000万 DAU（Slackのイメージ）
		ActionsPerUser: 50,         // 1日50メッセージ
		DataSizeBytes:  500,        // 1メッセージ500バイト
		ReadWriteRatio: 10,         // 読み書き比 10:1
		PeakMultiplier: 3,          // ピーク3倍
		RetentionYears: 5,          // 5年保持
	}
	e.Calculate()
	// 出力例:
	// 書き込みQPS（通常）:   5787 req/sec
	// 読み込みQPS（通常）:   57870 req/sec
	// 書き込みQPS（ピーク）: 17361 req/sec
	// 読み込みQPS（ピーク）: 173611 req/sec
	// 1日のストレージ増加:   250.00 GB/day
	// 5年後の総ストレージ:   456.25 TB
	// 必要帯域幅:            11574 Mbps
}

# 面接で使う概算テンプレート（Rubyコメント形式）
 
# == ステップ1: 前提の確認 ==
# DAU: X M（要件から引き出す）
# 1人あたり日次アクション数: N 回
# 読み書き比: R : 1
# データサイズ/件: Y bytes
# ピーク係数: P 倍（通常2〜3）
# 保持期間: T 年
 
# == ステップ2: QPS ==
# 書き込みQPS  = DAU × N / 86_400
# 読み込みQPS  = 書き込みQPS × R
# ピークQPS    = 読み込みQPS × P
 
# == ステップ3: ストレージ ==
# 1日の増加量 = DAU × N × Y bytes
# T年後の総量 = 1日の増加量 × 365 × T
 
# == ステップ4: 帯域 ==
# 帯域(bps) = 読み込みQPS × 平均レスポンスサイズ × 8
 
# == ステップ5: サーバー台数 ==
# 必要台数（通常）= 通常QPS / 1台あたりのQPS
# ピーク台数      = ピークQPS / 1台あたりのQPS
# Auto Scaling 範囲 = 通常台数 〜 ピーク台数