1. مقدمة
Cloud Spanner هي خدمة قواعد بيانات ارتباطية مُدارة بالكامل وقابلة للتوسّع أفقيًا وموزّعة على مستوى العالم، وتوفّر معاملات ACID ودلالات SQL بدون التنازل عن الأداء العالي ومدى التوفّر العالي.
تجعل هذه الميزات من Spanner خيارًا مناسبًا لبنية الألعاب التي تريد إتاحة قاعدة لاعبين عالمية أو التي تهتم باتساق البيانات.
في هذا المختبر، ستنشئ خدمتَين من Go تتفاعلان مع قاعدة بيانات إقليمية في Spanner لتمكين اللاعبين من الحصول على عناصر وأموال (item-service)، ثم إدراج العناصر في مركز التداول ليشتريها لاعبون آخرون (tradepost-service).
يعتمد هذا المختبر على درس تطبيقي حول الترميز Cloud Spanner Getting Started with Games Development لإنشاء لاعبين وألعاب باستخدام profile-service وmatchmaking-service.
بعد ذلك، ستنشئ بيانات باستخدام إطار عمل تحميل Python Locust.io لمحاكاة اللاعبين الذين يحصلون على الأموال والعناصر خلال "اللعب". يمكن للاعبين بعد ذلك إدراج عناصر للبيع في مركز تجاري، حيث يمكن للاعبين الآخرين الذين لديهم ما يكفي من المال شراء هذه العناصر.
ستطلب أيضًا من Spanner تحديد أرصدة حسابات اللاعبين وعدد السلع، وبعض الإحصاءات حول طلبات التداول المفتوحة أو التي تم تنفيذها.
وأخيرًا، ستنظّف الموارد التي تم إنشاؤها في هذا الدرس التطبيقي.
ما ستنشئه
في هذا الدرس التطبيقي، ستنفّذ ما يلي:
- أعِد استخدام مثيل Spanner من بدء استخدام Cloud Spanner في تطوير الألعاب.
- نشر خدمة "العناصر" مكتوبة بلغة Go للتعامل مع اللاعبين الذين يحصلون على عناصر وأموال
- يمكنك نشر خدمة Trading Post مكتوبة بلغة Go لمحاكاة اللاعبين الذين يعرضون سلعًا للبيع، واللاعبين الآخرين الذين يشترون هذه السلع.
أهداف الدورة التعليمية
- كيفية استخدام معاملات القراءة والكتابة لضمان الاتساق عند إجراء تغييرات على البيانات
- كيفية الاستفادة من DML وعمليات التغيير في Spanner لتعديل البيانات
المتطلبات
- مشروع على السحابة الإلكترونية من Google Cloud مرتبط بحساب الفوترة.
- متصفّح ويب، مثل Chrome أو Firefox
- أكملت سابقًا برنامج بدء استخدام Cloud Spanner في تطوير الألعاب، بدون خطوة التنظيف.
2. الإعداد والمتطلبات
أكمِل الدرس التطبيقي حول الترميز "بدء استخدام Cloud Spanner في تطوير الألعاب".
أكمِل درس بدء استخدام 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- تفعيل خدمة العناصر
نظرة عامة على الخدمة
خدمة العناصر هي واجهة برمجة تطبيقات REST مكتوبة بلغة Go تستخدم إطار عمل gin. في واجهة برمجة التطبيقات هذه، يحصل اللاعبون المشاركون في مباريات مفتوحة على أموال ومنتجات.
يضبط الملف ./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" تمامًا مثل خدمة الملف الشخصي وخدمة مواءمة اللاعبين من الدرس التطبيقي حول الترميز السابق.
تعمل خدمة العناصر مع 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 لتعديل كل من اللاعبين و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
نظرة عامة على الخدمة
خدمة Tradepost هي واجهة برمجة تطبيقات REST مكتوبة بلغة Go تستخدم إطار عمل Gin. في واجهة برمجة التطبيقات هذه، يتم نشر عناصر اللاعبين للبيع. يمكن للاعبي الألعاب بعد ذلك الحصول على صفقات مفتوحة، وإذا كان لديهم ما يكفي من المال، يمكنهم شراء العنصر.
يتبع الملف ./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 إلى نقطة نهاية واجهة برمجة التطبيقات /trades/sell. المعلومات المطلوبة هي playerItemUUID الخاص بـ player_item المطلوب بيعه و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 للتأكّد من إمكانية إدراجه للبيع. يعني ذلك في المقام الأول أنّ 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
}
- أضِف list_price الخاص بالطلب إلى رصيد حساب lister، مع إدخال قيد دفتر الأستاذ مطابق.
// 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
}
- اطرح list_price الخاص بالطلب من رصيد حساب المشتري، مع إدخال قيد مطابق في دفتر الأستاذ.
// 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
}
- تعدّل إدخال الطلبات للإشارة إلى أنّه تمّت معالجة السلعة ولم تعُد نشطة.
في ما يلي الشكل الكامل للدالة 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 لتجنُّب التعارض مع الخدمات الأخرى*.*
باستخدام هذه المعلومات، حان الوقت الآن لتشغيل خدمة Tradepost.
تشغيل الخدمة
سيؤدي تشغيل الخدمة إلى إنشاء الخدمة التي تعمل على المنفذ 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 المتوفّرة.
توفّر Locust واجهة ويب لتشغيل المولدات، ولكن في هذا المختبر، ستستخدم سطر الأوامر (الخيار –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 الخاصة بخدماتنا.
يمكنك تعديل الوقت المستغرَق في إنشاء اللاعبين وتشغيل الألعاب، بالإضافة إلى عدد المستخدمين المتزامنين (-u).
الخطوات التالية
بعد المحاكاة، عليك التحقّق من الإحصاءات المختلفة من خلال طلب البحث في Spanner.
6. استرداد إحصاءات التجارة
بعد أن أجرَينا محاكاة لعملية اكتساب اللاعبين للأموال والعناصر، ثم بيع هذه العناصر في مركز التداول، لنتحقّق من بعض الإحصاءات.
لإجراء ذلك، استخدِم Cloud Console لإرسال طلبات البحث إلى 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;
النتيجة:
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
ملخّص
في هذه الخطوة، راجعت إحصاءات مختلفة عن اللاعبين وأوامر التداول باستخدام Cloud Console لطلب البحث من Spanner.
الخطوات التالية
بعد ذلك، حان وقت التنظيف.
7. تنظيف
بعد كلّ المرح الذي قضيناه في اللعب باستخدام Spanner، علينا تنظيف ساحة اللعب. لحسن الحظ، هذه خطوة سهلة، ما عليك سوى الانتقال إلى قسم Cloud Spanner في Cloud Console وحذف المثيل الذي أنشأناه في هذا الدرس البرمجي.
8. تهانينا!
تهانينا، لقد نشرت عيّنة لعبة بنجاح على Spanner
ما هي الخطوات التالية؟
في هذا الدرس التطبيقي، أكملت عملية إعداد خدمتَين للتعامل مع إنشاء عناصر اللعبة وحصول اللاعبين على عناصر ليتم بيعها في مركز التداول.
من المفترض أن تمنحك نماذج الرموز البرمجية هذه فهمًا أفضل لكيفية عمل اتّساق Cloud Spanner ضمن المعاملات لكل من لغة معالجة البيانات (DML) وعمليات التعديل في Spanner.
يمكنك استخدام أدوات الإنشاء المتوفّرة لاستكشاف إمكانية توسيع نطاق Spanner.