※本記事はアフィリエイト広告(PR)を含みます。
負荷分散の回で、アプリのプロセスを2つに増やしました。片方を落としても 200 が返るところまで確認して、その回はそこで終わっています。
前回: L4とL7の違いは中身を見るか — OSI参照モデル 作業場所はVMの中(Ubuntu Server)です。
appdb(MySQL)、Docker Compose、~/serverの Express + Knex が動いている状態から始めます。
ただ、あの記事の最後に、こういう表を置きました。
| 壊れ方 | 耐えられるか |
|---|---|
| 片方のアプリが落ちる | ✅ 耐えられる |
| MySQL が落ちる | ❌ 1台しか無いので全滅 |
アプリだけ2つにして、データベースは1台のままだったのです。
つまり、いまの構成はこうなっています。
nginx
/ \
アプリ① アプリ②
\ /
MySQL ← ここが落ちたら、上を何台に増やしても全部止まる
増やした意味が、ほとんど無い状態です。 一番落ちて困るものが1つしか無いからです。こういう場所を単一障害点(SPOF)と呼びます。
この回で、その穴を埋めます。 ただ、埋めてみると分かるのですが、データベースを増やすと、増やす前には無かった問題が新しく生まれます。
書いた直後に読むと、まだ無い。
これが今日の山場です。そして、これは NoSQL の回で出てきた「結果整合性」そのものです。NoSQL の性質だと思っていたものが、MySQL でも普通に起きます。
対象レベル: 中級 / 区分: 必修
この記事でわかること
- 「データベースを増やす」には、まったく別の2つの方法があること。同じものを複数持つ(レプリケーション)と、分けて持つ(シャーディング)は、解いている問題が違うこと
- レプリケーションは「読み」しか増やせないこと。書き込みは、結局1台に集まる
- 結果整合性は NoSQL の専売特許ではないこと。MySQL のレプリケーションでも、まったく同じことが起きる
- CAP定理は「3つから2つ選ぶ」ではないこと。ネットワークが切れたときに、古いデータを返すか、エラーを返すかの話だということ
- シャーディングをすると、
JOINと集計とトランザクションを失うこと。だから最後の手段であること - レプリケーションはバックアップではないこと。消せば、両方から消える
この記事でやること
- Docker Compose で MySQL を2台立てる(先に
docker statsでメモリを見る。軽い設定にする) - レプリケーションを組んで、書き込み側に入れたデータが読み取り側に出てくるのを目で見る
- わざと遅れを作って、「書いた直後に読むと、まだ無い」を再現する
- Knex で読み書きの接続先を分ける。書いた直後だけ書き込み側から読む逃げ方を書く
docker network disconnectでネットワークを切って、CAP定理を実験で確かめる- 片づけて、メモリを返す
先に知る言葉
この記事で初めて出てくる言葉です。 基本的な言葉は用語集にもまとめてあります。
| 言葉 | 意味 |
|---|---|
| レプリケーション | 同じデータを、複数のサーバーに持つこと。複製 |
| ソース / レプリカ | 複製元(書き込み側)と複製先(読み取り側)。昔は master / slave と呼ばれていた |
| バイナリログ(binlog) | MySQL が「何を変更したか」を順番に書き出したファイル。レプリカはこれを読んで真似する |
| GTID | 変更1つ1つに付く世界で唯一の通し番号。「どこまで反映したか」を番号で言える |
| レプリケーション遅延(ラグ) | 複製元に入ってから、複製先に出るまでの時間差 |
| 結果整合性 | いつかは揃うが、いま揃っている保証は無いという状態 |
| 強整合性 | 書いた瞬間から、どこで読んでも必ず新しい状態 |
| シャーディング | データを分割して、別々のサーバーに置くこと。レプリケーションとは別物 |
| CAP定理 | ネットワークが切れたとき、整合性と可用性は両立しないという定理 |
| フェイルオーバー | 壊れたほうから、生きているほうへ切り替えること |
| スプリットブレイン | 切り替えを失敗して、2台とも「自分が本番だ」と思い込む事故 |
| 単一障害点(SPOF) | そこが落ちたら全部止まる場所。 いまの MySQL がこれ |
「レプリケーション」と「シャーディング」を混ぜないでください。 この2つの区別が、この記事の半分です。
増やし方は2種類ある
「データベースを増やす」と一言で言いますが、中身は完全に別の話が2つあります。
| レプリケーション | シャーディング | |
|---|---|---|
| 何をするか | 同じものを複数持つ | 分けて持つ |
| 1台に入っているデータ | 全部(同じものが2つある) | 一部だけ(合わせて1つ) |
| 解決する問題 | 読みが多い / 落ちたら困る | 1台に入りきらない |
| 失うもの | 少ない(遅延が出るだけ) | JOIN・集計・トランザクション |
| 難易度 | やれる | 最後の手段 |
絵にするとこうです。
レプリケーション(同じものを複数持つ)
書き込み ──→ [ 1〜100番 全部 ]
│ コピー
↓
読み取り ←─── [ 1〜100番 全部 ]
シャーディング(分けて持つ)
1〜50番の人 ──→ [ 1〜50番 ]
51〜100番の人 ─→ [ 51〜100番 ]
↑
どっちにも「全部」は無い
先にやるのは、必ずレプリケーションのほうです。 シャーディングは、レプリケーションでも索引でもキャッシュでも足りなくなってからの手段です(後半で理由を書きます)。
レプリケーションで「増える」のは読みだけ
ここを最初に押さえてください。
レプリカを10台に増やしても、書き込みの性能は1ミリも上がりません。
書き込みは必ず複製元の1台に集まるからです。レプリカは、その1台がやったことを後から真似するだけなので、書き込みの量はどのレプリカも複製元と同じだけあります。
| 増えるもの | 増えないもの |
|---|---|
読み取り(SELECT)を分散できる | 書き込み(INSERT / UPDATE) |
| 複製元が落ちても、データが残る | 1件あたりの速さ(むしろ遅延が増える) |
世の中のWebサービスは、読みが書きより圧倒的に多いので、これでもかなり効きます。ただし「データベースが遅い」の原因が書き込みなら、レプリケーションは効きません。パフォーマンスの回でやったとおり、先に測ってください。
① 先にメモリを見る
MySQL は、動かしているだけでメモリを食います。 これから2台立てます。学習用のVMでは、ここが一番の事故ポイントです。
立てる前に、いまの空きを見ます。
出力例(この記事の実機)
total used free shared buff/cache available
Mem: 3.8Gi 1.4Gi 1.1Gi 12Mi 1.3Gi 2.2Gi
Swap: 0B 0B 0B
available の数字を見てください。 ここが1.5GB を切っているなら、先に何かを止めてください。
availableが 1GB を切ったまま MySQL を2台立てると、Killedが出ます。 これは Linux の OOM Killer が、メモリを一番食っているプロセスを問答無用で殺した印です。エラーメッセージが出ないので、原因が分からず何時間も溶かします。先に見ておけば、5秒で分かります。
MySQL を 2 台立てるたびに VM のメモリと相談するのが続くなら、自宅で常時動かす検証用の小型マシンを 1 台足す手もあります。GMKtec
のミニ PC は、G11 PLUS(Ryzen 5 3500U)が 16GB+512GB SSD で 54,999 円、メモリ・SSD・OS 非搭載のベアボーンキットなら 29,900 円(税込・2026 年 10 月 3 日時点の公式ストア表示)です。基本は香港からの発送で、OS 搭載構成は Windows 11 Pro・初期設定言語が英語なので、届いてからの準備も見込んでおいてください。
② Docker Compose で MySQL を2台立てる
置き場所を作る
VM に元から入っている MySQL(appdb)は止めません。 あれはあれで動かしたまま、別の2台をコンテナで立てます。 触るものを増やさないためです。
MYSQL_ROOT_PASSWORD=repl_root_change_me
REPL_PASSWORD=repl_user_change_me
APP_PASSWORD=app_user_change_me
.envは Compose が自動で読みます。 Composeの回でやったとおり、同じディレクトリに置くだけで${...}に入ります。Git に上げないでください。
compose.yaml
services:
primary:
image: mysql:8.0
restart: unless-stopped
command:
- --server-id=1
- --log-bin=binlog
- --binlog-format=ROW
- --gtid-mode=ON
- --enforce-gtid-consistency=ON
- --innodb-buffer-pool-size=64M
- --performance-schema=OFF
- --skip-mysqlx
environment:
MYSQL_ROOT_PASSWORD: ${MYSQL_ROOT_PASSWORD}
ports:
- "127.0.0.1:3307:3306"
volumes:
- primary-data:/var/lib/mysql
replica:
image: mysql:8.0
restart: unless-stopped
command:
- --server-id=2
- --relay-log=relaylog
- --gtid-mode=ON
- --enforce-gtid-consistency=ON
- --read-only=ON
- --super-read-only=ON
- --innodb-buffer-pool-size=64M
- --performance-schema=OFF
- --skip-mysqlx
environment:
MYSQL_ROOT_PASSWORD: ${MYSQL_ROOT_PASSWORD}
ports:
- "127.0.0.1:3308:3306"
volumes:
- replica-data:/var/lib/mysql
volumes:
primary-data:
replica-data:
1行ずつ
| 書いたもの | 意味 |
|---|---|
image: mysql:8.0 | mysql:8 ではなく 8.0 と書いています。 8.4 では今回使う命令の一部が消えています。ただし 8.0 は 2026年4月30日でサポートが終了した版です(後述) |
--server-id | サーバーの背番号。 レプリケーションでは全員が違う番号でなければいけません |
--log-bin | バイナリログを出す。 これが無いと、複製先に渡すものが存在しません |
--binlog-format=ROW | 「どの行がどう変わったか」で記録する。 MySQL 8.0 の既定値ですが、重要なので明示しています |
--gtid-mode=ON | 変更1つ1つに通し番号を付ける。 「どこまで反映したか」を人間が数えなくて済みます |
--innodb-buffer-pool-size=64M | MySQL が握るメモリの上限。 既定は 128M ですが、2台なので半分に絞っています |
--performance-schema=OFF | 統計取得の仕組みを止める。 これだけで数百MB変わります。学習用なので切ります |
--skip-mysqlx | 使っていない別プロトコルを止める。 起動するだけでメモリを取ります |
--read-only / --super-read-only | 読み取り側を、手で書き換えられないようにする(複製の反映だけは通ります) |
ports: "127.0.0.1:3307:3306" | 左端の 127.0.0.1 が本体。 これが無いと外から丸見えになります |
ポートが 3307 と 3308 なのは、VM の MySQL が 3306 を使っているからです。同じ番号は2つ使えません。
Address already in useが出たら、まずこれを疑ってください。
MYSQL_DATABASE:は、どちらにも書いていません。 ここでデータベースを作ると、複製を組む前に両側の中身がずれます。 中身は、複製を組んでから作ります。
起動する
初回は、イメージのダウンロードに数分かかります。 STATUS が両方 Up になるまで待ってください。
ready for connections が出ていれば起動しています。先にログを見てください。 落ちていると次の手順が全部エラーになり、原因を見失います。
もう一度メモリを見る
[スクリーンショット: 01_docker_statsでメモリを見る.png] docker stats --no-stream で、repl-primary-1 と repl-replica-1 の MEM USAGE が並んでいる画面を撮ってください。
ここで想定より大きければ、先に進まないでください。 途中で OOM Killer に殺されると、レプリケーションが半端な状態で止まり、初心者には区別のつかないエラーが出ます。
③ レプリケーションを組む
複製用のユーザーを作る(書き込み側)
複製先は、複製元に「客として」ログインしてバイナリログを読みに来ます。 そのためのユーザーが要ります。
パスワードを聞かれたら、.env に書いた MYSQL_ROOT_PASSWORD を打ちます。
-pの後ろにパスワードを続けて書かないでください。-pxxxxと書くと、シェルの履歴とpsの一覧に平文で残ります。 対話で打てば残りません。
CREATE USER 'repl'@'%' IDENTIFIED BY 'repl_user_change_me';
GRANT REPLICATION SLAVE ON *.* TO 'repl'@'%';
SELECT @@GLOBAL.gtid_executed;
出力例
+-----------------------------------------+
| @@GLOBAL.gtid_executed |
+-----------------------------------------+
| 3f2a1c8e-...-9b1d:1-4 |
+-----------------------------------------+
この文字列を、まるごとコピーしてください。 次の手順で使います。「複製元は、ここまで済んでいる」という印です。
REPLICATION SLAVEという権限名は、いまでもこの綴りです。 呼び名が master/slave から source/replica に変わったあとも、権限名だけは互換のために残っています。 打ち間違いではありません。
exit で抜けます。
「どこから複製するか」を教える(読み取り側)
RESET MASTER;
SET GLOBAL gtid_purged = '3f2a1c8e-...-9b1d:1-4';
この2行が何をしているか。 複製先は、起動したときに自分でも少しだけ内部の変更をしています。そのまま繋ぐと、複製元の「最初から」を全部やり直そうとして、
CREATE USERの重複などで止まります。
RESET MASTERで自分の履歴を消し、gtid_purgedに複製元の現在地を入れることで、「ここまでは済んだことにする。続きから頼む」と宣言しています。
RESET MASTER は MySQL 8.4 で RESET BINARY LOGS AND GTIDS に置き換えられ、使えなくなりました。 mysql:8.0 を指定したのはこれが理由です。バージョンを上げると、この行が動かなくなります。 ただし、MySQL 8.0 は 2026年4月30日でサポートが終了しています(セキュリティ修正も出ません)。この記事の 8.0 は、手元のVMで壊して学ぶための練習用と割り切ってください。 現行の LTS である 8.4 で試すときは、この行を RESET BINARY LOGS AND GTIDS; に置き換えます(8.4 では他にも既定の違いがあり、この記事の手順を 8.4 でそのまま通るかは確かめていません)。
続けて、繋ぎ先を教えます。
CHANGE REPLICATION SOURCE TO
SOURCE_HOST = 'primary',
SOURCE_PORT = 3306,
SOURCE_USER = 'repl',
SOURCE_PASSWORD = 'repl_user_change_me',
SOURCE_AUTO_POSITION = 1,
GET_SOURCE_PUBLIC_KEY = 1;
START REPLICA;
| 項目 | 意味 |
|---|---|
SOURCE_HOST = 'primary' | compose.yaml に書いたサービス名。Compose が名前解決してくれます。IPアドレスは要りません |
SOURCE_PORT = 3306 | コンテナ同士の通信なので 3306 です。 3307 ではありません(あれはVMから見た番号) |
SOURCE_AUTO_POSITION = 1 | GTID で「続きから」を自動で決める。 ファイル名と位置を手で書かなくて済みます |
GET_SOURCE_PUBLIC_KEY = 1 | これが無いと繋がりません(下で説明します) |
GET_SOURCE_PUBLIC_KEY = 1を落とすと、こう出ます。Authentication plugin 'caching_sha2_password' reported error: Authentication requires secure connection.MySQL 8 の既定のパスワード方式は、暗号化されていない接続では、先に公開鍵を受け取る必要があります。 この1行がそれを許可しています。本番なら、鍵を配るのではなく通信自体をTLSにします。
動いているか確認する
SHOW REPLICA STATUS\G
行数が多いので、見るのは4つだけです。
Replica_IO_Running: Yes
Replica_SQL_Running: Yes
Seconds_Behind_Source: 0
Last_Error:
| 項目 | 意味 |
|---|---|
Replica_IO_Running | 複製元から受け取れているか。 ここが No / Connecting なら繋がっていない |
Replica_SQL_Running | 受け取ったものを自分に反映できているか。 ここが No なら中身で失敗している |
Seconds_Behind_Source | 何秒遅れているか。 0 なら追いついています |
Last_Error | 止まった理由。 ここが空でないなら、まずこれを読みます |
IOとSQLは、別々に止まります。 そして原因がまったく違います。
止まった側 原因の方向 IOがNoネットワーク・ユーザー・パスワード(外の問題) SQLがNo反映しようとした内容が失敗した(中の問題。重複キーなど) 「レプリケーションが止まった」で調べる前に、どっちが止まったのかを見てください。
[スクリーンショット: 02_レプリカの状態がYes.png] SHOW REPLICA STATUS\G の結果で、Replica_IO_Running: Yes と Replica_SQL_Running: Yes が写っている部分を撮ってください。
④ 書いたものが、もう一方に出てくる
ここが今日の中心です。 複製元で作ったものが、何もしていない複製先に勝手に出てくるのを目で見ます。
exit して、複製元に入ります。
CREATE DATABASE shopdb;
USE shopdb;
CREATE TABLE tasks (
id INT AUTO_INCREMENT PRIMARY KEY,
title VARCHAR(200) NOT NULL,
done TINYINT(1) NOT NULL DEFAULT 0
);
INSERT INTO tasks (title) VALUES ('複製されるはずのタスク');
SELECT * FROM tasks;
exit して、今度は複製先に入ります。
SHOW DATABASES;
SELECT * FROM shopdb.tasks;
出力例
+----+----------------------------+------+
| id | title | done |
+----+----------------------------+------+
| 1 | 複製されるはずのタスク | 0 |
+----+----------------------------+------+
複製先では、CREATE DATABASE も CREATE TABLE も INSERT も、1つも打っていません。
[スクリーンショット: 03_読み取り側に出てくる.png] 複製先(replica)で SELECT * FROM shopdb.tasks; を打って、行が返っている画面を撮ってください。
表の作成(DDL)も複製されます。 マイグレーションの回でやった
ALTER TABLEも、複製元に流せば複製先に伝わります。マイグレーションを2回打つ必要はありません。(ただし、大きな表へのALTERは複製先を長時間止めます。 これは後半の遅延の話に直結します)
読み取り側に書こうとすると、断られる
INSERT INTO shopdb.tasks (title) VALUES ('こっちに書いてみる');
ERROR 1290 (HY000): The MySQL server is running with the --super-read-only
option so it cannot execute this statement
これは正しい動きです。 --super-read-only を付けたのはこのためです。
ここを開けてはいけません。 読み取り側に手で書くと、その行は複製元に存在しません。 以後、同じ
idが複製元に来た瞬間に重複で止まります。「レプリカに書き込めるようにしたら壊れた」は、この事故です。
⑤ 遅れを、目に見える大きさにする
さっきは一瞬で出ました。 同じPCの中で、データが2件しか無いからです。本番ではそうなりません。
遅れは、常にあります。 ただ、小さすぎて見えないだけです。見えるまで拡大します。
exit して、複製先に入ります。
STOP REPLICA;
CHANGE REPLICATION SOURCE TO SOURCE_DELAY = 10;
START REPLICA;
「受け取ったものを、10秒待ってから反映する」という設定です。
これはズルではありません。 本当に起きていることを、10秒に引き伸ばしただけです。実際の現場では、重い
UPDATE、大きなALTER TABLE、遅いネットワーク、複製先のCPU不足で、これが数秒から数分になります。
書いた直後に読む
VM側でターミナルをもう1つ開いてください(VS Code のターミナルなら + で増やせます)。
片方(複製元)で入れて、
すぐにもう片方(複製先)で読みます。
出力例(入れた直後)
+----+----------------------------+------+
| id | title | done |
+----+----------------------------+------+
| 1 | 複製されるはずのタスク | 0 |
+----+----------------------------+------+
入れたはずの行が、ありません。 エラーも出ません。「無い」という答えが、正常に返ってきます。
10秒後にもう一度同じコマンドを打つと、出てきます。
[スクリーンショット: 04_書いた直後はまだ無い.png] 複製元に INSERT した直後の SELECT に行が無く、少し待った後の SELECT には行がある、その2回分が並んでいる画面を撮ってください。
これが「結果整合性」の正体
NoSQL の回で名前だけ出てきた言葉が、いま目の前で起きました。
結果整合性 = 「いつかは揃う」。「いま揃っている」ではない。
そして重要なのはここです。
これは NoSQL の性質ではありません。 データを2箇所以上に持った瞬間に、必ず出てくる性質です。MySQL でも、PostgreSQL でも、同じことが起きます。
「NoSQL は結果整合性だから信用できない、MySQL は ACID だから安心」という説明を見かけますが、半分しか合っていません。
| 1台のとき | 複製したとき | |
|---|---|---|
| MySQL | 強整合性(ACIDの回のとおり) | 複製先は結果整合性 |
| MongoDB | 1件の更新は原子的 | 複製先は結果整合性 |
ACID の回で COMMIT した瞬間に確定する、と書きました。あれは嘘ではありません。 ただし「確定するのは、COMMIT を受けたそのサーバーの中で」です。別のサーバーで読んだときの話は、あの回はしていませんでした。
遅れの設定は戻しておきます。
STOP REPLICA;
CHANGE REPLICATION SOURCE TO SOURCE_DELAY = 0;
START REPLICA;
⑥ アプリ側の対応 —— 読み書きを分ける
データベースを2台にしても、アプリが片方しか見ていなければ意味がありません。 接続を2つ持ちます。
接続を2本にする
const knex = require("knex");
const base = { client: "mysql2", pool: { min: 0, max: 2 } };
const conn = (port) => ({
host: "127.0.0.1",
port: port,
user: "app",
password: process.env.APP_PASSWORD,
database: "shopdb",
});
const write = knex({ ...base, connection: conn(3307) }); // 複製元
const read = knex({ ...base, connection: conn(3308) }); // 複製先
async function main() {
const title = "test-" + Date.now();
await write("tasks").insert({ title: title });
console.log("書き込み側に入れた:", title);
const a = await write("tasks").where({ title: title }).first();
const b = await read("tasks").where({ title: title }).first();
console.log("書き込み側で読む:", a ? "ある" : "ない");
console.log("読み取り側で読む:", b ? "ある" : "ない");
await write.destroy();
await read.destroy();
}
main();
先にアプリ用のユーザーを作ります。複製元に作れば、複製先には勝手にできます。
CREATE USER 'app'@'%' IDENTIFIED BY 'app_user_change_me';
GRANT SELECT, INSERT, UPDATE, DELETE ON shopdb.* TO 'app'@'%';
ユーザーの作成も複製されます。 複製先で
SELECT User, Host FROM mysql.user;を見ると、appが増えています。片方に作れば済むのは、地味ですが効きます。
動かします。
出力例
書き込み側に入れた: test-1757400000000
書き込み側で読む: ある
読み取り側で読む: ある
遅延をもう一度 10 秒に設定してから同じものを流すと、読み取り側で読む: ない になります。 ここまでが再現できれば、レプリケーションの理解としては十分です。
書いた直後だけ、書き込み側から読む
この問題に、綺麗な解決はありません。 現実には、こういう逃げ方をします。
// 「この人は、さっき書いた」を覚えておく
const recentWriters = new Map();
const STICKY_MS = 5000;
function dbFor(userId) {
const until = recentWriters.get(userId);
if (until && until > Date.now()) {
return write; // 書いた直後の5秒だけ、書き込み側から読む
}
return read; // それ以外は読み取り側
}
async function createTask(userId, title) {
await write("tasks").insert({ title: title });
recentWriters.set(userId, Date.now() + STICKY_MS);
}
async function listTasks(userId) {
return dbFor(userId)("tasks").select("*");
}
これは「読んだ本人だけは、自分の書いたものが必ず見える」ようにする方法です。read-your-writes(自分の書き込みは読める)と呼びます。
完璧ではありません。 割り切っている点を、正直に書きます。
| 割り切っていること | 中身 |
|---|---|
| 他人の書き込みは遅れて見える | Aさんが書いた5秒後まで、Bさんには見えないことがある |
| 5秒という数字に根拠は無い | 実際の遅延を測って決めます。測らずに決めない |
| 書き込み側の負荷が増える | 「直後」の読みが全部そっちに行くため |
この Map は、アプリを2つにすると壊れる
気づいた人は、もう分かっているはずです。
recentWritersは、Node.js のプロセスの中にあります。
負荷分散の回で、まったく同じ形の事故を起こしました。セッションをプロセスの中に置いていたので、アプリを2つにしたらログインが切れた、あれです。
今回も同じです。 書いたときはアプリ①、次に読むときはアプリ②に振り分けられると、アプリ②は「この人がさっき書いた」ことを知りません。 結果、また消えます。
直し方も同じです。
プロセスの外に出す。 つまり Redis に置きます。TTL(有効期限)は Redis が勝手に切ってくれるので、
Date.now()の比較も要りません。
「状態をアプリの中に持たない」は、1回覚えれば一生使えます。 今日で2回目です。
⑦ CAP定理を、ネットワークを切って確かめる
CAP定理は、たいてい「3つのうち2つしか選べない」と説明されます。 その説明で理解できた人を、私は見たことがありません。切ってみます。
切る
ネットワーク名とコンテナ名は、
docker network lsとdocker compose psで実際の名前を確認してください。 ディレクトリ名がreplでなければ、前半が変わります。
これで、複製先は複製元から完全に見えなくなりました。 ケーブルを引き抜いたのと同じです。これが「ネットワーク分断(Partition)」です。
docker compose execは、ネットワークを切っても使えます。 コンテナの中で直接コマンドを動かしているだけで、通信をしていないからです。
複製元に書く
複製元は、平然と成功します。 相手が消えたことを、まだ知りもしません。
複製先で読む
「分断中に入れた」は出てきません。 そして —— エラーも出ません。
[スクリーンショット: 05_分断中は古いデータが返る.png] docker network disconnect した後に複製先で SELECT を打ち、最新の行が無い状態で正常に結果が返っている画面を撮ってください。
複製先の状態を見ると、こうなっています。
Replica_IO_Running: Connecting
Last_IO_Error: error connecting to master 'repl@primary:3306'
IO が止まり、SQL は生きています。 さっきの表のとおり、外側の問題です。
古いデータを返すか、エラーを返すか
いま起きたことを、言葉にします。
複製先は、「知らない」とは言わずに「古い」を返した。
これが選択です。 分断されたとき、複製先にできることは2つしかありません。
| 選択 | やること | 何を守ったか | 何を捨てたか |
|---|---|---|---|
| A を取る | 古いデータでも返す(いまの動き) | 可用性(止まらない) | 整合性(内容が古い) |
| C を取る | 「答えられません」とエラーを返す | 整合性(嘘を言わない) | 可用性(止まる) |
両方は、原理的に無理です。 相手と話せないのに「相手と同じ答え」を保証する方法はありません。これが CAP定理です。
C を取りたければ、こう書きます。
async function readSafely(maxLagSeconds) {
// SHOW REPLICA STATUS には REPLICATION CLIENT 権限が要る。
// app には付けていないので、複製元で次を足しておく(複製先にも伝わる)
// GRANT REPLICATION CLIENT ON *.* TO 'app'@'%';
const rows = await read.raw("SHOW REPLICA STATUS");
const st = rows[0][0];
const healthy =
st.Replica_IO_Running === "Yes" &&
st.Seconds_Behind_Source !== null &&
st.Seconds_Behind_Source <= maxLagSeconds;
if (!healthy) {
// ① 書き込み側に切り替える(可用性を優先)
// ② またはエラーを返す(整合性を優先)
throw new Error("読み取り側が古すぎます");
}
return read("tasks").select("*");
}
「どちらを選ぶか」に正解はありません。 ただし、選ばないという選択肢はありません。 決めなければ、A(古いデータを返す)が既定で選ばれます。 いま実際にそうなりました。
CAPの正しい読み方
| よくある説明 | 実際 |
|---|---|
| ❌ 3つから2つ選ぶ | ✅ P は選べない。 ネットワークは勝手に切れる |
| ❌ CA型のデータベースがある | ✅ 1台構成のこと。 分断が起きないなら定理の対象外 |
| ❌ システム全体でどれか1つ | ✅ 機能ごとに変えられる。 残高はC、いいね数はA、で構わない |
PACELC という続きもあります。「分断していないときは(Else)、遅さ(Latency)と整合性のどちらを取るか」という話です。今日やったことは、分断していないときにも遅れが出たので、その半分をすでに見ています。
繋ぎ直す
しばらくして読むと、「分断中に入れた」が出てきます。
STOP REPLICA; START REPLICA;を打っているのは、待たされるからです。 複製先は、繋がらなくなると既定で60秒おきにしか再挑戦しません。 何もしなくても復旧しますが、「復旧しない」と勘違いする時間が生まれます。
これが「いつかは揃う(結果整合性)」の実演です。 揃うまでの間、システムは間違った答えを返し続け、そして誰にも怒られませんでした。
⑧ シャーディング —— 分けると何ができなくなるか
ここからは手を動かしません。 やらないほうがいいからです。理由を書きます。
シャーディングは、データを分けて別々のサーバーに置くことです。「1台のディスクに入りきらない」「書き込みが1台で捌けない」を解く、唯一の方法でもあります。レプリケーションでは絶対に解けません(書きは増えないので)。
ただし、分けた瞬間に、これだけ失います。
| 失うもの | 何が起きるか |
|---|---|
JOIN | 相手のテーブルが別のサーバーにある。SQL 1本では書けない。アプリで2回引いて自分で繋ぐ |
| 集計 | SELECT COUNT(*) が全台に聞いて足す作業になる。ORDER BY ... LIMIT 10 も全台から集めて並べ直す |
| トランザクション | ACIDの回がまるごと効かなくなる。 台をまたぐ「全部やるか、1つもやらないか」は成立しない |
AUTO_INCREMENT | 各台が「1, 2, 3…」と振るのでIDがぶつかる。別の採番方法が要る |
| 一意制約 | 「メールアドレスは全体で1つだけ」が保証できない。別の台に同じものが入れられる |
| 分け直し | 一番きついのはこれ。 2台を3台にすると全データの置き場所が変わる。動かしながらやることになる |
「どの列で分けるか(シャードキー)」は、後から変えられません。 変えるには全部を配り直すからです。設計を1回で当てなければならない、という点で、この記事で扱った他のどれとも難易度が違います。
やらずに済ませる方法を、先に全部試す
上から順に、必ずこの順番で試してください。
| 順番 | 手段 | どこでやったか |
|---|---|---|
| 1 | 測る。 本当にデータベースが原因か確かめる | パフォーマンスの回 |
| 2 | 索引を張る。 全件走査を1つ潰すだけで桁が変わる | 同上 |
| 3 | N+1 を潰す。 101回の問い合わせを1回にする | 同上 |
| 4 | キャッシュを入れる。 同じ読みを何度もさせない | Redisの回 |
| 5 | 読み取りレプリカを足す。 今日やったこと | この記事 |
| 6 | 古いデータを別の表に移す。 現役の表を小さく保つ | — |
| 7 | サーバーを大きくする(スケールアップ)。 お金で殴る。驚くほど遠くまで行けます | — |
| 8 | シャーディング | ここまで来てから |
7番を軽く見ないでください。 いまのサーバー1台は、10年前のデータセンター1つ分の力があります。「アプリを書き直すより、メモリを128GBにするほうが安い」は、実際によくあります。シャーディングは、お金では買えなくなってからの手段です。
⑨ フェイルオーバー —— 自動でやるのは難しい
複製元が落ちたとき、複製先を昇格させれば、システムは生き延びます。
手でやるなら、こうです。
STOP REPLICA;
RESET REPLICA ALL;
SET GLOBAL super_read_only = OFF;
SET GLOBAL read_only = OFF;
これで、複製先は「ただの MySQL」に戻り、書き込めるようになります。
難しいのは、この後です。
| 残っている仕事 | 中身 |
|---|---|
| アプリの接続先を変える | 全アプリの設定(3307 → 3308)を書き換えて再起動。その間は止まります |
| 落ちた側が復活したとき | 古い複製元は、自分がまだ本番だと思っています |
| 未反映の変更 | 複製元にあって複製先に届いていなかった分は、消えます |
スプリットブレイン
2台とも「自分が書き込み側だ」と思い込む事故を、スプリットブレインと呼びます。
両方に別々の書き込みが入り、どちらも正しく、どちらも不完全になります。 後から自動で直す方法はありません。 人間が、片方を捨てるか、1行ずつ突き合わせるかです。
この事故が起きる典型は、「複製元が落ちた」の判定を間違えたときです。
落ちたのか、ネットワークが切れて見えないだけなのかは、外からは区別がつきません。
さっき docker network disconnect でやったことが、まさにそれです。 複製元は動き続けていたのに、複製先からは「落ちた」ようにしか見えませんでした。あそこで自動昇格していたら、2台とも書き込み可になっていました。
だから、自動フェイルオーバーの本体は「切り替えること」ではありません。
古いほうを、確実に殺すこと(フェンシング)です。
この仕事をやる道具は、名前だけ挙げておきます。 いま入れる必要はありません。
| 道具 | 何 |
|---|---|
| MySQL InnoDB Cluster / Group Replication | MySQL 本体が持つ、複数台で多数決する仕組み |
| Orchestrator | 構成を監視して切り替えを指揮する道具 |
| マネージドサービス(RDS など) | 切り替えをクラウド側がやる。 現実的には、これが最初の選択肢 |
Kubernetes の回で「1台落としてもPodは移る」をやりました。あれと同じことを、データベースでやるのは桁違いに難しいです。アプリは状態を持たないから移せるのであって、データベースは状態そのものだからです。
⑩ やりすぎない —— まず1台をきちんとバックアップする
最後に、一番大事なことを書きます。
レプリケーションはバックアップではありません。
理由は1行です。
DELETE FROM tasks;
この操作も、忠実に複製されます。 0.1秒後には、両方から消えています。
| レプリケーション | バックアップ | |
|---|---|---|
| 守れるもの | ディスクが壊れた・サーバーが落ちた | 上に加えて、消した・間違えた・戻したい |
| 時間 | いまの状態しか無い | 過去のある時点に戻せる |
| 人為ミス | ❌ 一緒に消える | ✅ 戻せる |
そして、優先順位はこうです。
1台のバックアップが取れていないなら、2台目を立てるより先に、そっちです。
理由: データが消える原因の圧倒的1位は、ハードウェア故障ではなく、人間の操作だからです。レプリケーションは、この1位に対して何の効果もありません。
最低限、これだけはやっておいてください。
| 引数 | なぜ |
|---|---|
--single-transaction | 表をロックせずに、ある一瞬の姿を取る。 ACIDの回の分離レベルが効いています |
--routines --events | ストアドプロシージャなども一緒に取る |
そして —— 戻す練習を1回してください。
戻したことのないバックアップは、バックアップではありません。
取れているつもりのファイルが、実は 0 バイトだったは、本当によくあります。障害の回でやったとおり、壊れる前に壊しておくのがVMの価値です。今日立てたコンテナは、戻す練習の相手として最適です(本番でも何でもないので)。
つまずいたところ
| 症状 | 原因と直し方 |
|---|---|
docker compose up の直後に片方が消える | メモリ不足(OOM Killer)。 dmesg -T | grep -i "killed process" で確認。--innodb-buffer-pool-size をさらに小さく(32M)するか、他を止める |
Address already in use | VM の MySQL が 3306 を使っている。 ports: の左を 3307 / 3308 にしているか確認 |
Replica_IO_Running: Connecting のまま | 繋がっていない。 Last_IO_Error を読む。大半はパスワード違いか、SOURCE_PORT を 3307 と書いた(正しくは 3306) |
Authentication requires secure connection | GET_SOURCE_PUBLIC_KEY = 1 を書き忘れている。 STOP REPLICA; してから CHANGE REPLICATION SOURCE TO GET_SOURCE_PUBLIC_KEY = 1; を打ち直す |
Replica_SQL_Running: No で Error 1007(データベースが既に存在) | MYSQL_DATABASE: を書いたか、RESET MASTER と gtid_purged を飛ばした。 一番早いのは docker compose down -v からやり直すこと |
RESET MASTER が You have an error in your SQL syntax | イメージが 8.4 以上。 mysql:8.0 を指定しているか確認。8.4 なら RESET BINARY LOGS AND GTIDS |
server-id のエラーで起動しない | 2つのサービスに同じ番号を書いている。 1 と 2 で違えます |
| ネットワークを繋ぎ直したのに復旧しない | 60秒待つか、STOP REPLICA; START REPLICA;。 止まったのではなく、次の再挑戦を待っているだけ |
docker network disconnect でコンテナ名が見つからない | docker compose ps で実際の名前を見る。ディレクトリ名が接頭辞になります |
Seconds_Behind_Source が NULL | 遅れが0なのではなく、複製が止まっている。 NULL は「測れない」。0 と混同しない |
一番はまったのは
Seconds_Behind_Source: NULLでした。 「0に近いから大丈夫」と読んで放置し、その間ずっと複製が止まっていました。NULLは数字ではありません。監視するなら、NULLを異常として扱ってください(監視の回の話です)。
後片づけ
MySQL 2台は、動かしているだけでメモリを食い続けます。 次の回で「なぜか重い」の犯人になります。 使わないなら消してください。
止めるだけ(データは残る)
データごと消す
-vを付けると名前付きボリュームごと消えます。 Composeの回のとおり、戻せません。grepで何も出なければ消えています。
イメージも消す(600MB近くあります)
練習用のファイルを消す
メモリが返ってきたか確認する
止めていたアプリを戻す
VM の
appdb(MySQL)、Redis、~/serverはそのままにしてください。 この回で消えるのは、今日立てた2台だけです。
まとめ
- アプリを増やしても、データベースが1台なら単一障害点は残る。 負荷分散の回でやり残したのはここだった
- 増やし方は2種類。 レプリケーション(同じものを複数持つ)とシャーディング(分けて持つ)は別物
- レプリケーションで増えるのは読みだけ。 書き込みは複製元1台に集まり続ける
- 複製されるのはデータだけではない。 表の作成もユーザーの作成も伝わる
- 複製先は
--super-read-onlyにする。 手で書き込むと、その時点で壊れる Replica_IO_RunningとReplica_SQL_Runningは別々に止まり、原因も別。 IO は外(接続)、SQL は中(内容)Seconds_Behind_Source: NULLは「遅れ0」ではなく「止まっている」- 遅れは常にある。 小さくて見えないだけで、
SOURCE_DELAYで拡大すると必ず見える - 「書いた直後に読むと、まだ無い」= 結果整合性。 NoSQL の性質ではなく、データを2箇所に持った瞬間の性質
COMMITが確定させるのは「それを受けたサーバーの中」まで。 ACID は嘘ではないが、範囲がある- アプリの逃げ方は read-your-writes。 書いた直後の数秒だけ、書き込み側から読む
- その「直後かどうか」をプロセスの中に置くと、アプリ2台で壊れる。 Redis に出す。これで2回目
- CAP は「3つから2つ」ではない。 P は選べない。 分断のとき 古いのを返す(A)か、エラーを返す(C)か
- 決めなければ A が既定で選ばれる。 実際、複製先はエラーを出さずに古い行を返した
- CAP はシステム全体で1つ選ぶものでもない。 残高は C、いいね数は A、で構わない
- シャーディングは
JOIN・集計・トランザクション・一意制約を失う。 分け直しが一番きつい - その前に、索引・N+1・キャッシュ・読み取りレプリカ・スケールアップを全部試す。 お金で殴れる範囲は広い
- 自動フェイルオーバーの本体は「切り替え」ではなく「古いほうを確実に殺すこと」
- 「落ちた」と「見えないだけ」は外から区別できない。 間違えるとスプリットブレイン
- レプリケーションはバックアップではない。
DELETEは両方に伝わる - 2台目を立てるより、1台のバックアップと、戻す練習が先
参考リンク
- roadmap.sh — Backend(Database Replication / Sharding Strategies / CAP Theorem の項目)
- roadmap.sh — SQL
- MySQL 8.0 リファレンス — レプリケーション
- MySQL 8.0 — GTID を使ったレプリケーション
- MySQL 8.0 — CHANGE REPLICATION SOURCE TO
- MySQL 8.0 — SHOW REPLICA STATUS
- MySQL 8.0 — 遅延レプリケーション
- MySQL 8.0 — mysqldump
- MySQL 8.0 — read_only と super_read_only
- mysql(Docker 公式イメージ)
- Docker — network disconnect
- Docker Compose — Compose file リファレンス
次に読む
この記事は 【第8段階】深掘り の 9 / 30 本目です。
| 記事 | |
|---|---|
| ← 前の記事 | L4とL7の違いは中身を見るか — OSI参照モデル |
| → 次の記事 | 読んでも消えないキュー — Kafkaとオフセット |
上から順に読めば積み上がるように並べています。 飛ばしても構いませんが、詰まったら前の回に戻ってください。
全体の順路は はじめに にあります。
roadmap.sh のどこをやっているか
- レプリケーションとシャーディング
- CAP定理(ネットワークが切れたとき、何を諦めるか)
この記事は、上の項目を実際に手を動かして確かめる回です。

コメント