Creazione di un'area di autenticazione

In questa pagina viene spiegato come creare, elencare, descrivere e aggiornare le aree di gioco dei server di gioco. Un realm è un raggruppamento definito dall'utente dei cluster di server di gioco in base ai requisiti di latenza del gioco per le popolazioni dei giocatori.

Prima di iniziare

Prima di iniziare, ti consigliamo di familiarizzare con i concetti principali nella panoramica dei server di gioco. Assicurati di aver eseguito anche le seguenti attività:

  • Assicurati di aver attivato l'API Game Services.
  • Abilita l'API Game Services
  • Scegli una shell con gcloud CLI installato o utilizza un client API:
  • Cloud Shell

    Per avviare Cloud Shell, esegui questi passaggi:

    1. Vai a Google Cloud Console.

      Google Cloud console

    2. Nell'angolo in alto a destra della console, fai clic sul pulsante Attiva Cloud Shell:

    Una sessione di Cloud Shell si apre all'interno di un frame inferiore nella console. Puoi utilizzare questa shell per eseguire comandi gcloud.

    Profilo locale

    Installa l'interfaccia a riga di comando gcloud.

    Verifica di avere impostato il progetto predefinito desiderato per l'interfaccia a riga di comando di Google Cloud, altrimenti dovrai specificare esplicitamente il flag --project per ogni comando in un secondo momento:

    gcloud config list project
    

    In caso contrario, puoi eseguire il comando seguente per impostare un progetto predefinito, sostituendo PROJECT_ID con l'ID progetto desiderato :

    gcloud config set project PROJECT_ID
    

    Esegui questo comando per verificare la tua versione dell'interfaccia a riga di comando di Google Cloud. Game Servers richiede la versione 306.0.0 o successiva dell'interfaccia a riga di comando gcloud.

    gcloud version
    

    Per aggiornare l'installazione, esegui questo comando:

    gcloud components update
    

    curl / PowerShell

    Per utilizzare l'API REST con curl o Windows PowerShell, procedi come segue:

    1. Creare un account di servizio.
    2. Scarica una chiave privata come file JSON.
    3. Imposta la variabile di ambiente GOOGLE_APPLICATION_CREDENTIALS sul percorso del file JSON che contiene la chiave dell'account di servizio. Questa variabile si applica solo alla sessione shell corrente, quindi se apri una nuova sessione, impostala di nuovo.

    Libreria client

    I server di gioco Google Cloud possono essere controllati a livello di programmazione mediante una libreria client. Consulta la Panoramica sulle librerie client per istruzioni sull'utilizzo della libreria e sull'autenticazione.

Creazione di un'area di autenticazione

I realm possono essere globali o a livello di area geografica. Un regno globale è una buona opzione se i cluster registrati in un regno provengono da aree geografiche che coprono varie località geografiche, come il Nord America e il Sud America o l'Europa e l'Asia. Un regno regionale è una buona opzione se i cluster si trovano nella stessa area geografica, ad esempio Europa occidentale. In caso di interruzione di rete tra aree geografiche, un realm globale potrebbe non essere in grado di gestire i cluster in ogni area geografica. Per aumentare la resilienza contro le interruzioni di rete tra aree geografiche, assicurati di creare aree di autenticazione regionali nelle aree geografiche più simili ai cluster di server di gioco associati.

Ad esempio, se crei cluster nelle aree geografiche europe-west1, europe-west2 e europe-west3 per gestire gli utenti nell'Europa occidentale, puoi anche creare un realm regionale in una di queste aree geografiche. Questa configurazione garantisce che il realm possa continuare a gestire i cluster nel caso in cui queste aree geografiche non possano essere raggiunte da aree geografiche in altre parti del mondo a causa di un'interruzione della rete.

Se non sai dove creare il tuo regno, puoi crearlo come ambiente globale. Man mano che i tuoi requisiti cambiano, puoi creare un nuovo realm in un'area geografica più vicina ai cluster che deve gestire. Successivamente, puoi spostare i cluster esistenti nel nuovo realm regionale eliminando e annullando la registrazione dei cluster dal realm globale e poi registrandoli nel nuovo realm regionale.

console

  1. In Google Cloud Console, vai alla pagina Realms &Clusters (Cluster).

    Vai a Game Servers

  2. Fai clic su Crea realm.

  3. Nella casella Nome realm, inserisci un identificatore univoco per l'area.

  4. Nella casella Fuso orario, seleziona un fuso orario per questo realm. Quando pianifichi eventi basati sul tempo, come i criteri di scalabilità, è per questo fuso orario.

  5. Fai clic su Crea.

gcloud

Puoi creare aree di autenticazione utilizzando l'interfaccia a riga di comando di Google Cloud. Per creare un realm globale, esegui il comando seguente e sostituisci i valori segnaposto, come realmID, con i valori appropriati:

gcloud game servers realms create realmID --time-zone tz

Per creare un realm a livello di area geografica, esegui il comando seguente e sostituisci i valori segnaposto, ad esempio realmID, con i valori appropriati:

gcloud game servers realms create realmID --time-zone tz --location=region

I segnaposto delle variabili corrispondono alle seguenti descrizioni:

  • realmID è un identificatore univoco che puoi specificare per questo realm.
  • tz è il fuso orario per questo regno. Quando pianifichi eventi basati sul tempo, come i criteri di scalabilità, il fuso orario si trova in questo fuso orario.
  • region è region per il regno. Se vuoi controllare i domini in errore, specifica un'area geografica. Ti consigliamo di creare un realm globale e omettere questa opzione.

REST &CMD LINE

Prima di utilizzare uno qualsiasi dei dati della richiesta, effettua le seguenti sostituzioni:

  • PROJECT_ID: il tuo ID progetto Google Cloud elencato nelle impostazioni IAM
  • LOCATION: l'area geografica per il regno. Se vuoi controllare i domini in errore, specifica un'area geografica dall'elenco di località supportate. Ti consigliamo di specificare un realm global.
  • REALM_ID: un identificatore definito dall'utente per il nuovo realm
  • TIME_ZONE: il fuso orario per questo dominio (ad esempio, US/Eastern). Puoi pianificare eventi basati sul tempo, come criteri di scalabilità, per questo fuso orario.

Corpo JSON richiesta:

{
  "timeZone": "TIME_ZONE"
}

Per inviare la richiesta, espandi una delle seguenti opzioni:

Dovresti ricevere una risposta JSON simile alla seguente:

{
  "name": "projects/PROJECT_ID/locations/LOCATION/operations/OPERATION_ID",
  "metadata": {
    "@type": "type.googleapis.com/google.cloud.gaming.v1.OperationMetadata",
    "createTime": CREATE_TIME,
    "target": "projects/PROJECT_ID/locations/LOCATION/realms/REALM_ID",
    "verb": "create",
    "requestedCancellation": false,
    "apiVersion": "v1"
  },
  "done": false
}

C#

Per informazioni su come installare e utilizzare la libreria client per Game Servers, consulta la sezione Librerie client di Game Servers.


using Google.Api.Gax.ResourceNames;
using Google.Cloud.Gaming.V1;
using Google.LongRunning;
using System.Threading.Tasks;

public class CreateRealmSample
{
    public async Task<Realm> CreateRealmAsync(
        string projectId, string regionId, string realmId)
    {
        // Create the client.
        RealmsServiceClient client = await RealmsServiceClient.CreateAsync();

        Realm realm = new Realm
        {
            RealmName = RealmName.FromProjectLocationRealm(projectId, regionId, realmId),
            TimeZone = "America/Los_Angeles"
        };

        CreateRealmRequest request = new CreateRealmRequest
        {
            ParentAsLocationName = LocationName.FromProjectLocation(projectId, regionId),
            RealmId = realmId,
            Realm = realm
        };

        // Make the request.
        Operation<Realm, OperationMetadata> response = await client.CreateRealmAsync(request);

        // Poll until the returned long-running operation is complete.
        Operation<Realm, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();

        // Retrieve the operation result.
        return completedResponse.Result;
    }
}

Go

Per informazioni su come installare e utilizzare la libreria client per Game Servers, consulta la sezione Librerie client di Game Servers.


import (
	"context"
	"fmt"
	"io"

	gaming "cloud.google.com/go/gaming/apiv1"
	gamingpb "google.golang.org/genproto/googleapis/cloud/gaming/v1"
)

// createRealm creates a game server realm.
func createRealm(w io.Writer, projectID, location, realmID string) error {
	// projectID := "my-project"
	// location := "global"
	// realmID := "myrealm"
	ctx := context.Background()
	client, err := gaming.NewRealmsClient(ctx)
	if err != nil {
		return fmt.Errorf("NewRealmsClient: %v", err)
	}
	defer client.Close()

	req := &gamingpb.CreateRealmRequest{
		Parent:  fmt.Sprintf("projects/%s/locations/%s", projectID, location),
		RealmId: realmID,
		Realm: &gamingpb.Realm{
			TimeZone:    "US/Pacific",
			Description: "My Game Server Realm",
		},
	}

	op, err := client.CreateRealm(ctx, req)
	if err != nil {
		return fmt.Errorf("CreateRealm: %v", err)
	}
	resp, err := op.Wait(ctx)
	if err != nil {
		return fmt.Errorf("Wait: %v", err)
	}

	fmt.Fprintf(w, "Realm created: %v", resp.Name)
	return nil
}

Java

Per informazioni su come installare e utilizzare la libreria client per Game Servers, consulta la sezione Librerie client di Game Servers.


import com.google.api.gax.longrunning.OperationFuture;
import com.google.cloud.gaming.v1.CreateRealmRequest;
import com.google.cloud.gaming.v1.OperationMetadata;
import com.google.cloud.gaming.v1.Realm;
import com.google.cloud.gaming.v1.RealmsServiceClient;
import java.io.IOException;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

public class CreateRealm {
  public static void createRealm(String projectId, String regionId, String realmId)
      throws InterruptedException, ExecutionException, TimeoutException, IOException {
    // String projectId = "your-project-id";
    // String regionId = "us-central1-f";
    // String realmId = "your-realm-id";
    // Initialize client that will be used to send requests. This client only needs to be created
    // once, and can be reused for multiple requests. After completing all of your requests, call
    // the "close" method on the client to safely clean up any remaining background resources.
    try (RealmsServiceClient client = RealmsServiceClient.create()) {
      String parent = String.format("projects/%s/locations/%s", projectId, regionId);
      String realmName = String.format("%s/realms/%s", parent, realmId);

      Realm realm =
          Realm.newBuilder().setName(realmName).setTimeZone("America/Los_Angeles").build();

      CreateRealmRequest request =
          CreateRealmRequest.newBuilder()
              .setParent(parent)
              .setRealmId(realmId)
              .setRealm(realm)
              .build();

      OperationFuture<Realm, OperationMetadata> call = client.createRealmAsync(request);
      Realm result = call.get(1, TimeUnit.MINUTES);

      System.out.println("Realm created: " + result.getName());
    }
  }
}

Node.js

Per informazioni su come installare e utilizzare la libreria client per Game Servers, consulta la sezione Librerie client di Game Servers.

const {RealmsServiceClient} = require('@google-cloud/game-servers');

const client = new RealmsServiceClient();

async function createRealm() {
  /**
   * TODO(developer): Uncomment these variables before running the sample.
   */
  // const projectId = 'Your Google Cloud Project ID';
  // const location = 'A Compute Engine region, e.g. "us-central1"';
  // const realmId = 'A unique identifier for the realm';
  const request = {
    parent: `projects/${projectId}/locations/${location}`,
    realmId: realmId,
    realm: {
      // Must use a supported time zone name.
      // See https://cloud.google.com/dataprep/docs/html/Supported-Time-Zone-Values_66194188
      timeZone: 'US/Pacific',
      description: 'My Game Server realm',
    },
  };

  const [operation] = await client.createRealm(request);
  const results = await operation.promise();
  const [realm] = results;

  console.log('Realm created:');

  console.log(`\tRealm name: ${realm.name}`);
  console.log(`\tRealm description: ${realm.description}`);
  console.log(`\tRealm time zone: ${realm.timeZone}`);
}

createRealm();

Python

Per informazioni su come installare e utilizzare la libreria client per Game Servers, consulta la sezione Librerie client di Game Servers.

def create_realm(project_id, location, realm_id):
    """Creates a realm."""

    client = gaming.RealmsServiceClient()

    request = realms.CreateRealmRequest(
        parent=f"projects/{project_id}/locations/{location}",
        realm_id=realm_id,
        realm=realms.Realm(
            description="My Realm",
            time_zone="US/Pacific",
        ),
    )

    operation = client.create_realm(request)
    print(f"Create realm operation: {operation.operation.name}")
    operation.result(timeout=120)

Elenco delle aree di autenticazione

console

  1. In Google Cloud Console, vai alla pagina Realms &Clusters (Cluster).

    Vai a Game Servers

  2. Puoi utilizzare la casella di filtro per filtrare l'elenco delle aree di autenticazione in base a diverse proprietà.

REST &CMD LINE

Prima di utilizzare uno qualsiasi dei dati della richiesta, effettua le seguenti sostituzioni:

  • PROJECT_ID: il tuo ID progetto Google Cloud elencato nelle impostazioni IAM
  • LOCATION: area geografica dei reami o global

Per inviare la richiesta, espandi una delle seguenti opzioni:

Dovresti ricevere una risposta JSON simile alla seguente:

{
  "realms": [
    {
      "name": "projects/PROJECT_ID/locations/LOCATION/realms/realm1",
      "createTime": CREATE_TIME,
      "updateTime": UPDATE_TIME,
      "timeZone": "US/Eastern",
      "etag": "PlXtLrUJ5pHQoZk0Lz-pWkPFN_dt3PXhIpRrJ5HHWu8"
    },
    {
      "name": "projects/PROJECT_ID/locations/LOCATION/realms/realm2",
      "createTime": CREATE_TIME,
      "updateTime": UPDATE_TIME,
      "timeZone": "America/Eirunepe",
      "etag": "ay1tXqeujLSsSd93n6uhlZwlxdNTOfG7El992Tsiz98"
    },
    {
      "name": "projects/PROJECT_ID/locations/LOCATION/realms/realm3",
      "createTime": CREATE_TIME,
      "updateTime": UPDATE_TIME,
      "timeZone": "Asia/Anadyr",
      "etag": "cBxzV2AWK_zgijSmYA-oXPWv3giwhUzssoWcqjPZFuk"
    }
  ]
}

gcloud

Puoi elencare i reami globali o a livello di area geografica utilizzando l'interfaccia a riga di comando di Google Cloud.

Per elencare i reami globali e a livello di area geografica, esegui il comando seguente:

gcloud game servers realms list

Per elencare le realm in una località specifica, esegui il comando seguente e sostituisci region con global o un'area geografica Google Cloud:

gcloud game servers realms list --location=region

C#

Per informazioni su come installare e utilizzare la libreria client per Game Servers, consulta la sezione Librerie client di Game Servers.


using Google.Api.Gax;
using Google.Api.Gax.ResourceNames;
using Google.Cloud.Gaming.V1;
using System.Collections.Generic;
using System.Linq;

public class ListRealmsSample
{
    public IList<Realm> ListRealms(
        string projectId, string regionId)
    {
        // Create the client.
        RealmsServiceClient client = RealmsServiceClient.Create();

        ListRealmsRequest request = new ListRealmsRequest
        {
            ParentAsLocationName = LocationName.FromProjectLocation(projectId, regionId)
        };

        // Make the request.
        PagedEnumerable<ListRealmsResponse, Realm> response = client.ListRealms(request);

        // The returned sequence will lazily perform RPCs as it's being iterated over.
        return response.ToList();
    }
}

Go

Per informazioni su come installare e utilizzare la libreria client per Game Servers, consulta la sezione Librerie client di Game Servers.


import (
	"context"
	"fmt"
	"io"

	gaming "cloud.google.com/go/gaming/apiv1"
	"google.golang.org/api/iterator"
	gamingpb "google.golang.org/genproto/googleapis/cloud/gaming/v1"
)

// listRealms lists the realms in a location.
func listRealms(w io.Writer, projectID, location string) error {
	// projectID := "my-project"
	// location := "global"
	ctx := context.Background()
	client, err := gaming.NewRealmsClient(ctx)
	if err != nil {
		return fmt.Errorf("NewRealmsClient: %v", err)
	}
	defer client.Close()

	req := &gamingpb.ListRealmsRequest{
		Parent: fmt.Sprintf("projects/%s/locations/%s", projectID, location),
	}

	it := client.ListRealms(ctx, req)
	for {
		resp, err := it.Next()
		if err == iterator.Done {
			break
		}
		if err != nil {
			return fmt.Errorf("Next: %v", err)
		}

		fmt.Fprintf(w, "Realm listed: %v\n", resp.Name)
	}

	return nil
}

Java

Per informazioni su come installare e utilizzare la libreria client per Game Servers, consulta la sezione Librerie client di Game Servers.


import com.google.cloud.gaming.v1.ListRealmsRequest;
import com.google.cloud.gaming.v1.Realm;
import com.google.cloud.gaming.v1.RealmsServiceClient;
import com.google.cloud.gaming.v1.RealmsServiceClient.ListRealmsPagedResponse;
import com.google.common.base.Strings;
import java.io.IOException;

public class ListRealms {
  public static void listRealms(String projectId, String regionId) throws IOException {
    // String projectId = "your-project-id";
    // String regionId = "us-central1-f";
    // Initialize client that will be used to send requests. This client only needs to be created
    // once, and can be reused for multiple requests. After completing all of your requests, call
    // the "close" method on the client to safely clean up any remaining background resources.
    try (RealmsServiceClient client = RealmsServiceClient.create()) {
      String parent = String.format("projects/%s/locations/%s", projectId, regionId);

      ListRealmsPagedResponse response = client.listRealms(parent);
      for (Realm realm : response.iterateAll()) {
        System.out.println("Realm found: " + realm.getName());
      }

      while (!Strings.isNullOrEmpty(response.getNextPageToken())) {
        ListRealmsRequest request =
            ListRealmsRequest.newBuilder()
                .setParent(parent)
                .setPageToken(response.getNextPageToken())
                .build();
        response = client.listRealms(request);
        for (Realm realm : response.iterateAll()) {
          System.out.println("Realm found: " + realm.getName());
        }
      }
    }
  }
}

Node.js

Per informazioni su come installare e utilizzare la libreria client per Game Servers, consulta la sezione Librerie client di Game Servers.

const {RealmsServiceClient} = require('@google-cloud/game-servers');

const client = new RealmsServiceClient();

async function listRealms() {
  /**
   * TODO(developer): Uncomment these variables before running the sample.
   */
  // const projectId = 'Your Google Cloud Project ID';
  // const location = 'A Compute Engine region, e.g. "us-central1"';
  const request = {
    parent: `projects/${projectId}/locations/${location}`,
  };

  const [results] = await client.listRealms(request);
  for (const realm of results) {
    console.log(`Realm name: ${realm.name}`);
    console.log(`Realm description: ${realm.description}`);
    console.log(`Realm time zone: ${realm.timeZone}`);

    const createTime = realm.createTime;
    const createDate = new Date(createTime.seconds * 1000);
    console.log(`Realm created on: ${createDate.toLocaleDateString()}\n`);
  }
}

listRealms();

Python

Per informazioni su come installare e utilizzare la libreria client per Game Servers, consulta la sezione Librerie client di Game Servers.



def list_realms(project_id, location):
    """Lists the existing realms."""

    client = gaming.RealmsServiceClient()

    response = client.list_realms(parent=f"projects/{project_id}/locations/{location}")

    for realm in response.realms:
        print(f"Name: {realm.name}")

    return response.realms

Descrizione dei reami

console

  1. In Google Cloud Console, vai alla pagina Realms &Clusters (Cluster).

    Vai a Game Servers

  2. Puoi utilizzare la casella di filtro per filtrare l'elenco delle aree di autenticazione in base a diverse proprietà.

  3. Nell'ultima colonna della tabella, fai clic sui puntini di sospensione e seleziona Visualizza dettagli.

gcloud

Puoi ottenere informazioni dettagliate su un'area di autenticazione, ad esempio l'ora di creazione o il fuso orario, utilizzando l'interfaccia a riga di comando di Google Cloud.

Per descrivere un realm globale, esegui il comando seguente e sostituisci realmID con l'identificatore di un'area di autenticazione creata in precedenza:

gcloud game servers realms describe realmID

Se hai creato uno o più realm non globali, puoi descrivere i dettagli di un realm in un'area geografica specifica. Per descrivere un realm in un'area geografica, sostituiscirealmID con l'identificatore per un realm che hai creato in precedenza e regioncon l'area geografica in cui si trova il realm:

gcloud game servers realms describe realmID --location=region

REST &CMD LINE

Prima di utilizzare uno qualsiasi dei dati della richiesta, effettua le seguenti sostituzioni:

  • PROJECT_ID: il tuo ID progetto Google Cloud elencato nelle impostazioni IAM
  • LOCATION: l'area geografica per il regno o global
  • REALM_ID: un identificatore definito dall'utente per il realm

Per inviare la richiesta, espandi una delle seguenti opzioni:

Dovresti ricevere una risposta JSON simile alla seguente:

{
  "name": "projects/PROJECT_ID/locations/LOCATION/realms/REALM_ID",
  "createTime": CREATE_TIME,
  "updateTime": UPDATE_TIME,
  "timeZone": "Asia/Anadyr",
  "etag": "cBxzV2AWK_zgijSmYA-oXPWv3giwhUzssoWcqjPZFuk"
}

C#

Per informazioni su come installare e utilizzare la libreria client per Game Servers, consulta la sezione Librerie client di Game Servers.


using Google.Cloud.Gaming.V1;

public class GetRealmSample
{
    public Realm GetRealm(
        string projectId, string regionId, string realmId)
    {
        // Create the client.
        RealmsServiceClient client = RealmsServiceClient.Create();

        GetRealmRequest request = new GetRealmRequest
        {
            RealmName = RealmName.FromProjectLocationRealm(projectId, regionId, realmId)
        };

        // Make the request.
        Realm response = client.GetRealm(request);
        return response;
    }
}

Go

Per informazioni su come installare e utilizzare la libreria client per Game Servers, consulta la sezione Librerie client di Game Servers.


import (
	"context"
	"fmt"
	"io"

	gaming "cloud.google.com/go/gaming/apiv1"
	gamingpb "google.golang.org/genproto/googleapis/cloud/gaming/v1"
)

// getRealm retrieves info on a realm.
func getRealm(w io.Writer, projectID, location, realmID string) error {
	// projectID := "my-project"
	// location := "global"
	// realmID := "myrealm"
	ctx := context.Background()
	client, err := gaming.NewRealmsClient(ctx)
	if err != nil {
		return fmt.Errorf("NewRealmsClient: %v", err)
	}
	defer client.Close()

	req := &gamingpb.GetRealmRequest{
		Name: fmt.Sprintf("projects/%s/locations/%s/realms/%s", projectID, location, realmID),
	}

	resp, err := client.GetRealm(ctx, req)
	if err != nil {
		return fmt.Errorf("GetRealm: %v", err)
	}

	fmt.Fprintf(w, "Realm retrieved: %v", resp.Name)
	return nil
}

Java

Per informazioni su come installare e utilizzare la libreria client per Game Servers, consulta la sezione Librerie client di Game Servers.


import com.google.cloud.gaming.v1.Realm;
import com.google.cloud.gaming.v1.RealmsServiceClient;
import java.io.IOException;

public class GetRealm {
  public static void getRealm(String projectId, String regionId, String realmId)
      throws IOException {
    // String projectId = "your-project-id";
    // String regionId = "us-central1-f";
    // String realmId = "your-realm-id";
    // Initialize client that will be used to send requests. This client only needs to be created
    // once, and can be reused for multiple requests. After completing all of your requests, call
    // the "close" method on the client to safely clean up any remaining background resources.
    try (RealmsServiceClient client = RealmsServiceClient.create()) {
      String realmName =
          String.format("projects/%s/locations/%s/realms/%s", projectId, regionId, realmId);

      Realm allocationPolicy = client.getRealm(realmName);

      System.out.println("Realm found: " + allocationPolicy.getName());
    }
  }
}

Node.js

Per informazioni su come installare e utilizzare la libreria client per Game Servers, consulta la sezione Librerie client di Game Servers.

const {RealmsServiceClient} = require('@google-cloud/game-servers');

const client = new RealmsServiceClient();

async function getRealm() {
  /**
   * TODO(developer): Uncomment these variables before running the sample.
   */
  // const projectId = 'Your Google Cloud Project ID';
  // const location = 'A Compute Engine region, e.g. "us-central1"';
  // const realmId = 'Unique identifier of the realm';
  const request = {
    // Realm name is the full resource name including project ID and location
    name: client.realmPath(projectId, location, realmId),
  };

  const [realm] = await client.getRealm(request);
  console.log(`Realm name: ${realm.name}`);
  console.log(`Realm description: ${realm.description}`);
  console.log(`Realm time zone: ${realm.timeZone}`);

  const createTime = realm.createTime;
  const createDate = new Date(createTime.seconds * 1000);

  console.log(`Realm created on: ${createDate.toLocaleDateString()}`);
}

getRealm();

Python

Per informazioni su come installare e utilizzare la libreria client per Game Servers, consulta la sezione Librerie client di Game Servers.

def get_realm(project_id, location, realm_id):
    """Gets a realm."""

    client = gaming.RealmsServiceClient()

    request = realms.GetRealmRequest(
        name=f"projects/{project_id}/locations/{location}/realms/{realm_id}",
    )

    response = client.get_realm(request)
    print(f"Get realm response:\n{response}")
    return response

Aggiornamento di un realm

gcloud

Per aggiornare un campo per un realm, esegui il comando gcloud game servers realms update dopo aver sostituito realmID e region per un realm esistente. Il seguente comando aggiorna il valore del fuso orario per un realm. Sostituisci tz con un valore di fuso orario supportato.

gcloud game servers realms update realmID --location=region \
    --time-zone=tz --no-dry-run

Per trovare i flag per altri campi realm, consulta la documentazione di riferimento di gcloud.

REST &CMD LINE

L'esempio seguente aggiorna il campo timeZone. Per aggiornare altri campi, aggiungi i nomi dei campi al parametro di ricerca ?updateMask= e richiedi il corpo JSON.

Prima di utilizzare uno qualsiasi dei dati della richiesta, effettua le seguenti sostituzioni:

  • PROJECT_ID: il tuo ID progetto Google Cloud elencato nelle impostazioni IAM
  • LOCATION: area geografica per il regno
  • REALM_ID: identificatore definito dall'utente per il realm
  • TIME_ZONE: il fuso orario aggiornato per questo dominio (ad esempio, US/Eastern). Puoi pianificare eventi basati sul tempo, come criteri di scalabilità, per questo fuso orario.

Corpo JSON richiesta:

{
  "timeZone": "TIME_ZONE"
}

Per inviare la richiesta, espandi una delle seguenti opzioni:

Dovresti ricevere una risposta JSON simile alla seguente:

{
  "name": "projects/PROJECT_ID/locations/LOCATION/operations/OPERATION_ID",
  "metadata": {
    "@type": "type.googleapis.com/google.cloud.gaming.v1.OperationMetadata",
    "createTime": CREATE_TIME,
    "target": "projects/PROJECT_ID/locations/LOCATION/realms/REALM_ID",
    "verb": "update",
    "requestedCancellation": false,
    "apiVersion": "v1"
  },
  "done": false
}

C#

Per informazioni su come installare e utilizzare la libreria client per Game Servers, consulta la sezione Librerie client di Game Servers.


using Google.Cloud.Gaming.V1;
using Google.LongRunning;
using Google.Protobuf.WellKnownTypes;
using System.Threading.Tasks;

public class UpdateRealmSample
{
    public async Task<Realm> UpdateRealmAsync(
        string projectId, string regionId, string realmId)
    {
        // Create the client.
        RealmsServiceClient client = await RealmsServiceClient.CreateAsync();

        Realm realm = new Realm
        {
            RealmName = RealmName.FromProjectLocationRealm(projectId, regionId, realmId),
        };
        realm.Labels.Add("label-key-1", "label-value-1");
        realm.Labels.Add("label-key-2", "label-value-2");

        UpdateRealmRequest request = new UpdateRealmRequest
        {
            Realm = realm,
            UpdateMask = new FieldMask { Paths = { "labels" } }
        };

        // Make the request.
        Operation<Realm, OperationMetadata> response = await client.UpdateRealmAsync(request);
        Operation<Realm, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();

        // Retrieve the operation result. This result will NOT contain the updated labels.
        // If you want to get the updated resource, use a GET request on the resource.
        return completedResponse.Result;
    }
}

Go

Per informazioni su come installare e utilizzare la libreria client per Game Servers, consulta la sezione Librerie client di Game Servers.


import (
	"context"
	"fmt"
	"io"

	gaming "cloud.google.com/go/gaming/apiv1"
	gamingpb "google.golang.org/genproto/googleapis/cloud/gaming/v1"
	"google.golang.org/protobuf/types/known/fieldmaskpb"
)

// updateRealm updates a realm.
func updateRealm(w io.Writer, projectID, location, realmID string) error {
	// projectID := "my-project"
	// location := "global"
	// realmID := "myrealm"
	ctx := context.Background()
	client, err := gaming.NewRealmsClient(ctx)
	if err != nil {
		return fmt.Errorf("NewRealmsClient: %v", err)
	}
	defer client.Close()

	req := &gamingpb.UpdateRealmRequest{
		Realm: &gamingpb.Realm{
			Name:        fmt.Sprintf("projects/%s/locations/%s/realms/%s", projectID, location, realmID),
			Description: "My Updated Game Server Realm",
			Labels: map[string]string{
				"label-key-1": "label-value-1",
			},
		},
		UpdateMask: &fieldmaskpb.FieldMask{
			Paths: []string{
				"description", "labels",
			},
		},
	}

	op, err := client.UpdateRealm(ctx, req)
	if err != nil {
		return fmt.Errorf("UpdateRealm: %v", err)
	}
	resp, err := op.Wait(ctx)
	if err != nil {
		return fmt.Errorf("Wait: %v", err)
	}

	fmt.Fprintf(w, "Realm updated: %v", resp.Name)
	return nil
}

Java

Per informazioni su come installare e utilizzare la libreria client per Game Servers, consulta la sezione Librerie client di Game Servers.


import com.google.api.gax.longrunning.OperationFuture;
import com.google.cloud.gaming.v1.OperationMetadata;
import com.google.cloud.gaming.v1.Realm;
import com.google.cloud.gaming.v1.RealmsServiceClient;
import com.google.protobuf.FieldMask;
import java.io.IOException;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

public class UpdateRealm {
  public static void updateRealm(String projectId, String regionId, String realmId)
      throws IOException, InterruptedException, ExecutionException, TimeoutException {
    // String projectId = "your-project-id";
    // String regionId = "us-central1-f";
    // String realmId = "your-realm-id";
    // Initialize client that will be used to send requests. This client only needs to be created
    // once, and can be reused for multiple requests. After completing all of your requests, call
    // the "close" method on the client to safely clean up any remaining background resources.
    try (RealmsServiceClient client = RealmsServiceClient.create()) {
      String parent = String.format("projects/%s/locations/%s", projectId, regionId);
      String realmName = String.format("%s/realms/%s", parent, realmId);

      Realm realm = Realm.newBuilder().setName(realmName).setTimeZone("America/New_York").build();

      FieldMask fieldMask = FieldMask.newBuilder().addPaths("time_zone").build();

      OperationFuture<Realm, OperationMetadata> call = client.updateRealmAsync(realm, fieldMask);

      Realm updated = call.get(1, TimeUnit.MINUTES);
      System.out.println("Realm updated: " + updated.getName());
    }
  }
}

Node.js

Per informazioni su come installare e utilizzare la libreria client per Game Servers, consulta la sezione Librerie client di Game Servers.

const {RealmsServiceClient} = require('@google-cloud/game-servers');

const client = new RealmsServiceClient();

async function updateRealm() {
  /**
   * TODO(developer): Uncomment these variables before running the sample.
   */
  // const projectId = 'Your Google Cloud Project ID';
  // const location = 'A Compute Engine region, e.g. "us-central1"';
  // const realmId = 'The unique identifier for the realm';
  const request = {
    realm: {
      name: client.realmPath(projectId, location, realmId),
      labels: {
        'label-key-1': 'label-value-1',
      },
      timeZone: 'US/Pacific',
      description: 'My updated Game Server realm',
    },
    updateMask: {
      paths: ['labels', 'time_zone', 'description'],
    },
  };

  const [operation] = await client.updateRealm(request);
  const results = await operation.promise();
  const [realm] = results;

  console.log(`Realm updated: ${realm.name}`);
}

updateRealm();

Python

Per informazioni su come installare e utilizzare la libreria client per Game Servers, consulta la sezione Librerie client di Game Servers.

def update_realm(project_id, location, realm_id):
    """Updates a realm."""

    client = gaming.RealmsServiceClient()

    request = realms.UpdateRealmRequest(
        realm=realms.Realm(
            name=f"projects/{project_id}/locations/{location}/realms/{realm_id}",
            labels={"label-key-1": "label-value-1", "label-key-2": "label-value-2"},
        ),
        update_mask=field_mask.FieldMask(paths=["labels"]),
    )

    operation = client.update_realm(request)
    print(f"Update realm operation: {operation.operation.name}")
    operation.result(timeout=120)

Passaggi successivi