1. מבוא
Cloud Spanner הוא שירות מנוהל של מסד נתונים רלציוני, שניתן להרחבה אופקית, מבוזר גלובלית ומספק עסקאות ACID וסמנטיקה של SQL, בלי להתפשר על ביצועים וזמינות גבוהה.
התכונות האלה הופכות את Spanner לפתרון מצוין לארכיטקטורה של משחקים שרוצים לאפשר בסיס שחקנים גלובלי או שחשוב להם לשמור על עקביות הנתונים
במעבדה הזו תיצרו שני שירותי Go שפועלים באינטראקציה עם מסד נתונים אזורי של Spanner כדי לאפשר לשחקנים לרכוש פריטים וכסף (item-service), ואז לפרסם פריטים בבורסת המסחר כדי ששחקנים אחרים יוכלו לרכוש אותם (tradepost-service).
ה-Lab הזה מסתמך על ה-codelab Cloud Spanner Getting Started with Games Development, שבו נוצרו שחקנים ומשחקים באמצעות profile-service ו-matchmaking-service.
בשלב הבא תיצרו נתונים באמצעות מסגרת הטעינה של Python Locust.io כדי לדמות שחקנים שמקבלים כסף ופריטים במהלך 'משחק'. לאחר מכן, השחקנים יכולים להציג פריטים למכירה בנקודת מסחר, שבה שחקנים אחרים עם מספיק כסף יכולים לרכוש את הפריטים האלה.
תבצעו גם שאילתות ב-Spanner כדי לקבוע את יתרות החשבונות של השחקנים ואת מספר הפריטים, וגם כמה נתונים סטטיסטיים על הזמנות מסחר פתוחות או שהושלמו.
לבסוף, תסירו את המשאבים שנוצרו בשיעור ה-Lab הזה.
מה תפַתחו
במסגרת ה-Lab הזה:
- אפשר לעשות שימוש חוזר במכונת Spanner מתוך תחילת העבודה עם Cloud Spanner בפיתוח משחקים.
- פריסת שירות פריטים שנכתב ב-Go כדי לטפל בשחקנים שמשיגים פריטים וכסף
- פריסת שירות Trading Post שנכתב ב-Go כדי לדמות שחקנים שמפרסמים פריטים למכירה, ושחקנים אחרים שרוכשים את הפריטים האלה.
מה תלמדו
- איך משתמשים בעסקאות קריאה-כתיבה כדי להבטיח עקביות בשינויים בנתונים
- איך משתמשים ב-DML ובשינויים ב-Spanner כדי לשנות נתונים
הדרישות
- פרויקט ב-Google Cloud שמקושר לחשבון לחיוב.
- דפדפן אינטרנט, כמו Chrome או Firefox.
- השלמתם בעבר את המדריך תחילת העבודה עם פיתוח משחקים ב-Cloud Spanner, בלי שלב הניקוי.
2. הגדרה ודרישות
משלימים את ה-codelab בנושא תחילת העבודה עם פיתוח משחקים ב-Cloud Spanner
משלימים את ה-codelab בנושא תחילת העבודה עם פיתוח משחקים ב-Cloud Spanner. הפעולה הזו נדרשת כדי לקבל מערך נתונים של שחקנים ומשחקים. השחקנים והמשחקים צריכים להשיג פריטים וכסף, שמשמשים בתורם להצגת פריטים למכירה ולרכישת פריטים מנקודת המסחר.
הגדרת משתני סביבה ב-Cloud Shell
פותחים את Cloud Shell על ידי לחיצה על 'הפעלת Cloud Shell' 
(ההקצאה והחיבור לסביבת העבודה אמורים להימשך רק כמה רגעים, כי כבר עשיתם את זה בעבר).
אחרי שמתחברים ל-Cloud Shell, אמור להופיע אימות שכבר בוצע ושהפרויקט כבר הוגדר לפי PROJECT_ID.
הגדרת משתני הסביבה של Spanner ב-Cloud Shell
export SPANNER_PROJECT_ID=$GOOGLE_CLOUD_PROJECT
export SPANNER_INSTANCE_ID=cloudspanner-gaming
export SPANNER_DATABASE_ID=sample-game
יצירת הסכימה
אחרי שיוצרים את מסד הנתונים, אפשר להגדיר את הסכימה במסד הנתונים sample-game.
במעבדה הזו ייצרו ארבע טבלאות חדשות: game_items, player_items, player_ledger_entries ו-trade_orders.
קשרים בין פריטים בנגן
קשרים בין הזמנות מסחריות
פריטים במשחק מתווספים לטבלה game_items, ואז השחקנים יכולים לרכוש אותם. בטבלה player_items יש מפתחות זרים גם ל-itemUUID וגם ל-playerUUID, כדי לוודא שהשחקנים רוכשים רק פריטים תקינים.
בטבלה player_ledger_entries מתועדים כל השינויים הכספיים ביתרת החשבון של השחקן. אפשר להשיג כסף משלל או ממכירת פריטים בנקודת המסחר.
לבסוף, הטבלה trade_orders משמשת לפרסום הזמנות מכירה ולביצוע ההזמנות האלה על ידי הקונים.
כדי ליצור את הסכימה, לוחצים על הלחצן Write DDL ב-Cloud Console:
כאן מזינים את הגדרת הסכימה מקובץ schema/trading.sql:
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);
לוחצים על הלחצן Submit' כדי לשנות את הסכימה, ומחכים עד שעדכון הסכימה יסתיים:
הבא בתור
בשלב הבא תפרסו את שירות הפריטים.
3. פריסת שירות הפריטים
סקירה כללית על השירות
שירות הפריטים הוא API בארכיטקטורת REST שנכתב ב-Go ומתבסס על מסגרת gin. ב-API הזה, שחקנים שמשתתפים במשחקים פתוחים מקבלים כסף ופריטים.
קובץ ./src/golang/item-service/main.go מגדיר את נקודות הקצה הבאות לעבודה עם פריטים במשחק ושחקנים שמשיגים את הפריטים האלה. בנוסף, יש נקודת קצה שמאפשרת לשחקנים להשיג כסף.
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())
}
ההגדרה והשימוש בחיבורים ל-Spanner מתבצעים בדיוק כמו בשירות פרופיל ובשירות שידוך מה-codelab הקודם.
שירות הפריטים פועל עם GameItem, Player, PlayerLedger ו-PlayerItem עם ההגדרות הבאות:
// 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"`
}
קודם כול, צריך ליצור פריטים במשחק. כדי לעשות זאת, מתבצעת קריאה לבקשת POST לנקודת הקצה /items. זוהי פקודת DML פשוטה מאוד להוספה לטבלה 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
}
כדי לרכוש פריט, צריך לבצע קריאה לבקשת POST לנקודת הקצה /players/items. הלוגיקה של נקודת הקצה הזו היא לאחזר את הערך הנוכחי של פריט במשחק ואת סשן המשחק הנוכחי של השחקן. לאחר מכן, מוסיפים את המידע המתאים לטבלה player_items כדי לציין את המקור ואת השעה שבה הפריט נרכש.
הפונקציות האלה ממופות לפונקציות הבאות:
// 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
}
כדי ששחקן יקבל כסף, מתבצעת קריאה של בקשת PUT לנקודת הקצה /players/updatebalance.
הלוגיקה של נקודת הקצה הזו היא לעדכן את היתרה של השחקן אחרי החלת הסכום, וגם לעדכן את הטבלה player_ledger_entries ברשומה של הרכישה. הערך של account_balance של השחקן משתנה ומוחזר למתקשר. משתמשים ב-DML כדי לשנות גם את הטבלה players וגם את הטבלה player_ledger_entries.
הפונקציות האלה ממופות לפונקציות הבאות:
// 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
}
כברירת מחדל, השירות מוגדר באמצעות משתני סביבה. אפשר לעיין בקטע הרלוונטי בקובץ ./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
}
אפשר לראות שפעולת ברירת המחדל היא להריץ את השירות בכתובת localhost:8082.
עכשיו אפשר להפעיל את השירות.
הפעלת השירות
הפעלת השירות תגרום להורדת יחסי התלות, והשירות יפעל ביציאה 8082:
cd ~/spanner-gaming-sample/src/golang/item-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] 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
כדי לבדוק את השירות, מריצים פקודת curl ליצירת פריט:
curl http://localhost:8082/items \
--include \
--header "Content-Type: application/json" \
--request "POST" \
--data '{"item_name": "test_item","item_value": "3.14"}'
פלט הפקודה:
HTTP/1.1 201 Created
Content-Type: application/json; charset=utf-8
Date: <Date>
Content-Length: 38
"aecde380-0a79-48c0-ab5d-0da675d3412c"
בשלב הבא, רוצים ששחקן יקבל את הפריט הזה. כדי לעשות את זה, אתם צריכים ItemUUID ו-PlayerUUID. ItemUUID הוא הפלט מהפקודה הקודמת. בדוגמה הזו, זהו הערך: aecde380-0a79-48c0-ab5d-0da675d3412c.
כדי לקבל PlayerUUID, מבצעים קריאה לנקודת הקצה GET /players:
curl http://localhost:8082/players
פלט הפקודה:
{
"playerUUID": "b74cc194-87b0-4a55-a67f-0f0742ef6352",
"updated": "0001-01-01T00:00:00Z",
"account_balance": {},
"current_game": "7b97fa85-5658-4ded-a962-4c09269a0a79"
}
כדי שהשחקן יקבל את הפריט, צריך לשלוח בקשה לנקודת הקצה POST /players/items:
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"}'
פלט הפקודה:
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
}
סיכום
בשלב הזה, פרסתם את שירות הפריטים שמאפשר ליצור פריטים במשחק, ולשחקנים שמשתתפים במשחקים פתוחים לקבל כסף ופריטים במשחק.
השלבים הבאים
בשלב הבא תפעילו את שירות ה-tradepost.
4. פריסת שירות תחנת המסחר
סקירה כללית על השירות
שירות ה-tradepost הוא API בארכיטקטורת REST שנכתב ב-Go ומתבסס על מסגרת gin. ב-API הזה, פריטים של שחקנים נשלחים למכירה. שחקנים במשחקים יכולים לראות הצעות למסחר פתוח, ואם יש להם מספיק כסף, הם יכולים לרכוש את הפריט.
הקובץ ./src/golang/tradepost-service/main.go של שירות tradepost כולל הגדרה וקוד דומים לאלה של השירותים האחרים, ולכן הוא לא מופיע כאן. השירות הזה חושף כמה נקודות קצה, באופן הבא:
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())
}
השירות הזה מספק מבנה נתונים מסוג TradeOrder, וגם מבני נתונים נדרשים מסוג GameItem, PlayerItem, Player ו-PlayerLedger:
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"`
}
כדי ליצור הזמנת מסחר, שולחים בקשת POST לנקודת קצה ל-API /trades/sell. המידע הנדרש הוא playerItemUUID של פריט השחקן שרוצים למכור, lister ו-list_price.
מוטציות של Spanner נבחרות כדי ליצור את הזמנת המסחר ולסמן את player_item כלא גלוי. הפעולה הזו מונעת מהמוכר לפרסם פריטים כפולים למכירה.
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
}
לפני שיוצרים את ההזמנה בפועל, המערכת מאמתת את PlayerItem כדי לוודא שאפשר להציג אותו למכירה. המשמעות העיקרית היא שפריט הנגן גלוי לנגן, ושהתוקף שלו לא פג.
// 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
}
כדי לבצע רכישה, שולחים בקשת PUT לנקודת הקצה /trades/buy. המידע הנדרש הוא orderUUID ו-buyer, שהוא ה-UUID של השחקן שמבצע את הרכישה.
בגלל המורכבות הזו וכמות השינויים, שוב נבחרות מוטציות כדי לרכוש את ההזמנה. הפעולות הבאות מתבצעות בטרנזקציה אחת של קריאה וכתיבה:
- מוודאים שאפשר למלא את ההזמנה כי היא לא מולאה בעבר והתוקף שלה לא פג.
// 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
}
- מאחזרים את פרטי הקונה ומוודאים שיש לו אפשרות לרכוש את הפריט. כלומר, הקונה לא יכול להיות אותו אדם שפרסם את המוצר, ויש לו מספיק כסף.
// 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
}
- מוסיפים את מחיר המחירון של ההזמנה ליתרת החשבון של המוכר, עם רשומה תואמת בספר החשבונות.
// 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
}
- מפחיתים את מחיר המחירון של ההזמנה מיתרת החשבון של הקונה, עם רישום תואם בספר החשבונות.
// Update buyer's account balance
negAmount := o.ListPrice.Neg(&o.ListPrice)
buyer.UpdateBalance(ctx, txn, *negAmount)
- מעבירים את player_item לשחקן החדש על ידי הוספת מופע חדש של פריט המשחק עם פרטי המשחק ופרטי הקונה לטבלה PlayerItems, ומסירים את המופע של הפריט של המוכר.
// 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
}
- העדכון של הרשומה Orders מציין שהפריט מולא וכבר לא פעיל.
הפונקציה Buy נראית כך:
// 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
}
כברירת מחדל, השירות מוגדר באמצעות משתני סביבה. אפשר לעיין בקטע הרלוונטי בקובץ ./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
}
אפשר לראות שההתנהגות שמוגדרת כברירת מחדל היא הפעלת השירות ב-localhost:8083 כדי למנוע התנגשויות עם שירותים אחרים*.*
עכשיו, אחרי שיש לכם את המידע הזה, הגיע הזמן להפעיל את שירות תחנת המסחר.
הפעלת השירות
הפעלת השירות תגרום להפעלת השירות ביציאה 8083. לשירות הזה יש הרבה יחסי תלות כמו לשירות הפריטים, לכן לא יורדו יחסי תלות חדשים.
cd ~/spanner-gaming-sample/src/golang/tradepost-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] 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
פרסום פריט
בודקים את השירות על ידי שליחת בקשת GET לאחזור PlayerItem למכירה:
curl http://localhost:8083/trades/player_items
פלט הפקודה:
{
"PlayerUUID": "b74cc194-87b0-4a55-a67f-0f0742ef6352",
"PlayerItemUUID": "a42b1899-4509-4fce-9958-265d2a2838a0",
"Price": "3.14"
}
עכשיו נפרסם פריט למכירה באמצעות קריאה לנקודת הקצה /trades/sell
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>"}'
פלט הפקודה:
HTTP/1.1 201 Created
Content-Type: application/json; charset=utf-8
Date: <Date>
Content-Length: 38
"282ea691-b956-4c4c-95ff-f461d6415651"
סיכום
בשלב הזה, פרסתם את tradepost-service כדי לטפל ביצירת הזמנות מכירה. השירות הזה גם מאפשר לקנות את ההזמנות האלה.
השלבים הבאים
עכשיו, אחרי שהשירותים שלכם פועלים, הגיע הזמן לדמות שחקנים שמוכרים וקונים בנקודת המסחר!
5. התחלת מסחר
עכשיו, כשהשירותים של הפריט ושל תחנת המסחר פועלים, אפשר ליצור עומס באמצעות מחוללי הארבה שסופקו.
ל-Locust יש ממשק אינטרנט להרצת הגנרטורים, אבל בשיעור ה-Lab הזה תשתמשו בשורת הפקודה (האפשרות –headless).
יצירת פריטים במשחק
קודם כול, צריך ליצור פריטים. הקובץ ./generators/item_generator.py כולל משימה ליצירת פריטים למשחק עם מחרוזות אקראיות לשמות וערכי מחיר אקראיים:
# 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)
הפקודה הבאה קוראת לקובץ item_generator.py שייצור פריטים למשחק למשך 10 שניות (t=10s):
cd ~/spanner-gaming-sample
locust -H http://127.0.0.1:8082 -f ./generators/item_generator.py --headless -u=1 -r=1 -t=10s
פלט הפקודה:
*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
השחקנים מקבלים פריטים וכסף
בשלב הבא, נגרום לשחקנים להשיג פריטים וכסף כדי שיוכלו להשתתף בנקודת המסחר. לשם כך, הקובץ ./generators/game_server.py מספק משימות לאחזור פריטים במשחק להקצאה לשחקנים, וגם סכומים אקראיים של מטבע.
# 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'")
הפקודה הזו תאפשר לשחקנים להשיג פריטים וכסף למשך 60 שניות:
locust -H http://127.0.0.1:8082 -f game_server.py --headless -u=1 -r=1 -t=60s
פלט הפקודה:
*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
שחקנים שקונים ומוכרים בנקודת המסחר
עכשיו, כשיש לשחקנים פריטים וכסף לקניית פריטים, הם יכולים להתחיל להשתמש בנקודת המסחר.
קובץ הגנרטור ./generators/trading_server.py מספק משימות ליצירת הזמנות מכירה ולביצוע ההזמנות האלה.
# 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'")
הפקודה הזו מאפשרת לשחקנים להציג למכירה פריטים שהם השיגו, ולשחקנים אחרים לרכוש את הפריטים האלה למשך 10 שניות:
locust -H http://127.0.0.1:8083 -f ./generators/trading_server.py --headless -u=1 -r=1 -t=10s
פלט הפקודה:
*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
סיכום
בשלב הזה, הדמייתם שחקנים שנרשמים לשחק במשחקים, ואז הפעלתם הדמיות של שחקנים שמשחקים במשחקים באמצעות שירות השידוך. הסימולציות האלה הסתמכו על מסגרת Locust Python כדי להנפיק בקשות ל-REST API של השירותים שלנו.
אתם יכולים לשנות את משך הזמן שמוקדש ליצירת שחקנים ולמשחק, וגם את מספר המשתמשים בו-זמנית (-u).
השלבים הבאים
אחרי הסימולציה, כדאי לבדוק נתונים סטטיסטיים שונים באמצעות שאילתות ב-Spanner.
6. אחזור נתונים סטטיסטיים של מסחר
אחרי שסימולציית השחקנים רכשה כסף ופריטים, ואז מכרה את הפריטים האלה בנקודת המסחר, נבדוק כמה נתונים סטטיסטיים.
כדי לעשות זאת, משתמשים במסוף Cloud כדי להנפיק בקשות לשאילתות ל-Spanner.
בדיקת הזמנות פתוחות לעומת הזמנות שסופקו
כשרוכשים TradeOrder בנקודת המסחר, שדה המטא-נתונים filled מתעדכן.
השאילתה הזו תאפשר לכם לבדוק כמה הזמנות פתוחות וכמה הזמנות מולאו:
-- 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
)
תוצאה:
סוג | NumTrades |
Open Trades | 159 |
טריידים מלאים | 454 |
בדיקת היתרה בחשבון של השחקן ומספר הפריטים
שחקן משחק במשחק אם העמודה current_game שלו מוגדרת. אחרת, הם לא משחקים כרגע.
כדי להגיע ל-10 השחקנים המובילים שמשחקים כרגע במשחקים עם הכי הרבה פריטים, עם account_balance
, משתמשים בשאילתה הזו :
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;
תוצאה:
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
סיכום
בשלב הזה, בדקתם נתונים סטטיסטיים שונים של שחקנים והזמנות מסחר באמצעות שאילתות ב-Spanner דרך Cloud Console.
השלבים הבאים
עכשיו הגיע הזמן לנקות!
7. סידור וארגון
אחרי שנהנינו לשחק עם Spanner, צריך לנקות את ארגז החול. למזלנו, זה שלב פשוט. פשוט נכנסים אל הקטע Cloud Spanner ב-Cloud Console ומוחקים את המופע שיצרנו בשביל ה-codelab הזה.
8. מעולה!
כל הכבוד, פרסת בהצלחה משחק לדוגמה ב-Spanner
מה השלב הבא?
בשיעור ה-Lab הזה השלמתם את ההגדרה של שני שירותים לטיפול ביצירת פריטים במשחק ובשחקנים שרוכשים פריטים למכירה בנקודת המסחר.
דוגמאות הקוד האלה יעזרו לכם להבין טוב יותר איך העקביות ב-Cloud Spanner פועלת בתוך טרנזקציות, גם ב-DML וגם במוטציות של Spanner.
אתם יכולים להשתמש בגנרטורים שסיפקנו כדי לבדוק את יכולת ההרחבה של Spanner.