Registrar un clúster

En esta página, se explica cómo registrar, enumerar y ver detalles de un clúster de Game Servers en un dominio.

Antes de comenzar

Antes de comenzar, te recomendamos que te familiarices con los conceptos clave en la Descripción general de servidores para juegos. Asegúrate de haber realizado las siguientes tareas:

  • Asegúrate de haber habilitado la API de los servicios de juego.
  • Habilitar la API de Game Services
  • Elige una shell con la CLI de gcloud instalada o usa un cliente de API:
  • Cloud Shell

    Para iniciar Cloud Shell, sigue estos pasos:

    1. Ve a la consola de Google Cloud.

      Google Cloud Console

    2. Desde la esquina superior derecha de la consola, haz clic en el botón Activar Cloud Shell: .

    Se abrirá una sesión de Cloud Shell dentro de un marco en la parte inferior en la consola. Usa esta shell para ejecutar los comandos de gcloud.

    Shell local

    Instala la CLI de gcloud

    Verifica si configuraste el proyecto predeterminado deseado para la CLI de Google Cloud (de lo contrario, deberás especificar la marca --project de forma explícita para cada comando más adelante):

    gcloud config list project
    

    Si no puedes ejecutar el siguiente comando para configurar un proyecto predeterminado, reemplaza PROJECT_ID por el ID del proyecto deseado:

    gcloud config set project PROJECT_ID
    

    Ejecute el siguiente comando para verificar su versión de la CLI de Google Cloud. Game Servers requiere la versión 306.0.0 o una posterior de la CLI de gcloud.

    gcloud version
    

    Para actualizar la instalación, ejecuta el siguiente comando:

    gcloud components update
    

    curl / PowerShell

    Para usar la API de REST con curl o Windows PowerShell, haz lo siguiente:

    1. Crea una cuenta de servicio.
    2. Descarga una clave privada como un archivo JSON.
    3. Configura la variable de entorno GOOGLE_APPLICATION_CREDENTIALS en la ruta del archivo JSON que contiene la clave de tu cuenta de servicio. Esta variable solo se aplica a la sesión actual de shell. Por lo tanto, si abres una sesión nueva, deberás volver a configurar la variable.

    Biblioteca cliente

    Google Cloud Game Servers se puede controlar de manera programática mediante una biblioteca cliente. Consulta Descripción general de bibliotecas cliente a fin de obtener instrucciones para usar la biblioteca y la autenticación.

Registrar un clúster

Asegúrate de haber creado un dominio de Game Servers.

Si no tienes un clúster de Google Kubernetes Engine (GKE) con Agones instalado, haz lo siguiente:

  1. Crea un clúster público de Google Kubernetes Engine y una regla de firewall para Agones. Asegúrate de habilitar la API de Kubernetes Engine.

    Ten en cuenta que Game Servers no admite clústeres privados.

  2. Verifica que la regla de firewall para Agones esté habilitada:

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

    Debería ver el siguiente resultado:

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

  4. Asegúrate de que tus versiones de clúster de Agones y Kubernetes cumplan con los requisitos y que hayas instalado Agones en el espacio de nombres agones-system (consulta Confirma la instalación de Agones para obtener más información).

Registra un clúster de servidor para videojuegos

Console

  1. En Cloud Console, ve a la página Clústeres y dominios.

    Ir a Game Servers

  2. Haz clic en Add Game Server Cluster.

  3. Selecciona el dominio al que pertenecerá el clúster del servidor de juegos de la lista Realms to choose from. Puedes hacer clic en el botón Create a realm para crear un dominio si es necesario.

  4. Haga clic en Continuar.

  5. En el cuadro Game server cluster ID, ingresa un identificador único para este clúster de servidor para videojuegos.

  6. En la lista Kubernetes cluster, selecciona un clúster de Kubernetes con Agones instalado.

  7. Haga clic en Crear.

gcloud

Puedes registrar un clúster de Game Servers en un dominio con la CLI de Google Cloud.

Registra un clúster de servidor para videojuegos global

Si deseas registrar un clúster de servidor para videojuegos global, haz lo siguiente:

  1. Ejecuta el siguiente comando y reemplaza los valores del marcador de posición, como realmID, con los valores apropiados:

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

    El resultado muestra el targetState para que puedas obtener una vista previa del clúster nuevo antes de registrarlo.

  2. Para registrar y crear el clúster global, ejecuta el siguiente comando:

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

Registra un clúster de servidor de videojuegos regional

Si deseas registrar un clúster de servidor para videojuegos regional, haz lo siguiente:

  1. Ejecuta el siguiente comando y reemplaza los valores del marcador de posición, como realmID, con los valores apropiados:

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

    En el resultado, se muestra el targetState para que puedas obtener una vista previa del clúster nuevo antes de su creación.

  2. Para registrar y crear el clúster regional, ejecuta el siguiente comando:

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

Si Game Servers no puede validar el clúster que intentas conectar, es posible que veas el siguiente error:

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

Si es así, asegúrate de que gkeCluster tenga el formato correcto y de que el clúster exista en project y en location.

Los marcadores de posición de variables corresponden a las siguientes descripciones:

  • gscID es un identificador único que puedes especificar para este clúster.
  • realmID es el identificador único del dominio en el que deseas almacenar el clúster.
  • gkeCluster es la ruta de acceso a recursos completamente calificados de un clúster de GKE, como projects/<projectId>/locations/<location>/clusters/<clusterId>.
  • region es la región del clúster. Elige la misma región que el dominio superior.

LÍNEA DE CMD Y REST

Antes de usar cualquiera de los datos de solicitud a continuación, realiza los siguientes reemplazos:

  • PROJECT_ID: Es el ID de tu proyecto de Google Cloud que aparece en Configuración de IAM.
  • REALM_LOCATION: Es la región para el dominio, o global, en la que se almacena este clúster.
  • REALM_ID: Es el identificador del dominio en el que se almacena este clúster.
  • GS_CLUSTER_ID: Es un identificador definido por el usuario para el clúster.
  • GKE_CLUSTER_LOCATION: Es la región del clúster de GKE.
  • GKE_CLUSTER_ID: Es el identificador de un clúster de GKE.

Cuerpo JSON de la solicitud:

{
  "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 tu solicitud, expande una de estas opciones:

Deberías recibir una respuesta JSON similar a la que se muestra a continuación:

{
  "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#

Si deseas obtener información para instalar y usar la biblioteca cliente de Game Servers, consulta las bibliotecas cliente de 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

Si deseas obtener información para instalar y usar la biblioteca cliente de Game Servers, consulta las bibliotecas cliente de 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

Si deseas obtener información para instalar y usar la biblioteca cliente de Game Servers, consulta las bibliotecas cliente de 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

Si deseas obtener información para instalar y usar la biblioteca cliente de Game Servers, consulta las bibliotecas cliente de 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

Si deseas obtener información para instalar y usar la biblioteca cliente de Game Servers, consulta las bibliotecas cliente de 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)

Después de crear un clúster de servidor para videojuegos, Game Servers crea flotas de Agones y escaladores automáticos según sea necesario. Game Servers no altera las flotas de Agones creadas manualmente.

Enumera clústeres

Console

  1. En Cloud Console, ve a la página Clústeres y dominios.

    Ir a Game Servers

  2. Expande un dominio para ver los clústeres del servidor para videojuegos que le pertenecen.

  3. Puedes usar el cuadro de filtro para filtrar los dominios y la lista de clústeres según las diferentes propiedades.

gcloud

Puedes enumerar los clústeres globales o regionales con la CLI de Google Cloud.

Para enumerar los clústeres globales y regionales, ejecuta el siguiente comando. Agrega la marca --view=FULL opcional para mostrar las versiones de Agones y Kubernetes instaladas en los clústeres.

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

Para enumerar solo los clústeres en una región, ejecuta el siguiente comando y reemplaza region por la región en la que deseas enumerar los clústeres:

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

Para enumerar todos los clústeres en un dominio, ejecuta el siguiente comando y reemplaza realmID por el dominio superior y region por la región en la que deseas enumerar los clústeres:

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

LÍNEA DE REST Y CMD

Antes de usar cualquiera de los datos de solicitud a continuación, realiza los siguientes reemplazos:

  • PROJECT_ID: Es el ID de tu proyecto de Google Cloud que aparece en Configuración de IAM.
  • REALM_LOCATION: Es la región para el dominio o global.
  • REALM_ID: Es el identificador definido por el usuario para el dominio.

Para enviar tu solicitud, expande una de estas opciones:

Deberías recibir una respuesta JSON similar a la que se muestra a continuación:

{
  "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#

Si deseas obtener información para instalar y usar la biblioteca cliente de Game Servers, consulta las bibliotecas cliente de 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

Si deseas obtener información para instalar y usar la biblioteca cliente de Game Servers, consulta las bibliotecas cliente de 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

Si deseas obtener información para instalar y usar la biblioteca cliente de Game Servers, consulta las bibliotecas cliente de 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

Si deseas obtener información para instalar y usar la biblioteca cliente de Game Servers, consulta las bibliotecas cliente de 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

Si deseas obtener información para instalar y usar la biblioteca cliente de Game Servers, consulta las bibliotecas cliente de 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

Visualiza detalles sobre un clúster

Console

  1. En Cloud Console, ve a la página Clústeres y dominios.

    Ir a Game Servers

  2. Expande un dominio para ver los clústeres del servidor para videojuegos que le pertenecen.

  3. En la última columna de la tabla para el dominio, haz clic en la elipsis y selecciona View details.

gcloud

Encuentra detalles sobre un clúster, como la hora de creación o los detalles del clúster de GKE, con la CLI de Google Cloud.

Para ver los detalles de un clúster, ejecuta el siguiente comando y reemplaza los valores del marcador de posición, como realmID, por los valores apropiados:

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

El resultado te brinda los detalles del clúster. Agrega la marca --view=FULL opcional para mostrar las versiones de Agones y Kubernetes instalados en el clúster.

Los marcadores de posición de variables corresponden a las siguientes descripciones:

  • gscID es el identificador único que especificaste para este clúster de servidor de videojuegos.
  • realmID es un identificador único para el dominio en el que se almacena tu clúster.
  • region es la región del clúster. Elige la misma región que el dominio superior.

LÍNEA DE CMD Y REST

Antes de usar cualquiera de los datos de solicitud a continuación, realiza los siguientes reemplazos:

  • PROJECT_ID: Es el ID de tu proyecto de Google Cloud que aparece en Configuración de IAM.
  • REALM_LOCATION: Es la región para el dominio o global.
  • REALM_ID: Es el identificador definido por el usuario para el dominio.
  • GS_CLUSTER_ID: Es el identificador definido por el usuario para el clúster.

Para enviar tu solicitud, expande una de estas opciones:

Deberías recibir una respuesta JSON similar a la que se muestra a continuación:

{
  "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#

Si deseas obtener información para instalar y usar la biblioteca cliente de Game Servers, consulta las bibliotecas cliente de 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

Si deseas obtener información para instalar y usar la biblioteca cliente de Game Servers, consulta las bibliotecas cliente de 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

Si deseas obtener información para instalar y usar la biblioteca cliente de Game Servers, consulta las bibliotecas cliente de 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

Si deseas obtener información para instalar y usar la biblioteca cliente de Game Servers, consulta las bibliotecas cliente de 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

Si deseas obtener información para instalar y usar la biblioteca cliente de Game Servers, consulta las bibliotecas cliente de 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

Actualiza un clúster

gcloud

Para actualizar un campo de un clúster, ejecuta el comando de gcloud game servers clusters update después de reemplazar los identificadores de un clúster existente. El siguiente comando actualiza el campo de descripción de un clúster.

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

Para encontrar las marcas de otros campos del clúster, consulta la referencia de gcloud.

LÍNEA DE CMD Y REST

En el siguiente ejemplo, se actualiza el campo description. Para actualizar otros campos, agrega los nombres de campo al parámetro de búsqueda ?updateMask= y solicita el cuerpo JSON.

Antes de usar cualquiera de los datos de solicitud a continuación, realiza los siguientes reemplazos:

  • PROJECT_ID: Es el ID de tu proyecto de Google Cloud que aparece en Configuración de IAM.
  • REALM_LOCATION: Es la región para el dominio o global.
  • REALM_ID: Es el identificador del dominio.
  • GS_CLUSTER_ID: Es el identificador definido por el usuario para el clúster.

Cuerpo JSON de la solicitud:

{
  "description": "My updated description"
}

Para enviar tu solicitud, expande una de estas opciones:

Deberías recibir una respuesta JSON similar a la que se muestra a continuación:

{
  "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#

Si deseas obtener información para instalar y usar la biblioteca cliente de Game Servers, consulta las bibliotecas cliente de 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

Si deseas obtener información para instalar y usar la biblioteca cliente de Game Servers, consulta las bibliotecas cliente de 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

Si deseas obtener información para instalar y usar la biblioteca cliente de Game Servers, consulta las bibliotecas cliente de 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

Si deseas obtener información para instalar y usar la biblioteca cliente de Game Servers, consulta las bibliotecas cliente de 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

Si deseas obtener información para instalar y usar la biblioteca cliente de Game Servers, consulta las bibliotecas cliente de 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)

Solución de problemas

Error de permisos de IAM

Si los permisos no se configuraron de forma correcta, verás el siguiente error:

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

Si esto ocurre, completa el paso en esta sección para configurar los permisos de IAM.

Cuando creas recursos de Game Servers en un proyecto de Google Cloud, Game Servers también crea un servidor para videojuegos. Cuenta de servicio administrada por Google que toma el formato serviceAccount:service-projectNumber@gcp-sa-gameservices.iam.gserviceaccount.com. A esta cuenta de servicio se le otorga la función predefinida roles/gameservices.serviceAgent de Game Servers de forma automática. Esta función le otorga a la cuenta de servicio administrada por Google los permisos necesarios para administrar el clúster de GKE que registras. Si lo revocas, verás el mensaje de error anterior.

En el siguiente comando, se muestra la sintaxis para otorgar a la cuenta de servicio la función roles/gameservices.serviceAgent de Game Servers:

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

En el ejemplo anterior, se ilustra lo siguiente:

  • projectId es el ID del proyecto. Puedes obtener projectId si ejecutas gcloud config get-value project.
  • Puedes recuperar projectNumber si ejecutas gcloud projects describe projectId.

¿Qué sigue?

Obtén más información para borrar un clúster.