Como registrar um cluster

Nesta página, explicamos como registrar, listar e visualizar os detalhes de um cluster do Game Servers em um realm.

Antes de começar

Antes de começar, recomendamos que você se familiarize com os principais conceitos na Visão geral do Game Servers. Verifique se você também realizou as seguintes tarefas:

  • Verifique se você ativou a API Game Services.
  • Ativar a API Game Services
  • Escolha um shell com o SDK do Cloud instalado ou use um cliente de API:
  • Cloud Shell

    Para iniciar o Cloud Shell, execute os seguintes passos:

    1. Acesse o Console do Google Cloud.

      Console do Google Cloud

    2. No canto superior direito do console, clique no botão Ativar Cloud Shell:

    Uma sessão do Cloud Shell é aberta dentro de um quadro inferior no console. Use esse shell para executar comandos gcloud.

    Shell local

    Para instalar gcloud, instale o SDK do Cloud, que inclui a ferramenta de linha de comando gcloud.

    Verifique se você definiu o projeto padrão desejado para a ferramenta de linha de comando do gcloud (caso contrário, você precisará especificar a sinalização --project explicitamente para cada comando mais tarde):

    gcloud config list project
    

    Caso contrário, execute o seguinte comando para definir um projeto padrão, substituindo PROJECT_ID pelo ID do projeto que você quer:

    gcloud config set project PROJECT_ID
    

    Execute o comando a seguir para verificar sua versão do SDK do Cloud. O Game Servers requer a versão 306.0.0 ou superior do SDK.

    gcloud version
    

    Para atualizar a instalação, execute o seguinte comando:

    gcloud components update
    

    curl / PowerShell

    Para usar a API REST com curl ou o Windows PowerShell, faça o seguinte:

    1. Crie uma conta de serviço.
    2. Faça o download de uma chave privada como um arquivo JSON.
    3. Defina a variável de ambiente GOOGLE_APPLICATION_CREDENTIALS como o caminho do arquivo JSON que contém a chave da conta de serviço. Essa variável só se aplica à sessão de shell atual. Dessa maneira, se você abrir uma nova sessão, defina a variável novamente.

    Biblioteca de cliente

    O Game Servers do Google Cloud pode ser controlado de maneira programática usando uma biblioteca de cliente. Consulte Visão geral das bibliotecas de cliente para instruções sobre como usar a biblioteca e fazer a autenticação.

Como registrar um cluster

Verifique se você criou um realm do Game Servers.

Se você não tiver um cluster do Google Kubernetes Engine (GKE) com o Agones instalado, faça o seguinte:

  1. Crie um cluster público do Google Kubernetes Engine e uma regra de firewall para o Agones. Ative a API Kubernetes Engine.

    O Game Servers não é compatível com clusters particulares.

  2. Verifique se a regra de firewall para o Agones está ativada:

    gcloud compute firewall-rules list --filter="name~'game-server.*'"
    

    Você verá esta resposta:

    NAME                               NETWORK  DIRECTION  PRIORITY  ALLOW    DENY  DISABLED
    game-server-firewall-test-cluster  default  INGRESS    1000      udp:7000-8000  False
    
  3. Instale o Agones.

  4. Verifique se as versões do cluster do Agones e do Kubernetes são compatíveis e você instalou o Agones no namespace agones-system. Consulte Como confirmar a instalação do Agones para mais informações.

Como registrar um cluster de servidor de jogos

Console

  1. No Console do Cloud, acesse a página Realms e clusters.

    Acessar o Game Servers

  2. Clique em Adicionar cluster do Game Server.

  3. Selecione o realm a que o cluster do Game Servers pertencerá na lista Realms para escolher. Clique no botão Criar um realm para criar um realm, se necessário.

  4. Clique em Continuar.

  5. Na caixa ID do cluster do Game Servers, insira um identificador exclusivo para esse cluster do Game Servers.

  6. Na lista do cluster do Kubernetes, selecione um cluster do Kubernetes com o Agones instalado.

  7. Clique em Criar.

gcloud

É possível registrar um cluster do Game Servers em um realm usando a ferramenta de linha de comando gcloud.

Como registrar um cluster de servidor de jogos global

Para registrar um cluster de servidor de jogos global:

  1. Execute o seguinte comando e substitua os valores do marcador, como realmID, pelos valores apropriados:

    gcloud game servers clusters create gscID --realm=realmID --gke-cluster=gkeCluster --namespace=default --dry-run
    

    A saída retorna targetState para que você possa visualizar o novo cluster antes de registrá-lo.

  2. Para registrar e criar o cluster global, execute o seguinte comando:

    gcloud game servers clusters create gscID --realm=realmID --gke-cluster gkeCluster --namespace=default --no-dry-run
    

Como registrar um cluster de servidor de jogos regional

Para registrar um cluster de servidor de jogos regional:

  1. Execute o seguinte comando e substitua os valores do marcador, como realmID, pelos valores apropriados:

    gcloud game servers clusters create gscID --realm=realmID --gke-cluster gkeCluster --location=region --namespace=default --dry-run
    

    A saída retorna targetState para que você possa visualizar o novo cluster antes de criá-lo.

  2. Para registrar e criar o cluster regional, execute o seguinte comando:

    gcloud game servers clusters create gscID --realm=realmID --gke-cluster gkeCluster --location=region --namespace=default --no-dry-run
    

Se o Game Servers não puder validar o cluster que você está tentando anexar, você verá o seguinte erro:

Cannot connect to the provided Kubernetes cluster "projects/project/locations/location/clusters/gkeCluster, check the name and make sure that the cluster exists

Em caso afirmativo, verifique se gkeCluster está formatado corretamente e se o cluster existe em project e em location.

Os marcadores das variáveis correspondem às seguintes descrições:

  • gscID é um identificador exclusivo que pode ser especificado para esse cluster.
  • realmID é o identificador exclusivo do realm em que você quer armazenar o cluster.
  • gkeCluster é o caminho do recurso totalmente qualificado de um cluster do GKE, como projects/<projectId>/locations/<location>/clusters/<clusterId>.
  • region é a região do cluster. Escolha a mesma região do realm pai.

REST e LINHA DE CMD

Antes de usar os dados da solicitação abaixo, faça as substituições a seguir:

  • PROJECT_ID: o ID do projeto do Google Cloud listado nas Configurações do IAM
  • REALM_LOCATION: a região do realm, ou global, em que o cluster será armazenado
  • REALM_ID: o identificador do realm em que o cluster será armazenado
  • GS_CLUSTER_ID: um identificador definido pelo usuário para o cluster
  • GKE_CLUSTER_LOCATION: a região do cluster do GKE
  • GKE_CLUSTER_ID: o identificador de um cluster do GKE

Corpo JSON da solicitação:

{
  "name": "projects/PROJECT_ID/locations/REALM_LOCATION/realms/REALM_ID/gameServerClusters/GS_CLUSTER_ID",
  "connectionInfo": {
    "namespace": "default",
    "gkeClusterReference": {
      "cluster": "projects/PROJECT_ID/locations/GKE_CLUSTER_LOCATION/clusters/GKE_CLUSTER_ID"
    }
  }
}

Para enviar a solicitação, expanda uma destas opções:

Você receberá uma resposta JSON semelhante a esta:

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

C#

Para saber como instalar e usar a biblioteca de cliente do Game Servers, consulte as Bibliotecas de cliente do Game Servers.


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

public class CreateClusterSample
{
    public async Task<GameServerCluster> CreateClusterAsync(
        string projectId, string regionId, string realmId, string clusterId, string gkeName)
    {
        // Create the client.
        GameServerClustersServiceClient client = await GameServerClustersServiceClient.CreateAsync();

        GameServerCluster cluster = new GameServerCluster()
        {
            GameServerClusterName = GameServerClusterName.FromProjectLocationRealmCluster(projectId, regionId, realmId, clusterId),
            ConnectionInfo = new GameServerClusterConnectionInfo
            {
                GkeClusterReference = new GkeClusterReference
                {
                    Cluster = gkeName
                },
                Namespace = "default"
            }
        };
        CreateGameServerClusterRequest request = new CreateGameServerClusterRequest
        {
            ParentAsRealmName = RealmName.FromProjectLocationRealm(projectId, regionId, realmId),
            GameServerClusterId = clusterId,
            GameServerCluster = cluster
        };

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

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

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

Go

Para saber como instalar e usar a biblioteca de cliente do Game Servers, consulte as Bibliotecas de cliente do Game Servers.


import (
	"context"
	"fmt"
	"io"

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

// createCluster registers a game server cluster.
func createCluster(w io.Writer, projectID, location, realmID, clusterID, gkeClusterName string) error {
	// projectID := "my-project"
	// location := "global"
	// realmID := "myrealm"
	// clusterID := "mycluster"
	// gkeClusterName := "projects/1234/locations/us-central1/clusters/gke-cluster"
	ctx := context.Background()
	client, err := gaming.NewGameServerClustersClient(ctx)
	if err != nil {
		return fmt.Errorf("NewGameServerClustersClient: %v", err)
	}
	defer client.Close()

	req := &gamingpb.CreateGameServerClusterRequest{
		Parent:              fmt.Sprintf("projects/%s/locations/%s/realms/%s", projectID, location, realmID),
		GameServerClusterId: clusterID,
		GameServerCluster: &gamingpb.GameServerCluster{
			ConnectionInfo: &gamingpb.GameServerClusterConnectionInfo{
				Namespace: "default",
				ClusterReference: &gamingpb.GameServerClusterConnectionInfo_GkeClusterReference{
					GkeClusterReference: &gamingpb.GkeClusterReference{
						Cluster: gkeClusterName,
					},
				},
			},
			Description: "My Game Server Cluster",
		},
	}

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

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

Java

Para saber como instalar e usar a biblioteca de cliente do Game Servers, consulte as Bibliotecas de cliente do Game Servers.


import com.google.api.gax.longrunning.OperationFuture;
import com.google.cloud.gaming.v1.CreateGameServerClusterRequest;
import com.google.cloud.gaming.v1.GameServerCluster;
import com.google.cloud.gaming.v1.GameServerClusterConnectionInfo;
import com.google.cloud.gaming.v1.GameServerClustersServiceClient;
import com.google.cloud.gaming.v1.GkeClusterReference;
import com.google.cloud.gaming.v1.OperationMetadata;
import java.io.IOException;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

public class CreateCluster {

  public static void createGameServerCluster(
      String projectId, String regionId, String realmId, String clusterId, String gkeName)
      throws InterruptedException, ExecutionException, TimeoutException, IOException {
    // String projectId = "your-project-id";
    // String regionId = "us-central1-f";
    // String realmId = "your-realm-id";
    // String clusterId = "your-game-server-cluster-id";
    // String gkeName = "projects/your-project-id/locations/us-central1/clusters/test";
    // 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 (GameServerClustersServiceClient client = GameServerClustersServiceClient.create()) {
      String parent =
          String.format("projects/%s/locations/%s/realms/%s", projectId, regionId, realmId);
      String clusterName = String.format("%s/gameServerClusters/%s", parent, clusterId);

      GameServerCluster gameServerCluster =
          GameServerCluster.newBuilder()
              .setName(clusterName)
              .setConnectionInfo(
                  GameServerClusterConnectionInfo.newBuilder()
                      .setGkeClusterReference(
                          GkeClusterReference.newBuilder().setCluster(gkeName).build())
                      .setNamespace("default"))
              .build();

      CreateGameServerClusterRequest request =
          CreateGameServerClusterRequest.newBuilder()
              .setParent(parent)
              .setGameServerClusterId(clusterId)
              .setGameServerCluster(gameServerCluster)
              .build();

      OperationFuture<GameServerCluster, OperationMetadata> call =
          client.createGameServerClusterAsync(request);

      GameServerCluster created = call.get(1, TimeUnit.MINUTES);
      System.out.println("Game Server Cluster created: " + created.getName());
    }
  }
}

Node.js

Para saber como instalar e usar a biblioteca de cliente do Game Servers, consulte as Bibliotecas de cliente do Game Servers.

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

const client = new GameServerClustersServiceClient();

async function createGameServerCluster() {
  /**
   * 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 ID of the realm to locate this cluster in';
  // const gameClusterId = 'A unique ID for this Game Server Cluster';
  // const gkeClusterName= 'The full resource name of the GKE cluster to use';
  const request = {
    // Provide full resource name of a Game Server Realm
    parent: client.realmPath(projectId, location, realmId),
    gameServerClusterId: gameClusterId,
    gameServerCluster: {
      description: 'My Game Server Cluster',
      connectionInfo: {
        gkeClusterReference: {
          // Provide full resource name of a Kubernetes Engine cluster
          // In the form of 'projects/<project-id>/locations/<location>/clusters/<gke-cluster-name>'
          cluster: gkeClusterName,
        },
        namespace: 'default',
      },
    },
  };

  const [operation] = await client.createGameServerCluster(request);
  const [result] = await operation.promise();

  console.log('Game Server Cluster created:');
  console.log(`\tCluster name: ${result.name}`);
  console.log(`\tCluster description: ${result.description}`);
  console.log(
    `\tGKE cluster: ${result.connectionInfo.gkeClusterReference.cluster}`
  );
}

createGameServerCluster();

Python

Para saber como instalar e usar a biblioteca de cliente do Game Servers, consulte as Bibliotecas de cliente do Game Servers.

def create_cluster(project_id, location, realm_id, cluster_id, gke_cluster_name):
    """Creates a game server cluster."""

    client = gaming.GameServerClustersServiceClient()

    gke_cluster_reference = game_server_clusters.GkeClusterReference(
        cluster=gke_cluster_name,
    )
    request = game_server_clusters.CreateGameServerClusterRequest(
        parent=f"projects/{project_id}/locations/{location}/realms/{realm_id}",
        game_server_cluster_id=cluster_id,
        game_server_cluster=game_server_clusters.GameServerCluster(
            description="My Game Server Cluster",
            connection_info=game_server_clusters.GameServerClusterConnectionInfo(
                gke_cluster_reference=gke_cluster_reference, namespace="default",
            ),
        ),
    )

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

Depois de criar um cluster do servidor de jogos, o Game Servers cria frotas do Agones e escalonadores automáticos, conforme necessário. O Game Servers não altera as frotas do Agones criadas manualmente.

Como listar clusters

Console

  1. No Console do Cloud, acesse a página Realms e clusters.

    Acessar o Game Servers

  2. Expanda um realm para ver os clusters do Game Servers que pertencem a ele.

  3. É possível usar a caixa de filtro para filtrar os realms e a lista de clusters por propriedades diferentes.

gcloud

Você pode listar clusters globais ou regionais usando a ferramenta de linha de comando gcloud.

Para listar clusters globais e regionais, execute o seguinte comando: Adicione a sinalização opcional --view=FULL para exibir as versões do Agones e Kubernetes instalados nos clusters.

gcloud game servers clusters list [--view=FULL; default="BASIC"]

Para listar somente clusters em uma região, execute o comando a seguir e substitua region pela região em que você quer listar os clusters:

gcloud game servers clusters list --location=region [--view=FULL; default="BASIC"]

Para listar todos os clusters em um realm, execute o seguinte comando e substitua realmID pelo realm pai e region pela região em que você quer listar os clusters:

gcloud game servers clusters list --realm=realmID --location=region [--view=FULL; default="BASIC"]

REST e LINHA DE CMD

Antes de usar os dados da solicitação abaixo, faça as substituições a seguir:

  • PROJECT_ID: o ID do projeto do Google Cloud listado nas Configurações do IAM
  • REALM_LOCATION: a região do realm ou global
  • REALM_ID: o identificador definido pelo usuário para o realm

Para enviar a solicitação, expanda uma destas opções:

Você receberá uma resposta JSON semelhante a esta:

{
  "gameServerClusters": [
    {
      "name": "projects/PROJECT_ID/locations/REALM_LOCATION/realms/REALM_ID/gameServerClusters/my-gs-cluster-1",
      "createTime": CREATE_TIME,
      "updateTime": UPDATE_TIME,
      "connectionInfo": {
        "namespace": "default",
        "gkeClusterReference": {
          "cluster": "projects/PROJECT_ID/locations/GKE_CLUSTER_LOCATION/clusters/my-gke-cluster-1"
        }
      },
      "etag": "8mBC7IJJFvY40k-rBabOOaGR6sSRG3dP6pI-frTuu9Y",
      "clusterState": {
        "agonesVersionInstalled": "1.15.0",
        "kubernetesVersionInstalled": "1.18.20-gke.900",
        "installationState": "AGONES_KUBERNETES_VERSION_SUPPORTED",
        "provider": "gke"
      }
    },
    {
      "name": "projects/PROJECT_ID/locations/REALM_LOCATION/realms/REALM_ID/gameServerClusters/my-gs-cluster-2",
      "createTime": CREATE_TIME,
      "updateTime": UPDATE_TIME,
      "connectionInfo": {
        "namespace": "default",
        "gkeClusterReference": {
          "cluster": "projects/PROJECT_ID/locations/GKE_CLUSTER_LOCATION/clusters/my-gke-cluster-2"
        }
      },
      "etag": "8mBC7IJJFvY40k-rBabOOaGR6sSRG3dP6pI-frTuu9Y",
      "clusterState": {
        "agonesVersionInstalled": "1.15.0",
        "kubernetesVersionInstalled": "1.18.20-gke.900",
        "installationState": "AGONES_KUBERNETES_VERSION_SUPPORTED",
        "provider": "gke"
      }
    }
  ]
}

C#

Para saber como instalar e usar a biblioteca de cliente do Game Servers, consulte as Bibliotecas de cliente do Game Servers.


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

public class ListClustersSample
{
    public IList<GameServerCluster> ListClusters(
        string projectId, string regionId, string realmId)
    {
        // Create the client.
        GameServerClustersServiceClient client = GameServerClustersServiceClient.Create();

        ListGameServerClustersRequest request = new ListGameServerClustersRequest
        {
            ParentAsRealmName = RealmName.FromProjectLocationRealm(projectId, regionId, realmId),
            View = GameServerClusterView.Full
        };

        // Make the request.
        PagedEnumerable<ListGameServerClustersResponse, GameServerCluster> response = client.ListGameServerClusters(request);

        // You could iterate through response and write the cluster.Name and
        // cluster.ClusterState to the console to see the installed versions of Agones
        // and Kubernetes on each cluster.

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

Go

Para saber como instalar e usar a biblioteca de cliente do Game Servers, consulte as Bibliotecas de cliente do 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"
)

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

	req := &gamingpb.ListGameServerClustersRequest{
		Parent: fmt.Sprintf("projects/%s/locations/%s/realms/%s", projectID, location, realmID),
		View:   gamingpb.GameServerClusterView_FULL,
	}

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

		fmt.Fprintf(w, "Cluster listed: %v\n", resp.Name)
		fmt.Fprintf(w, "Cluster installed Agones version: %v\n", resp.ClusterState.AgonesVersionInstalled)
		fmt.Fprintf(w, "Cluster installed Kubernetes version: %v\n", resp.ClusterState.KubernetesVersionInstalled)
		fmt.Fprintf(w, "Cluster installation state: %v\n", resp.ClusterState.InstallationState)
	}

	return nil
}

Java

Para saber como instalar e usar a biblioteca de cliente do Game Servers, consulte as Bibliotecas de cliente do Game Servers.


import com.google.cloud.gaming.v1.GameServerCluster;
import com.google.cloud.gaming.v1.GameServerClusterView;
import com.google.cloud.gaming.v1.GameServerClustersServiceClient;
import com.google.cloud.gaming.v1.GameServerClustersServiceClient.ListGameServerClustersPagedResponse;
import com.google.cloud.gaming.v1.ListGameServerClustersRequest;
import com.google.cloud.gaming.v1.RealmName;
import com.google.common.base.Strings;
import java.io.IOException;

public class ListClusters {

  public static void listGameServerClusters(String projectId, String regionId, String realmId)
      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 (GameServerClustersServiceClient client = GameServerClustersServiceClient.create()) {
      ListGameServerClustersRequest request =
          ListGameServerClustersRequest.newBuilder()
              .setParent(RealmName.of(projectId, regionId, realmId).toString())
              .setView(GameServerClusterView.FULL)
              .build();
      ListGameServerClustersPagedResponse response = client.listGameServerClusters(request);
      for (GameServerCluster cluster : response.iterateAll()) {
        System.out.println("Game Server Cluster found: " + cluster.getName());
        System.out.println(
            "Cluster installed Agones version: "
                + cluster.getClusterState().getAgonesVersionInstalled());
        System.out.println(
            "Cluster installed Kubernetes version: "
                + cluster.getClusterState().getKubernetesVersionInstalled());
        System.out.println(
            "Cluster installation state: " + cluster.getClusterState().getInstallationState());
      }

      while (!Strings.isNullOrEmpty(response.getNextPageToken())) {
        ListGameServerClustersRequest request2 =
            ListGameServerClustersRequest.newBuilder()
                .setParent(RealmName.of(projectId, regionId, realmId).toString())
                .setPageToken(response.getNextPageToken())
                .build();
        response = client.listGameServerClusters(request2);
        for (GameServerCluster cluster : response.iterateAll()) {
          System.out.println("Game Server Cluster found: " + cluster.getName());
          System.out.println(
              "Cluster installed Agones version: "
                  + cluster.getClusterState().getAgonesVersionInstalled());
          System.out.println(
              "Cluster installed Kubernetes version: "
                  + cluster.getClusterState().getKubernetesVersionInstalled());
          System.out.println(
              "Cluster installation state: " + cluster.getClusterState().getInstallationState());
        }
      }
    }
  }
}

Node.js

Para saber como instalar e usar a biblioteca de cliente do Game Servers, consulte as Bibliotecas de cliente do Game Servers.

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

const client = new GameServerClustersServiceClient();

async function listGameServerClusters() {
  /**
   * 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 ID of the realm to locate this cluster in';
  const request = {
    // Provide full resource name of a Game Server Realm
    parent: client.realmPath(projectId, location, realmId),
    view: 'FULL',
  };

  const results = await client.listGameServerClusters(request);
  const [clusters] = results;

  for (const cluster of clusters) {
    console.log('Game Server Cluster:');
    console.log(`\tCluster name: ${cluster.name}`);
    console.log(`\tCluster description: ${cluster.description}`);
    console.log(
      `\tCluster installed Agones version: ${cluster.clusterState.agonesVersionInstalled}`
    );
    console.log(
      `\tCluster installed Kubernetes version: ${cluster.clusterState.kubernetesVersionInstalled}`
    );
    console.log(
      `\tCluster installation state: ${cluster.clusterState.installationState}`
    );
    console.log(
      `\tGKE cluster: ${cluster.connectionInfo.gkeClusterReference.cluster}`
    );
  }
}

listGameServerClusters();

Python

Para saber como instalar e usar a biblioteca de cliente do Game Servers, consulte as Bibliotecas de cliente do Game Servers.

def list_clusters(project_id, location, realm_id):
    """Lists the existing game server clusters."""

    client = gaming.GameServerClustersServiceClient()

    response = client.list_game_server_clusters(
        request=game_server_clusters.ListGameServerClustersRequest(
            parent=f"projects/{project_id}/locations/{location}/realms/{realm_id}",
            view=game_server_clusters.GameServerClusterView.FULL,
        )
    )

    for cluster in response.game_server_clusters:
        print(f"Name: {cluster.name}")
        print(f"State:\n{cluster.cluster_state}")

    return response.game_server_clusters

Como ver detalhes de um cluster

Console

  1. No Console do Cloud, acesse a página Realms e clusters.

    Acessar o Game Servers

  2. Expanda um realm para ver os clusters do Game Servers que pertencem a ele.

  3. Na última coluna da tabela para o realm, clique nas reticências e selecione Visualizar detalhes.

gcloud

Para encontrar detalhes de um cluster, como horário de criação ou detalhes do cluster do GKE, use a ferramenta de linha de comando gcloud.

Para ver os detalhes de um cluster, execute o comando a seguir e substitua os valores do marcador, como realmID, pelos valores apropriados:

gcloud game servers clusters describe gscID --realm realmID --location=region [--view=FULL; default="BASIC"]

A resposta mostra os detalhes do cluster. Adicione a sinalização --view=FULL opcional para exibir as versões do Agones e do Kubernetes instaladas no cluster.

Os marcadores das variáveis correspondem às seguintes descrições:

  • gscID é o identificador exclusivo que você especificou para esse cluster de servidor de jogos.
  • realmID é um identificador exclusivo do realm em que o cluster está armazenado.
  • region é a região do cluster. Escolha a mesma região do realm pai.

REST e LINHA DE CMD

Antes de usar os dados da solicitação abaixo, faça as substituições a seguir:

  • PROJECT_ID: o ID do projeto do Google Cloud listado nas Configurações do IAM
  • REALM_LOCATION: a região do realm ou global
  • REALM_ID: o identificador definido pelo usuário para o realm
  • GS_CLUSTER_ID: o identificador definido pelo usuário para o cluster

Para enviar a solicitação, expanda uma destas opções:

Você receberá uma resposta JSON semelhante a esta:

{
  "name": "projects/PROJECT_ID/locations/REALM_LOCATION/realms/REALM_ID/gameServerClusters/GS_CLUSTER_ID",
  "createTime": CREATE_TIME,
  "updateTime": UPDATE_TIME,
  "connectionInfo": {
    "namespace": "default",
    "gkeClusterReference": {
      "cluster": "projects/PROJECT_ID/locations/GKE_CLUSTER_LOCATION/clusters/MY_GKE_CLUSTER"
    }
  },
  "etag": "8mBC7IJJFvY40k-rBabOOaGR6sSRG3dP6pI-frTuu9Y",
  "clusterState": {
    "agonesVersionInstalled": "1.15.0",
    "kubernetesVersionInstalled": "1.18.20-gke.900",
    "installationState": "AGONES_KUBERNETES_VERSION_SUPPORTED",
    "provider": "gke"
  }
}

C#

Para saber como instalar e usar a biblioteca de cliente do Game Servers, consulte as Bibliotecas de cliente do Game Servers.


using Google.Cloud.Gaming.V1;

public class GetClusterSample
{
    public GameServerCluster GetCluster(
        string projectId, string regionId, string realmId, string clusterId)
    {
        // Create the client.
        GameServerClustersServiceClient client = GameServerClustersServiceClient.Create();

        GetGameServerClusterRequest request = new GetGameServerClusterRequest
        {
            GameServerClusterName = GameServerClusterName.FromProjectLocationRealmCluster(projectId, regionId, realmId, clusterId),
            View = GameServerClusterView.Full
        };

        // Make the request.
        GameServerCluster response = client.GetGameServerCluster(request);

        // You could write response.Name and response.ClusterState to the console
        // to see the installed versions of Agones and Kubernetes on the cluster.

        return response;
    }
}

Go

Para saber como instalar e usar a biblioteca de cliente do Game Servers, consulte as Bibliotecas de cliente do Game Servers.


import (
	"context"
	"fmt"
	"io"

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

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

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

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

	fmt.Fprintf(w, "Cluster retrieved: %v\n", resp.Name)
	fmt.Fprintf(w, "Cluster installed Agones version: %v\n", resp.ClusterState.AgonesVersionInstalled)
	fmt.Fprintf(w, "Cluster installed Kubernetes version: %v\n", resp.ClusterState.KubernetesVersionInstalled)
	fmt.Fprintf(w, "Cluster installation state: %v\n", resp.ClusterState.InstallationState)
	return nil
}

Java

Para saber como instalar e usar a biblioteca de cliente do Game Servers, consulte as Bibliotecas de cliente do Game Servers.


import com.google.cloud.gaming.v1.GameServerCluster;
import com.google.cloud.gaming.v1.GameServerClusterName;
import com.google.cloud.gaming.v1.GameServerClusterView;
import com.google.cloud.gaming.v1.GameServerClustersServiceClient;
import com.google.cloud.gaming.v1.GetGameServerClusterRequest;
import java.io.IOException;

public class GetCluster {

  public static void getGameServerCluster(
      String projectId, String regionId, String realmId, String clusterId) throws IOException {
    // String projectId = "your-project-id";
    // String regionId = "us-central1-f";
    // String realmId = "your-realm-id";
    // String clusterId = "your-game-server-cluster-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 (GameServerClustersServiceClient client = GameServerClustersServiceClient.create()) {
      GetGameServerClusterRequest request =
          GetGameServerClusterRequest.newBuilder()
              .setName(GameServerClusterName.of(projectId, regionId, realmId, clusterId).toString())
              .setView(GameServerClusterView.FULL)
              .build();
      GameServerCluster cluster = client.getGameServerCluster(request);

      System.out.println("Game Server Cluster found: " + cluster.getName());
      System.out.println(
          "Cluster installed Agones version: "
              + cluster.getClusterState().getAgonesVersionInstalled());
      System.out.println(
          "Cluster installed Kubernetes version: "
              + cluster.getClusterState().getKubernetesVersionInstalled());
      System.out.println(
          "Cluster installation state: " + cluster.getClusterState().getInstallationState());
    }
  }
}

Node.js

Para saber como instalar e usar a biblioteca de cliente do Game Servers, consulte as Bibliotecas de cliente do Game Servers.

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

const client = new GameServerClustersServiceClient();

async function getGameServerCluster() {
  /**
   * 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 ID of the realm to locate this cluster in';
  // const gameClusterId = 'The unique ID for this Game Server Cluster';
  const request = {
    // Provide full resource name of a Game Server Realm
    name: client.gameServerClusterPath(
      projectId,
      location,
      realmId,
      gameClusterId
    ),
    view: 'FULL',
  };

  const [cluster] = await client.getGameServerCluster(request);

  console.log('Game Server Cluster:');
  console.log(`\tCluster name: ${cluster.name}`);
  console.log(`\tCluster description: ${cluster.description}`);
  console.log(
    `\tCluster installed Agones version: ${cluster.clusterState.agonesVersionInstalled}`
  );
  console.log(
    `\tCluster installed Kubernetes version: ${cluster.clusterState.kubernetesVersionInstalled}`
  );
  console.log(
    `\tCluster installation state: ${cluster.clusterState.installationState}`
  );
  console.log(
    `\tGKE cluster: ${cluster.connectionInfo.gkeClusterReference.cluster}`
  );
}

getGameServerCluster();

Python

Para saber como instalar e usar a biblioteca de cliente do Game Servers, consulte as Bibliotecas de cliente do Game Servers.

def get_cluster(project_id, location, realm_id, cluster_id):
    """Gets a game server cluster."""

    client = gaming.GameServerClustersServiceClient()

    request = game_server_clusters.GetGameServerClusterRequest(
        name=f"projects/{project_id}/locations/{location}/realms/{realm_id}/gameServerClusters/{cluster_id}",
        view=game_server_clusters.GameServerClusterView.FULL,
    )

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

Atualizar um cluster

gcloud

Para atualizar um campo para um cluster, execute o comando gcloud game servers clusters update depois de substituir os identificadores de um cluster existente. O comando a seguir atualiza o campo de descrição de um cluster.

gcloud game servers clusters update gscID \
    --realm=realmID --location=region \
    --description="My updated description" --no-dry-run

Para encontrar as sinalizações de outros campos de cluster, consulte a referência do gcloud.

REST e LINHA DE CMD

A amostra a seguir atualiza o campo description. Para atualizar outros campos, adicione os nomes deles ao parâmetro de consulta ?updateMask= e solicite o corpo JSON.

Antes de usar os dados da solicitação abaixo, faça as substituições a seguir:

  • PROJECT_ID: o ID do projeto do Google Cloud listado nas Configurações do IAM
  • REALM_LOCATION: a região do realm ou global
  • REALM_ID: o identificador do realm.
  • GS_CLUSTER_ID: o identificador definido pelo usuário para o cluster

Corpo JSON da solicitação:

{
  "description": "My updated description"
}

Para enviar a solicitação, expanda uma destas opções:

Você receberá uma resposta JSON semelhante a esta:

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

C#

Para saber como instalar e usar a biblioteca de cliente do Game Servers, consulte as Bibliotecas de cliente do Game Servers.


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

public class UpdateClusterSample
{
    public async Task<GameServerCluster> UpdateClusterAsync(
        string projectId, string regionId, string realmId, string clusterId)
    {
        // Create the client.
        GameServerClustersServiceClient client = await GameServerClustersServiceClient.CreateAsync();

        GameServerCluster cluster = new GameServerCluster()
        {
            GameServerClusterName = GameServerClusterName.FromProjectLocationRealmCluster(projectId, regionId, realmId, clusterId)
        };
        cluster.Labels.Add("label-key-1", "label-value-1");
        cluster.Labels.Add("label-key-2", "label-value-2");

        UpdateGameServerClusterRequest request = new UpdateGameServerClusterRequest
        {
            GameServerCluster = cluster,
            UpdateMask = new FieldMask { Paths = { "labels" } }
        };

        // Make the request.
        Operation<GameServerCluster, OperationMetadata> response = await client.UpdateGameServerClusterAsync(request);
        Operation<GameServerCluster, 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

Para saber como instalar e usar a biblioteca de cliente do Game Servers, consulte as Bibliotecas de cliente do 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"
)

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

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

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

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

Java

Para saber como instalar e usar a biblioteca de cliente do Game Servers, consulte as Bibliotecas de cliente do Game Servers.


import com.google.api.gax.longrunning.OperationFuture;
import com.google.cloud.gaming.v1.GameServerCluster;
import com.google.cloud.gaming.v1.GameServerClustersServiceClient;
import com.google.cloud.gaming.v1.OperationMetadata;
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 UpdateCluster {
  public static void updateGameServerCluster(
      String projectId, String regionId, String realmId, String clusterId)
      throws IOException, InterruptedException, ExecutionException, TimeoutException {
    // String projectId = "your-project-id";
    // String regionId = "us-central1-f";
    // String realmId = "your-realm-id";
    // String clusterId = "your-game-server-cluster-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 (GameServerClustersServiceClient client = GameServerClustersServiceClient.create()) {
      String parent =
          String.format("projects/%s/locations/%s/realms/%s", projectId, regionId, realmId);
      String clusterName = String.format("%s/gameServerClusters/%s", parent, clusterId);

      GameServerCluster cluster =
          GameServerCluster.newBuilder().setName(clusterName).putLabels("key", "value").build();

      FieldMask fieldMask = FieldMask.newBuilder().addPaths("labels").build();
      OperationFuture<GameServerCluster, OperationMetadata> call =
          client.updateGameServerClusterAsync(cluster, fieldMask);

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

Node.js

Para saber como instalar e usar a biblioteca de cliente do Game Servers, consulte as Bibliotecas de cliente do Game Servers.

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

const client = new GameServerClustersServiceClient();

async function updateGameServerCluster() {
  /**
   * 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 ID of the realm of this cluster';
  // const gameClusterId = 'A unique ID for this Game Server Cluster';
  const request = {
    // Provide full resource name of a Game Server Cluster
    gameServerCluster: {
      name: client.gameServerClusterPath(
        projectId,
        location,
        realmId,
        gameClusterId
      ),
      labels: {
        'label-key-1': 'label-value-1',
      },
      description: 'My updated Game Server Cluster',
    },
    updateMask: {
      paths: ['labels', 'description'],
    },
  };

  const [operation] = await client.updateGameServerCluster(request);
  const [result] = await operation.promise();

  console.log(`Cluster updated: ${result.name}`);
}

updateGameServerCluster();

Python

Para saber como instalar e usar a biblioteca de cliente do Game Servers, consulte as Bibliotecas de cliente do Game Servers.

def update_cluster(project_id, location, realm_id, cluster_id):
    """Updates a game server cluster."""

    client = gaming.GameServerClustersServiceClient()

    request = game_server_clusters.UpdateGameServerClusterRequest(
        game_server_cluster=game_server_clusters.GameServerCluster(
            name=f"projects/{project_id}/locations/{location}/realms/{realm_id}/gameServerClusters/{cluster_id}",
            labels={"label-key-1": "label-value-1", "label-key-2": "label-value-2"},
        ),
        update_mask=field_mask.FieldMask(paths=["labels"]),
    )

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

Solução de problemas

Erro de permissões do IAM

Se as permissões não estiverem definidas corretamente, você verá o seguinte erro:

Cannot connect to the provided Kubernetes cluster "projects/projectId/locations/location/clusters/gkeCluster", make sure that "service-projectNumber@gcp-sa-gameservices.iam.gserviceaccount.com" has been granted the required permissions to access the cluster

Se isso ocorrer, conclua a etapa nesta seção para definir permissões do IAM.

Quando você cria recursos do Game Servers em um projeto do Google Cloud, esse Game Servers também cria uma conta de serviço gerenciada pelo Google do Game Servers que assume a forma serviceAccount:service-projectNumber@gcp-sa-gameservices.iam.gserviceaccount.com. Essa conta de serviço recebe automaticamente o papel predefinido roles/gameservices.serviceAgentdos servidores de jogos. Esse papel fornece à conta de serviço gerenciada pelo Google as permissões necessárias para gerenciar o cluster do GKE que você está registrando. Se você revogar a mensagem, verá a mensagem de erro acima.

O comando a seguir mostra a sintaxe para conceder à conta de serviço o papel roles/gameservices.serviceAgent dos servidores de jogos:

gcloud projects add-iam-policy-binding projectId --role roles/gameservices.serviceAgent --member serviceAccount:service-projectNumber@gcp-sa-gameservices.iam.gserviceaccount.com

onde:

  • projectId é o código do projeto. Para receber projectId, execute gcloud config get-value project.
  • projectNumber pode ser recuperado executando gcloud projects describe projectId.

A seguir

Saiba como excluir um cluster.