1. はじめに
Cloud Spanner はフルマネージドで水平スケール可能なグローバルに分散されたリレーショナル データベース サービスで、パフォーマンスと高可用性を損なうことなく ACID トランザクションと SQL セマンティクスを提供します。
これらの機能により、Spanner はグローバルなプレーヤー ベースを有効にしたいゲームや、データの整合性を重視するゲームのアーキテクチャに最適です。
このラボでは、リージョン Spanner データベースとやり取りする 2 つの Go サービスを作成し、プレーヤーが登録してプレイを開始できるようにします。
次に、Python ロード フレームワーク Locust.io を活用してデータを生成し、プレーヤーの登録とゲームのプレイをシミュレートします。次に、Spanner にクエリを実行して、プレイしているプレーヤーの数と、プレーヤーの勝利数とプレイ数の統計情報を取得します。
最後に、このラボで作成したリソースをクリーンアップします。
作成するアプリの概要
このラボでは、次の作業を行います。
- Spanner インスタンスの作成
- Go で記述された Profile サービスをデプロイして、プレーヤーの登録を処理する
- Go で記述されたマッチメイキング サービスをデプロイして、プレーヤーをゲームに割り当て、勝者を決定し、プレーヤーのゲーム統計情報を更新します。
学習内容
- Cloud Spanner インスタンスを設定する方法
- ゲーム データベースとスキーマの作成方法
- Cloud Spanner と連携する Go アプリをデプロイする方法
- Locust を使用してデータを生成する方法
- Cloud Spanner でデータをクエリして、ゲームとプレーヤーに関する質問に回答する方法。
必要なもの
2. 設定と要件
プロジェクトを作成する
Google アカウント（Gmail または Google Apps）をお持ちでない場合は、1 つ作成する必要があります。Google Cloud Platform のコンソール（console.cloud.google.com）にログインし、新しいプロジェクトを作成します。
すでにプロジェクトが存在する場合は、コンソールの左上にあるプロジェクト選択プルダウン メニューをクリックします。
表示されたダイアログで [NEW PROJECT] ボタンをクリックして、新しいプロジェクトを作成します。
まだプロジェクトが存在しない場合は、次のような最初のプロジェクトを作成するためのダイアログが表示されます。
続いて表示されるプロジェクト作成ダイアログでは、新しいプロジェクトの詳細を入力できます。
プロジェクト ID を忘れないようにしてください。プロジェクト ID は、すべての Google Cloud プロジェクトを通じて一意の名前にする必要があります（上記の名前はすでに使用されているため使用できません）。以降、この Codelab では PROJECT_ID と呼びます。
次に、Google Cloud リソースを使用し、Cloud Spanner API を有効にするために、Developers Console で課金を有効にする必要があります。
この Codelab の操作をすべて行っても、費用は数ドル程度です。ただし、その他のリソースを使いたい場合や、実行したままにしておきたいステップがある場合は、追加コストがかかる可能性があります（このドキュメントの最後にある「クリーンアップ」セクションをご覧ください）。Google Cloud Spanner の料金については、こちらをご覧ください。
Google Cloud Platform の新規ユーザーの皆さんには、$300 の無料トライアルをご利用いただけます。その場合は、この Codelab を完全に無料でご利用いただけます。
Google Cloud Shell の設定
Google Cloud と Spanner はノートパソコンからリモートで操作でき、この Codelab では、Google Cloud Shell（Cloud 上で動作するコマンドライン環境）を使用します。
この Debian ベースの仮想マシンには、必要な開発ツールがすべて用意されています。仮想マシンは Google Cloud で稼働し、永続的なホーム ディレクトリが 5 GB 用意されているため、ネットワークのパフォーマンスと認証が大幅に向上しています。つまり、この Codelab に必要なのはブラウザだけです（Chromebook でも動作します）。
- Cloud Console から Cloud Shell を有効にするには、[Cloud Shell をアクティブにする]
をクリックします（環境のプロビジョニングと接続に若干時間を要します）。
Cloud Shell に接続すると、すでに認証は完了しており、プロジェクトに各自の PROJECT_ID が設定されています。
gcloud auth list
コマンド出力
Credentialed accounts:
- <myaccount>@<mydomain>.com (active)
gcloud config list project
コマンド出力
[core]
project = <PROJECT_ID>
なんらかの理由でプロジェクトが設定されていない場合は、次のコマンドを実行します。
gcloud config set project <PROJECT_ID>
PROJECT_ID が見つからない場合は、設定手順で使用した ID を確認するか、Cloud Console ダッシュボードで検索します。
Cloud Shell では、デフォルトで環境変数もいくつか設定されます。これらの変数は、以降のコマンドを実行する際に有用なものです。
echo $GOOGLE_CLOUD_PROJECT
コマンド出力
<PROJECT_ID>
コードをダウンロードする
Cloud Shell で、このラボのコードをダウンロードできます。これは v0.1.0 リリースに基づいているため、そのタグをチェックアウトします。
git clone https://github.com/cloudspannerecosystem/spanner-gaming-sample.git
cd spanner-gaming-sample/
# Check out v0.1.0 release
git checkout tags/v0.1.0 -b v0.1.0-branch
コマンド出力
Cloning into 'spanner-gaming-sample'...
*snip*
Switched to a new branch 'v0.1.0-branch'
Locust 負荷生成ツールを設定する
Locust は、REST API エンドポイントのテストに役立つ Python 負荷テスト フレームワークです。この Codelab では、強調表示する 2 つの異なるロードテストが「generators」ディレクトリにあります。
- authentication_server.py: プレーヤーを作成するタスクと、単一ポイントのルックアップを模倣するランダムなプレーヤーを取得するタスクが含まれています。
- match_server.py: ゲームの作成と終了を行うタスクが含まれています。ゲームを作成すると、現在ゲームをプレイしていない 100 人のランダムなプレーヤーが割り当てられます。ゲームを終了すると、games_played と games_won の統計情報が更新され、そのプレーヤーを今後のゲームに割り当てることができます。
Cloud Shell で Locust を実行するには、Python 3.7 以降が必要です。Cloud Shell には Python 3.9 が付属しているため、バージョンを確認するだけです。
python -V
コマンド出力
Python 3.9.12
これで、Locust の要件をインストールできます。
pip3 install -r requirements.txt
コマンド出力
Collecting locust==2.11.1
*snip*
Successfully installed ConfigArgParse-1.5.3 Flask-BasicAuth-0.2.0 Flask-Cors-3.0.10 brotli-1.0.9 gevent-21.12.0 geventhttpclient-2.0.2 greenlet-1.1.3 locust-2.11.1 msgpack-1.0.4 psutil-5.9.2 pyzmq-22.3.0 roundrobin-0.0.4 zope.event-4.5.0 zope.interface-5.4.0
次に、新しくインストールした locust バイナリが見つかるように PATH を更新します。
PATH=~/.local/bin":$PATH"
which locust
コマンド出力
/home/<user>/.local/bin/locust
概要
この手順では、プロジェクトがない場合はプロジェクトを設定し、Cloud Shell を有効にして、このラボのコードをダウンロードしました。
最後に、ラボの後半で負荷生成用に Locust を設定します。
次のステップ
次に、Cloud Spanner のインスタンスとデータベースを設定します。
3. Spanner のインスタンスとデータベースを作成する
Spanner インスタンスを作成する
この手順では、この Codelab 用に Spanner インスタンスを設定します。左上のハンバーガー メニュー 
で Spanner の項目 
を探すか、「/」を押して「Spanner」と入力し Spanner を検索します。
次に、
をクリックしてインスタンスのインスタンス名 cloudspanner-gaming を入力し、構成を選択（us-central1 などのリージョン インスタンスを選択）してノード数を設定しフォームに入力します。この Codelab では、500 processing units のみが必要です。
最後に、重要な [作成] をクリックすると、数秒で指定した Cloud Spanner インスタンスが作成されます。
データベースとスキーマを作成する
インスタンスが実行されたら、データベースを作成できます。Spanner では、1 つのインスタンスに複数のデータベースを作成できます。
データベースは、スキーマを定義する場所です。データベースにアクセスできるユーザーの制御、カスタム暗号化の設定、オプティマイザーの構成、保持期間の設定も可能です。
マルチリージョン インスタンスでは、デフォルトのリーダーを構成することもできます。Spanner のデータベースの詳細については、こちらをご覧ください。
この Codelab では、デフォルトのオプションでデータベースを作成し、作成時にスキーマを指定します。
このラボでは、players と games の 2 つのテーブルを作成します。
プレーヤーは、複数のゲームに時間経過で参加できますが、一度に参加できるのは 1 つのゲームのみです。プレーヤーは、games_played や games_won などの興味深い統計情報を追跡するための JSON データ型として統計情報も持っています。他の統計情報が後で追加される可能性があるため、これはプレーヤーのスキーマレス列として機能します。
ゲームは、Spanner の ARRAY データ型を使用して、参加したプレーヤーを追跡します。ゲームの勝者と終了属性は、ゲームが終了するまで入力されません。
プレーヤーの current_game が有効なゲームであることを確認するための外部キーが 1 つあります。
インスタンスの概要で [データベースを作成] をクリックして、データベースを作成します。
詳細を入力します。重要なオプションは、データベース名と言語です。この例では、データベースに sample-game という名前を付け、Google 標準 SQL 言語を選択しています。
[スキーマ] ボックスに、この DDL をコピーして貼り付けます。
CREATE TABLE games (
gameUUID STRING(36) NOT NULL,
players ARRAY<STRING(36)> NOT NULL,
winner STRING(36),
created TIMESTAMP,
finished TIMESTAMP,
) PRIMARY KEY(gameUUID);
CREATE TABLE players (
playerUUID STRING(36) NOT NULL,
player_name STRING(64) NOT NULL,
email STRING(MAX) NOT NULL,
password_hash BYTES(60) NOT NULL,
created TIMESTAMP,
updated TIMESTAMP,
stats JSON,
account_balance NUMERIC NOT NULL DEFAULT (0.00),
is_logged_in BOOL,
last_login TIMESTAMP,
valid_email BOOL,
current_game STRING(36),
FOREIGN KEY (current_game) REFERENCES games (gameUUID),
) PRIMARY KEY(playerUUID);
CREATE UNIQUE INDEX PlayerAuthentication ON players(email) STORING (password_hash);
CREATE INDEX PlayerGame ON players(current_game);
CREATE UNIQUE INDEX PlayerName ON players(player_name);
次に、作成ボタンをクリックし、データベースが作成されるまで数秒待ちます。
データベースの作成ページは次のようになります。
次に、コードラボで後で使用する環境変数を Cloud Shell で設定する必要があります。インスタンス ID をメモして、Cloud Shell で INSTANCE_ID と DATABASE_ID を設定します。
export SPANNER_PROJECT_ID=$GOOGLE_CLOUD_PROJECT
export SPANNER_INSTANCE_ID=cloudspanner-gaming
export SPANNER_DATABASE_ID=sample-game
概要
このステップでは、Spanner インスタンスと sample-game データベースを作成しました。また、このサンプルゲームで使用されるスキーマも定義しました。
次のステップ
次に、プロファイル サービスをデプロイして、プレーヤーがゲームに登録できるようにします。
4. プロファイル サービスをデプロイする
サービスの概要
プロファイル サービスは、gin フレームワークを活用する Go で記述された REST API です。
この API では、プレーヤーはゲームをプレイするために登録できます。これは、プレーヤーの名前、メールアドレス、パスワードを受け入れる簡単な POST コマンドで作成されます。パスワードは bcrypt で暗号化され、ハッシュがデータベースに保存されます。
メールアドレスは一意の識別子として扱われ、player_name はゲームの表示目的で使用されます。
この API は現在ログインを処理していませんが、追加の演習として実装することもできます。
プロファイル サービスの ./src/golang/profile-service/main.go ファイルは、次の 2 つのプライマリ エンドポイントを公開します。
func main() {
configuration, _ := config.NewConfig()
router := gin.Default()
router.SetTrustedProxies(nil)
router.Use(setSpannerConnection(configuration))
router.POST("/players", createPlayer)
router.GET("/players", getPlayerUUIDs)
router.GET("/players/:id", getPlayerByID)
router.Run(configuration.Server.URL())
}
これらのエンドポイントのコードは player モデルにルーティングされます。
func getPlayerByID(c *gin.Context) {
var playerUUID = c.Param("id")
ctx, client := getSpannerConnection(c)
player, err := models.GetPlayerByUUID(ctx, client, playerUUID)
if err != nil {
c.IndentedJSON(http.StatusNotFound, gin.H{"message": "player not found"})
return
}
c.IndentedJSON(http.StatusOK, player)
}
func createPlayer(c *gin.Context) {
var player models.Player
if err := c.BindJSON(&player); err != nil {
c.AbortWithError(http.StatusBadRequest, err)
return
}
ctx, client := getSpannerConnection(c)
err := player.AddPlayer(ctx, client)
if err != nil {
c.AbortWithError(http.StatusBadRequest, err)
return
}
c.IndentedJSON(http.StatusCreated, player.PlayerUUID)
}
サービスが最初に行うことの 1 つは、Spanner 接続の設定です。これは、サービスレベルで実装され、サービスのセッション プールを作成します。
func setSpannerConnection() gin.HandlerFunc {
ctx := context.Background()
client, err := spanner.NewClient(ctx, configuration.Spanner.URL())
if err != nil {
log.Fatal(err)
}
return func(c *gin.Context) {
c.Set("spanner_client", *client)
c.Set("spanner_context", ctx)
c.Next()
}
}
Player と PlayerStats は、次のように定義された構造体です。
type Player struct {
PlayerUUID string `json:"playerUUID" validate:"omitempty,uuid4"`
Player_name string `json:"player_name" validate:"required_with=Password Email"`
Email string `json:"email" validate:"required_with=Player_name Password,email"`
// not stored in DB
Password string `json:"password" validate:"required_with=Player_name Email"`
// stored in DB
Password_hash []byte `json:"password_hash"`
created time.Time
updated time.Time
Stats spanner.NullJSON `json:"stats"`
Account_balance big.Rat `json:"account_balance"`
last_login time.Time
is_logged_in bool
valid_email bool
Current_game string `json:"current_game" validate:"omitempty,uuid4"`
}
type PlayerStats struct {
Games_played spanner.NullInt64 `json:"games_played"`
Games_won spanner.NullInt64 `json:"games_won"`
}
プレーヤーを追加する関数は、ReadWrite トランザクション内の DML 挿入を利用します。これは、プレーヤーの追加がバッチ挿入ではなく単一のステートメントであるためです。関数は次のようになります。
func (p *Player) AddPlayer(ctx context.Context, client spanner.Client) error {
// Validate based on struct validation rules
err := p.Validate()
if err != nil {
return err
}
// take supplied password+salt, hash. Store in user_password
passHash, err := hashPassword(p.Password)
if err != nil {
return errors.New("Unable to hash password")
}
p.Password_hash = passHash
// Generate UUIDv4
p.PlayerUUID = generateUUID()
// Initialize player stats
emptyStats := spanner.NullJSON{Value: PlayerStats{
Games_played: spanner.NullInt64{Int64: 0, Valid: true},
Games_won: spanner.NullInt64{Int64: 0, Valid: true},
}, Valid: true}
// insert into spanner
_, err = client.ReadWriteTransaction(ctx, func(ctx context.Context, txn *spanner.ReadWriteTransaction) error {
stmt := spanner.Statement{
SQL: `INSERT players (playerUUID, player_name, email, password_hash, created, stats) VALUES
(@playerUUID, @playerName, @email, @passwordHash, CURRENT_TIMESTAMP(), @pStats)
`,
Params: map[string]interface{}{
"playerUUID": p.PlayerUUID,
"playerName": p.Player_name,
"email": p.Email,
"passwordHash": p.Password_hash,
"pStats": emptyStats,
},
}
_, err := txn.Update(ctx, stmt)
return err
})
if err != nil {
return err
}
// return empty error on success
return nil
}
UUID に基づいてプレーヤーを取得するには、単純な読み取りを発行します。これにより、プレーヤーの playerUUID、player_name、email、および統計情報が取得されます。
func GetPlayerByUUID(ctx context.Context, client spanner.Client, uuid string) (Player, error) {
row, err := client.Single().ReadRow(ctx, "players",
spanner.Key{uuid}, []string{"playerUUID", "player_name", "email", "stats"})
if err != nil {
return Player{}, err
}
player := Player{}
err = row.ToStruct(&player)
if err != nil {
return Player{}, err
}
return player, nil
}
デフォルトでは、サービスは環境変数を使用して構成されます。./src/golang/profile-service/config/config.go ファイルの関連セクションをご覧ください。
func NewConfig() (Config, error) {
*snip*
// Server defaults
viper.SetDefault("server.host", "localhost")
viper.SetDefault("server.port", 8080)
// Bind environment variable override
viper.BindEnv("server.host", "SERVICE_HOST")
viper.BindEnv("server.port", "SERVICE_PORT")
viper.BindEnv("spanner.project_id", "SPANNER_PROJECT_ID")
viper.BindEnv("spanner.instance_id", "SPANNER_INSTANCE_ID")
viper.BindEnv("spanner.database_id", "SPANNER_DATABASE_ID")
*snip*
return c, nil
}
デフォルトの動作では、サービスが localhost:8080 で実行されることがわかります。
この情報を使用して、サービスを実行します。
プロファイル サービスを実行する
go コマンドを使用してサービスを実行します。これにより、依存関係がダウンロードされ、ポート 8080 で実行されているサービスが確立されます。
cd ~/spanner-gaming-sample/src/golang/profile-service
go run . &
コマンド出力:
[GIN-debug] [WARNING] Creating an Engine instance with the Logger and Recovery middleware already attached.
[GIN-debug] [WARNING] Running in "debug" mode. Switch to "release" mode in production.
- using env: export GIN_MODE=release
- using code: gin.SetMode(gin.ReleaseMode)
[GIN-debug] POST /players --> main.createPlayer (4 handlers)
[GIN-debug] GET /players --> main.getPlayerUUIDs (4 handlers)
[GIN-debug] GET /players/:id --> main.getPlayerByID (4 handlers)
[GIN-debug] GET /players/:id/stats --> main.getPlayerStats (4 handlers)
[GIN-debug] Listening and serving HTTP on localhost:8080
curl コマンドを発行して、サービスをテストします。
curl http://localhost:8080/players \
--include \
--header "Content-Type: application/json" \
--request "POST" \
--data '{"email": "test@gmail.com","password": "s3cur3P@ss","player_name": "Test Player"}'
コマンド出力:
HTTP/1.1 201 Created
Content-Type: application/json; charset=utf-8
Date: <date> 18:55:08 GMT
Content-Length: 38
"506a1ab6-ee5b-4882-9bb1-ef9159a72989"
概要
このステップでは、プレーヤーがゲームに登録できるようにするプロファイル サービスをデプロイし、POST API 呼び出しを発行して新しいプレーヤーを作成することで、サービスをテストしました。
次のステップ
次のステップでは、マッチメイキング サービスをデプロイします。
5. マッチング サービスをデプロイする
サービスの概要
マッチング サービスは、gin フレームワークを活用する Go で記述された REST API です。
この API では、ゲームは作成され、終了します。ゲームが作成されると、現在ゲームをプレイしていない 10 人のプレーヤーがゲームに割り当てられます。
ゲームが終了すると、勝者がランダムに選択され、各プレーヤーの games_played と games_won の統計情報が調整されます。また、各プレーヤーは、プレーを終了したことを示すように更新され、今後のゲームでプレーできるようになります。
マッチメイキング サービスの ./src/golang/matchmaking-service/main.go ファイルは、profile サービスと同様の設定とコードに従っているため、ここでは繰り返しません。このサービスは、次の 2 つのプライマリ エンドポイントを公開します。
func main() {
router := gin.Default()
router.SetTrustedProxies(nil)
router.Use(setSpannerConnection())
router.POST("/games/create", createGame)
router.PUT("/games/close", closeGame)
router.Run(configuration.Server.URL())
}
このサービスは、Game 構造体と、簡略化された Player 構造体と PlayerStats 構造体を提供します。
type Game struct {
GameUUID string `json:"gameUUID"`
Players []string `json:"players"`
Winner string `json:"winner"`
Created time.Time `json:"created"`
Finished spanner.NullTime `json:"finished"`
}
type Player struct {
PlayerUUID string `json:"playerUUID"`
Stats spanner.NullJSON `json:"stats"`
Current_game string `json:"current_game"`
}
type PlayerStats struct {
Games_played int `json:"games_played"`
Games_won int `json:"games_won"`
}
ゲームを作成するために、マッチメイキング サービスは現在ゲームをプレイしていない 100 人のプレーヤーをランダムに選択します。
Spanner ミューテーションは、ゲームの作成とプレーヤーの割り当てに使用されます。これは、大規模な変更の場合、ミューテーションの方が DML よりもパフォーマンスが高いためです。
// Create a new game and assign players
// Players that are not currently playing a game are eligble to be selected for the new game
// Current implementation allows for less than numPlayers to be placed in a game
func (g *Game) CreateGame(ctx context.Context, client spanner.Client) error {
// Initialize game values
g.GameUUID = generateUUID()
numPlayers := 10
// Create and assign
_, err := client.ReadWriteTransaction(ctx, func(ctx context.Context, txn *spanner.ReadWriteTransaction) error {
var m []*spanner.Mutation
// get players
query := fmt.Sprintf("SELECT playerUUID FROM (SELECT playerUUID FROM players WHERE current_game IS NULL LIMIT 10000) TABLESAMPLE RESERVOIR (%d ROWS)", numPlayers)
stmt := spanner.Statement{SQL: query}
iter := txn.Query(ctx, stmt)
playerRows, err := readRows(iter)
if err != nil {
return err
}
var playerUUIDs []string
for _, row := range playerRows {
var pUUID string
if err := row.Columns(&pUUID); err != nil {
return err
}
playerUUIDs = append(playerUUIDs, pUUID)
}
// Create the game
gCols := []string{"gameUUID", "players", "created"}
m = append(m, spanner.Insert("games", gCols, []interface{}{g.GameUUID, playerUUIDs, time.Now()}))
// Update players to lock into this game
for _, p := range playerUUIDs {
pCols := []string{"playerUUID", "current_game"}
m = append(m, spanner.Update("players", pCols, []interface{}{p, g.GameUUID}))
}
txn.BufferWrite(m)
return nil
})
if err != nil {
return err
}
return nil
}
プレーヤーのランダム選択は、GoogleSQL の TABLESPACE RESERVOIR 機能を使用して SQL で行われます。
ゲームを終了する手順は、少し複雑です。これには、ゲームのプレーヤーの中からランダムに勝者を選び、ゲームの終了時刻をマークし、各プレーヤーの games_played と games_won の統計情報を更新することが含まれます。
この複雑さと変更の量から、ゲームを終了するために再び突然変異が選択されます。
func determineWinner(playerUUIDs []string) string {
if len(playerUUIDs) == 0 {
return ""
}
var winnerUUID string
rand.Seed(time.Now().UnixNano())
offset := rand.Intn(len(playerUUIDs))
winnerUUID = playerUUIDs[offset]
return winnerUUID
}
// Given a list of players and a winner's UUID, update players of a game
// Updating players involves closing out the game (current_game = NULL) and
// updating their game stats. Specifically, we are incrementing games_played.
// If the player is the determined winner, then their games_won stat is incremented.
func (g Game) updateGamePlayers(ctx context.Context, players []Player, txn *spanner.ReadWriteTransaction) error {
for _, p := range players {
// Modify stats
var pStats PlayerStats
json.Unmarshal([]byte(p.Stats.String()), &pStats)
pStats.Games_played = pStats.Games_played + 1
if p.PlayerUUID == g.Winner {
pStats.Games_won = pStats.Games_won + 1
}
updatedStats, _ := json.Marshal(pStats)
p.Stats.UnmarshalJSON(updatedStats)
// Update player
// If player's current game isn't the same as this game, that's an error
if p.Current_game != g.GameUUID {
errorMsg := fmt.Sprintf("Player '%s' doesn't belong to game '%s'.", p.PlayerUUID, g.GameUUID)
return errors.New(errorMsg)
}
cols := []string{"playerUUID", "current_game", "stats"}
newGame := spanner.NullString{
StringVal: "",
Valid: false,
}
txn.BufferWrite([]*spanner.Mutation{
spanner.Update("players", cols, []interface{}{p.PlayerUUID, newGame, p.Stats}),
})
}
return nil
}
// Closing game. When provided a Game, choose a random winner and close out the game.
// A game is closed by setting the winner and finished time.
// Additionally all players' game stats are updated, and the current_game is set to null to allow
// them to be chosen for a new game.
func (g *Game) CloseGame(ctx context.Context, client spanner.Client) error {
// Close game
_, err := client.ReadWriteTransaction(ctx,
func(ctx context.Context, txn *spanner.ReadWriteTransaction) error {
// Get game players
playerUUIDs, players, err := g.getGamePlayers(ctx, txn)
if err != nil {
return err
}
// Might be an issue if there are no players!
if len(playerUUIDs) == 0 {
errorMsg := fmt.Sprintf("No players found for game '%s'", g.GameUUID)
return errors.New(errorMsg)
}
// Get random winner
g.Winner = determineWinner(playerUUIDs)
// Validate game finished time is null
row, err := txn.ReadRow(ctx, "games", spanner.Key{g.GameUUID}, []string{"finished"})
if err != nil {
return err
}
if err := row.Column(0, &g.Finished); err != nil {
return err
}
// If time is not null, then the game is already marked as finished.
// That's an error.
if !g.Finished.IsNull() {
errorMsg := fmt.Sprintf("Game '%s' is already finished.", g.GameUUID)
return errors.New(errorMsg)
}
cols := []string{"gameUUID", "finished", "winner"}
txn.BufferWrite([]*spanner.Mutation{
spanner.Update("games", cols, []interface{}{g.GameUUID, time.Now(), g.Winner}),
})
// Update each player to increment stats.games_played
// (and stats.games_won if winner), and set current_game
// to null so they can be chosen for a new game
playerErr := g.updateGamePlayers(ctx, players, txn)
if playerErr != nil {
return playerErr
}
return nil
})
if err != nil {
return err
}
return nil
}
構成は、サービスの ./src/golang/matchmaking-service/config/config.go で説明されているように、環境変数を使用して再度処理されます。
// Server defaults
viper.SetDefault("server.host", "localhost")
viper.SetDefault("server.port", 8081)
// Bind environment variable override
viper.BindEnv("server.host", "SERVICE_HOST")
viper.BindEnv("server.port", "SERVICE_PORT")
viper.BindEnv("spanner.project_id", "SPANNER_PROJECT_ID")
viper.BindEnv("spanner.instance_id", "SPANNER_INSTANCE_ID")
viper.BindEnv("spanner.database_id", "SPANNER_DATABASE_ID")
profile-service との競合を避けるため、このサービスはデフォルトで localhost:8081 で実行されます。
この情報を使用して、マッチメイキング サービスを実行します。
マッチング サービスを実行する
go コマンドを使用してサービスを実行します。これにより、ポート 8082 で実行されているサービスが確立されます。このサービスには profile-service と同じ依存関係が多数あるため、新しい依存関係はダウンロードされません。
cd ~/spanner-gaming-sample/src/golang/matchmaking-service
go run . &
コマンド出力:
[GIN-debug] [WARNING] Creating an Engine instance with the Logger and Recovery middleware already attached.
[GIN-debug] [WARNING] Running in "debug" mode. Switch to "release" mode in production.
- using env: export GIN_MODE=release
- using code: gin.SetMode(gin.ReleaseMode)
[GIN-debug] POST /games/create --> main.createGame (4 handlers)
[GIN-debug] PUT /games/close --> main.closeGame (4 handlers)
[GIN-debug] Listening and serving HTTP on localhost:8081
ゲームを作成する
サービスをテストしてゲームを作成します。まず、Cloud Shell で新しいターミナルを開きます。
次の curl コマンドを実行します。
curl http://localhost:8081/games/create \
--include \
--header "Content-Type: application/json" \
--request "POST"
コマンド出力:
HTTP/1.1 201 Created
Content-Type: application/json; charset=utf-8
Date: <date> 19:38:45 GMT
Content-Length: 38
"f45b0f7f-405b-4e67-a3b8-a624e990285d"
ゲームを閉じる
curl http://localhost:8081/games/close \
--include \
--header "Content-Type: application/json" \
--data '{"gameUUID": "f45b0f7f-405b-4e67-a3b8-a624e990285d"}' \
--request "PUT"
コマンド出力:
HTTP/1.1 200 OK
Content-Type: application/json; charset=utf-8
Date: <date> 19:43:58 GMT
Content-Length: 38
"506a1ab6-ee5b-4882-9bb1-ef9159a72989"
概要
このステップでは、ゲームの作成と、そのゲームへのプレーヤーの割り当てを処理する matchmaking-service をデプロイしました。このサービスはゲームの終了も処理します。ランダムに勝者を選び、すべてのゲーム プレーヤーの games_played と games_won の統計情報を更新します。
次のステップ
サービスが実行されたので、プレーヤーに登録してゲームをプレイしてもらいましょう。
6. 再生を開始する
プロファイル サービスとマッチング サービスが実行されたので、提供された locust ジェネレータを使用して負荷を生成できます。
Locust にはジェネレータを実行するためのウェブ インターフェースがありますが、このラボではコマンドライン（–headless オプション）を使用します。
プレーヤーを登録する
まず、プレーヤーを生成します。
./generators/authentication_server.py ファイルでプレーヤーを作成する Python コードは次のようになります。
class PlayerLoad(HttpUser):
def on_start(self):
global pUUIDs
pUUIDs = []
def generatePlayerName(self):
return ''.join(random.choices(string.ascii_lowercase + string.digits, k=32))
def generatePassword(self):
return ''.join(random.choices(string.ascii_lowercase + string.digits, k=32))
def generateEmail(self):
return ''.join(random.choices(string.ascii_lowercase + string.digits, k=32) + ['@'] +
random.choices(['gmail', 'yahoo', 'microsoft']) + ['.com'])
@task
def createPlayer(self):
headers = {"Content-Type": "application/json"}
data = {"player_name": self.generatePlayerName(), "email": self.generateEmail(), "password": self.generatePassword()}
with self.client.post("/players", data=json.dumps(data), headers=headers, catch_response=True) as response:
try:
pUUIDs.append(response.json())
except json.JSONDecodeError:
response.failure("Response could not be decoded as JSON")
except KeyError:
response.failure("Response did not contain expected key 'gameUUID'")
プレーヤーの名前、メールアドレス、パスワードはランダムに生成されます。
登録に成功したプレーヤーは、読み取り負荷を生成する 2 番目のタスクによって取得されます。
@task(5)
def getPlayer(self):
# No player UUIDs are in memory, reschedule task to run again later.
if len(pUUIDs) == 0:
raise RescheduleTask()
# Get first player in our list, removing it to avoid contention from concurrent requests
pUUID = pUUIDs[0]
del pUUIDs[0]
headers = {"Content-Type": "application/json"}
self.client.get(f"/players/{pUUID}", headers=headers, name="/players/[playerUUID]")
次のコマンドは、./generators/authentication_server.py ファイルを呼び出します。このファイルは、同時に 2 つのスレッド（u=2）で 30 秒間（t=30s）新しいプレーヤーを生成します。
cd ~/spanner-gaming-sample
locust -H http://127.0.0.1:8080 -f ./generators/authentication_server.py --headless -u=2 -r=2 -t=30s
プレーヤーがゲームに参加する
プレーヤーが登録したので、ゲームを始めたいと思います。
./generators/match_server.py ファイルでゲームを作成して閉じる Python コードは次のようになります。
from locust import HttpUser, task
from locust.exception import RescheduleTask
import json
class GameMatch(HttpUser):
def on_start(self):
global openGames
openGames = []
@task(2)
def createGame(self):
headers = {"Content-Type": "application/json"}
# Create the game, then store the response in memory of list of open games.
with self.client.post("/games/create", headers=headers, catch_response=True) as response:
try:
openGames.append({"gameUUID": response.json()})
except json.JSONDecodeError:
response.failure("Response could not be decoded as JSON")
except KeyError:
response.failure("Response did not contain expected key 'gameUUID'")
@task
def closeGame(self):
# No open games are in memory, reschedule task to run again later.
if len(openGames) == 0:
raise RescheduleTask()
headers = {"Content-Type": "application/json"}
# Close the first open game in our list, removing it to avoid
# contention from concurrent requests
game = openGames[0]
del openGames[0]
data = {"gameUUID": game["gameUUID"]}
self.client.put("/games/close", data=json.dumps(data), headers=headers)
このジェネレータを実行すると、ゲームが 2:1（開く:閉じる）の比率で開閉されます。このコマンドは、10 秒間 (-t=10s) ジェネレータを実行します。
locust -H http://127.0.0.1:8081 -f ./generators/match_server.py --headless -u=1 -r=1 -t=10s
概要
このステップでは、ゲームをプレイするために登録するプレーヤーをシミュレートし、マッチメイキング サービスを使用してゲームをプレイするプレーヤーのシミュレーションを実行しました。これらのシミュレーションでは、Locust Python フレームワークを利用して、サービスの REST API にリクエストを発行しました。
プレーヤーの作成とゲームのプレイに費やす時間や、同時ユーザー数（-u）は適宜変更してください。
次のステップ
シミュレーション後、Spanner にクエリを実行してさまざまな統計情報を確認します。
7. ゲームの統計情報を取得する
プレーヤーが登録してゲームをプレイできることをシミュレートしたので、統計情報を確認する必要があります。
これを行うには、Cloud Console を使用して Spanner にクエリ リクエストを発行します。
オープン ゲームとクローズド ゲームの確認
終了したゲームには finished タイムスタンプが設定され、未終了のゲームには finished が NULL になります。この値は、ゲームが閉じられたときに設定されます。
このクエリを使用すると、オープン中のゲームとクローズ済みのゲームの数を確認できます。
SELECT Type, NumGames FROM
(SELECT "Open Games" as Type, count(*) as NumGames FROM games WHERE finished IS NULL
UNION ALL
SELECT "Closed Games" as Type, count(*) as NumGames FROM games WHERE finished IS NOT NULL
)
結果:
|
|
|
|
|
|
プレイしているプレーヤーとプレイしていないプレーヤーの数を確認する
current_game 列が設定されている場合、プレーヤーはゲームをプレイしています。それ以外の場合は、現在ゲームをプレイしていません。
現在プレイしているプレーヤーとプレイしていないプレーヤーの数を比較するには、次のクエリを使用します。
SELECT Type, NumPlayers FROM
(SELECT "Playing" as Type, count(*) as NumPlayers FROM players WHERE current_game IS NOT NULL
UNION ALL
SELECT "Not Playing" as Type, count(*) as NumPlayers FROM players WHERE current_game IS NULL
)
結果:
|
|
|
|
|
|
上位の受賞者を決定する
ゲームが終了すると、プレーヤーの 1 人がランダムに勝者として選ばれます。そのプレーヤーの games_won 統計情報は、ゲームの終了時にインクリメントされます。
SELECT playerUUID, stats
FROM players
WHERE CAST(JSON_VALUE(stats, "$.games_won") AS INT64)>0
LIMIT 10;
結果:
playerUUID | stats |
07e247c5-f88e-4bca-a7bc-12d2485f2f2b | {"games_played":49,"games_won":1} |
09b72595-40af-4406-a000-2fb56c58fe92 | {"games_played":56,"games_won":1} |
1002385b-02a0-462b-a8e7-05c9b27223aa | {"games_played":66,"games_won":1} |
13ec3770-7ae3-495f-9b53-6322d8e8d6c3 | {"games_played":44,"games_won":1} |
15513852-3f2a-494f-b437-fe7125d15f1b | {"games_played":49,"games_won":1} |
17faec64-4f77-475c-8df8-6ab026cf6698 | {"games_played":50,"games_won":1} |
1abfcb27-037d-446d-bb7a-b5cd17b5733d | {"games_played":63,"games_won":1} |
2109a33e-88bd-4e74-a35c-a7914d9e3bde | {"games_played":56,"games_won":2} |
222e37d9-06b0-4674-865d-a0e5fb80121e | {"games_played":60,"games_won":1} |
22ced15c-0da6-4fd9-8cb2-1ffd233b3c56 | {"games_played":50,"games_won":1} |
概要
このステップでは、Cloud Console を使用して Spanner にクエリを実行し、プレーヤーとゲームのさまざまな統計情報を確認しました。
次のステップ
次に、クリーンアップを行います。
8. クリーンアップ（省略可）
クリーンアップするには、Cloud Console の Cloud Spanner セクションに移動して、「Cloud Spanner インスタンスを設定する」という名前の Codelab で作成した ‘cloudspanner-gaming' インスタンスを削除します。
9. 完了
これで、Spanner にサンプルゲームが正常にデプロイされました。
次のステップ
このラボでは、golang ドライバを使用して Spanner を操作するさまざまなトピックを紹介しました。これにより、次のような重要なコンセプトを理解するための基盤が強化されます。
- スキーマの設計
- DML とミューテーション
- Golang の操作
ゲームのバックエンドとして Spanner を使用する別の例については、Cloud Spanner ゲーム取引ポストの Codelab をご覧ください。