キャッシュを置く5つの層 — 入れたのに速くならない

キャッシュを置く場所。ブラウザとサーバー、キャッシュ用の引き出し、ストップウォッチ。

この記事はわざと古いデータを出し続けさせ、わざと DB へ殺到させ、わざと「他人の情報が見える」状態を作ります。 個人情報はすべて自分で作ったダミーです。最後の「後片づけ」まで必ずやってください。

これは【深掘り】の記事です。本線の順路ではありません。 読まなくても先へ進めます。 本線の ボトルネックは動く — 負荷分散とキャッシュの設計 の続きとして、「キャッシュをどこに置くか」だけを、実際に5箇所へ置いて測り比べます。

前回: ロードバランサと振り分け方式 — 3台なのに偏る

この記事のコマンドは、すべてVMの中(Ubuntu Server)で打ちます。 Windows の PowerShell では打ちません。最後のブラウザ確認だけ、ホストの Windows から見ます。

前提: nginxの導入と初期設定|繋がらないときの確認手順とnginxのリバースプロキシ設定|serverブロックと複数サイトの振り分け、Redisの導入とキャッシュ設計|有効期限と削除のタイミング、Node.jsでREST APIを作る|JSONを返すGETとPOSTの実装を終えていること。

「遅い」と言われたので、Redis の回でやったとおりにキャッシュを入れました。コードは正しく動いています。redis-cli で覗くとキーもちゃんと入っています。

なのに、体感がほとんど変わりませんでした。

測り直して、理由が分かりました。遅かったのは「アプリが計算している時間」ではなく、「そこへ行って帰ってくるまでの全部」でした。Redis は一番奥にあります。一番奥を速くしても、手前の往復は1回も減っていません。

キャッシュは「入れるか入れないか」の話ではなく、「どこに置くか」の話です。 そして置き場所を1つ手前にずらすたびに、速くなり、同時に消せなくなります。

この記事では、まったく同じ1つの処理を、5つの層でキャッシュして測ります。効果の差は、想像よりずっと大きいです。

対象レベル: 中級〜上級 / 区分: 発展

目次

この記事でわかること

  • キャッシュは「入れたら速くなる」ものではないこと。置く層を1つ間違えるだけで、効果がほぼゼロになること
  • 手前の層ほど速く、手前の層ほど消せないこと。この1本の軸だけで、置き場所はだいたい決まること
  • ヒット率が低いキャッシュは、速くするどころか遅いこと。確認するコストだけが増えるから
  • 「元の処理が何ミリ秒以上か」で、キャッシュが黒字になるかどうかが決まること。速い処理にキャッシュを足すのは損だということ
  • キャッシュの事故は「古い」だけではないこと。期限切れの瞬間に全部が DB へ殺到すること、個人向けの応答が他人に見えることがあること
  • 一番良い対策は、キャッシュを置かないことである場合が多いこと

この記事でやること

  1. 測るための土台を作る。 1回120ミリ秒かかる処理を1つ用意して、何回本当に計算したかを数える窓口を付ける
  2. 同じ処理を5つの層でキャッシュして、平均レイテンシとアプリへの到達回数を測る(山場①)。表にする
  3. ヒット率を測る。 Redis の INFO stats と nginx の X-Cache-Status でヒット数とミス数を数える(山場②)
  4. キャッシュが原因の事故を3つ、わざと起こして直す(山場③)。古いまま・殺到・他人に見える
  5. キャッシュを外して、代わりに計算を減らす。 そのうえで判断表を作り、後片づけをする

先に知る言葉

この記事で初めて出てくる言葉です。 基本的な言葉は用語集にもまとめてあります。

言葉意味
層(レイヤ)リクエストがブラウザからDBへ届くまでに通る場所のこと。 ブラウザ・nginx・アプリ・Redis・DB がそれぞれ1つの層
ヒット / ミスキャッシュに入っていた=ヒット、入っていなかった=ミス
ヒット率ヒット ÷(ヒット+ミス)。 キャッシュが「効いているか」を表す唯一の数字
TTLTime To Live。そのキャッシュが自動で消えるまでの秒数
プロセス内キャッシュアプリのプログラムが自分のメモリの中に持つキャッシュ。 一番手軽で、そのプロセスの外からは見えない
共有キャッシュ複数の利用者や複数のプロセスが同じものを見るキャッシュ。 Redis・nginx・CDN がこれ
プライベートキャッシュ1人のためだけのキャッシュ。 ブラウザの中がこれ
proxy_cachenginx が、後ろのアプリから受け取った応答を自分で保存して返す機能
X-Cache-Statusnginx が「今のはヒットかミスか」を教えてくれるようにするための、自分で付ける応答ヘッダ
キャッシュスタンピードキャッシュが切れた瞬間に、待っていたリクエストが全部いっせいに元の処理へ流れ込むこと。踏みつけ(stampede)
シングルフライト同じ計算が同時に何本も来たとき、1本だけ実行して、残りはその結果を待たせるやり方
Vary「この応答は、どのリクエストヘッダによって内容が変わるか」を共有キャッシュに伝えるヘッダ

「キャッシュ」という言葉が指すものは1つではありません。 本線の回で 4箇所の地図と Cache-Control の書き方はやりました。 この記事は地図の続きではなく、「同じ処理を各層に置いたら、実際にどれだけ違うのか」を数字で出す回です。


準備 — 測るための土台を作る

測れないものは改善できません。 ここは「速くする前に必ず測る」の回と同じ立場です。

まず、わざと遅い処理を1つ作ります。中身は何でも構いません。「DBで重い集計をしている120ミリ秒」だと思ってください。

大事なのは、何回「本当に計算したか」を数える窓口を付けておくことです。これが無いと、「キャッシュが効いた」のか「たまたま速かった」のかが区別できません。

置き場所を作る

VMの中(Ubuntu)で打ちます。

bash
$ mkdir -p ~/cache-lab
$ cd ~/cache-lab
$ npm init -y
$ npm install express redis

added ... packages と出れば成功です。

アプリを書く

bash
$ nano ~/cache-lab/app.js
// ~/cache-lab/app.js
const express = require('express');
const { createClient } = require('redis');

const app = express();
const port = Number(process.argv[2] || 3001);

// none = キャッシュなし / mem = プロセス内 / redis = Redis
const MODE = process.env.CACHE || 'none';
const TTL = 30; // 秒

let computeCount = 0; // ★ 本当に計算した回数
const mem = new Map(); // ② プロセス内キャッシュ

let redis = null;
if (MODE === 'redis') {
  // ★ Redisの回で requirepass を設定しているので、パスワードが要ります
  redis = createClient({ url: process.env.REDIS_URL });
  redis.on('error', (e) => console.error('redis:', e.message));
  redis.connect().catch((e) => console.error('connect:', e.message));
}

// 「DBの重い集計」の代わり。1回120ミリ秒かかる、と思ってください
async function computeReport() {
  computeCount++;
  await new Promise((r) => setTimeout(r, 120));
  return { title: '売上レポート', total: 1234567, at: new Date().toISOString() };
}

async function getReport() {
  const key = 'report:v1';

  if (MODE === 'mem') {
    const hit = mem.get(key);
    if (hit && hit.expires > Date.now()) return hit.value;
    const value = await computeReport();
    mem.set(key, { value, expires: Date.now() + TTL * 1000 });
    return value;
  }

  if (MODE === 'redis') {
    const hit = await redis.get(key);
    if (hit) return JSON.parse(hit);
    const value = await computeReport();
    await redis.set(key, JSON.stringify(value), { EX: TTL });
    return value;
  }

  return computeReport(); // ① 何もしない
}

app.get('/report', async (req, res) => {
  res.json(await getReport());
});

// 何回「本当に計算したか」を見るための窓口
app.get('/stat', (req, res) => res.json({ port, mode: MODE, computeCount }));
app.get('/stat/reset', (req, res) => {
  computeCount = 0;
  res.json({ ok: true });
});

app.listen(port, () => console.log(`listening on ${port} mode=${MODE}`));

測る道具を書く

ab や hey は入っていないかもしれません。 curl と awk だけで足ります。どちらも素の Ubuntu Server に入っています。

bash
$ nano ~/cache-lab/bench.sh
bash
#!/bin/bash
  # 使い方: ./bench.sh <URL> <回数>
  url="$1"
  n="${2:-100}"
  for i in $(seq 1 "$n"); do
    curl -s -o /dev/null -w '%{time_total}\n' "$url"
  done | awk '{s+=$1} END {printf "平均 %.1f ミリ秒 / %d 回\n", s/NR*1000, NR}'
bash
$ chmod +x ~/cache-lab/bench.sh

curl の %{time_total} は「秒」で返ります。 awk で1000倍しているのはそのためです。 1回だけ測らないでください。 1回目は接続の確立が入るので、必ず遅く出ます。100回の平均を見ます。


同じ処理を、5つの層でキャッシュする

ここからが本題です。 中身がまったく同じ1つの処理を、置く場所だけ変えて5回測ります。

① 何もしない — 基準を測る

キャッシュの話をする前に、必ず基準を取ります。 これが無いと、あとで出た数字が良いのか悪いのか分かりません。

bash
$ cd ~/cache-lab
$ CACHE=none node app.js 3001

別のターミナルをもう1つ開いて(VS Code のターミナルなら + で増やせます)、測ります。

bash
$ curl -s http://127.0.0.1:3001/stat/reset
$ ~/cache-lab/bench.sh http://127.0.0.1:3001/report 100
$ curl -s http://127.0.0.1:3001/stat
{"ok":true}
平均 122.6 ミリ秒 / 100 回
{"port":3001,"mode":"none","computeCount":100}

100回投げて、100回とも計算しています。 これが基準です。

[スクリーンショット: 01_基準の計測.png] bench.sh を実行して「平均 122.6 ミリ秒 / 100 回」と出ている画面と、その下の computeCount: 100 が両方写るように撮ってください。

② アプリのメモリ内 — 一番手軽で、一番共有できない

Ctrl + C でアプリを止めて、モードを変えて起動し直します。

bash
$ CACHE=mem node app.js 3001
bash
$ curl -s http://127.0.0.1:3001/stat/reset
$ ~/cache-lab/bench.sh http://127.0.0.1:3001/report 100
$ curl -s http://127.0.0.1:3001/stat
平均 1.4 ミリ秒 / 100 回
{"port":3001,"mode":"mem","computeCount":1}

100回のうち、計算したのは1回だけになりました。Map に置いてあるものを返しているので、ネットワークもディスクも通りません。

ここで終わらせてはいけません。 プロセスを2つに増やすと、話が変わります。

bash
$ CACHE=mem node app.js 3001    # 1つ目のターミナル
$ CACHE=mem node app.js 3002    # 2つ目のターミナル

前回のロードバランサの回と同じように、nginx で2台に振り分けます(設定はこの次の節で書きます)。振り分けた状態で200回投げると、こうなります。

{"port":3001,"mode":"mem","computeCount":1}
{"port":3002,"mode":"mem","computeCount":1}

計算が2回に増えました。 プロセスが4つなら4回、8つなら8回です。

プロセス内キャッシュは、プロセスの外からは見えません。 1台のうちは気になりませんが、台数を増やした瞬間に、キャッシュの数だけ「別々の古さ」が生まれます。 そして、消したいときに全プロセスへ届ける手段がありません。(1つのプロセスに DELETE /cache を投げても、隣のプロセスには何も起きません)

③ Redis — プロセスをまたげる

「プロセスをまたいで共有したい」というただ1点のために、外に出します。

Redis の回で requirepass を設定しているので、パスワードが要ります。パスワードは自分で決めたものに読み替えてください。

bash
$ export REDIS_URL='redis://:あなたのパスワード@127.0.0.1:6379'
$ CACHE=redis node app.js 3001

つながっているか、先に確かめます。

bash
$ redis-cli -u "$REDIS_URL" PING
PONG

PONG が返らないときは sudo systemctl status redis-server を見ます。ここで進むと、あとの数字が全部おかしくなります。

bash
$ redis-cli -u "$REDIS_URL" DEL report:v1
$ curl -s http://127.0.0.1:3001/stat/reset
$ ~/cache-lab/bench.sh http://127.0.0.1:3001/report 100
$ curl -s http://127.0.0.1:3001/stat
平均 3.1 ミリ秒 / 100 回
{"port":3001,"mode":"redis","computeCount":1}

メモリ内(1.4ミリ秒)より遅く、何もしない(122.6ミリ秒)よりはるかに速い。 これがちょうど「同じマシンの中でネットワークを1往復する」コストです。

そして、プロセスを2つに増やしても計算は1回のままです。 ここが Redis を外に出した理由の全部です。

{"port":3001,"mode":"redis","computeCount":1}
{"port":3002,"mode":"redis","computeCount":0}

④ nginx の proxy_cache — アプリに届かない

ここまでの①〜③は、全部「アプリが1回は動いている」話でした。 次は、アプリまで届かせません。

bash
$ sudo nano /etc/nginx/conf.d/cache-lab.conf
proxy_cache_path /var/cache/nginx/lab levels=1:2 keys_zone=lab:10m max_size=100m inactive=10m;

upstream lab_app {
    server 127.0.0.1:3001;
    server 127.0.0.1:3002;
}

server {
    listen 8080;
    server_name _;

    # キャッシュしない入口(比較用)
    location / {
        proxy_pass http://lab_app;
    }

    # キャッシュする入口
    location /cached/ {
        proxy_pass http://lab_app/;
        proxy_cache lab;
        proxy_cache_valid 200 30s;
        add_header X-Cache-Status $upstream_cache_status always;
    }
}

proxy_cache_path は server { } の中には書けません。 conf.d に置いたファイルは nginx の http の中に読み込まれるので、ファイルの一番上(server の外)に書きます。 ポートを 8080 にしているのは、既存のサイトを壊さないためです。80番はそのままにしておきます。

bash
$ sudo mkdir -p /var/cache/nginx/lab
$ sudo nginx -t
$ sudo systemctl reload nginx

syntax is ok と test is successful が出てから reload します。-t を飛ばして reload すると、設定が壊れていたときにサイトごと落ちます。

測ります。

bash
$ curl -s http://127.0.0.1:3001/stat/reset
$ curl -s http://127.0.0.1:3002/stat/reset
$ ~/cache-lab/bench.sh http://127.0.0.1:8080/cached/report 100
$ curl -s http://127.0.0.1:3001/stat
$ curl -s http://127.0.0.1:3002/stat
平均 1.1 ミリ秒 / 100 回
{"port":3001,"mode":"none","computeCount":1}
{"port":3002,"mode":"none","computeCount":0}

アプリのモードは none(キャッシュなし)のままです。 それでも計算は100回中1回しか起きていません。

アプリに届いていないからです。 nginx が自分の持っているコピーを返して、そこで折り返しています。

ヒットしているかどうかは、ヘッダで見えます。

bash
$ curl -s -o /dev/null -D - http://127.0.0.1:8080/cached/report | grep -i x-cache-status
X-Cache-Status: HIT

[スクリーンショット: 02_X-Cache-Status.png] X-Cache-Status: MISS が出たあと、もう一度同じコマンドを打って HIT に変わるところを、2回分が同じ画面に写るように撮ってください。

⑤ ブラウザ(Cache-Control)— 通信自体が消える

最後は、リクエストそのものを出させません。

location /cached/ に1行足します。

    location /cached/ {
        proxy_pass http://lab_app/;
        proxy_cache lab;
        proxy_cache_valid 200 30s;
        add_header X-Cache-Status $upstream_cache_status always;
        add_header Cache-Control "public, max-age=60" always;
    }
bash
$ sudo nginx -t && sudo systemctl reload nginx

ホストの Windows のブラウザから http://VMのIP:8080/cached/report を開き、F12 で開発者ツールの Network を出して、もう一度同じURLを開きます。

2回目は (disk cache) あるいは (memory cache) と表示され、Time が 0 ms になります。

[スクリーンショット: 03_ブラウザキャッシュ.png] 開発者ツールの Network タブで、Size 列に (disk cache) と出ている行が見えるように撮ってください。

これは「速くなった」のではなく、「通信が消えた」のです。 サーバー側のログを見ても、この2回目は1行も残りません。 VMのIPは ip a で確認できます(Linuxのネットワークの回)。

5つを1枚の表にする

層平均レイテンシアプリへ届くか効く範囲消しやすさ
① 何もしない122.6 ms毎回届く——
② アプリのメモリ内1.4 ms届く(1回だけ計算)そのプロセスだけ△ 再起動すれば消える。ただし全プロセスに届ける手段が無い
③ Redis3.1 ms届く(1回だけ計算)全プロセス◎ DEL 1発。狙って消せる
④ nginx proxy_cache1.1 ms届かない全利用者○ キャッシュのファイルを消せば消える
⑤ ブラウザ0 ms(通信なし)届かないその人のPCだけ✕ こちらからは消せない。期限が切れるまで待つしかない

この表から読み取ることは、速さではありません。 一番右の列です。

手前ほど速いが、手前ほど消せない。 ⑤ は最速ですが、間違ったものを配ったら取り返せません。 読者のPCの中にあるからです。 ③ は少し遅いですが、間違えても DEL 1つで直せます。

だから「どれだけ速くしたいか」ではなく、「間違えたときにどれだけ困るか」で層を選びます。

そして、①から③への差(122.6 → 3.1)と、③から⑤への差(3.1 → 0)を見比べてください。ほとんどの改善は最初の1歩で終わっています。 それ以上を手前に取りに行くのは、消せなさというリスクを買っているのと同じです。


キャッシュヒット率を測る

「キャッシュを入れた」だけでは、効いているかどうか分かりません。 見るべき数字は1つだけです。ヒット率です。

Redis のヒット数とミス数を数える

Redis はサーバー側で数えてくれています。

bash
$ redis-cli -u "$REDIS_URL" INFO stats | grep keyspace
keyspace_hits:97
keyspace_misses:3

ヒット率は 97 / (97 + 3) = 97% です。

この数字は Redis サーバー全体のものです。 セッションも他のキーも全部混ざっています。 キーの種類ごとに見たいなら、アプリ側で自分で数えます。 getReport() の中で hit++ / miss++ するだけで足ります。 リセットしたいときは redis-cli -u "$REDIS_URL" CONFIG RESETSTAT です。

nginx のヒット数とミス数を数える

nginx は $upstream_cache_status を持っています。まず curl で雑に数えます。

bash
$ for i in $(seq 1 20); do
$   curl -s -o /dev/null -D - http://127.0.0.1:8080/cached/report | grep -i x-cache-status
$ done | sort | uniq -c
      1 X-Cache-Status: MISS
     19 X-Cache-Status: HIT

運用で見るなら、ログに出します。

log_format cachelog '$request_uri $upstream_cache_status $request_time';

server { } の中の location の外に access_log /var/log/nginx/cache-lab.log cachelog; を足すと、あとから集計できます。

bash
$ sudo awk '{print $2}' /var/log/nginx/cache-lab.log | sort | uniq -c

$upstream_cache_status の値は、覚えるのは3つで足ります。

値意味
MISS無かった。後ろのアプリまで行った
HITあった。アプリまで行っていない
EXPIREDあったが期限切れ。行き直した
BYPASS条件に当てはまったので、わざと使わなかった
-そもそもキャッシュ対象の location ではない

ヒット率が低いキャッシュは、ただの遅延

ここが一番の勘違いどころです。

キャッシュを入れると、ヒットしてもミスしても「まず確認する」時間が必ず増えます。 Redis なら1往復(約1ミリ秒)です。式にするとこうです。

実効の平均 = ヒット率 × ヒット時の時間 + (1 - ヒット率) × (確認の時間 + 元の処理の時間)

元の処理が遅いとき(120ミリ秒、ヒット率80%):

0.8 × 1 + 0.2 × (1 + 120) = 25.0 ミリ秒     ← 122.6 から大幅に改善

元の処理が速いとき(5ミリ秒、ヒット率20%):

0.2 × 1 + 0.8 × (1 + 5) = 5.0 ミリ秒        ← 元の 5 ミリ秒と同じ

後者は、まったく速くなっていません。 それどころか、

  • メモリを消費している
  • 古い値を返す危険を背負っている
  • 「キャッシュを消し忘れる」という新しい事故の種を1つ増やしている

速くもなっていないのに、全部のコストだけ払っています。 これが「ヒット率が低いキャッシュは、ただの遅延」の意味です。

どこから効き始めるかの目安を出しておきます。厳密な線ではなく、判断を始める場所として使ってください。

元の処理の時間ヒット率の目安判断
10ミリ秒未満どれだけ高くても入れない。 確認コストに埋もれる
10〜50ミリ秒90%以上なら入れてもよい。ただし効果は控えめ
50ミリ秒以上70%以上あれば入れる価値がある
どれでも50%未満入れない。 キャッシュではなく、対象の選び方が間違っている

ヒット率が低いときに TTL を伸ばしてはいけません。 数字は良くなりますが、古さが伸びただけです。 ヒット率が低い本当の原因は、たいてい「キーが細かすぎる」か「そもそも同じものが2回要求されていない」かの2つです。


何をキャッシュしてよいか

層を決める前に、そもそも置いていいものかを決めます。 条件は3つで、共有キャッシュ(③④⑤の共有部分)に置くなら3つとも満たす必要があります。

条件意味例
① 変わらないしばらく同じ答えでいい都道府県の一覧、商品カテゴリ
② 少し古くてよい30秒前の数字でも実害が無いランキング、閲覧数、集計レポート
③ 全員に同じ誰が見ても中身が同じ公開記事、トップページ

②と③を満たさないものが混ざったときが事故です。

  • ②を満たさない例: 在庫数、残高、注文の確定状態。 30秒古いだけで人が損をします
  • ③を満たさない例: ログイン後のマイページ、「◯◯さん」の表示、権限で出し分けている画面

個人向けの内容を、共有キャッシュに入れてはいけません。 これは「気をつけましょう」ではなく、構造上、必ず他人に見えます。 共有キャッシュは「URLが同じなら中身も同じ」を前提に動いているからです。Cookie を見て中身を変えているのに、キャッシュのキーが URL だけなら、最初に来た人の応答が次の人に返ります。

この型の事故は、実際に何度も起きています。 山場③で、自分で起こして確かめます。


キャッシュが原因の事故を、3つ起こす

読むだけでは身につきません。 3つとも実際に起こして、直します。

事故① 古いデータが出続ける(消し忘れ)

一番よくある事故です。 書き込む側が、キャッシュを消し忘れます。

app.js に「更新」を足します。わざと、キャッシュを消さずに書きます。

let total = 1234567;

app.get('/update', async (req, res) => {
  total = Number(req.query.v) || total;
  // ★ わざとキャッシュを消していない
  res.json({ ok: true, total });
});

computeReport() の total: 1234567 を total, に直して、起動し直します。

bash
$ export REDIS_URL='redis://:あなたのパスワード@127.0.0.1:6379'
$ CACHE=redis node app.js 3001
bash
$ redis-cli -u "$REDIS_URL" DEL report:v1
$ curl -s http://127.0.0.1:3001/report
$ curl -s 'http://127.0.0.1:3001/update?v=9999999'
$ curl -s http://127.0.0.1:3001/report
{"title":"売上レポート","total":1234567,"at":"..."}
{"ok":true,"total":9999999}
{"title":"売上レポート","total":1234567,"at":"..."}

更新したのに、古い数字が返り続けています。 TTL の30秒が過ぎるまで直りません。

対策は、書いた側が消すことです。

app.get('/update', async (req, res) => {
  total = Number(req.query.v) || total;
  if (redis) await redis.del('report:v1'); // ★ 書いたら消す
  res.json({ ok: true, total });
});

これは「書き込みのたびに消す」という一番素朴なやり方です。 消す場所が1箇所で済むうちは、これで十分です。 問題は、書き込む場所が増えたときです。 3箇所から書けるなら、3箇所すべてで消さないといけません。 1箇所忘れれば、そこだけ古いままになります。 だから「キャッシュを増やす」ことより「書き込みの入口を1つにまとめる」ことのほうが、先に効きます。

事故② キャッシュスタンピード — 期限切れの瞬間に全部が殺到する

これは、キャッシュが正しく動いているときにだけ起きます。 タチが悪い理由です。

TTL を短くして、観察しやすくします。TTL = 5 に変えて起動し直してください。

キャッシュが無い状態から、50本を同時に投げます。

bash
$ redis-cli -u "$REDIS_URL" DEL report:v1
$ curl -s http://127.0.0.1:3001/stat/reset
$ seq 1 50 | xargs -P 50 -I{} curl -s -o /dev/null http://127.0.0.1:3001/report
$ curl -s http://127.0.0.1:3001/stat
{"port":3001,"mode":"redis","computeCount":50}

50本すべてが計算しました。

理由はコードを追えば分かります。50本がほぼ同時に redis.get() を実行し、50本とも「無い」と言われ、50本とも computeReport() へ進みます。最初の1本が結果を書き込むのは120ミリ秒後で、それまでに全員が通り過ぎています。

これが、キャッシュの期限が切れるたびに起きます。 平常時は Redis が守ってくれているぶん、DB は「50本同時」に耐えられる大きさになっていません。 そこへ突然50本が来ます。

[スクリーンショット: 04_スタンピード.png] computeCount: 50 と返っている画面を撮ってください。キャッシュを入れているのに50回計算している、というのが要点です。

対策1: TTL をずらす(一番安い)

全員が同じ秒に切れるのが原因なら、切れる時刻をばらけさせます。

function ttlWithJitter() {
  return 30 + Math.floor(Math.random() * 10); // 30〜39秒
}

redis.set(..., { EX: TTL }) を { EX: ttlWithJitter() } に変えるだけです。

これはキーが複数あるときに効きます。 100種類のキーを同じ TTL で作ると、100個が同じ瞬間に切れます。 ずらせば、切れる時刻が10秒に散ります。

ただし、キーが1つのときは効きません。 1つのキーが切れる瞬間に殺到するのは、そのままだからです。

対策2: ロックする(本命)

「同じ計算は1本だけ走らせる」にします。まず、同じプロセスの中だけなら、これで足ります。

const inflight = new Map(); // 実行中の計算

function singleFlight(key, fn) {
  if (inflight.has(key)) return inflight.get(key); // ★ 待たせる
  const p = fn().finally(() => inflight.delete(key));
  inflight.set(key, p);
  return p;
}

getReport() の computeReport() を singleFlight(key, computeReport) に差し替えて、同じ50本を投げ直します。

{"port":3001,"mode":"redis","computeCount":1}

50 が 1 になりました。

プロセスが複数あるなら、これでは足りません。 プロセスの数だけ計算が走ります。Redis に鍵を置きます。

async function getReportLocked() {
  const key = 'report:v1';
  const hit = await redis.get(key);
  if (hit) return JSON.parse(hit);

  // 鍵を取れた1本だけが計算する。5秒で自動的に外れる
  const got = await redis.set('lock:' + key, '1', { NX: true, PX: 5000 });
  if (!got) {
    await new Promise((r) => setTimeout(r, 50)); // 少し待って
    const again = await redis.get(key);
    if (again) return JSON.parse(again); // 誰かが入れてくれた
    return computeReport(); // それでも無ければ諦めて自分で計算する
  }

  try {
    const value = await computeReport();
    await redis.set(key, JSON.stringify(value), { EX: ttlWithJitter() });
    return value;
  } finally {
    await redis.del('lock:' + key);
  }
}

PX: 5000(5秒で勝手に外れる)を必ず付けてください。 計算の途中でプロセスが落ちると、鍵が永久に残って、全員が待ち続けます。 鍵は「取れなかった側が諦められる」ように書きます。 上のコードで最後に computeReport() へ落ちているのはそのためです。待ち続けるより、遅くても答えを返すほうがマシです。

nginx にも同じ機能があります。 設定1行です。

        proxy_cache_lock on;
        proxy_cache_use_stale updating;

proxy_cache_lock が「1本だけ後ろへ通す」、proxy_cache_use_stale updating が「更新中は古いものを返しておく」です。後者は、①の事故(古い)を意図的に受け入れる代わりに、②を防いでいます。 何かを守るために何かを捨てている、という形をよく見ておいてください。

事故③ 個人情報が他人に見える(ダミーデータで)

ここで使う名前・数字は、すべて自分で作ったダミーです。 本物のデータでは絶対にやらないでください。

app.js に、ログインしている人向けのページを足します。

// ★ ダミーデータです。Cookieの user= を見て中身を変えます
app.get('/me', (req, res) => {
  const m = (req.headers.cookie || '').match(/user=([a-z0-9_]+)/);
  const user = m ? m[1] : 'guest';
  res.json({ user, message: `${user} さんの残高は 12,345 円です` });
});

キャッシュされる入口(/cached/)から、2人が順番にアクセスします。

bash
$ curl -s -b 'user=taro' http://127.0.0.1:8080/cached/me
$ curl -s -b 'user=hanako' http://127.0.0.1:8080/cached/me
{"user":"taro","message":"taro さんの残高は 12,345 円です"}
{"user":"taro","message":"taro さんの残高は 12,345 円です"}

hanako に taro の内容が返りました。

理由は単純です。nginx がキャッシュのキーに使っているのは URL であって、Cookie ではありません。 /cached/me という同じ URL なので、同じものとして扱われています。

[スクリーンショット: 05_他人の情報.png] -b 'user=hanako' で叩いたのに taro が返っている2行を、同じ画面に写して撮ってください。

これは nginx の不具合ではありません。 共有キャッシュはそういうものです。 同じ事故は CDN でも、ブラウザの手前にある会社のプロキシでも起きます。 「うちは CDN を使っていないから大丈夫」にはなりません。

対策: アプリ側から「共有するな」と言う

nginx の設定で除外するのではなく、アプリが応答に書きます。 そうすれば、どの共有キャッシュに対しても効きます。

app.get('/me', (req, res) => {
  const m = (req.headers.cookie || '').match(/user=([a-z0-9_]+)/);
  const user = m ? m[1] : 'guest';
  res.set('Cache-Control', 'private, no-store'); // ★ 共有キャッシュに置くな
  res.set('Vary', 'Cookie');                     // ★ Cookieで中身が変わる
  res.json({ user, message: `${user} さんの残高は 12,345 円です` });
});

キャッシュを消してから、やり直します。

bash
$ sudo rm -rf /var/cache/nginx/lab/*
$ sudo systemctl reload nginx
$ curl -s -b 'user=taro' http://127.0.0.1:8080/cached/me
$ curl -s -b 'user=hanako' http://127.0.0.1:8080/cached/me
{"user":"taro","message":"taro さんの残高は 12,345 円です"}
{"user":"hanako","message":"hanako さんの残高は 12,345 円です"}

直りました。 X-Cache-Status は MISS のままです(応答が保存されないので、毎回アプリまで行きます)。

3つのヘッダの役目を分けて覚えます。

書くもの何を言っているか
private「この人のブラウザにだけ置いていい。共有キャッシュは持つな」
no-store「どこにも保存するな」。 残高や個人情報はこちら
Vary: Cookie「Cookie が違えば別物として扱え」。 共有してよいが人によって変わるもの向け

Vary: Cookie に頼りすぎないでください。 Cookie は少し違うだけで別のキーになるので、ヒット率がほぼ0%まで落ちます。 個人向けのものは、そもそも共有キャッシュの経路に載せない(location /cached/ に入れない)ほうが、確実で速いです。

nginx 側にも保険を掛けておきます。 アプリの1箇所で書き忘れても止まるようにします。

        proxy_no_cache $http_cookie;
        proxy_cache_bypass $http_cookie;

「Cookie が付いているリクエストは、保存もしないし使いもしない」という意味です。乱暴ですが、事故の被害の大きさを考えると、これで釣り合います。


キャッシュを置かないという選択

3つの事故を全部やったあとで、元に戻ります。

本線のパフォーマンスの回で、こう書きました。

キャッシュは最後の手段。 回数を減らす → 1回を速くする → 返す量を減らす → それでも駄目なら。

この記事は、その結論を裏側から確かめたことになります。キャッシュを1つ置くたびに、消し忘れ・殺到・漏洩という3つの事故の種を、同時に3つ置いているからです。

だから、置く前に必ず2つ試します。

① そもそも計算を減らす。

今回の computeReport() が120ミリ秒かかっているのは、毎回ゼロから集計しているからです。集計結果を1行のテーブルに書いておいて、注文が入ったときに足すなら、読み出しは1行の SELECT です。キャッシュではありません。データの持ち方を変えただけなので、古くなりません。

② 索引を張る。

SQL深掘りの索引の回でやったように、EXPLAIN で全表走査になっているだけなら、索引1本で120ミリ秒が2ミリ秒になります。そうなればキャッシュは要りません(上のヒット率の表の「10ミリ秒未満」に落ちます)。

キャッシュで速くなったものは、キャッシュが切れた瞬間に元の遅さに戻ります。 計算を減らして速くなったものは、切れません。 この違いが、「最後の手段」の理由です。


判断表 — 何を、どの層に置くか

置くもの層TTL の目安理由
ハッシュ付きの JS / CSS / 画像⑤ ブラウザ(+④)1年URL が変われば別物なので、消す必要が無い
HTML(ログイン不要のページ)④ nginx数秒〜数分消したいときに消せる。ブラウザには置かせない
公開ページの集計・ランキング③ Redis30秒〜数分全プロセスで共有したい。間違えたら DEL で消したい
設定値・都道府県一覧など変わらないもの② プロセス内起動中ずっと外に出す価値が無い。 変わったら再起動でいい
ログイン後のマイページ・残高・権限で変わる画面キャッシュしない—private, no-store。 事故③の型
在庫数・決済の状態キャッシュしない—1秒古いだけで人が損をする
10ミリ秒で終わる処理キャッシュしない—確認コストに埋もれる。ヒット率が高くても黒字にならない

迷ったら、③ Redis から始めてください。 消せるからです。 効果が確認できて、かつ間違えても実害が無いと分かってから、④や⑤へ手前に動かします。


つまずいたところ

遠回りした順に書きます。

Redis を入れたのに、平均が122ミリ秒から動かなかった

最初にやった失敗です。 ロードバランサの後ろに2台並べた状態で、片方にだけ CACHE=redis を付け忘れていました。 半分はキャッシュ、半分は計算です。平均は当然、真ん中あたりで止まります。

computeCount を両方のプロセスで見て、初めて気づきました。 平均レイテンシだけ見ていたら、たぶんまだ悩んでいます。「何回本当に計算したか」を数える窓口は、最初に作ってください。

redis.connect() を待たずに get を呼んで落ちた

redis: The client is closed

createClient() はつないでいません。 connect() を呼んで、しかもその完了を待つ必要があります。上のコードでは connect() を起動時に1回呼んでいますが、起動直後の1本目だけ失敗することがあります。

PING が PONG を返すのを確かめてから測る、という順番にすれば踏みません。

proxy_cache_path を server { } の中に書いて nginx が起動しなくなった

nginx: [emerg] "proxy_cache_path" directive is not allowed here

proxy_cache_path は http の直下にしか書けません。 conf.d のファイルはまるごと http の中に入るので、ファイルの先頭(server の外)に置きます。

sudo nginx -t を打っていたので、reload の前に気づけました。 これを飛ばして restart していたら、80番のサイトごと落ちていました。

add_header が効かず、X-Cache-Status が出てこなかった

add_header は、上の階層で add_header を書いていると、下の階層のものだけが効きます(親の分は消えます)。さらに、エラー応答には既定で付きません。

always を付けて解決しました。キャッシュの状態は 404 のときこそ見たいので、always は付けておいたほうがいいです。

Vary: Cookie を入れたらヒット率が 3% になった

事故③の対策で Vary: Cookie を入れたところ、ほぼ全部 MISS になりました。

原因は、アクセス解析の Cookie が全員違う値だったことです。Cookie は1文字違えば別のキーなので、実質的にキャッシュが無効になっていました。

個人向けのページは Vary で共有しようとせず、キャッシュの経路から外すのが正解でした。

事故②の対策を入れたのに、computeCount が 2 のままだった

シングルフライトを入れたのに 1 になりません。プロセスを2つ起動したままだったからです。

プロセス内のロックは、プロセスをまたげません。 事故②の Redis ロックは、まさにこのために要ります。「メモリ内キャッシュはプロセスをまたげない」と、まったく同じ話です。


後片づけ

これは必ずやってください。 8080 のポートと、Cookie を無視するキャッシュを残したままにしないためです。

① アプリを止める

起動中のターミナルで Ctrl + C を押します。残っていないか確認します。

bash
$ ss -ltnp | grep -E '3001|3002'

何も出なければ止まっています。

② nginx の設定を消す

bash
$ sudo rm /etc/nginx/conf.d/cache-lab.conf
$ sudo nginx -t && sudo systemctl reload nginx

③ nginx のキャッシュを消す

bash
$ sudo rm -rf /var/cache/nginx/lab

④ Redis に残ったキーを消す

FLUSHALL は打たないでください。 セッションなど、他のものまで消えます。今回作ったキーだけを消します。

bash
$ redis-cli -u "$REDIS_URL" DEL report:v1 lock:report:v1
bash
$ redis-cli -u "$REDIS_URL" KEYS 'report:*'

空((empty array))になっていれば完了です。

⑤ 8080 を開けていたら閉じる

ufw でポートを開けた場合だけです(ufw の回)。

bash
$ sudo ufw status
$ sudo ufw delete allow 8080/tcp

⑥ 作業ディレクトリを消す

bash
$ rm -rf ~/cache-lab

環境変数も消しておきます(パスワードが入っています)。

bash
$ unset REDIS_URL

まとめ(理解できたこと)

  • キャッシュを入れても速くならないことがある。 原因はたいてい、置いた層が奥すぎるか、ヒット率が低いかのどちらか
  • 同じ処理を5つの層に置くと、122.6 / 1.4 / 3.1 / 1.1 / 0 ミリ秒になった。改善の大部分は、最初の1歩で終わっている
  • 手前ほど速く、手前ほど消せない。 選ぶ基準は速さではなく、間違えたときに取り返せるか
  • プロセス内キャッシュは、プロセスをまたげない。 台数を増やした瞬間に「別々の古さ」が生まれる。Redis を外に出す理由はこれ1つ
  • nginx の proxy_cache は、アプリに届かせない。 アプリ側が何もしていなくても、計算は100回中1回になる
  • ヒット率が唯一の指標。 INFO stats と X-Cache-Status で数える。元の処理が10ミリ秒未満なら、ヒット率が何%でも入れない
  • 事故は3種類。 消し忘れ・スタンピード・共有漏れ。対策は 書いた側が消す / ロックと TTL のずらし / private と no-store
  • ロックには必ず期限を付ける。 計算中に落ちると、鍵が残って全員が待ち続ける
  • 共有キャッシュのキーは URL であって Cookie ではない。 だから個人向けの応答は、構造上、必ず他人に見える
  • キャッシュは最後の手段。 計算を減らして速くしたものは切れないが、キャッシュで速くしたものは、切れた瞬間に元に戻る

参考リンク


次に読む

この記事は 【深掘り】システム設計 の 4 / 17 本目です。

記事
← 前の記事ロードバランサと振り分け方式 — 3台なのに偏る
→ 次の記事キャッシュの書き込み戦略 — 更新したのに古い値が返る

上から順に読めば積み上がるように並べています。 飛ばしても構いませんが、詰まったら前の回に戻ってください。

全体の順路は はじめに にあります。

roadmap.sh のどこをやっているか

System Design›System Design — Caching
  • キャッシュを置く5つの層を実測で比べる
  • ヒット率とキャッシュスタンピード

この記事は、上の項目を実際に手を動かして確かめる回です。

よかったらシェアしてね!
  • URLをコピーしました!
  • URLをコピーしました!

コメント

コメントする

目次