1. Giriş
Cloud Spanner, performanstan ve yüksek kullanılabilirlikten ödün vermeden ACID işlemleri ve SQL semantiği sağlayan, tümüyle yönetilen, yatay olarak ölçeklenebilir, küresel olarak dağıtılmış bir ilişkisel veritabanı hizmetidir.
Bu özellikler, Spanner'ı küresel bir oyuncu tabanı oluşturmak isteyen veya veri tutarlılığı konusunda endişeli olan oyunların mimarisine mükemmel bir uyum sağlar
Bu laboratuvarda, oyuncuların öğe ve para kazanmalarını sağlamak için bölgesel bir Spanner veritabanıyla etkileşimde bulunan iki Go hizmeti oluşturacaksınız (item-service) ve ardından diğer oyuncuların satın alması için alım satım sırasında öğeleri listeleyecek (tradepost-service).
Bu laboratuvar, profile-service ve matchmaking-service kullanılarak oyuncular ve oyunlar oluşturmak için Cloud Spanner Oyun Geliştirmeye Başlama codelab'ine dayalıdır.
Ardından, "oyun" süreci boyunca para ve öğe edinmelerini simüle etmek için Python yük çerçevesi Locust.io'yu kullanarak veri oluşturacaksınız. Oyuncular daha sonra öğeleri satılık alanda listeleyebilir ve üzerlerinde yeterli paraya sahip diğer oyuncular bu öğeleri satın alabilir.
Ayrıca, oynatıcıların performansını belirlemek için Spanner'ı sorgulayacak hesap bakiyeleri ve öğe sayısı ile açık veya doldurulmuş ticari siparişlerle ilgili bazı istatistikler.
Son olarak, bu laboratuvarda oluşturulan kaynakları temizleyeceksiniz.
Neler oluşturacaksınız?
Bu laboratuvar kapsamında:
- Cloud Spanner Oyun Geliştirmeye Başlama bölümündeki Spanner örneğini yeniden kullanın.
- Oyuncuların öğe ve para almasını sağlamak için Go'da yazılmış bir Öğe hizmeti dağıtın
- Satılık öğeleri listeleyen oyuncuları ve bu öğeleri satın alan diğer oyuncuları simüle etmek için Go'da yazılmış bir Değişim Gönderisi hizmeti dağıtın.
Neler öğreneceksiniz?
- Veri değişikliklerinde tutarlılığı sağlamak için okuma-yazma işlemlerini kullanma
- Verileri değiştirmek için DML ve Spanner mutasyonlarından yararlanma
İhtiyacınız olanlar
- Faturalandırma hesabına bağlı bir Google Cloud projesi.
- Chrome veya Firefox gibi bir web tarayıcısı.
- Daha önce Cloud Spanner Oyun Geliştirmeye Başlama adımını temizleme adımı olmadan tamamlamıştı.
2. Kurulum ve Gereksinimler
Cloud Spanner Oyun Geliştirmeye Başlama codelab'ini tamamlayın
Cloud Spanner Oyun Geliştirmeye Başlama codelab'ini tamamlayın. Oyunculardan ve oyunlardan oluşan bir veri kümesi elde etmek için bu gereklidir. Oyuncuların ve oyunların öğe ve para elde etmesi gerekir. Bu öğeler de satılık öğeleri listelemek ve takas sonrasında ürün satın almak için kullanılır.
Cloud Shell'de ortam değişkenlerini yapılandırma
Cloud Shell'i Etkinleştir'i 
tıklayarak Cloud Shell'i açın (daha önce bunu yaptığınız için temel hazırlığın yapılması ve ortama bağlanması yalnızca birkaç dakika sürer).
Cloud Shell'e bağlandıktan sonra kimliğinizin doğrulanmış olduğunu ve projenin PROJECT_ID'nize ayarlanmış olduğunu göreceksiniz.
Cloud Shell'de SPANNER ortam değişkenlerini ayarlayın
export SPANNER_PROJECT_ID=$GOOGLE_CLOUD_PROJECT
export SPANNER_INSTANCE_ID=cloudspanner-gaming
export SPANNER_DATABASE_ID=sample-game
Şemayı oluşturma
Veritabanınız oluşturulduğuna göre şimdi sample-game veritabanında şemayı tanımlayabilirsiniz.
Bu laboratuvar dört yeni tablo oluşturur: game_items, player_items, player_ledger_entries ve trade_orders.
Oyuncu öğesi ilişkileri
Ticari sipariş ilişkileri
Oyun öğeleri, game_items tablosuna eklenir ve ardından oyuncular tarafından edinilebilir. Oyuncuların yalnızca geçerli öğeleri aldığından emin olmak için player_items tablosunda hem itemUUID hem de PlayerUUID'nin yabancı anahtarları bulunur.
player_ledger_entries tablosu, oyuncunun hesap bakiyesindeki parasal değişiklikleri takip eder. Bu, ganimetten para elde etmek veya takas alanında ürün satarak olabilir.
Son olarak, trade_orders tablosu satış siparişlerinin yayınlanması ve alıcıların bu siparişleri karşılaması için kullanılır.
Şemayı oluşturmak için Cloud Console'da Write DDL düğmesini tıklamanız gerekir:
Burada, schema/trading.sql dosyasından şema tanımını girmeniz gerekir:
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" seçeneğini tıklayın düğmesini tıklayın ve şema güncellemesinin tamamlanmasını bekleyin:
Sıradaki
Sonra, öğe hizmetini dağıtmalısınız.
3. Öğe hizmetini dağıtma
Hizmete genel bakış
Öğe hizmeti, Go'da yazılmış ve gin çerçevesinden yararlanan bir REST API'dir. Bu API'de, açık oyunlara katılan oyuncular para ve öğe edinir.
./src/golang/item-service/main.go dosyası, aşağıdaki uç noktaları, oyun öğeleriyle ve bu öğeleri edinen oyuncularla çalışacak şekilde yapılandırır. Ayrıca, oyuncuların para kazanabilecekleri bir uç nokta da var.
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 Bağlantılarının yapılandırılması ve kullanılması, önceki codelab'deki profil-hizmet ve eşleştirme-hizmeti ile tam olarak aynı şekilde gerçekleştirilir.
Öğe hizmeti, aşağıdaki tanımlara sahip GameItem, Player,PlayerLedger ve PlayerItem ile çalışır:
// 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"`
}
İlk olarak, oyunda bazı öğelerin oluşturulması gerekir. Bunu yapmak için /items uç noktasına bir POST isteği çağrılır. Bu, game_items tablosuna yapılan çok basit bir DML eklemesidir.
// 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
}
Bir öğeyi almak için /players/items uç noktasına bir POST isteği çağrılır. Bu uç noktanın mantığı, oyun öğesinin mevcut değerini ve oyuncunun mevcut oyun oturumunu almaktır. Ardından, player_items tablosuna, öğe edinmenin kaynağını ve zamanını belirten uygun bilgileri ekleyin.
Bu, aşağıdaki işlevlerle eşleşir:
// 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
}
Oyuncunun para edinebilmesi için /players/updatebalance uç noktasına yapılan bir PUT isteği çağrılır.
Bu uç noktanın mantığı, amount uygulandıktan sonra oynatıcının bakiyesini güncellemek ve player_ledger_entries tablosunu edinme kaydı ile güncellemektir. Oyuncunun account_balance ayarı arayana döndürülecek şekilde değiştirilir. DML hem oynatıcıları hem de oynatıcı_belgeleri_girişlerini değiştirmek için kullanılır.
Bu, aşağıdaki işlevlerle eşleşir:
// 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
}
Hizmet, varsayılan olarak ortam değişkenleri kullanılarak yapılandırılır. ./src/golang/item-service/config/config.go dosyasının ilgili bölümüne bakın.
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
}
Varsayılan davranışın, hizmeti localhost:8082 üzerinde çalıştırmak olduğunu göreceksiniz.
Bu bilgiler doğrultusunda hizmeti çalıştırma zamanı gelmiş demektir.
Hizmeti çalıştırma
Hizmeti çalıştırmak bağımlılıkları indirir ve 8082 bağlantı noktasında çalışan hizmeti kurar:
cd ~/spanner-gaming-sample/src/golang/item-service
go run . &
Komut çıkışı:
[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
Bir öğe oluşturmak için curl komutu vererek hizmeti test edin:
curl http://localhost:8082/items \
--include \
--header "Content-Type: application/json" \
--request "POST" \
--data '{"item_name": "test_item","item_value": "3.14"}'
Komut çıkışı:
HTTP/1.1 201 Created
Content-Type: application/json; charset=utf-8
Date: <Date>
Content-Length: 38
"aecde380-0a79-48c0-ab5d-0da675d3412c"
Daha sonra, bir oyuncunun bu öğeyi edinmesini istiyorsunuz. Bunu yapmak için bir ItemUUID ve PlayerUUID kullanmanız gerekir. ItemUUID, önceki komutun çıkışıdır. Bu örnekte boyut: aecde380-0a79-48c0-ab5d-0da675d3412c.
PlayerUUID almak için GET /players uç noktasına çağrı yapın:
curl http://localhost:8082/players
Komut çıkışı:
{
"playerUUID": "b74cc194-87b0-4a55-a67f-0f0742ef6352",
"updated": "0001-01-01T00:00:00Z",
"account_balance": {},
"current_game": "7b97fa85-5658-4ded-a962-4c09269a0a79"
}
Oynatıcının öğeyi edinmesi için POST /players/items uç noktasına bir istek gönderin:
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"}'
Komut çıkışı:
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
}
Özet
Bu adımda, oyun öğelerinin oluşturulmasına olanak tanıyan öğe hizmetini dağıttınız ve açık oyunlara atanan oyuncular para ve oyun öğeleri elde edebilmektedir.
Sonraki Adımlar
Bir sonraki adımda takas hizmetini dağıtacaksınız.
4. Tradepost hizmetini dağıtın
Hizmete genel bakış
Tradepost hizmeti, Go'da yazılmış ve cin çerçevesinden yararlanan bir REST API'dir. Bu API'de, oynatıcı öğeleri satmak için yayınlanır. Daha sonra oyunların oyuncuları açık takas alabilir ve yeterli paraları varsa öğeyi satın alabilirler.
Tradepost hizmetinin ./src/golang/tradepost-service/main.go dosyası, diğer hizmetlerle benzer bir kuruluma ve koda sahip olduğundan burada tekrarlanmaz. Bu hizmet, çeşitli uç noktaları aşağıdaki gibi sunar:
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())
}
Bu hizmet, bir TradeOrder yapısı ile birlikte TradeOrder ve TradeOrder yapıları için gerekli struct'ları da sağlar:
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"`
}
Ticari sipariş oluşturmak için /trades/sell API uç noktasına bir POST isteği gönderilir. Gerekli bilgiler, satılacak Player_item öğesinin playerItemUUID değeri, lister ve list_price'dir.
Ticari sırası oluşturmak ve Player_item öğesini görünür değil olarak işaretlemek için Spanner mutasyonları seçilir. Bu, satıcının yinelenen öğeleri satış için yayınlamasını engeller.
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, siparişi gerçekten oluşturulmadan önce satışa listelenebildiğinden emin olmak için doğrulanır. Temel olarak bu, PlayerItem'in oynatıcı tarafından görülebileceği ve süresinin dolmadığı anlamına gelir.
// 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
}
Satın alma işlemi, /trades/buy uç noktasına yapılan bir PUT isteğiyle gerçekleştirilir. Gerekli bilgiler, orderUUID ve alıcıdır. Bu, satın alma işlemini yapan oynatıcının UUID'sidir.
Bu karmaşıklık ve değişiklik miktarı nedeniyle, siparişi satın almak için tekrar mutasyonlar seçilir. Aşağıdaki işlemler tek bir okuma-yazma işleminde gerçekleştirilir:
- Siparişin daha önce doldurulmadığı ve süresi dolmadığı için doldurulabileceğini doğrulayın.
// 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
}
- Alıcı bilgilerini alın ve öğeyi satın alabileceklerini doğrulayın. Bu, alıcının listeleyen ile aynı olamayacağı ve yeterli paraya sahip olduğu anlamına gelir.
// 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
}
- Siparişin list_price değerini, eşleşen bir defter girişiyle lister'in hesap bakiyesine ekleyin.
// 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
}
- Alıcının hesap bakiyesinden siparişin list_price değerini, eşleşen bir defter girişiyle çıkarın.
// Update buyer's account balance
negAmount := o.ListPrice.Neg(&o.ListPrice)
buyer.UpdateBalance(ctx, txn, *negAmount)
- PlayerItems tablosuna, oyun ve alıcı ayrıntılarıyla oyun öğesinin yeni bir örneğini ekleyerek oynatıcı_öğesini yeni oyuncuya taşıyın ve öğenin listeleyici örneğini kaldırın.
// 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
}
- Siparişler girişini, öğenin doldurulduğunu ve artık etkin olmadığını gösterecek şekilde günceller.
Satın al işlevi özet olarak şu şekilde görünür:
// 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
}
Hizmet, varsayılan olarak ortam değişkenleri kullanılarak yapılandırılır. ./src/golang/tradepost-service/config/config.go dosyasının ilgili bölümüne bakın.
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
}
Varsayılan davranışın, diğer hizmetlerle çakışma olmaması için hizmeti localhost:8083 üzerinde çalıştırmak olduğunu görebilirsiniz.*.*
Bu bilgiler doğrultusunda sıra, takas hizmetini çalıştırmaya geldi.
Hizmeti çalıştırma
Hizmet çalıştırıldığında 8083 numaralı bağlantı noktasında çalışan hizmet oluşturulur. Bu hizmet, öğe-hizmet ile aynı bağımlılıklara sahip olduğundan yeni bağımlılıklar indirilmez.
cd ~/spanner-gaming-sample/src/golang/tradepost-service
go run . &
Komut çıkışı:
[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
Öğe yayınla
Satılacak bir PlayerItem almak için GET isteği göndererek hizmeti test edin:
curl http://localhost:8083/trades/player_items
Komut çıkışı:
{
"PlayerUUID": "b74cc194-87b0-4a55-a67f-0f0742ef6352",
"PlayerItemUUID": "a42b1899-4509-4fce-9958-265d2a2838a0",
"Price": "3.14"
}
Şimdi de /trades/sel uç noktasını çağırarak satılık bir öğe yayınlayalım.
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>"}'
Komut çıkışı:
HTTP/1.1 201 Created
Content-Type: application/json; charset=utf-8
Date: <Date>
Content-Length: 38
"282ea691-b956-4c4c-95ff-f461d6415651"
Özet
Bu adımda, satış siparişlerinin oluşturulması için tradepost-service'i dağıttınız. Bu hizmet, söz konusu siparişleri satın alma işlemlerini de gerçekleştirir.
Sonraki Adımlar
Hizmetleriniz çalışmaya başladığına göre artık oyuncuları işlem yayınında satış ve satın alma simülasyonu yapmanın zamanı geldi.
5. Alım satıma başla
Ürün ve alım satım hizmetleri çalıştığına göre, sağlanan yer işareti oluşturma araçlarını kullanarak yük oluşturabilirsiniz.
Locust, oluşturucuları çalıştırmak için bir web arayüzü sunar. Ancak bu laboratuvarda, komut satırını (–gözetimsiz seçeneği) kullanacaksınız.
Oyun öğeleri oluştur
Öncelikle öğeler oluşturmanız gerekir. ./generators/item_generator.py dosyası, adlar için rastgele dizeler ve rastgele fiyat değerleriyle oyun öğeleri oluşturma görevi içerir:
# 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)
Aşağıdaki komut, 10 saniye boyunca oyun öğeleri oluşturacak item_generator.py dosyasını (t=10s) çağırır:
cd ~/spanner-gaming-sample
locust -H http://127.0.0.1:8082 -f ./generators/item_generator.py --headless -u=1 -r=1 -t=10s
Komut çıkışı:
*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
Oyuncular öğe ve para kazanır
Şimdi oyuncuların alım satım yayınına katılabilmeleri için öğe ve para kazanmalarını sağlayalım. Bunun için ./generators/game_server.py dosyasında oyunculara atanacak oyun öğelerini alma görevleriyle birlikte rastgele para birimleri kullanılır.
# 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'")
Bu komut, oyuncuların 60 saniye boyunca öğe ve para kazanmasını sağlar:
locust -H http://127.0.0.1:8082 -f game_server.py --headless -u=1 -r=1 -t=60s
Komut çıkışı:
*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
Borsada satın alma ve satış yapan oyuncular
Oyuncular artık öğe satın alabilecekleri öğelere ve paraya sahip olduklarına göre, takas alanını kullanmaya başlayabilirler.
./generators/trading_server.py oluşturma aracı, satış siparişleri oluşturup bu siparişleri karşılamak için gereken görevleri sağlar.
# 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'")
Bu komut, oyuncuların satış için edindikleri öğeleri listelemelerine ve diğer oyuncuların 10 saniye boyunca bu öğeyi satın almasına olanak tanır:
locust -H http://127.0.0.1:8083 -f ./generators/trading_server.py --headless -u=1 -r=1 -t=10s
Komut çıkışı:
*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
Özet
Bu adımda, oyun oynamaya kaydolan oyuncuları simüle ettiniz ve ardından oyuncuların eşleştirme hizmetini kullanarak oyun oynamaları için simülasyonlar yaptınız. Bu simülasyonlar, hizmetlerimize talep göndermek için Locust Python çerçevesinden REST API
Oyuncu oluşturmak ve oyun oynamak için harcanan süreyi ve eşzamanlı kullanıcı sayısını (-u) istediğiniz gibi değiştirebilirsiniz.
Sonraki Adımlar
Simülasyondan sonra, Spanner'ı sorgulayarak çeşitli istatistikleri kontrol etmek isteyebilirsiniz.
6. Ticaret istatistiklerini alma
Artık para ve öğe edinen ve bu öğeleri takas sayfasında satan oyuncuları simüle ettiğimize göre bazı istatistikleri kontrol edebiliriz.
Bunu yapmak için Cloud Console'u kullanarak Spanner'a sorgu istekleri gönderin.
Açık ve tamamlanmış ticari siparişleri kontrol etme
İşlem yayınında bir TradeOrder satın alındığında, TradeOrder meta veri alanı güncellenir.
Bu sorgu sayesinde kaç siparişin açık olduğunu ve kaç tanesinin doldurulduğunu kontrol edebilirsiniz:
-- 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
)
Sonuç:
Tür | NumTrades |
Açık Borsa | 159 |
Doldurulmuş İşlemler | 454 |
Oyuncu hesabı bakiyesini ve öğe sayısını kontrol etme
Bir oyuncu, current_game sütunu ayarlanmışsa oyun oynamaktadır. Aksi takdirde, o anda oyun oynamazlar.
account_balance değerleriyle şu anda en çok öğe içeren ilk 10 oyuncuya ulaşmak için
, şu sorguyu kullanın :
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;
Sonuç:
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
Özet
Bu adımda, Spanner'ı sorgulamak için Cloud Console'u kullanarak oyuncu ve ticari siparişlerin çeşitli istatistiklerini incelediniz.
Sonraki Adımlar
Şimdi de temizlik zamanı.
7. Temizleme
Spanner ile oynarken yaşanan tüm eğlenceden sonra oyun alanımızı temizlememiz gerekiyor. Neyse ki bu, kolay bir adımdır. Cloud Console'un Cloud Spanner bölümüne giderek bu codelab için oluşturduğumuz örneği silebilirsiniz.
8. Tebrikler!
Tebrikler, Spanner'da başarıyla örnek bir oyun dağıttınız
Sırada ne var?
Bu laboratuvarda oyun öğesi oluşturma işlemini ve oyuncuları takas ekranında satılacak öğeleri alacak iki hizmetin kurulumunu tamamladınız.
Bu kod örnekleri, işlemler içindeki Cloud Spanner tutarlılığının hem DML hem de Spanner mutasyonları için nasıl çalıştığını daha iyi anlamanızı sağlayacaktır.
Spanner'ı ölçeklendirmeyi keşfetmek için sağlanan oluşturucuları kullanabilirsiniz.