1. Einführung
Cloud Spanner ist ein vollständig verwalteter, horizontal skalierbarer, global verteilter relationaler Datenbankdienst, der ACID-Transaktionen und SQL-Semantik bietet, ohne auf Leistung und Hochverfügbarkeit zu verzichten.
Diese Features machen Spanner zu einer hervorragenden Lösung für die Architektur von Spielen, die eine globale Spieler-Community ermöglichen oder sich Gedanken über die Datenkonsistenz machen möchten.
In diesem Lab erstellen Sie zwei Go-Dienste, die mit einer regionalen Spanner-Datenbank interagieren, um es Spielern zu ermöglichen, Gegenstände und Geld zu erwerben (item-service). Dann listen Sie auf dem Handelsposten Artikel auf, die andere Spieler kaufen können (tradepost-service).
Dieses Lab basiert auf dem Codelab Cloud Spanner – Erste Schritte bei der Spieleentwicklung, in dem Spieler und Spiele mithilfe von profile-service und matchmaking-service generiert wurden.
Als Nächstes generieren Sie Daten mithilfe des Python-Lade-Frameworks Locust.io, um zu simulieren, dass Spieler im Rahmen des „Gameplays“ Geld und Gegenstände erwerben. Die Spieler können dann in einem Tradepost Artikel zum Verkauf anbieten, wo andere Spieler mit ausreichend Geld diese Artikel kaufen können.
Außerdem fragen Sie Spanner ab, um zu ermitteln, und die Anzahl der Artikel sowie Statistiken zu Handelsaufträgen, die offen oder bereits ausgeführt wurden.
Zum Schluss bereinigen Sie die in diesem Lab erstellten Ressourcen.
Aufgaben
Aufgaben in diesem Lab:
- Verwenden Sie die Spanner-Instanz aus Cloud Spanner – Erste Schritte bei der Spieleentwicklung.
- In Go geschriebenen Artikeldienst bereitstellen, um Spieler beim Erwerb von Artikeln und Geld zu unterstützen
- Stellen Sie einen Handelspost-Dienst bereit, der in Go geschrieben ist, um zu simulieren, wie Spieler Artikel zum Verkauf anbieten und andere Spieler diese Artikel kaufen.
Lerninhalte
- Wie Sie Lese-Schreib-Transaktionen verwenden, um Konsistenz bei Datenänderungen zu gewährleisten
- DML- und Spanner-Mutationen zum Ändern von Daten nutzen
Voraussetzungen
- Ein Google Cloud-Projekt, das mit einem Rechnungskonto verbunden ist.
- Ein Webbrowser wie Chrome oder Firefox
- Ich habe zuvor den Schritt Erste Schritte bei der Spieleentwicklung mit Cloud Spanner ohne Bereinigungsschritt abgeschlossen.
2. Einrichtung und Anforderungen
Codelab „Erste Schritte mit der Spieleentwicklung“ in Cloud Spanner abschließen
Absolvieren Sie das Codelab Cloud Spanner – Erste Schritte bei der Spieleentwicklung. Dies ist erforderlich, um ein Dataset mit Spielern und Spielen abzurufen. Spieler und Spiele werden benötigt, um Gegenstände und Geld zu erwerben, die wiederum verwendet werden, um Artikel zum Verkauf anzubieten und an den Handelsposten zu kaufen.
Umgebungsvariablen in Cloud Shell konfigurieren
Klicken Sie zum Öffnen von Cloud Shell auf „Cloud Shell aktivieren“ 
. Die Bereitstellung und Verbindung mit der Umgebung dauert nur einen Moment.
Sobald Sie mit Cloud Shell verbunden sind, sollten Sie sehen, dass Sie bereits authentifiziert sind und dass das Projekt bereits auf Ihre PROJECT_ID eingestellt ist.
SPANNER-Umgebungsvariablen in Cloud Shell festlegen
export SPANNER_PROJECT_ID=$GOOGLE_CLOUD_PROJECT
export SPANNER_INSTANCE_ID=cloudspanner-gaming
export SPANNER_DATABASE_ID=sample-game
Schema erstellen
Nachdem die Datenbank erstellt wurde, können Sie das Schema in der Datenbank sample-game definieren.
In diesem Lab werden vier neue Tabellen erstellt: game_items, player_items, player_ledger_entries und trade_orders.
Beziehungen zwischen Spielerelementen
Handelsordnungsbeziehungen
Spielelemente werden der Tabelle „game_items“ hinzugefügt und können dann von anderen Spielern erworben werden. Die Tabelle player_items enthält Fremdschlüssel für eine item-UUID und eine Spieler-UUID, um sicherzustellen, dass Spieler nur gültige Items erwerben.
In der Tabelle player_ledger_entries werden alle monetären Änderungen am Kontostand des Spielers aufgeführt. Dabei kann es sich um den Erwerb von Geld aus Beute oder den Verkauf von Gegenständen auf den Handelsposten handeln.
Und schließlich wird die Tabelle trade_orders für die Übermittlung von Verkaufsaufträgen und für die Abwicklung dieser Bestellungen durch Käufer verwendet.
Klicken Sie zum Erstellen des Schemas in der Cloud Console auf die Schaltfläche Write DDL:
Hier geben Sie die Schemadefinition aus der Datei schema/trading.sql ein:
CREATE TABLE game_items
(
itemUUID STRING(36) NOT NULL,
item_name STRING(MAX) NOT NULL,
item_value NUMERIC NOT NULL,
available_time TIMESTAMP NOT NULL,
duration int64
)PRIMARY KEY (itemUUID);
CREATE TABLE player_items
(
playerItemUUID STRING(36) NOT NULL,
playerUUID STRING(36) NOT NULL,
itemUUID STRING(36) NOT NULL,
price NUMERIC NOT NULL,
source STRING(MAX) NOT NULL,
game_session STRING(36) NOT NULL,
acquire_time TIMESTAMP NOT NULL DEFAULT (CURRENT_TIMESTAMP()),
expires_time TIMESTAMP,
visible BOOL NOT NULL DEFAULT(true),
FOREIGN KEY (itemUUID) REFERENCES game_items (itemUUID),
FOREIGN KEY (game_session) REFERENCES games (gameUUID)
) PRIMARY KEY (playerUUID, playerItemUUID),
INTERLEAVE IN PARENT players ON DELETE CASCADE;
CREATE TABLE player_ledger_entries (
playerUUID STRING(36) NOT NULL,
source STRING(MAX) NOT NULL,
game_session STRING(36) NOT NULL,
amount NUMERIC NOT NULL,
entryDate TIMESTAMP NOT NULL OPTIONS (allow_commit_timestamp=true),
FOREIGN KEY (game_session) REFERENCES games (gameUUID)
) PRIMARY KEY (playerUUID, entryDate DESC),
INTERLEAVE IN PARENT players ON DELETE CASCADE;
CREATE TABLE trade_orders
(
orderUUID STRING(36) NOT NULL,
lister STRING(36) NOT NULL,
buyer STRING(36),
playerItemUUID STRING(36) NOT NULL,
trade_type STRING(5) NOT NULL,
list_price NUMERIC NOT NULL,
created TIMESTAMP NOT NULL DEFAULT (CURRENT_TIMESTAMP()),
ended TIMESTAMP,
expires TIMESTAMP NOT NULL DEFAULT (TIMESTAMP_ADD(CURRENT_TIMESTAMP(), interval 24 HOUR)),
active BOOL NOT NULL DEFAULT (true),
cancelled BOOL NOT NULL DEFAULT (false),
filled BOOL NOT NULL DEFAULT (false),
expired BOOL NOT NULL DEFAULT (false),
FOREIGN KEY (playerItemUUID) REFERENCES player_items (playerItemUUID)
) PRIMARY KEY (orderUUID);
CREATE INDEX TradeItem ON trade_orders(playerItemUUID, active);
Klicken Sie auf „Submit“. Schaltfläche zum Ändern des Schemas und warten Sie, bis die Schemaaktualisierung abgeschlossen ist:
Nächstes Video
Als Nächstes stellen Sie den Artikeldienst bereit.
3. Artikeldienst bereitstellen
Überblick über den Service
Der Artikeldienst ist eine in Go geschriebene REST API, die das Gin-Framework nutzt. In dieser API erhalten Spieler, die an offenen Spielen teilnehmen, Geld und In-Game-Artikel.
Die Datei ./src/golang/item-service/main.go konfiguriert die folgenden Endpunkte so, dass sie mit Spielelementen und Spielern funktionieren, die diese Elemente erwerben. Darüber hinaus gibt es einen Endpunkt, über den die Spieler Geld erwerben können.
func main() {
configuration, _ := config.NewConfig()
router := gin.Default()
router.SetTrustedProxies(nil)
router.Use(setSpannerConnection(configuration))
router.GET("/items", getItemUUIDs)
router.POST("/items", createItem)
router.GET("/items/:id", getItem)
router.PUT("/players/balance", updatePlayerBalance)
router.GET("/players", getPlayer)
router.POST("/players/items", addPlayerItem)
router.Run(configuration.Server.URL())
}
Die Konfiguration und Verwendung von Spanner-Verbindungen wird genauso gehandhabt wie „profile-service“ und „matchmaking-service“ aus dem vorherigen Codelab.
Der Artikeldienst funktioniert mit GameItem, Player, PlayerLedger und PlayerItem mit den folgenden Definitionen:
// models/game_items.go
type GameItem struct {
ItemUUID string `json:"itemUUID"`
Item_name string `json:"item_name"`
Item_value big.Rat `json:"item_value"`
Available_time time.Time `json:"available_time"`
Duration int64 `json:"duration"`
}
// models/players.go
type Player struct {
PlayerUUID string `json:"playerUUID" binding:"required,uuid4"`
Updated time.Time `json:"updated"`
Account_balance big.Rat `json:"account_balance"`
Current_game string `json:"current_game"`
}
type PlayerLedger struct {
PlayerUUID string `json:"playerUUID" binding:"required,uuid4"`
Amount big.Rat `json:"amount"`
Game_session string `json:"game_session"`
Source string `json:"source"`
}
// models/player_items.go
type PlayerItem struct {
PlayerItemUUID string `json:"playerItemUUID" binding:"omitempty,uuid4"`
PlayerUUID string `json:"playerUUID" binding:"required,uuid4"`
ItemUUID string `json:"itemUUID" binding:"required,uuid4"`
Source string `json:"source" binding:"required"`
Game_session string `json:"game_session" binding:"omitempty,uuid4"`
Price big.Rat `json:"price"`
AcquireTime time.Time `json:"acquire_time"`
ExpiresTime spanner.NullTime `json:"expires_time"`
Visible bool `json:"visible"`
}
Zuerst müssen im Spiel einige Artikel erstellt worden sein. Dazu wird eine POST-Anfrage an den Endpunkt /items aufgerufen. Dies ist eine sehr einfache DML-Einfügung in die Tabelle game_items.
// main.go
func createItem(c *gin.Context) {
var item models.GameItem
if err := c.BindJSON(&item); err != nil {
c.AbortWithError(http.StatusBadRequest, err)
return
}
ctx, client := getSpannerConnection(c)
err := item.Create(ctx, client)
if err != nil {
c.AbortWithError(http.StatusBadRequest, err)
return
}
c.IndentedJSON(http.StatusCreated, item.ItemUUID)
}
// models/game_items.go
func (i *GameItem) Create(ctx context.Context, client spanner.Client) error {
// Initialize item values
i.ItemUUID = generateUUID()
if i.Available_time.IsZero() {
i.Available_time = time.Now()
}
// insert into spanner
_, err := client.ReadWriteTransaction(ctx, func(ctx context.Context, txn *spanner.ReadWriteTransaction) error {
stmt := spanner.Statement{
SQL: `INSERT game_items (itemUUID, item_name, item_value, available_time, duration)
VALUES (@itemUUID, @itemName, @itemValue, @availableTime, @duration)
`,
Params: map[string]interface{}{
"itemUUID": i.ItemUUID,
"itemName": i.Item_name,
"itemValue": i.Item_value,
"availableTime": i.Available_time,
"duration": i.Duration,
},
}
_, err := txn.Update(ctx, stmt)
return err
})
if err != nil {
return err
}
// return empty error on success
return nil
}
Um ein Objekt zu erwerben, wird eine POST-Anfrage an den Endpunkt /players/items aufgerufen. Die Logik für diesen Endpunkt besteht darin, den aktuellen Wert eines Spielgegenstands und die aktuelle Spielsitzung des Spielers abzurufen. Füge dann die entsprechenden Informationen in die Tabelle player_items ein, die die Quelle und den Zeitpunkt des Erhalts der Items angeben.
Dies entspricht den folgenden Funktionen:
// main.go
func addPlayerItem(c *gin.Context) {
var playerItem models.PlayerItem
if err := c.BindJSON(&playerItem); err != nil {
c.AbortWithError(http.StatusBadRequest, err)
return
}
ctx, client := getSpannerConnection(c)
err := playerItem.Add(ctx, client)
if err != nil {
c.AbortWithError(http.StatusBadRequest, err)
return
}
c.IndentedJSON(http.StatusCreated, playerItem)
}
// models/player_items.go
func (pi *PlayerItem) Add(ctx context.Context, client spanner.Client) error {
// insert into spanner
_, err := client.ReadWriteTransaction(ctx, func(ctx context.Context, txn *spanner.ReadWriteTransaction) error {
// Get item price at time of transaction
price, err := GetItemPrice(ctx, txn, pi.ItemUUID)
if err != nil {
return err
}
pi.Price = price
// Get Game session
session, err := GetPlayerSession(ctx, txn, pi.PlayerUUID)
if err != nil {
return err
}
pi.Game_session = session
pi.PlayerItemUUID = generateUUID()
// Insert
cols := []string{"playerItemUUID", "playerUUID", "itemUUID", "price", "source", "game_session"}
txn.BufferWrite([]*spanner.Mutation{
spanner.Insert("player_items", cols,
[]interface{}{pi.PlayerItemUUID, pi.PlayerUUID, pi.ItemUUID, pi.Price, pi.Source, pi.Game_session}),
})
return nil
})
if err != nil {
return err
}
// return empty error on success
return nil
}
Damit ein Spieler Geld erhalten kann, wird eine PUT-Anfrage an den Endpunkt /players/updatebalance aufgerufen.
Die Logik für diesen Endpunkt besteht darin, das Guthaben des Spielers nach Anwendung von amount und sowie die Tabelle player_ledger_entries mit einem Datensatz des Erwerbs zu aktualisieren. Das „account_balance“-Konto des Spielers wird so geändert, dass es an den Aufrufer zurückgegeben wird. Mit DML werden sowohl „Player“ als auch „player_ledger_entries“ geändert.
Dies entspricht den folgenden Funktionen:
// main.go
func updatePlayerBalance(c *gin.Context) {
var player models.Player
var ledger models.PlayerLedger
if err := c.BindJSON(&ledger); err != nil {
c.AbortWithError(http.StatusBadRequest, err)
return
}
ctx, client := getSpannerConnection(c)
err := ledger.UpdateBalance(ctx, client, &player)
if err != nil {
c.AbortWithError(http.StatusBadRequest, err)
return
}
type PlayerBalance struct {
PlayerUUID, AccountBalance string
}
balance := PlayerBalance{PlayerUUID: player.PlayerUUID, AccountBalance: player.Account_balance.FloatString(2)}
c.IndentedJSON(http.StatusOK, balance)
}
// models/players.go
func (l *PlayerLedger) UpdateBalance(ctx context.Context, client spanner.Client, p *Player) error {
// Update balance with new amount
_, err := client.ReadWriteTransaction(ctx, func(ctx context.Context, txn *spanner.ReadWriteTransaction) error {
p.PlayerUUID = l.PlayerUUID
stmt := spanner.Statement{
SQL: `UPDATE players SET account_balance = (account_balance + @amount) WHERE playerUUID = @playerUUID`,
Params: map[string]interface{}{
"amount": l.Amount,
"playerUUID": p.PlayerUUID,
},
}
numRows, err := txn.Update(ctx, stmt)
if err != nil {
return err
}
// No rows modified. That's an error
if numRows == 0 {
errorMsg := fmt.Sprintf("Account balance for player '%s' could not be updated", p.PlayerUUID)
return errors.New(errorMsg)
}
// Get player's new balance (read after write)
stmt = spanner.Statement{
SQL: `SELECT account_balance, current_game FROM players WHERE playerUUID = @playerUUID`,
Params: map[string]interface{}{
"playerUUID": p.PlayerUUID,
},
}
iter := txn.Query(ctx, stmt)
defer iter.Stop()
for {
row, err := iter.Next()
if err == iterator.Done {
break
}
if err != nil {
return err
}
var accountBalance big.Rat
var gameSession string
if err := row.Columns(&accountBalance, &gameSession); err != nil {
return err
}
p.Account_balance = accountBalance
l.Game_session = gameSession
}
stmt = spanner.Statement{
SQL: `INSERT INTO player_ledger_entries (playerUUID, amount, game_session, source, entryDate)
VALUES (@playerUUID, @amount, @game, @source, PENDING_COMMIT_TIMESTAMP())`,
Params: map[string]interface{}{
"playerUUID": l.PlayerUUID,
"amount": l.Amount,
"game": l.Game_session,
"source": l.Source,
},
}
numRows, err = txn.Update(ctx, stmt)
if err != nil {
return err
}
return nil
})
if err != nil {
return err
}
return nil
}
Standardmäßig wird der Dienst mithilfe von Umgebungsvariablen konfiguriert. Weitere Informationen finden Sie im entsprechenden Abschnitt der Datei ./src/golang/item-service/config/config.go.
func NewConfig() (Config, error) {
*snip*
// Server defaults
viper.SetDefault("server.host", "localhost")
viper.SetDefault("server.port", 8082)
// 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
}
Wie Sie sehen, wird der Dienst standardmäßig auf localhost:8082 ausgeführt.
Anhand dieser Informationen kann der Dienst ausgeführt werden.
Dienst ausführen
Wenn Sie den Dienst ausführen, werden die Abhängigkeiten heruntergeladen und der Dienst wird eingerichtet, der auf Port 8082 ausgeführt wird:
cd ~/spanner-gaming-sample/src/golang/item-service
go run . &
Befehlsausgabe:
[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] GET /items --> main.getItemUUIDs (4 handlers)
[GIN-debug] POST /items --> main.createItem (4 handlers)
[GIN-debug] GET /items/:id --> main.getItem (4 handlers)
[GIN-debug] PUT /players/balance --> main.updatePlayerBalance (4 handlers)
[GIN-debug] GET /players --> main.getPlayer (4 handlers)
[GIN-debug] POST /players/items --> main.addPlayerItem (4 handlers)
[GIN-debug] Listening and serving HTTP on localhost:8082
Testen Sie den Dienst, indem Sie einen curl-Befehl ausführen, um ein Element zu erstellen:
curl http://localhost:8082/items \
--include \
--header "Content-Type: application/json" \
--request "POST" \
--data '{"item_name": "test_item","item_value": "3.14"}'
Befehlsausgabe:
HTTP/1.1 201 Created
Content-Type: application/json; charset=utf-8
Date: <Date>
Content-Length: 38
"aecde380-0a79-48c0-ab5d-0da675d3412c"
Als Nächstes soll ein Spieler diesen Gegenstand erwerben. Dazu benötigen Sie eine ItemUUID und eine PlayerUUID. Die ItemUUID ist die Ausgabe des vorherigen Befehls. In diesem Beispiel ist das aecde380-0a79-48c0-ab5d-0da675d3412c.
Rufen Sie den Endpunkt GET /players auf, um eine PlayerUUID zu erhalten:
curl http://localhost:8082/players
Befehlsausgabe:
{
"playerUUID": "b74cc194-87b0-4a55-a67f-0f0742ef6352",
"updated": "0001-01-01T00:00:00Z",
"account_balance": {},
"current_game": "7b97fa85-5658-4ded-a962-4c09269a0a79"
}
Damit der Spieler den Artikel erhält, muss er eine Anfrage an den Endpunkt POST /players/items senden:
curl http://localhost:8082/players/items \
--include \
--header "Content-Type: application/json" \
--request "POST" \
--data '{"playerUUID": "b74cc194-87b0-4a55-a67f-0f0742ef6352","itemUUID": "109ec745-9906-402b-9d03-ca7153a10312", "source": "loot"}'
Befehlsausgabe:
Content-Type: application/json; charset=utf-8
Date: <Date>
Content-Length: 369
{
"playerItemUUID": "a42b1899-4509-4fce-9958-265d2a2838a0",
"playerUUID": "b74cc194-87b0-4a55-a67f-0f0742ef6352",
"itemUUID": "109ec745-9906-402b-9d03-ca7153a10312",
"source": "loot",
"game_session": "7b97fa85-5658-4ded-a962-4c09269a0a79",
"price": {},
"acquire_time": "0001-01-01T00:00:00Z",
"expires_time": null,
"visible": false
}
Zusammenfassung
In diesem Schritt haben Sie den Artikeldienst bereitgestellt, mit dem Spielgegenstände erstellt werden können. Spieler, die einem offenen Spiel zugewiesen sind, können Geld und In-Game-Artikel erwerben.
Nächste Schritte
Im nächsten Schritt stellen Sie den Tradepost-Dienst bereit.
4. Tradepost-Dienst bereitstellen
Überblick über den Service
Der Tradepost-Dienst ist eine in Go geschriebene REST API, die das Gin-Framework nutzt. In dieser API werden Spielerartikel zum Verkaufen veröffentlicht. Die Spieler können dann an offenen Trades teilnehmen und können den Artikel kaufen, wenn sie genug Geld haben.
Die Datei ./src/golang/tradepost-service/main.go für den Tradepost-Dienst folgt einer ähnlichen Einrichtung und einem ähnlichen Code wie die anderen Dienste. Daher wird sie hier nicht wiederholt. Dieser Dienst stellt mehrere Endpunkte so bereit:
func main() {
configuration, _ := config.NewConfig()
router := gin.Default()
router.SetTrustedProxies(nil)
router.Use(setSpannerConnection(configuration))
router.GET("/trades/player_items", getPlayerItem)
router.POST("/trades/sell", createOrder)
router.GET("/trades/open", getOpenOrder)
router.PUT("/trades/buy", purchaseOrder)
router.Run(configuration.Server.URL())
}
Dieser Dienst stellt eine TradeOrder-Struktur sowie erforderliche Strukturen für GameItem, PlayerItem, Player und PlayerLedger bereit:
type TradeOrder struct {
OrderUUID string `json:"orderUUID" binding:"omitempty,uuid4"`
Lister string `json:"lister" binding:"omitempty,uuid4"`
Buyer string `json:"buyer" binding:"omitempty,uuid4"`
PlayerItemUUID string `json:"playerItemUUID" binding:"omitempty,uuid4"`
TradeType string `json:"trade_type"`
ListPrice big.Rat `json:"list_price" spanner:"list_price"`
Created time.Time `json:"created"`
Ended spanner.NullTime `json:"ended"`
Expires time.Time `json:"expires"`
Active bool `json:"active"`
Cancelled bool `json:"cancelled"`
Filled bool `json:"filled"`
Expired bool `json:"expired"`
}
type GameItem struct {
ItemUUID string `json:"itemUUID"`
ItemName string `json:"item_name"`
ItemValue big.Rat `json:"item_value"`
AvailableTime time.Time `json:"available_time"`
Duration int64 `json:"duration"`
}
type PlayerItem struct {
PlayerItemUUID string `json:"playerItemUUID" binding:"omitempty,uuid4"`
PlayerUUID string `json:"playerUUID" binding:"required,uuid4"`
ItemUUID string `json:"itemUUID" binding:"required,uuid4"`
Source string `json:"source"`
GameSession string `json:"game_session" binding:"omitempty,uuid4"`
Price big.Rat `json:"price"`
AcquireTime time.Time `json:"acquire_time" spanner:"acquire_time"`
ExpiresTime spanner.NullTime `json:"expires_time" spanner:"expires_time"`
Visible bool `json:"visible"`
}
type Player struct {
PlayerUUID string `json:"playerUUID" binding:"required,uuid4"`
Updated time.Time `json:"updated"`
AccountBalance big.Rat `json:"account_balance" spanner:"account_balance"`
CurrentGame string `json:"current_game" binding:"omitempty,uuid4" spanner:"current_game"`
}
type PlayerLedger struct {
PlayerUUID string `json:"playerUUID" binding:"required,uuid4"`
Amount big.Rat `json:"amount"`
GameSession string `json:"game_session" spanner:"game_session"`
Source string `json:"source"`
}
Zum Erstellen einer Trade Order wird eine POST-Anfrage an den API-Endpunkt /trades/sell gesendet. Die erforderlichen Informationen sind die playerItemUUID des zu verkaufenden Spieler-Artikels, der lister und der list_price.
Spanner-Mutationen werden ausgewählt, um die Trade Order zu erstellen und das „player_item“ als nicht sichtbar zu markieren. Dadurch wird verhindert, dass der Verkäufer doppelte Artikel zum Verkauf hochlädt.
func (o *TradeOrder) Create(ctx context.Context, client spanner.Client) error {
// insert into spanner
_, err := client.ReadWriteTransaction(ctx, func(ctx context.Context, txn *spanner.ReadWriteTransaction) error {
// get the Item to be listed
pi, err := GetPlayerItem(ctx, txn, o.Lister, o.PlayerItemUUID)
if err != nil {
return err
}
// Set expires to 1 day by default
if o.Expires.IsZero() {
currentTime := time.Now()
o.Expires = currentTime.Add(time.Hour * 24)
}
// Item is not visible or expired, so it can't be listed. That's an error
if !validateSellOrder(pi) {
errorMsg := fmt.Sprintf("Item (%s, %s) cannot be listed.", o.Lister, o.PlayerItemUUID)
return errors.New(errorMsg)
}
// Initialize order values
o.OrderUUID = generateUUID()
o.Active = true // TODO: Have to set this by default since testing with emulator does not support 'DEFAULT' schema option
// Insert the order
var m []*spanner.Mutation
cols := []string{"orderUUID", "playerItemUUID", "lister", "list_price", "trade_type", "expires", "active"}
m = append(m, spanner.Insert("trade_orders", cols, []interface{}{o.OrderUUID, o.PlayerItemUUID, o.Lister, o.ListPrice, "sell", o.Expires, o.Active}))
// Mark the item as invisible
cols = []string{"playerUUID", "playerItemUUID", "visible"}
m = append(m, spanner.Update("player_items", cols, []interface{}{o.Lister, o.PlayerItemUUID, false}))
txn.BufferWrite(m)
return nil
})
if err != nil {
return err
}
// return empty error on success
return nil
}
Vor der Erstellung des Auftrags wird PlayerItem validiert, um sicherzustellen, dass es zum Verkauf angeboten werden kann. Dies bedeutet in erster Linie, dass das PlayerItem für den Spieler sichtbar ist und nicht abgelaufen ist.
// Validate that the order can be placed: Item is visible and not expired
func validateSellOrder(pi PlayerItem) bool {
// Item is not visible, can't be listed
if !pi.Visible {
return false
}
// item is expired. can't be listed
if !pi.ExpiresTime.IsNull() && pi.ExpiresTime.Time.Before(time.Now()) {
return false
}
// All validation passed. Item can be listed
return true
}
Ein Kauf erfolgt über eine PUT-Anfrage an den Endpunkt /trades/buy. Die erforderlichen Informationen sind die orderUUID und der buyer, d. h. die UUID des Players, der den Kauf tätigt.
Aufgrund dieser Komplexität und der Menge an Änderungen werden erneut Mutationen für den Kauf der Bestellung ausgewählt. Die folgenden Vorgänge werden in einer einzigen Lese-Schreib-Transaktion ausgeführt:
- Prüfe, ob der Auftrag ausgeführt werden kann, weil er noch nicht ausgeführt wurde und noch nicht abgelaufen ist.
// Validate that the order can be filled: Order is active and not expired
func validatePurchase(o TradeOrder) bool {
// Order is not active
if !o.Active {
return false
}
// order is expired. can't be filled
if !o.Expires.IsZero() && o.Expires.Before(time.Now()) {
return false
}
// All validation passed. Order can be filled
return true
}
- Rufen Sie die Käuferinformationen ab und bestätigen Sie, dass er den Artikel kaufen kann. Das bedeutet, dass der Käufer nicht mit dem Listener identisch sein darf und er über genügend Geld verfügt.
// Validate that a buyer can buy this item.
func validateBuyer(b Player, o TradeOrder) bool {
// Lister can't be the same as buyer
if b.PlayerUUID == o.Lister {
return false
}
// Big.rat returns -1 if Account_balance is less than price
if b.AccountBalance.Cmp(&o.ListPrice) == -1 {
return false
}
return true
}
- Fügen Sie den list_price (Preis) der Bestellung mit einem entsprechenden Hauptbucheintrag zum Guthaben des listers hinzu.
// models/trade_order.go
// Buy an order
func (o *TradeOrder) Buy(ctx context.Context, client spanner.Client) error {
*snip*
// Update seller's account balance
lister.UpdateBalance(ctx, txn, o.ListPrice)
*snip*
}
// models/players.go
// Update a player's balance, and add an entry into the player ledger
func (p *Player) UpdateBalance(ctx context.Context, txn *spanner.ReadWriteTransaction, newAmount big.Rat) error {
// This modifies player's AccountBalance, which is used to update the player entry
p.AccountBalance.Add(&p.AccountBalance, &newAmount)
txn.BufferWrite([]*spanner.Mutation{
spanner.Update("players", []string{"playerUUID", "account_balance"}, []interface{}{p.PlayerUUID, p.AccountBalance}),
spanner.Insert("player_ledger_entries", []string{"playerUUID", "amount", "game_session", "source", "entryDate"},
[]interface{}{p.PlayerUUID, newAmount, p.CurrentGame, "tradepost", spanner.CommitTimestamp}),
})
return nil
}
- Ziehen Sie den list_price (Preis) der Bestellung vom Guthaben des Käufers mit einem übereinstimmenden Hauptbucheintrag ab.
// Update buyer's account balance
negAmount := o.ListPrice.Neg(&o.ListPrice)
buyer.UpdateBalance(ctx, txn, *negAmount)
- Verschieben Sie „player_item“ zum neuen Spieler, indem Sie eine neue Instanz des Spielartikels mit den Spiel- und buyer-Details in die Tabelle PlayerItems einfügen und die lister-Instanz des Artikels entfernen.
// models/player_items.go
// Move an item to a new player, removes the item entry from the old player
func (pi *PlayerItem) MoveItem(ctx context.Context, txn *spanner.ReadWriteTransaction, toPlayer string) error {
fmt.Printf("Buyer: %s", toPlayer)
txn.BufferWrite([]*spanner.Mutation{
spanner.Insert("player_items", []string{"playerItemUUID", "playerUUID", "itemUUID", "price", "source", "game_session"},
[]interface{}{pi.PlayerItemUUID, toPlayer, pi.ItemUUID, pi.Price, pi.Source, pi.GameSession}),
spanner.Delete("player_items", spanner.Key{pi.PlayerUUID, pi.PlayerItemUUID}),
})
return nil
}
- Aktualisiert den Eintrag Orders, um anzuzeigen, dass der Artikel gefüllt wurde und nicht mehr aktiv ist.
Insgesamt sieht die Buy-Funktion so aus:
// Buy an order
func (o *TradeOrder) Buy(ctx context.Context, client spanner.Client) error {
// Fulfil the order
_, err := client.ReadWriteTransaction(ctx, func(ctx context.Context, txn *spanner.ReadWriteTransaction) error {
// Get Order information
err := o.getOrderDetails(ctx, txn)
if err != nil {
return err
}
// Validate order can be filled
if !validatePurchase(*o) {
errorMsg := fmt.Sprintf("Order (%s) cannot be filled.", o.OrderUUID)
return errors.New(errorMsg)
}
// Validate buyer has the money
buyer := Player{PlayerUUID: o.Buyer}
err = buyer.GetBalance(ctx, txn)
if err != nil {
return err
}
if !validateBuyer(buyer, *o) {
errorMsg := fmt.Sprintf("Buyer (%s) cannot purchase order (%s).", buyer.PlayerUUID, o.OrderUUID)
return errors.New(errorMsg)
}
// Move money from buyer to seller (which includes ledger entries)
var m []*spanner.Mutation
lister := Player{PlayerUUID: o.Lister}
err = lister.GetBalance(ctx, txn)
if err != nil {
return err
}
// Update seller's account balance
lister.UpdateBalance(ctx, txn, o.ListPrice)
// Update buyer's account balance
negAmount := o.ListPrice.Neg(&o.ListPrice)
buyer.UpdateBalance(ctx, txn, *negAmount)
// Move item from seller to buyer, mark item as visible.
pi, err := GetPlayerItem(ctx, txn, o.Lister, o.PlayerItemUUID)
if err != nil {
return err
}
pi.GameSession = buyer.CurrentGame
// Moves the item from lister (current pi.PlayerUUID) to buyer
pi.MoveItem(ctx, txn, o.Buyer)
// Update order information
cols := []string{"orderUUID", "active", "filled", "buyer", "ended"}
m = append(m, spanner.Update("trade_orders", cols, []interface{}{o.OrderUUID, false, true, o.Buyer, time.Now()}))
txn.BufferWrite(m)
return nil
})
if err != nil {
return err
}
// return empty error on success
return nil
}
Standardmäßig wird der Dienst mithilfe von Umgebungsvariablen konfiguriert. Weitere Informationen finden Sie im entsprechenden Abschnitt der Datei ./src/golang/tradepost-service/config/config.go.
func NewConfig() (Config, error) {
*snip*
// Server defaults
viper.SetDefault("server.host", "localhost")
viper.SetDefault("server.port", 8083)
// 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
}
Wie Sie sehen, wird der Dienst standardmäßig unter localhost:8083 ausgeführt, um Konflikte mit anderen Diensten zu vermeiden.*
Mit diesen Informationen ist es nun an der Zeit, den Tradepost-Dienst zu betreiben.
Dienst ausführen
Wenn Sie den Dienst ausführen, wird er auf Port 8083 ausgeführt. Dieser Dienst hat viele der gleichen Abhängigkeiten wie der Artikeldienst, sodass keine neuen Abhängigkeiten heruntergeladen werden.
cd ~/spanner-gaming-sample/src/golang/tradepost-service
go run . &
Befehlsausgabe:
[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] GET /trades/player_items --> main.getPlayerItem (4 handlers)
[GIN-debug] POST /trades/sell --> main.createOrder (4 handlers)
[GIN-debug] GET /trades/open --> main.getOpenOrder (4 handlers)
[GIN-debug] PUT /trades/buy --> main.purchaseOrder (4 handlers)
[GIN-debug] Listening and serving HTTP on localhost:8083
Artikel posten
Testen Sie den Dienst, indem Sie eine GET-Anfrage ausgeben, um ein PlayerItem-Objekt zum Verkauf abzurufen:
curl http://localhost:8083/trades/player_items
Befehlsausgabe:
{
"PlayerUUID": "b74cc194-87b0-4a55-a67f-0f0742ef6352",
"PlayerItemUUID": "a42b1899-4509-4fce-9958-265d2a2838a0",
"Price": "3.14"
}
Veröffentlichen Sie jetzt einen Artikel zum Verkauf, indem wir den Endpunkt /trades/sell aufrufen.
curl http://localhost:8083/trades/sell \
--include \
--header "Content-Type: application/json" \
--request "POST" \
--data '{"lister": "<PlayerUUID>","playerItemUUID": "<PlayerItemUUID>", "list_price": "<some price higher than item's price>"}'
Befehlsausgabe:
HTTP/1.1 201 Created
Content-Type: application/json; charset=utf-8
Date: <Date>
Content-Length: 38
"282ea691-b956-4c4c-95ff-f461d6415651"
Zusammenfassung
In diesem Schritt haben Sie den tradepost-service zum Erstellen von Verkaufsaufträgen bereitgestellt. Dieser Dienst übernimmt auch die Möglichkeit zum Kauf dieser Bestellungen.
Nächste Schritte
Jetzt, da Ihre Dienste ausgeführt werden, ist es an der Zeit, Spieler zu simulieren, die auf dem Handelsposten verkaufen und kaufen.
5. Mit dem Handeln beginnen
Da die Artikel- und Handelspostdienste jetzt ausgeführt werden, können Sie mit den bereitgestellten Locust-Generatoren Last generieren.
Locust bietet eine Weboberfläche zum Ausführen der Generatoren. In diesem Lab verwenden Sie jedoch die Befehlszeile (Option –headless).
Spielelemente generieren
Zuerst werden Sie Elemente generieren. Die Datei ./generators/item_generator.py enthält eine Aufgabe zum Erstellen von Spielelementen mit zufälligen Strings für Namen und zufälligen Preiswerten:
# Generate random items
class ItemLoad(HttpUser):
def generateItemName(self):
return ''.join(random.choices(string.ascii_lowercase + string.digits, k=32))
def generateItemValue(self):
return str(decimal.Decimal(random.randrange(100, 10000))/100)
@task
def createItem(self):
headers = {"Content-Type": "application/json"}
data = {"item_name": self.generateItemName(), "item_value": self.generateItemValue()}
self.client.post("/items", data=json.dumps(data), headers=headers)
Mit dem folgenden Befehl wird die Datei item_generator.py aufgerufen, mit der zehn Sekunden lang Spielelemente (t=10s) generiert werden:
cd ~/spanner-gaming-sample
locust -H http://127.0.0.1:8082 -f ./generators/item_generator.py --headless -u=1 -r=1 -t=10s
Befehlsausgabe:
*snip*
/INFO/locust.main: --run-time limit reached. Stopping Locust
/INFO/locust.main: Shutting down (exit code 0)
Name # reqs # fails | Avg Min Max Median | req/s failures/s
----------------------------------------------------------------------------------------------------------------------------------------------------------------
POST /items 606 0(0.00%) | 16 12 161 15 | 60.61 0.00
----------------------------------------------------------------------------------------------------------------------------------------------------------------
Aggregated 606 0(0.00%) | 16 12 161 15 | 60.61 0.00
Response time percentiles (approximated)
Type Name 50% 66% 75% 80% 90% 95% 98% 99% 99.9% 99.99% 100% # reqs
--------|--------------------------------------------------------------------------------|---------|------|------|------|------|------|------|------|------|------|------|------|
POST /items 15 16 16 17 18 19 21 34 160 160 160 606
--------|--------------------------------------------------------------------------------|---------|------|------|------|------|------|------|------|------|------|------|------|
None Aggregated 15 16 16 17 18 19 21 34 160 160 160 606
Spieler erhalten Gegenstände und Geld
Lassen Sie die Spieler nun Gegenstände und Geld erwerben, damit sie am Handelsposten teilnehmen können. Dazu enthält die Datei ./generators/game_server.py Aufgaben zum Abrufen von Spielelementen, die Spielern zugewiesen werden können, sowie zufällige Währungsbeträge.
# Players generate items and money at 5:2 ratio. We don't want to devalue the currency!
class GameLoad(HttpUser):
def on_start(self):
self.getItems()
def getItems(self):
headers = {"Content-Type": "application/json"}
r = requests.get(f"{self.host}/items", headers=headers)
global itemUUIDs
itemUUIDs = json.loads(r.text)
def generateAmount(self):
return str(round(random.uniform(1.01, 49.99), 2))
@task(2)
def acquireMoney(self):
headers = {"Content-Type": "application/json"}
# Get a random player that's part of a game, and update balance
with self.client.get("/players", headers=headers, catch_response=True) as response:
try:
data = {"playerUUID": response.json()["playerUUID"], "amount": self.generateAmount(), "source": "loot"}
self.client.put("/players/balance", data=json.dumps(data), headers=headers)
except json.JSONDecodeError:
response.failure("Response could not be decoded as JSON")
except KeyError:
response.failure("Response did not contain expected key 'playerUUID'")
@task(5)
def acquireItem(self):
headers = {"Content-Type": "application/json"}
# Get a random player that's part of a game, and add an item
with self.client.get("/players", headers=headers, catch_response=True) as response:
try:
itemUUID = itemUUIDs[random.randint(0, len(itemUUIDs)-1)]
data = {"playerUUID": response.json()["playerUUID"], "itemUUID": itemUUID, "source": "loot"}
self.client.post("/players/items", data=json.dumps(data), headers=headers)
except json.JSONDecodeError:
response.failure("Response could not be decoded as JSON")
except KeyError:
response.failure("Response did not contain expected key 'playerUUID'")
Mit diesem Befehl können Spieler 60 Sekunden lang Gegenstände und Geld erwerben:
locust -H http://127.0.0.1:8082 -f game_server.py --headless -u=1 -r=1 -t=60s
Befehlsausgabe:
*snip*
dev-machine/INFO/locust.main: --run-time limit reached. Stopping Locust
dev-machine/INFO/locust.main: Shutting down (exit code 0)
Name # reqs # fails | Avg Min Max Median | req/s failures/s
----------------------------------------------------------------------------------------------------------------------------------------------------------------
GET /players 231 0(0.00%) | 14 9 30 13 | 23.16 0.00
PUT /players/balance 53 0(0.00%) | 33 30 39 34 | 5.31 0.00
POST /players/items 178 0(0.00%) | 26 22 75 26 | 17.85 0.00
----------------------------------------------------------------------------------------------------------------------------------------------------------------
Aggregated 462 0(0.00%) | 21 9 75 23 | 46.32 0.00
Response time percentiles (approximated)
Type Name 50% 66% 75% 80% 90% 95% 98% 99% 99.9% 99.99% 100% # reqs
--------|--------------------------------------------------------------------------------|---------|------|------|------|------|------|------|------|------|------|------|------|
GET /players 13 16 17 17 19 20 21 23 30 30 30 231
PUT /players/balance 34 34 35 35 36 37 38 40 40 40 40 53
POST /players/items 26 27 27 27 28 29 34 53 76 76 76 178
--------|--------------------------------------------------------------------------------|---------|------|------|------|------|------|------|------|------|------|------|------|
None Aggregated 23 26 27 27 32 34 36 37 76 76 76 462
Spieler, die auf dem Handelsposten kaufen und verkaufen
Da die Spieler nun über Gegenstände und das Geld verfügen, mit dem sie diese kaufen können, können sie den Handelsposten verwenden.
Die Generatordatei ./generators/trading_server.py enthält Aufgaben zum Erstellen und Ausführen dieser Bestellungen.
# Players can sell and buy items
class TradeLoad(HttpUser):
def itemMarkup(self, value):
f = float(value)
return str(f*1.5)
@task
def sellItem(self):
headers = {"Content-Type": "application/json"}
# Get a random item
with self.client.get("/trades/player_items", headers=headers, catch_response=True) as response:
try:
playerUUID = response.json()["PlayerUUID"]
playerItemUUID = response.json()["PlayerItemUUID"]
list_price = self.itemMarkup(response.json()["Price"])
# Currently don't have any items that can be sold, retry
if playerItemUUID == "":
raise RescheduleTask()
data = {"lister": playerUUID, "playerItemUUID": playerItemUUID, "list_price": list_price}
self.client.post("/trades/sell", data=json.dumps(data), headers=headers)
except json.JSONDecodeError:
response.failure("Response could not be decoded as JSON")
except KeyError:
response.failure("Response did not contain expected key 'playerUUID'")
@task
def buyItem(self):
headers = {"Content-Type": "application/json"}
# Get a random item
with self.client.get("/trades/open", headers=headers, catch_response=True) as response:
try:
orderUUID = response.json()["OrderUUID"]
buyerUUID = response.json()["BuyerUUID"]
# Currently don't have any buyers that can fill the order, retry
if buyerUUID == "":
raise RescheduleTask()
data = {"orderUUID": orderUUID, "buyer": buyerUUID}
self.client.put("/trades/buy", data=json.dumps(data), headers=headers)
except json.JSONDecodeError:
response.failure("Response could not be decoded as JSON")
except KeyError:
response.failure("Response did not contain expected key 'playerUUID'")
Mit diesem Befehl können Spieler Artikel auflisten, die sie zum Verkauf erworben haben. Andere Spieler haben dann 10 Sekunden lang die Möglichkeit, diese Artikel zu kaufen:
locust -H http://127.0.0.1:8083 -f ./generators/trading_server.py --headless -u=1 -r=1 -t=10s
Befehlsausgabe:
*snip*
Name # reqs # fails | Avg Min Max Median | req/s failures/s
----------------------------------------------------------------------------------------------------------------------------------------------------------------
PUT /trades/buy 20 5(25.00%) | 43 10 78 43 | 2.07 0.52
GET /trades/open 20 0(0.00%) | 358 7 971 350 | 2.07 0.00
GET /trades/player_items 20 0(0.00%) | 49 35 113 41 | 2.07 0.00
POST /trades/sell 20 0(0.00%) | 29 21 110 24 | 2.07 0.00
----------------------------------------------------------------------------------------------------------------------------------------------------------------
Aggregated 80 5(6.25%) | 120 7 971 42 | 8.29 0.52
Response time percentiles (approximated)
Type Name 50% 66% 75% 80% 90% 95% 98% 99% 99.9% 99.99% 100% # reqs
--------|--------------------------------------------------------------------------------|---------|------|------|------|------|------|------|------|------|------|------|------|
PUT /trades/buy 43 45 49 50 71 78 78 78 78 78 78 20
GET /trades/open 360 500 540 550 640 970 970 970 970 970 970 20
GET /trades/player_items 43 55 57 59 72 110 110 110 110 110 110 20
POST /trades/sell 24 25 25 27 50 110 110 110 110 110 110 20
--------|--------------------------------------------------------------------------------|---------|------|------|------|------|------|------|------|------|------|------|------|
None Aggregated 42 50 71 110 440 550 640 970 970 970 970 80
Zusammenfassung
In diesem Schritt haben Sie simuliert, wie sich Spieler für Spiele anmelden, und dann Simulationen für Spiele mit dem Partnervermittlungsdienst ausgeführt. Bei diesen Simulationen wurde das Locust-Python-Framework genutzt, um Anfragen an die Dienste REST API.
Sie können die für das Erstellen von Spielern und Spielen aufgewendete Zeit sowie die Anzahl der gleichzeitigen Nutzer (-u) ändern.
Nächste Schritte
Nach der Simulation sollten Sie verschiedene Statistiken überprüfen, indem Sie Spanner abfragen.
6. Handelsstatistiken abrufen
Nachdem wir simuliert haben, dass Spieler Geld und Gegenstände erwerben und diese Artikel dann auf den Handelsposten verkaufen, sehen wir uns einige Statistiken an.
Verwenden Sie dazu die Cloud Console, um Abfrageanfragen an Spanner zu senden.
Offene und ausgeführte Handelsbestellungen prüfen
Beim Kauf eines TradeOrder auf dem Handelsposten wird das Metadatenfeld filled aktualisiert.
Mit dieser Abfrage können Sie prüfen, wie viele Bestellungen offen und wie viele ausgeführt wurden:
-- Open vs Filled Orders
SELECT Type, NumTrades FROM
(SELECT "Open Trades" as Type, count(*) as NumTrades FROM trade_orders WHERE active=true
UNION ALL
SELECT "Filled Trades" as Type, count(*) as NumTrades FROM trade_orders WHERE filled=true
)
Ergebnis:
Typ | NumTrades |
Offene Transaktionen | 159 |
Ausgefüllte Trades | 454 |
Guthaben und Anzahl der Artikel im Spielerkonto prüfen
Ein Spieler spielt ein Spiel, wenn seine Spalte current_game angegeben ist. Andernfalls spielen sie gerade kein Spiel.
Die Top 10 der Spieler, die derzeit die meisten Artikel spielen, mit ihrem account_balance
, verwenden Sie diese Abfrage :
SELECT playerUUID, account_balance, (SELECT COUNT(*) FROM player_items WHERE playerUUID=p.PlayerUUID) AS numItems, current_game
FROM players AS p
WHERE current_game IS NOT NULL
ORDER BY numItems DESC
LIMIT 10;
Ergebnis:
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
Zusammenfassung
In diesem Schritt haben Sie verschiedene Statistiken zu Spieler- und Handelsbestellungen mithilfe der Cloud Console überprüft, um Spanner abzufragen.
Nächste Schritte
Als Nächstes ist es Zeit, aufzuräumen!
7. Bereinigen
Nach so viel Spaß beim Spielen mit Spanner müssen wir unseren Spielplatz aufräumen. Dies ist ein einfacher Schritt. Rufen Sie einfach den Bereich „Cloud Spanner“ der Cloud Console auf und löschen Sie die Instanz, die wir für dieses Codelab erstellt haben.
8. Glückwunsch!
Herzlichen Glückwunsch, Sie haben erfolgreich ein Beispielspiel in Spanner bereitgestellt
Nächste Schritte
In diesem Lab haben Sie zwei Dienste eingerichtet, um Spielelemente zu generieren und Spieler Artikel zu erwerben, die auf der Handelsposten verkauft werden sollen.
Diese Codebeispiele sollen Ihnen ein besseres Verständnis dafür vermitteln, wie die Cloud Spanner-Konsistenz innerhalb von Transaktionen sowohl bei DML- als auch bei Spanner-Mutationen funktioniert.
Sie können die bereitgestellten Generatoren verwenden, um die Skalierung von Spanner zu erkunden.