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 de juegos. Asegúrate de haber realizado las siguientes tareas:

  • Asegúrate de haber habilitado la API de servicios de juego.
  • Habilita la API de servicios de juego
  • Elige una shell con el SDK de Cloud instalado o usa un cliente de API:
  • Cloud Shell

    Para iniciar Cloud Shell, sigue estos pasos:

    1. Ve a Google Cloud Console

      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 este shell para ejecutar los comandos de gcloud.

    Shell local

    Para instalar gcloud, instala el SDK de Cloud, que incluye la herramienta de línea de comandos de gcloud.

    Verifica que hayas configurado el proyecto predeterminado deseado para la herramienta de línea de comandos de gcloud (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
    

    Ejecuta el siguiente comando para verificar tu versión del SDK de Google Cloud. Game Servers requiere la versión 306.0.0 o posterior del SDK.

    gcloud version
    

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

    gcloud components update
    

    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, sigue las guías para crear un clúster de Google Kubernetes Engine y Instalación de Agones. Asegúrate de que tus versiones de Agones y Kubernetes cumplan con y que hayas instalado Agones en el espacio de nombres agones-system.

Registra un clúster de servidor de videojuegos

Comando de gcloud

Puedes registrar un clúster de Game Servers en un dominio con la herramienta de línea de comandos de gcloud.

Registra un clúster de servidor de videojuegos global

Si deseas registrar un clúster de servidor de 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 juegos regional

Si deseas registrar un clúster de servidor de 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
    

    El resultado 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 ti.

Go


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
}

Node.js

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

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 de videojuegos, Game Servers crea flotas de Agones y escaladores automáticos según sea necesario. Game Servers no altera los bloques de Agones creados manualmente.

Enumera clústeres

Comando de gcloud

Puedes enumerar clústeres globales o regionales con la herramienta de línea de comandos de gcloud.

Para enumerar los clústeres globales y regionales, ejecuta el siguiente comando:

gcloud game servers clusters list

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

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

gcloud game servers clusters list --realm=realmID --location=region

Go


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),
	}

	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)
	}

	return nil
}

Node.js

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),
  };

  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(
      `\tGKE cluster: ${cluster.connectionInfo.gkeClusterReference.cluster}`
    );
  }
}

listGameServerClusters();

Python

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

    client = gaming.GameServerClustersServiceClient()

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

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

    return response.game_server_clusters

Visualiza detalles sobre un clúster

Comando de gcloud

Puedes encontrar detalles sobre un clúster, como la hora de creación o los detalles del clúster de GKE, con la herramienta de línea de comandos de gcloud:

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

gcloud game servers clusters describe gscID --realm realmID --location=region

El resultado te brinda los detalles del 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 juegos.
  • 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 ti.

Go


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),
	}

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

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

Node.js

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
    ),
  };

  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(
    `\tGKE cluster: ${cluster.connectionInfo.gkeClusterReference.cluster}`
  );
}

getGameServerCluster();

Python

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}",
    )

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

Soluciona problemas

Error de permisos de IAM

Si los permisos no se configuraron correctamente, 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 de Game Servers. Cuenta de servicio administrada por Google que toma la forma serviceAccount:service-projectNumber@gcp-sa-gameservices.iam.gserviceaccount.com para crear el adjunto de VLAN de supervisión. 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 estás registrando. 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

Donde:

  • 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 sobre cómo borrar un clúster.