Cloud Spanner: crea una classifica dei videogiochi con Go

1. Panoramica

Google Cloud Spanner è un servizio di database relazionale completamente gestito, scalabile orizzontalmente e distribuito a livello globale che fornisce transazioni ACID e semantica SQL senza rinunciare a prestazioni e alta disponibilità.

In questo lab imparerai a configurare un'istanza Cloud Spanner. Seguirai la procedura per creare un database e uno schema da utilizzare per una classifica dei giochi. Inizierai creando una tabella dei giocatori per le informazioni sui giocatori e una tabella dei punteggi per memorizzare i punteggi dei giocatori.

Successivamente, completerai le tabelle con dati di esempio. Quindi concluderai il lab eseguendo alcune query di esempio principali e infine eliminando l'istanza per liberare risorse.

Cosa imparerai a fare

  • Come configurare un'istanza Cloud Spanner.
  • Come creare un database e le tabelle.
  • Come utilizzare una colonna del timestamp di commit.
  • Come caricare dati nella tabella di database Cloud Spanner con timestamp.
  • Come eseguire query sul database Cloud Spanner.
  • Come eliminare l'istanza Cloud Spanner.

Che c****che ti servirà

Come utilizzerai questo tutorial?

Solo lettura Leggilo e completa gli esercizi

Come giudichi la tua esperienza con la piattaforma Google Cloud?

Principiante Livello intermedio Eccellente

2. Configurazione e requisiti

Configurazione dell'ambiente da seguire in modo autonomo

Se non disponi già di un account Google (Gmail o Google Apps), devi crearne uno. Accedi alla console della piattaforma Google Cloud ( console.cloud.google.com) e crea un nuovo progetto.

Se hai già un progetto, fai clic sul menu a discesa per la selezione del progetto in alto a sinistra nella console:

6c9406d9b014760.png

e fai clic su "NUOVO PROGETTO" nella finestra di dialogo risultante per creare un nuovo progetto:

f708315ae07353d0.png

Se non hai ancora un progetto, dovresti visualizzare una finestra di dialogo come questa per crearne uno:

870a3cbd6541ee86.png

La finestra di dialogo di creazione del progetto successiva ti consente di inserire i dettagli del nuovo progetto:

6a92c57d3250a4b3.png

Ricorda l'ID progetto, che è un nome univoco tra tutti i progetti Google Cloud (il nome precedente è già in uso e non funzionerà per te). Verrà indicato più avanti in questo codelab come PROJECT_ID.

Successivamente, se non l'hai ancora fatto, dovrai abilitare la fatturazione in Developers Console per utilizzare le risorse Google Cloud e abilitare l'API Cloud Spanner.

15d0ef27a8fbab27.png

L'esecuzione di questo codelab non dovrebbe costare più di qualche euro, ma potrebbe essere più costoso se decidi di utilizzare più risorse o se le lasci in esecuzione (consulta la sezione relativa alla pulizia alla fine di questo documento). I prezzi di Google Cloud Spanner sono documentati qui.

I nuovi utenti di Google Cloud Platform hanno diritto a una prova senza costi di 300$, che dovrebbe rendere questo codelab completamente senza costi.

Configurazione di Google Cloud Shell

Mentre Google Cloud e Spanner possono essere gestiti da remoto dal tuo laptop, in questo codelab utilizzeremo Google Cloud Shell, un ambiente a riga di comando in esecuzione nel cloud.

Questa macchina virtuale basata su Debian viene caricata con tutti gli strumenti di sviluppo necessari. Offre una home directory permanente da 5 GB e viene eseguita in Google Cloud, migliorando notevolmente le prestazioni di rete e l'autenticazione. Ciò significa che per questo codelab sarà sufficiente un browser (sì, funziona su Chromebook).

  1. Per attivare Cloud Shell dalla console Cloud, fai clic su Attiva Cloud Shell a8460e837e9f5fda.png (il provisioning e la connessione all'ambiente dovrebbero richiedere solo pochi minuti).

b532b2f19ab85dda.png

Screen Shot 2017-06-14 at 10.13.43 PM.png

Una volta stabilita la connessione a Cloud Shell, dovresti vedere che hai già eseguito l'autenticazione e che il progetto è già impostato su PROJECT_ID.

gcloud auth list

Output comando

Credentialed accounts:
 - <myaccount>@<mydomain>.com (active)
gcloud config list project

Output comando

[core]
project = <PROJECT_ID>

Se, per qualche motivo, il progetto non è impostato, invia semplicemente il seguente comando:

gcloud config set project <PROJECT_ID>

Stai cercando il tuo PROJECT_ID? Controlla l'ID utilizzato nei passaggi di configurazione o cercalo nella dashboard della console Cloud:

2485e00c1223af09.png

Cloud Shell imposta anche alcune variabili di ambiente per impostazione predefinita, cosa che può essere utile quando eseguirai comandi futuri.

echo $GOOGLE_CLOUD_PROJECT

Output comando

<PROJECT_ID>
  1. Infine, imposta la zona e la configurazione del progetto predefinite.
gcloud config set compute/zone us-central1-f

Puoi scegliere zone diverse. Per ulteriori informazioni, consulta Regioni e Zone.

Riepilogo

In questo passaggio devi configurare il tuo ambiente.

A seguire

Ora devi configurare un'istanza Cloud Spanner.

3. Configura un'istanza Cloud Spanner

In questo passaggio configuriamo la nostra istanza Cloud Spanner per il codelab. Cerca la voce Spanner 1a6580bd3d3e6783.pngnel menu a tre linee in alto a sinistra 3129589f7bc9e5ce.png o cerca Spanner premendo "/" e digita "Spanner"

36e52f8df8e13b99.png

Quindi, fai clic su 19bb9864067757cb.png e compila il modulo inserendo il nome dell'istanza cloudspanner-leaderboard per la tua istanza, scegliendo una configurazione (seleziona un'istanza a livello di regione) e imposta il numero di nodi. Per questo codelab avremo bisogno di un solo nodo. Per le istanze di produzione e per l'idoneità allo SLA (accordo sul livello del servizio) di Cloud Spanner, devi eseguire 3 o più nodi nella tua istanza Cloud Spanner.

Infine, fai clic su "Crea" e in pochi secondi hai a disposizione un'istanza Cloud Spanner.

dceb68e9ed3801e8.png

Nel passaggio successivo utilizzeremo la libreria client Go per creare un database e uno schema nella nuova istanza.

4. Crea un database e uno schema

In questo passaggio creeremo il database e lo schema di esempio.

Usiamo la libreria client Go per creare due tabelle; una tabella dei giocatori per le informazioni sui giocatori e una tabella dei punteggi per memorizzare i punteggi dei giocatori. Per farlo, seguiamo i passaggi per creare un'applicazione della console Go in Cloud Shell.

Per prima cosa, clona il codice campione per questo codelab da GitHub digitando il seguente comando in Cloud Shell:

export GO111MODULE=auto
go get -u github.com/GoogleCloudPlatform/golang-samples/spanner/...

Quindi cambia la directory in "leaderboard" in cui creerai l'applicazione.

cd gopath/src/github.com/GoogleCloudPlatform/golang-samples/spanner/spanner_leaderboard

Tutto il codice necessario per questo codelab si trova nella directory golang-samples/spanner/spanner_leaderboard/esistente come un'applicazione Go eseguibile denominata leaderboard da utilizzare come riferimento man mano che procedi nel codelab. Creeremo una nuova directory e creeremo una copia dell'applicazione Leaderboard gradualmente.

Crea una nuova directory denominata "codelab" dell'applicazione e passare alla directory al suo interno con il seguente comando:

mkdir codelab && cd $_

Ora creiamo un'applicazione Go di base denominata "Leaderboard". che utilizza la libreria client Spanner per creare una classifica composta da due tabelle; Giocatori e punteggi. Puoi farlo direttamente nell'editor di Cloud Shell:

Apri l'editor di Cloud Shell facendo clic su "Apri editor" icona evidenziata sotto:

7519d016b96ca51b.png

Crea un file denominato "leaderboard.go" nella cartella ~/gopath/src/github.com/GoogleCloudPlatform/golang-samples/spanner/codelab.

  • Per prima cosa, assicurati di avere il "codelab" selezionata nell'elenco di cartelle dell'editor di Cloud Shell.
  • Quindi seleziona "New File" (Nuovo file). nel campo "File" dell'editor di Cloud Shell o dal menu Fogli Google.
  • Inserisci "leaderboard.go" come nome per il nuovo file.

Questo è il file principale dell'applicazione che conterrà il codice dell'applicazione e i riferimenti per includere eventuali dipendenze.

Per creare il database leaderboard e le tabelle Players e Scores, copia (Ctrl + P) e incolla (Ctrl + V) il seguente codice Go nel file leaderboard.go:

package main

import (
        "context"
        "flag"
        "fmt"
        "io"
        "log"
        "os"
        "regexp"
        "time"

        "cloud.google.com/go/spanner"
        database "cloud.google.com/go/spanner/admin/database/apiv1"

        adminpb "google.golang.org/genproto/googleapis/spanner/admin/database/v1"
)

type adminCommand func(ctx context.Context, w io.Writer, adminClient *database.DatabaseAdminClient, database string) error


func createDatabase(ctx context.Context, w io.Writer, adminClient *database.DatabaseAdminClient, db string) error {
        matches := regexp.MustCompile("^(.*)/databases/(.*)$").FindStringSubmatch(db)
        if matches == nil || len(matches) != 3 {
                return fmt.Errorf("Invalid database id %s", db)
        }
        op, err := adminClient.CreateDatabase(ctx, &adminpb.CreateDatabaseRequest{
                Parent:          matches[1],
                CreateStatement: "CREATE DATABASE `" + matches[2] + "`",
                ExtraStatements: []string{
                        `CREATE TABLE Players(
                            PlayerId INT64 NOT NULL,
                            PlayerName STRING(2048) NOT NULL
                        ) PRIMARY KEY(PlayerId)`,
                        `CREATE TABLE Scores(
                            PlayerId INT64 NOT NULL,
                            Score INT64 NOT NULL,
                            Timestamp TIMESTAMP NOT NULL
                            OPTIONS(allow_commit_timestamp=true)
                        ) PRIMARY KEY(PlayerId, Timestamp),
                        INTERLEAVE IN PARENT Players ON DELETE NO ACTION`,
                },
        })
        if err != nil {
                return err
        }
        if _, err := op.Wait(ctx); err != nil {
                return err
        }
        fmt.Fprintf(w, "Created database [%s]\n", db)
        return nil
}

func createClients(ctx context.Context, db string) (*database.DatabaseAdminClient, *spanner.Client) {
        adminClient, err := database.NewDatabaseAdminClient(ctx)
        if err != nil {
                log.Fatal(err)
        }

        dataClient, err := spanner.NewClient(ctx, db)
        if err != nil {
                log.Fatal(err)
        }

        return adminClient, dataClient
}

func run(ctx context.Context, adminClient *database.DatabaseAdminClient, dataClient *spanner.Client, w io.Writer,
        cmd string, db string, timespan int) error {
        // createdatabase command
        if cmd == "createdatabase" {
                err := createDatabase(ctx, w, adminClient, db)
                if err != nil {
                        fmt.Fprintf(w, "%s failed with %v", cmd, err)
                }
                return err
        }
        return nil
}

func main() {
        flag.Usage = func() {
                fmt.Fprintf(os.Stderr, `Usage: leaderboard <command> <database_name> [command_option]

        Command can be one of: createdatabase

Examples:
        leaderboard createdatabase projects/my-project/instances/my-instance/databases/example-db
                - Create a sample Cloud Spanner database along with sample tables in your project.
`)
        }

        flag.Parse()
        flagCount := len(flag.Args())
        if flagCount != 2 {
                flag.Usage()
                os.Exit(2)
        }

        cmd, db := flag.Arg(0), flag.Arg(1)
        // Set timespan to zero, as it's not currently being used
        var timespan int = 0

        ctx, cancel := context.WithTimeout(context.Background(), 1*time.Minute)
        defer cancel()
        adminClient, dataClient := createClients(ctx, db)
        if err := run(ctx, adminClient, dataClient, os.Stdout, cmd, db, timespan); err != nil {
                os.Exit(1)
        }
}

Salva le modifiche apportate al file leaderboard.go selezionando "Salva" nel campo "File" dell'editor di Cloud Shell o dal menu Fogli Google.

Puoi utilizzare il file leaderboard.go nella directory golang-samples/spanner/spanner_leaderboard per vedere un esempio dell'aspetto del file leaderboard.go dopo aver aggiunto il codice per abilitare il comando createdatabase.

Per creare la tua app in Cloud Shell, esegui "go build" dalla directory codelab in cui si trova il file leaderboard.go:

go build leaderboard.go

Una volta creata l'applicazione, esegui l'applicazione risultante in Cloud Shell inserendo questo comando:

./leaderboard

Dovresti vedere un output simile al seguente:

Usage: leaderboard <command> <database_name> [command_option]

        Command can be one of: createdatabase

Examples:
        leaderboard createdatabase projects/my-project/instances/my-instance/databases/example-db
                - Create a sample Cloud Spanner database along with sample tables in your project.

Da questa risposta possiamo vedere che questa è l'applicazione Leaderboard che al momento ha un possibile comando: createdatabase. Possiamo vedere che l'argomento previsto del comando createdatabase è una stringa contenente un ID istanza e un ID database specifici.

Ora esegui questo comando. Assicurati di sostituire my-project con l'ID progetto che hai creato all'inizio di questo codelab.

./leaderboard createdatabase projects/my-project/instances/cloudspanner-leaderboard/databases/leaderboard

Dopo un paio di secondi, dovresti visualizzare una risposta come la seguente:

Created database [projects/my-project/instances/cloudspanner-leaderboard/databases/leaderboard] 

Nella sezione della panoramica dei database Cloud Spanner della console Cloud dovresti vedere il nuovo database e le nuove tabelle nel menu a sinistra.

a12fa65e352836b1.png

Nel passaggio successivo aggiorneremo la nostra applicazione per caricare alcuni dati nel nuovo database.

5. Carica dati

Ora abbiamo un database chiamato leaderboard contenente due tabelle: Players e Scores. Ora usiamo la libreria client Go per popolare la tabella Players con i giocatori e la tabella Scores con punteggi casuali per ogni giocatore.

Se non è già aperto, apri l'editor di Cloud Shell facendo clic sull'icona evidenziata di seguito:

7519d016b96ca51b.png

A questo punto, modifica il file leaderboard.go nell'editor di Cloud Shell per aggiungere un comando insertplayers che possa essere utilizzato per inserire 100 player nella tabella Players. Aggiungeremo anche un comando insertscores che può essere usato per inserire 4 punteggi casuali nella tabella Scores per ogni giocatore nella tabella Players.

Per prima cosa, aggiorna la sezione imports nella parte superiore del file leaderboard.go, sostituendo il file attualmente presente, in modo che una volta finito il file abbia il seguente aspetto:

import (
        "context"
        "flag"
        "fmt"
        "io"
        "log"
        "math/rand"
        "os"
        "regexp"
        "time"

        "cloud.google.com/go/spanner"
        database "cloud.google.com/go/spanner/admin/database/apiv1"

        "google.golang.org/api/iterator"
        adminpb "google.golang.org/genproto/googleapis/spanner/admin/database/v1"
)

Quindi aggiungi un nuovo tipo di comando insieme a un elenco di comandi nella parte superiore del file, appena sotto la riga che inizia con "type adminCommand ..." in modo che al termine dovrebbe avere l'aspetto seguente:

type adminCommand func(ctx context.Context, w io.Writer, adminClient *database.DatabaseAdminClient, database string) error

type command func(ctx context.Context, w io.Writer, client *spanner.Client) error
var (
        commands = map[string]command{
                "insertplayers": insertPlayers,
                "insertscores":  insertScores,
        }
)

Poi aggiungi le seguenti funzioni insertPlayer e insertScores sotto la funzione createdatabase() esistente:

func insertPlayers(ctx context.Context, w io.Writer, client *spanner.Client) error {
        // Get number of players to use as an incrementing value for each PlayerName to be inserted
        stmt := spanner.Statement{
                SQL: `SELECT Count(PlayerId) as PlayerCount FROM Players`,
        }
        iter := client.Single().Query(ctx, stmt)
        defer iter.Stop()
        row, err := iter.Next()
        if err != nil {
                return err
        }
        var numberOfPlayers int64 = 0
        if err := row.Columns(&numberOfPlayers); err != nil {
                return err
        }
        // Initialize values for random PlayerId
        rand.Seed(time.Now().UnixNano())
        min := 1000000000
        max := 9000000000
        // Insert 100 player records into the Players table
        _, err = client.ReadWriteTransaction(ctx, func(ctx context.Context, txn *spanner.ReadWriteTransaction) error {
                stmts := []spanner.Statement{}
                for i := 1; i <= 100; i++ {
                        numberOfPlayers++
                        playerID := rand.Intn(max-min) + min
                        playerName := fmt.Sprintf("Player %d", numberOfPlayers)
                        stmts = append(stmts, spanner.Statement{
                                SQL: `INSERT INTO Players
                                                (PlayerId, PlayerName)
                                                VALUES (@playerID, @playerName)`,
                                Params: map[string]interface{}{
                                        "playerID":   playerID,
                                        "playerName": playerName,
                                },
                        })
                }
                _, err := txn.BatchUpdate(ctx, stmts)
                if err != nil {
                        return err
                }
                return nil
        })
        fmt.Fprintf(w, "Inserted players \n")
        return nil
}

func insertScores(ctx context.Context, w io.Writer, client *spanner.Client) error {
        playerRecordsFound := false
        // Create slice for insert statements
        stmts := []spanner.Statement{}
        // Select all player records
        stmt := spanner.Statement{SQL: `SELECT PlayerId FROM Players`}
        iter := client.Single().Query(ctx, stmt)
        defer iter.Stop()
        // Insert 4 score records into the Scores table for each player in the Players table
        for {
                row, err := iter.Next()
                if err == iterator.Done {
                        break
                }
                if err != nil {
                        return err
                }
                playerRecordsFound = true
                var playerID int64
                if err := row.ColumnByName("PlayerId", &playerID); err != nil {
                        return err
                }
                // Initialize values for random score and date
                rand.Seed(time.Now().UnixNano())
                min := 1000
                max := 1000000
                for i := 0; i < 4; i++ {
                        // Generate random score between 1,000 and 1,000,000
                        score := rand.Intn(max-min) + min
                        // Generate random day within the past two years
                        now := time.Now()
                        endDate := now.Unix()
                        past := now.AddDate(0, -24, 0)
                        startDate := past.Unix()
                        randomDateInSeconds := rand.Int63n(endDate-startDate) + startDate
                        randomDate := time.Unix(randomDateInSeconds, 0)
                        // Add insert statement to stmts slice
                        stmts = append(stmts, spanner.Statement{
                                SQL: `INSERT INTO Scores
                                                (PlayerId, Score, Timestamp)
                                                VALUES (@playerID, @score, @timestamp)`,
                                Params: map[string]interface{}{
                                        "playerID":  playerID,
                                        "score":     score,
                                        "timestamp": randomDate,
                                },
                        })
                }

        }
        if !playerRecordsFound {
                fmt.Fprintln(w, "No player records currently exist. First insert players then insert scores.")
        } else {
                _, err := client.ReadWriteTransaction(ctx, func(ctx context.Context, txn *spanner.ReadWriteTransaction) error {
                        // Commit insert statements for all scores to be inserted as a single transaction
                        _, err := txn.BatchUpdate(ctx, stmts)
                        return err
                })
                if err != nil {
                        return err
                }
                fmt.Fprintln(w, "Inserted scores")
        }
        return nil
}

Quindi, per rendere funzionale il comando insert, aggiungi il seguente codice al comando "run" dell'applicazione sotto l'istruzione di gestione createdatabase, sostituendo l'istruzione return nil :

        // insert and query commands
        cmdFn := commands[cmd]
        if cmdFn == nil {
                flag.Usage()
                os.Exit(2)
        }
        err := cmdFn(ctx, w, dataClient)
        if err != nil {
                fmt.Fprintf(w, "%s failed with %v", cmd, err)
        }
        return err

Al termine dell'operazione, la funzione run dovrebbe avere il seguente aspetto:

func run(ctx context.Context, adminClient *database.DatabaseAdminClient, dataClient *spanner.Client, w io.Writer,
        cmd string, db string, timespan int) error {
        // createdatabase command
        if cmd == "createdatabase" {
                err := createDatabase(ctx, w, adminClient, db)
                if err != nil {
                        fmt.Fprintf(w, "%s failed with %v", cmd, err)
                }
                return err
        }

        // insert and query commands
        cmdFn := commands[cmd]
        if cmdFn == nil {
                flag.Usage()
                os.Exit(2)
        }
        err := cmdFn(ctx, w, dataClient)
        if err != nil {
                fmt.Fprintf(w, "%s failed with %v", cmd, err)
        }
        return err
}

Il passaggio finale per completare l'aggiunta di "Inserisci" della tua applicazione è l'aggiunta del testo della guida per "insertplayers" e "insertscores" i comandi alla funzione flag.Usage(). Aggiungi il seguente testo della guida alla funzione flag.Usage() per includere il testo della guida per i comandi di inserimento:

Aggiungi i due comandi all'elenco dei comandi possibili:

Command can be one of: createdatabase, insertplayers, insertscores

Inoltre, aggiungi questo ulteriore testo di supporto sotto il testo della guida per il comando createdatabase.

        leaderboard insertplayers projects/my-project/instances/my-instance/databases/example-db
                - Insert 100 sample Player records into the database.
        leaderboard insertscores projects/my-project/instances/my-instance/databases/example-db
                - Insert sample score data into Scores sample Cloud Spanner database table.

Salva le modifiche apportate al file leaderboard.go selezionando "Salva" nel campo "File" dell'editor di Cloud Shell o dal menu Fogli Google.

Puoi utilizzare il file leaderboard.go nella directory golang-samples/spanner/spanner_leaderboard per vedere un esempio dell'aspetto del file leaderboard.go dopo aver aggiunto il codice per abilitare i comandi insertplayers e insertscores.

Ora creiamo ed eseguiamo l'applicazione per confermare che i nuovi comandi insertplayers e insertscores siano inclusi nell'elenco dei possibili comandi dell'applicazione. Esegui questo comando per creare l'applicazione:

go build leaderboard.go

Esegui l'applicazione risultante in Cloud Shell inserendo questo comando:

./leaderboard

Ora i comandi insertplayers e insertscores dovrebbero essere inclusi nell'output predefinito dell'applicazione:

Usage: leaderboard <command> <database_name> [command_option]

        Command can be one of: createdatabase, insertplayers, insertscores

Examples:
        leaderboard createdatabase projects/my-project/instances/my-instance/databases/example-db
                - Create a sample Cloud Spanner database along with sample tables in your project.
        leaderboard insertplayers projects/my-project/instances/my-instance/databases/example-db
                - Insert 100 sample Player records into the database.
        leaderboard insertscores projects/my-project/instances/my-instance/databases/example-db
                - Insert sample score data into Scores sample Cloud Spanner database table.

Ora eseguiamo il comando insertplayers con gli stessi valori di argomento che abbiamo utilizzato quando abbiamo chiamato il comando createdatabase. Assicurati di sostituire my-project con l'ID progetto che hai creato all'inizio di questo codelab.

./leaderboard insertplayers projects/my-project/instances/cloudspanner-leaderboard/databases/leaderboard

Dopo un paio di secondi, dovresti visualizzare una risposta come la seguente:

Inserted players

Ora utilizziamo la libreria client Go per popolare la tabella Scores con quattro punteggi casuali e i timestamp per ogni giocatore nella tabella Players.

La colonna Timestamp della tabella Scores è stata definita come "timestamp di impegno" tramite la seguente istruzione SQL eseguita quando in precedenza abbiamo eseguito il comando create:

CREATE TABLE Scores(
  PlayerId INT64 NOT NULL,
  Score INT64 NOT NULL,
  Timestamp TIMESTAMP NOT NULL OPTIONS(allow_commit_timestamp=true)
) PRIMARY KEY(PlayerId, Timestamp),
    INTERLEAVE IN PARENT Players ON DELETE NO ACTION

Osserva l'attributo OPTIONS(allow_commit_timestamp=true). Timestamp diventa un "timestamp di commit" e consente di compilarla automaticamente con il timestamp esatto della transazione per le operazioni INSERT e UPDATE su una determinata riga della tabella.

Puoi anche inserire i tuoi valori di timestamp in un "timestamp di commit" devi inserire un timestamp con un valore nel passato, che è ciò che faremo in questo codelab.

Ora eseguiamo il comando insertscores con gli stessi valori di argomento che abbiamo utilizzato quando abbiamo chiamato il comando insertplayers. Assicurati di sostituire my-project con l'ID progetto che hai creato all'inizio di questo codelab.

./leaderboard insertscores projects/my-project/instances/cloudspanner-leaderboard/databases/leaderboard

Dopo un paio di secondi, dovresti visualizzare una risposta come la seguente:

Inserted scores

L'esecuzione della funzione insertScores utilizza il seguente snippet di codice per inserire un timestamp generato casualmente con data e ora del passato:

now := time.Now()
endDate := now.Unix()
past := now.AddDate(0, -24, 0)
startDate := past.Unix()
randomDateInSeconds := rand.Int63n(endDate-startDate) + startDate
randomDate := time.Unix(randomDateInSeconds, 0)
stmts = append(stmts, spanner.Statement{
        SQL: `INSERT INTO Scores
              (PlayerId, Score, Timestamp)
                 VALUES (@playerID, @score, @timestamp)`,
        Params: map[string]interface{}{
                "playerID":  playerID,
                "score":     score,
                "timestamp": randomDate,
        },
})

Per compilare automaticamente la colonna Timestamp con il timestamp corrispondente al momento esatto in cui "Inserisci" avviene la transazione, puoi inserire la costante Go spanner.CommitTimestamp come nel seguente snippet di codice:

...
stmts = append(stmts, spanner.Statement{
        SQL: `INSERT INTO Scores
              (PlayerId, Score, Timestamp)
                 VALUES (@playerID, @score, @timestamp)`,
        Params: map[string]interface{}{
                "playerID":  playerID,
                "score":     score,
                "timestamp": spanner.CommitTimestamp,
        },
})

Ora che il caricamento dei dati è stato completato, verifichiamo i valori che abbiamo appena scritto nelle nuove tabelle nella sezione Cloud Spanner della console Cloud. Seleziona prima il database leaderboard, quindi seleziona la tabella Players. Fai clic sulla scheda Data. Dovresti vedere che sono presenti dati nelle colonne PlayerId e PlayerName della tabella.

86dc5b927809a4ec.png

Verifica che anche la tabella dei punteggi contenga dei dati facendo clic sulla tabella Scores e selezionando la scheda Data. Dovresti vedere che sono presenti dati nelle colonne PlayerId, Timestamp e Score della tabella.

87c8610c92d3c612.png

Ben fatto! Aggiorniamo l'app in modo che esegua alcune query da usare per creare una classifica dei giochi.

6. Eseguire query sulla classifica

Ora che abbiamo impostato il database e caricato le informazioni nelle nostre tabelle, possiamo creare un leaderboard utilizzando questi dati. Per farlo, dobbiamo rispondere alle seguenti quattro domande:

  1. Quali giocatori sono i "primi dieci" di tutti i tempi?
  2. Quali giocatori sono i "primi dieci" dell'anno?
  3. Quali giocatori sono i "primi dieci" del mese?
  4. Quali giocatori sono i "primi dieci" della settimana?

Aggiorniamo l'applicazione in modo che esegua le query SQL che rispondono a queste domande.

Aggiungeremo un comando query e un comando queryWithTimespan che ti forniranno un modo per eseguire le query e rispondere alle domande che produrranno le informazioni richieste per la nostra classifica.

Modifica il file leaderboard.go nell'editor di Cloud Shell per aggiornare l'applicazione e aggiungere un comando query e un comando queryWithTimespan. Aggiungeremo anche una funzione helper formatWithCommas per formattare i punteggi con virgole.

Per prima cosa, aggiorna la sezione imports nella parte superiore del file leaderboard.go, sostituendo il file attualmente presente, in modo che una volta finito il file abbia il seguente aspetto:

import (
        "bytes"
        "context"
        "flag"
        "fmt"
        "io"
        "log"
        "math/rand"
        "os"
        "regexp"
        "strconv"
        "time"

        "cloud.google.com/go/spanner"
        database "cloud.google.com/go/spanner/admin/database/apiv1"

        "google.golang.org/api/iterator"
        adminpb "google.golang.org/genproto/googleapis/spanner/admin/database/v1"
)

A questo punto, aggiungi le due funzioni seguenti e la funzione helper sotto il metodo insertScores esistente:

func query(ctx context.Context, w io.Writer, client *spanner.Client) error {
        stmt := spanner.Statement{
                SQL: `SELECT p.PlayerId, p.PlayerName, s.Score, s.Timestamp
                        FROM Players p
                        JOIN Scores s ON p.PlayerId = s.PlayerId
                        ORDER BY s.Score DESC LIMIT 10`}
        iter := client.Single().Query(ctx, stmt)
        defer iter.Stop()
        for {
                row, err := iter.Next()
                if err == iterator.Done {
                        return nil
                }
                if err != nil {
                        return err
                }
                var playerID, score int64
                var playerName string
                var timestamp time.Time
                if err := row.Columns(&playerID, &playerName, &score, &timestamp); err != nil {
                        return err
                }
                fmt.Fprintf(w, "PlayerId: %d  PlayerName: %s  Score: %s  Timestamp: %s\n",
                        playerID, playerName, formatWithCommas(score), timestamp.String()[0:10])
        }
}

func queryWithTimespan(ctx context.Context, w io.Writer, client *spanner.Client, timespan int) error {
        stmt := spanner.Statement{
                SQL: `SELECT p.PlayerId, p.PlayerName, s.Score, s.Timestamp
                                FROM Players p
                                JOIN Scores s ON p.PlayerId = s.PlayerId 
                                WHERE s.Timestamp > TIMESTAMP_SUB(CURRENT_TIMESTAMP(), INTERVAL @Timespan HOUR)
                                ORDER BY s.Score DESC LIMIT 10`,
                Params: map[string]interface{}{"Timespan": timespan},
        }
        iter := client.Single().Query(ctx, stmt)
        defer iter.Stop()
        for {
                row, err := iter.Next()
                if err == iterator.Done {
                        return nil
                }
                if err != nil {
                        return err
                }
                var playerID, score int64
                var playerName string
                var timestamp time.Time
                if err := row.Columns(&playerID, &playerName, &score, &timestamp); err != nil {
                        return err
                }
                fmt.Fprintf(w, "PlayerId: %d  PlayerName: %s  Score: %s  Timestamp: %s\n",
                        playerID, playerName, formatWithCommas(score), timestamp.String()[0:10])
        }
}

func formatWithCommas(n int64) string {
        numberAsString := strconv.FormatInt(n, 10)
        numberLength := len(numberAsString)
        if numberLength < 4 {
                return numberAsString
        }
        var buffer bytes.Buffer
        comma := []rune(",")
        bufferPosition := numberLength % 3
        if (bufferPosition) > 0 {
                bufferPosition = 3 - bufferPosition
        }
        for i := 0; i < numberLength; i++ {
                if bufferPosition == 3 {
                        buffer.WriteRune(comma[0])
                        bufferPosition = 0
                }
                bufferPosition++
                buffer.WriteByte(numberAsString[i])
        }
        return buffer.String()
}

Poi, all'inizio del file leaderboard.go, aggiungi "query" come una delle opzioni di comando nella variabile commands, appena sotto l'opzione "insertscores": insertScores, in modo che la variabile commands abbia il seguente aspetto:

var (
        commands = map[string]command{
                "insertplayers": insertPlayers,
                "insertscores":  insertScores,
                "query":         query,
        }
)

Poi, aggiungi "queryWithTimespan" come opzione di comando all'interno della funzione run, sotto "createdatabase" nella sezione di comando gcloud e sopra "insert and query" nella sezione dedicata alla gestione dei comandi.

        // querywithtimespan command
        if cmd == "querywithtimespan" {
                err := queryWithTimespan(ctx, w, dataClient, timespan)
                if err != nil {
                        fmt.Fprintf(w, "%s failed with %v", cmd, err)
                }
                return err
        }

Al termine dell'operazione, la funzione run dovrebbe avere il seguente aspetto:

func run(ctx context.Context, adminClient *database.DatabaseAdminClient, dataClient *spanner.Client, w io.Writer,
        cmd string, db string, timespan int) error {
        // createdatabase command
        if cmd == "createdatabase" {
                err := createDatabase(ctx, w, adminClient, db)
                if err != nil {
                        fmt.Fprintf(w, "%s failed with %v", cmd, err)
                }
                return err
        }

        // querywithtimespan command
        if cmd == "querywithtimespan" {
                if timespan == 0 {
                        flag.Usage()
                        os.Exit(2)
                }
                err := queryWithTimespan(ctx, w, dataClient, timespan)
                if err != nil {
                        fmt.Fprintf(w, "%s failed with %v", cmd, err)
                }
                return err
        }

        // insert and query commands
        cmdFn := commands[cmd]
        if cmdFn == nil {
                flag.Usage()
                os.Exit(2)
        }
        err := cmdFn(ctx, w, dataClient)
        if err != nil {
                fmt.Fprintf(w, "%s failed with %v", cmd, err)
        }
        return err
}

Quindi, per rendere funzionale il comando queryWithTimespan, aggiorna il blocco di codice flag.Parse() nel campo "main" della tua applicazione in modo che abbia il seguente aspetto:

        flag.Parse()
        flagCount := len(flag.Args())
        if flagCount < 2 || flagCount > 3 {
                flag.Usage()
                os.Exit(2)
        }

        cmd, db := flag.Arg(0), flag.Arg(1)
        // If query timespan flag is specified, parse to int
        var timespan int = 0
        if flagCount == 3 {
                parsedTimespan, err := strconv.Atoi(flag.Arg(2))
                if err != nil {
                        fmt.Println(err)
                        os.Exit(2)
                }
                timespan = parsedTimespan
        }

        ctx, cancel := context.WithTimeout(context.Background(), 1*time.Minute)
        defer cancel()
        adminClient, dataClient := createClients(ctx, db)
        if err := run(ctx, adminClient, dataClient, os.Stdout, cmd, db, timespan); err != nil {
                os.Exit(1)
        }

Il passaggio finale per completare l'aggiunta della "query" alla tua applicazione è l'aggiunta di testo di aiuto per la "query" e "querywithtimespan" i comandi alla funzione flag.Usage(). Aggiungi le seguenti righe di codice alla funzione flag.Usage() per includere il testo della guida per i comandi di query:

Aggiungi le due "query" all'elenco dei possibili comandi:

Command can be one of: createdatabase, insertplayers, insertscores, query, querywithtimespan

Inoltre, aggiungi questo ulteriore testo di supporto sotto il testo della guida per il comando insertscores.

        leaderboard query projects/my-project/instances/my-instance/databases/example-db
                - Query players with top ten scores of all time.
        leaderboard querywithtimespan projects/my-project/instances/my-instance/databases/example-db 168
                - Query players with top ten scores within a timespan specified in hours.

Salva le modifiche apportate al file leaderboard.go selezionando "Salva" nel campo "File" dell'editor di Cloud Shell o dal menu Fogli Google.

Puoi utilizzare il file leaderboard.go nella directory golang-samples/spanner/spanner_leaderboard per vedere un esempio dell'aspetto del file leaderboard.go dopo aver aggiunto il codice per abilitare i comandi query e querywithtimespan.

Ora creiamo ed eseguiamo l'applicazione per confermare che i nuovi comandi query e querywithtimespan siano inclusi nell'elenco dei possibili comandi dell'applicazione.

Esegui questo comando in Cloud Shell per creare l'applicazione:

go build leaderboard.go

Esegui l'applicazione risultante in Cloud Shell inserendo questo comando:

./leaderboard

Ora i comandi query e querywithtimespan dovrebbero essere inclusi nell'output predefinito dell'app come nuova opzione di comando:

Usage: leaderboard <command> <database_name> [command_option]

        Command can be one of: createdatabase, insertplayers, insertscores, query, querywithtimespan

Examples:
        leaderboard createdatabase projects/my-project/instances/my-instance/databases/example-db
                - Create a sample Cloud Spanner database along with sample tables in your project.
        leaderboard insertplayers projects/my-project/instances/my-instance/databases/example-db
                - Insert 100 sample Player records into the database.
        leaderboard insertscores projects/my-project/instances/my-instance/databases/example-db
                - Insert sample score data into Scores sample Cloud Spanner database table.
        leaderboard query projects/my-project/instances/my-instance/databases/example-db
                - Query players with top ten scores of all time.
        leaderboard querywithtimespan projects/my-project/instances/my-instance/databases/example-db 168
                - Query players with top ten scores within a timespan specified in hours.

Dalla risposta puoi capire che possiamo usare il comando query per ottenere un elenco dei nostri "primi dieci" giocatori di tutti i tempi. Possiamo anche notare che il comando querywithtimespan consente di specificare un periodo di tempo in numero di ore da utilizzare per filtrare i record in base al relativo valore nella colonna Timestamp della tabella Scores.

Eseguiamo il comando query utilizzando gli stessi valori di argomento che abbiamo utilizzato quando abbiamo eseguito il comando create. Assicurati di sostituire my-project con l'ID progetto che hai creato all'inizio di questo codelab.

./leaderboard query  projects/my-project/instances/cloudspanner-leaderboard/databases/leaderboard

Dovresti vedere una risposta che include i "primi dieci" giocatori di tutti i tempi, come i seguenti:

PlayerId: 4018687297  PlayerName: Player 83  Score: 999,618  Timestamp: 2017-07-01
PlayerId: 4018687297  PlayerName: Player 83  Score: 998,956  Timestamp: 2017-09-02
PlayerId: 4285713246  PlayerName: Player 51  Score: 998,648  Timestamp: 2017-12-01
PlayerId: 5267931774  PlayerName: Player 49  Score: 997,733  Timestamp: 2017-11-09
PlayerId: 1981654448  PlayerName: Player 35  Score: 997,480  Timestamp: 2018-12-06
PlayerId: 4953940705  PlayerName: Player 87  Score: 995,184  Timestamp: 2018-09-14
PlayerId: 2456736905  PlayerName: Player 84  Score: 992,881  Timestamp: 2017-04-14
PlayerId: 8234617611  PlayerName: Player 19  Score: 992,399  Timestamp: 2017-12-27
PlayerId: 1788051688  PlayerName: Player 76  Score: 992,265  Timestamp: 2018-11-22
PlayerId: 7127686505  PlayerName: Player 97  Score: 992,038  Timestamp: 2017-12-02

Ora eseguiamo il comando querywithtimespan con gli argomenti necessari per eseguire una query sui "primi dieci" giocatori dell'anno specificando un "periodo" equivale al numero di ore in un anno che è 8760. Assicurati di sostituire my-project con l'ID progetto che hai creato all'inizio di questo codelab.

./leaderboard querywithtimespan projects/my-project/instances/cloudspanner-leaderboard/databases/leaderboard 8760

Dovresti vedere una risposta che include i "primi dieci" giocatori dell'anno come i seguenti:

PlayerId: 1981654448  PlayerName: Player 35  Score: 997,480  Timestamp: 2018-12-06
PlayerId: 4953940705  PlayerName: Player 87  Score: 995,184  Timestamp: 2018-09-14
PlayerId: 1788051688  PlayerName: Player 76  Score: 992,265  Timestamp: 2018-11-22
PlayerId: 6862349579  PlayerName: Player 30  Score: 990,877  Timestamp: 2018-09-14
PlayerId: 5529627211  PlayerName: Player 16  Score: 989,142  Timestamp: 2018-03-30
PlayerId: 9743904155  PlayerName: Player 1  Score: 988,765  Timestamp: 2018-05-30
PlayerId: 6809119884  PlayerName: Player 7  Score: 986,673  Timestamp: 2018-05-16
PlayerId: 2132710638  PlayerName: Player 54  Score: 983,108  Timestamp: 2018-09-11
PlayerId: 2320093590  PlayerName: Player 79  Score: 981,373  Timestamp: 2018-05-07
PlayerId: 9554181430  PlayerName: Player 80  Score: 981,087  Timestamp: 2018-06-21

Ora eseguiamo il comando querywithtimespan per interrogare i "primi dieci" giocatori del mese specificando un "intervallo di tempo" equivale al numero di ore di un mese, che è 730. Assicurati di sostituire my-project con l'ID progetto che hai creato all'inizio di questo codelab.

./leaderboard querywithtimespan projects/my-project/instances/cloudspanner-leaderboard/databases/leaderboard 730

Dovresti vedere una risposta che include i "primi dieci" giocatori del mese, come i seguenti:

PlayerId: 3869829195  PlayerName: Player 69  Score: 949,686  Timestamp: 2019-02-19
PlayerId: 7448359883  PlayerName: Player 20  Score: 938,998  Timestamp: 2019-02-07
PlayerId: 1981654448  PlayerName: Player 35  Score: 929,003  Timestamp: 2019-02-22
PlayerId: 9336678658  PlayerName: Player 44  Score: 914,106  Timestamp: 2019-01-27
PlayerId: 6968576389  PlayerName: Player 40  Score: 898,041  Timestamp: 2019-02-21
PlayerId: 5529627211  PlayerName: Player 16  Score: 896,433  Timestamp: 2019-01-29
PlayerId: 9395039625  PlayerName: Player 59  Score: 879,495  Timestamp: 2019-02-09
PlayerId: 2094604854  PlayerName: Player 39  Score: 860,434  Timestamp: 2019-02-01
PlayerId: 9395039625  PlayerName: Player 59  Score: 849,955  Timestamp: 2019-02-21
PlayerId: 4285713246  PlayerName: Player 51  Score: 805,654  Timestamp: 2019-02-02

Ora eseguiamo il comando querywithtimespan per interrogare i "primi dieci" giocatori della settimana specificando un "intervallo di tempo" equivale al numero di ore di una settimana che è 168. Assicurati di sostituire my-project con l'ID progetto che hai creato all'inizio di questo codelab.

./leaderboard querywithtimespan  projects/my-project/instances/cloudspanner-leaderboard/databases/leaderboard 168

Dovresti vedere una risposta che include i "primi dieci" giocatori della settimana come i seguenti:

PlayerId: 3869829195  PlayerName: Player 69  Score: 949,686  Timestamp: 2019-02-19
PlayerId: 1981654448  PlayerName: Player 35  Score: 929,003  Timestamp: 2019-02-22
PlayerId: 6968576389  PlayerName: Player 40  Score: 898,041  Timestamp: 2019-02-21
PlayerId: 9395039625  PlayerName: Player 59  Score: 849,955  Timestamp: 2019-02-21
PlayerId: 5954045812  PlayerName: Player 8  Score: 795,639  Timestamp: 2019-02-22
PlayerId: 3889939638  PlayerName: Player 71  Score: 775,252  Timestamp: 2019-02-21
PlayerId: 5529627211  PlayerName: Player 16  Score: 604,695  Timestamp: 2019-02-19
PlayerId: 9006728426  PlayerName: Player 3  Score: 457,208  Timestamp: 2019-02-22
PlayerId: 8289497066  PlayerName: Player 58  Score: 227,697  Timestamp: 2019-02-20
PlayerId: 8065482904  PlayerName: Player 99  Score: 198,429  Timestamp: 2019-02-24

Eccellente.

Ora che aggiungi i record, Cloud Spanner scala il tuo database in base alle tue esigenze. Indipendentemente dalla crescita del tuo database, la classifica del tuo gioco può continuare a scalare con precisione con Cloud Spanner e la sua tecnologia Truetime.

7. Esegui la pulizia

Dopo il divertimento con Spanner dobbiamo ripulire il nostro parco giochi, risparmiando risorse e denaro preziosi. Fortunatamente, questo è un passaggio semplice. Basta accedere alla sezione Cloud Spanner della console Cloud ed eliminare l'istanza creata nel codelab denominato "Configura un'istanza Cloud Spanner".

8. Complimenti!

Argomenti trattati:

  • Schema delle tabelle, dei database e delle istanze di Google Cloud Spanner per una classifica
  • Come creare un'applicazione della console Go
  • Creare un database e tabelle Spanner utilizzando la libreria client Go
  • Come caricare i dati in un database Spanner utilizzando la libreria client Go
  • Come eseguire una query nella sezione "Top dieci" di risultati dai tuoi dati usando i timestamp di commit di Spanner e la libreria client Go.

Passaggi successivi:

Inviaci il tuo feedback

  • Dedica qualche istante a completare il nostro breve sondaggio