メインコンテンツへスキップ
見出し画像

ソシャゲのサーバーを作る。セッションをRedisに移す(5)

    前回、認証を実装しました。

    そのとき作ったテーブルのうち2つは「あとで削除します」と書いていました。
    今回はそこを片付けます。

    なぜ移すのか

    前回の最後に、こういう状態になっていました。

    mysql> select * from user_session;
    (6行。ユーザーは3人しかいないのに)

    signupを叩くたびに1行増えて、古いトークンも期限が切れるまで残ったままです。
    ワンタイムキーのほうも、発行されたまま使われなかったキーが残り続けます。

    このまま運用すると、テーブルが際限なく膨らみます。
    定期的に期限切れを消す仕組みを作らないといけません。

    ただ、この2つのデータには共通点があります。

    期限が来たら要らなくなる。履歴としても不要。

    こういうものはRedisに置くほうが向いています。
    書き込むときに有効期限を指定できて、切れたら勝手に消えるので。
    掃除の仕組みを自分で作らなくて済みます。
    これホントに楽です(笑)

    Redisを足す

    docker-compose.ymlにサービスを1つ追加します。

      redis:
        image: redis:7-alpine
        environment:
          TZ: Asia/Tokyo
        # ホストへのポート公開はしない。触るのは app コンテナだけ。
        # ボリュームは用意しない。セッションは消えても作り直せるデータなので、残す理由がない

    ポートを公開していません。外から触る必要がないので。
    触るのはappコンテナだけですね。

    ボリュームも用意していません。
    MySQLのほうはデータをボリュームに残していますが、Redisは消えてもいいのでやりません。

    「消えたら困るデータ」と「消えても作り直せるデータ」を分けておく。
    DBを3つに分けたときと同じ発想です。

    appからの接続先も足します。

          REDIS_HOST: redis
          REDIS_PORT: 6379

    `.env`には書きません。
    コンテナ名なので環境によって変わらない値ですね。
    `DB_HOST: db`と同じ扱いです。

    依存も1つ入れます。

    docker compose exec app npm install redis

    接続はひとつだけ作る

    // src/redis.ts
    import { createClient } from "redis";
    
    // ワンタイムキーとセッションの置き場。
    // クライアントは起動時に1つだけ作って使い回す。リクエストごとに接続しない。
    
    const client = createClient({
      socket: {
        host: requireEnv("REDIS_HOST"),
        port: Number(requireEnv("REDIS_PORT")),
      },
    });
    
    // 接続まわりのエラーは握りつぶさない。ログに出さないと原因が追えなくなる
    client.on("error", (error: unknown) => {
      console.error("redis:", error);
    });
    
    await client.connect();
    
    export const redis = client;

    リクエストのたびに接続してはいけません。
    起動時に1本作って使い回します。
    MySQLでコネクションプールを作ったのと同じです。

    キーの設計

    Redisはキーと値だけの世界です。
    要はディクショナリですね。
    C++で言うところの`std::unordered_map`でしょうか。

    ただし普通のディクショナリと違うのは、プロセスの外にあることです。
    サーバーが複数台になっても全員が同じものを見られる。そして値に期限を付けられます。

    「この値は5分で捨てて」と言えるわけですね。
    自分でやろうとすると、値にタイムスタンプを持たせて、定期的に全部を走査して、期限が過ぎたものを消して、という話になります。
    あの手間が要らないのは楽です。

    onetime:<キーのハッシュ>   値は発行時刻      期限 300秒
    session:<トークンのハッシュ> 値は user_id     期限 86400秒

    キーの頭に用途を書いておくのが定番ですね。
    全部が同じ空間に入るので、`onetime:`と`session:`で分けておかないと混ざります。

    保存するのは今までどおりハッシュです。
    生のトークンや端末キーはRedisにも入れません。

    /**
     * Redisのキーのプレフィックス。用途ごとに分けて、他のキーと混ざらないようにする。
     * 後ろに付けるのは生の値ではなくハッシュ。
     */
    export const ONETIME_KEY_PREFIX = "onetime:";
    export const SESSION_KEY_PREFIX = "session:";

    ワンタイムキー

    ここが今回いちばん変わったところです。

    前回はこうでした。

    export async function consumeOnetimeKey(key: string): Promise<ConsumeResult> {
      const keyHash = hashKey(key);
      const conn = await userPool.getConnection();
      try {
        await conn.beginTransaction();
    
        const [rows] = await conn.execute<RowDataPacket[]>(
          "SELECT `expires_at` < NOW() AS `expired`," +
            " TIMESTAMPDIFF(SECOND, `created_at`, NOW()) < ? AS `too_fast`" +
            " FROM `auth_onetime` WHERE `key_hash` = ? FOR UPDATE",
          [ONETIME_KEY_MIN_ELAPSED_SECONDS, keyHash],
        );
    
        const row = rows[0];
        if (row === undefined) {
          await conn.rollback();
          return { ok: false, reason: "not_found" };
        }
    
        await conn.execute("DELETE FROM `auth_onetime` WHERE `key_hash` = ?", [keyHash]);
        await conn.commit();
    
        if (Number(row.expired) === 1) return { ok: false, reason: "expired" };
        if (Number(row.too_fast) === 1) return { ok: false, reason: "too_fast" };
        return { ok: true };
      } catch (error) {
        await conn.rollback();
        throw error;
      } finally {
        conn.release();
      }
    }

    Redisにするとこうなります。

    /**
     * ワンタイムキーを取得すると同時に削除する。
     *
     * GETDEL は単一のコマンドなので、同じキーで並行して叩かれても
     * 値を受け取れるのは片方だけ。ロックもトランザクションも要らない。
     *
     * 時刻の比較は Date.now() で行う。発行と検証を同じプロセスでやるので、時計はずれない。
     */
    export async function consumeOnetimeKey(key: string): Promise<ConsumeResult> {
      const issuedAt = await redis.getDel(onetimeRedisKey(key));
      if (issuedAt === null) return { ok: false, reason: "not_found" };
    
      if (Date.now() - Number(issuedAt) < ONETIME_KEY_MIN_ELAPSED_MS) {
        return { ok: false, reason: "too_fast" };
      }
      return { ok: true };
    }

    32行が9行になりました。

    消えたのは、トランザクションの開始、`FOR UPDATE`でのロック、`DELETE`、コミット、ロールバック、コネクションの解放。
    前回あれだけ説明した仕組みが、まるごと不要になっています。

    `GETDEL`が1つのコマンドだからです。

    取得と削除が分かれていないので、その間に割り込まれる余地がありません。
    同じキーで同時に叩かれても、値を受け取れるのは片方だけ。
    しかも、ロック不要。

    前回は「取得と削除を割り込まれないようにやる」ために、あれだけの手続きを踏んでいました。
    やりたかったことは最初から1コマンドで表現できる操作だったわけですね。

    期限切れの判定が消えた

    前回は`expires_at < NOW()`で期限を見ていましたが、それも不要になりました。

    Redisが期限切れを勝手に消すので、`GETDEL`が値を返した時点で有効です。
    逆に言うと、期限切れと「そもそも無い」が区別できなくなります。
    どちらも「キーが無い」としか分かりません。

    なので戻り値の型はそのままにして、`expired`は返さないようにしました。

    // expired は残してあるが、もう返らない。
    // 期限切れは Redis が TTL で勝手に消すので、未発行・使用済みと区別できず not_found になる。
    export type ConsumeResult =
      | { ok: true }
      | { ok: false; reason: "not_found" | "expired" | "too_fast" };

    発行が早すぎるものを弾く判定

    こちらは残したいので、少し工夫が要ります。

    前回はDBの`created_at`と`NOW()`を比べていました。
    Redisにはそういう列がないので、値のほうに発行時刻を入れます。

    export async function issueOnetimeKey(): Promise<OnetimeKey> {
      const key = generateKey();
      await redis.set(onetimeRedisKey(key), String(Date.now()), {
        expiration: { type: "EX", value: ONETIME_KEY_TTL_SECONDS },
      });
      return { key, expiresIn: ONETIME_KEY_TTL_SECONDS };
    }

    `EX`が有効期限の指定ですね。
    ここで300秒と書いておけば、5分後に勝手に消えます。

    前回は時刻の比較をすべてDB側でやっていました。
    アプリとDBで時計がずれる可能性があったからです。
    今回は発行も検証も同じプロセスの中でやるので、`Date.now()`同士の比較で問題ありません。

    おまけに分解能が上がりました。
    MySQLの`DATETIME`は秒単位でしたが、`Date.now()`はミリ秒なので。

    セッション

    こちらはもっと単純です。

    /** セッショントークンを発行する。Redisに入るのはハッシュ、返すのは生のトークン */
    export async function issueToken(userId: number): Promise<Session> {
      const token = generateKey();
      await redis.set(sessionRedisKey(token), String(userId), {
        expiration: { type: "EX", value: SESSION_TTL_SECONDS },
      });
      return { token, expiresIn: SESSION_TTL_SECONDS };
    }
    
    /**
     * トークンから user_id を引く。存在しなければ null。
     * 期限切れは Redis が消しているので、返ってきた時点で有効。自分で期限を見る必要はない。
     */
    export async function resolveUserId(token: string): Promise<number | null> {
      const userId = await redis.get(sessionRedisKey(token));
      return userId === null ? null : Number(userId);
    }

    `WHERE expires_at > NOW()`が消えました。
    Redisが消してくれるので、返ってきた時点で有効です。

    変えなかったところ

    `routes/`と`index.ts`は1文字も触っていません。

    前回、`onetime.ts`と`session.ts`を独立したファイルにしていました。
    理由として「あとでRedisに差し替えるから」と書いたんですが、それが効いた形ですね。

    保存先がMySQLからRedisに変わっても、外から見た関数の名前も引数も戻り値も同じです。
    呼んでいる側は何も知らなくていい。

    こういう「中身を差し替えても外に影響しない」形にしておくのは、後から効いてきます。
    今回みたいに構成を変えるときはもちろん、テストを書くときにも楽になりますね。

    `authenticate`も無変更です。中で`resolveUserId`を呼んでいるだけなので。

    動かす

    $ curl -s -X POST http://localhost:3000/auth/prepare
    {"onetime_key":"...","expires_in":300}

    Redisを覗いてみます。

    $ docker compose exec redis redis-cli KEYS '*'
    1) "session:f10b5e43b54dec71b7e115084be54a9dc7016caa434e50dd00bfc11c92772390"
    2) "onetime:044f59036099b449f9731f4d07c661dd041853a47b95d0d4d7b283c2a9d215bc"
    3) "session:851a0bb401fcb8de61832b1c76ea87dfb6a3f439b2b9d3084e2ac946d706e315"

    プレフィックスで用途が分かれているのが見えますね。
    テーブルという区切りがない代わりに、キーの名前で分けています。

    なお、ここに出ている`onetime:`は前に叩いたときのものです。
    使われないまま残っているキーですね。
    放っておけば5分後に勝手に消えます。

    TTLと値も見てみます。

    127.0.0.1:6379> TTL onetime:...
    (integer) 299
    
    127.0.0.1:6379> GET onetime:...
    "1787238812350"

    TTLが残り秒数を返します。
    299と出ているので、あと5分弱ですね。
    値は発行時刻のミリ秒です。

    signupを通します。

    $ curl -s -X POST http://localhost:3000/auth/signup \
      -H "Content-Type: application/json" \
      -d '{"onetime_key":"...","device_key":"test-device-001"}'
    {"user_id":4,"token":"...","is_new":true}

    もう一度Redisを見ると、`onetime:`は消えて`session:`だけになっています。
    `GETDEL`が持っていった形ですね。

    127.0.0.1:6379> TTL session:...
    (integer) 86387
    
    (3秒後)
    
    127.0.0.1:6379> TTL session:...
    (integer) 86384

    カウントダウンしています。0になったら消えます。

    MySQLの`expires_at`は「切れた印」でしかなくて、行そのものは残り続けました。
    こちらは期限が来た時点で本当に消えます。

    APIの振る舞いは前回と同じです。

    $ curl -s http://localhost:3000/user/profile -H "Authorization: Bearer ..."
    {"user_id":4,"name":"プレイヤー4","created_at":"..."}
    
    $ curl -s http://localhost:3000/user/profile -H "Authorization: Bearer dummy"
    {"error":{"code":"UNAUTHORIZED","message":"トークンが無効か、期限切れ"}}

    同じワンタイムキーを二度使うと弾かれるのも、同じ端末キーなら同じユーザーに戻るのも、前回と変わりません。
    中身を入れ替えただけなので。

    生の値が入っていないことも確認

    127.0.0.1:6379> KEYS *test-device*
    (empty array)

    `test-device-001`という文字列は、キーにも値にも入っていません。
    MySQLのときと同じですね。

    テーブルを消す

    Redis経由で動くことが確認できたので、使わなくなったテーブルを消します。

    $ docker compose exec db mysql -ugameuser -p**** api_game_user -e "show tables;"
    +-------------------------+
    | Tables_in_api_game_user |
    +-------------------------+
    | auth_onetime            |
    | user                    |
    | user_auth               |
    | user_session            |
    +-------------------------+

    4つありますが、このうち2つはもう誰も読み書きしていません。

    USE `api_game_user`;
    
    DROP TABLE IF EXISTS `auth_onetime`;
    DROP TABLE IF EXISTS `user_session`;

    流します。

    $ docker compose exec -T db mysql -uroot -p**** api_game_user < db/api_game_user/drop_session_tables.sql
    mysql: [Warning] Using a password on the command line interface can be insecure.
    $ docker compose exec db mysql -ugameuser -p**** api_game_user -e "show tables;"
    +-------------------------+
    | Tables_in_api_game_user |
    +-------------------------+
    | user                    |
    | user_auth               |
    +-------------------------+

    2つになりました。

    `api_game_user`に残っているのは、消してはいけないデータだけです。
    プレイヤー本体と、その認証手段。
    それ以外は全部Redisに移りました。

    DBの性格がはっきりしましたね。
    ここにあるのは全部「消してはいけない」データです。

    今回はここまで

    • Redisのコンテナを足した

    • ワンタイムキーとセッションを移した

    • `consumeOnetimeKey`が32行から9行になった

    • 掃除の仕組みを作らずに済んだ

    • テーブルが4つから2つになった

    保存先を変えただけで、APIの挙動は何も変わっていません。

    次回はマスターデータのほうに戻ろうと思います。
    キャラのデータは入っていますが、まだレアリティも属性も数字のままなので。

    【最後まで読んでいただきありがとうございます!】
    面白かったと感じた方は、ぜひ「スキ」と「フォロー」をお願いします!

    コード

    今回の記事で変更したファイルです、興味のある方はどうぞ。

    src/redis.ts

    import { createClient } from "redis";
    
    // ワンタイムキーとセッションの置き場。
    // クライアントは起動時に1つだけ作って使い回す。リクエストごとに接続しない。
    
    function requireEnv(name: string): string {
      const value = process.env[name];
      if (value === undefined || value === "") {
        throw new Error(`環境変数 ${name} が設定されていない`);
      }
      return value;
    }
    
    const client = createClient({
      socket: {
        host: requireEnv("REDIS_HOST"),
        port: Number(requireEnv("REDIS_PORT")),
      },
    });
    
    // 接続まわりのエラーは握りつぶさない。ログに出さないと原因が追えなくなる
    client.on("error", (error: unknown) => {
      console.error("redis:", error);
    });
    
    await client.connect();
    
    export const redis = client;

    src/auth/onetime.ts

    import { redis } from "../redis.ts";
    import { generateKey, hashKey } from "./hash.ts";
    import {
      ONETIME_KEY_MIN_ELAPSED_MS,
      ONETIME_KEY_PREFIX,
      ONETIME_KEY_TTL_SECONDS,
    } from "../constants.ts";
    
    // ワンタイムキーの読み書きはこのモジュールに閉じる。
    // 保存先が Redis であることを、ここから外に漏らさない。
    
    export type OnetimeKey = {
      key: string;
      expiresIn: number;
    };
    
    // expired は残してあるが、もう返らない。
    // 期限切れは Redis が TTL で勝手に消すので、未発行・使用済みと区別できず not_found になる。
    export type ConsumeResult =
      | { ok: true }
      | { ok: false; reason: "not_found" | "expired" | "too_fast" };
    
    function onetimeRedisKey(key: string): string {
      return `${ONETIME_KEY_PREFIX}${hashKey(key)}`;
    }
    
    /**
     * ワンタイムキーを発行する。Redisに入るのはハッシュ、返すのは生のキー。
     * 値には発行時刻を入れる。発行からの経過時間を、使うときに見るため。
     */
    export async function issueOnetimeKey(): Promise<OnetimeKey> {
      const key = generateKey();
      await redis.set(onetimeRedisKey(key), String(Date.now()), {
        expiration: { type: "EX", value: ONETIME_KEY_TTL_SECONDS },
      });
      return { key, expiresIn: ONETIME_KEY_TTL_SECONDS };
    }
    
    /**
     * ワンタイムキーを取得すると同時に削除する。
     *
     * GETDEL は単一のコマンドなので、同じキーで並行して叩かれても
     * 値を受け取れるのは片方だけ。ロックもトランザクションも要らない。
     *
     * 時刻の比較は Date.now() で行う。発行と検証を同じプロセスでやるので、時計はずれない。
     */
    export async function consumeOnetimeKey(key: string): Promise<ConsumeResult> {
      const issuedAt = await redis.getDel(onetimeRedisKey(key));
      if (issuedAt === null) return { ok: false, reason: "not_found" };
    
      if (Date.now() - Number(issuedAt) < ONETIME_KEY_MIN_ELAPSED_MS) {
        return { ok: false, reason: "too_fast" };
      }
      return { ok: true };
    }

    src/auth/session.ts

    import type { IncomingMessage } from "node:http";
    import { redis } from "../redis.ts";
    import { generateKey, hashKey } from "./hash.ts";
    import { SESSION_KEY_PREFIX, SESSION_TTL_SECONDS } from "../constants.ts";
    
    // セッションの読み書きはこのモジュールに閉じる。
    // 保存先が Redis であることを、ここから外に漏らさない。
    
    export type Session = {
      token: string;
      expiresIn: number;
    };
    
    function sessionRedisKey(token: string): string {
      return `${SESSION_KEY_PREFIX}${hashKey(token)}`;
    }
    
    /** セッショントークンを発行する。Redisに入るのはハッシュ、返すのは生のトークン */
    export async function issueToken(userId: number): Promise<Session> {
      const token = generateKey();
      await redis.set(sessionRedisKey(token), String(userId), {
        expiration: { type: "EX", value: SESSION_TTL_SECONDS },
      });
      return { token, expiresIn: SESSION_TTL_SECONDS };
    }
    
    /**
     * トークンから user_id を引く。存在しなければ null。
     * 期限切れは Redis が消しているので、返ってきた時点で有効。自分で期限を見る必要はない。
     */
    export async function resolveUserId(token: string): Promise<number | null> {
      const userId = await redis.get(sessionRedisKey(token));
      return userId === null ? null : Number(userId);
    }
    
    /**
     * 全APIが通る認証。Authorization ヘッダから user_id を解決する。
     * 認証が要るハンドラはこの1関数だけを呼ぶ。
     */
    export async function authenticate(req: IncomingMessage): Promise<number | null> {
      const header = req.headers.authorization;
      if (header === undefined) return null;
    
      const matched = /^Bearer\s+(\S+)$/.exec(header);
      if (matched === null) return null;
    
      return resolveUserId(matched[1]);
    }

    src/constants.ts(変更した部分)

    /**
     * Redisのキーのプレフィックス。用途ごとに分けて、他のキーと混ざらないようにする。
     * 後ろに付けるのは生の値ではなくハッシュ。
     */
    export const ONETIME_KEY_PREFIX = "onetime:";
    export const SESSION_KEY_PREFIX = "session:";
    
    /** ワンタイムキーの有効期限(秒)。Redisの TTL に渡す */
    export const ONETIME_KEY_TTL_SECONDS = 300;
    
    /**
     * ワンタイムキーの発行からこのミリ秒が経つ前に使われたら、機械的なアクセスとみなして弾く。
     * 発行時刻を Date.now() で持つので、判定の分解能はミリ秒。
     */
    export const ONETIME_KEY_MIN_ELAPSED_MS = 1000;
    
    /** セッショントークンの有効期限(秒)。Redisの TTL に渡す */
    export const SESSION_TTL_SECONDS = 60 * 60 * 24;

    docker-compose.yml(追加した部分)

    services:
      app:
        ...
        environment:
          ...
          # ワンタイムキーとセッションの置き場。ここも compose のサービス名
          REDIS_HOST: redis
          REDIS_PORT: 6379
        depends_on:
          db:
            condition: service_healthy
          redis:
            condition: service_started
    
      redis:
        image: redis:7-alpine
        environment:
          TZ: Asia/Tokyo
        # ホストへのポート公開はしない。触るのは app コンテナだけ。
        # ボリュームは用意しない。セッションは消えても作り直せるデータなので、残す理由がない

    db/api_game_user/drop_session_tables.sql

    -- api_game_user : セッションを Redis に移したことで不要になったテーブルを消す
    --
    -- 流し方(手で実行する。スクリプトから自動で流さない):
    --   docker compose exec -T db mysql -uroot -p"$MYSQL_ROOT_PASSWORD" < db/api_game_user/drop_session_tables.sql
    --
    -- 実行後、api_game_user に残るのは `user` と `user_auth` の2つだけ。
    
    USE `api_game_user`;
    
    DROP TABLE IF EXISTS `auth_onetime`;
    DROP TABLE IF EXISTS `user_session`;
     
     
    泥臭い現場のリアルを語る現役エンジニア ゲーム開発歴30年。会社員・フリーランスの両方で修羅場をくぐり抜けてきた50代現役サーバプログラマです

    あなたへのおすすめ