1. مقدمة
Cloud Spanner هي خدمة قاعدة بيانات ارتباطية وقابلة للتطوير أفقيًا وموزعة عالميًا، وتوفّر معاملات ACID ودلالات SQL بدون التخلّي عن الأداء والتوفّر العالي.
تجعل هذه الميزات Spanner من الألعاب الرائعة التي تسعى إلى بناء قاعدة لاعبين عالميين أو تهتمّ باتساق البيانات.
في هذا التمرين المعملي، سيتم إنشاء خدمتين من خدمات Go تتفاعل مع قاعدة بيانات Spanner إقليمية لتمكين اللاعبين من الحصول على العناصر والمال (item-service)، ثم إدراج عناصر في موقع التداول ليشتريها اللاعبون الآخرون (tradepost-service).
يعتمد هذا التمرين المعملي على الدرس التطبيقي حول الترميز Cloud Spanner "بدء تطوير الألعاب" لإنشاء لاعبين وألعاب باستخدام 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 وPlay وPlayLedger و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.
الغرض من نقطة النهاية هذه هو تعديل رصيد اللاعب بعد تطبيق قيمة amount، بالإضافة إلى تعديل جدول player_ledger_entries بسجلّ عملية الاكتساب. تم تعديل رصيد حساب اللاعب لإعادته إلى المتصل. يتم استخدام 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
}
ملخّص
في هذه الخطوة، فعّلت خدمة العناصر التي تتيح إنشاء عناصر في اللعبة، وأتاحت للّاعبين المخصّصين للألعاب المفتوحة كسب الأموال وعناصر اللعبة.
الخطوات التالية
في الخطوة التالية، ستقوم بنشر خدمة البريد التجاري.
4. نشر خدمة البريد التجاري
نظرة عامة حول الخدمة
خدمة 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 وPlayItem وPlay و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 والمشتري، وهو المعرّف الفريد العالمي للمشغّل الذي يُجري عملية الشراء.
وبسبب هذا التعقيد وحجم التغييرات، يتم اختيار التغييرات مرة أخرى لشراء الطلب. تتم العمليات التالية في معاملة قراءة وكتابة واحدة:
- يُرجى التحقّق من إمكانية ملء الطلب لأنّه لم يتم ملؤه مسبقًا ولم تنتهِ صلاحيته.
// 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، وإزالة مثال lister للعنصر.
// 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 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. تحتوي هذه الخدمة على العديد من التبعيات نفسها مثل خدمة item-الخدمة، لذلك لن يتم تنزيل التبعيات الجديدة.
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/sel
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 واجهة ويب لتشغيل أدوات إنشاء المنشئين، ولكنك ستستخدم في هذا التمرين المعملي سطر الأوامر (خيار -بلا واجهة مستخدم رسومية).
إنشاء عناصر في اللعبة
أولاً، ستحتاج إلى إنشاء عناصر. يتضمن الملف ./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 ثوانٍ (item_generator.py:
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 في مركز التداول، يتم تعديل حقل البيانات الوصفية TradeOrder.
سيساعدك هذا الاستعلام في التحقق من عدد الطلبات المفتوحة وعدد الطلبات التي تم ملؤها:
-- 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 |
التداولات المفتوحة | 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.