RDSとElastiCacheの仕組み — フェイルオーバーで接続が切れる

RDSとElastiCacheの仕組み。データベースとキャッシュのブロック、再接続の矢印。

※本記事はアフィリエイト広告(PR)を含みます。

フェイルオーバーの瞬間、接続は切れます。RDSとElastiCacheの仕組みを押さえ、アプリ側で何をすべきかを決めます。

前回: Route 53とDNSのTTL — 切り替えたのに古いサーバーへ行く

これは【深掘り】の記事です。本線の順路ではありません。 本線の プロセスを止めても消えない場所 — MySQLとSQLの基本 で立てた MySQL を、 人に任せるとどうなるのかを、ここで掘ります。飛ばしても本線は進めます。

このシリーズは、読者にアカウントを作らせません。 触るのは LocalStack と、aws CLI の --endpoint-url だけです。 課金が発生する操作は一切しません。 料金は具体的な金額を書きません(変わるため)。 何に対して課金されるかという構造だけを書き、数字は公式の料金ページ(RDS / ElastiCache)を見てください。 コマンドは VM の中(Ubuntu Server)で打ちます。 最後に全部消します。 なお LocalStack は2026年3月23日から1つのイメージに統合され、それ以降の版(2026.03.0 以降)は起動に auth token(LocalStack のアカウントで取得。無料プランあり)が必要になりました。 この記事では、統合前に公開されて更新が止まった localstack/localstack:3 を固定して使い、アカウントを作らずに進めます。旧イメージの固定は練習用の短期的な手段です(公式は、更新が来ない・修正済みの脆弱性が残ると注意しています)。新しい版を使う場合は、取得した token を LOCALSTACK_AUTH_TOKEN 環境変数に設定します。

この記事には、最初に正直に書いておくことがあります。 LocalStack のコミュニティ版では、RDS と ElastiCache は「作ったことになる」だけで、中の MySQL も Redis も動きません。 接続して SELECT を投げることはできません。だからこの記事の目的は「動かすこと」ではなく、 設定項目の意味を読めるようになることです。 実際に手を動かして確かめる部分は、すべて Docker の MySQL / Redis で再現します。


私は MySQL を自分で立てられます。

Docker で mysql:8 を上げて、ボリュームを付けて、ユーザーを作って、設定ファイルを書いて、mysqldump を cron で回す。 Redis も同じです。redis:7 を上げて、maxmemory と maxmemory-policy を書く。両方とも、この連載でやりました。

だから RDS の説明を最初に読んだとき、私はこう理解しました。

マネージドにすれば、DBの運用が要らなくなる。

これが、完全に間違いでした。


最初にそれを疑ったのは、練習で作った DB が遅かったときです。

RDS にしていれば速いはず、という前提でいたので、原因が分かりませんでした。 実際に遅かった理由は、索引が張られていない WHERE 句でした。

AWS は、私のクエリを速くしてくれません。

もう1つは、「マルチAZ」を有効にしたときです。待機系のインスタンスが立ち上がったので、 読み取りが2台に分散されて速くなると思っていました。

なりませんでした。 待機系は、読み取りにも使えません。

そして極めつけが、これです。

Error: Connection lost: The server closed the connection.
    at Connection._handleProtocolEnd ...

DBの切り替え(フェイルオーバー)が起きた瞬間、アプリが全部落ちました。 自動で切り替わってくれるはずなのに、なぜアプリが落ちるのかが分かりませんでした。

自動で切り替わるのは「DB側」だけです。 既にDBに繋がっていたコネクションは、全部切断されます。 繋ぎ直すのは、アプリの仕事です。

この3つの誤解を、この記事で1つずつ潰します。


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

目次

この記事でわかること

  • マネージドは「運用が要らなくなる」ではなく「運用の種類が変わる」。 肩代わりされる仕事と、絶対に自分に残る仕事がはっきり分かれている
  • RDS では設定ファイルを直接編集できない。 設定はパラメータグループという別の入れ物で変える。再起動が要るものと要らないものがある
  • マルチAZ は速くするための機能ではない。 待機系は読み取りにも使えない。速くしたいならリードレプリカで、それは別の機能
  • フェイルオーバーでは既存の接続が全部切れる。 エンドポイント名は変わらない(DNSが向き先を変える)ので、アプリは繋ぎ直せばいい。繋ぎ直す処理が無いと落ちる
  • バックアップは「取れているか」ではなく「戻せるか」を確かめないと意味がない。 そして DBインスタンスを消すと自動バックアップも消える
  • キャッシュ(ElastiCache)を入れる前に、索引とクエリを見る。 キャッシュは、遅い原因を隠すのが上手いだけ
  • 正直な結論: 個人開発の初期は、1台のVMに同居させるほうが安くて速い

この記事でやること

  1. AWS が肩代わりする仕事と、自分に残る仕事を、2列の表に分ける(ここが山場)
  2. LocalStack で create-db-instance を打ち、全パラメータの意味を1つずつ読む
  3. パラメータグループを作り、max_connections を変えて、再起動が要る設定と要らない設定を確かめる
  4. マルチAZ と リードレプリカの違いを表にして、「速くならない」誤解を潰す
  5. Docker の MySQL を再起動して、アプリの接続が切れる瞬間を実際に再現し、リトライを実装して直す
  6. スナップショットから復元して、「戻せること」を確かめる
  7. ElastiCache(Redis / Memcached)の違いを表にし、キャッシュを入れる前に見るものを確認する
  8. 自分で立てる vs RDS の判断表を作り、全部消す

先に知る言葉

基本的な言葉は用語集にもまとめてあります。

言葉意味
RDSAWS が MySQL / PostgreSQL などを代わりに動かしてくれるサービス。Relational Database Service
ElastiCache同じく Redis / Memcached を代わりに動かしてくれるサービス
DBインスタンスRDS が動かしている1台のこと。EC2 のインスタンスと同じ数え方
エンドポイントDBに繋ぐための名前(xxxx.ap-northeast-1.rds.amazonaws.com の形)。IPではなく名前で繋ぐ
マルチAZ別のデータセンターに待機系を持ち、故障したら自動で切り替える構成。速くする機能ではない
フェイルオーバー故障時に、待機系が本番に昇格すること。切り替えの瞬間、接続は切れる
リードレプリカ読み取り専用の複製。マルチAZ とは目的も仕組みも別
パラメータグループ設定ファイルの代わり。RDS では DB の設定値をここで持つ
自動バックアップRDS が毎日勝手に取るバックアップ。保持期間を過ぎると消える
スナップショット自分の意思で取るバックアップ。明示的に消すまで残る

① マネージドにしても、消えない仕事がある

この記事で一番大事なのは、ここです。 コマンドは出てきません。先に線を引きます。

RDS を使い始めると、DBの仕事が2つに割れます。

AWS が肩代わりしてくれる仕事自分に残る仕事
OS とエンジンのパッチ当て(apt upgrade 相当)スキーマ設計 — どの表にどの列を持つか
バックアップの取得(毎日・自動)索引 — どの列に張るか、張りすぎていないか
故障したハードの入れ替え遅いクエリ — EXPLAIN を読んで直すのは自分
待機系の同期と、故障時の自動切り替え接続数の管理 — 何本まで開くか、プールするか
リードレプリカの構築(コマンド1本)アプリ側の再接続 — 切れたときに繋ぎ直す処理
ストレージの自動拡張パラメータの選択 — 何をどの値にするかの判断
監視メトリクスの収集メトリクスを見て、次にどう動くかの判断
エンジンの新バージョンの提供いつアップグレードするかの判断とテスト

左の列を見てください。全部「手を動かす作業」です。 右の列を見てください。 全部「設計と判断」です。

マネージドは、作業を肩代わりします。判断は肩代わりしません。

そして、判断のほうが難しい。


「運用が要らなくなる」ではなく「運用の種類が変わる」

自分で MySQL を立てていたとき、私の運用はこうでした。

・ディスクが埋まっていないか見る
・mysqldump が失敗していないか見る
・セキュリティ更新が出たら apt upgrade して再起動する
・落ちたら SSH で入って起こす

RDS にすると、この4つは消えます。 その代わり、こういう仕事が増えます。

・パラメータグループのどの値を変えるか決める
・メンテナンスウィンドウをいつにするか決める(この時間帯に再起動されうる)
・エンジンのメジャーバージョンアップを、いつ・どうテストして当てるか決める
・アプリ側に「接続が切れたら繋ぎ直す」処理を書く
・接続数の上限に当たっていないか監視する

後者のほうが、知識が要ります。

「楽になる」と思って入れると、 「知らないうちに再起動された」「バージョンアップの案内を無視していたら強制で上がった」という形で殴られます。

この記事の残りは、右の列を1つずつ潰していく作業です。


課金の構造だけ、先に書いておく

金額は書きません(変わるので、書いた瞬間に嘘になります)。何に対してお金が発生するかの構造だけです。

課金の対象何で決まるか
インスタンス稼働時間インスタンスクラスの大きさ × 動いていた時間
ストレージ確保した容量(使った量ではない)。減らせない
バックアップ確保容量を超えた分のバックアップ保管量
マルチAZ待機系のぶん、インスタンスとストレージがもう1組
リードレプリカ1台につき、もう1組。台数ぶん増える
データ転送AZ をまたぐ通信など

マルチAZ とリードレプリカは「機能を有効にする」のではなく「もう1台借りる」ことです。 具体的な金額は、RDS の料金ページ を見てください。


② DBインスタンスを作る — 全パラメータを読む

準備 — LocalStack を立てる

bash
$ mkdir -p ~/awslab/rds
$ cd ~/awslab/rds
$ nano docker-compose.yml
services:
  localstack:
    image: localstack/localstack:3
    ports:
      - "4566:4566"
    environment:
      - SERVICES=rds,elasticache,ec2
      - DEBUG=0
    volumes:
      - "./volume:/var/lib/localstack"
bash
$ docker compose up -d
$ docker compose ps
NAME         IMAGE                     STATUS                   PORTS
localstack   localstack/localstack:3   Up 21 seconds (healthy)   0.0.0.0:4566->4566/tcp

(healthy) になるまで待ちます。

bash
$ aws configure set aws_access_key_id test
$ aws configure set aws_secret_access_key test
$ aws configure set region ap-northeast-1
$ alias awsl='aws --endpoint-url=http://localhost:4566'

本物のアクセスキーを絶対にここに入れないでください。 LocalStack は認証情報を見ません。 この記事は最初から最後まで、本物の AWS には1度も繋ぎません。


置き場所を先に作る(サブネットグループ)

RDS は「どこに置くか」を先に決めないと作れません。

これは 公開と非公開の差はルート1行 — AWS深掘り の続きです。 DBは、インターネットから直接見えない場所(プライベートサブネット)に置きます。

bash
$ VPC=$(awsl ec2 create-vpc --cidr-block 10.0.0.0/16 \
    --query 'Vpc.VpcId' --output text)

$ SUB_A=$(awsl ec2 create-subnet --vpc-id $VPC --cidr-block 10.0.11.0/24 \
    --availability-zone ap-northeast-1a --query 'Subnet.SubnetId' --output text)

$ SUB_C=$(awsl ec2 create-subnet --vpc-id $VPC --cidr-block 10.0.12.0/24 \
    --availability-zone ap-northeast-1c --query 'Subnet.SubnetId' --output text)

$ echo "$VPC / $SUB_A / $SUB_C"
vpc-4a1f7c93e2b806d5f / subnet-9e2c41f7a3d508b6c / subnet-71b3e8d40f9a25c7e

サブネットを2つ作ったのには理由があります。

bash
$ awsl rds create-db-subnet-group \
    --db-subnet-group-name lab-db-subnets \
    --db-subnet-group-description "practice only" \
    --subnet-ids $SUB_A $SUB_C \
    --query 'DBSubnetGroup.[DBSubnetGroupName,VpcId]' --output text
lab-db-subnets   vpc-4a1f7c93e2b806d5f

サブネットグループには、最低2つの AZ のサブネットが要ります。 1つしか渡さないと、作成そのものが拒否されます。 理由は 「マルチAZ にしたくなったとき、待機系を置く場所が要るから」 です。 AWS は、最初から「1台では足りなくなる日」を前提に設計させます。


DBインスタンスを作る

ここが本題です。 1行ずつ意味があるので、丸ごとコピーせずに読んでください。

bash
$ awsl rds create-db-instance \
    --db-instance-identifier lab-mysql \
    --engine mysql \
    --engine-version 8.0.35 \
    --db-instance-class db.t3.micro \
    --allocated-storage 20 \
    --storage-type gp3 \
    --master-username labadmin \
    --master-user-password "PracticeOnly-ChangeMe" \
    --db-subnet-group-name lab-db-subnets \
    --no-publicly-accessible \
    --backup-retention-period 7 \
    --preferred-backup-window 17:00-17:30 \
    --preferred-maintenance-window sun:18:00-sun:18:30 \
    --no-multi-az \
    --query 'DBInstance.[DBInstanceIdentifier,DBInstanceStatus,Engine]' --output text
lab-mysql   creating   mysql

PracticeOnly-ChangeMe は、この記事の練習用の文字列です。 本物のパスワードとして使わないでください。 本番では手で決めず、Secrets Manager などに生成させます。 パスワードをコマンドラインに書く時点で本番の作法ではありません(シェルの履歴に残ります)。

1行ずつ読みます。

パラメータ何を決めているか
--db-instance-identifierこの DB の名前。エンドポイント名の一部になる。後から変えるとエンドポイントも変わる
--engineMySQL か PostgreSQL かなど。後から変えられない。変えたければ作り直して移行
--engine-versionエンジンのバージョン。上げるのは自分の判断。下げられない。本物の RDS では、MySQL 8.0 の標準サポートは2026年7月31日に終わり、今は追加料金のかかる延長サポート(RDS Extended Support)でだけ使えます(8.0.35 は提供一覧にもありません)。ここでは LocalStack の練習として 8.0.35 のまま進めますが、本物で新しく作るなら 8.4 系を選び、パラメータグループのファミリーもその版に合わせます
--db-instance-classCPU とメモリの大きさ。EC2 のインスタンスタイプと同じ考え方で、頭に db. が付く
--allocated-storageディスクの大きさ(GiB)。増やせるが、減らせない
--storage-typeディスクの種類。前回の EBS の話と同じ gp3 などを選ぶ
--master-username最初の管理ユーザー名。一部の予約語(root など)は使えない
--master-user-password管理ユーザーのパスワード。練習用の文字列にすること
--db-subnet-group-nameどの VPC のどのサブネットに置くか。上で作ったもの
--no-publicly-accessibleインターネット側から名前解決させない。ここが一番大事(下で説明)
--backup-retention-period自動バックアップを何日残すか。0 にすると自動バックアップが無効(⑥で説明)
--preferred-backup-windowバックアップを取る時間帯(UTC)。UTC なので日本時間と9時間ずれる
--preferred-maintenance-windowAWS がパッチを当てる時間帯(UTC)。再起動されうる時間帯
--no-multi-az待機系を持たない。練習では持たない(④で意味を説明)

--preferred-backup-window 17:00-17:30 は、日本時間の深夜2時です。 UTC で書くので、日本時間のつもりで書くと、一番アクセスが多い時間に当たります。


--publicly-accessible を true にしない

これは、この記事で一番強く言いたいことです。

--publicly-accessible を有効にすると、DBのエンドポイントがインターネット側のアドレスに解決されるようになります。

「自分のPCの GUI ツールから直接繋げて便利だから」 という理由で、これを有効にしてしまう例があります。

やらないでください。

セキュリティグループで絞っていても、それは「壁が1枚しか無い」状態です。 設定を1つ間違えた瞬間に、データベースがインターネットに露出します。

DBは、アプリのサーバーからしか見えない場所に置きます。 自分が繋ぎたいときは、 アプリのサーバーを経由します。

確認します。

bash
$ awsl rds describe-db-instances --db-instance-identifier lab-mysql \
    --query 'DBInstances[0].[DBInstanceIdentifier,DBInstanceStatus,PubliclyAccessible,MultiAZ,EngineVersion]' \
    --output table
-----------------------------------------------------------------
|                     DescribeDBInstances                       |
+-------------+------------+---------+---------+----------------+
|  lab-mysql  |  available |  False  |  False  |  8.0.35        |
+-------------+------------+---------+---------+----------------+

PubliclyAccessible が False であることを、毎回この目で確認します。

エンドポイントの名前も見ておきます。

bash
$ awsl rds describe-db-instances --db-instance-identifier lab-mysql \
    --query 'DBInstances[0].Endpoint' --output json
{
    "Address": "lab-mysql.localhost.localstack.cloud",
    "Port": 3306
}

IP ではなく、名前が返っています。 この「名前で繋ぐ」という点が、⑤で効いてきます。

スクリーンショットを撮ってください: 01_rds_created.png describe-db-instances の表で PubliclyAccessible が False になっている画面を撮ってください。

正直に書きます。 LocalStack のコミュニティ版では、このエンドポイントに MySQL クライアントで繋いでも応答しません。 「作った記録」が返ってくるだけです。 中の MySQL は動いていません。 本物の RDS では、ここで mysql -h <エンドポイント> -u labadmin -p が通ります。 実際に接続して確かめる実験は、⑤で Docker の MySQL を使ってやります。


③ パラメータグループ — 設定ファイルを直接触れない

自分で MySQL を立てていたとき、設定を変えるのはこうでした。

bash
$ sudo nano /etc/mysql/conf.d/custom.cnf
$ sudo systemctl restart mysql

RDS では、これができません。

理由ははっきりしています。 RDS のインスタンスには、SSH で入れないからです。 「OS の面倒は AWS が見る」ということは、裏返すと「OS を触らせない」ということです。

代わりに、パラメータグループという入れ物を作って、そこに値を書きます。

bash
$ awsl rds create-db-parameter-group \
    --db-parameter-group-name lab-mysql80 \
    --db-parameter-group-family mysql8.0 \
    --description "practice only" \
    --query 'DBParameterGroup.[DBParameterGroupName,DBParameterGroupFamily]' --output text
lab-mysql80   mysql8.0

--db-parameter-group-family は、エンジンとバージョンの組です。 mysql8.0 用のグループを、PostgreSQL に付けることはできません。


max_connections を変えてみる

一番よく変えるのがこれです。 「同時に何本の接続を受け付けるか」の上限です。

bash
$ awsl rds modify-db-parameter-group \
    --db-parameter-group-name lab-mysql80 \
    --parameters "ParameterName=max_connections,ParameterValue=200,ApplyMethod=pending-reboot"
{
    "DBParameterGroupName": "lab-mysql80"
}

ApplyMethod に注目してください。 ここが、この節の山です。

ApplyMethod意味使えるパラメータ
immediateすぐ反映する動的パラメータだけ
pending-reboot次に再起動したときに反映するどちらでも指定できる

そして、パラメータには2種類あります。

種類反映のしかた例
動的(dynamic)再起動なしで反映できるslow_query_log、long_query_time、general_log
静的(static)再起動しないと反映されないmax_connections、innodb_buffer_pool_instances、log_bin

max_connections は静的です。 ApplyMethod=immediate を指定するとエラーになるか、指定できても反映されません。

これは、自分で立てた MySQL でも同じです。 SET GLOBAL で変えられる値と、設定ファイルを書いて再起動しないと変わらない値がある。 RDS が特別なのではなく、MySQL がそういう作りなのです。

動的か静的かは、一覧で確認できます。

bash
$ awsl rds describe-engine-default-parameters \
    --db-parameter-group-family mysql8.0 \
    --query 'EngineDefaults.Parameters[?ParameterName==`max_connections`].[ParameterName,ApplyType,AllowedValues]' \
    --output table
------------------------------------------------
|      DescribeEngineDefaultParameters         |
+-------------------+----------+---------------+
|  max_connections  |  static  |  1-100000     |
+-------------------+----------+---------------+

ApplyType が static と出ています。 この一覧を見る癖を付けると、事故が減ります。

LocalStack のコミュニティ版では、この一覧が空だったり、簡略化された内容が返ることがあります。 本物の AWS では、数百行の一覧が返ってきます。 形だけ覚えて、実物は公式ドキュメントで引いてください。


既定値は「数字」ではなく「式」で書かれている

ここが、自分で立てるのと一番違うところです。

RDS のパラメータの既定値を見ると、こういう文字列が入っています。

max_connections = {DBInstanceClassMemory/12582880}

数字ではありません。式です。

DBInstanceClassMemory は、そのインスタンスクラスのメモリ量です。 つまり max_connections の既定値は、インスタンスの大きさによって自動的に変わります。

これが何を意味するか。

小さいインスタンスから大きいインスタンスに変えると、max_connections も勝手に増えます。 逆に、大きいインスタンスから小さくすると、勝手に減ります。 「アプリの接続プールの上限を変えていないのに、突然 Too many connections が出た」の原因はこれです。

自分で数字を固定したいなら、明示的に書きます。 ただし、その値がメモリに見合っているかは自分の責任です。

接続を1本開くたびに、MySQL はメモリを使います。 max_connections を大きくすれば安全になるのではなく、 大きくした結果メモリを使い切って落ちる、という壊れ方をします。

正しい直し方は、上限を上げることではなく、「アプリが接続を開きすぎていないか」を見ることです。 接続プールを使っていない、あるいは使い捨てで開いては閉じている、というのが典型的な原因です。

変更したグループを DB に付けます。

bash
$ awsl rds modify-db-instance \
    --db-instance-identifier lab-mysql \
    --db-parameter-group-name lab-mysql80 \
    --apply-immediately \
    --query 'DBInstance.DBParameterGroups' --output json
[
    {
        "DBParameterGroupName": "lab-mysql80",
        "ParameterApplyStatus": "applying"
    }
]

applying であって、in-sync ではありません。 静的パラメータを変えた場合、in-sync になるのは再起動のあとです。

bash
$ awsl rds reboot-db-instance --db-instance-identifier lab-mysql \
    --query 'DBInstance.DBInstanceStatus' --output text
rebooting

「再起動する」というのは、⑤で見る「接続が全部切れる」と同じことが起きるということです。 設定を変えるだけのつもりでも、アプリから見れば障害と同じです。


④ マルチAZ は「速くする」ものではない

私が一番長く誤解していたのが、ここです。

マルチAZ を有効にすると、別の AZ にもう1台立ちます。 私はそれを「2台になったから、読み取りが分散される」と思っていました。

待機系(standby)には、読み取りすら投げられません。

【マルチAZ(シングルスタンバイ)】

  アプリ ──→ [ 本番インスタンス ] ══同期══> [ 待機系 ]
                    ↑                          ↑
              全部の読み書き              ⚠️ 何も投げられない
                                        (ただ同じ内容を持っているだけ)

では何のためにあるのか。 本番が壊れたときに、待機系が代わりに立つためです。

それだけです。速さのための機能ではありません。


リードレプリカとの違い

「読み取りを分散したい」のなら、使うのはこちらです。

マルチAZ(待機系)リードレプリカ
目的壊れたときに止まらないこと読み取りの負荷を分けること
複製のしかた同期(書き込みは両方に書けてから完了)非同期(少し遅れて届く)
読み取りに使えるか使えない使える
書き込みできるかできないできない(読み取り専用)
故障時に自動で昇格するかする(自動)しない(手動で昇格させる)
AZ をまたぐか必ずまたぐ(またがないと意味がない)同じでも別でも、別リージョンでも可
書き込み性能への影響少し遅くなる(両方に書くため)ほぼ無い
エンドポイント同じ1つ(切り替わっても名前は同じ)別の名前(アプリが振り分ける)

表の一番下の行が、実務では一番効きます。

  • マルチAZ: アプリの接続先は1つのまま。アプリの改修が要らない
  • リードレプリカ: アプリが「これは読み取りだからレプリカへ」と自分で振り分ける必要がある

リードレプリカは、有効にしただけでは何も速くなりません。 アプリのコードを直さないと、誰もレプリカを使いません。


非同期であることの意味

リードレプリカは非同期です。つまり、

1. アプリが本番に INSERT する          → 成功が返る
2. アプリがすぐレプリカから SELECT する → ⚠️ まだ無い

「保存したのに、リロードしたら消えている」という不具合の正体がこれです。

これは AWS の話ではなく、レプリケーションそのものの性質です。 詳しくは 書いた直後に読むと無い — レプリケーションとCAP でやりました。

RDS にしても、この問題は消えません。 ①の表でいう「自分に残る仕事」です。


ただし、例外がある

正確を期すために書いておきます。

  • Aurora では、待機系にあたるものが読み取りに使えます(構造そのものが違う)
  • 「マルチAZ DBクラスター」 という新しい方式では、待機系のうち読み取りに使えるものがあります

この記事で「待機系は読めない」と書いているのは、従来のマルチAZ(シングルスタンバイ)の話です。 どれを使っているかで答えが変わるので、公式ドキュメントを必ず確認してください。

LocalStack のコミュニティ版では、マルチAZ の切り替え動作は再現されません。 --multi-az を付けて作ると MultiAZ: true と返りますが、本当に待機系が立っているわけではありません。

bash
$ awsl rds modify-db-instance --db-instance-identifier lab-mysql \
    --multi-az --apply-immediately \
    --query 'DBInstance.[DBInstanceIdentifier,MultiAZ]' --output text
lab-mysql   True

True と返りましたが、これは「設定が記録された」だけです。 次の節で、切り替えの瞬間に何が起きるかを、Docker の MySQL で本当に再現します。


⑤ フェイルオーバーで、接続は切れる

ここが、この記事のタイトルにした部分です。

フェイルオーバーが起きると、何が起きるのか。

【切り替え前】
  アプリ ──(TCP接続 10本)──> [ 本番 ] ══> [ 待機系 ]
       lab-mysql.xxx.rds.amazonaws.com → 10.0.11.25

【切り替え中】 ⚠️ 数十秒
  アプリ ──✕ 切断 ✕──   [ 故障 ]      [ 昇格中 ]
       DNS が書き換わる

【切り替え後】
  アプリ ──(新しく繋ぎ直せば)──> [ 元・待機系が本番に ]
       lab-mysql.xxx.rds.amazonaws.com → 10.0.12.31   ← ⚠️ 名前は同じ、IPが変わった

大事なのは2つです。

  1. エンドポイントの「名前」は変わらない。 設定ファイルを書き換える必要はない
  2. 既存の TCP 接続は、全部切れる。 繋ぎ直すのはアプリの仕事

「自動フェイルオーバー」という言葉が誤解を生みます。 自動なのは DB 側の昇格だけで、アプリの再接続は自動ではありません。


手元で、本当に再現する

LocalStack では起こせないので、Docker の MySQL でやります。 アプリから見れば、「DBが急に居なくなって、少し経って戻ってくる」という点は同じです。

bash
$ mkdir -p ~/awslab/rds/failover
$ cd ~/awslab/rds/failover
$ nano docker-compose.yml
services:
  db:
    image: mysql:8
    environment:
      MYSQL_ROOT_PASSWORD: practice-only-pass
      MYSQL_DATABASE: labdb
    ports:
      - "3307:3306"
bash
$ docker compose up -d
$ docker compose ps
NAME               IMAGE     STATUS          PORTS
failover-db-1      mysql:8   Up 30 seconds   0.0.0.0:3307->3306/tcp

practice-only-pass は練習用です。 本番のパスワードを compose ファイルに直接書かないでください。

繋がることを確認します。

bash
$ docker compose exec db mysql -uroot -ppractice-only-pass -e "SELECT 1 AS ok;"
ok
1

素朴なアプリを書く

1秒ごとに SELECT NOW() を投げ続けるだけのプログラムです。

bash
$ cd ~/awslab/rds/failover
$ npm init -y > /dev/null
$ npm install mysql2
$ nano app-naive.js
const mysql = require('mysql2/promise');

async function main() {
  const conn = await mysql.createConnection({
    host: '127.0.0.1',
    port: 3307,
    user: 'root',
    password: 'practice-only-pass',
    database: 'labdb',
  });
  console.log('接続しました');

  for (let i = 1; ; i++) {
    const [rows] = await conn.query('SELECT NOW() AS t');
    console.log(i, rows[0].t.toISOString());
    await new Promise((r) => setTimeout(r, 1000));
  }
}

main().catch((e) => {
  console.error('落ちました:', e.code, e.message);
  process.exit(1);
});
bash
$ node app-naive.js
接続しました
1 2026-10-06T12:04:01.000Z
2 2026-10-06T12:04:02.000Z
3 2026-10-06T12:04:03.000Z

動いています。ここで、別のターミナルを開いて、DBを落とします。

bash
$ cd ~/awslab/rds/failover
$ docker compose restart db

元のターミナルを見ます。

7 2026-10-06T12:04:07.000Z
落ちました: PROTOCOL_CONNECTION_LOST Connection lost: The server closed the connection.

アプリが死にました。

DBは10秒ほどで復帰します。

bash
$ docker compose exec db mysql -uroot -ppractice-only-pass -e "SELECT 1;"
1
1

DBは戻っているのに、アプリは死んだままです。

これが、私が本物の RDS でやらかしたことです。 AWS のコンソールでは「フェイルオーバーは正常に完了しました」と出ているのに、 サービスは止まったままでした。 止めていたのは、私のコードです。


直す — 繋ぎ直す処理を書く

直し方は2段階です。

  1. クエリが「接続断」で失敗したら、繋ぎ直してやり直す
  2. やり直しは、間隔を空けて、回数を決めて行う
bash
$ nano app-retry.js
const mysql = require('mysql2/promise');

const CONF = {
  host: '127.0.0.1',
  port: 3307,
  user: 'root',
  password: 'practice-only-pass',
  database: 'labdb',
  connectTimeout: 3000,
};

// 「繋がっていない」系のエラーだけを再試行の対象にする
const RETRYABLE = new Set([
  'PROTOCOL_CONNECTION_LOST',
  'ECONNRESET',
  'ECONNREFUSED',
  'ETIMEDOUT',
  'EPIPE',
]);

const sleep = (ms) => new Promise((r) => setTimeout(r, ms));

let conn = null;

async function getConn() {
  if (conn) return conn;
  conn = await mysql.createConnection(CONF);
  console.log('  → 繋ぎ直しました');
  return conn;
}

async function queryWithRetry(sql, maxTry = 6) {
  for (let attempt = 1; attempt <= maxTry; attempt++) {
    try {
      const c = await getConn();
      const [rows] = await c.query(sql);
      return rows;
    } catch (e) {
      if (!RETRYABLE.has(e.code)) throw e;      // 文法エラーなどは即あきらめる
      conn = null;                               // 壊れた接続は捨てる
      const waitMs = Math.min(2 ** attempt * 100, 5000)
                   + Math.floor(Math.random() * 200);  // ゆらぎ
      console.log(`  ! ${e.code} — ${attempt}回目、${waitMs}ms 待って再試行`);
      await sleep(waitMs);
    }
  }
  throw new Error('再試行しても繋がりませんでした');
}

async function main() {
  for (let i = 1; ; i++) {
    const rows = await queryWithRetry('SELECT NOW() AS t');
    console.log(i, rows[0].t.toISOString());
    await sleep(1000);
  }
}

main().catch((e) => {
  console.error('落ちました:', e.message);
  process.exit(1);
});

もう一度、同じことをします。

bash
$ node app-retry.js

別のターミナルで、

bash
$ docker compose restart db
5 2026-10-06T12:11:05.000Z
  ! PROTOCOL_CONNECTION_LOST — 1回目、315ms 待って再試行
  ! ECONNREFUSED — 2回目、548ms 待って再試行
  ! ECONNREFUSED — 3回目、912ms 待って再試行
  ! ECONNREFUSED — 4回目、1687ms 待って再試行
  ! ECONNREFUSED — 5回目、3298ms 待って再試行
  → 繋ぎ直しました
6 2026-10-06T12:11:17.000Z
7 2026-10-06T12:11:18.000Z

12秒ほど止まりましたが、アプリは死にませんでした。

スクリーンショットを撮ってください: 02_failover_retry.png PROTOCOL_CONNECTION_LOST のあとに → 繋ぎ直しました が出て、カウントが再開している画面を撮ってください。

書いた再試行には、意味のある工夫が3つ入っています。

工夫なぜ要るか
待ち時間を倍にしていく復帰していないDBを、1秒間隔で叩き続けても無駄。むしろ復帰の邪魔になる
ゆらぎ(ランダム)を足す全サーバーが同じ秒に一斉に殺到するのを防ぐ
再試行するエラーを絞る文法エラーを再試行しても永遠に通らない。無限に叩くだけ

この3つは、落ちても全部は止めない — サーキットブレーカと縮退 でやった話と同じです。 フェイルオーバーへの備えは、DBの機能ではなく、アプリの設計です。


もう1つの罠 — DNS のキャッシュ

エンドポイントの名前は変わらず、向き先の IP だけが変わる。 ということは、名前を引き直さないアプリは、古い IP に繋ぎ続けます。

手元で名前解決を見てみます。

bash
$ getent hosts localhost
127.0.0.1       localhost

本物の RDS のエンドポイントは、こういう見え方をします。

lab-mysql.xxxxxxxx.ap-northeast-1.rds.amazonaws.com  →  10.0.11.25   (TTL 5秒)

TTL(キャッシュしてよい秒数)は、RDS のエンドポイントでは非常に短く設定されています。 AWS 側は「すぐ引き直せるように」してくれています。

問題は、アプリ側がそれを無視する場合です。

状況何が起きるか
JVM の DNS キャッシュが無期限プロセスが生きている限り、古い IP に繋ぎ続ける
アプリが起動時に1回だけ名前解決して IP を保持同じ。切り替わっても気づかない
接続プールが壊れた接続を捨てないプールから取り出すたびに死ぬ

設定ファイルに IP を直接書いてはいけません。 エンドポイントの「名前」を書きます。 名前で繋ぐこと自体が、フェイルオーバーへの備えです。

接続プールを使う場合は、「壊れた接続を検知して捨てる」設定があるかを確認してください。 プールは接続を使い回すので、切れた接続を持ち続けると、フェイルオーバーの被害が長引きます。


⑥ バックアップとリストア — 「戻せるか」を確かめる

RDS には、2種類のバックアップがあります。 性質がまったく違います。

自動バックアップ手動スナップショット
誰が取るかRDS が毎日勝手に自分が明示的に
いつ消えるか保持期間を過ぎたら自動で消える自分で消すまで残る
DBインスタンスを消したら一緒に消える残る
できることポイントインタイムリカバリ(任意の時刻に戻す)取った瞬間の状態にだけ戻せる
保持期間の設定--backup-retention-period(0〜35日)無し
リージョンをまたげるか設定すれば別リージョンへ複製できる(自動バックアップのレプリケーション)コピーできる

この表の3行目と4行目が、一番痛い目を見るところです。


保持期間を 0 にすると、自動バックアップが無効になる

bash
$ awsl rds modify-db-instance --db-instance-identifier lab-mysql \
    --backup-retention-period 0 --apply-immediately \
    --query 'DBInstance.BackupRetentionPeriod' --output text
0

これで、毎日のバックアップが止まりました。

「バックアップの保管でお金がかかるから 0 にする」という判断は、成立しません。 なぜなら、ポイントインタイムリカバリができなくなるからです。

ポイントインタイムリカバリとは、「昨日の 14:32 の状態に戻す」ができる機能です。 これは、毎日のバックアップに加えて、その後の変更ログ(トランザクションログ)を保存し続けているから可能になります。 保持期間 0 は、そのログの保存も止めます。

WHERE を書き忘れた UPDATE を打ってしまったとき、助けてくれるのはこれです。 「打ってしまった SQL は取り消せない」ので、戻す手段を残しておくかどうかの話です。

戻します。

bash
$ awsl rds modify-db-instance --db-instance-identifier lab-mysql \
    --backup-retention-period 7 --apply-immediately \
    --query 'DBInstance.BackupRetentionPeriod' --output text
7

手動スナップショットを取る

bash
$ awsl rds create-db-snapshot \
    --db-instance-identifier lab-mysql \
    --db-snapshot-identifier lab-mysql-before-migration \
    --query 'DBSnapshot.[DBSnapshotIdentifier,Status]' --output text
lab-mysql-before-migration   creating
bash
$ awsl rds describe-db-snapshots \
    --query 'DBSnapshots[*].[DBSnapshotIdentifier,SnapshotType,Status]' --output table
--------------------------------------------------------------
|                     DescribeDBSnapshots                    |
+------------------------------+-----------+-----------------+
|  lab-mysql-before-migration  |  manual   |  available      |
+------------------------------+-----------+-----------------+

SnapshotType が manual です。 自動バックアップは automated と出ます。

スキーマ変更の前には、必ず手動スナップショットを取ります。 ALTER TABLE は取り消せません。 RDS でも、それは変わりません。


復元は「上書き」ではない

ここも間違えやすいところです。

bash
$ awsl rds restore-db-instance-from-db-snapshot \
    --db-instance-identifier lab-mysql-restored \
    --db-snapshot-identifier lab-mysql-before-migration \
    --db-subnet-group-name lab-db-subnets \
    --no-publicly-accessible \
    --query 'DBInstance.[DBInstanceIdentifier,DBInstanceStatus]' --output text
lab-mysql-restored   creating

--db-instance-identifier が違う名前になっていることに注目してください。

スナップショットから戻すと、「新しいDBインスタンス」が別に立ちます。 元のインスタンスは、そのまま残ります。上書きはされません。

ということは、復元後にやることが残っています。

1. 新しいインスタンスができる      ← ここまでが RDS の仕事
2. データが正しいか自分で確認する  ← ⚠️ 自分
3. アプリの接続先を切り替える      ← ⚠️ 自分
4. 古いインスタンスを消す          ← ⚠️ 自分

エンドポイントの名前は新しいものになります。 「フェイルオーバーなら名前は同じ」でしたが、復元は別物なので名前が変わります。

bash
$ awsl rds describe-db-instances \
    --query 'DBInstances[*].[DBInstanceIdentifier,DBInstanceStatus]' --output table
------------------------------------------
|         DescribeDBInstances            |
+----------------------+-----------------+
|  lab-mysql           |  available      |
|  lab-mysql-restored  |  available      |
+----------------------+-----------------+

2台になりました。ということは、2台ぶんのお金がかかります。 復元の練習をしたまま放置すると、それが翌月の請求になります。

スクリーンショットを撮ってください: 03_restore_two_instances.png lab-mysql と lab-mysql-restored が2台とも available になっている表を撮ってください。


削除するとき、自動バックアップは消える

bash
$ awsl rds delete-db-instance \
    --db-instance-identifier lab-mysql-restored \
    --final-db-snapshot-identifier lab-mysql-restored-final \
    --query 'DBInstance.DBInstanceStatus' --output text
deleting

--final-db-snapshot-identifier を付けると、消す直前の状態を1つ手動スナップショットとして残します。

付けたくない場合は、明示的にこう書きます。(書き方の例です。lab-mysql-restored は上で消したので、ここでは打ちません)

bash
$ awsl rds delete-db-instance \
    --db-instance-identifier lab-mysql-restored \
    --skip-final-snapshot \
    --query 'DBInstance.DBInstanceStatus' --output text

どちらかを必ず指定させられます。 黙って消させてくれません。 これは AWS の親切です。 「最後の状態を残すか」を、消す人に必ず考えさせています。

そして、ここが一番大事です。

DBインスタンスを削除すると、自動バックアップは一緒に消えます。 手動スナップショットは残ります。 「消したけど自動バックアップがあるから戻せる」は、成立しません。


バックアップは「取れているか」ではなく「戻せるか」

私はこれを、自分で MySQL を立てていたときに痛感しました。

mysqldump を cron で回して、ファイルが毎日できているのを見て安心していました。 実際に戻そうとしたとき、中身が 0 バイトでした。 パスワードを変えたのに cron の設定を直していなかった。

RDS だと、この事故は起きません。 AWS がバックアップを取るからです。 でも、「戻せるか」を確かめていないという点は、まったく同じです。

確かめるべきこと確かめ方
戻せるか実際に別インスタンスとして復元してみる(今やったこと)
どれくらい時間がかかるか復元にかかった時間を測る。数十分かかることがある
どこまで戻るかポイントインタイムリカバリで戻せる最古の時刻を確認する
アプリの切り替えができるか接続先を差し替える手順が書いてあるか

上の4つを1度もやったことがないなら、それはバックアップがあるとは言えません。

わざと壊して、直す。 本番で初めてやることを、練習用の環境で1度もやっていないのは危険です。


⑦ ElastiCache — Redis と Memcached

キャッシュも、同じように任せられます。 ElastiCache です。

bash
$ awsl elasticache create-cache-cluster \
    --cache-cluster-id lab-cache \
    --engine redis \
    --cache-node-type cache.t3.micro \
    --num-cache-nodes 1 \
    --query 'CacheCluster.[CacheClusterId,Engine,CacheClusterStatus]' --output text
lab-cache   redis   creating
bash
$ awsl elasticache describe-cache-clusters \
    --query 'CacheClusters[*].[CacheClusterId,Engine,EngineVersion,CacheClusterStatus]' --output table
--------------------------------------------------
|            DescribeCacheClusters               |
+-------------+---------+-----------+------------+
|  lab-cache  |  redis  |  7.1.0    |  available |
+-------------+---------+-----------+------------+

これも「作ったことになる」だけです。 LocalStack のコミュニティ版では、このエンドポイントに redis-cli で繋いでも応答しません。 確かめられるのは API の形までです。


Redis か Memcached か

RedisMemcached
持てるデータ型文字列・リスト・集合・ハッシュ・順序付き集合文字列だけ
永続化できる(ディスクに書ける)できない(消えたら終わり)
レプリケーションできる(複製を持てる)できない
フェイルオーバー自動でできる無い
スレッド主に1スレッド(一部は並列化)複数スレッド(大きいノードを使い切れる)
スナップショット取れる取れない
向いている用途セッション・ランキング・キュー・キャッシュ純粋なキャッシュだけ

迷ったら Redis です。 Memcached が有利なのは「巨大なノードを複数スレッドで使い切りたい、純粋なキャッシュだけ」という限られた場合です。 できることが多いほうを選んで困ることは、あまりありません。

この違いは、キャッシュは消すのが一番難しい — Redisの導入 でやった Redis の性質そのままです。 ElastiCache は、その Redis を AWS が動かしているだけです。


クラスターモードの有無

Redis を選ぶと、さらに2択があります。

クラスターモード無効クラスターモード有効
データの持ち方1つのノードに全部複数に分割(シャーディング)
書き込みの受け口1つ分割の数だけ
クライアント側普通の Redis クライアントでよいクラスター対応のクライアントが要る
できないコマンド無し複数キーをまたぐ操作に制限(別のノードにあるため)
向いている規模メモリが1台に収まるうち1台に収まらなくなってから

最初はクラスターモード無効で十分です。 有効にすると、アプリのコードにも制約が出ます(複数キーをまたぐ操作が使えなくなる)。 「大きくできるから」という理由で最初から有効にすると、使えないコマンドに後から気づきます。


キャッシュを入れる前に、索引とクエリを見る

これは、この節で一番言いたいことです。

「DBが遅い」→「じゃあキャッシュを入れよう」は、順番が間違っています。

【正しい順番】
  1. どのクエリが遅いのかを測る       ← ⚠️ 推測しない
  2. EXPLAIN でなぜ遅いのかを見る
  3. 索引を張る / クエリを直す        ← ⚠️ ここで大半は解決する
  4. それでも足りなければ、キャッシュ

手元の MySQL で、1と2はできます。

bash
$ docker compose exec db mysql -uroot -ppractice-only-pass labdb
CREATE TABLE orders (
  id      INT PRIMARY KEY AUTO_INCREMENT,
  user_id INT NOT NULL,
  amount  INT NOT NULL
);

INSERT INTO orders (user_id, amount)
SELECT FLOOR(RAND()*10000), FLOOR(RAND()*5000)
FROM information_schema.columns a, information_schema.columns b
LIMIT 200000;

EXPLAIN SELECT * FROM orders WHERE user_id = 42;
+----+-------------+--------+------+---------------+------+---------+------+--------+-------------+
| id | select_type | table  | type | possible_keys | key  | key_len | ref  | rows   | Extra       |
+----+-------------+--------+------+---------------+------+---------+------+--------+-------------+
|  1 | SIMPLE      | orders | ALL  | NULL          | NULL | NULL    | NULL | 199324 | Using where |
+----+-------------+--------+------+---------------+------+---------+------+--------+-------------+

type が ALL、rows が約20万。 20行を返すために、20万行を読んでいます。

CREATE INDEX idx_orders_user ON orders (user_id);
EXPLAIN SELECT * FROM orders WHERE user_id = 42;
+----+-------------+--------+------+-----------------+-----------------+---------+-------+------+-------+
| id | select_type | table  | type | possible_keys   | key             | key_len | ref   | rows | Extra |
+----+-------------+--------+------+-----------------+-----------------+---------+-------+------+-------+
|  1 | SIMPLE      | orders | ref  | idx_orders_user | idx_orders_user | 4       | const |   19 | NULL  |
+----+-------------+--------+------+-----------------+-----------------+---------+-------+------+-------+

20万行が19行になりました。

キャッシュを入れる前に、これをやってください。 索引1本で1万倍速くなるものに、キャッシュ層を足すのは、遅い原因を隠しているだけです。 やり方は 索引を張ったのに使われない — SQL深掘り にまとめてあります。

キャッシュを足すと、新しい問題が増えます。

キャッシュを入れると増える問題中身
古い値が返る更新したのに、キャッシュが古いまま
消し方いつ、どのキーを消すのかを決めなければならない
キャッシュが落ちたときDBに全部の負荷が一気に来る(雪崩)
メモリが溢れたとき何を捨てるか(maxmemory-policy)を決めていないと、勝手に消える

これは全部「自分に残る仕事」です。 ElastiCache にしても、1つも減りません。


ElastiCache は VPC の中にしか置けない

RDS には --publicly-accessible という選択肢がありました(使ってはいけませんが)。

ElastiCache には、それすらありません。

ElastiCache のノードは、VPC の中からしか繋げません。 自宅のPCから直接 redis-cli -h <エンドポイント> を打つことは、できません。

これは制限ではなく、設計です。

Redis は、既定では認証がありません。 繋げた人が全部読めて、全部消せます。 だから AWS は、「インターネットに出す」という選択肢そのものを用意していません。

手元で試すときも、同じ考え方をしてください。

services:
  cache:
    image: redis:7
    ports:
      - "127.0.0.1:6379:6379"

127.0.0.1: を頭に付けると、そのマシンの中からしか繋げなくなります。 - "6379:6379" と書くと、VM の外からも繋がります。

「どこまで開いているのか」を、書いた本人が言えることが大事です。


⑧ 判断表 — 自分で立てるか、RDS にするか

ここまでやってきて、正直に書きます。

自分で立てる(1台のVMに同居)RDS / ElastiCache
立ち上げるまでの手間数分(compose 1ファイル)数十分(VPC・サブネットグループ・パラメータグループ)
費用の構造VM 1台ぶんに含まれるDB専用にもう1台ぶん。マルチAZ なら2台ぶん
パッチ当て自分(apt upgrade して再起動)AWS
バックアップの取得自分(cron と mysqldump)AWS
深夜に落ちたら自分が起きて直すAWS が自動で入れ替える
アップグレードの責任自分(やらなければ、いつまでも古いまま)自分(AWS は期限を切ってくるが、テストは自分)
スキーマ・索引・クエリ自分自分(変わらない)
アプリの再接続処理自分自分(むしろ必須になる)
設定の変え方設定ファイルを書いて再起動パラメータグループ経由(静的なら再起動)
中に入れるか入れる(SSH でログ・プロセスを見られる)入れない(メトリクスとログ出力だけ)

表の一番下が、初学者にとっては意外に大きい違いです。

RDS では、DBのサーバーの中に入れません。 「ディスクが埋まっているのでは」と思っても、df -h は打てません。 AWS が出してくれるメトリクスからしか、状況を知る方法がありません。

これは、学ぶ段階では明確な不利です。


正直な結論

個人開発の初期は、1台のVMに DB を同居させるほうが、安くて速いです。

理由は3つです。

  1. 費用がVM1台に収まる。 RDS は DB のためにもう1台借りるのと同じ
  2. 中に入れる。 遅い原因も、埋まったディスクも、自分の目で見られる
  3. DBの仕組みが分かる。 立てて、壊して、直す。この記事の①の右列は、これでしか身につかない

では RDS はいつ要るのか。

「自分が寝ている間に壊れても、復旧してほしい」と思ったときです。

その1行に尽きます。

  • 止まっても、朝起きてから直せばいい → 自分で立てる
  • 止まったら、勝手に直っていてほしい → RDS のマルチAZ

その判断ができるようになるために、①の表があります。 「マネージドだから安心」で選ぶと、任せられていない仕事に気づかないまま本番を迎えます。


「自分で立てる」側を選ぶなら、メモリに余裕のあるVPSにMySQLとRedisを同居させる形が現実的です。シンVPSはメモリあたりの月額を抑えた大容量メモリプランがあり、2GB(2コア・50GB)が1ヶ月契約1,040円〜36ヶ月契約で月950円、4GBは1ヶ月契約で1,800円(2026-11時点、税込)です。無料のお試し期間は無く最低利用期間は3ヶ月なので、RDSとの比較は「運用の判断が自分に残る」点も含めて決めてください。

つまずいたところ

1. サブネットを1つしか作らず、サブネットグループが作れなかった

An error occurred (DBSubnetGroupDoesNotCoverEnoughAZs)

最低2つの AZ が要ります。 「1台で始めるのに、なぜ2つ要るのか」と思いましたが、 マルチAZ にしたくなったときに待機系を置く場所を、最初から確保させる設計でした。


2. --backup-retention-period 0 にして、戻せなくなった

練習用だから要らないと思って 0 にしました。 そのあと UPDATE を WHERE 無しで打ってしまい、ポイントインタイムリカバリを試そうとして、できないことに気づきました。 手動スナップショットも取っていませんでした。 練習用のデータだったので助かりました。


3. max_connections を変えたのに反映されなかった

ApplyMethod=immediate を指定して、in-sync になるのを待っていました。 max_connections は静的パラメータで、再起動しないと反映されません。 describe-engine-default-parameters で ApplyType を見る癖を付けてから、間違えなくなりました。


4. マルチAZ にしたのに、読み取りが速くならなかった

待機系は読み取りにも使えません。 速くしたいならリードレプリカで、それは別の機能です。 さらに、リードレプリカは「アプリが自分で振り分ける」必要があります。 有効にしただけでは、誰も使いません。


5. フェイルオーバーでアプリが落ちた

「自動フェイルオーバー」という言葉を、「アプリも自動で繋ぎ直してくれる」と読んでいました。 自動なのは DB の昇格だけです。 既存の接続は全部切れます。 ⑤で書いた再試行を入れるまで、フェイルオーバーのたびにサービスが止まりました。


6. 復元したら、DBが2台になっていた

スナップショットからの復元は、上書きではありません。 別の名前で新しいインスタンスが立ちます。 元のインスタンスを消し忘れると、2台ぶん課金され続けます。


7. LocalStack で作った RDS に、mysql コマンドで繋げなかった

ERROR 2003 (HY000): Can't connect to MySQL server

コミュニティ版では、RDS も ElastiCache も「API の応答を返すだけ」です。 中で MySQL や Redis が動いているわけではありません。 しばらく設定を疑っていましたが、最初からそういう仕様でした。 接続の実験は、Docker の MySQL / Redis でやるのが正しいやり方です。


8. 遅い原因がキャッシュ不足だと思い込んでいた

ElastiCache を入れる設計を先に考えていました。 先に EXPLAIN を打ったら、20万行を全部読んでいるクエリが1本ありました。 索引を1本張ったら、キャッシュは要らなくなりました。 キャッシュは、遅い原因を隠すのが上手いだけです。


後片づけ

練習で作ったものを、全部消します。

まず、手元の Docker から。

bash
$ cd ~/awslab/rds/failover
$ docker compose down -v
$ docker compose ps
NAME   IMAGE   STATUS   PORTS

-v を付けないと、MySQL のデータボリュームが残ります。 これは コンテナを消すとデータも消える — Docker深掘り でやった通りです。

次に、LocalStack 側のリソースを消します。 1本目の lab-mysql-restored は、⑥で消してあれば不要です(打つと DBInstanceNotFound になります)。

bash
$ awsl rds delete-db-instance --db-instance-identifier lab-mysql-restored \
    --skip-final-snapshot --query 'DBInstance.DBInstanceStatus' --output text
bash
$ awsl rds delete-db-instance --db-instance-identifier lab-mysql \
    --skip-final-snapshot --query 'DBInstance.DBInstanceStatus' --output text

練習なので --skip-final-snapshot で構いません。 本番では、--final-db-snapshot-identifier を付けます。

手動スナップショットは、インスタンスを消しても残るので、明示的に消します。

bash
$ awsl rds describe-db-snapshots \
    --query 'DBSnapshots[*].DBSnapshotIdentifier' --output text
lab-mysql-before-migration   lab-mysql-restored-final
bash
$ awsl rds delete-db-snapshot --db-snapshot-identifier lab-mysql-before-migration
$ awsl rds delete-db-snapshot --db-snapshot-identifier lab-mysql-restored-final

ElastiCache も消します。

bash
$ awsl elasticache delete-cache-cluster --cache-cluster-id lab-cache \
    --query 'CacheCluster.CacheClusterStatus' --output text

パラメータグループとサブネットグループも消します。

bash
$ awsl rds delete-db-parameter-group --db-parameter-group-name lab-mysql80
$ awsl rds delete-db-subnet-group --db-subnet-group-name lab-db-subnets

空になったことを確認します。

bash
$ awsl rds describe-db-instances --query 'DBInstances[*].DBInstanceIdentifier' --output text
$ awsl rds describe-db-snapshots --query 'DBSnapshots[*].DBSnapshotIdentifier' --output text
$ awsl elasticache describe-cache-clusters --query 'CacheClusters[*].CacheClusterId' --output text

3つとも何も出なければ完了です。

LocalStack を止めます。

bash
$ cd ~/awslab/rds
$ docker compose down -v
$ docker compose ps

練習用フォルダを消します。

bash
$ cd ~
$ rm -rf ~/awslab/rds

node_modules もここに入っているので、一緒に消えます。

bash
$ df -h ~ | tail -1
$ docker system df

mysql:8 と redis:7 のイメージは残ります。 もう使わないなら消してください。

bash
$ docker image rm mysql:8

まとめ — 理解できたこと

  • マネージドは「運用が要らなくなる」ではなく「運用の種類が変わる」。 作業は肩代わりされるが、判断は残る
  • AWS がやるのは、パッチ当て・バックアップ取得・故障時の入れ替え・レプリカ構築。自分に残るのは、スキーマ・索引・遅いクエリ・接続数・再接続・パラメータの選択・アップグレードの判断
  • RDS では設定ファイルを直接編集できない。 SSH で入れないから。パラメータグループで変える
  • 静的パラメータは再起動しないと反映されない。 max_connections はその代表
  • パラメータの既定値は数字ではなく式で、インスタンスクラスのメモリから計算される。 大きさを変えると既定値も変わる
  • マルチAZ は速くする機能ではない。 待機系は読み取りにも使えない(Aurora とマルチAZ DBクラスターは別)
  • 速くしたいならリードレプリカ。 ただし非同期で、アプリが自分で振り分ける必要がある。有効にしただけでは誰も使わない
  • フェイルオーバーで既存の接続は全部切れる。 自動なのは DB の昇格だけ
  • エンドポイントの名前は変わらない。 DNS が向き先を変えるので、アプリは繋ぎ直せばいい。IP を設定に直書きしない
  • 再試行には3つの工夫が要る: 待ち時間を倍にする・ゆらぎを足す・再試行するエラーを絞る
  • 保持期間を 0 にすると、ポイントインタイムリカバリができなくなる
  • DBインスタンスを消すと自動バックアップも消える。 手動スナップショットだけが残る
  • 復元は上書きではない。 別インスタンスが立つので、接続先の切り替えと古い方の削除は自分の仕事
  • バックアップは「取れているか」ではなく「戻せるか」。 復元にかかる時間まで測って初めて、バックアップがあると言える
  • ElastiCache は迷ったら Redis。 Memcached は文字列だけ・永続化なし・レプリケーションなし
  • ElastiCache は VPC の中にしか置けない。 Redis に既定の認証が無いことを考えれば、これは正しい設計
  • キャッシュを入れる前に、索引とクエリを見る。 索引1本で解決するものに層を足すのは、原因を隠しているだけ
  • 個人開発の初期は、1台のVMに同居させるほうが安くて速い。 RDS が要るのは「自分が寝ている間に壊れても復旧してほしい」と思ったとき

参考リンク


次に読む

この記事は 【深掘り】AWS の 10 / 16 本目です。

記事
← 前の記事Route 53とDNSのTTL — 切り替えたのに古いサーバーへ行く
→ 次の記事DynamoDBの設計とキー — あとから条件を足せない

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

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

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

AWS›AWS — RDS & ElastiCache
  • 任せても消えない仕事がある
  • マルチAZ は読み取りを速くしない

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

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

コメント

コメントする

目次