Mirrativ tech blog

株式会社ミラティブの開発者(サーバサイドエンジニア,iOSエンジニア,Androidエンジニア,機械学習エンジニア,インフラエンジニア, etc...)によるブログです

Goで開発した配信サーバーのメモリ使用量問題に向き合う

こんにちは。ストリーミングチームの松本です。

Mirrativのストリーミングチームは、低遅延配信や、通知ぼかしというような機能を追加するため、配信のorigin serverの前段にtranscoder serverというものを導入してきました。

tech.mirrativ.stream

tech.mirrativ.stream

transcoder serverはGoによる内製のミドルウェアであり、主に映像の変換を行う目的で作られました。現在は配信プロトコルの変換(既存プロトコル -> 低遅延プロトコル)などを行っています。また、実際にはサーバー上のDockerコンテナ内で動作しています。

f:id:hma2moto:20210120154004p:plain

transcoder serverを展開していくにあたり、メモリ使用量が常に増え続ける問題が起きていたため、その際に直面したGoの実メモリ使用量に関する話を書きたいと思います。

メモリ使用量の増加問題

ミラティブでは Sharding を行っているため、簡易的な構成図では下記のようになっています。

f:id:hma2moto:20210120155256p:plain

これに対してtranscoder server の動作するサーバーインスタンスでは数日〜数週間動作させているとプロセスのメモリ使用量があるタイミングで急激に増えその後低下しない状態になっていき、結果的にメモリ使用量の監視アラートが通知されるという問題が起きていました。

アラートを検知した際には対象の配信shardをサービスから外す・翌日になり対象の配信shardのすべての配信が終了してからtranscoder serverを再起動する。というような対応をおこなっていました。

Goのヒープ使用量調査

このようなメモリ使用量の大幅な上昇は開発環境上では再現していませんでした。

まず最初に疑ったのは、Goのアプリケーション自体がメモリリークしている箇所があるのではということでした。特に goroutineリークにより、実行中のgoroutineが残ってしまい、そこで利用されているメモリが開放されていないのではということです。

transcoder serverに対しては、pprofをhttp apiでリクエストできるようにしています1。そのため、transcoder serverの動作するDockerコンテナ内に入りさえすれば任意のタイミングで現在実行中のアプリケーションのpprofの結果を取得することができるようになっています。

以下のようにして取得しました。

go tool pprof http://localhost:6060/debug/pprof/heap
go tool pprof http://localhost:6060/debug/pprof/goroutine

結果としては、Goのヒープに実際に処理に必要なもの以外で数百MB、数GBのような割当があるものは見つからず。また、goroutineリークも見つけることはできませんでした。

実メモリ使用量が減少しないのはなぜ?

Goのヒープ上のメモリは不要になったタイミングで開放されているのですが、メトリクス上で確認できるメモリ使用量のグラフは減少せず一定のままになっています。また、メモリ使用量は常に一定ではなく急激に増える箇所もありました。

transcoder serverのプロセスについてtopで確認できるRSSやpsコマンドで確認できるRESも高い値のままです。一体何が実メモリ使用量として割り当てられているのかを調べる必要がありました。

以下はTelegrafで取得した統計情報をソースとして グラフ化したものです。

transcoder serverのメモリ使用量内訳(対応前)

f:id:hma2moto:20210119162619p:plain

以下は赤線が使用メモリ(total memory - free memory)量(左軸)、黄線が使用率(右軸)

transcoder serverのメモリ使用量と使用率(対応前)

f:id:hma2moto:20210119162513p:plain

Go 1.12以上 + Linux 4.5以上においてMADV_FREEが利用される際の問題

実メモリ使用量が増え続ける理由の一つとして、Goのmadvise呼び出しに関する以下のような問題がありました。

  • Go1.12で、LinuxのKernel 4.5以上2ではmadviseのシステムコールについてデフォルトでMADV_FREEを使用するようになっていました。
  • ページフォルトが頻繁に発生しないことで理論上はMADV_DONTNEEDよりもMADV_FREEのほうがパフォーマンスが良くなるはずでしたが、実際にそのメリットを享受できているデータがほとんどないようでした。また、統計ツール上にあらわれる値は次に述べるように監視を行うエンジニアにとってユーザーエクスペリエンスの低下を招いていました。github.com

  • MADV_FREEを利用したことによる問題の例

    • 不要になった実メモリがすぐに開放されていないため、メモリリークではないのに メモリリークに見えることがある
    • 実メモリ使用量は増えつづけるため、実際にメモリリークしていることに気付きにくい
    • LazyFreeの値をRSSの値から差し引けばMADV_DONTNEED指定した際と同等の値になるが、それを知る方法が /proc/<PID>/smaps を参照するしかなく非常にわかりにくい。github.com

上記の問題は Go 1.16 において GOOS == "linux" の場合に debug.madvdontneed = 1 が付くようになる(デフォルトでMADV_DONTNEED) ことで対応されるようです。

また、Go 1.12〜1.15をLinuxで利用する場合においては、環境変数で GODEBUG=madvdontneed=1 を設定することにより、MADV_DONTNEEDが利用されるようになります。

ミラティブでは transcoder server に MADV_DONTNEEDを利用するようにした結果、メモリ使用量が増加傾向にあることは変わりませんでしたが、時間帯によって実メモリの使用量は増減していることがわかるようになりました。

transcoder serverのメモリ使用量内訳(MADV_DONTNEED設定後)

f:id:hma2moto:20210119163203p:plain

transcoder serverのメモリ使用量と使用率(MADV_DONTNEED設定後)

f:id:hma2moto:20210119162611p:plain

まとめ

Go1.12以降ではLinux上において、メモリをOSへ返却する際の実装が監視ツールとの相性が悪く結果としてUXの低下を招いていました。

ミラティブでは配信サーバの運用上、メモリ使用量が減らない状況にあり原因究明をしようとしていましたが、MADV_DONTNEEDを使うことでメトリクス上でメモリ使用量がわかりやすくなりました。

残念ながら解決しようとしてたtranscoder serverのメモリリークの問題はまだ残っています。根本的な解決に向けて今後さらに深堀りが必要です。

We are hiring!

ミラティブではGoでライブ配信をゴリゴリ開発できるストリーミングエンジニアを募集中です!

www.mirrativ.co.jp


  1. 配信サーバ以外のミラティブ本体ではprofefe の導入 を行っています。

  2. transcoder serverが動作しているインスタンスのOSはUbuntuでありカーネルは4.5以上です。また、transcoder serverのアプリケーション本体は、Dockerコンテナ上で動作しています

【インフラ】Mirrativのデータベースを最小限の影響で切り替える運用の紹介

こんにちは、ミラティブのインフラを担当している清水です。 今回はミラティブのデータベースのマスタをどのようにフェイルオーバさせているかノウハウをお伝えしようかと思います。

ミラティブではデータベースにMySQLを利用しており、マスタ・スレーブ構成で冗長化しています。 マスタ・スレーブ構成の優れている点はデータをフルダンプすればデータベースを完全に複製でき、マルチマスタ構成で発生しうるデータ不整合を気にかけなくて良い点です。 データベースのクラスタリングには MySQL Cluster や GaleraCluster などもありますが、マスタ・スレーブ構成はストレージエンジンに依存せず素のMySQLで運用できるので、クラスタ固有の制約にハマったりせずシンプルに運用できるのも強みです。

ただし、マスタ・スレーブ構成の鬼門となるのがマスタのフェイルオーバです。 スレーブは参照のみリクエストを処理するので1台停止しても別のスレーブから再び参照すればよいだけなので復旧が容易です。 一方でマスタは、データの書き込み処理を行っているため、フェイルオーバ時にはデータ不整合なく書き込み先を切り替える必要があります。

生きているスレーブをマスタに昇格するにしても、

  1. スレーブが複数台ある場合はデータ欠損を最小とするため、もっともRelaylogのポジションの進んだスレーブを探し出してマスタ昇格候補にする
  2. スレーブが複数台ある場合はRelaylogのポジションにズレがないか確認し、ズレが発生していたら欠損しているバイナリログを手動で解消させる
  3. マスタ昇格候補のスレーブにレプリケーションを張り直す

といった作業が発生します。

とても慎重且つ神経を使う作業が要求されますが、作業中にユーザさんはサービスを完全な状態で利用できないわけで、焦りや緊張でオペレーションミスを誘発しかねません。

そこで、ミラティブではマスタ切り替えにMHA for MySQL(Master High Availability Manager and tools for MySQL)というHAツールを利用して、データ不整合を最小限に解消させ、安全且つ短時間にフェイルオーバを行えるようにしています。

MHA for MySQL(Master High Availability Manager and tools for MySQL)とは

MHA for MySQL(以下、MHAと略す)はDeNA社がオープンソースとして公開している MySQL の HAツールで、githubにソースコードが公開されています。

MHAはMySQLサーバにmha4mysql-nodeをインストールし、外部サーバからmha4mysql-managerに含まれるスクリプトを動かしてフェイルオーバを行います。 インストール方法は本家 mha4mysql wiki で解説されているので本記事では割愛します。

MHAを利用すれば複雑なマスタのフェイルオーバ作業をワンコマンド化することができ、デーモンとして動かしておけば自動化させることもできますが、動かすためにいくつか注意点もあります。

一つ目はスレーブでもBinlogを吐くようにしておく必要があることです。 これはMHAがマスタ・スレーブをフェイルオーバさせた時にマスタからBinlogを回収してスレーブとの差分を埋めてくれるためで、Binlogが吐かれていないとスレーブがマスタ昇格後にMHAを実行できなくなってしまうからです。

二つ目はマスタと昇格対象のスレーブのスペックを揃えておくことです。 マスタ昇格後にスペックが下がってしまうようなことがあると、もともと捌けていたリクエストを昇格後に捌くことができず障害になりかねないからです。

ミラティブではマスタと昇格対象のスレーブはスペックを揃えてBinlogを吐くように運用していて、いつでもスレーブをマスタに昇格できるようにしています。

MHAの処理の流れを追ってみる

MHAを実行した時にどのような制御をしてマスタのフェイルオーバを行っているのか紹介します。 ここの所を理解しておけばMHAの実行に失敗してもパニックにならず落ち着いて作業できるかと思います。

mha4mysql-managerに含まれるmasterha_master_switchを利用してマスタをフェイルオーバした時の処理の流れを見て行きましょう。

マスタが停止している場合

マスタが停止してしまったときのMHAの処理を見ていきましょう。 MHAは切り替えをPhaseで管理しており、マスタが停止している場合はPhase1~5まで進んでフェイルオーバが完了します。

  • Phase 1: Configuration Check Phase..
  • Phase 2: Dead Master Shutdown Phase..
  • Phase 3: Master Recovery Phase..
  • Phase 3.1: Getting Latest Slaves Phase..
  • Phase 3.2: Saving Dead Master's Binlog Phase..
  • Phase 3.3: Determining New Master Phase..
  • Phase 3.3: New Master Diff Log Generation Phase..
  • Phase 3.4: Master Log Apply Phase..
  • Phase 4: Slaves Recovery Phase..
  • Phase 4.1: Starting Parallel Slave Diff Log Generation Phase..
  • Phase 4.2: Starting Parallel Slave Log Apply Phase..
  • Phase 5: New master cleanup phase..

Phase 1: Configuration Check Phase..

f:id:masaya-shimizu:20201221153601j:plain

Phase1はMHAのconfを検証してくれます。 MHAのconfは環境ごとに異なりますが、概ねこのような設定を記述します。

[server default]
user=${MYSQL_USER}
password=${MYSQL_PASSWORD}
repl_user=${REPL_USER}
repl_password=${REPL_PASSWORD}
remote_workdir=/path/to/workdir
master_binlog_dir=/path/to/mysql
ssh_user=${SSH_USER}
master_pid_file=/path/to/mysqld.pid
master_ip_failover_script=/path/to/master_ip_failover_script
master_ip_online_change_script=/path/to/master_ip_online_change_script
shutdown_script=/path/to/shutdown_script
report_script=/path/to/report_script

manager_workdir=/path/to/workdir
manager_log=/path/to/mha/log

[server1]
hostname=${SERVER1}
ip=${ADDRESS1}

[server2]
hostname=${SERVER2}
ip=${ADDRESS2}
candidate_master=1

[server3]
hostname=${SERVER3}
ip=${ADDRESS3}
candidate_master=1

[server4]
hostname=${SERVER4}
ip=${ADDRESS4}
candidate_master=0

MHAのconf内容が間違っていたり、スレーブが停止していたり、スレーブにssh接続できないときはPhase1で中断されます。 この段階でマスタ切り替えは行われていないので、落ち着いてconf内容と実際に動いているマスタ・スレーブ構成を見直してみて下さい。

Phase 2: Dead Master Shutdown Phase..

f:id:masaya-shimizu:20201221154024j:plain

Phase2は停止したマスタを完全停止させます。 ハングアップしたと思われていたマスタが実は生きていて、マスタ切替中にアプリケーションからデータの書き込みが発生してデータ不整合が発生することを防いでくれます。

Phase2に入るとまず master_ip_failover_scriptが--command=stop|stopssh 引数とともに実行されます。

/path/to/master_ip_failover_script  \
  --command=stop|stopssh \
  --orig_master_host=${ORIG_MASTER_HOST} \
  --orig_master_ip=${ORIG_MASTER_IP} \
  --orig_master_port=${ORIG_MASTER_PORT}

Phase2で実行されるmaster_ip_failover_scriptはこれからマスタを完全停止するための事前処理を記述して実行します。 例えば、停止したマスタのレコードを引けなくしたり、これから停止するマスタの情報を通知させたりできますが、何もさせたくない場合は処理を記述しなければよいです。

mha4mysql-managerに master_ip_failover というサンプルスクリプトが付属しているので、サンプルを参考にしつつ自前で処理を記述してみましょう。 Perl製ですが、同じ引数を受け取ることができれば別言語でも実装可能です。

続いて、マスタを完全停止させるためshutdown_script が実行されます。

/path/to/shutdown_script \
  --command=stop \
  --host=${HOSTNAME}  \
  --ip=${ADRESS}  \
  --port=${PORT} \
  --pid_file=/path/to/mysqld.pid

mha4mysql-managerに power_manager というshutdown_scriptがスクリプトが付属していますが、ミラティブのMySQLデータベースはGCP(Google Cloud Platform)で動いており、GCPと連携して確実にマスタを停止させたかったのでGo製のツールを自作しています。 このGo製のマスタ停止ツールはssh越しにMySQLの停止を試みて、失敗した場合はGCPからインスタンスを強制停止してくれます。

例ですが、shutdown_scriptはこんな感じで実装しています。

package main

import(
  "fmt"
  "log"

  "gopkg.in/urfave/cli.v1"

  "infra-tool"
  "infra-tool/util"
  "infra-tool/mha"
)

func mha_shutdown(c *cli.Context) error {
  ...
  sshPrivateKey := c.String("ssh-private-key")
  maxRetry      := uint64(c.Int("max-retry"))
  project       := c.String("project")

  if util.FileExists(sshPrivateKey) != true {
    return fmt.Errorf("ssh-private-key not exist: %s", sshPrivateKey)
  }
  if maxRetry < 1 {
    maxRetry = 1
  }

  // port22 に接続できないと--ssh_user が引数に渡されないのでrootを引き渡す
  sshUser := c.String("ssh_user")
  if c.String("ssh_user") == "" {
    sshUser = "root"
  }

  mhaOptions          := mha.MHAShutdownOptions{}
  mhaOptions.Command  = c.String("command")
  mhaOptions.SshUser  = sshUser
  mhaOptions.Host     = c.String("host")
  mhaOptions.Ip       = c.String("ip")
  mhaOptions.Port     = c.Int("port")
  mhaOptions.PidFile  = c.String("pid_file")

  log.Printf("debug: command: %s", mhaOptions.Command)
  log.Printf("debug: ssh_user: %s, host: %s, ip: %s, port: %d, pid_file: %s",
    mhaOptions.SshUser, mhaOptions.Host, mhaOptions.Ip, mhaOptions.Port, mhaOptions.PidFile,
  )

  if mhaOptions.Command == "stopssh" || mhaOptions.Command == "stop" {
    if err:= shutdownStopsshCommand(mhaOptions, sshPrivateKey, maxRetry, project); err != nil {
      return err
    }
  }

  return nil
}

func shutdownStopsshCommand(mhaOptions mha.MHAShutdownOptions, sshPrivateKey string, maxRetry uint64, project string) error {
  if err := mha.KillMySql(mhaOptions.Host, mhaOptions.Ip, mhaOptions.SshUser, sshPrivateKey, maxRetry, mhaOptions.PidFile, project); err != nil {
    log.Printf("warn: %s", err.Error())
    if err := mha.ShutdownInstance(mhaOptions.Host, project); err != nil {
      return err
    }
  }
  return nil
}

func init(){
  addCommand(cli.Command{
    Name: "mha-shutdown",
    Usage: "mha shutdown_script",
    Flags: []cli.Flag{
      cli.StringFlag{
        Name: "ssh-private-key",
        Usage: "/path/to/.ssh/id_rsa",
        Value: watch.DEFAULT_MS_SSH_PRIVATE_KEY,
        EnvVar: "INFRA_WATCH_MS_SSH_PRIVATE_KEY",
      },
      cli.IntFlag{
        Name: "max-retry",
        Usage: "maximum number of times to retry on failure",
        Value: watch.DEFAULT_MS_MAX_RETRY,
        EnvVar: "INFRA_WATCH_MS_MAX_RETRY",
      },
      cli.StringFlag{
        Name: "project",
        Usage: "specify gcp project",
        Value: watch.DEFAULT_MS_PROJECT,
        EnvVar: "INFRA_WATCH_MS_PROJECT",
      },
      cli.StringFlag{
        Name: "command",
        ...
      },
      cli.StringFlag{
        Name: "ssh_user",
        ...
      },
      cli.StringFlag{
        Name: "host",
        ...
      },
      cli.StringFlag{
        Name: "ip",
        ...
      },
      cli.IntFlag{
        Name: "port",
        ...
      },
      cli.StringFlag{
        Name: "pid_file",
        ...
      },
    },
    Action: mha_shutdown,
  })
}

Phase2で失敗した場合はmaster_ip_failover_scriptまたはshutdown_scriptの実行に失敗しているので、スクリプトをデバッグしてみてください。 スクリプトでマスタを落とし切ることができずエラー判定となる場合は手動で落としてしまうのも手です。

Phase 3: Master Recovery Phase..

Phase3はスレーブをマスタに昇格させるための下準備を進めるフェーズです。 3.1 ~ 3.4 まであるのでそれぞれ見ていきましょう。

Phase 3.1: Getting Latest Slaves Phase..

f:id:masaya-shimizu:20201221155914j:plain

Phase3.1は全てのスレーブのRelaylogポジションをチェックしてもっともポジションの進んでいるスレーブを探し出します。 図ではSlave2がもっともポジションの進んだsalveです。

Phase 3.2: Saving Dead Master's Binlog Phase..

f:id:masaya-shimizu:20201222175743j:plain

Phase3.2は停止したマスタにsshログインを試行し、もっともRelaylogポジションの進んだスレーブと停止したマスタのBinlogポジションの差分を回収します。 インスタンスが停止してしまっている場合はsshログインできないのでスキップされます。

f:id:masaya-shimizu:20201222175900j:plain

停止したマスタからBinlogの回収に成功した場合は全てのスレーブに差分を転送します。

Phase 3.3: Determining New Master Phase..

f:id:masaya-shimizu:20201221161135j:plain

Phase3.3パート1はマスタの昇格候補となるスレーブを決定します。 もっともRelaylogポジションの進んでいるスレーブが昇格候補となりますが、MHAのconfに candidate_master=1 を定義すると優先的に特定のスレーブを昇格候補とすることができます。

Phase 3.3: New Master Diff Log Generation Phase..

f:id:masaya-shimizu:20201221161240j:plain

Phase3.3パート2はもっとものRelaylogポジションの進んでいるスレーブとマスタ昇格候補スレーブのRelaylogの差分を取り出し、マスタ昇格候補スレーブに転送します

Phase 3.4: Master Log Apply Phase..

f:id:masaya-shimizu:20201221161656j:plain

Phase3.4はマスタ昇格候補のスレーブに停止したマスタから回収したBinlogの差分と、もっともRelaylogポジションの進んでいるスレーブとの差分を適用します。

ここまで進むともう後戻りはできません。差分適用に失敗したら戻すのは困難なので壊れていない他のslaveからdumpを取ってマスタ・スレーブを作り直した方が早いです。 無事終わることを見守りましょう。

差分適用に成功したらmaster_ip_failover_scriptが--command=start引数とともに実行されます。

/path/to/master_ip_failover_script  \
  --command=start \
  --ssh_user=${SSH_USER} \
  --orig_master_host=${ORIG_MASTER_HOST} \
  --orig_master_ip=${ORIG_MASTER_IP} \
  --orig_master_port=${ORIG_MASTER_PORT} \
  --new-master_host=${NEW_MASTER_HOST} \
  --new_master_ip=${NEW_MASTER_IP} \
  --new_master_port=${NEW_MASTER_PORT} \
  --new_master_user=${NEW_MASTER_USER} \
  --new_master_password=${NEW_MASTER_PASSWORD}

Phase 3.4で実行されるmaster_ip_failover_scriptはアプリケーションの書き込み先をマスタ昇格候補のスレーブに切り替えるための処理を記述します。 DNSで制御している場合はマスタのレコードを切り替えたり、IPで書き込み先を制御している場合はIPを付け替えたりします。

Phase 4: Slaves Recovery Phase..

Phase4はマスタ昇格候補のスレーブとその他スレーブの差分を埋めてレプリケーションを張り直します。

Phase 4.1: Starting Parallel Slave Diff Log Generation Phase..

f:id:masaya-shimizu:20201222180020j:plain

Phase 4.1はマスタ昇格候補のスレーブとその他スレーブのRelaylogの差分を生成してそれぞれのスレーブに転送します。

Phase 4.2: Starting Parallel Slave Log Apply Phase..

f:id:masaya-shimizu:20201221162216j:plain

Phase 4.2は各スレーブで停止したマスタから回収したBinlogの差分と、もっともRelaylogポジションの進んでいるスレーブとの差分を適用します。 ここで差分適用に失敗してしまってもマスタ昇格候補のスレーブは復元が完了しているので、そこからダンプを取ってスレーブを作り直しましょう。

f:id:masaya-shimizu:20201221162329j:plain

差分適用に成功したらマスタ昇格候補のスレーブにレプリケーションを張り直します。

Phase 5: New master cleanup phase..

Phase5はマスタ昇格候補のスレーブで reset slave all が実行されて、停止したマスタとレプリケーションを張っていたときの情報がクリーニングされます。

Master failover to ${HOSTNAME}(${ADDRESS}:${PORT}) completed successfully.

メッセージが表示されればマスタ切り替えは完了です。おつかれさまでした。

マスタが起動している場合

マスタが停止せずともスレーブをマスタに昇格させたい場合もよくあります。 例えば、CPUやメモリといったサーバのスペックを増強したり、コスト最適化のためにディスク容量を減らしたり、サーバの性能劣化による入れ替えを行いたいケースなどです。

停止メンテナンスを伴う時間を確保すれば切り替えはできますが、ユーザへの告知、サービス連携している協力会社さんへの連絡、停止中のユーザアクセスの停止が発生するためできればやりたくはありません。 MHAはマスタが起動状態でも切り替えられるように作られているので停止メンテナンスを伴う時間を確保せずとも切り替えることができます。

それでは、マスタが起動している場合のmasterha_master_switchの挙動を見ていきましょう。 マスタが起動している場合のPhaseは1,2,5で、マスタが停止している場合と異なるのはBinlogとRelaylogの差分回収と適用が無い点です。

  • Phase 1: Configuration Check Phase..
  • Phase 2: Rejecting updates Phase..
  • Phase 5: New master cleanup phase..

Phase 1: Configuration Check Phase..

f:id:masaya-shimizu:20201221222549j:plain

Phase1はマスタが停止している時と概ね同じ挙動をします。 スレーブが停止していたりssh接続できないときはPhase1で中断されるので、落ち着いてMHAのConf内容とマスタ・スレーブ構成の状態を見比べてみましょう。

マスタが停止している場合と異なる挙動はPhase1で FLUSH NO_WRITE_TO_BINLOG が実行されてBinlogの書き出しが行われる点です。 書き込みが多いとIO詰まりを誘発しかねないので、書き込みの少ない時間帯にあらかじめ1台ずつ FLUSH NO_WRITE_TO_BINLOG を実行しておくと安全です。 もし IO に余裕がある環境であれば、 cron などで FLUSH NO_WRITE_TO_BINLOG を定期実行しておき、 Binlog を定期的に書き出しておくのも有効かもしれません。

Phase 2: Rejecting updates Phase..

f:id:masaya-shimizu:20201221222847j:plain

Phase2はマスタ切り替え中のデータ不整合を防ぐためにアプリケーションからの書き込みをブロックします。 書き込みのブロックはmaster_ip_online_change_scriptが --command=stop|stopssh 引数とともに呼び出されて行ってくれます。

/path/to/master_ip_online_change_script \
  --command=stop|stopssh \
  --orig_master_host=${ORIG_MASTER_HOST} \
  --orig_master_ip=${ORIG_MASTER_IP} \
  --orig_master_port=${ORIG_MASTER_PORT} \
  --orig_master_user=${ORIG_MASTER_PORT} \
  --orig_master_password=${ORIG_MASTER_PASSWORD} \
  --new_master_host=${NEW_MASTER_HOST} \
  --new_master_ip=${NEW_MASTER_IP} \
  --new_master_port=${NEW_MASTER_PORT} \
  --new_master_user=${NEW_MASTER_USER} \
  --new_master_password=${NEW_MASTER_PASSWORD} \
  --orig_master_ssh_user=${ORIG_MASTER_SSH_USER} \
  --new_master_ssh_user=${NEW_MASTER_SSH_USER}

mha4mysql-managerに master_ip_online_change がサンプルスクリプトとして付属しているので環境にあわせてカスタマイズしてみましょう。

ミラティブではアプリケーション用のMySQLユーザを以下表のとおり書き込み用と参照用を分けており、 Goで実装したmaster_ip_online_change_script が書き込み用ユーザをアンダースコア付きのユーザ名にrenameして新規の書き込み用のセッションを落としています。

書き込みユーザ 参照ユーザ
master writeuser readuser
slave1 _writeuser readuser
slave2 _writeuser readuser
slave3 _writeuser readuser

持続的な接続があると効果が無いので注意が必要ですが、ミラティブのアプリケーションは切り替えを考慮して処理毎に都度、接続を切断して接続が残らないように実装しています。

一般的なサービスではmysql接続時のオーバヘッドを減らす目的でkeepaliveで実装されていますが、ミラティブはフェイルオーバ発生時のダウンタイムを極力減らす目的でコネクションプールでも長時間接続が残らないようにしています。 持続的な接続に比べオーバヘッドも含んでしまいますが、接続がmax-connectionになるまで溜まることもほとんどなくなります。

万が一書き込みを復旧させたい時でも、MySQLユーザをrenameしているだけなので切り戻しも簡単です。 また、書き込み先を1箇所に限定できるので切り替え中に意図せぬスレーブへアプリケーションが書き込んでしまう事故も防げます。

master_ip_online_change_script で安全に新規書き込みの接続を落とすことができたら、 FLUSH TABLES WITH READ LOCK でテーブルロックされて完全に書き込みできない状態となり、マスタの切り替えが開始されます。

まず、master_ip_online_change_scriptが --command=start とともに呼び出されます。 ここではマスタ昇格先のスレーブで書き込みを行えるようにするための処理を記述しておきます。 ミラティブの場合ですと、書き込み用ユーザをアプリケーションが利用できるようにrenameして、DNSを切り替えてAレコードを昇格したマスタに向けるように実装しています。

/path/to/master_ip_online_change_script  \
  --command=start \
  --orig_master_host=${ORIG_MASTER_HOST} \
  --orig_master_ip=${ORIG_MASTER_IP} \
  --orig_master_port=${ORIG_MASTER_PORT} \
  --orig_master_user=${ORIG_MASTER_USER} \
  --orig_master_password=${ORIG_MASTER_PASSWORD} \
  --new_master_host=${NEW_MASTER_HOST} \
  --new_master_ip=${NEW_MASTER_IP} \
  --new_master_port=${NEW_MASTER_PORT} \
  --new_master_user=${NEW_MASTER_USER} \
  --new_master_password=${NEW_MASTER_PASSWORD} \
  --orig_master_ssh_user=${ORIG_MASTER_SSH_USER} \
  --new_master_ssh_user=${NEW_MASTER_SSH_USER}

master_ip_online_change_scriptの実行が完了したら set global read_only = 0 が実行されて書き込みが行える状態となります。

f:id:masaya-shimizu:20201221223255j:plain

そして、マスタに昇格したスレーブにレプリケーションを張り直します。

Phase 5: New master cleanup phase..

Phase5はマスタに昇格したスレーブで reset slave all が実行されます。 Switching master to ${HOSTNAME}(${ADDRESS}:${PORT}) completed successfully. メッセージが表示されれば切り替え完了です。

最後に

MHAのフェイルオーバの動きは理解していただけたでしょうか。MHA実行時のトラブルに遭遇した時にお役いただけるとうれしいです。

MHAは非常によくできたHAツールですが、あくまでマスタ・スレーブの構成管理ができている前提で動作します。 ミラティブでは構成管理するためにマスタ・スレーブの構成監視やMHAのconfを動いているマスタ・スレーブ構成から生成していて、いつでもMHAが実行できる環境を整えています。

今回は紹介しきれなかったので、いずれまた紹介できたらなと思います。

We are hiring!

ミラティブでは サービスの拡大と安定化を支えるインフラエンジニアを募集中です! meetup も開催しているため気軽にご参加ください!

www.mirrativ.co.jp

speakerdeck.com

【Go】profefeでContinuous Profilingをやっていく話

こんにちは、サーバーエンジニアの牧野です。 今回はGoで開発しているアプリケーションでContinuous Profilingを実践するために導入した profefe を紹介したいと思います。

Continuous Profilingとは

Continuous Profilingとは、ざっくり言うと本番環境で継続的にプロファイリングすることを指します。Continuous Profilingができると、本番環境でのみ発生するパフォーマンスの問題を捉えることができたり、継続的にプロファイリングすることで問題が発生する前後の状態を比較することができます。

Goには pprof というプロファイリングのための標準パッケージがあり、プロファイリング自体は容易に行うことができますが、Continuous Profilingを実現するとなると、以下のような課題と向き合う必要があります。

  • 本番環境でオーバーヘッドが少なく安全にプロファイリングを実行できるか
  • どこにプロファイリング結果を保存するか
  • 保存したプロファイリング結果をどのようにして検索・抽出するか

今回はこれらの課題を解決するために、profefe というOSSを導入しました。

github.com

Continuous Profilingを支援するサービスとして、Cloud ProfilerDatadog Continuous Profilerといったサービスがありますが、データの保持期間に上限があったりするので、より柔軟な運用をしたいとなるとprofefeのようなOSSが選択肢に入ってくるかと思います。

profefeについて

profefeは、CollectorAgentという2つのコンポーネントから構成されています。

f:id:tatsumack:20201217105318p:plain
https://github.com/profefe/profefe/blob/master/DESIGN.md より引用

Collector

Collectorはプロファイルを受け取るサーバーです。Docker Imageが提供されているので、以下のコマンドで起動することができます。

$ docker run -d -p 10100:10100 profefe/profefe

以下のようにPOSTメソッドでプロファイルを送ると、profefeがプロファイルを保存します。

$ curl -X POST \
    "http://localhost:10100/api/0/profiles?service=<service>&type=cpu" \
    --data-binary @pprof.profefe.samples.cpu.001.pb.gz

プロファイルはpprofのフォーマットに従ってさえさえいれば良く、Go以外の言語でも使用することができます。

プロファイルを検索・抽出するためのAPIが提供されており、たとえば特定の期間のプロファイルをマージした結果を参照することができます。

$ go tool pprof \
   'http://localhost:10100/api/0/profiles/merge?service=<service>&type=<type>&from=<created_from>&to=<created_to>'

また、プロファイル保存時にlabelを指定することができ、プロファイルを検索するときの条件に指定することができます。例えば、labelにアプリケーションのversionを加えて、go tool pprofbaseオプションを利用してversion間のプロファイル差分を見ることができます。

$ go tool pprof \
   -base 'http://localhost:10100/api/0/profiles/merge?service=<service>&type=<type>&from=<created_from>&to=<created_to>&version=0.0.1' \
   'http://localhost:10100/api/0/profiles/merge?service=<service>&type=<type>&from=<created_from>&to=<created_to>&version=0.0.2'

プロファイルを保存するストレージは差し替えが可能になっており、Badger DBAWS S3Clickhouse DBを保存先として指定することができます。
ただ、今回はプロファイルをGoogle Cloud Storage(GCS)に保存したかったので、GCSをprofefeのストレージとして扱う実装を行いました。

profefeのストレージは以下のinterfaceを満たせばよく、integration testも用意されているので、さくっと実装することができました。手持ちの技術スタックに合わせて、ストレージを差し替えることができるのもprofefeの良い点だと思います。

type Storage interface {
    Writer
    Reader
}

type Writer interface {
    WriteProfile(ctx context.Context, params *WriteProfileParams, r io.Reader) (profile.Meta, error)
}

type Reader interface {
    FindProfiles(ctx context.Context, params *FindProfilesParams) ([]profile.Meta, error)
    FindProfileIDs(ctx context.Context, params *FindProfilesParams) ([]profile.ID, error)
    ListProfiles(ctx context.Context, pid []profile.ID) (ProfileList, error)
    ListServices(ctx context.Context) ([]string, error)
}

今回の実装はPRとして送っています。現時点ではまだマージされていませんが、"the change looks good to me."というコメントをいただいているので、そのうちマージされるかと思います。 マージされました 🎉 github.com

Agent

Agentは以下のようにアプリケーションに組み込んで使用します。

import "github.com/profefe/profefe/agent"

func main() {
    _, err := agent.Start("<profefe-url>", "<service-name>")
    ...
}  

Agentはgoroutineを起動し、定期的にプロファイリングを実行し、Collectorに送信します。プロファイリングにはruntime/pprofパッケージが使われています。

デフォルトでは1分おきに10秒間プロファイリングを実行します。Diagnostics - The Go Programming Language にもある通り、pprofは本番環境でも安全に実行できるとのことですが、オーバーヘッドはゼロではないので、プロファイリングの実行時間・間隔を調整して許容できる範囲を探ると良いと思います。ちなみにミラティブではデフォルトの設定のまま使用していますが、profefeの導入前後でCPU使用率に大きな変化はありませんでした。
また、異なるインスタンスで同時にプロファイリングが実行されてシステム全体の性能が劣化することがないように、ランダムにsleepを入れることで、インスタンス間でプロファイリングの実行タイミングを分散するような工夫がされていたりします。

このAgentは必ずしもアプリケーションに組み込む必要はありません。アプリケーションがnet/http/pprofを組み込んでいれば、cronなどで定期的にプロファイリングを実行してCollecterに送信する、といった使い方をすることも可能です。

f:id:tatsumack:20201217105150p:plain
https://github.com/profefe/profefe/blob/master/DESIGN.md より引用

おわりに

ミラティブでは本番環境にprofefeを導入して数週間経過しましたが、特に問題なく使うことができています。 profefeを導入してContinuous Profilingの基盤は整備できましたが、実運用としてどのように実践していくかはまだ固まっておらず、これから模索していくところです。今後知見が溜まってきましたら、またテックブログにて共有できればと思っております。

Continuous Profilingに関しては、GoogleのデータセンターのContinuous Profiling基盤に関する論文があるので、興味を持った方は読んでみると楽しめるかと思います。
Google-Wide Profiling: A Continuous Profiling Infrastructure for Data Centers – Google Research

また、profefeの作者の方がprofefeを作った背景をブログ記事に書いているので、こちらもオススメです。
Continuous Profiling and Go. There are lots of hidden details we… | by Vladimir Varankin | Medium

We are hiring!

ミラティブではサーバーエンジニアを募集中です!

  • Goで大規模サービスの開発をしたい
  • サーバーシステムの基盤の整備をしたい
  • ゲーム×ライブ配信サービスの開発をしたい

といった方のご応募をお待ちしております!

www.mirrativ.co.jp

speakerdeck.com

ミラティブのサーバサイドをGo + Clean Architectureに再設計した話

こんにちは、テックリードの夏です。

今年4月にCTOからテックリードに肩書が変わり、ガリガリコードを書くようになりました。 背景については、こちらをご覧ください。

www.wantedly.com

普段はプロダクト側の機能開発と、サーバ側の基盤開発を半々ぐらいの割合で仕事しています。 一口にサーバ側の基盤開発といっても定義が曖昧なのですが、基本的にはこんな感じのタスクをやっています。

  • インフラコストの最適化
  • 不正なアクセスからの防御
  • 障害の再発防止
  • 新技術の導入やアーキテクチャの整備

今回はこのうち「新技術の導入やアーキテクチャの整備」の中で、サーバサイドをGo + Clean Architectureで再設計したことについてお話したいと思います。

背景

ミラティブは2015年春頃に開発が始まり、同年8月にサービスがリリースされ、2020年8月で5周年を迎えました。 その過程で組織やプロダクトが成長するにつれ、サーバサイドには以下のような負債が溜まっていました。

  • アーキテクチャが崩れかけている
    • MVC + Serviceだが、依存関係がスパゲッティ
      • Service = Controllerの処理を共通化したレイヤー
    • 膨れ上がるModel
      • データ型 + 永続化の両方を担当
      • 場合によってはPresenter的な仕事も
    • Contextという名のもとにあらゆるレイヤーから密結合を黙認されているGodなクラス
  • query digestやslow queryなどで危険なSQLが洗い出されても、どこで発行されているのか調査に時間がかかる
    • method chainによる柔軟なSQLの組み立てのメリットがもはや負債
    • Modelが永続化も内包しているせいで、様々なレイヤーから実行時にSQLが発行される恐れアリ
      • 果てはViewからも。。。
  • 負債が溜まったテーブルを再設計しづらい
  • テストがすべてシナリオテストで書かれている
    • テストの実行時間が長い
    • シナリオテストは開発者によって書き方に差異が出やすい
    • エッジケースのテストを書くためのコストが大きい

また、ミラティブのサーバサイドは開発当時の事情によりPerlで書かれているのですが、OSSコミュニティでのプレゼンス低下なども踏まえてGoへの移行を検討し始めました。

そこで、サービス固有の歴史的経緯やインフラ構成に即したコードを表現できるか確認するために、Go言語とアーキテクチャの整備を同時に行うのではなく、 既存のPerl側のコードで上記の課題を改善し得るアーキテクチャを整備してから、Go移行を進めることになりました。 これにより、標準的なDBの負荷分散手法を抽象化できるか、トランザクションやロギングをどう表現するのか、チームに受け入れられるかどうかなどもGo移行に先んじて検証することができました。

半年くらいかけてPerl側のClean Architectureのプロトタイプを完成させ、1年かけてサーバチーム全体に浸透させました。現時点では、既存アーキテクチャのコードはフリーズしています。 また、Perl側のアーキテクチャ刷新と並走しながら、Goのプロトタイプ実装を進めてきました。

Go移行に関しては正直まだDaemonやBatchなど、移行しやすいコンポーネントしか本番投入出来ていません。しかし、テックブログを書くことで逆説的に社内への普及を加速させるためにも、 ミラティブのサーバサイドのGoコードのアーキテクチャをまとめてみようと思います。

Clean Architecture

アーキテクチャを再設計する上でClean Architectureを参考にすることにしました。 世の中のClean Architectureの文献を色々漁ってみても、コアとなる考え方は同じなのですが、細部に関してはいろいろな流派があるように見受けられます。 そこで、Clean Architectureとして正解を追うのではなく、過去の実装上の経緯を背負った上で、辛みポイントを解消できるようなアーキテクチャを設計しました。 Clean Architectureがどういうものなのかは参考記事に譲るとして、本記事ではミラティブで利用されているコードに近い形で、設計の詳細に入りたいと思います。 (本家本元のClean Architectureとは異なる場合がありますが、ご了承ください)

qiita.com qiita.com qiita.com www.m3tech.blog (「なぜ書くのか」に激しく同意)

再設計する上で大事にしたポイントは、「コンポーネントの依存性を一方向にする」の一点に集中するかなと思います。 これはなにも、ミドルウェアを差し替えた場合でも、内側のビジネスレイヤーを1行も変更したくないレベルの抽象化を目指したいわけではなく、 負債が溜まったMySQLのtableを再設計する際の影響範囲を最小限に留めようとか、外側の依存性を内側に注入することで、外部APIに依存する処理をテスト時だけモックを差し込みやすくすることなどが目的です。

f:id:mirrativ:20201127114557j:plain
あまりにも有名な例のあの図 The Clean Code Blog

ディレクトリ構造

├── entities
├── usecases
│   ├── inputport
│   ├── interactor
│   │   └── user
│   └── repository
├── gateways
│   ├── repository
│   │   ├── user
│   │   └── datasource
│   │       ├── dsmemcached
│   │       └── dsmysql
│   ├── datasource
│   │   ├── dsmemcachedimpl
│   │   └── dsmysqlimpl
│   └── infra
│       ├── infradns
│       ├── infralogger
│       ├── inframemcached
│       └── inframysql
├── controllers
│   ├── daemon
│   └── web
├── frameworks
│   ├── daemon
│   └── web
├── assets     // ここ以下のファイルはstatikによってバイナリに埋め込む
├── cmd        // アプリケーションの起動コマンドや、各種lint/generator/migrationコマンドが存在
│   └── wire   // DIライブラリ google/wire の定義ファイル
└── utils      // インフラレイヤーにもビジネスレイヤーにも該当しないutility群

Entities

オブジェクトでビジネスロジックを表現する責務を負っています。 ここでいうEntityは、DDDなどでのEntityとは違い、一意な識別子が存在しないものも定義しています。

これにより、Loggerのように全レイヤーから参照されるinterfaceなどもEntitiesに存在しています(実装はInfra層)。

package entity

type UserID uint64

type User struct {
    UserID UserID
    Name   string
}

type Logger interface {
    Error(ctx context.Context, err error)
    Log(ctx context.Context, level LogLevel, label string, payload ...interface{})
}

UseCases

Entity・Repositoryを使い、ユースケースを達成する責務を負っています。

└── usecases
     ├── inputport
     │   └── user.go
     ├── interactor
     │   └── user
     │       └── interactor.go
     └── repository
         └── user.go

ここでは usecases/inputport ディレクトリにinterfaceを定義し、

package inputport

import (
    "context"
    "time"
)

type User interface {
    UpdateRecommend(ctx context.Context, now time.Time) error
}

usecases/interactor ディレクトリにその実装を配置しています。 また、トランザクションのスコープを管理するのもInteractorのお仕事です。

package user

import (
    "context"
    "time"

    "server/entities/entity"
    "server/usecases/inputport"
    "server/usecases/repository"
)

type interactor struct {
    txm      repository.TransactionManager
    repoUser repository.User
}

func New(txm repository.TransactionManager, repoUser repository.User) inputport.User {
    return &interactor{
        txm:      txm,
        repoUser: repoUser,
    }
}

func (i interactor) UpdateRecommend(ctx context.Context, now time.Time) error {
    var recommendUserIDs []entity.UserID

    // おすすめユーザを計算

    return i.txm.Do(ctx, func(txns repository.Transactions) error {
        return i.repoUser.UpdateRecommend(ctx, txns, recommendUserIDs)
    })
}

usecases/repository ディレクトリにはInteractorが要求するRepositoryのinterfaceが定義されます。

package repository

import (
    "context"

    "server/entities/entity"
)

type User interface {
    ReadRecommend(ctx context.Context) ([]entity.User, error)
    UpdateRecommend(ctx context.Context, txns Transactions, recommendUserIDs []entity.UserID) error
}

Repository

データの集約、永続化の責務を負っています。 対応するDataSourceを活用し、UseCasesレイヤーが実際のテーブル構造などを把握しなくてもEntityの永続化を行える責務を負っています。

  • データの整合性が取れる最小単位
    • 例)MySQL側のDataSourceを更新したら、Memcached側のDataSourceも更新
  • DataSourceで取得したデータをEntityに変換
  • CRUDなinterfaceを提供
    • 命名規則もCreate/Read/Update/Deleteを強制
└── gateways
     └── repository
         ├── datasource
         │   ├── dsmemcached
         │   │   └── recommend_users.go
         │   └── dsmysql
         │        └── user.go
         ├── transaction
         │   └── repo.go
         └── user
             └── repo.go

usecases/inputport で定義されたRepositoryのinterfaceの実装が配置されています。

package user

import (
    "context"

    "server/entities/entity"
    "server/gateways/repository/datasource/dsmemcached"
    "server/gateways/repository/datasource/dsmysql"
    "server/usecases/repository"
)

type user struct {
    dsmemcachedRecommendUsers dsmemcached.RecommendUsers
    dsmysqlRecommendUser      dsmysql.RecommendUser
}

func New(dsmemcachedRecommendUsers dsmemcached.RecommendUsers, dsmysqlUser dsmysql.User) repository.User {
    return &user{
        dsmemcachedRecommendUsers: dsmemcachedRecommendUsers,
        dsmysqlRecommendUser:      dsmysqlRecommendUser,
    }
}

func (r user) ReadRecommend(ctx context.Context) ([]entity.User, error) {
    // dsmemcachedRecommendUsersからおすすめユーザを取得
    // なければdsmysqlUserから問い合わせ
    // 取得したDataSource固有の構造体をEntityへ変換
}

func (r user) UpdateRecommend(ctx context.Context, txns repository.Transactions, recommendUserIDs []entity.UserID) error {
    // dsmysqlRecommendUserで更新してから、dsmemcachedRecommendUsersを更新
}

gateways/repository 以下には、Repositoryが期待するDataSourceのinterfaceを定義しています。

package dsmysql

import (
    "context"

    "server/entities/entity"
)

type RecommendUsers interface {
    Update(ctx context.Context, txns repository.Transactions, users []*RecommendUserRow) error
    Select(ctx context.Context) ([]*RecommendUserRow, error)
}

Transaction

複数のInfra・DataSourceへのトランザクションを管理する責務を追っています。 (トランザクションスコープはInteractorで管理)

ミドルウェアを跨った厳密なトランザクションはサポートされていませんが、複数のMySQLのデータベースへの書き込みがある場合は、 すべての処理が完了してからのcommitやエラー時にすべてのsql.Txのrollbackなどを抽象化しています。

package repository

import "context"

// commitとrollbackができるものをTransactionと定義
type Transaction interface {
    Commit(ctx context.Context) error
    Rollback(ctx context.Context) error
}

// 複数のTransactionを抽象化し、同一データベースへのTransactionはキャッシュする
type Transactions interface {
    Get(key string, builder func() (Transaction, error)) (Transaction, error)
    Succeeded(f func() error) // cache更新などrollbackできない(厳密な整合性を担保しなくていい)処理などを登録し、全てのcommitが成功した場合のみ実行する
}

// トランザクションのスコープを管理するオブジェクト(dry-run時は最後に全てrollbackする)
type TransactionManager interface {
    Do(ctx context.Context, runner func(txns Transactions) error) error
}

DataSource

Infraを活用し、Repositoryが要求するデータの取得、永続化を達成する責務を負っています。

  • MySQLのtableや、Memcachedのkey、ElasticSearchのtypeと1:1の関係
  • 該当するミドルウェア固有の操作名に沿った命名規則
    • SQLであればSelect/Insert/Update/Delete
    • CacheであればGet/Set
└── gateways
     └── datasource
          ├── dsmemcachedimpl
          │   └── recommend_users.go
          └── dsmysqlimpl
               └── recommend_user.go

gateways/repository 以下で定義されたDataSourceのinterfaceの実装が配置されています。

package dsmysqlimpl

import (
    "context"

    "server/entities/entity"
    "server/gateways/infra"
    "server/gateways/repository/datasource/dsmysql"
    "server/usecases/repository"
)

type recommendUser struct {
    infraMySQL infra.MySQL
}

func NewRecommendUser(infraMySQL infra.MySQL) dsmysql.RecommendUser {
    return &recommendUser{infraMySQL: infraMySQL}
}

func (ds recommendUser) Update(ctx context.Context, txns repository.Transactions, users []*dsmysql.RecommendUserRow) error {
    txn, err := ds.infraMySQL.GetTxn(ctx, txns, "BASE_W") // BASE_W はデータベース系統の名前
    if err != nil {
        return nil
    }

    _, err = txn.ExecContext(ctx, "delete from recommend_user")
    if err != nil {
        return err
    }

    _, err = txn.ExecContext(ctx, "insert into recommend_user ...")
    return err
}

func (ds recommendUser) Select(ctx context.Context) ([]*dsmysql.RecommendUserRow, error) {
    return SelectRecommendUser(ctx, ds.infraMySQL, repository.DB_R)
}

このうち、 dsmysql.RecommendUserRow の構造体や SelectRecommendUser の処理などは、以下のような内製のテーブル定義から自動生成しています

kyleconroy/sqlc をオマージュしました)

recommend_user:
  columns:
    - name: user_id
      type: uint64
      foreign_key: user.user_id
    - name: name
      type: string
      collation: utf8mb4_bin
  primary_keys:
    - user_id
  queries:
    - sql: select * from recommend_user

このテーブル定義からDDLを生成し、 k0kubun/sqldef に食べさせることで、MySQLのマイグレーションなども行っています。

Infra

ミドルウェアとの実際の接続や入出力などを担当するレイヤーです。 内側のレイヤーが各ミドルウェアのI/Fを把握せずとも利用できる状態にする責務を負っています。

└── gateways
     └── infra
          ├── cache.go
          ├── config.go
          ├── db.go
          ├── dns.go
          ├── infradns
          │   └── infradnstest
          ├── infrahttp
          │   └── infrahttptest
          ├── infralogger
          │   └── infraloggertest
          ├── inframemcached
          │   └── inframemcachedtest
          ├── inframemorycache
          └── inframysql
               └── inframysqltest

gateways/infra 直下には各種ミドルウェアの入出力のinterfaceが定義しています。

package infra

import (
    "context"
    "database/sql"

    "server/go/usecases/repository"
)

type Transaction interface {
    repository.Transaction
    DB
}

type MySQL interface {
    Get(ctx context.Context, name string) (DB, error) // 複数系統のデータベースが存在するのでnameで指定する
    GetTxn(ctx context.Context, txns repository.Transactions, name string) (Transaction, error)
}

type DB interface {
    ExecContext(ctx context.Context, query string, args ...interface{}) (sql.Result, error)
    QueryContext(ctx context.Context, query string, args ...interface{}) (*sql.Rows, error)
}

そして、実際の実装はさらに一階層掘って定義しています。 そして、さらに一階層掘ったディレクトリにはtest用の実装が存在しています。 (loggerであればファイルに書き出さずに出力内容を変数として保持しておくとか)

Frameworks

外界からの入力をControllerへルーティングする責務を負っています。 ここでは時刻情報も外界の一部としてみなし、このレイヤー以外では現在時刻を取得しないように制限しています。 これにより特別なライブラリを用いずともテストを決定的にしたり、動作確認する際に任意の時刻への変更を行いやすくなります。

  • Web
    • HTTP RequestのURLなどを参照し、該当するControllerへRequestを渡す
      • Sessionの解決などもこのレイヤー
    • RequestやResponseがOpenAPIの定義通りかどうかを検証する
      • 実行速度が犠牲になるので開発環境のみ
    • 内部に引き回す時刻情報はリクエストを受け取った時刻
  • Daemon
    • queueベースで動作している非同期処理の場合は、該当のqueueからdequeue処理とControllerをつなげる
      • 内部に引き回す時刻情報はenqueueされた時刻
    • それ以外の非同期処理の場合は、実行間隔だけが指定されるので、指定された頻度でControllerを実行する
      • 内部に引き回す時刻情報はControllerが実行された時刻

Controllers

外界からの入力を、達成するユースケースが求めるインタフェースに変換する責務を負っています。 HTTP Request内のパラメータを取り出したり、queueの中から必要な情報を取り出して適切なInteractorに渡したりします。

また、ミラティブではPresenterを呼び出すのはInteractorではなくController内なので、 Interactorから返ってきたEntityをPresenterで変換し、外界が求める出力フォーマットに変更するのもControllerの責務です。

package user

import (
    "context"

    "server/controllers/web"
    "server/presenters/user"
    "server/usecases/inputport"
)

type Controller struct {
    user   inputport.User
}

func New(user inputport.User) *Controller {
    return &Controller{user: user}
}

func (c Controller) RecommendUsers(ctx context.Context, webCtx *web.Context) error {
    recommendUsers, err := c.user.ReadRecommendUsers(ctx)
    if err != nil {
        return err
    }

    return webCtx.RenderJSON(ctx, map[string]interface{}{
        "users": user.PresentUsers(recommendUsers),
    })
}

テスト戦略

もともとはすべてシナリオテストでカバーしていたのですが、アーキテクチャを再設計したタイミングで、 基本的なカバレッジ率の達成にはユニットテストを用い、統合テストでは正常系のユースケースのみ検証しています。

(ここに登場する話が身につまされたので、今後はTesting Pyramidに従おうと思います) testing.googleblog.com

テストのカバレッジ率は90%以上を目指しており、それ以下の場合はCIに怒られるように設定しています。 高めの数字を置いてはいますが、実は go tool cover で出力されるカバレッジ率は使っていません。 以下のようなテストを書くコストが見合わなさそうなブロックを除いてカバレッジ率を計算しているので、思ったほど酷な数字ではないと思います。

  • errorが存在していたら後続処理を行わずに、呼び出し元にreturnするだけのif文
  • panic
    • そもそも初期化時やアプリケーション実行中にどう足掻いても復旧できない場合のみpanicを使用しているため
  • delegateのように引数を一切加工せずにフィールドに渡すだけの関数

また、テストの実行速度は生産性に直結するため、すべてのテストにt.Parallelを指定することをLintで強制したり、 データベース名にユニークなsuffixを差し込むことでテスト同士で衝突しないようにしたり、Fixtureのロードを該当するtableへのSQLが実行された場合のみ行ったりと、小技を駆使しています。

今後の展望

現在、DaemonやBatchは本番投入済みで、Web側のいくつかエンドポイントもGo実装が完了しています。 しかし、モノリシックなPerlのWebサーバを移行していくのはそう簡単ではなく、 現在インフラチームと協力しながら、前段にProxyを挟みながら、特定のエンドポイントだけGo + Dockerコンテナで受けられるような仕組みを開発中です。

来期中にWebの本番投入と新機能の開発を全てGo化、半年後にはPerlコードのフリーズまでできると最高だなあと妄想しつつ、きっと色々ハマると思いますし、 アーキテクチャの整備に完成などないので、面白いことがあったらまたテックブログネタにしようかなと思います。

We are hiring!

ミラティブでは サービスや組織の成長に合わせて、生産性を最大化するためのより良いアーキテクチャを模索し続けられるサーバエンジニアを募集中です! meetup も開催しているため気軽にご参加ください!

www.mirrativ.co.jp

speakerdeck.com

Mirrativ の iOS アプリで使っているライブラリを紹介する!

こんにちは、iOSエンジニアのちぎらです。今回は Mirrativ の iOS アプリで使っているライブラリをご紹介します。

Mirrativ ではどんなライブラリを使用していますか?と質問されることが時々あります。設定画面のライセンス情報に一覧で表示はされているものの、ライブラリ名だけでは用途が分かりにくいものもあるので、説明を添えて一覧で確認できるようにしようというのが今回の趣旨です。

ライブラリ管理には CocoaPods、Carthage を使用しています。最新のライブラリに追従できるように、一部のライブラリでは CI(Bitrise)上で定期的にバージョン更新のためのプルリクを作成しています。Swift Package Manager はまだ導入していませんが、タイミングを見て集約していけたらいいですね。

続きを読む

【Unity】MirrativのEmbedding Unityを更新した話: 実践 Unity as a Library

こんにちは皆様いかがお過ごしでしょうか、10ヶ月ぶりくらいのポストになります、よこてです。今日は「Mirrativ の Unity は進化してるんだぞ」という記事を書いていきます。

tech.mirrativ.stream

Mirrativ は Swift/Kotlin によるネイティブアプリですが、3D/アバター部分は Unity で実現しています。いわゆる embedding unity で、 Unity 2018.3 からは Unity as a Library として公式サポートされています。前回記事で触れたように、Unity をネイティブアプリに組み込むこと自体は公式サポート以前にもできて、ミラティブでは Unity 2018.2(2018年8月頃)から使っています。

f:id:n0mimono:20201015194824p:plain

Mirrativ では今 Unity 2019.4 LTS を使っていて、8月から Mirrativ の機能としてリリースした「エモモRUN」(3Dアバター × ゲーム × ライブ配信)もこれを利用しています。公式としてサポートされたといってもハマりどころがあったりするので今日はそのあたりを中心に話をします。

Unity as a Library

Unity as a Library は読んで字のごとく「Unity を(アプリケーションでなく)ライブラリとしてつかう」方法です。Mirrativ がアバター機能を最初にリリースした2018年時点では、ググっても情報量皆無の認知度でしたが、今はそれなりにヒットする感じで1ミリずつ広がりを見せているんじゃないかと思います。

公式の説明から引用すると

Unity では、ランタイムライブラリの読み込み、アクティベーション、アンロードの方法とタイミングをネイティブアプリケーション内で管理するための制御機能を用意しています。その上、モバイルアプリの構築プロセスはほぼ同じです。Unity では iOS Xcode と Android Gradle のプロジェクトを制作できます。

もともと Unity は昔から、エンジン部分をライブラリとしてアプリケーション本体から切り離すような構成をしていました。具体的に Android では、エンジンのエントリーは libmain.so 、ビューとして Surface View (本体はVulkanあるいはGLSL)、ラッパーとしての UnityPlayerextends FrameLayout)があり、これを使うためのアプリケーションとして MainActivity がある、という構成です。

前回記事(Unity 2018.2)時点では、UnityPlayerを Unity が用意する MainActivity から切り離して使いました。ビルドという視点では、もともとアプリ用に準備されたプロジェクトをライブラリ用の設定にして、ライブラリとしてビルドするということをやっています。

  • アプリ用プロジェクト ← これをライブラリ用に書き換えてビルドする

Unity 2018.3 以降の Unity as a Library では、Unity 上で iOS/Android ビルドをした時点で Unity エンジン部分がプロジェクトとして初めから分離しています。Android の場合には、アプリケーションのプロジェクトの中に unityLibrary というサブプロジェクトが出力され、アプリのプロジェクトがこの unityLibrary に依存する構成になっています。このため unityLibrary をそのままビルドすれば他プロジェクトで利用するための .aar が取得できます。

  • アプリ用プロジェクト
    • ライブラリ用プロジェクト ← これをビルドする

出力されたプロジェクトをそのままネイティブ側のプロジェクトに組み込んでもよいですが、Mirrativ では一度ライブラリ(iOS の場合は .framework)としてビルドしています。

フレームワークのビルド(2020版)

そのままビルドすればいいといったものの、そのままビルドできません。。いくつかの hack を入れます。

iOS

Mirrativ では次の3つの処理を行っています。

  1. Xcodeプロジェクトの修正
  2. Info.plistの修正
  3. ネイティブコードの修正

すべてポストプロセスで処理するようにしています。コードの一部を抜粋すると

    public void OnPostprocessBuild(BuildReport report)
    {
        var outputPath = summary.outputPath;
        var overridePath = Application.dataPath + "/../Framework/iOS/build";
        EditProject(outputPath); // 1
        EditPList(outputPath); // 2
        Utility.RSync(overridePath, outputPath); // 3
    }

Utility.RSyncrsync -av overridePath outputPath と同じ処理を行うメソッドで、overridePath 以下にある全ファイルを outputPath 以下のファイルに上書きします。

Xcodeプロジェクトの修正は必須の処理になります。

    static void EditProject(string outputPath)
    {
        var projectPath = outputPath + "/Unity-iPhone.xcodeproj/project.pbxproj";

        var pbx = new PBXProject();
        pbx.ReadFromFile(projectPath);

        // Get UnityFramework Target
        var guidTarget = pbx.GetUnityFrameworkTargetGuid();

        // Add Public Header
        var guidHeader = pbx.FindFileGuidByProjectPath("Libraries/Plugins/iOS/UnityPlayerToIOS.h");
        pbx.AddPublicHeaderToBuild(guidTarget, guidHeader);

        // Add Data to Resources Build Phase.
        var guidData = pbx.FindFileGuidByProjectPath("Data");
        var guidResPhase = pbx.GetResourcesBuildPhaseByTarget(guidTarget);
        pbx.AddFileToBuildSection(guidTarget, guidResPhase, guidData);

        // Add BITCODE_GENERATION_MODE
        pbx.SetBuildProperty(guidTarget, "BITCODE_GENERATION_MODE", "bitcode");

        pbx.WriteToFile(projectPath);
    }

Unity が出力する Xcode のプロジェクトにはアプリ用の Target とフレームワーク用の Target が含まれます。フレームワーク用の Target に対して次の3つを行います。

  • iOS 用プラグインをプロジェクトに含める
  • Data(バンドルされるリソース郡)をプロジェクトに含める
  • bitcode を生成するようにする

この中で Data フォルダをリソースに指定するのは必須で、これがないと Unity が正常に動きません。Data フォルダはアプリ用 Target に含まれますが、フレームワーク用の Target には含まれないため、これを追加する処理を行います。プラグインと bitcode の対応は必須ではありませんが、Mirrativ では両方とも使用しているためこれを入れています。

Info.plist の修正は optional な処理になります。

    static void EditPList(string outputPath)
    {
        var plistPath = outputPath + "/UnityFramework/Info.plist";

        var plist = new PlistDocument();
        plist.ReadFromFile(plistPath);

        var root = plist.root;
        root.SetString("CFBundleShortVersionString", Application.version);

        plist.WriteToFile(plistPath);
    }

バージョンをフレームワークに入れています。Unity エディタ上で指定するバージョンはアプリの Info.plist に書かれますが、フレームワークの Info.plist には書かれないためこの処理を入れています。

ネイティブコードの修正は optional な処理になります。 Xcode が出力するコードを適当に書き変えたいときに Utility.RSync を利用して書き換えます。例えば、Mirrativ では UnityFramework.h とその周辺のファイルを書き換えていて

__attribute__ ((visibility("default")))
@interface UnityFramework : NSObject
{
}

...

- (void)setAudioSessionActiveUnsafe:(bool)active;
@end

main.mm で

- (void)setAudioSessionActiveUnsafe:(bool)active
{
    UnitySetAudioSessionActive(active ? 1 : 0);
}

という風にしています(この例だと絶対に必要というわけではありませんが。。)。

Android

ライブラリビルド用にポストプロセスを用意します。コードの一部を抜粋すると

    public void OnPostprocessBuild(BuildReport report)
    {
        var outputPath = summary.outputPath + "/unityLibrary";
        var overridePath = Application.dataPath + "/../Framework/Android/unityLibrary";

        ProcessorUtility.Rsync(overridePath, outputPath);
    }

Mirrativでは次のファイルを書き換えています。

  • unityLibrary
    • build.gradle
    • src
      • main
        • AndroidManifest.xml
        • jniLibs
          • x86
            • libmain.so
        • res
          • values
            • ids.xml
            • strings.xml

Unity には AndroidManifest.xml を上書きする仕組みがありますが、ライブラリ用には動いてくれないためポストプロセスで上書きします。

AndroidManifest.xml から application タグを消します。

<?xml version="1.0" encoding="utf-8"?>
<!-- GENERATED BY UNITY. REMOVE THIS COMMENT TO PREVENT OVERWRITING WHEN EXPORTING AGAIN-->
<manifest xmlns:android="http://schemas.android.com/apk/res/android" package="com.unity3d.player" xmlns:tools="http://schemas.android.com/tools">
  <uses-feature android:glEsVersion="0x00020000" />
  <uses-permission android:name="android.permission.INTERNET" />
  <uses-permission android:name="android.permission.CHANGE_WIFI_MULTICAST_STATE" />
  <uses-feature android:name="android.hardware.touchscreen" android:required="false" />
  <uses-feature android:name="android.hardware.touchscreen.multitouch" android:required="false" />
  <uses-feature android:name="android.hardware.touchscreen.multitouch.distinct" android:required="false" />
</manifest>

さらに UnityPlayer

    private static String a(Context var0) {
        return var0.getResources().getString(var0.getResources().getIdentifier("game_view_content_description", "string", var0.getPackageName()));
    }

というようにリソースにアクセスしているため、アプリのプロジェクトに含まれる strings.xml をライブラリに含むようにします。

<string name="game_view_content_description">Game view</string>

また必須の処理ではありませんが、x86 用の libmain.so を用意しています。UnityPlayer は static initializer で libmain.so を読み込みますが、Unity は x86 の端末(たとえばエミュレータ)をサポートしないため(libmain.soがないため)クラッシュを起こします。

    static {
        (new m()).a();

        try {
            System.loadLibrary("main");
        } catch (UnsatisfiedLinkError var1) {
            com.unity3d.player.g.Log(6, "Failed to load 'libmain.so', the application will terminate.");
            throw var1;
        }
    }

動作する x86 ビルドは用意できないしする必要もないので読み込めるだけのダミーの libmain.so を用意します。

フレームワークの利用

iOS

基本的には公式のサンプルコードを Swift で書き直すだけです。実際に使っているコードから一部抜粋します。

import UnityFramework

extension Unity {
    final class Framework {
        #if arch(i386) || arch(x86_64)
        public func load(argc: Int32, argv: UnsafeMutablePointer<UnsafeMutablePointer<Int8>?>!, launchOptions: [UIApplication.LaunchOptionsKey: Any]?) {
        }
        #else
        public func load(argc: Int32, argv: UnsafeMutablePointer<UnsafeMutablePointer<Int8>?>!, launchOptions: [UIApplication.LaunchOptionsKey: Any]?) {
            func unityFramewokLoad() -> UnityFramework? {
                let bundlePath = "\(Bundle.main.bundlePath)/Frameworks/UnityFramework.framework"
                let bundle = Bundle(path: bundlePath)
                if let bundle = bundle, !bundle.isLoaded {
                    bundle.load()
                }

                let ufw = bundle?.principalClass?.getInstance()
                if ufw?.appController() == nil {
                    var header = _mh_execute_header
                    ufw?.setExecuteHeader(&header)
                }
                return ufw
            }

            let ufw = unityFramewokLoad()
            ufw?.setDataBundleId("com.unity3d.framework")
            ufw?.runEmbedded(withArgc: argc, argv: argv, appLaunchOpts: launchOptions)
        }
        #endif
    }
}

シミュレータ用にダミーの関数を用意しています。

Android

こちらも同じく公式にサンプルがありますが、Mirrativ では OverrideUnityActivity を使わずに UnityPlayer を直接使っています。

class AnyUnityViewFragment : Fragment() {
    private val unityPlayer: UnityPlayer by inject()
}

UnityPlayer は子に SurfaceView をもつ FrameLayout ですが かなり問題児で 適当に扱うと割とクラッシュします。SurfaceView のサイズがなんらかの理由で変更されたときにフレームバッファを作り直す処理が走るため、Unity の処理がハングするのと、さらに処理が終わる前にサイズをさらに変更すると容易にクラッシュします。処理の完了を上手く拾えなかったため( onSurfaceChanged もあまり当てにならず、、)、アプリの方にサイズ変更を連発させないような処理を入れています。

おわりに

Unity as a Library を使うと Unity とネイティブのいいとこどりができるという側面もある一方制約も増えます。例えば、開発中のイテレーションを考えると、Unity ビルド → Xcode ビルド(Unity フレームワーク) → Xcode ビルド(iOS ビルド)となり単純にビルド時間が伸びます。また、アプリから利用する場合はアセットバンドルのビルドも考慮する必要が出てきます。

このような事情のため、Mirrativ の開発方針としては可能な限り Unity/iOS/Android が各々独立して動作可能になるように設計、運用しています。アセットフローという視点では、Unity 側では CI によってフレームワークをビルドし、アウトプット先として GitHub のリポジトリにフレームワークを push、iOS/Android 側のプロジェクトでは git submodule として扱う、という形で運用しています。

未解決の問題はそれなりにあって、例えばネイティブ/Unity間の通信と設計というトピックがあります。現状はネイティブ(iOS/Android)から Unity に情報を伝えるとき SendMessage を使って request を投げるような構成になっているのですが、iOS/Android のアプリ側はFluxなアーキテクチャになっているため、ネイティブ側としては state を Unity にわたして、ネイティブからは Unity が状態を持っていないように見える、、というのが良さげな設計かな、と考えています。今年もあと3ヶ月程度ですが、このあたりは年末までにやっつけていきたいですね。

We are hiring!

ミラティブでは ゲーム×ライブ配信のアプリを一緒に作ってくれる iOS/Android エンジニアを募集中です!meetup も開催しているため気軽にご参加ください!

www.mirrativ.co.jp

speakerdeck.com

MirrativのiOSアプリリリースを支える自動化技術

 こん○○は。エンジニアのshogo4405です。普段は、ミラティブで開発しながら、余暇にOSSのHaishinKit*1をつくっています。

はじめに

 MirrativのiOSアプリは、git-flow で開発を行なっています。git-flow や日々の開発を運用する中で、次のような考慮すべきタイミングがありました。今回は、これらを自動化した際の話をコード付き*2で紹介します。

  • ライブラリーのアップデート
  • releaseブランチ作成
  • tag付けの実施
  • releaseブランチのmasterへのマージとdevelopへのマージ

 なお、リリース頻度は、1週間に1回以上。毎週火曜日に通常版の申請を実施しています。手動で運用していた時には、文字通り、気を付け ながら運用していました。

週の業務の流れ

 MirrativのiOSチームの業務の流れと共に、曜日ベースで📝自動化した内容を紹介していきます。

月曜日

 ミラティブ社の週始めは、10:30に全体で集合する朝会から始まります。朝会は、当週の方針や社の方向性を共有する大事な会です。

📝ライブラリーの更新

 開発は、ライブラリーの更新から始まります。10:00の定時バッチで、自動的に更新を行っています。以下の作業を行ったPRが作成されて、朝会後にレビューをしてからマージをしています。

f:id:shogo4405:20200214192147p:plain

  1. bundleの更新
  2. CocoaPodsの更新
  3. Carthageの更新
  4. SwiftLintの自動実行
  5. ライセンスの更新
lane :update_dependencies do |options|
  date = Date.today.to_s # 現在日付を取得
  token = options[:token] || ENV["GITHUB_API_TOKEN"]
  branch_name = "feature/update-dependencies-" + date # branch名

  sh('cd ../ && find ./mirrorman -name "*.storyboard" -or -name "*.xib" | xargs -IFILE xcrun ibtool --upgrade FILE --write FILE')

  # bundleの更新 
  sh("cd ../ && bundle update")
  # CocoaPodsの更新
  sh("cd ../ && bundle exec pod update")
  # Carthageの更新
  sh("cd ../ && carthage update --platform iOS --use-ssh --no-use-binaries --cache-builds")
  # SwiftLintの自動実行
  sh("cd ../ && ./Pods/SwiftLint/swiftlint autocorrect")
  # ライセンスの更新 LicensePlist 感謝
  sh("cd ../ && ./Pods/LicensePlist/license-plist --output-path mirrorman/Settings.bundle --github-token #{token}")
  sh("git checkout -b #{branch_name}")

  git_add
  git_commit(
    path: "./",
    message: "定期のライブラリーの更新(#{date})"
  )

  push_to_git_remote(
    remote: "origin",
    local_branch: branch_name,
    remote_branch: branch_name,
    tags: false
  )

  create_pull_request(
    repo: "path_to/repo",
    title: "[定期] ライブラリーの更新(#{date})",
    head: branch_name,
    base: "develop",
    body: "定期のライブラリーの更新です"
  )

end

火曜日

 前週の金曜日に締めたソースコードを、AppStoreへ申請する日です。

📝 AppStoreへの定期アップロード

 月・火曜日では、前週に締めたアプリのリグレッションテストを行っています。このテストで確認した不具合を修正してAppStoreへ申請することになります。申請作業の短縮化のために、Bitrise上で、tag付けをフックとして、AppStoreへアップロードするようにしています。

 tag付け*3と同時に、AppStoreへアップロードすることにより、git-flow上でのtag付け忘れに役に立ちました f:id:shogo4405:20200214191623p:plain

desc "Releaseビルドを作成する"
lane :release do |options|
  v = get_info_plist_value(path: "./mirrorman/Supporting Files/mirrativ-prod-Info.plist", key: "CFBundleVersion")

  slack(
    message: "iOSのReleaseビルド(#{v})を作成中",
    payload: { "Build by": `whoami` },
    channel: "#github_mr-ios"
  )

  # build your iOS app
  gym(
    scheme: "mirrativ",
    configuration: "Release",
    include_bitcode: true,
    export_method: "app-store"
  )

  upload_to_testflight(
    skip_submission: true,
    skip_waiting_for_build_processing: true
  )

  slack(
    message: "iOSのReleaseビルド(#{v})をAppStoreにアップロードしました。",
    default_payloads: [],
    channel: "#github_mr-ios"
  )

  clear_derived_data()

end

📝 releaseブランチからmasterへのマージ作業

 GitHub上で、masterへマージすると同時に、developにもマージしています。現在は、別のスクリプトエラーで止まっています😭

 GitHub上のWebhookをトリガーで実現しています。Webhookの受け口側で、以下のようなRubyのコードを実行すれば master へマージ時と同時に、developへ戻すこと可能です。

octkit.merge("レポジトリー名", 'develop', pull_request['head']['ref'])

水曜日

 火曜日に、申請したアプリのリリース日です。

📝GitHubのリリースノートの作成

 リリース内容を後から見返すために、GitHubのリリース情報の更新を行います。AppStoreから届くメールをフックにして、リリース情報を更新しています。iOSチームではマイルストーン管理しており、リリース内容は、該当のマイルストーンからのプルリクエストのタイトルを元に作成しています。

f:id:shogo4405:20200214180926p:plain

desc 'リリースノートを作成する'
desc '    version: バージョン番号(フォーマットは、7.5.1)'
desc '    target: Slackのチャンネル名(デフォルトは、#bot_test)'
desc '    preview: ストア文言作成用の文言か否か(デフォルトは、false)'
desc '    code: githubのリリースノート更新に必要なコード. iOSだったら:7.5.1(7.5.1.0), Androidだったら:7.5.1(232)みたいな、()の部分'
desc "    ENV['GITHUB_API_TOKEN']: https://github.com/settings/tokens で取得してして Shell に定義しておいてください"
lane :release_note do |options|
  target = options[:target] || '#bot_test'
  version = options[:version] || ENV['VERSION']
  preview = options[:preview] || false
  code = options[:code] || ENV['CODE']

  token = ENV['GITHUB_API_TOKEN']
  UI.user_error!('Required version and token. ex: fastlane release_note version:7.5.1') unless version || token

  if target == 'github'

    value = github_release_note(
      version: version,
      format: 'md',
      repository_name: ENV['GITHUB_PATH']
    )

    set_github_release(
      repository_name: ENV['GITHUB_PATH'],
      name: version,
      tag_name: "#{version}(#{code})",
      description: value,
      commitish: 'master'
    )

    github_close_milestone(
      repository_name: ENV['GITHUB_PATH'],
      title: version
    )

  else

    value = github_release_note(
      version: version,
      repository_name: ENV['GITHUB_PATH']
    )

    pretext = preview ?
      "#{ENV['NAME']}(#{version})のリリースが近づいてきたよ!ストア文言作成お願いします。 " :
      "#{ENV['NAME']}(#{version})を審査にだすよ!リリース内容は以下の通りだよ! "

    slack(
      default_payloads: [],
      channel: target,
      attachment_properties: {
        text: [value].join("\n"),
        pretext: pretext,
        title: ":notebook: リリースノート(#{version})",
        mrkdwn_in: ['text']
      }
    )
  end
end

github_release_note

 GitHubから該当マイルストーンのPRからタイトルを抽出するために、fastlaneにて、次のような、カスタムアクションを作成しています。

module Fastlane
  module Actions
    module SharedValues
      GITHUB_RELEASE_NOTE_CUSTOM_VALUE = :GITHUB_RELEASE_NOTE_CUSTOM_VALUE
    end

    class GithubReleaseNoteAction < Action
      def self.run(params)
        version = params[:version]
        repository_name = params[:repository_name]
        @client = Octokit::Client.new(access_token: ENV['GITHUB_API_TOKEN'])
        params[:format] == 'md' ? output_md(repository_name, version) : output_slack(repository_name, version)
      end

      #####################################################
      # @!group Documentation
      #####################################################

      def self.description
        'A short description with <= 80 characters of what this action does'
      end

      def self.details
        'You can use this action to do cool things...'
      end

      def self.available_options
        [
          FastlaneCore::ConfigItem.new(key: :version,
                                       env_name: 'FL_GITHUB_RELEASE_NOTE_API_TOKEN',
                                       description: 'API Token for GithubReleaseNoteAction',
                                       verify_block: proc do |value|
                                         UI.user_error!("No API token for GithubReleaseNoteAction given, pass using `api_token: 'token'`") unless value && !value.empty?
                                       end),
          FastlaneCore::ConfigItem.new(key: :format,
                                       env_name: 'FL_GITHUB_RELEASE_NOTE_FORMAT',
                                       description: 'Create a development certificate instead of a distribution one',
                                       is_string: false,
                                       default_value: 'slack'),
          FastlaneCore::ConfigItem.new(key: :repository_name,
                                       env_name: 'FL_GITHUB_RELEASE_NOTE_GITHUB_PATH',
                                       description: 'Create a development certificate instead of a distribution one',
                                       is_string: true,
                                       default_value: '')
        ]
      end

      def self.output
        [
        ]
      end

      def self.return_value
        # If your method provides a return value, you can describe here what it does
      end

      def self.authors
        ['shogo4405']
      end

      def self.is_supported?(platform)
        platform == :ios
      end

      def self.milestone(repo, name)
        number = @client.list_milestones(repo).select do |milestone|
          milestone.title == name
        end.first.number
        @client.list_issues(repo, milestone: number, state: 'all')
      end

      def self.group(issue)
        return 'プロダクト' if issue.title.start_with?('[MIP-')
        return 'CS' if issue.title.start_with?('[CS-')
        return '不具合管理' if issue.title.start_with?('[MIR-')
        '開発'
      end

      def self.issues(repo, name)
        result = {}
        issues = milestone(repo, name)

        issues.each do |issue|
          result[group(issue)] = [] unless result[group(issue)].instance_of?(Array)
          result[group(issue)].push(issue)
        end

        result
      end

      def self.output_md(repo, name)
        message = ''
        issues = issues(repo, name)
        issues.sort.each do |key, value|
          message += "## #{key}\n"
          i = 1
          value.each do |issue|
            title = issue.title
                         .sub(/\[(MIP-\d+)\]/, '[[\1]](https://mirrativ.backlog.com/view/\1)')
                         .sub(/\[(CS-\d+)\]/, '[[\1]](https://mirrativ.backlog.com/view/\1)')
                         .sub(/\[(MIR-\d+)\]/, '[[\1]](https://mirrativ.atlassian.net/browse/\1)')
            message += "#{i}. #{title} (##{issue.number})\n"
            i += 1
          end
          message += "\n"
        end
        message
      end

      def self.output_slack(repo, name)
        message = ''
        issues = issues(repo, name)
        issues.sort.each do |key, value|
          message += ":mira1: *#{key}*\n"
          i = 1
          value.each do |issue|
            title = issue.title
                         .sub(/\[(MIP-\d+)\]/, '<https://mirrativ.backlog.com/view/\1|[\1]>')
                         .sub(/\[(CS-\d+)\]/, '<https://mirrativ.backlog.com/view/\1|[\1]>')
                         .sub(/\[(MIR-\d+)\]/, '<https://mirrativ.atlassian.net/browse/\1|[\1]>')
            message += "#{i}. #{title} (<#{issue.html_url}|##{issue.number}>)\n"
            i += 1
          end
          message += "\n"
        end
        message
      end
    end
  end
end

金曜日

 お疲れ様でした。週終わりの日です。ミラティブ社では、金曜日の18:30開始の夕会でその週の振り返りを全体で共有しています。

 金曜日までに、developへマージしたコードをコードフリーズして翌週にリリースする運用を行っています。

日曜日

 金曜日に締めたコードからgit-flowのreleaseブランチを作成する日です。

📝リリースブランチの作成

 毎時18:00に、自動的にreleaseブランチを作成しています。また、Slack上に、GitHubのPR一覧を投稿しています。この投稿情報は、AppStoreへのアップデート文言作成に利用したり、今週リリースする内容のサマリーとして社内全体で共有しています。

f:id:shogo4405:20200214060601p:plain

lane :release_branch do |options|
  token = options[:token] || ENV["GITHUB_API_TOKEN"]
  UI.user_error!("Required release token. ex: fastlane release_branch version:7.5.1 token:${github_api_token}") unless token

  unless options[:version]
    github = Octokit::Client.new access_token: token
    milestone = github.milestones("path_to/repo").sort { |a, b| a["due_on"] <=> b["due_on"] }.first
    UI.user_error!("直近リリースはないようです") if 5 < (milestone.due_on.to_date - Date.today).to_i
    UI.user_error!("マイルストーンが見つからないです") unless milestone
    options[:version] = milestone.title
  end

  branch = "release/#{options[:version]}"

  sh("git checkout develop && git pull origin develop")
  sh("git checkout -b #{branch}")

  version(v: options[:version] + ".0")

  File.open(".timestamp", "w") do |f|
    f.puts(Time.now.to_s)
  end

  short_version = get_info_plist_value(path: "./mirrorman/Supporting Files/mirrativ-prod-Info.plist", key: "CFBundleShortVersionString")

  # release_note作成のlane
  release_note(
    target: "#release_note",
    version: short_version,
    token: token,
    preview: true
  )

  git_commit(path: "*", message: "Bump to #{options[:version]}")
  add_git_tag(tag: "#{short_version}(#{short_version}.0)")

  push_to_git_remote

  create_pull_request(
    repo: "path_to/repo",
    title: "v#{short_version}",
    body: "release v#{short_version}"
  )

  deliver(
    submit_for_review: false,
    skip_binary_upload: true,
    skip_screenshots: true,
    force: true
  )
end

自動化によって得られたもの

 年間7人日程度*4の工数の削減に寄与と推定しています。2019年の実績として57回のリリースを行いました。1回のリリースに関わる作業として週あたり概算累計1時間程度と計算しました。

 また、ついうっかり作業を忘れてしまって、同僚につつかれるといったことが無くなりました。 リリースに関する一連の作業を円滑に行うという心理面のプレッシャーが減り、結果としてコードに集中して向き合う時間が増えました。

We are hiring!

 ミラティブでは、このように開発フローの効率化なども得意な、エンジニアを募集しています!副業や体験入社も行っておりますので是非遊びに来てください。

www.mirrativ.co.jp

 うちの会社では、こういうことをやっているぞーということをはてブのコメントで残してもらえると嬉しいです!

*1:iOS向けのRTMPストリーミングライブラリー

*2:こちらのコードは、ご自由にお使いください

*3:git-flow上では、masterブランチへマージした時点でtag付けを行いますが、releaseブランチへtag付けを行う運用を行なっています。

*4:57 * 1 = 57時間 = 約7人日

【iOS】ReactorKitの導入とアプリのFlux化

こんにちは。 iOS エンジニアの千吉良(ちぎら)です。

今回は iOS アプリの設計をサポートするフレームワークとして ReactorKit を導入した話をします。

動機

Mirrativ の iOS アプリは元々「1ViewControllerあたり1Storyboard」という構成で作られていました。

ViewController内の実装に関しては特に実装方針を定めていませんでしたが、多くの方が実装に関わっていくにつれて、実装方針が決まっていないことは、新しく開発に参加される方の戸惑いや、特殊なケースに特化した独自の設計が導入されていく危険性につながるのではないかという懸念が出てきました。メインの課題はそれらの懸念を解消することなのですが、設計を決めるにあたって、いくつかの前提がありました。

  • 機能開発を並行で進めたいので、部分的に適用できるものにしたい
  • モデル層は型安全な形式に移行しているので、モデル層の構成に密に依存しないようにしたい
  • AndroidにFluxを導入しそうな機運があり、思想は近いものにしたい

Clean Architecture や MVVM, VIPER など様々なアーキテクチャがありますが、上記の前提と懸念の解消のために、ReactorKit を設計をサポートするフレームワークとして選びました。

ReactorKit とは

ReactorKit

ReactorKit is a framework for a reactive and unidirectional Swift application architecture. This repository introduces the basic concept of ReactorKit and describes how to build an application using ReactorKit.

...

ReactorKit is a combination of Flux and Reactive Programming.

上記の README から引用した文章から分かるように、ReactorKit はリアクティブかつ単一方向のデータフローの為のフレームワークです。Design Goal として、以下の3つが挙げられています。

  • Testability
  • Start Small
  • Less Typing

Small Start, Less Typing は、機能開発と並行で設計を導入していく上で魅力的な要素でした。特に既存のプロダクトに新たに設計を導入する場合は、適度な記述量で精神的な負担が少ないことも、無理なく開発を進めていく上で大事な要素だと思います。

以下に ReactorKit のコンセプトの概要図を引用します。

f:id:naru-jpn:20200131142801p:plain
Basic Concept of ReactorKit

ReactorKit は大きく View と、対となる Reactor という層から構成されます。

図に書かれている View は、プログラム上では UIViewControllerUITableViewCell に相当する単位です。既存のプログラムが「1ViewControllerあたり1Storyboard」という粒度で構成されている為、その粒度も変更する必要はなく、新しく作る ViewController から ReactorKit に準拠していけばいいという非常にお手軽な状況を作ることができました。

ActionState は、ViewReactor のコミュニケーションの為に使用される要素ですが、それらは Reactor ごとに定義することになるので、既存のモデル層の作りにそれほど依存せずに実装していくことができます。

つまり、上に挙げた

  • 機能開発を並行で進めたいので、部分的に適用できるものにしたい
  • モデル層は型安全な形式に移行しているので、モデル層の構成に密に依存しないようにしたい
  • AndroidにFluxを導入しそうな機運があり、思想は近いものにしたい

を全て満たしてくれます。

ReactorKit と Flux

f:id:naru-jpn:20200131145826p:plain
Communication between Reactor and View

ReactorKit には Reactor という UI とは独立した層が存在しています。 ViewAction を発行し、 Reactor が内部で処理をして State を変化させ、 State の変化を View が受け取るという流れをフレームワークでサポートすることで、単一方向のデータフローを実現しています。

ActionMutation は enum で定義され、簡素で扱いやすい形式で表現ができます。下記のコードは README にあるサンプルコードから持ってきたものですが、シンプルな定義のReactorでうまく単一方向のデータフローがサポートされていることがわかると思います。

class ProfileViewReactor: Reactor {
  // Viewから渡されるActionはenumで定義する. Associated Valueをパラメータとして利用している.
  enum Action {
    case refreshFollowingStatus(Int)
    case follow(Int)
  }

  // Stateを変化させるMutationもenumで定義する.
  enum Mutation {
    case setFollowing(Bool)
  }

  // View側でstateの変化に応じてUIを更新している.
  struct State {
    var isFollowing: Bool = false
  }

  let initialState: State = State()

  // Action → Mutation
  func mutate(action: Action) -> Observable<Mutation> {
    switch action {
    case let .refreshFollowingStatus(userID): // receive an action
      return UserAPI.isFollowing(userID) // create an API stream
        .map { (isFollowing: Bool) -> Mutation in
          return Mutation.setFollowing(isFollowing) // convert to Mutation stream
      }
  ...
  }

  // Mutation → State
  func reduce(state: State, mutation: Mutation) -> State {
    var state = state // create a copy of the old state
    switch mutation {
    case let .setFollowing(isFollowing):
      state.isFollowing = isFollowing // manipulate the state, creating a new state
      return state // return the new state
    }
  }
}

チームへの共有と浸透

新しい設計をいきなり導入することは難しいので、3ヶ月の猶予を持って「新規で作成する画面はすべて新しい設計に準拠している」ことを目指しました。僕自身もReactorKitを実務で使用するのは初めてだったので、まずは既存のプロジェクトに導入をしてリファレンス実装を作るところからはじめました。浸透までは、大まかには以下のような流れで行いました。

  • 1ヶ月目
    • 簡単な画面をReactorKitの新設計に書き換え、実装する際の参考にしてもらう為のリファレンス実装とする
  • 2ヶ月目
    • リファレンス実装のコードを実例として添えながら、新設計の思想やルールなどを簡単にまとめたドキュメントを作成する
  • 3ヶ月目
    • 啓蒙

結果としては、3ヶ月経過時点で「新規で作成する画面はすべて新しい設計に準拠している」状態になり、新しく関わっていただく方にも迷いなく設計方針を伝えられる環境ができました。

また、XcodeのテンプレートにReactorKitの為のテンプレートを追加して、新規クラス作成時の負担を軽減しています。

f:id:naru-jpn:20200204214918p:plain
1. ReactorKit用のテンプレートを選択して

f:id:naru-jpn:20200204214945p:plain
2. 名前を入力すると

f:id:naru-jpn:20200204215330p:plain
3. ViewControllerとReactorクラスが生成されます

頭を使わない作業をテンプレートにすることで少しだけ楽ができるようになりました。

まとめ

今回は、MirrativのiOSアプリにReactorKitを導入したという話をしました。これまではViewControllerにすべてのコードが書かれていて非常に自由度が大きく、人によって実装に差があり、実装方針もその都度考えていましたが、方針が定まったことで実装やコミュニケーションのコストを減らすことができました。今後もより楽が出るように改善を進めていきたいと思います。

We are hiring!

Mirrativ では一緒に開発してくれるエンジニアを募集しています!

体験入社や副業も大歓迎なのでお気軽にどうぞ!

www.mirrativ.co.jp

2/20 にCTOが登壇するミートアップも開催するそうです!お気軽に遊びにきてください!

https://meety.net/group_talks/158

ミラティブ エンジニアチーム四季報(創刊号)

こんにちは Mirrativ CTOの夏です。

現在、ミラティブでは事業部単位でチームや目標を管理しており、エンジニアが所属するチームとして以下の6つがあります。今回はこのうち、エンジニアチームについて、2019年度に行ってきた取り組みの振り返りをしたいと思います。

  • ライブプラットフォームチーム
    • ユーザの定着を追う
  • マーケ連携チーム
    • ユーザの新規獲得を追う
  • エモモチーム
    • 3Dアバターであるエモモを使った新体験の創出・基礎体験の向上を追う
  • ストリーミング改善チーム
    • モバイル端末でのライブストリーミングの配信・視聴の品質改善を追う
  • インフラチーム
    • クラウド上での安定したインフラ基盤の設計・構築を追う
  • エンジニアチーム
    • お問い合わせ調査、不具合・障害の再発防止、開発体験の向上を追う
  • AI技術部
    • コミュニティやストリーミングとAI活用の可能性を追う

f:id:hottestseason:20200124110555p:plain
毎週定例で振り返りを行っており、Confluenceに議事録を残しています

4~6月

全プラットフォームで負債の洗い出し

当時、まだAndroid4やiOS10系のサポートを行っており、シェアが少ない古いOSのために開発工数・QA工数が使われていました。そこで、コミュニティチームを巻き込んで、終了するとどういうことが起きるのか含めて、上手くユーザに説明できるように、コミュニケーション方法・時期について練りながら、古いOSのサポートを終了するなどの対応を行いました。

また、会社設立当初は、各プラットフォームそれぞれ1人で開発している状態で、短期的なリリーススケジュールを優先してきた結果、状態管理が複雑化し、新規機能追加時やバグフィックス時に該当箇所以外の理解や暗黙的な知識が求められていました。

その結果、副業や業務委託の方が入っても、なかなか生産性がスケールしなかったり、リモートで稼働している人にとって、キャッチアップに時間がかかる状態が続いていました。

そこで、見通しの悪さの原因の1つである、最強のBaseクラスの再設計を行ったり、不要になったライブラリの廃止(AndroidAnnotationなど)、ディレクトリ構造の見直し、Fluxの導入、分析ログの送信機構の改善、Lintの改善などを行ってきました。

tech.mirrativ.stream

これにより、開発体制がスケールする仕組みに向き合う土壌ができ、開発体験の向上戦略が整ったかなと思います。

リリースフローの整備

また、今まで、開発が完了した修正からアドホックに検証・リリース作業を行ってきたのですが、QAの日程調整やリリース作業の煩雑さを抑えつつ、毎週アプリの更新を行えるようにするために、以下のようなリリースフローを整備しました。

  1. 機能改修などのPRは基本的に金曜日までにQA済みの状態でdevelopへmerge
  2. 日曜日にbotにより自動でリリースブランチとリリースビルドを作成
  3. 月曜日・火曜日に本番環境でリグレッションテスト
  4. 火曜日の夕方にアプリを申請し、審査が通り次第(最速で水曜日の朝)にリリース

7~9月

🚑119番の開始

4~6月を通して、開発体験の向上のためのチームづくりは出来たものの、反省点としては、PMの熱量に負けてプロダクト側の開発を優先してしまい、なかなか開発体験向上のための時間をとれずにいました。

そこで7月からは新たに119番なるものを組成し、エンジニアが毎週日替わりで担当し、その日の担当者はプロダクト開発を行わない曜日としました。(カレンダー・ガントチャート上で抑えてしまいます)

f:id:hottestseason:20200124112944p:plain

行う業務としては

  1. お問い合わせ1次調査 & 対応
  2. エラー、クラッシュ、障害、その他不具合対応
  3. パフォーマンス改善、障害再発防止対応
  4. エンジニア以外からの細かい依頼タスク
  5. PRレビュー、開発体験向上、フルスタック化、その他

などがあります。

週1日プロダクト開発できないとリリースサイクルが遅くなる恐れがありましたが、もともと属人的に依頼されていたタスクを当番制にすることで、残りの4日間はメリハリを持ってプロダクト開発に専念できたり、普段扱わない領域のコードを触る癖ができたかなと思っています。

特に、お問い合わせ対応に関しては、Backlogで管理することで、1営業日以内に対応完了できているかどうかを意識し、お問い合わせが放置されない体制作りや、そもそもお問い合わせが来ない(= ユーザが困らない)ために、どう再発防止すべきか、どうアプリのUXを実現すべきかなどをエンジニア自身が意識できるようになったかなと思っています。

新アーキテクチャのリファレンス実装の整備

前期での改善をさらに進め、7~9月はiOS・Android側はFlux化、サーバ側はAPI仕様のOpenAPI(Swagger)化とClean Architecture化を進めてきました。

もともとミラティブではMarkdown形式でAPI仕様を記述できるAPI Blueprintを採用しておりました。しかし、API仕様を形骸化させず、実装との差分をゼロに維持するために、自動テスト時や開発時には自動的にパラメータやレスポンスのValidationを行おうとすると、MarkdownよりもJSONやYAML形式で記述できるOpenAPIの方が仕組み化しやすいと思い、API仕様をOpenAPI化することを決意しました。

現在では移行が済んでいないブラックリスト上APIのエンドポイント以外は全て、仕様と実装に差異があると自動テスト時や開発時にエラーになるようにしています。 (本番環境では計算コストを意識し、Validationはオフにしている)

iOS・AndroidのFlux化に関しては 千吉良morizooo から、サーバ側のClean Architecture化に関しては、次回、僕の方からまたこのブログで共有したいと思います。

10~12月

リファレンス準拠100%でレビュー工数削減

7~9月の改善でiOS・AndroidのFlux化のリファレンス実装が揃い、副業・業務委託の方々も含めた全員に共有できたこともあり、10~12月はiOSとAndroidのPRはほぼ全てFlux準拠することが出来ました。これに対し、サーバ側のClean Architecture化は、リファレンス実装の整備が12月までずれ込んだこともあり、PRの準拠100%は2020年1月以降の課題となっています。(そもそもサーバ側は自動テストの書きやすさも手伝ってか、レビュー体制が上手く整備されておらず、こちらもまだ課題として残っています)

f:id:hottestseason:20200124122658p:plain
CleanArchitecture移行のためのドキュメント

障害の再発防止

ミラティブではMVP(Minimum Viable Product)を意識した開発を行っており、できるだけ早くユーザに触ってもらってフィードバックをもらうことを大事にしています。そのため、リリース後に時間を置いてから、開発当初に想定していた以上のアクセス数やデータ量になり、障害につながるケースも存在します。

もちろん、最初からスケーラビリティを意識した開発ができるに越したことはありませんが、綿密に流量を想定し、負荷試験を行って、リリース速度を下げるよりか、開発の練度を上げつつ、障害につながる前兆に早めに気づき、放置しない体制をつくろうと思っています。とくに、障害が起きてしまうと、ユーザの体験が悪化するだけでなく、調査・対応・補填含めてエンジニアのリソースがかなり消費されるため、障害の再発防止がエンジニア組織として最優先となっております。

そこで10月からは、以下のような領域毎にそれぞれ担当者をアサインし、彼らに優先順位を付けてタスク管理をしてもらうようにしました。(実作業は担当者が119番の日を使って行いつつ、時と場合に応じて他のエンジニアへアサインします)

  • 障害の再発防止
    • 障害対応した人に振り返りのドキュメントを1週間以内にまとめてもらい、ナレッジを共有することで、チームの練度を上げていく
    • 今後joinする方のためにも、そもそも障害が起きない・前兆を早めに気付ける仕組みづくりをタスクとして優先順位付けしダッシュボード化
  • DB
    • 最重要コンポーネントであり、ここの負荷が上がると、Webも詰まり始めるので、優先順位が高い
    • tcpdumpとpt-query-digestを用いることで、MySQLへの負荷が支配的なSQLを洗い出し、そこから優先順位付けしてダッシュボード化
  • Web
    • UXの改善やインフラコスト💵の削減に貢献
    • 各エンドポイントのパフォーマンスレポート(実行時間やメモリ使用量)から、優先順位付けしてダッシュボード化
  • エラー
    • 既存のエラーが放置され続けると、障害の前兆となるようなエラーが見逃されるため、発見次第潰す体制づくり
    • 新規のエラーが発生した際に、原因となる修正を特定し、担当者に連絡

最後に

何か新しい技術を紹介できているわけではありませんが、僕の方からは当分このような形で、定期的にミラティブでの地に足がついた運用と改善と悩みを共有していこうと思うので、興味がある方や、うちはこうやってるよみたいな話があれば、SNSやはてブにコメントを残したり、オフィスに遊びに来て語らいましょう。2月20日(木)20時〜ミートアップ実施しますので、ご興味のある方は是非お待ちしております!

meety.net

ミラティブでは体験入社や副業も大歓迎なので、興味ある方はぜひ宜しくお願いします!!www.mirrativ.co.jp speakerdeck.com

f:id:hottestseason:20200124175620p:plain

追伸

「CTOからの採用候補者様への手紙」の表紙を、我らがウルトラデザイナのえいじさん に入れて頂きました。こうなると一気に読みたくなりますね。えいじさん、表紙以外も何卒宜しくお願いします🙏 (テックブログ側からも催促していくスタイル)

f:id:hottestseason:20200123214246j:plain