gameservices

package
v2.13.0 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Apr 13, 2020 License: Apache-2.0 Imports: 4 Imported by: 0

Documentation

Overview

nolint: lll

nolint: lll

nolint: lll

nolint: lll

nolint: lll

nolint: lll

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

This section is empty.

Types

type GameServerCluster 

type GameServerCluster struct {
	pulumi.CustomResourceState

	// Required. The resource name of the game server cluster
	ClusterId pulumi.StringOutput `pulumi:"clusterId"`
	// Game server cluster connection information. This information is used to manage game server clusters.
	ConnectionInfo GameServerClusterConnectionInfoOutput `pulumi:"connectionInfo"`
	// Human readable description of the cluster.
	Description pulumi.StringPtrOutput `pulumi:"description"`
	// The labels associated with this game server cluster. Each label is a key-value pair.
	Labels pulumi.StringMapOutput `pulumi:"labels"`
	// Location of the Cluster.
	Location pulumi.StringPtrOutput `pulumi:"location"`
	// The resource id of the game server cluster, eg:
	// 'projects/{project_id}/locations/{location}/realms/{realm_id}/gameServerClusters/{cluster_id}'. For example,
	// 'projects/my-project/locations/{location}/realms/zanzibar/gameServerClusters/my-onprem-cluster'.
	Name pulumi.StringOutput `pulumi:"name"`
	// The ID of the project in which the resource belongs.
	// If it is not provided, the provider project is used.
	Project pulumi.StringOutput `pulumi:"project"`
	// The realm id of the game server realm.
	RealmId pulumi.StringOutput `pulumi:"realmId"`
}

A game server cluster resource.

To get more information about GameServerCluster, see:

* [API documentation](https://cloud.google.com/game-servers/docs/reference/rest/v1beta/projects.locations.realms.gameServerClusters) * How-to Guides

> This content is derived from https://github.com/terraform-providers/terraform-provider-google/blob/master/website/docs/r/game_services_game_server_cluster.html.markdown.

func GetGameServerCluster 

func GetGameServerCluster(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *GameServerClusterState, opts ...pulumi.ResourceOption) (*GameServerCluster, error)

GetGameServerCluster gets an existing GameServerCluster resource's state with the given name, ID, and optional state properties that are used to uniquely qualify the lookup (nil if not required).

func NewGameServerCluster 

func NewGameServerCluster(ctx *pulumi.Context,
	name string, args *GameServerClusterArgs, opts ...pulumi.ResourceOption) (*GameServerCluster, error)

NewGameServerCluster registers a new resource with the given unique name, arguments, and options.

type GameServerClusterArgs 

type GameServerClusterArgs struct {
	// Required. The resource name of the game server cluster
	ClusterId pulumi.StringInput
	// Game server cluster connection information. This information is used to manage game server clusters.
	ConnectionInfo GameServerClusterConnectionInfoInput
	// Human readable description of the cluster.
	Description pulumi.StringPtrInput
	// The labels associated with this game server cluster. Each label is a key-value pair.
	Labels pulumi.StringMapInput
	// Location of the Cluster.
	Location pulumi.StringPtrInput
	// The ID of the project in which the resource belongs.
	// If it is not provided, the provider project is used.
	Project pulumi.StringPtrInput
	// The realm id of the game server realm.
	RealmId pulumi.StringInput
}

The set of arguments for constructing a GameServerCluster resource.

func (GameServerClusterArgs) ElementType 

func (GameServerClusterArgs) ElementType() reflect.Type

type GameServerClusterConnectionInfo 

type GameServerClusterConnectionInfo struct {
	GkeClusterReference GameServerClusterConnectionInfoGkeClusterReference `pulumi:"gkeClusterReference"`
	Namespace           string                                             `pulumi:"namespace"`
}

type GameServerClusterConnectionInfoArgs 

type GameServerClusterConnectionInfoArgs struct {
	GkeClusterReference GameServerClusterConnectionInfoGkeClusterReferenceInput `pulumi:"gkeClusterReference"`
	Namespace           pulumi.StringInput                                      `pulumi:"namespace"`
}

func (GameServerClusterConnectionInfoArgs) ElementType 

func (GameServerClusterConnectionInfoArgs) ElementType() reflect.Type

func (GameServerClusterConnectionInfoArgs) ToGameServerClusterConnectionInfoOutput 

func (i GameServerClusterConnectionInfoArgs) ToGameServerClusterConnectionInfoOutput() GameServerClusterConnectionInfoOutput

func (GameServerClusterConnectionInfoArgs) ToGameServerClusterConnectionInfoOutputWithContext 

func (i GameServerClusterConnectionInfoArgs) ToGameServerClusterConnectionInfoOutputWithContext(ctx context.Context) GameServerClusterConnectionInfoOutput

func (GameServerClusterConnectionInfoArgs) ToGameServerClusterConnectionInfoPtrOutput 

func (i GameServerClusterConnectionInfoArgs) ToGameServerClusterConnectionInfoPtrOutput() GameServerClusterConnectionInfoPtrOutput

func (GameServerClusterConnectionInfoArgs) ToGameServerClusterConnectionInfoPtrOutputWithContext 

func (i GameServerClusterConnectionInfoArgs) ToGameServerClusterConnectionInfoPtrOutputWithContext(ctx context.Context) GameServerClusterConnectionInfoPtrOutput

type GameServerClusterConnectionInfoGkeClusterReference 

type GameServerClusterConnectionInfoGkeClusterReference struct {
	Cluster string `pulumi:"cluster"`
}

type GameServerClusterConnectionInfoGkeClusterReferenceArgs 

type GameServerClusterConnectionInfoGkeClusterReferenceArgs struct {
	Cluster pulumi.StringInput `pulumi:"cluster"`
}

func (GameServerClusterConnectionInfoGkeClusterReferenceArgs) ElementType 

func (GameServerClusterConnectionInfoGkeClusterReferenceArgs) ElementType() reflect.Type

func (GameServerClusterConnectionInfoGkeClusterReferenceArgs) ToGameServerClusterConnectionInfoGkeClusterReferenceOutput 

func (i GameServerClusterConnectionInfoGkeClusterReferenceArgs) ToGameServerClusterConnectionInfoGkeClusterReferenceOutput() GameServerClusterConnectionInfoGkeClusterReferenceOutput

func (GameServerClusterConnectionInfoGkeClusterReferenceArgs) ToGameServerClusterConnectionInfoGkeClusterReferenceOutputWithContext 

func (i GameServerClusterConnectionInfoGkeClusterReferenceArgs) ToGameServerClusterConnectionInfoGkeClusterReferenceOutputWithContext(ctx context.Context) GameServerClusterConnectionInfoGkeClusterReferenceOutput

type GameServerClusterConnectionInfoGkeClusterReferenceInput 

type GameServerClusterConnectionInfoGkeClusterReferenceInput interface {
	pulumi.Input

	ToGameServerClusterConnectionInfoGkeClusterReferenceOutput() GameServerClusterConnectionInfoGkeClusterReferenceOutput
	ToGameServerClusterConnectionInfoGkeClusterReferenceOutputWithContext(context.Context) GameServerClusterConnectionInfoGkeClusterReferenceOutput
}

type GameServerClusterConnectionInfoGkeClusterReferenceOutput 

type GameServerClusterConnectionInfoGkeClusterReferenceOutput struct{ *pulumi.OutputState }

func (GameServerClusterConnectionInfoGkeClusterReferenceOutput) Cluster 

func (o GameServerClusterConnectionInfoGkeClusterReferenceOutput) Cluster() pulumi.StringOutput

func (GameServerClusterConnectionInfoGkeClusterReferenceOutput) ElementType 

func (GameServerClusterConnectionInfoGkeClusterReferenceOutput) ElementType() reflect.Type

func (GameServerClusterConnectionInfoGkeClusterReferenceOutput) ToGameServerClusterConnectionInfoGkeClusterReferenceOutput 

func (o GameServerClusterConnectionInfoGkeClusterReferenceOutput) ToGameServerClusterConnectionInfoGkeClusterReferenceOutput() GameServerClusterConnectionInfoGkeClusterReferenceOutput

func (GameServerClusterConnectionInfoGkeClusterReferenceOutput) ToGameServerClusterConnectionInfoGkeClusterReferenceOutputWithContext 

func (o GameServerClusterConnectionInfoGkeClusterReferenceOutput) ToGameServerClusterConnectionInfoGkeClusterReferenceOutputWithContext(ctx context.Context) GameServerClusterConnectionInfoGkeClusterReferenceOutput

type GameServerClusterConnectionInfoInput 

type GameServerClusterConnectionInfoInput interface {
	pulumi.Input

	ToGameServerClusterConnectionInfoOutput() GameServerClusterConnectionInfoOutput
	ToGameServerClusterConnectionInfoOutputWithContext(context.Context) GameServerClusterConnectionInfoOutput
}

type GameServerClusterConnectionInfoOutput 

type GameServerClusterConnectionInfoOutput struct{ *pulumi.OutputState }

func (GameServerClusterConnectionInfoOutput) ElementType 

func (GameServerClusterConnectionInfoOutput) ElementType() reflect.Type

func (GameServerClusterConnectionInfoOutput) GkeClusterReference 

func (o GameServerClusterConnectionInfoOutput) GkeClusterReference() GameServerClusterConnectionInfoGkeClusterReferenceOutput

func (GameServerClusterConnectionInfoOutput) Namespace 

func (o GameServerClusterConnectionInfoOutput) Namespace() pulumi.StringOutput

func (GameServerClusterConnectionInfoOutput) ToGameServerClusterConnectionInfoOutput 

func (o GameServerClusterConnectionInfoOutput) ToGameServerClusterConnectionInfoOutput() GameServerClusterConnectionInfoOutput

func (GameServerClusterConnectionInfoOutput) ToGameServerClusterConnectionInfoOutputWithContext 

func (o GameServerClusterConnectionInfoOutput) ToGameServerClusterConnectionInfoOutputWithContext(ctx context.Context) GameServerClusterConnectionInfoOutput

func (GameServerClusterConnectionInfoOutput) ToGameServerClusterConnectionInfoPtrOutput 

func (o GameServerClusterConnectionInfoOutput) ToGameServerClusterConnectionInfoPtrOutput() GameServerClusterConnectionInfoPtrOutput

func (GameServerClusterConnectionInfoOutput) ToGameServerClusterConnectionInfoPtrOutputWithContext 

func (o GameServerClusterConnectionInfoOutput) ToGameServerClusterConnectionInfoPtrOutputWithContext(ctx context.Context) GameServerClusterConnectionInfoPtrOutput

type GameServerClusterConnectionInfoPtrInput 

type GameServerClusterConnectionInfoPtrInput interface {
	pulumi.Input

	ToGameServerClusterConnectionInfoPtrOutput() GameServerClusterConnectionInfoPtrOutput
	ToGameServerClusterConnectionInfoPtrOutputWithContext(context.Context) GameServerClusterConnectionInfoPtrOutput
}

func GameServerClusterConnectionInfoPtr 

func GameServerClusterConnectionInfoPtr(v *GameServerClusterConnectionInfoArgs) GameServerClusterConnectionInfoPtrInput

type GameServerClusterConnectionInfoPtrOutput 

type GameServerClusterConnectionInfoPtrOutput struct{ *pulumi.OutputState }

func (GameServerClusterConnectionInfoPtrOutput) Elem 

func (o GameServerClusterConnectionInfoPtrOutput) Elem() GameServerClusterConnectionInfoOutput

func (GameServerClusterConnectionInfoPtrOutput) ElementType 

func (GameServerClusterConnectionInfoPtrOutput) ElementType() reflect.Type

func (GameServerClusterConnectionInfoPtrOutput) GkeClusterReference 

func (o GameServerClusterConnectionInfoPtrOutput) GkeClusterReference() GameServerClusterConnectionInfoGkeClusterReferenceOutput

func (GameServerClusterConnectionInfoPtrOutput) Namespace 

func (o GameServerClusterConnectionInfoPtrOutput) Namespace() pulumi.StringOutput

func (GameServerClusterConnectionInfoPtrOutput) ToGameServerClusterConnectionInfoPtrOutput 

func (o GameServerClusterConnectionInfoPtrOutput) ToGameServerClusterConnectionInfoPtrOutput() GameServerClusterConnectionInfoPtrOutput

func (GameServerClusterConnectionInfoPtrOutput) ToGameServerClusterConnectionInfoPtrOutputWithContext 

func (o GameServerClusterConnectionInfoPtrOutput) ToGameServerClusterConnectionInfoPtrOutputWithContext(ctx context.Context) GameServerClusterConnectionInfoPtrOutput

type GameServerClusterState 

type GameServerClusterState struct {
	// Required. The resource name of the game server cluster
	ClusterId pulumi.StringPtrInput
	// Game server cluster connection information. This information is used to manage game server clusters.
	ConnectionInfo GameServerClusterConnectionInfoPtrInput
	// Human readable description of the cluster.
	Description pulumi.StringPtrInput
	// The labels associated with this game server cluster. Each label is a key-value pair.
	Labels pulumi.StringMapInput
	// Location of the Cluster.
	Location pulumi.StringPtrInput
	// The resource id of the game server cluster, eg:
	// 'projects/{project_id}/locations/{location}/realms/{realm_id}/gameServerClusters/{cluster_id}'. For example,
	// 'projects/my-project/locations/{location}/realms/zanzibar/gameServerClusters/my-onprem-cluster'.
	Name pulumi.StringPtrInput
	// The ID of the project in which the resource belongs.
	// If it is not provided, the provider project is used.
	Project pulumi.StringPtrInput
	// The realm id of the game server realm.
	RealmId pulumi.StringPtrInput
}

func (GameServerClusterState) ElementType 

func (GameServerClusterState) ElementType() reflect.Type

type GameServerConfig 

type GameServerConfig struct {
	pulumi.CustomResourceState

	// A unique id for the deployment config.
	ConfigId pulumi.StringOutput `pulumi:"configId"`
	// A unique id for the deployment.
	DeploymentId pulumi.StringOutput `pulumi:"deploymentId"`
	// The description of the game server config.
	Description pulumi.StringPtrOutput `pulumi:"description"`
	// The fleet config contains list of fleet specs. In the Single Cloud, there will be only one.
	FleetConfigs GameServerConfigFleetConfigArrayOutput `pulumi:"fleetConfigs"`
	// The labels associated with this game server config. Each label is a key-value pair.
	Labels pulumi.StringMapOutput `pulumi:"labels"`
	// Location of the Deployment.
	Location pulumi.StringPtrOutput `pulumi:"location"`
	// The resource name of the game server config, in the form:
	// 'projects/{project_id}/locations/{location}/gameServerDeployments/{deployment_id}/configs/{config_id}'.
	Name pulumi.StringOutput `pulumi:"name"`
	// The ID of the project in which the resource belongs.
	// If it is not provided, the provider project is used.
	Project pulumi.StringOutput `pulumi:"project"`
	// Optional. This contains the autoscaling settings.
	ScalingConfigs GameServerConfigScalingConfigArrayOutput `pulumi:"scalingConfigs"`
}

A game server config resource. Configs are global and immutable.

To get more information about GameServerConfig, see:

* [API documentation](https://cloud.google.com/game-servers/docs/reference/rest/v1beta/projects.locations.gameServerDeployments.configs) * How-to Guides

> This content is derived from https://github.com/terraform-providers/terraform-provider-google/blob/master/website/docs/r/game_services_game_server_config.html.markdown.

func GetGameServerConfig 

func GetGameServerConfig(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *GameServerConfigState, opts ...pulumi.ResourceOption) (*GameServerConfig, error)

GetGameServerConfig gets an existing GameServerConfig resource's state with the given name, ID, and optional state properties that are used to uniquely qualify the lookup (nil if not required).

func NewGameServerConfig 

func NewGameServerConfig(ctx *pulumi.Context,
	name string, args *GameServerConfigArgs, opts ...pulumi.ResourceOption) (*GameServerConfig, error)

NewGameServerConfig registers a new resource with the given unique name, arguments, and options.

type GameServerConfigArgs 

type GameServerConfigArgs struct {
	// A unique id for the deployment config.
	ConfigId pulumi.StringInput
	// A unique id for the deployment.
	DeploymentId pulumi.StringInput
	// The description of the game server config.
	Description pulumi.StringPtrInput
	// The fleet config contains list of fleet specs. In the Single Cloud, there will be only one.
	FleetConfigs GameServerConfigFleetConfigArrayInput
	// The labels associated with this game server config. Each label is a key-value pair.
	Labels pulumi.StringMapInput
	// Location of the Deployment.
	Location pulumi.StringPtrInput
	// The ID of the project in which the resource belongs.
	// If it is not provided, the provider project is used.
	Project pulumi.StringPtrInput
	// Optional. This contains the autoscaling settings.
	ScalingConfigs GameServerConfigScalingConfigArrayInput
}

The set of arguments for constructing a GameServerConfig resource.

func (GameServerConfigArgs) ElementType 

func (GameServerConfigArgs) ElementType() reflect.Type

type GameServerConfigFleetConfig 

type GameServerConfigFleetConfig struct {
	FleetSpec string  `pulumi:"fleetSpec"`
	Name      *string `pulumi:"name"`
}

type GameServerConfigFleetConfigArgs 

type GameServerConfigFleetConfigArgs struct {
	FleetSpec pulumi.StringInput    `pulumi:"fleetSpec"`
	Name      pulumi.StringPtrInput `pulumi:"name"`
}

func (GameServerConfigFleetConfigArgs) ElementType 

func (GameServerConfigFleetConfigArgs) ElementType() reflect.Type

func (GameServerConfigFleetConfigArgs) ToGameServerConfigFleetConfigOutput 

func (i GameServerConfigFleetConfigArgs) ToGameServerConfigFleetConfigOutput() GameServerConfigFleetConfigOutput

func (GameServerConfigFleetConfigArgs) ToGameServerConfigFleetConfigOutputWithContext 

func (i GameServerConfigFleetConfigArgs) ToGameServerConfigFleetConfigOutputWithContext(ctx context.Context) GameServerConfigFleetConfigOutput

type GameServerConfigFleetConfigArray 

type GameServerConfigFleetConfigArray []GameServerConfigFleetConfigInput

func (GameServerConfigFleetConfigArray) ElementType 

func (GameServerConfigFleetConfigArray) ElementType() reflect.Type

func (GameServerConfigFleetConfigArray) ToGameServerConfigFleetConfigArrayOutput 

func (i GameServerConfigFleetConfigArray) ToGameServerConfigFleetConfigArrayOutput() GameServerConfigFleetConfigArrayOutput

func (GameServerConfigFleetConfigArray) ToGameServerConfigFleetConfigArrayOutputWithContext 

func (i GameServerConfigFleetConfigArray) ToGameServerConfigFleetConfigArrayOutputWithContext(ctx context.Context) GameServerConfigFleetConfigArrayOutput

type GameServerConfigFleetConfigArrayInput 

type GameServerConfigFleetConfigArrayInput interface {
	pulumi.Input

	ToGameServerConfigFleetConfigArrayOutput() GameServerConfigFleetConfigArrayOutput
	ToGameServerConfigFleetConfigArrayOutputWithContext(context.Context) GameServerConfigFleetConfigArrayOutput
}

type GameServerConfigFleetConfigArrayOutput 

type GameServerConfigFleetConfigArrayOutput struct{ *pulumi.OutputState }

func (GameServerConfigFleetConfigArrayOutput) ElementType 

func (GameServerConfigFleetConfigArrayOutput) ElementType() reflect.Type

func (GameServerConfigFleetConfigArrayOutput) Index 

func (o GameServerConfigFleetConfigArrayOutput) Index(i pulumi.IntInput) GameServerConfigFleetConfigOutput

func (GameServerConfigFleetConfigArrayOutput) ToGameServerConfigFleetConfigArrayOutput 

func (o GameServerConfigFleetConfigArrayOutput) ToGameServerConfigFleetConfigArrayOutput() GameServerConfigFleetConfigArrayOutput

func (GameServerConfigFleetConfigArrayOutput) ToGameServerConfigFleetConfigArrayOutputWithContext 

func (o GameServerConfigFleetConfigArrayOutput) ToGameServerConfigFleetConfigArrayOutputWithContext(ctx context.Context) GameServerConfigFleetConfigArrayOutput

type GameServerConfigFleetConfigInput 

type GameServerConfigFleetConfigInput interface {
	pulumi.Input

	ToGameServerConfigFleetConfigOutput() GameServerConfigFleetConfigOutput
	ToGameServerConfigFleetConfigOutputWithContext(context.Context) GameServerConfigFleetConfigOutput
}

type GameServerConfigFleetConfigOutput 

type GameServerConfigFleetConfigOutput struct{ *pulumi.OutputState }

func (GameServerConfigFleetConfigOutput) ElementType 

func (GameServerConfigFleetConfigOutput) ElementType() reflect.Type

func (GameServerConfigFleetConfigOutput) FleetSpec 

func (o GameServerConfigFleetConfigOutput) FleetSpec() pulumi.StringOutput

func (GameServerConfigFleetConfigOutput) Name 

func (o GameServerConfigFleetConfigOutput) Name() pulumi.StringPtrOutput

func (GameServerConfigFleetConfigOutput) ToGameServerConfigFleetConfigOutput 

func (o GameServerConfigFleetConfigOutput) ToGameServerConfigFleetConfigOutput() GameServerConfigFleetConfigOutput

func (GameServerConfigFleetConfigOutput) ToGameServerConfigFleetConfigOutputWithContext 

func (o GameServerConfigFleetConfigOutput) ToGameServerConfigFleetConfigOutputWithContext(ctx context.Context) GameServerConfigFleetConfigOutput

type GameServerConfigScalingConfig 

type GameServerConfigScalingConfig struct {
	FleetAutoscalerSpec string                                  `pulumi:"fleetAutoscalerSpec"`
	Name                string                                  `pulumi:"name"`
	Schedules           []GameServerConfigScalingConfigSchedule `pulumi:"schedules"`
	Selectors           []GameServerConfigScalingConfigSelector `pulumi:"selectors"`
}

type GameServerConfigScalingConfigArgs 

type GameServerConfigScalingConfigArgs struct {
	FleetAutoscalerSpec pulumi.StringInput                              `pulumi:"fleetAutoscalerSpec"`
	Name                pulumi.StringInput                              `pulumi:"name"`
	Schedules           GameServerConfigScalingConfigScheduleArrayInput `pulumi:"schedules"`
	Selectors           GameServerConfigScalingConfigSelectorArrayInput `pulumi:"selectors"`
}

func (GameServerConfigScalingConfigArgs) ElementType 

func (GameServerConfigScalingConfigArgs) ElementType() reflect.Type

func (GameServerConfigScalingConfigArgs) ToGameServerConfigScalingConfigOutput 

func (i GameServerConfigScalingConfigArgs) ToGameServerConfigScalingConfigOutput() GameServerConfigScalingConfigOutput

func (GameServerConfigScalingConfigArgs) ToGameServerConfigScalingConfigOutputWithContext 

func (i GameServerConfigScalingConfigArgs) ToGameServerConfigScalingConfigOutputWithContext(ctx context.Context) GameServerConfigScalingConfigOutput

type GameServerConfigScalingConfigArray 

type GameServerConfigScalingConfigArray []GameServerConfigScalingConfigInput

func (GameServerConfigScalingConfigArray) ElementType 

func (GameServerConfigScalingConfigArray) ElementType() reflect.Type

func (GameServerConfigScalingConfigArray) ToGameServerConfigScalingConfigArrayOutput 

func (i GameServerConfigScalingConfigArray) ToGameServerConfigScalingConfigArrayOutput() GameServerConfigScalingConfigArrayOutput

func (GameServerConfigScalingConfigArray) ToGameServerConfigScalingConfigArrayOutputWithContext 

func (i GameServerConfigScalingConfigArray) ToGameServerConfigScalingConfigArrayOutputWithContext(ctx context.Context) GameServerConfigScalingConfigArrayOutput

type GameServerConfigScalingConfigArrayInput 

type GameServerConfigScalingConfigArrayInput interface {
	pulumi.Input

	ToGameServerConfigScalingConfigArrayOutput() GameServerConfigScalingConfigArrayOutput
	ToGameServerConfigScalingConfigArrayOutputWithContext(context.Context) GameServerConfigScalingConfigArrayOutput
}

type GameServerConfigScalingConfigArrayOutput 

type GameServerConfigScalingConfigArrayOutput struct{ *pulumi.OutputState }

func (GameServerConfigScalingConfigArrayOutput) ElementType 

func (GameServerConfigScalingConfigArrayOutput) ElementType() reflect.Type

func (GameServerConfigScalingConfigArrayOutput) Index 

func (o GameServerConfigScalingConfigArrayOutput) Index(i pulumi.IntInput) GameServerConfigScalingConfigOutput

func (GameServerConfigScalingConfigArrayOutput) ToGameServerConfigScalingConfigArrayOutput 

func (o GameServerConfigScalingConfigArrayOutput) ToGameServerConfigScalingConfigArrayOutput() GameServerConfigScalingConfigArrayOutput

func (GameServerConfigScalingConfigArrayOutput) ToGameServerConfigScalingConfigArrayOutputWithContext 

func (o GameServerConfigScalingConfigArrayOutput) ToGameServerConfigScalingConfigArrayOutputWithContext(ctx context.Context) GameServerConfigScalingConfigArrayOutput

type GameServerConfigScalingConfigInput 

type GameServerConfigScalingConfigInput interface {
	pulumi.Input

	ToGameServerConfigScalingConfigOutput() GameServerConfigScalingConfigOutput
	ToGameServerConfigScalingConfigOutputWithContext(context.Context) GameServerConfigScalingConfigOutput
}

type GameServerConfigScalingConfigOutput 

type GameServerConfigScalingConfigOutput struct{ *pulumi.OutputState }

func (GameServerConfigScalingConfigOutput) ElementType 

func (GameServerConfigScalingConfigOutput) ElementType() reflect.Type

func (GameServerConfigScalingConfigOutput) FleetAutoscalerSpec 

func (o GameServerConfigScalingConfigOutput) FleetAutoscalerSpec() pulumi.StringOutput

func (GameServerConfigScalingConfigOutput) Name 

func (o GameServerConfigScalingConfigOutput) Name() pulumi.StringOutput

func (GameServerConfigScalingConfigOutput) Schedules 

func (o GameServerConfigScalingConfigOutput) Schedules() GameServerConfigScalingConfigScheduleArrayOutput

func (GameServerConfigScalingConfigOutput) Selectors 

func (o GameServerConfigScalingConfigOutput) Selectors() GameServerConfigScalingConfigSelectorArrayOutput

func (GameServerConfigScalingConfigOutput) ToGameServerConfigScalingConfigOutput 

func (o GameServerConfigScalingConfigOutput) ToGameServerConfigScalingConfigOutput() GameServerConfigScalingConfigOutput

func (GameServerConfigScalingConfigOutput) ToGameServerConfigScalingConfigOutputWithContext 

func (o GameServerConfigScalingConfigOutput) ToGameServerConfigScalingConfigOutputWithContext(ctx context.Context) GameServerConfigScalingConfigOutput

type GameServerConfigScalingConfigSchedule 

type GameServerConfigScalingConfigSchedule struct {
	CronJobDuration *string `pulumi:"cronJobDuration"`
	CronSpec        *string `pulumi:"cronSpec"`
	EndTime         *string `pulumi:"endTime"`
	StartTime       *string `pulumi:"startTime"`
}

type GameServerConfigScalingConfigScheduleArgs 

type GameServerConfigScalingConfigScheduleArgs struct {
	CronJobDuration pulumi.StringPtrInput `pulumi:"cronJobDuration"`
	CronSpec        pulumi.StringPtrInput `pulumi:"cronSpec"`
	EndTime         pulumi.StringPtrInput `pulumi:"endTime"`
	StartTime       pulumi.StringPtrInput `pulumi:"startTime"`
}

func (GameServerConfigScalingConfigScheduleArgs) ElementType 

func (GameServerConfigScalingConfigScheduleArgs) ElementType() reflect.Type

func (GameServerConfigScalingConfigScheduleArgs) ToGameServerConfigScalingConfigScheduleOutput 

func (i GameServerConfigScalingConfigScheduleArgs) ToGameServerConfigScalingConfigScheduleOutput() GameServerConfigScalingConfigScheduleOutput

func (GameServerConfigScalingConfigScheduleArgs) ToGameServerConfigScalingConfigScheduleOutputWithContext 

func (i GameServerConfigScalingConfigScheduleArgs) ToGameServerConfigScalingConfigScheduleOutputWithContext(ctx context.Context) GameServerConfigScalingConfigScheduleOutput

type GameServerConfigScalingConfigScheduleArray 

type GameServerConfigScalingConfigScheduleArray []GameServerConfigScalingConfigScheduleInput

func (GameServerConfigScalingConfigScheduleArray) ElementType 

func (GameServerConfigScalingConfigScheduleArray) ElementType() reflect.Type

func (GameServerConfigScalingConfigScheduleArray) ToGameServerConfigScalingConfigScheduleArrayOutput 

func (i GameServerConfigScalingConfigScheduleArray) ToGameServerConfigScalingConfigScheduleArrayOutput() GameServerConfigScalingConfigScheduleArrayOutput

func (GameServerConfigScalingConfigScheduleArray) ToGameServerConfigScalingConfigScheduleArrayOutputWithContext 

func (i GameServerConfigScalingConfigScheduleArray) ToGameServerConfigScalingConfigScheduleArrayOutputWithContext(ctx context.Context) GameServerConfigScalingConfigScheduleArrayOutput

type GameServerConfigScalingConfigScheduleArrayInput 

type GameServerConfigScalingConfigScheduleArrayInput interface {
	pulumi.Input

	ToGameServerConfigScalingConfigScheduleArrayOutput() GameServerConfigScalingConfigScheduleArrayOutput
	ToGameServerConfigScalingConfigScheduleArrayOutputWithContext(context.Context) GameServerConfigScalingConfigScheduleArrayOutput
}

type GameServerConfigScalingConfigScheduleArrayOutput 

type GameServerConfigScalingConfigScheduleArrayOutput struct{ *pulumi.OutputState }

func (GameServerConfigScalingConfigScheduleArrayOutput) ElementType 

func (GameServerConfigScalingConfigScheduleArrayOutput) ElementType() reflect.Type

func (GameServerConfigScalingConfigScheduleArrayOutput) Index 

func (o GameServerConfigScalingConfigScheduleArrayOutput) Index(i pulumi.IntInput) GameServerConfigScalingConfigScheduleOutput

func (GameServerConfigScalingConfigScheduleArrayOutput) ToGameServerConfigScalingConfigScheduleArrayOutput 

func (o GameServerConfigScalingConfigScheduleArrayOutput) ToGameServerConfigScalingConfigScheduleArrayOutput() GameServerConfigScalingConfigScheduleArrayOutput

func (GameServerConfigScalingConfigScheduleArrayOutput) ToGameServerConfigScalingConfigScheduleArrayOutputWithContext 

func (o GameServerConfigScalingConfigScheduleArrayOutput) ToGameServerConfigScalingConfigScheduleArrayOutputWithContext(ctx context.Context) GameServerConfigScalingConfigScheduleArrayOutput

type GameServerConfigScalingConfigScheduleInput 

type GameServerConfigScalingConfigScheduleInput interface {
	pulumi.Input

	ToGameServerConfigScalingConfigScheduleOutput() GameServerConfigScalingConfigScheduleOutput
	ToGameServerConfigScalingConfigScheduleOutputWithContext(context.Context) GameServerConfigScalingConfigScheduleOutput
}

type GameServerConfigScalingConfigScheduleOutput 

type GameServerConfigScalingConfigScheduleOutput struct{ *pulumi.OutputState }

func (GameServerConfigScalingConfigScheduleOutput) CronJobDuration 

func (o GameServerConfigScalingConfigScheduleOutput) CronJobDuration() pulumi.StringPtrOutput

func (GameServerConfigScalingConfigScheduleOutput) CronSpec 

func (o GameServerConfigScalingConfigScheduleOutput) CronSpec() pulumi.StringPtrOutput

func (GameServerConfigScalingConfigScheduleOutput) ElementType 

func (GameServerConfigScalingConfigScheduleOutput) ElementType() reflect.Type

func (GameServerConfigScalingConfigScheduleOutput) EndTime 

func (o GameServerConfigScalingConfigScheduleOutput) EndTime() pulumi.StringPtrOutput

func (GameServerConfigScalingConfigScheduleOutput) StartTime 

func (o GameServerConfigScalingConfigScheduleOutput) StartTime() pulumi.StringPtrOutput

func (GameServerConfigScalingConfigScheduleOutput) ToGameServerConfigScalingConfigScheduleOutput 

func (o GameServerConfigScalingConfigScheduleOutput) ToGameServerConfigScalingConfigScheduleOutput() GameServerConfigScalingConfigScheduleOutput

func (GameServerConfigScalingConfigScheduleOutput) ToGameServerConfigScalingConfigScheduleOutputWithContext 

func (o GameServerConfigScalingConfigScheduleOutput) ToGameServerConfigScalingConfigScheduleOutputWithContext(ctx context.Context) GameServerConfigScalingConfigScheduleOutput

type GameServerConfigScalingConfigSelector 

type GameServerConfigScalingConfigSelector struct {
	Labels map[string]string `pulumi:"labels"`
}

type GameServerConfigScalingConfigSelectorArgs 

type GameServerConfigScalingConfigSelectorArgs struct {
	Labels pulumi.StringMapInput `pulumi:"labels"`
}

func (GameServerConfigScalingConfigSelectorArgs) ElementType 

func (GameServerConfigScalingConfigSelectorArgs) ElementType() reflect.Type

func (GameServerConfigScalingConfigSelectorArgs) ToGameServerConfigScalingConfigSelectorOutput 

func (i GameServerConfigScalingConfigSelectorArgs) ToGameServerConfigScalingConfigSelectorOutput() GameServerConfigScalingConfigSelectorOutput

func (GameServerConfigScalingConfigSelectorArgs) ToGameServerConfigScalingConfigSelectorOutputWithContext 

func (i GameServerConfigScalingConfigSelectorArgs) ToGameServerConfigScalingConfigSelectorOutputWithContext(ctx context.Context) GameServerConfigScalingConfigSelectorOutput

type GameServerConfigScalingConfigSelectorArray 

type GameServerConfigScalingConfigSelectorArray []GameServerConfigScalingConfigSelectorInput

func (GameServerConfigScalingConfigSelectorArray) ElementType 

func (GameServerConfigScalingConfigSelectorArray) ElementType() reflect.Type

func (GameServerConfigScalingConfigSelectorArray) ToGameServerConfigScalingConfigSelectorArrayOutput 

func (i GameServerConfigScalingConfigSelectorArray) ToGameServerConfigScalingConfigSelectorArrayOutput() GameServerConfigScalingConfigSelectorArrayOutput

func (GameServerConfigScalingConfigSelectorArray) ToGameServerConfigScalingConfigSelectorArrayOutputWithContext 

func (i GameServerConfigScalingConfigSelectorArray) ToGameServerConfigScalingConfigSelectorArrayOutputWithContext(ctx context.Context) GameServerConfigScalingConfigSelectorArrayOutput

type GameServerConfigScalingConfigSelectorArrayInput 

type GameServerConfigScalingConfigSelectorArrayInput interface {
	pulumi.Input

	ToGameServerConfigScalingConfigSelectorArrayOutput() GameServerConfigScalingConfigSelectorArrayOutput
	ToGameServerConfigScalingConfigSelectorArrayOutputWithContext(context.Context) GameServerConfigScalingConfigSelectorArrayOutput
}

type GameServerConfigScalingConfigSelectorArrayOutput 

type GameServerConfigScalingConfigSelectorArrayOutput struct{ *pulumi.OutputState }

func (GameServerConfigScalingConfigSelectorArrayOutput) ElementType 

func (GameServerConfigScalingConfigSelectorArrayOutput) ElementType() reflect.Type

func (GameServerConfigScalingConfigSelectorArrayOutput) Index 

func (o GameServerConfigScalingConfigSelectorArrayOutput) Index(i pulumi.IntInput) GameServerConfigScalingConfigSelectorOutput

func (GameServerConfigScalingConfigSelectorArrayOutput) ToGameServerConfigScalingConfigSelectorArrayOutput 

func (o GameServerConfigScalingConfigSelectorArrayOutput) ToGameServerConfigScalingConfigSelectorArrayOutput() GameServerConfigScalingConfigSelectorArrayOutput

func (GameServerConfigScalingConfigSelectorArrayOutput) ToGameServerConfigScalingConfigSelectorArrayOutputWithContext 

func (o GameServerConfigScalingConfigSelectorArrayOutput) ToGameServerConfigScalingConfigSelectorArrayOutputWithContext(ctx context.Context) GameServerConfigScalingConfigSelectorArrayOutput

type GameServerConfigScalingConfigSelectorInput 

type GameServerConfigScalingConfigSelectorInput interface {
	pulumi.Input

	ToGameServerConfigScalingConfigSelectorOutput() GameServerConfigScalingConfigSelectorOutput
	ToGameServerConfigScalingConfigSelectorOutputWithContext(context.Context) GameServerConfigScalingConfigSelectorOutput
}

type GameServerConfigScalingConfigSelectorOutput 

type GameServerConfigScalingConfigSelectorOutput struct{ *pulumi.OutputState }

func (GameServerConfigScalingConfigSelectorOutput) ElementType 

func (GameServerConfigScalingConfigSelectorOutput) ElementType() reflect.Type

func (GameServerConfigScalingConfigSelectorOutput) Labels 

func (o GameServerConfigScalingConfigSelectorOutput) Labels() pulumi.StringMapOutput

func (GameServerConfigScalingConfigSelectorOutput) ToGameServerConfigScalingConfigSelectorOutput 

func (o GameServerConfigScalingConfigSelectorOutput) ToGameServerConfigScalingConfigSelectorOutput() GameServerConfigScalingConfigSelectorOutput

func (GameServerConfigScalingConfigSelectorOutput) ToGameServerConfigScalingConfigSelectorOutputWithContext 

func (o GameServerConfigScalingConfigSelectorOutput) ToGameServerConfigScalingConfigSelectorOutputWithContext(ctx context.Context) GameServerConfigScalingConfigSelectorOutput

type GameServerConfigState 

type GameServerConfigState struct {
	// A unique id for the deployment config.
	ConfigId pulumi.StringPtrInput
	// A unique id for the deployment.
	DeploymentId pulumi.StringPtrInput
	// The description of the game server config.
	Description pulumi.StringPtrInput
	// The fleet config contains list of fleet specs. In the Single Cloud, there will be only one.
	FleetConfigs GameServerConfigFleetConfigArrayInput
	// The labels associated with this game server config. Each label is a key-value pair.
	Labels pulumi.StringMapInput
	// Location of the Deployment.
	Location pulumi.StringPtrInput
	// The resource name of the game server config, in the form:
	// 'projects/{project_id}/locations/{location}/gameServerDeployments/{deployment_id}/configs/{config_id}'.
	Name pulumi.StringPtrInput
	// The ID of the project in which the resource belongs.
	// If it is not provided, the provider project is used.
	Project pulumi.StringPtrInput
	// Optional. This contains the autoscaling settings.
	ScalingConfigs GameServerConfigScalingConfigArrayInput
}

func (GameServerConfigState) ElementType 

func (GameServerConfigState) ElementType() reflect.Type

type GameServerDeployment 

type GameServerDeployment struct {
	pulumi.CustomResourceState

	// A unique id for the deployment.
	DeploymentId pulumi.StringOutput `pulumi:"deploymentId"`
	// Human readable description of the game server deployment.
	Description pulumi.StringPtrOutput `pulumi:"description"`
	// The labels associated with this game server deployment. Each label is a key-value pair.
	Labels pulumi.StringMapOutput `pulumi:"labels"`
	// Location of the Deployment.
	Location pulumi.StringPtrOutput `pulumi:"location"`
	// The resource id of the game server deployment, eg:
	// 'projects/{project_id}/locations/{location}/gameServerDeployments/{deployment_id}'. For example,
	// 'projects/my-project/locations/{location}/gameServerDeployments/my-deployment'.
	Name pulumi.StringOutput `pulumi:"name"`
	// The ID of the project in which the resource belongs.
	// If it is not provided, the provider project is used.
	Project pulumi.StringOutput `pulumi:"project"`
}

A game server deployment resource.

To get more information about GameServerDeployment, see:

* [API documentation](https://cloud.google.com/game-servers/docs/reference/rest/v1beta/projects.locations.gameServerDeployments) * How-to Guides

> This content is derived from https://github.com/terraform-providers/terraform-provider-google/blob/master/website/docs/r/game_services_game_server_deployment.html.markdown.

func GetGameServerDeployment 

func GetGameServerDeployment(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *GameServerDeploymentState, opts ...pulumi.ResourceOption) (*GameServerDeployment, error)

GetGameServerDeployment gets an existing GameServerDeployment resource's state with the given name, ID, and optional state properties that are used to uniquely qualify the lookup (nil if not required).

func NewGameServerDeployment 

func NewGameServerDeployment(ctx *pulumi.Context,
	name string, args *GameServerDeploymentArgs, opts ...pulumi.ResourceOption) (*GameServerDeployment, error)

NewGameServerDeployment registers a new resource with the given unique name, arguments, and options.

type GameServerDeploymentArgs 

type GameServerDeploymentArgs struct {
	// A unique id for the deployment.
	DeploymentId pulumi.StringInput
	// Human readable description of the game server deployment.
	Description pulumi.StringPtrInput
	// The labels associated with this game server deployment. Each label is a key-value pair.
	Labels pulumi.StringMapInput
	// Location of the Deployment.
	Location pulumi.StringPtrInput
	// The ID of the project in which the resource belongs.
	// If it is not provided, the provider project is used.
	Project pulumi.StringPtrInput
}

The set of arguments for constructing a GameServerDeployment resource.

func (GameServerDeploymentArgs) ElementType 

func (GameServerDeploymentArgs) ElementType() reflect.Type

type GameServerDeploymentRollout 

type GameServerDeploymentRollout struct {
	pulumi.CustomResourceState

	// This field points to the game server config that is applied by default to all realms and clusters. For example,
	// 'projects/my-project/locations/global/gameServerDeployments/my-game/configs/my-config'.
	DefaultGameServerConfig pulumi.StringOutput `pulumi:"defaultGameServerConfig"`
	// The deployment to rollout the new config to. Only 1 rollout must be associated with each deployment.
	DeploymentId pulumi.StringOutput `pulumi:"deploymentId"`
	// The game_server_config_overrides contains the per game server config overrides. The overrides are processed in the order
	// they are listed. As soon as a match is found for a cluster, the rest of the list is not processed.
	GameServerConfigOverrides GameServerDeploymentRolloutGameServerConfigOverrideArrayOutput `pulumi:"gameServerConfigOverrides"`
	// The resource id of the game server deployment eg:
	// 'projects/my-project/locations/global/gameServerDeployments/my-deployment/rollout'.
	Name pulumi.StringOutput `pulumi:"name"`
	// The ID of the project in which the resource belongs.
	// If it is not provided, the provider project is used.
	Project pulumi.StringOutput `pulumi:"project"`
}

This represents the rollout state. This is part of the game server deployment.

To get more information about GameServerDeploymentRollout, see:

* [API documentation](https://cloud.google.com/game-servers/docs/reference/rest/v1beta/GameServerDeploymentRollout) * How-to Guides

> This content is derived from https://github.com/terraform-providers/terraform-provider-google/blob/master/website/docs/r/game_services_game_server_deployment_rollout.html.markdown.

func GetGameServerDeploymentRollout 

func GetGameServerDeploymentRollout(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *GameServerDeploymentRolloutState, opts ...pulumi.ResourceOption) (*GameServerDeploymentRollout, error)

GetGameServerDeploymentRollout gets an existing GameServerDeploymentRollout resource's state with the given name, ID, and optional state properties that are used to uniquely qualify the lookup (nil if not required).

func NewGameServerDeploymentRollout 

func NewGameServerDeploymentRollout(ctx *pulumi.Context,
	name string, args *GameServerDeploymentRolloutArgs, opts ...pulumi.ResourceOption) (*GameServerDeploymentRollout, error)

NewGameServerDeploymentRollout registers a new resource with the given unique name, arguments, and options.

type GameServerDeploymentRolloutArgs 

type GameServerDeploymentRolloutArgs struct {
	// This field points to the game server config that is applied by default to all realms and clusters. For example,
	// 'projects/my-project/locations/global/gameServerDeployments/my-game/configs/my-config'.
	DefaultGameServerConfig pulumi.StringInput
	// The deployment to rollout the new config to. Only 1 rollout must be associated with each deployment.
	DeploymentId pulumi.StringInput
	// The game_server_config_overrides contains the per game server config overrides. The overrides are processed in the order
	// they are listed. As soon as a match is found for a cluster, the rest of the list is not processed.
	GameServerConfigOverrides GameServerDeploymentRolloutGameServerConfigOverrideArrayInput
	// The ID of the project in which the resource belongs.
	// If it is not provided, the provider project is used.
	Project pulumi.StringPtrInput
}

The set of arguments for constructing a GameServerDeploymentRollout resource.

func (GameServerDeploymentRolloutArgs) ElementType 

func (GameServerDeploymentRolloutArgs) ElementType() reflect.Type

type GameServerDeploymentRolloutGameServerConfigOverride 

type GameServerDeploymentRolloutGameServerConfigOverride struct {
	ConfigVersion  *string                                                            `pulumi:"configVersion"`
	RealmsSelector *GameServerDeploymentRolloutGameServerConfigOverrideRealmsSelector `pulumi:"realmsSelector"`
}

type GameServerDeploymentRolloutGameServerConfigOverrideArgs 

type GameServerDeploymentRolloutGameServerConfigOverrideArgs struct {
	ConfigVersion  pulumi.StringPtrInput                                                     `pulumi:"configVersion"`
	RealmsSelector GameServerDeploymentRolloutGameServerConfigOverrideRealmsSelectorPtrInput `pulumi:"realmsSelector"`
}

func (GameServerDeploymentRolloutGameServerConfigOverrideArgs) ElementType 

func (GameServerDeploymentRolloutGameServerConfigOverrideArgs) ElementType() reflect.Type

func (GameServerDeploymentRolloutGameServerConfigOverrideArgs) ToGameServerDeploymentRolloutGameServerConfigOverrideOutput 

func (i GameServerDeploymentRolloutGameServerConfigOverrideArgs) ToGameServerDeploymentRolloutGameServerConfigOverrideOutput() GameServerDeploymentRolloutGameServerConfigOverrideOutput

func (GameServerDeploymentRolloutGameServerConfigOverrideArgs) ToGameServerDeploymentRolloutGameServerConfigOverrideOutputWithContext 

func (i GameServerDeploymentRolloutGameServerConfigOverrideArgs) ToGameServerDeploymentRolloutGameServerConfigOverrideOutputWithContext(ctx context.Context) GameServerDeploymentRolloutGameServerConfigOverrideOutput

type GameServerDeploymentRolloutGameServerConfigOverrideArray 

type GameServerDeploymentRolloutGameServerConfigOverrideArray []GameServerDeploymentRolloutGameServerConfigOverrideInput

func (GameServerDeploymentRolloutGameServerConfigOverrideArray) ElementType 

func (GameServerDeploymentRolloutGameServerConfigOverrideArray) ElementType() reflect.Type

func (GameServerDeploymentRolloutGameServerConfigOverrideArray) ToGameServerDeploymentRolloutGameServerConfigOverrideArrayOutput 

func (i GameServerDeploymentRolloutGameServerConfigOverrideArray) ToGameServerDeploymentRolloutGameServerConfigOverrideArrayOutput() GameServerDeploymentRolloutGameServerConfigOverrideArrayOutput

func (GameServerDeploymentRolloutGameServerConfigOverrideArray) ToGameServerDeploymentRolloutGameServerConfigOverrideArrayOutputWithContext 

func (i GameServerDeploymentRolloutGameServerConfigOverrideArray) ToGameServerDeploymentRolloutGameServerConfigOverrideArrayOutputWithContext(ctx context.Context) GameServerDeploymentRolloutGameServerConfigOverrideArrayOutput

type GameServerDeploymentRolloutGameServerConfigOverrideArrayInput 

type GameServerDeploymentRolloutGameServerConfigOverrideArrayInput interface {
	pulumi.Input

	ToGameServerDeploymentRolloutGameServerConfigOverrideArrayOutput() GameServerDeploymentRolloutGameServerConfigOverrideArrayOutput
	ToGameServerDeploymentRolloutGameServerConfigOverrideArrayOutputWithContext(context.Context) GameServerDeploymentRolloutGameServerConfigOverrideArrayOutput
}

type GameServerDeploymentRolloutGameServerConfigOverrideArrayOutput 

type GameServerDeploymentRolloutGameServerConfigOverrideArrayOutput struct{ *pulumi.OutputState }

func (GameServerDeploymentRolloutGameServerConfigOverrideArrayOutput) ElementType 

func (GameServerDeploymentRolloutGameServerConfigOverrideArrayOutput) ElementType() reflect.Type

func (GameServerDeploymentRolloutGameServerConfigOverrideArrayOutput) Index 

func (o GameServerDeploymentRolloutGameServerConfigOverrideArrayOutput) Index(i pulumi.IntInput) GameServerDeploymentRolloutGameServerConfigOverrideOutput

func (GameServerDeploymentRolloutGameServerConfigOverrideArrayOutput) ToGameServerDeploymentRolloutGameServerConfigOverrideArrayOutput 

func (o GameServerDeploymentRolloutGameServerConfigOverrideArrayOutput) ToGameServerDeploymentRolloutGameServerConfigOverrideArrayOutput() GameServerDeploymentRolloutGameServerConfigOverrideArrayOutput

func (GameServerDeploymentRolloutGameServerConfigOverrideArrayOutput) ToGameServerDeploymentRolloutGameServerConfigOverrideArrayOutputWithContext 

func (o GameServerDeploymentRolloutGameServerConfigOverrideArrayOutput) ToGameServerDeploymentRolloutGameServerConfigOverrideArrayOutputWithContext(ctx context.Context) GameServerDeploymentRolloutGameServerConfigOverrideArrayOutput

type GameServerDeploymentRolloutGameServerConfigOverrideInput 

type GameServerDeploymentRolloutGameServerConfigOverrideInput interface {
	pulumi.Input

	ToGameServerDeploymentRolloutGameServerConfigOverrideOutput() GameServerDeploymentRolloutGameServerConfigOverrideOutput
	ToGameServerDeploymentRolloutGameServerConfigOverrideOutputWithContext(context.Context) GameServerDeploymentRolloutGameServerConfigOverrideOutput
}

type GameServerDeploymentRolloutGameServerConfigOverrideOutput 

type GameServerDeploymentRolloutGameServerConfigOverrideOutput struct{ *pulumi.OutputState }

func (GameServerDeploymentRolloutGameServerConfigOverrideOutput) ConfigVersion 

func (o GameServerDeploymentRolloutGameServerConfigOverrideOutput) ConfigVersion() pulumi.StringPtrOutput

func (GameServerDeploymentRolloutGameServerConfigOverrideOutput) ElementType 

func (GameServerDeploymentRolloutGameServerConfigOverrideOutput) ElementType() reflect.Type

func (GameServerDeploymentRolloutGameServerConfigOverrideOutput) RealmsSelector 

func (o GameServerDeploymentRolloutGameServerConfigOverrideOutput) RealmsSelector() GameServerDeploymentRolloutGameServerConfigOverrideRealmsSelectorPtrOutput

func (GameServerDeploymentRolloutGameServerConfigOverrideOutput) ToGameServerDeploymentRolloutGameServerConfigOverrideOutput 

func (o GameServerDeploymentRolloutGameServerConfigOverrideOutput) ToGameServerDeploymentRolloutGameServerConfigOverrideOutput() GameServerDeploymentRolloutGameServerConfigOverrideOutput

func (GameServerDeploymentRolloutGameServerConfigOverrideOutput) ToGameServerDeploymentRolloutGameServerConfigOverrideOutputWithContext 

func (o GameServerDeploymentRolloutGameServerConfigOverrideOutput) ToGameServerDeploymentRolloutGameServerConfigOverrideOutputWithContext(ctx context.Context) GameServerDeploymentRolloutGameServerConfigOverrideOutput

type GameServerDeploymentRolloutGameServerConfigOverrideRealmsSelector 

type GameServerDeploymentRolloutGameServerConfigOverrideRealmsSelector struct {
	Realms []string `pulumi:"realms"`
}

type GameServerDeploymentRolloutGameServerConfigOverrideRealmsSelectorArgs 

type GameServerDeploymentRolloutGameServerConfigOverrideRealmsSelectorArgs struct {
	Realms pulumi.StringArrayInput `pulumi:"realms"`
}

func (GameServerDeploymentRolloutGameServerConfigOverrideRealmsSelectorArgs) ElementType 

func (GameServerDeploymentRolloutGameServerConfigOverrideRealmsSelectorArgs) ElementType() reflect.Type

func (GameServerDeploymentRolloutGameServerConfigOverrideRealmsSelectorArgs) ToGameServerDeploymentRolloutGameServerConfigOverrideRealmsSelectorOutput 

func (i GameServerDeploymentRolloutGameServerConfigOverrideRealmsSelectorArgs) ToGameServerDeploymentRolloutGameServerConfigOverrideRealmsSelectorOutput() GameServerDeploymentRolloutGameServerConfigOverrideRealmsSelectorOutput

func (GameServerDeploymentRolloutGameServerConfigOverrideRealmsSelectorArgs) ToGameServerDeploymentRolloutGameServerConfigOverrideRealmsSelectorOutputWithContext 

func (i GameServerDeploymentRolloutGameServerConfigOverrideRealmsSelectorArgs) ToGameServerDeploymentRolloutGameServerConfigOverrideRealmsSelectorOutputWithContext(ctx context.Context) GameServerDeploymentRolloutGameServerConfigOverrideRealmsSelectorOutput

func (GameServerDeploymentRolloutGameServerConfigOverrideRealmsSelectorArgs) ToGameServerDeploymentRolloutGameServerConfigOverrideRealmsSelectorPtrOutput 

func (i GameServerDeploymentRolloutGameServerConfigOverrideRealmsSelectorArgs) ToGameServerDeploymentRolloutGameServerConfigOverrideRealmsSelectorPtrOutput() GameServerDeploymentRolloutGameServerConfigOverrideRealmsSelectorPtrOutput

func (GameServerDeploymentRolloutGameServerConfigOverrideRealmsSelectorArgs) ToGameServerDeploymentRolloutGameServerConfigOverrideRealmsSelectorPtrOutputWithContext 

func (i GameServerDeploymentRolloutGameServerConfigOverrideRealmsSelectorArgs) ToGameServerDeploymentRolloutGameServerConfigOverrideRealmsSelectorPtrOutputWithContext(ctx context.Context) GameServerDeploymentRolloutGameServerConfigOverrideRealmsSelectorPtrOutput

type GameServerDeploymentRolloutGameServerConfigOverrideRealmsSelectorInput 

type GameServerDeploymentRolloutGameServerConfigOverrideRealmsSelectorInput interface {
	pulumi.Input

	ToGameServerDeploymentRolloutGameServerConfigOverrideRealmsSelectorOutput() GameServerDeploymentRolloutGameServerConfigOverrideRealmsSelectorOutput
	ToGameServerDeploymentRolloutGameServerConfigOverrideRealmsSelectorOutputWithContext(context.Context) GameServerDeploymentRolloutGameServerConfigOverrideRealmsSelectorOutput
}

type GameServerDeploymentRolloutGameServerConfigOverrideRealmsSelectorOutput 

type GameServerDeploymentRolloutGameServerConfigOverrideRealmsSelectorOutput struct{ *pulumi.OutputState }

func (GameServerDeploymentRolloutGameServerConfigOverrideRealmsSelectorOutput) ElementType 

func (GameServerDeploymentRolloutGameServerConfigOverrideRealmsSelectorOutput) ElementType() reflect.Type

func (GameServerDeploymentRolloutGameServerConfigOverrideRealmsSelectorOutput) Realms 

func (o GameServerDeploymentRolloutGameServerConfigOverrideRealmsSelectorOutput) Realms() pulumi.StringArrayOutput

func (GameServerDeploymentRolloutGameServerConfigOverrideRealmsSelectorOutput) ToGameServerDeploymentRolloutGameServerConfigOverrideRealmsSelectorOutput 

func (o GameServerDeploymentRolloutGameServerConfigOverrideRealmsSelectorOutput) ToGameServerDeploymentRolloutGameServerConfigOverrideRealmsSelectorOutput() GameServerDeploymentRolloutGameServerConfigOverrideRealmsSelectorOutput

func (GameServerDeploymentRolloutGameServerConfigOverrideRealmsSelectorOutput) ToGameServerDeploymentRolloutGameServerConfigOverrideRealmsSelectorOutputWithContext 

func (o GameServerDeploymentRolloutGameServerConfigOverrideRealmsSelectorOutput) ToGameServerDeploymentRolloutGameServerConfigOverrideRealmsSelectorOutputWithContext(ctx context.Context) GameServerDeploymentRolloutGameServerConfigOverrideRealmsSelectorOutput

func (GameServerDeploymentRolloutGameServerConfigOverrideRealmsSelectorOutput) ToGameServerDeploymentRolloutGameServerConfigOverrideRealmsSelectorPtrOutput 

func (o GameServerDeploymentRolloutGameServerConfigOverrideRealmsSelectorOutput) ToGameServerDeploymentRolloutGameServerConfigOverrideRealmsSelectorPtrOutput() GameServerDeploymentRolloutGameServerConfigOverrideRealmsSelectorPtrOutput

func (GameServerDeploymentRolloutGameServerConfigOverrideRealmsSelectorOutput) ToGameServerDeploymentRolloutGameServerConfigOverrideRealmsSelectorPtrOutputWithContext 

func (o GameServerDeploymentRolloutGameServerConfigOverrideRealmsSelectorOutput) ToGameServerDeploymentRolloutGameServerConfigOverrideRealmsSelectorPtrOutputWithContext(ctx context.Context) GameServerDeploymentRolloutGameServerConfigOverrideRealmsSelectorPtrOutput

type GameServerDeploymentRolloutGameServerConfigOverrideRealmsSelectorPtrInput 

type GameServerDeploymentRolloutGameServerConfigOverrideRealmsSelectorPtrInput interface {
	pulumi.Input

	ToGameServerDeploymentRolloutGameServerConfigOverrideRealmsSelectorPtrOutput() GameServerDeploymentRolloutGameServerConfigOverrideRealmsSelectorPtrOutput
	ToGameServerDeploymentRolloutGameServerConfigOverrideRealmsSelectorPtrOutputWithContext(context.Context) GameServerDeploymentRolloutGameServerConfigOverrideRealmsSelectorPtrOutput
}

func GameServerDeploymentRolloutGameServerConfigOverrideRealmsSelectorPtr 

func GameServerDeploymentRolloutGameServerConfigOverrideRealmsSelectorPtr(v *GameServerDeploymentRolloutGameServerConfigOverrideRealmsSelectorArgs) GameServerDeploymentRolloutGameServerConfigOverrideRealmsSelectorPtrInput

type GameServerDeploymentRolloutGameServerConfigOverrideRealmsSelectorPtrOutput 

type GameServerDeploymentRolloutGameServerConfigOverrideRealmsSelectorPtrOutput struct{ *pulumi.OutputState }

func (GameServerDeploymentRolloutGameServerConfigOverrideRealmsSelectorPtrOutput) Elem 

func (o GameServerDeploymentRolloutGameServerConfigOverrideRealmsSelectorPtrOutput) Elem() GameServerDeploymentRolloutGameServerConfigOverrideRealmsSelectorOutput

func (GameServerDeploymentRolloutGameServerConfigOverrideRealmsSelectorPtrOutput) ElementType 

func (GameServerDeploymentRolloutGameServerConfigOverrideRealmsSelectorPtrOutput) ElementType() reflect.Type

func (GameServerDeploymentRolloutGameServerConfigOverrideRealmsSelectorPtrOutput) Realms 

func (o GameServerDeploymentRolloutGameServerConfigOverrideRealmsSelectorPtrOutput) Realms() pulumi.StringArrayOutput

func (GameServerDeploymentRolloutGameServerConfigOverrideRealmsSelectorPtrOutput) ToGameServerDeploymentRolloutGameServerConfigOverrideRealmsSelectorPtrOutput 

func (o GameServerDeploymentRolloutGameServerConfigOverrideRealmsSelectorPtrOutput) ToGameServerDeploymentRolloutGameServerConfigOverrideRealmsSelectorPtrOutput() GameServerDeploymentRolloutGameServerConfigOverrideRealmsSelectorPtrOutput

func (GameServerDeploymentRolloutGameServerConfigOverrideRealmsSelectorPtrOutput) ToGameServerDeploymentRolloutGameServerConfigOverrideRealmsSelectorPtrOutputWithContext 

func (o GameServerDeploymentRolloutGameServerConfigOverrideRealmsSelectorPtrOutput) ToGameServerDeploymentRolloutGameServerConfigOverrideRealmsSelectorPtrOutputWithContext(ctx context.Context) GameServerDeploymentRolloutGameServerConfigOverrideRealmsSelectorPtrOutput

type GameServerDeploymentRolloutState 

type GameServerDeploymentRolloutState struct {
	// This field points to the game server config that is applied by default to all realms and clusters. For example,
	// 'projects/my-project/locations/global/gameServerDeployments/my-game/configs/my-config'.
	DefaultGameServerConfig pulumi.StringPtrInput
	// The deployment to rollout the new config to. Only 1 rollout must be associated with each deployment.
	DeploymentId pulumi.StringPtrInput
	// The game_server_config_overrides contains the per game server config overrides. The overrides are processed in the order
	// they are listed. As soon as a match is found for a cluster, the rest of the list is not processed.
	GameServerConfigOverrides GameServerDeploymentRolloutGameServerConfigOverrideArrayInput
	// The resource id of the game server deployment eg:
	// 'projects/my-project/locations/global/gameServerDeployments/my-deployment/rollout'.
	Name pulumi.StringPtrInput
	// The ID of the project in which the resource belongs.
	// If it is not provided, the provider project is used.
	Project pulumi.StringPtrInput
}

func (GameServerDeploymentRolloutState) ElementType 

func (GameServerDeploymentRolloutState) ElementType() reflect.Type

type GameServerDeploymentState 

type GameServerDeploymentState struct {
	// A unique id for the deployment.
	DeploymentId pulumi.StringPtrInput
	// Human readable description of the game server deployment.
	Description pulumi.StringPtrInput
	// The labels associated with this game server deployment. Each label is a key-value pair.
	Labels pulumi.StringMapInput
	// Location of the Deployment.
	Location pulumi.StringPtrInput
	// The resource id of the game server deployment, eg:
	// 'projects/{project_id}/locations/{location}/gameServerDeployments/{deployment_id}'. For example,
	// 'projects/my-project/locations/{location}/gameServerDeployments/my-deployment'.
	Name pulumi.StringPtrInput
	// The ID of the project in which the resource belongs.
	// If it is not provided, the provider project is used.
	Project pulumi.StringPtrInput
}

func (GameServerDeploymentState) ElementType 

func (GameServerDeploymentState) ElementType() reflect.Type

type Realm 

type Realm struct {
	pulumi.CustomResourceState

	// Human readable description of the realm.
	Description pulumi.StringPtrOutput `pulumi:"description"`
	// ETag of the resource.
	Etag pulumi.StringOutput `pulumi:"etag"`
	// The labels associated with this realm. Each label is a key-value pair.
	Labels pulumi.StringMapOutput `pulumi:"labels"`
	// Location of the Realm.
	Location pulumi.StringPtrOutput `pulumi:"location"`
	// The resource id of the realm, of the form: 'projects/{project_id}/locations/{location}/realms/{realm_id}'. For example,
	// 'projects/my-project/locations/{location}/realms/my-realm'.
	Name pulumi.StringOutput `pulumi:"name"`
	// The ID of the project in which the resource belongs.
	// If it is not provided, the provider project is used.
	Project pulumi.StringOutput `pulumi:"project"`
	// GCP region of the Realm.
	RealmId pulumi.StringOutput `pulumi:"realmId"`
	// Required. Time zone where all realm-specific policies are evaluated. The value of this field must be from the IANA time
	// zone database: https://www.iana.org/time-zones.
	TimeZone pulumi.StringOutput `pulumi:"timeZone"`
}

A Realm resource.

To get more information about Realm, see:

* [API documentation](https://cloud.google.com/game-servers/docs/reference/rest/v1beta/projects.locations.realms) * How-to Guides

> This content is derived from https://github.com/terraform-providers/terraform-provider-google/blob/master/website/docs/r/game_services_realm.html.markdown.

func GetRealm 

func GetRealm(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *RealmState, opts ...pulumi.ResourceOption) (*Realm, error)

GetRealm gets an existing Realm resource's state with the given name, ID, and optional state properties that are used to uniquely qualify the lookup (nil if not required).

func NewRealm 

func NewRealm(ctx *pulumi.Context,
	name string, args *RealmArgs, opts ...pulumi.ResourceOption) (*Realm, error)

NewRealm registers a new resource with the given unique name, arguments, and options.

type RealmArgs 

type RealmArgs struct {
	// Human readable description of the realm.
	Description pulumi.StringPtrInput
	// The labels associated with this realm. Each label is a key-value pair.
	Labels pulumi.StringMapInput
	// Location of the Realm.
	Location pulumi.StringPtrInput
	// The ID of the project in which the resource belongs.
	// If it is not provided, the provider project is used.
	Project pulumi.StringPtrInput
	// GCP region of the Realm.
	RealmId pulumi.StringInput
	// Required. Time zone where all realm-specific policies are evaluated. The value of this field must be from the IANA time
	// zone database: https://www.iana.org/time-zones.
	TimeZone pulumi.StringInput
}

The set of arguments for constructing a Realm resource.

func (RealmArgs) ElementType 

func (RealmArgs) ElementType() reflect.Type

type RealmState 

type RealmState struct {
	// Human readable description of the realm.
	Description pulumi.StringPtrInput
	// ETag of the resource.
	Etag pulumi.StringPtrInput
	// The labels associated with this realm. Each label is a key-value pair.
	Labels pulumi.StringMapInput
	// Location of the Realm.
	Location pulumi.StringPtrInput
	// The resource id of the realm, of the form: 'projects/{project_id}/locations/{location}/realms/{realm_id}'. For example,
	// 'projects/my-project/locations/{location}/realms/my-realm'.
	Name pulumi.StringPtrInput
	// The ID of the project in which the resource belongs.
	// If it is not provided, the provider project is used.
	Project pulumi.StringPtrInput
	// GCP region of the Realm.
	RealmId pulumi.StringPtrInput
	// Required. Time zone where all realm-specific policies are evaluated. The value of this field must be from the IANA time
	// zone database: https://www.iana.org/time-zones.
	TimeZone pulumi.StringPtrInput
}

func (RealmState) ElementType 

func (RealmState) ElementType() reflect.Type

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.