Creating a config

This page explains how to register, edit, list, and view details of a Game Servers config in a deployment. This config defines the Agones fleet specification, which includes information on game server count, buffer, and game server version. This config also defines the scaling configuration, which specifies how the fleet is automatically scaled up and down to meet demand.

Before you begin

Before you start, we recommend you familiarize yourself with key concepts in the Game Servers Overview. Make sure you have also performed the following tasks:

  • Ensure that you have enabled the Game Services API.
    • Enable Game Services API
  • Either choose a shell with gcloud CLI installed, or use an API client:

    • Cloud Shell

    To launch Cloud Shell, perform the following steps:

    1. Go to Google Cloud console.

      Google Cloud console

    2. From the upper-right corner of the console, click the Activate Cloud Shell button:

    A Cloud Shell session opens inside a frame lower on the console. You use this shell to run gcloud commands.

    Local shell

    Install the gcloud CLI.

    Verify that you have set desired default project for Google Cloud CLI (otherwise you need to specify flag --project explicitly for each command later):

    gcloud config list project

    If not you can run the following command to set a default project, replacing PROJECT_ID with your desired project ID :

    gcloud config set project PROJECT_ID

    Run the following command to verify your version of the Google Cloud CLI. Game Servers requires version 306.0.0 or higher of the gcloud CLI. 

    gcloud version

    To update your installation, run the following command:

    gcloud components update

    curl / PowerShell

    To use the REST API with curl or Windows PowerShell, do the following:

    1. Create a service account.
    2. Download a private key as a JSON file.

    3. Set the environment variable GOOGLE_APPLICATION_CREDENTIALS to the path of the JSON file that contains your service account key. This variable only applies to your current shell session, so if you open a new session, set the variable again.

    Client Library

    Google Cloud Game Servers can be controlled programmatically using a client library. See Client Libraries Overview for instructions on using the library and authenticating.

Creating a config

Make sure you have created a Game Servers deployment.

Console

  1. In the Cloud console, go to the Game Server Deployments page.

    Go to Game Servers

  2. Find a deployment in the table. In the last table column, click the ellipses and select List configs. You can view the active and inactive configs for the deployment from this page.

  3. To create a new config for the deployment, click Create Config.

  4. In the Config name box, enter a unique identifier for this config.

  5. (Optional) In the Description box, enter a description for this config.

  6. In the Fleet config name box, enter a unique identifier for this fleet config.

  7. In the Fleet spec box, enter the fleet specification.

  8. (Optional) Under Scaling config, you can specify one or more configs that automatically scale the fleet up or down. Click Add to add a scaling config.

    1. In the Scaling Config Name box, enter a unique identifier for this scaling config.
    2. (Optional) In the Start Time and End Time boxes, schedule the time period for when this scaling config will be active. See Creating scaling schedules for more information.
    3. In the Autoscaper spec box, enter the scaling specification.

gcloud

You can create a Game Servers config in a deployment using the Google Cloud CLI.

To create a game server config:

  1. Copy this fleet specification into a file.

    - name: fleet-spec-1
  fleetSpec:
   replicas: 10
   scheduling: Packed
   strategy:
     type: RollingUpdate
     rollingUpdate:
       maxSurge: 25%
       maxUnavailable: 25%
   template:
     metadata:
       labels:
         gameName: udp-server
     spec:
       ports:
       - name: default
         portPolicy: Dynamic
         containerPort: 7654
         protocol: UDP
       health:
         initialDelaySeconds: 30
         periodSeconds: 60
       sdkServer:
         logLevel: Info
         grpcPort: 9357
         httpPort: 9358
       template:
         spec:
           containers:
           - name: dedicated
             image: gcr.io/agones-images/udp-server:0.21
             imagePullPolicy: Always
             resources:
               requests:
                 memory: 200Mi
                 cpu: 500m
               limits:
                 memory: 200Mi
                 cpu: 500m

  2. Run the following command and replace the placeholder values, such as deploymentID and configID, with appropriate values:

    gcloud game servers configs create configID --deployment deploymentID --fleet-configs-file fleetSpecFile

    The variable placeholders correspond to the following descriptions:

  • configID is a unique identifier that you can specify for this config.
  • deploymentID is the unique identifier for the deployment.
  • fleetSpecFile is the path to the file with the Agones Fleet specification.

REST & CMD LINE

Before using any of the request data, make the following replacements:

  • PROJECT_ID: your Google Cloud project ID listed in the IAM Settings
  • DEPLOYMENT_ID: the user-defined identifier for the deployment
  • CONFIG_ID: a user-defined identifier for the config

Request JSON body: 

{
  "fleetConfigs": [
    {
      "name": "fleet-spec-1",
      "fleetSpec": "{
        \"replicas\": 10,
        \"scheduling\": \"Packed\",
        \"template\": {
          \"metadata\": {
            \"labels\": {
              \"gameName\": \"udp-server\"
            }
          },
          \"spec\": {
            \"ports\": [
              {
                \"name\": \"default\",
                \"portPolicy\": \"Dynamic\",
                \"containerPort\": 7654,
                \"protocol\": \"UDP\"
              }
            ],
            \"health\": {
              \"periodSeconds\": 60,
              \"initialDelaySeconds\": 30
            },
            \"sdkServer\": {
              \"logLevel\": \"Info\",
              \"grpcPort\": 9357,
              \"httpPort\": 9358
            },
            \"template\": {
              \"spec\": {
                \"containers\": [
                  {
                    \"name\": \"dedicated\",
                    \"image\": \"gcr.io/agones-images/udp-server:0.21\",
                    \"imagePullPolicy\": \"Always\",
                    \"resources\": {
                      \"requests\": {
                        \"memory\": \"200Mi\",
                        \"cpu\": \"500m\"
                      },
                      \"limits\": {
                        \"memory\": \"200Mi\",
                        \"cpu\": \"500m\"
                      }
                    }
                  }
                ]
              }
            }
          }
        }
      }"
    }
  ]
}

To send your request, expand one of these options:

You should receive a JSON response similar to the following:

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

C#

To learn how to install and use the client library for Game Servers, see Game Servers client libraries. 


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

public class CreateConfigSample
{
    public async Task<GameServerConfig> CreateConfigAsync(
        string projectId, string regionId, string deploymentId, string configId)
    {
        // Create the client.
        GameServerConfigsServiceClient client = await GameServerConfigsServiceClient.CreateAsync();

        GameServerConfig config = new GameServerConfig
        {
            GameServerConfigName = GameServerConfigName.FromProjectLocationDeploymentConfig(projectId, regionId, deploymentId, configId),
            Description = "My Game Server Config",
            FleetConfigs =
            {
                new FleetConfig
                {

                    Name = "fleet-spec-1",
                    FleetSpec = JsonConvert.SerializeObject(new
                    {
                        replicas = 10,
                        scheduling = "Packed",
                        strategy = new
                        {
                            type = "RollingUpdate",
                            rollingUpdate = new
                            {
                                maxSurge = "25%",
                                maxUnavailable = "25%",
                            }
                        },
                        template = new
                        {
                            metadata = new
                            {
                                labels = new
                                {
                                    gameName = "udp-server",
                                }
                            },
                            spec = new
                            {
                                ports = new [] {
                                    new {
                                        name = "default",
                                        portPolicy = "Dynamic",
                                        containerPort = 7654,
                                        protocol = "UDP",
                                    }
                                },
                                health = new
                                {
                                    initialDelaySeconds = 30,
                                    periodSeconds = 60,
                                },
                                sdkServer = new
                                {
                                    logLevel = "Info",
                                    grpcPort = 9357,
                                    httpPort = 9358,
                                },
                                template = new
                                {
                                    spec = new
                                    {
                                        containers = new [] {
                                            new {
                                                name = "dedicated",
                                                image = "gcr.io/agones-images/udp-server:0.21",
                                                imagePullPolicy = "Always",
                                                resources = new
                                                {
                                                    requests = new
                                                    {
                                                        memory = "200Mi",
                                                        cpu = "500m",
                                                    },
                                                    limits = new
                                                    {
                                                        memory = "200Mi",
                                                        cpu = "500m",
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                        }
                    })
                }
            }
        };

        CreateGameServerConfigRequest request = new CreateGameServerConfigRequest
        {
            ParentAsGameServerDeploymentName = GameServerDeploymentName.FromProjectLocationDeployment(projectId, regionId, deploymentId),
            ConfigId = configId,
            GameServerConfig = config
        };

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

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

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

Go

To learn how to install and use the client library for Game Servers, see Game Servers client libraries. 


import (
	"context"
	"fmt"
	"io"

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

// fleet is the spec portion of an agones Fleet.  It must be in JSON format.
// See https://agones.dev/site/docs/reference/fleet/ for more on fleets.
const fleet = `
{
   "replicas": 10,
   "scheduling": "Packed",
   "strategy": {
      "type": "RollingUpdate",
      "rollingUpdate": {
         "maxSurge": "25%",
         "maxUnavailable": "25%"
      }
   },
   "template": {
      "metadata": {
         "labels": {
            "gameName": "udp-server"
         }
      },
      "spec": {
         "ports": [
            {
               "name": "default",
               "portPolicy": "Dynamic",
               "containerPort": 2156,
               "protocol": "TCP"
            }
         ],
         "health": {
            "initialDelaySeconds": 30,
            "periodSeconds": 60
         },
         "sdkServer": {
            "logLevel": "Info",
            "grpcPort": 9357,
            "httpPort": 9358
         },
         "template": {
            "spec": {
               "containers": [
                  {
                     "name": "dedicated",
                     "image": "gcr.io/agones-images/udp-server:0.17",
                     "imagePullPolicy": "Always",
                     "resources": {
                        "requests": {
                           "memory": "200Mi",
                           "cpu": "500m"
                        },
                        "limits": {
                           "memory": "200Mi",
                           "cpu": "500m"
                        }
                     }
                  }
               ]
            }
         }
      }
   }
}
`

// createGameServerConfig creates a game server config.
func createGameServerConfig(w io.Writer, projectID, deploymentID, configID string) error {
	// projectID := "my-project"
	// deploymentID := "mydeployment"
	// configID := "mydeployment"
	ctx := context.Background()
	client, err := gaming.NewGameServerConfigsClient(ctx)
	if err != nil {
		return fmt.Errorf("NewGameServerConfigsClient: %v", err)
	}
	defer client.Close()

	req := &gamingpb.CreateGameServerConfigRequest{
		Parent:   fmt.Sprintf("projects/%s/locations/global/gameServerDeployments/%s", projectID, deploymentID),
		ConfigId: configID,
		GameServerConfig: &gamingpb.GameServerConfig{
			FleetConfigs: []*gamingpb.FleetConfig{
				{
					Name:      "fleet-spec-1",
					FleetSpec: fleet,
				},
			},
			Description: "My Game Server Config",
		},
	}

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

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

Node.js

To learn how to install and use the client library for Game Servers, see Game Servers client libraries. 

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

  const client = new GameServerConfigsServiceClient();

  async function createGameServerConfig() {
    /**
     * TODO(developer): Uncomment these variables before running the sample.
     */
    // const projectId = 'Your Google Cloud Project ID';
    // const deploymentId = 'A unique ID for the Game Server Deployment';
    // const configId = 'A unique ID for the Game Server Config';
    // const fleetName = 'The fleet name to be stored in Agones';
    // fleet is the spec portion of an agones Fleet.  It must be in JSON format.
    // See https://agones.dev/site/docs/reference/fleet/ for more on fleets.
    const fleet = `
{
   "replicas": 10,
   "scheduling": "Packed",
   "strategy": {
      "type": "RollingUpdate",
      "rollingUpdate": {
         "maxSurge": "25%",
         "maxUnavailable": "25%"
      }
   },
   "template": {
      "metadata": {
         "labels": {
            "gameName": "udp-server"
         }
      },
      "spec": {
         "ports": [
            {
               "name": "default",
               "portPolicy": "Dynamic",
               "containerPort": 2156,
               "protocol": "TCP"
            }
         ],
         "health": {
            "initialDelaySeconds": 30,
            "periodSeconds": 60
         },
         "sdkServer": {
            "logLevel": "Info",
            "grpcPort": 9357,
            "httpPort": 9358
         },
         "template": {
            "spec": {
               "containers": [
                  {
                     "name": "dedicated",
                     "image": "gcr.io/agones-images/udp-server:0.17",
                     "imagePullPolicy": "Always",
                     "resources": {
                        "requests": {
                           "memory": "200Mi",
                           "cpu": "500m"
                        },
                        "limits": {
                           "memory": "200Mi",
                           "cpu": "500m"
                        }
                     }
                  }
               ]
            }
         }
      }
   }
}
`;
    const request = {
      parent: client.gameServerDeploymentPath(
        projectId,
        'global',
        deploymentId
      ),
      configId: configId,
      gameServerConfig: {
        fleetConfigs: [
          {
            name: fleetName,
            fleetSpec: fleet,
          },
        ],
        description: 'nodejs test config',
      },
    };

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

    console.log('Game Server Config created:');
    console.log(`\t Config name: ${result.name}`);
    console.log(`\t Config description: ${result.description}`);
  }

  createGameServerConfig();

Python

To learn how to install and use the client library for Game Servers, see Game Servers client libraries. 


# FLEET_SPEC is the spec portion of an agones Fleet.  It must be in JSON format.
# See https://agones.dev/site/docs/reference/fleet/ for more on fleets.
FLEET_SPEC = """
{
   "replicas": 10,
   "scheduling": "Packed",
   "strategy": {
      "type": "RollingUpdate",
      "rollingUpdate": {
         "maxSurge": "25%",
         "maxUnavailable": "25%"
      }
   },
   "template": {
      "metadata": {
         "labels": {
            "gameName": "udp-server"
         }
      },
      "spec": {
         "ports": [
            {
               "name": "default",
               "portPolicy": "Dynamic",
               "containerPort": 2156,
               "protocol": "TCP"
            }
         ],
         "health": {
            "initialDelaySeconds": 30,
            "periodSeconds": 60
         },
         "sdkServer": {
            "logLevel": "Info",
            "grpcPort": 9357,
            "httpPort": 9358
         },
         "template": {
            "spec": {
               "containers": [
                  {
                     "name": "dedicated",
                     "image": "gcr.io/agones-images/udp-server:0.17",
                     "imagePullPolicy": "Always",
                     "resources": {
                        "requests": {
                           "memory": "200Mi",
                           "cpu": "500m"
                        },
                        "limits": {
                           "memory": "200Mi",
                           "cpu": "500m"
                        }
                     }
                  }
               ]
            }
         }
      }
   }
}
"""


def create_config(project_id, deployment_id, config_id):
    """Creates a game server config."""

    client = gaming.GameServerConfigsServiceClient()

    fleet_config = game_server_configs.FleetConfig(
        name="my-fleet-spec",
        fleet_spec=FLEET_SPEC,
    )

    # Location is hard coded as global, as game server configs can
    # only be created in global.  This is done for all operations on
    # game server configs.
    request = game_server_configs.CreateGameServerConfigRequest(
        parent=f"projects/{project_id}/locations/global/gameServerDeployments/{deployment_id}",
        config_id=config_id,
        game_server_config=game_server_configs.GameServerConfig(
            description="My Game Server Config",
            fleet_configs=[fleet_config],
        ),
    )

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

Editing configs

You can't edit a Game Servers config because configs are immutable. If you want to edit a config, copy the config (view config details), edit it locally, and use the updated version to create a new config.

Listing configs

Console

  1. In the Cloud console, go to the Game Server Deployments page.

    Go to Game Servers

  2. Find a deployment in the table. In the last table column, click the ellipses and select List configs. You can view the active and inactive configs for the deployment from this page.

gcloud

You can list configs using the Google Cloud CLI.

To list all configs, run the following command:

gcloud game servers configs list

To list all configs in a deployment, run the following command and replace deploymentID with the parent deployment that you want to list the configs in:

gcloud game servers configs list --deployment=deploymentID

REST & CMD LINE

Before using any of the request data, make the following replacements:

  • PROJECT_ID: your Google Cloud project ID listed in the IAM Settings
  • DEPLOYMENT_ID: the user-defined identifier for the deployment

To send your request, expand one of these options:

You should receive a JSON response similar to the following:

{
  "gameServerConfigs": [
    {
      "name": "projects/PROJECT_ID/locations/global/gameServerDeployments/DEPLOYMENT_ID/configs/MY-CONFIG-1",
      "createTime": CREATE_TIME,
      "updateTime": UPDATE_TIME,
      "fleetConfigs": [
        {
          "fleetSpec": ...
          "name": "MY-CONFIG-1"
        }
      ],
      "description": "Config 1"
    },
    {
      "name": "projects/PROJECT_ID/locations/global/gameServerDeployments/DEPLOYMENT_ID/configs/MY-CONFIG-2",
      "createTime": CREATE_TIME,
      "updateTime": UPDATE_TIME,
      "fleetConfigs": [
        {
          "fleetSpec": ...
          "name": "MY-CONFIG-2"
        }
      ],
      "description": "Config 2"
    },
  ]
}

C#

To learn how to install and use the client library for Game Servers, see Game Servers client libraries. 


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

public class ListConfigsSample
{
    public IList<GameServerConfig> ListConfigs(
        string projectId, string regionId, string deploymentId)
    {
        // Create the client.
        GameServerConfigsServiceClient client = GameServerConfigsServiceClient.Create();

        ListGameServerConfigsRequest request = new ListGameServerConfigsRequest
        {
            ParentAsGameServerDeploymentName = GameServerDeploymentName.FromProjectLocationDeployment(projectId, regionId, deploymentId)
        };

        // Make the request.
        PagedEnumerable<ListGameServerConfigsResponse, GameServerConfig> response = client.ListGameServerConfigs(request);

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

Go

To learn how to install and use the client library for Game Servers, see Game Servers client libraries. 


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

// listGameServerConfigs lists the game server configs.
func listGameServerConfigs(w io.Writer, projectID, deploymentID string) error {
	// projectID := "my-project"
	// deploymentID := "mydeployment"
	ctx := context.Background()
	client, err := gaming.NewGameServerConfigsClient(ctx)
	if err != nil {
		return fmt.Errorf("NewGameServerConfigsClient: %v", err)
	}
	defer client.Close()

	req := &gamingpb.ListGameServerConfigsRequest{
		Parent: fmt.Sprintf("projects/%s/locations/global/gameServerDeployments/%s", projectID, deploymentID),
	}

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

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

	return nil
}

Node.js

To learn how to install and use the client library for Game Servers, see Game Servers client libraries. 

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

const client = new GameServerConfigsServiceClient();

async function listGameServerConfigs() {
  /**
   * TODO(developer): Uncomment these variables before running the sample.
   */
  // const projectId = 'Your Google Cloud Project ID';
  // const deploymentId = 'A unique ID for the Game Server Deployment';
  const request = {
    parent: client.gameServerDeploymentPath(
      projectId,
      'global',
      deploymentId
    ),
  };

  const [results] = await client.listGameServerConfigs(request);
  for (const config of results) {
    console.log(`Config name: ${config.name}`);
    console.log(`Config description: ${config.description}`);

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

listGameServerConfigs();

Python

To learn how to install and use the client library for Game Servers, see Game Servers client libraries. 

def list_configs(project_id, deployment_id):
    """Lists the existing game server deployments."""

    client = gaming.GameServerConfigsServiceClient()

    # Location is hard coded as global, as game server configs can
    # only be created in global.  This is done for all operations on
    # game server configs.
    response = client.list_game_server_configs(
        parent=f"projects/{project_id}/locations/global/gameServerDeployments/{deployment_id}"
    )

    for config in response.game_server_configs:
        print(f"Name: {config.name}")

    return response.game_server_configs

Viewing details about a config

Console

  1. In the Cloud console, go to the Game Server Deployments page.

    Go to Game Servers

  2. Find a deployment in the table. In the last table column, click the ellipses and select List configs. You can view the active and inactive configs for the deployment from this page.

  3. Find a config in the table. In the last table column, click the ellipses and select View config.

gcloud

You can find details about a config, such as the creation time, using the Google Cloud CLI:

To view the details of a config, run the following command and replace the placeholder values, such as deploymentID and configID, with appropriate values:

gcloud game servers configs describe configID --deployment deploymentID

The output gives you the details of the config.

The variable placeholders correspond to the following descriptions:

  • configID is the unique identifier that you specified for this game server config.
  • deploymentID is a unique identifier for the parent deployment.

REST & CMD LINE

Before using any of the request data, make the following replacements:

  • PROJECT_ID: your Google Cloud project ID listed in the IAM Settings
  • DEPLOYMENT_ID: the user-defined identifier for the deployment
  • CONFIG_ID: the user-defined identifier for the config

To send your request, expand one of these options:

You should receive a JSON response similar to the following:

{
  "name": "projects/PROJECT_ID/locations/global/gameServerDeployments/DEPLOYMENT_ID/configs/CONFIG_ID",
  "createTime": CREATE_TIME,
  "updateTime": UPDATE_TIME,
  "fleetConfigs": [
    {
      "fleetSpec": ...
      "name": "CONFIG_ID"
    }
  ],
  "description": "My config"
}

C#

To learn how to install and use the client library for Game Servers, see Game Servers client libraries. 


using Google.Cloud.Gaming.V1;

public class GetConfigSample
{
    public GameServerConfig GetConfig(
        string projectId, string regionId, string deploymentId, string configId)
    {
        // Create the client.
        GameServerConfigsServiceClient client = GameServerConfigsServiceClient.Create();

        GetGameServerConfigRequest request = new GetGameServerConfigRequest
        {
            GameServerConfigName = GameServerConfigName.FromProjectLocationDeploymentConfig(projectId, regionId, deploymentId, configId)
        };

        // Make the request.
        GameServerConfig response = client.GetGameServerConfig(request);
        return response;
    }
}

Go

To learn how to install and use the client library for Game Servers, see Game Servers client libraries. 


import (
	"context"
	"fmt"
	"io"

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

// getGameServerConfig retrieves info on a game server config.
func getGameServerConfig(w io.Writer, projectID, deploymentID, configID string) error {
	// projectID := "my-project"
	// deploymentID := "mydeployment"
	// configID := "myconfig"
	ctx := context.Background()
	client, err := gaming.NewGameServerConfigsClient(ctx)
	if err != nil {
		return fmt.Errorf("NewGameServerConfigsClient: %v", err)
	}
	defer client.Close()

	req := &gamingpb.GetGameServerConfigRequest{
		Name: fmt.Sprintf("projects/%s/locations/global/gameServerDeployments/%s/configs/%s", projectID, deploymentID, configID),
	}

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

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

Node.js

To learn how to install and use the client library for Game Servers, see Game Servers client libraries. 

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

const client = new GameServerConfigsServiceClient();

async function getGameServerConfig() {
  /**
   * TODO(developer): Uncomment these variables before running the sample.
   */
  // const projectId = 'Your Google Cloud Project ID';
  // const deploymentId = 'A unique ID for the Game Server Deployment';
  // const configId = 'A unique ID for the Game Server Config';
  const request = {
    // The full resource name
    name: client.gameServerConfigPath(
      projectId,
      'global',
      deploymentId,
      configId
    ),
  };

  const [config] = await client.getGameServerConfig(request);
  console.log(`Config name: ${config.name}`);
  console.log(`Config description: ${config.description}`);

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

getGameServerConfig();

Python

To learn how to install and use the client library for Game Servers, see Game Servers client libraries. 

def get_config(project_id, deployment_id, config_id):
    """Gets a game server config."""

    client = gaming.GameServerConfigsServiceClient()

    # Location is hard coded as global, as game server configs can
    # only be created in global.  This is done for all operations on
    # game server configs.
    request = game_server_configs.GetGameServerConfigRequest(
        name=f"projects/{project_id}/locations/global/gameServerDeployments/{deployment_id}/configs/{config_id}",
    )

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

What's next