結果整合性とCAP定理 — リロードしたら件数が減った

結果整合性とCAP定理。2つのデータベースと同期の時計、切れた接続を示す小さなケーブル。

端末を3つ開きます。 VS Code の統合ターミナルでも、ssh を3本張っても構いません。この記事では「端末1」「端末2」「端末3」と呼びます。

前回: メッセージキューの型 — 急ぎの仕事が後ろで待つ

これは【深掘り】の記事です。本線の順路ではありません。 読まなくても先へは進めます。 本線の書いた直後に読むと無い — レプリケーションとCAPの回の続きです。あの回では「レプリカを足すと遅れる」「CAP定理というものがある」というところまでを、言葉で説明しました。 この記事はその先です。あそこで言葉だけで済ませた「遅れ」と「二択」を、全部手元で発生させて、数字で見ます。

この記事のコマンドは、すべてVMの中(Ubuntu Server)で打ちます。 Windows の PowerShell では打ちません。

前提: VMに Docker と Docker Compose が入っていること。docker compose version が返ること。 メモリを 2GB ほど使います。 MySQL を2つ立てるためです。他のコンテナが動いているなら、先に止めてください。

読み込みが重くなってきたので、データベースのレプリカを1台足しました。書き込みは primary、読み込みは replica。 教科書どおりです。負荷は実際に下がりました。

翌日、報告が3件来ました。

「投稿ボタンを押したのに、一覧に自分の投稿が出てきません」

「さっき『12件』と出ていたのに、リロードしたら『11件』に減りました。消していないのに」

「返信が先に表示されて、元の本文が下に出てきます。順番がおかしいです」

私は最初、アプリのバグを探しました。 キャッシュを疑い、キャッシュ戦略の回でやったとおりに削除の漏れを探し、SELECT の ORDER BY を疑い、トランザクションの分離レベルを疑いました。どこにもバグはありませんでした。

バグではありません。私が「読む先を2つにした」時点で、これは必ず起きます。

primary に書いたものが replica に届くまでには、時間がかかる。 その「かかっている間」に replica を読むと、古い値が返る。

これだけです。そして、この「かかっている間」は、ゼロにはできません。 光の速さで送っても、書いた瞬間には届いていないからです。

だから設計の仕事は、遅れを無くすことではありません。

どの業務で遅れを許すか、どの業務で許さないかを、業務ごとに決めること。

在庫と残高は、遅れてはいけません。いいねの数は、3秒遅れても誰も困りません。 それを決めるのが「整合性の強さを選ぶ」ということです。

この記事では、その遅れを手元で実際に作って、目で見ます。 図では身に付きません。SELECT の結果が、書いた直後に古い値を返すところを、自分の端末に出します。

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

目次

この記事でわかること

  • 「書いた直後に読めない」はバグではないこと。読む先を増やした瞬間に必ず発生する性質だということ
  • 結果整合とは「いつか合う」であって「すぐ合う」ではないこと。その「いつか」がどれくらいかは、測らないと分からないこと
  • 「全部を強整合にすればいい」は成立しないこと。強整合は、レイテンシと可用性を必ず削って買うものだということ
  • CAP定理は暗記するものではないこと。replica への通信が切れたとき、「古い値を返す」か「エラーを返す」かの二択しか無いという、それだけの話だということ
  • 単調読み取りと因果一貫性は、名前を覚えても意味がないこと。「リロードしたら件数が減る」「返信が本文より先に見える」という、利用者が見る症状そのものだということ
  • 強整合にする手段は3つあって、それぞれ犠牲にするものが違うこと。準同期レプリケーションは replica の読み込みを新しくする手段ではなく、primary が落ちてもコミット済みのデータを失いにくくする仕組みだということ

この記事でやること

  1. ~/conslab を作り、MySQL の primary 1台 + replica 1台を Docker Compose で立ててレプリケーションを繋ぐ
  2. replica にわざと5秒の遅延を作り、primary に書いた直後に replica を読むと古い値が返るところを実測する
  3. 単調読み取りが崩れて件数が減る様子と、返信が本文より先に見える様子を再現する
  4. 強整合にする手段を3つ試す(primary から読む / SELECT ... FOR UPDATE / 準同期レプリケーション)。それぞれ何ミリ秒遅くなるかを測る
  5. docker network disconnect で replica を切り離し、古い値を返すかエラーを返すかの二択しか無いことを目で見る
  6. 業務ごとの判断表を作り、立てたものを全部消す

先に知る言葉

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

言葉意味
primary(プライマリ)書き込みを受け付ける側のデータベース。 昔は master と呼ばれていた。MySQL 8.0 では SOURCE と書く
replica(レプリカ)primary の内容をコピーして持つ、読み込み専用のデータベース。 昔は slave
バイナリログ(binlog)primary で起きた変更を、起きた順に書き出した記録ファイル。 replica はこれを取りに来て、同じことを自分にも適用する
レプリケーション遅延primary に書いてから、replica にその内容が反映されるまでの時間。 ゼロにはならない
強整合(strong consistency)書き込みが成功した直後の読み込みが、必ずその新しい値を返す状態。読む先が1つなら自動的にこうなる
結果整合(eventual consistency)いつかは全員が同じ値になるが、途中は食い違ってよいという約束。「いつか」の長さは保証されない
read-your-writes「自分が書いたものは、自分には必ず見える」という保証。他人にはまだ見えなくてよい
単調読み取り(monotonic reads)一度見た値より古い値は、二度と見せないという保証。これが無いと「件数が減る」
因果一貫性(causal consistency)原因が見えるより先に結果が見えることはないという保証。これが無いと「返信が本文より先に出る」
準同期レプリケーションreplica の少なくとも1台が受け取ったことを確認してから、primary が「書けました」と返す方式
ネットワーク分断(partition)primary と replica の間の通信だけが切れて、両方とも生きている状態。一番厄介な壊れ方
CAP定理分断が起きたとき、一貫性(C)と可用性(A)は同時には満たせない、という主張

① 準備 —— primary と replica を立てる

作業場所を作ります。この記事で作るものは、全部この中に入れます。 最後にディレクトリごと消します。

端末1 で打ちます。

bash
$ mkdir -p ~/conslab
$ cd ~/conslab
$ pwd
/home/ubuntu/conslab

pwd が conslab を指していることを必ず確認してください。 最後に rm -rf を打つので、場所を間違えると別のものが消えます。

Compose ファイルを書く

bash
$ nano ~/conslab/compose.yml

以下を貼り付けます。

services:
  primary:
    image: mysql:8.0
    container_name: cons-primary
    environment:
      MYSQL_ROOT_PASSWORD: rootpass
      MYSQL_DATABASE: shop
    command: >
      --server-id=1
      --log-bin=binlog
      --binlog-format=ROW
      --gtid-mode=ON
      --enforce-gtid-consistency=ON
    ports:
      - "13306:3306"
    healthcheck:
      test: ["CMD", "mysqladmin", "ping", "-h", "127.0.0.1", "-prootpass"]
      interval: 3s
      timeout: 3s
      retries: 30

  replica:
    image: mysql:8.0
    container_name: cons-replica
    environment:
      MYSQL_ROOT_PASSWORD: rootpass
    command: >
      --server-id=2
      --log-bin=binlog
      --binlog-format=ROW
      --gtid-mode=ON
      --enforce-gtid-consistency=ON
      --read-only=ON
      --skip-replica-start
    ports:
      - "13307:3306"
    depends_on:
      primary:
        condition: service_healthy
    healthcheck:
      test: ["CMD", "mysqladmin", "ping", "-h", "127.0.0.1", "-prootpass"]
      interval: 3s
      timeout: 3s
      retries: 30

書いたら Ctrl+O → Enter → Ctrl+X で保存します。

ここで指定しているものの意味を、1行ずつ確認します。

指定なぜ要るか
--server-idレプリケーションに参加する全員に、違う番号が要る。 同じだと繋がらない
--log-bin=binlogバイナリログを取る。 これが無いと replica に送るものが無い
--binlog-format=ROW「どの行がどう変わったか」を記録する。 STATEMENT だと SQL 文をそのまま送るため、NOW() などで結果がずれる
--gtid-mode=ON各トランザクションに世界で一意なIDを振る。 これがあると「replica がどこまで受け取ったか」をIDで比較できる
--read-only=ONreplica に間違って書き込まないようにする。 事故防止
--skip-replica-start起動しても、まだレプリケーションを始めない。 この記事では手で始めます
ports を 13306 / 13307 にVMに既に MySQL が居ても衝突しないため。 ホスト側だけずらしています

depends_on に condition: service_healthy を付けているのは、Docker深掘りの depends_on の回でやったとおり、「起動した」と「受け付けられる」は別だからです。MySQL は起動してから接続を受けるまで20秒近くかかります。

立てる

bash
$ cd ~/conslab
$ docker compose up -d
[+] Running 3/3
 ✔ Network conslab_default   Created
 ✔ Container cons-primary    Healthy
 ✔ Container cons-replica    Started

Healthy が出るまで30秒ほどかかります。 待てない場合は次で確認します。

bash
$ docker compose ps
NAME           IMAGE       STATUS                   PORTS
cons-primary   mysql:8.0   Up 45 seconds (healthy)  0.0.0.0:13306->3306/tcp
cons-replica   mysql:8.0   Up 25 seconds (healthy)  0.0.0.0:13307->3306/tcp

両方 (healthy) になってから次へ進みます。

スクリーンショットを撮ってください: 01_compose_ps.png

打ちやすくするための短縮

このあと何十回も docker exec を打ちます。 毎回全部打つと事故るので、短い名前を付けます。

bash
$ alias P='docker exec -i cons-primary mysql -uroot -prootpass -N -B'
$ alias R='docker exec -i cons-replica mysql -uroot -prootpass -N -B'
オプション意味
-i標準入力を渡す。 これが無いとパイプで SQL を流し込めない
-N列名の見出しを出さない。 結果だけが欲しいときに読みやすい
-B罫線を描かず、タブ区切りで出す。 差分を目で追いやすい

alias は端末を閉じると消えます。 端末2・端末3でも同じ2行を打ってください。この記事では P が primary、R が replica です。

パスワードをコマンドラインに書いているのは、これが使い捨ての練習用だからです。 本番では環境変数か設定ファイルを使います。ここでは手順を短くすることを優先しました。

動くか確認します。

bash
$ echo "SELECT @@server_id, @@read_only;" | P
$ echo "SELECT @@server_id, @@read_only;" | R
1	0
2	1

primary は server_id=1 で書き込み可、replica は server_id=2 で読み取り専用です。 ここまで合っていれば準備は正しくできています。


② レプリケーションを繋ぐ

まだ繋がっていません。 立てただけです。手で繋ぎます。

replica 用のユーザーを primary に作る

bash
$ cat <<'SQL' | P
  CREATE USER 'repl'@'%' IDENTIFIED WITH mysql_native_password BY 'replpass';
  GRANT REPLICATION SLAVE ON *.* TO 'repl'@'%';
  FLUSH PRIVILEGES;
  SQL

何も出なければ成功です。 SQL は成功しても黙っています。

REPLICATION SLAVE という権限名は、MySQL 8.0 でもこの綴りのままです。 サーバー側の呼び名は SOURCE / REPLICA に変わりましたが、この権限名だけは古い綴りが残っています。

mysql_native_password を指定しているのは、MySQL 8.0 の既定の認証方式(caching_sha2_password)だと、暗号化していない接続では最初のやり取りで弾かれることがあるからです。練習用なので、ここは単純なほうを選びました。これは mysql:8.0 だから通ります。 8.0 は 2026年4月30日でサポートが終了しており、後継の 8.4 では mysql_native_password が既定で無効です。8.4 で試すときは IDENTIFIED WITH mysql_native_password を外してください(下で GET_SOURCE_PUBLIC_KEY=1 を指定済み)。

replica に「どこから取ってくるか」を教える

bash
$ cat <<'SQL' | R
  CHANGE REPLICATION SOURCE TO
    SOURCE_HOST='primary',
    SOURCE_PORT=3306,
    SOURCE_USER='repl',
    SOURCE_PASSWORD='replpass',
    SOURCE_AUTO_POSITION=1,
    GET_SOURCE_PUBLIC_KEY=1;
  START REPLICA;
  SQL

SOURCE_HOST='primary' の primary は、Compose が付けたサービス名です。 Docker のネットワークの回でやったとおり、同じ Compose ネットワークの中では、サービス名がそのままホスト名になります。 ここに localhost と書くと、replica が自分自身を見に行って繋がりません。

SOURCE_AUTO_POSITION=1 は「GTID で自動的に続きから取る」という意味です。 昔は「binlog のファイル名と、その中の何バイト目から」を手で指定していました。その番号を1桁間違えると、静かにデータがずれます。 GTID はそれを無くすための仕組みです。

繋がったか確認する

bash
$ docker exec -i cons-replica mysql -uroot -prootpass -e "SHOW REPLICA STATUS\G" | grep -E "Replica_IO_Running|Replica_SQL_Running|Seconds_Behind_Source|Last_Error"
             Replica_IO_Running: Yes
            Replica_SQL_Running: Yes
          Seconds_Behind_Source: 0
                     Last_Error:

見るのはこの4行だけです。

項目意味
Replica_IO_Runningprimary から binlog を受け取るスレッドが動いているか。 No なら繋がっていない(ネットワーク・認証)
Replica_SQL_Running受け取ったものを自分に適用するスレッドが動いているか。 No なら適用に失敗した(データの衝突)
Seconds_Behind_Source何秒遅れているか。 これが今回の主役
Last_Error止まった理由。 空なら問題なし

Replica_IO_Running と Replica_SQL_Running は、別々に止まります。 「片方だけ Yes」はよくある状態で、原因がまったく違います。両方 Yes を確認してください。

実際にコピーされることを見る

bash
$ cat <<'SQL' | P
  USE shop;
  CREATE TABLE posts (
    id INT AUTO_INCREMENT PRIMARY KEY,
    body VARCHAR(200) NOT NULL,
    parent_id INT NULL,
    created_at DATETIME(3) NOT NULL DEFAULT CURRENT_TIMESTAMP(3)
  );
  INSERT INTO posts (body) VALUES ('最初の投稿');
  SQL

replica 側を見ます。

bash
$ echo "SELECT id, body FROM shop.posts;" | R
1	最初の投稿

テーブルを作った覚えは replica にはありません。 CREATE TABLE も binlog に乗って流れてきています。ここまでで、レプリケーションは動いています。


③ 書いた直後に、自分の書き込みが読めない

ここからが本題です。いま Seconds_Behind_Source は 0 なので、遅れはほとんどありません。 これでは症状が見えません。

遅延をわざと作ります。

5秒の遅延を入れる

MySQL には「わざと遅らせる」設定があります。本来はオペレーションミスからの復旧用(DROP TABLE を打ってしまっても、遅延している replica にはまだ残っている)ですが、今回は症状の再現に使います。

bash
$ cat <<'SQL' | R
  STOP REPLICA;
  CHANGE REPLICATION SOURCE TO SOURCE_DELAY = 5;
  START REPLICA;
  SQL

SOURCE_DELAY は、レプリケーションを止めている間しか変更できません。 動いたまま打つと次のエラーになります。

ERROR 3081 (HY000): This operation cannot be performed with running replication threads; run STOP REPLICA SQL_THREAD FIRST.

エラーが出たら、STOP REPLICA; を打ってからやり直してください。

書いた直後に読む

ここが、冒頭の「投稿したのに一覧に出ない」の正体です。

短いシェルスクリプトで、「primary に書く → すぐ replica を読む」をやります。

bash
$ cat > ~/conslab/write-then-read.sh <<'EOF'
  #!/bin/bash
  BODY="投稿 $(date +%H:%M:%S.%3N)"
  echo "--- primary に書きます: $BODY"
  echo "INSERT INTO shop.posts (body) VALUES ('$BODY');" | \
    docker exec -i cons-primary mysql -uroot -prootpass -N -B
  echo "--- 書けました。すぐ replica を読みます"
  for i in 0 1 2 3 4 5 6 7; do
    N=$(echo "SELECT COUNT(*) FROM shop.posts;" | \
        docker exec -i cons-replica mysql -uroot -prootpass -N -B)
    echo "  ${i}秒後: replica の件数 = ${N}"
    sleep 1
  done
  EOF
$ chmod +x ~/conslab/write-then-read.sh
$ ~/conslab/write-then-read.sh
--- primary に書きます: 投稿 14:22:31.481
--- 書けました。すぐ replica を読みます
  0秒後: replica の件数 = 1
  1秒後: replica の件数 = 1
  2秒後: replica の件数 = 1
  3秒後: replica の件数 = 1
  4秒後: replica の件数 = 1
  5秒後: replica の件数 = 2
  6秒後: replica の件数 = 2
  7秒後: replica の件数 = 2

これが結果整合です。

  • INSERT は成功しています。 primary は「書けました」と返しました
  • その直後に replica を読むと、件数は 1 のままです
  • 5秒後に、やっと 2 になりました

利用者から見ると、こう見えています。 投稿ボタンを押した。「投稿しました」と出た。一覧に戻った。自分の投稿が無い。

アプリのコードには、1行もバグがありません。 書き込みは primary、読み込みは replica、という教科書どおりの構成が、そのままこの症状を作っています。

スクリーンショットを撮ってください: 02_write_then_read.png

この「自分が書いたものが自分に見えない」が read-your-writes 違反です。 名前を覚える必要はありません。「投稿したのに出てこない」という苦情が、これです。

「いつか合う」の「いつか」は何秒か

結果整合は「いつか合う」としか約束しません。 では実際は何秒なのか。測ります。

bash
$ docker exec -i cons-replica mysql -uroot -prootpass -e "SHOW REPLICA STATUS\G" | grep -E "Seconds_Behind_Source|SQL_Delay|SQL_Remaining_Delay"
          Seconds_Behind_Source: 5
                      SQL_Delay: 5
            SQL_Remaining_Delay: NULL

SQL_Delay は「自分で設定した遅延」、Seconds_Behind_Source は「実際の遅れ」です。 いまは設定した5秒がそのまま出ています。

Seconds_Behind_Source は信用しすぎてはいけません。 これは「replica が最後に適用したイベントの、primary での発生時刻」との差です。だから:

  • primary に一切書き込みが無い間は、0 が返ります。 実際には受け取っていないだけかもしれません
  • ネットワークが切れると NULL になります。 「遅れ 0」ではなく「分からない」です

本当の遅れを測りたいなら、GTID を比べます。

bash
$ echo "SELECT @@GLOBAL.gtid_executed;" | P
$ echo "SELECT @@GLOBAL.gtid_executed;" | R
3f7d2b8a-9c11-11ef-b3d4-0242ac120002:1-9
3f7d2b8a-9c11-11ef-b3d4-0242ac120002:1-4

primary は9番まで実行済み、replica は4番までしか実行していません。 差の5トランザクションが、まだ届いていない分です。これは「秒」ではなく「件」で、嘘をつきません。


④ 件数が減り、返信が本文より先に見える

read-your-writes は「自分の書き込み」の話でした。もっと気味の悪い壊れ方が2つあります。

単調読み取りが崩れる —— リロードしたら件数が減った

replica が2台あって、遅れ方が違うとどうなるか。そのために2台目は要りません。 「進んでいる側と遅れている側に、交互に振られる」を再現すれば同じです。

実運用では、ロードバランサが1回目と2回目で違う replica に振り分けたときに起きます。 負荷分散の回でやった「どこに振られるかは分からない」が、ここで牙をむきます。

bash
$ cat > ~/conslab/monotonic.sh <<'EOF'
  #!/bin/bash
  echo "INSERT INTO shop.posts (body) VALUES ('新しい投稿');" | \
    docker exec -i cons-primary mysql -uroot -prootpass -N -B
  for i in 1 2 3 4 5 6; do
    # 奇数回は進んでいる側、偶数回は遅れている側に振られたとする
    if [ $((i % 2)) -eq 1 ]; then
      TARGET=cons-primary; NAME="進んでいる側"
    else
      TARGET=cons-replica; NAME="遅れている側"
    fi
    N=$(echo "SELECT COUNT(*) FROM shop.posts;" | \
        docker exec -i $TARGET mysql -uroot -prootpass -N -B)
    echo "リロード${i}回目 (${NAME}に振られた): ${N}件"
    sleep 1
  done
  EOF
$ chmod +x ~/conslab/monotonic.sh
$ ~/conslab/monotonic.sh
リロード1回目 (進んでいる側に振られた): 3件
リロード2回目 (遅れている側に振られた): 2件
リロード3回目 (進んでいる側に振られた): 3件
リロード4回目 (遅れている側に振られた): 2件
リロード5回目 (進んでいる側に振られた): 3件
リロード6回目 (遅れている側に振られた): 3件

3件 → 2件 → 3件 → 2件。

利用者から見ると「リロードするたびに件数が変わる」「消していないのに減った」です。

これが単調読み取り(monotonic reads)が崩れた状態です。 保証されていれば、一度3件を見た人には、二度と2件は見せません。

この壊れ方は、read-your-writes よりたちが悪いです。 自分が書いていなくても起きるので、「私が何かしたせいかも」という手がかりすらありません。 私はここで丸1日、削除処理を疑いました。削除処理は1行も動いていませんでした。

因果一貫性が崩れる —— 返信が本文より先に出る

もっと分かりやすく壊れるのがこれです。

「本文を投稿し、それに返信する」。この2つには順番があります。返信は本文が無ければ存在できません。 これを因果関係と呼びます。

アプリが「本文は replica、返信は primary から読む」と経路を分けていると、この順番は簡単に逆転します。

bash
$ cat > ~/conslab/causal.sh <<'EOF'
  #!/bin/bash
  # 本文を投稿し、すぐ返信する
  echo "INSERT INTO shop.posts (body) VALUES ('質問: これはどう直しますか');" | \
    docker exec -i cons-primary mysql -uroot -prootpass -N -B
  PID=$(echo "SELECT MAX(id) FROM shop.posts;" | \
        docker exec -i cons-primary mysql -uroot -prootpass -N -B)
  echo "INSERT INTO shop.posts (body, parent_id) VALUES ('返信: 遅延を測ってください', $PID);" | \
    docker exec -i cons-primary mysql -uroot -prootpass -N -B
  
  echo "--- 画面の描画: 返信は primary から、本文は replica から読む実装だとする"
  echo "[返信一覧] (primary)"
  echo "SELECT body FROM shop.posts WHERE parent_id IS NOT NULL ORDER BY id DESC LIMIT 1;" | \
    docker exec -i cons-primary mysql -uroot -prootpass -N -B
  echo "[元の本文] (replica)"
  echo "SELECT IFNULL(MAX(body),'(本文が見つかりません)') FROM shop.posts WHERE id = $PID;" | \
    docker exec -i cons-replica mysql -uroot -prootpass -N -B
  EOF
$ chmod +x ~/conslab/causal.sh
$ ~/conslab/causal.sh
--- 画面の描画: 返信は primary から、本文は replica から読む実装だとする
[返信一覧] (primary)
返信: 遅延を測ってください
[元の本文] (replica)
(本文が見つかりません)

返信は表示されているのに、その返信が付いている本文が「見つかりません」。

利用者から見ると「返信だけが宙に浮いている」「削除された投稿への返信に見える」です。

これが因果一貫性の崩れです。 結果(返信)は見えるのに、原因(本文)が見えない。

ここで大事なのは、これがアプリの設計ミスだということです。 「返信は最新が欲しいから primary、本文は重いから replica」という、一見合理的な判断が原因です。因果関係のある2つを、違う整合性の経路で読んではいけません。

スクリーンショットを撮ってください: 03_causal_broken.png

4つの保証を、症状で並べる

保証の名前無いと、利用者に何が見えるか
read-your-writes投稿したのに、一覧に自分の投稿が出ない
単調読み取りリロードしたら件数が減った。押すたびに数字が変わる
因果一貫性返信が本文より先に出る。削除された投稿への返信に見える
強整合(崩れない。ただし遅く、落ちやすい)

名前を覚える必要はありません。 右の列の症状を見たときに、「読む先を分けたせいだ」と思い出せれば十分です。


⑤ 強整合にする —— 手段は3つ、犠牲はそれぞれ違う

では、どうやって直すか。 手段は3つあります。どれも、何かを犠牲にします。

手段1: 書いた人は primary から読む

一番単純で、一番よく使われる手です。 「書き込みの直後だけ、その利用者の読み込みを primary に向ける」。

bash
$ cat > ~/conslab/sticky.sh <<'EOF'
  #!/bin/bash
  echo "INSERT INTO shop.posts (body) VALUES ('primaryから読む投稿');" | \
    docker exec -i cons-primary mysql -uroot -prootpass -N -B
  echo "--- 直後に primary から読む"
  echo "SELECT body FROM shop.posts ORDER BY id DESC LIMIT 1;" | \
    docker exec -i cons-primary mysql -uroot -prootpass -N -B
  echo "--- 直後に replica から読む"
  echo "SELECT body FROM shop.posts ORDER BY id DESC LIMIT 1;" | \
    docker exec -i cons-replica mysql -uroot -prootpass -N -B
  EOF
$ chmod +x ~/conslab/sticky.sh
$ ~/conslab/sticky.sh
--- 直後に primary から読む
primaryから読む投稿
--- 直後に replica から読む
返信: 遅延を測ってください

primary から読めば、必ず見えます。 当たり前です。読む先が1つなら、整合性の問題はそもそも起きません。

犠牲は「replica を足した意味が薄れること」です。 書き込みの直後だけ、と言っても、書き込みの多い画面では大半の読み込みが primary に戻ります。 負荷を分散するために replica を足したのに、分散されません。

現実的な運用は「書き込みから N 秒間だけ、その利用者を primary に向ける」です。 N はレプリケーション遅延の実測値より少し大きい値にします。だから、遅延を測っていないと N が決められません。

手段2: 同じDBの中で SELECT ... FOR UPDATE

これはレプリケーションの話ではありません。 「primary の中で、複数の処理が同時に同じ行を触る」場合の話です。

在庫や残高で、本当に必要になるのはこちらです。

bash
$ cat <<'SQL' | P
  USE shop;
  CREATE TABLE stock (
    item VARCHAR(20) PRIMARY KEY,
    qty INT NOT NULL
  );
  INSERT INTO stock VALUES ('book', 1);
  SQL

在庫は1個です。 これを2人が同時に買おうとします。

端末2 を開き、alias の2行を貼ってから、まず FOR UPDATE を付けずにやってみます。

端末1:

bash
$ docker exec -i cons-primary mysql -uroot -prootpass shop <<'SQL'
  START TRANSACTION;
  SELECT qty FROM stock WHERE item='book';
  SELECT SLEEP(6);
  UPDATE stock SET qty = qty - 1 WHERE item='book';
  COMMIT;
  SELECT qty AS 端末1の最終在庫 FROM stock WHERE item='book';
  SQL

打ったら、6秒以内に端末2で同じものを打ちます。

端末2:

bash
$ docker exec -i cons-primary mysql -uroot -prootpass shop <<'SQL'
  START TRANSACTION;
  SELECT qty FROM stock WHERE item='book';
  UPDATE stock SET qty = qty - 1 WHERE item='book';
  COMMIT;
  SELECT qty AS 端末2の最終在庫 FROM stock WHERE item='book';
  SQL
qty
1
端末2の最終在庫
0

端末1のほうも見ます。

qty
1
端末1の最終在庫
-1

在庫が -1 になりました。

両方が「在庫は1個ある」と読み、両方が1個減らしたからです。 1個しか無い本が2人に売れました。

FOR UPDATE を付けると、これが防げます。 元に戻してやり直します。

bash
$ echo "UPDATE shop.stock SET qty=1 WHERE item='book';" | P

端末1:

bash
$ docker exec -i cons-primary mysql -uroot -prootpass shop <<'SQL'
  START TRANSACTION;
  SELECT qty FROM stock WHERE item='book' FOR UPDATE;
  SELECT SLEEP(6);
  UPDATE stock SET qty = qty - 1 WHERE item='book';
  COMMIT;
  SQL

端末2(6秒以内に):

bash
$ time docker exec -i cons-primary mysql -uroot -prootpass shop <<'SQL'
  START TRANSACTION;
  SELECT qty FROM stock WHERE item='book' FOR UPDATE;
  UPDATE stock SET qty = qty - 1 WHERE item='book';
  COMMIT;
  SELECT qty AS 最終在庫 FROM stock WHERE item='book';
  SQL
qty
0
最終在庫
-1

real	0m5.918s

端末2は 5.9 秒待たされました。 端末1が COMMIT するまで、SELECT が返ってこなかったからです。そして読めた値は 0 でした。 端末1が減らしたあとの、正しい値です。

ここで在庫が -1 になっているのは、FOR UPDATE のせいではありません。 「0個なら買わせない」という判定をアプリに書いていないからです。FOR UPDATE は「順番に読ませる」だけで、業務のルールは書いてくれません。 実際には WHERE qty > 0 を UPDATE に付けて、更新された行数を確認します。

bash
$ echo "UPDATE shop.stock SET qty=1 WHERE item='book';" | P
$ docker exec -i cons-primary mysql -uroot -prootpass shop -e \
    "UPDATE stock SET qty = qty - 1 WHERE item='book' AND qty > 0; SELECT ROW_COUNT() AS 更新できた行数;"
$ docker exec -i cons-primary mysql -uroot -prootpass shop -e \
    "UPDATE stock SET qty = qty - 1 WHERE item='book' AND qty > 0; SELECT ROW_COUNT() AS 更新できた行数;"
更新できた行数
1
更新できた行数
0

2回目は0行です。 「在庫が無かったので買えなかった」がここで分かります。ROW_COUNT() が 0 なら失敗、という判定をアプリに書くのが正解です。

犠牲はレイテンシです。 端末2は5.9秒待ちました。強整合とは「待たせること」です。 トランザクションとACIDの回と分離レベルの深掘りでやったロックの話が、そのままここに繋がります。

手段3: 準同期レプリケーション

「replica が受け取ったことを確認してから、primary が『書けました』と返す」方式です。

まず遅延を戻します。 5秒のままだと、書いた直後の replica の読み込みが毎回5秒古くなり、比べにくいからです。

bash
$ cat <<'SQL' | R
  STOP REPLICA;
  CHANGE REPLICATION SOURCE TO SOURCE_DELAY = 0;
  START REPLICA;
  SQL

ここは勘違いしやすいところです。 SOURCE_DELAY が遅らせるのは replica での適用(SQL スレッド)だけで、受け取り(リレーログへの書き込み)はすぐに行われます。準同期の確認応答は受け取った時点で返るので、SOURCE_DELAY=5 のままでも INSERT はタイムアウトしません。 そのかわり、準同期にしても replica を読めば5秒古い値が返ります。

先に、素の速さを測ります。

bash
$ time docker exec -i cons-primary mysql -uroot -prootpass shop -e \
    "INSERT INTO posts (body) VALUES ('非同期のとき');"
real	0m0.312s

プラグインを入れます。

bash
$ echo "INSTALL PLUGIN rpl_semi_sync_source SONAME 'semisync_source.so';" | P
$ echo "INSTALL PLUGIN rpl_semi_sync_replica SONAME 'semisync_replica.so';" | R

有効にします。

bash
$ cat <<'SQL' | P
  SET GLOBAL rpl_semi_sync_source_enabled = 1;
  SET GLOBAL rpl_semi_sync_source_timeout = 3000;
  SQL
bash
$ cat <<'SQL' | R
  SET GLOBAL rpl_semi_sync_replica_enabled = 1;
  STOP REPLICA IO_THREAD;
  START REPLICA IO_THREAD;
  SQL

replica 側は STOP REPLICA IO_THREAD → START REPLICA IO_THREAD を打たないと有効になりません。 接続をやり直さないと、primary 側が「この replica は準同期だ」と認識しないためです。

有効になったか確認します。

bash
$ echo "SHOW STATUS LIKE 'Rpl_semi_sync_source_clients';" | P
$ echo "SHOW STATUS LIKE 'Rpl_semi_sync_source_status';" | P
Rpl_semi_sync_source_clients	1
Rpl_semi_sync_source_status	ON

clients が 1 で status が ON なら効いています。 ここが 0 / OFF なら、上の IO_THREAD の打ち直しを忘れています。

測ります。

bash
$ time docker exec -i cons-primary mysql -uroot -prootpass shop -e \
    "INSERT INTO posts (body) VALUES ('準同期のとき');"
real	0m0.348s

直後に replica を読みます。

bash
$ echo "SELECT body FROM shop.posts ORDER BY id DESC LIMIT 1;" | R
準同期のとき

今回は新しい値が読めました。 ただしこれは、replica の適用が読み込みより先に終わっていただけです。準同期が保証するのは「少なくとも1台の replica がリレーログに受け取ったこと」までで、適用までは待ちません。 書いた直後に replica を読むと、古い値が返ることはあります。

3つの手段を、犠牲で並べる

実際に測った数字です。VMの性能で変わりますが、比が大事です。

手段書き込みの時間直後の replica 読み込み犠牲にするもの
何もしない(非同期)0.312秒古い値が返る正しさ
書いた人は primary から読む0.312秒(primary を読むので必ず新しい)replica の負荷分散効果
SELECT ... FOR UPDATE0.312秒(同一DB内の話)レイテンシ(競合時 5.9秒待った)
準同期レプリケーション0.348秒古い値が返りうる(受け取りまでしか待たない)可用性(replica が落ちると全書き込みが遅くなる)

スクリーンショットを撮ってください: 04_semisync_status.png

「準同期はたった 36 ミリ秒しか増えないなら、全部これでいいのでは」と思いました。 ここが罠です。次の節でそれを壊します。


⑥ replica を切る。二択しか無いことを見る

CAP定理という言葉を、いったん忘れてください。 覚えることは1つだけです。

primary と replica の通信が切れたとき、できることは2つしかない。 (A) 古いままの replica を読ませて、サービスを続ける (B) 「一貫性が保証できません」として、止める

両方はできません。 そして、「切れない」という選択肢はありません。 ネットワークは切れます。

実際に切ります。

replica をネットワークから切り離す

bash
$ docker network disconnect conslab_default cons-replica

コンテナは動いたままです。 通信だけが切れました。 これがネットワーク分断です。

ネットワーク名は環境で変わります。 違ったら次で確認してください。

bash
$ docker network ls | grep conslab

(A) 可用性を取る —— 古い値を返す

まず、準同期を切って、非同期に戻します。

bash
$ echo "SET GLOBAL rpl_semi_sync_source_enabled = 0;" | P
bash
$ time docker exec -i cons-primary mysql -uroot -prootpass shop -e \
    "INSERT INTO posts (body) VALUES ('分断中に書いた');"
$ echo "--- primary から読む"
$ echo "SELECT body FROM shop.posts ORDER BY id DESC LIMIT 1;" | P
$ echo "--- replica から読む"
$ echo "SELECT body FROM shop.posts ORDER BY id DESC LIMIT 1;" | R
real	0m0.298s
--- primary から読む
分断中に書いた
--- replica から読む
準同期のとき

書き込みは 0.298 秒で成功しました。 分断していることに、primary は気づいてすらいません。

そして replica は、古い値を返し続けます。 エラーも警告も出ません。

これが「可用性を取る」(AP)です。 サービスは動き続ける。ただし、読んだ値が正しい保証は無い。

一番怖いのは「エラーが出ないこと」です。 replica を読んでいるアプリは、何事も起きていないと思っています。 分断が10分続けば、10分前のデータをずっと返します。

(B) 一貫性を取る —— 返さずに止まる

準同期を戻します。 今度はすぐに非同期へ落ちないように、待ち時間を長くします。

bash
$ cat <<'SQL' | P
  SET GLOBAL rpl_semi_sync_source_enabled = 1;
  SET GLOBAL rpl_semi_sync_source_timeout = 30000;
  SQL
bash
$ echo "SHOW STATUS LIKE 'Rpl_semi_sync_source_clients';" | P
Rpl_semi_sync_source_clients	0

繋がっている replica は 0 台です。 この状態で書きます。

bash
$ time docker exec -i cons-primary mysql -uroot -prootpass shop -e \
    "INSERT INTO posts (body) VALUES ('準同期で分断中に書いた');"
real	0m30.084s

30秒かかりました。 待ち続けた末に、タイムアウトして非同期に落ちて、成功しました。

利用者から見れば、これは「エラー」と同じです。 30秒返ってこない画面は、ブラウザのタイムアウトか、サーキットブレーカで切られます。

これが「一貫性を取る」(CP)です。 正しくない値は絶対に返さない。ただし、返せないときは止まる。

MySQL の準同期は、厳密には「純粋な CP」ではありません。 タイムアウトすると自動的に非同期へ落ちて書き込みを通すからです。つまり「一貫性を諦めて可用性に切り替える」という判断が、MySQL の中に組み込まれています。タイムアウト値は、その切り替えの閾値です。

bash
$ echo "SHOW STATUS LIKE 'Rpl_semi_sync_source_status';" | P
Rpl_semi_sync_source_status	OFF

ON から OFF に変わっています。 30秒待った時点で、primary は自分で非同期へ切り替えました。

この1行が、CAP定理の全部です。 C を諦めて A を取った瞬間が、ここに記録されています。

スクリーンショットを撮ってください: 05_partition_tradeoff.png

繋ぎ直す

bash
$ docker network connect conslab_default cons-replica
bash
$ cat <<'SQL' | R
  STOP REPLICA;
  START REPLICA;
  SQL

30秒ほど待ってから確認します。

bash
$ echo "SELECT COUNT(*) FROM shop.posts;" | P
$ echo "SELECT COUNT(*) FROM shop.posts;" | R
11
11

追いつきました。 これが「eventually(いつかは)consistent」の「eventually」です。分断が直れば、いつかは合います。 その「いつか」は、分断していた時間の長さ次第です。

分断中に replica 側にも書き込みが起きていたら、こうはなりません。 今回は --read-only=ON にしていたので replica には誰も書けませんでした。両方に書ける構成にすると、繋ぎ直したときに「どちらが正しいか」を人間が決めることになります。 これが「分断に強いシステムは難しい」の中身です。


⑦ 3つの強さを、1枚の表にする

ここまで手で見たものを、並べます。

弱整合結果整合強整合
約束何も約束しないいつかは全員が同じ値になる書き込み成功の直後から、必ず新しい値
書いた直後に読むと古いかもしれず、順番も保証されない古い値が返る(今回 5秒)必ず新しい値
書き込みの速さ最速速い(0.312秒)遅い(0.348秒〜、競合時は数秒)
replica が落ちたら影響なし影響なし(古い値を返し続ける)書き込みが止まる/遅くなる
台数を増やすといくらでも速くなる読み込みは台数分速くなる増やすほど遅くなる
具体例動画通話の音声、ゲームの位置情報いいね数、閲覧数、検索インデックス、タイムライン在庫、残高、座席、注文番号
今回どこで見たか(今回は扱わない)③④で件数が 1 のままだった⑤の FOR UPDATE と準同期

「弱整合」は「壊れている」という意味ではありません。 音声通話で0.5秒前の音声を再送されても要らない、というときに、わざと捨てる設計です。


⑧ 全部を強整合にしてはいけない —— 業務ごとに選ぶ

⑤で「準同期は 36 ミリ秒しか増えない」と書きました。 では全部これでいいのか。駄目です。 理由は⑥で見ました。

replica が1台落ちただけで、全部の書き込みが 30 秒になりました。

強整合を選ぶということは、「関係する全員が生きていないと書けない」を選ぶことです。 台数を増やすほど、「誰か1台が落ちている確率」は上がります。

だから、業務ごとに選びます。 判断の表を作ります。

業務選ぶ強さ理由間違えるとどうなるか
口座の残高強整合二重に引き出せてはいけないお金が消える。取り返せない
在庫の引き当て強整合1個を2人に売れない売れないものを売る。謝罪と返金
座席・チケットの確保強整合同じ席が2枚出てはいけない当日、現場で揉める
注文の作成強整合二重注文は返金では戻らない信用の問題同じ商品が2つ届く
ログイン・権限の判定強整合権限を外した直後に使われては困る退職者がまだ入れる
いいね数・閲覧数結果整合3秒遅れても誰も困らない(困らない)
タイムライン・一覧結果整合(+read-your-writes だけ足す)全体は遅れてよいが、自分の投稿だけは見えてほしい「投稿したのに出ない」の苦情
検索インデックス結果整合数分遅れるのが普通(普通)
通知の未読数結果整合ずれても実害が小さい(小さい)
アクセス解析・集計結果整合(むしろ遅延前提)集計は元々あとから作るもの(問題なし)

この表の作り方は、たった1つの問いです。

「その値が3秒古かったせいで、取り返しのつかないことが起きるか?」

  • 起きる → 強整合。 お金・在庫・座席・権限
  • 起きない → 結果整合。 数字が3秒遅れて増えるだけのもの

「念のため全部強整合」は、判断ではなく判断の放棄です。 その分だけ、遅く、落ちやすいシステムになります。レイテンシとスループットの回で見たとおり、遅さは足し算で効いてきます。

一番よく使う実装は、これ

現実のアプリで一番よく書くのは、「全体は結果整合、自分の書き込みだけ read-your-writes」です。

// 書き込みの直後だけ、その利用者を primary に向ける
// 「lag より少し長め」の秒数を、実測してから決める
const STICKY_MS = 8000; // 実測 5秒 + 余裕3秒

function pickConnection(session) {
  const since = Date.now() - (session.lastWriteAt ?? 0);
  return since < STICKY_MS ? primaryPool : replicaPool;
}

async function createPost(session, body) {
  await primaryPool.query('INSERT INTO posts (body) VALUES (?)', [body]);
  session.lastWriteAt = Date.now();   // ここを忘れると症状が戻る
}

STICKY_MS を「実測してから決める」と書いているのが要点です。 ③で SOURCE_DELAY と GTID の差を測ったのは、この数字を決めるためです。 測らずに書いた STICKY_MS は、ただの願望です。


つまずいたところ

遠回りした過程を、消さずに置いておきます。

1. Replica_IO_Running: Connecting から進まなかった

             Replica_IO_Running: Connecting
                  Last_IO_Error: Authentication plugin 'caching_sha2_password' reported error

MySQL 8.0 の既定の認証方式が原因でした。 記事では最初から IDENTIFIED WITH mysql_native_password にしていますが、最初は指定していませんでした。 GET_SOURCE_PUBLIC_KEY=1 を足すか、認証方式を変えるかの2択で、練習用なので後者を選びました。

ここで20分溶かしました。 「Connecting のまま」は認証かネットワークのどちらかなので、Last_IO_Error を必ず読むことです。

2. SOURCE_HOST='localhost' と書いて繋がらなかった

コンテナの中の localhost は、そのコンテナ自身です。 replica が自分自身を primary として見に行っていました。Compose のサービス名(primary)を書くのが正解でした。Docker のネットワークの回で同じことをやったのに、また踏みました。

3. SOURCE_DELAY が変えられなかった

ERROR 3081 (HY000): This operation cannot be performed with running replication threads

レプリケーションを止めないと変えられません。 記事では STOP REPLICA を先に打っていますが、最初は打たずにエラーを出しました。 エラーメッセージが run STOP REPLICA SQL_THREAD FIRST と教えてくれています。エラーは下から読む、が今回も効きました。

4. 遅延させた replica では準同期がタイムアウトすると思い込んでいた

SOURCE_DELAY=5 を戻さずに準同期を有効にすると、全部の INSERT がタイムアウトまで待つと思っていました。 実際は待ちません。

  • 準同期は「replica が受け取るまで待つ」
  • しかし SOURCE_DELAY が遅らせるのは適用だけで、受け取り(リレーログへの書き込み)はすぐ
  • 結果、INSERT は待たされない。そのかわり replica を読むと5秒古い

準同期が待つのは「受け取り」で、「適用」ではありません。 ⑤の冒頭で SOURCE_DELAY = 0 に戻しているのは、書いた直後の読み込みを比べやすくするためです。

5. 準同期を有効にしたのに Rpl_semi_sync_source_clients が 0 のままだった

replica 側で STOP REPLICA IO_THREAD → START REPLICA IO_THREAD を打っていませんでした。 準同期は接続を張り直したときに決まるので、既にある接続には効きません。

SET GLOBAL を打ったのだから効いているはずだ、と思い込んだのが遠回りの原因です。設定したら、効いていることを別のコマンドで確認する。 これを飛ばすと、後の実験が全部無意味になります。

6. Seconds_Behind_Source: 0 を「遅れていない」と読んでしまった

書き込みが無い間は 0 が返ります。 「遅れていない」ではなく「新しく適用すべきものが無い」です。

そして分断中は NULL になります。 これも「遅れ 0」ではありません。「分からない」です。

遅れを本気で測るなら GTID を比べます。 「秒」は状況によって嘘をつきますが、「何トランザクション分届いていないか」は嘘をつきません。

7. docker network disconnect でネットワーク名を間違えた

Error response from daemon: network conslab not found

Compose が作るネットワーク名は、ディレクトリ名に _default が付いたものです。 conslab ではなく conslab_default。docker network ls で実物を見てから打つべきでした。

8. 在庫が -1 になったのを FOR UPDATE のせいだと思った

FOR UPDATE は「順番に読ませる」だけです。 「0個なら買わせない」はアプリのルールで、書かないと存在しません。

ロックを入れれば正しくなる、というのが誤解でした。 ロックは同時に走る処理の順番を整えるだけで、業務の正しさは自分で書きます。 ROW_COUNT() を見る形に直して、やっと -1 が止まりました。


後片づけ

立てたものを全部消します。

1. 準同期を止める

bash
$ echo "SET GLOBAL rpl_semi_sync_source_enabled = 0;" | P
$ echo "SET GLOBAL rpl_semi_sync_replica_enabled = 0;" | R

2. レプリケーションを止める

bash
$ cat <<'SQL' | R
  STOP REPLICA;
  RESET REPLICA ALL;
  SQL

3. コンテナとネットワークとデータを消す

bash
$ cd ~/conslab
$ docker compose down -v
[+] Running 3/3
 ✔ Container cons-replica    Removed
 ✔ Container cons-primary    Removed
 ✔ Network conslab_default   Removed

-v を付けているのは、MySQL のデータ本体(ボリューム)も消すためです。 これが無いと、数百MBが残り続けます。 Docker のボリュームの回でやったとおり、コンテナを消してもボリュームは残ります。

4. 残っていないか確認する

bash
$ docker ps -a | grep cons-
$ docker volume ls | grep conslab
$ docker network ls | grep conslab

3つとも何も出なければ、全部消えています。

5. 作業ディレクトリを消す

bash
$ cd ~
$ rm -rf ~/conslab
$ ls ~ | grep conslab

rm -rf は戻せません。 パスを2回読んでから打ってください。conslab という文字が入っていることを、目で確認してから Enter を押します。

6. alias を消す

bash
$ unalias P R

または端末を閉じれば消えます。

7. 最後の確認

bash
$ docker ps
$ free -h
$ df -h /

docker ps に cons- が無く、メモリとディスクが元に戻っていれば完了です。


まとめ — 理解できたこと

  • 「投稿したのに出てこない」はバグではない。 書き込みを primary、読み込みを replica に分けたその瞬間に、必ず発生する性質だった。冒頭の3件の苦情は、全部この1行から出ていた
  • 結果整合の「いつか」は、測らないと分からない。 今回は SOURCE_DELAY=5 できっかり5秒だった。実運用では負荷で変わるので、値ではなく測り方を持つことが要る
  • Seconds_Behind_Source は嘘をつく。 書き込みが無ければ 0、分断中は NULL。本当の遅れは GTID の差で見る。「秒」ではなく「何トランザクション届いていないか」
  • 単調読み取りが崩れると「リロードしたら件数が減った」になる。 自分が何もしていなくても起きるので、手がかりが無い。3件 → 2件 → 3件 を実際に出した
  • 因果一貫性が崩れると「返信が本文より先に出る」。 原因は「返信は primary、本文は replica」という一見合理的な実装。因果関係のある2つを、違う整合性の経路で読んではいけない
  • 強整合にする手段は3つあり、犠牲が全部違う。 primary から読む=分散効果を捨てる、FOR UPDATE=レイテンシを捨てる(5.9秒待った)、準同期=可用性を捨てる(ただし準同期は受け取りまでしか待たないので、replica の読み込みが新しくなる保証はない)
  • FOR UPDATE は業務の正しさを書いてくれない。 ロックは順番を整えるだけ。在庫が -1 になるのを止めたのは WHERE qty > 0 と ROW_COUNT() だった
  • 準同期は平常時 36 ミリ秒しか増えない。 それだけ見て「全部これでいい」と思ったのが誤りだった
  • replica を1台切っただけで、書き込みが 0.3秒 → 30秒 になった。 強整合は「関係する全員が生きていること」を前提にする。台数を増やすほど、その前提は崩れやすくなる
  • CAP定理は暗記するものではない。 分断したとき、古い値を返して動き続ける(AP)か、返さずに止まる(CP)かの二択しか無い、というだけの話だった
  • MySQL の準同期は、タイムアウトすると自分で非同期に落ちる。 Rpl_semi_sync_source_status が ON から OFF に変わった1行が、C を諦めて A を取った瞬間の記録だった
  • 一番怖いのは、結果整合が「エラーを出さない」こと。 分断中の replica は、何事も無かったように古い値を返し続けた。監視していなければ、誰も気づかない
  • 「念のため全部強整合」は判断の放棄。 判断の基準は1つだけ、「その値が3秒古かったせいで、取り返しのつかないことが起きるか」。起きるなら強整合(お金・在庫・座席・権限)、起きないなら結果整合(いいね・閲覧数・検索)
  • 現実に一番よく書くのは「全体は結果整合、自分の書き込みだけ read-your-writes」。 そのための「何秒 primary に向けるか」は、③で遅延を測ったから決められる。測らずに書いた数字は、ただの願望

参考リンク


次に読む

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

記事
← 前の記事メッセージキューの型 — 急ぎの仕事が後ろで待つ
→ 次の記事可用性とSLO — 99.9%は月に43分しかない

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

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

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

System Design›System Design — Consistency
  • 強整合・弱整合・結果整合を実際に起こす
  • CAP は分断が起きたときの二択

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

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

コメント

コメントする

目次