gameservices

package
v5.26.0 Latest Latest
Warning

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

 Go to latest Published: Nov 1, 2021 License: Apache-2.0 Imports: 7 Imported by: 0

Documentation

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.
	// Structure is documented below.
	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

## Example Usage

## Import

GameServerCluster can be imported using any of these accepted formats

```sh 

$ pulumi import gcp:gameservices/gameServerCluster:GameServerCluster default projects/{{project}}/locations/{{location}}/realms/{{realm_id}}/gameServerClusters/{{cluster_id}}

```

```sh 

$ pulumi import gcp:gameservices/gameServerCluster:GameServerCluster default {{project}}/{{location}}/{{realm_id}}/{{cluster_id}}

```

```sh 

$ pulumi import gcp:gameservices/gameServerCluster:GameServerCluster default {{location}}/{{realm_id}}/{{cluster_id}}

```

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.

func (*GameServerCluster) ElementType 

func (*GameServerCluster) ElementType() reflect.Type

func (*GameServerCluster) ToGameServerClusterOutput 

func (i *GameServerCluster) ToGameServerClusterOutput() GameServerClusterOutput

func (*GameServerCluster) ToGameServerClusterOutputWithContext 

func (i *GameServerCluster) ToGameServerClusterOutputWithContext(ctx context.Context) GameServerClusterOutput

func (*GameServerCluster) ToGameServerClusterPtrOutput 

func (i *GameServerCluster) ToGameServerClusterPtrOutput() GameServerClusterPtrOutput

func (*GameServerCluster) ToGameServerClusterPtrOutputWithContext 

func (i *GameServerCluster) ToGameServerClusterPtrOutputWithContext(ctx context.Context) GameServerClusterPtrOutput

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.
	// Structure is documented below.
	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 GameServerClusterArray 

type GameServerClusterArray []GameServerClusterInput

func (GameServerClusterArray) ElementType 

func (GameServerClusterArray) ElementType() reflect.Type

func (GameServerClusterArray) ToGameServerClusterArrayOutput 

func (i GameServerClusterArray) ToGameServerClusterArrayOutput() GameServerClusterArrayOutput

func (GameServerClusterArray) ToGameServerClusterArrayOutputWithContext 

func (i GameServerClusterArray) ToGameServerClusterArrayOutputWithContext(ctx context.Context) GameServerClusterArrayOutput

type GameServerClusterArrayInput 

type GameServerClusterArrayInput interface {
	pulumi.Input

	ToGameServerClusterArrayOutput() GameServerClusterArrayOutput
	ToGameServerClusterArrayOutputWithContext(context.Context) GameServerClusterArrayOutput
}

GameServerClusterArrayInput is an input type that accepts GameServerClusterArray and GameServerClusterArrayOutput values. You can construct a concrete instance of `GameServerClusterArrayInput` via: 

GameServerClusterArray{ GameServerClusterArgs{...} }

type GameServerClusterArrayOutput 

type GameServerClusterArrayOutput struct{ *pulumi.OutputState }

func (GameServerClusterArrayOutput) ElementType 

func (GameServerClusterArrayOutput) ElementType() reflect.Type

func (GameServerClusterArrayOutput) Index 

func (o GameServerClusterArrayOutput) Index(i pulumi.IntInput) GameServerClusterOutput

func (GameServerClusterArrayOutput) ToGameServerClusterArrayOutput 

func (o GameServerClusterArrayOutput) ToGameServerClusterArrayOutput() GameServerClusterArrayOutput

func (GameServerClusterArrayOutput) ToGameServerClusterArrayOutputWithContext 

func (o GameServerClusterArrayOutput) ToGameServerClusterArrayOutputWithContext(ctx context.Context) GameServerClusterArrayOutput

type GameServerClusterConnectionInfo 

type GameServerClusterConnectionInfo struct {
	// Reference of the GKE cluster where the game servers are installed.
	// Structure is documented below.
	GkeClusterReference GameServerClusterConnectionInfoGkeClusterReference `pulumi:"gkeClusterReference"`
	// Namespace designated on the game server cluster where the game server
	// instances will be created. The namespace existence will be validated
	// during creation.
	Namespace string `pulumi:"namespace"`
}

type GameServerClusterConnectionInfoArgs 

type GameServerClusterConnectionInfoArgs struct {
	// Reference of the GKE cluster where the game servers are installed.
	// Structure is documented below.
	GkeClusterReference GameServerClusterConnectionInfoGkeClusterReferenceInput `pulumi:"gkeClusterReference"`
	// Namespace designated on the game server cluster where the game server
	// instances will be created. The namespace existence will be validated
	// during creation.
	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 {
	// The full or partial name of a GKE cluster, using one of the following
	// forms:
	// * `projects/{project_id}/locations/{location}/clusters/{cluster_id}`
	// * `locations/{location}/clusters/{cluster_id}`
	// * `{cluster_id}`
	//   If project and location are not specified, the project and location of the
	//   GameServerCluster resource are used to generate the full name of the
	//   GKE cluster.
	Cluster string `pulumi:"cluster"`
}

type GameServerClusterConnectionInfoGkeClusterReferenceArgs 

type GameServerClusterConnectionInfoGkeClusterReferenceArgs struct {
	// The full or partial name of a GKE cluster, using one of the following
	// forms:
	// * `projects/{project_id}/locations/{location}/clusters/{cluster_id}`
	// * `locations/{location}/clusters/{cluster_id}`
	// * `{cluster_id}`
	//   If project and location are not specified, the project and location of the
	//   GameServerCluster resource are used to generate the full name of the
	//   GKE cluster.
	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

func (GameServerClusterConnectionInfoGkeClusterReferenceArgs) ToGameServerClusterConnectionInfoGkeClusterReferencePtrOutput 

func (i GameServerClusterConnectionInfoGkeClusterReferenceArgs) ToGameServerClusterConnectionInfoGkeClusterReferencePtrOutput() GameServerClusterConnectionInfoGkeClusterReferencePtrOutput

func (GameServerClusterConnectionInfoGkeClusterReferenceArgs) ToGameServerClusterConnectionInfoGkeClusterReferencePtrOutputWithContext 

func (i GameServerClusterConnectionInfoGkeClusterReferenceArgs) ToGameServerClusterConnectionInfoGkeClusterReferencePtrOutputWithContext(ctx context.Context) GameServerClusterConnectionInfoGkeClusterReferencePtrOutput

type GameServerClusterConnectionInfoGkeClusterReferenceInput 

type GameServerClusterConnectionInfoGkeClusterReferenceInput interface {
	pulumi.Input

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

GameServerClusterConnectionInfoGkeClusterReferenceInput is an input type that accepts GameServerClusterConnectionInfoGkeClusterReferenceArgs and GameServerClusterConnectionInfoGkeClusterReferenceOutput values. You can construct a concrete instance of `GameServerClusterConnectionInfoGkeClusterReferenceInput` via: 

GameServerClusterConnectionInfoGkeClusterReferenceArgs{...}

type GameServerClusterConnectionInfoGkeClusterReferenceOutput 

type GameServerClusterConnectionInfoGkeClusterReferenceOutput struct{ *pulumi.OutputState }

func (GameServerClusterConnectionInfoGkeClusterReferenceOutput) Cluster 

func (o GameServerClusterConnectionInfoGkeClusterReferenceOutput) Cluster() pulumi.StringOutput

The full or partial name of a GKE cluster, using one of the following forms:

  • `projects/{project_id}/locations/{location}/clusters/{cluster_id}`
  • `locations/{location}/clusters/{cluster_id}`
  • `{cluster_id}` If project and location are not specified, the project and location of the GameServerCluster resource are used to generate the full name of the GKE cluster.

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

func (GameServerClusterConnectionInfoGkeClusterReferenceOutput) ToGameServerClusterConnectionInfoGkeClusterReferencePtrOutput 

func (o GameServerClusterConnectionInfoGkeClusterReferenceOutput) ToGameServerClusterConnectionInfoGkeClusterReferencePtrOutput() GameServerClusterConnectionInfoGkeClusterReferencePtrOutput

func (GameServerClusterConnectionInfoGkeClusterReferenceOutput) ToGameServerClusterConnectionInfoGkeClusterReferencePtrOutputWithContext 

func (o GameServerClusterConnectionInfoGkeClusterReferenceOutput) ToGameServerClusterConnectionInfoGkeClusterReferencePtrOutputWithContext(ctx context.Context) GameServerClusterConnectionInfoGkeClusterReferencePtrOutput

type GameServerClusterConnectionInfoGkeClusterReferencePtrInput 

type GameServerClusterConnectionInfoGkeClusterReferencePtrInput interface {
	pulumi.Input

	ToGameServerClusterConnectionInfoGkeClusterReferencePtrOutput() GameServerClusterConnectionInfoGkeClusterReferencePtrOutput
	ToGameServerClusterConnectionInfoGkeClusterReferencePtrOutputWithContext(context.Context) GameServerClusterConnectionInfoGkeClusterReferencePtrOutput
}

GameServerClusterConnectionInfoGkeClusterReferencePtrInput is an input type that accepts GameServerClusterConnectionInfoGkeClusterReferenceArgs, GameServerClusterConnectionInfoGkeClusterReferencePtr and GameServerClusterConnectionInfoGkeClusterReferencePtrOutput values. You can construct a concrete instance of `GameServerClusterConnectionInfoGkeClusterReferencePtrInput` via: 

        GameServerClusterConnectionInfoGkeClusterReferenceArgs{...}

or:

        nil

func GameServerClusterConnectionInfoGkeClusterReferencePtr 

func GameServerClusterConnectionInfoGkeClusterReferencePtr(v *GameServerClusterConnectionInfoGkeClusterReferenceArgs) GameServerClusterConnectionInfoGkeClusterReferencePtrInput

type GameServerClusterConnectionInfoGkeClusterReferencePtrOutput 

type GameServerClusterConnectionInfoGkeClusterReferencePtrOutput struct{ *pulumi.OutputState }

func (GameServerClusterConnectionInfoGkeClusterReferencePtrOutput) Cluster 

func (o GameServerClusterConnectionInfoGkeClusterReferencePtrOutput) Cluster() pulumi.StringPtrOutput

The full or partial name of a GKE cluster, using one of the following forms:

  • `projects/{project_id}/locations/{location}/clusters/{cluster_id}`
  • `locations/{location}/clusters/{cluster_id}`
  • `{cluster_id}` If project and location are not specified, the project and location of the GameServerCluster resource are used to generate the full name of the GKE cluster.

func (GameServerClusterConnectionInfoGkeClusterReferencePtrOutput) Elem 

func (o GameServerClusterConnectionInfoGkeClusterReferencePtrOutput) Elem() GameServerClusterConnectionInfoGkeClusterReferenceOutput

func (GameServerClusterConnectionInfoGkeClusterReferencePtrOutput) ElementType 

func (GameServerClusterConnectionInfoGkeClusterReferencePtrOutput) ElementType() reflect.Type

func (GameServerClusterConnectionInfoGkeClusterReferencePtrOutput) ToGameServerClusterConnectionInfoGkeClusterReferencePtrOutput 

func (o GameServerClusterConnectionInfoGkeClusterReferencePtrOutput) ToGameServerClusterConnectionInfoGkeClusterReferencePtrOutput() GameServerClusterConnectionInfoGkeClusterReferencePtrOutput

func (GameServerClusterConnectionInfoGkeClusterReferencePtrOutput) ToGameServerClusterConnectionInfoGkeClusterReferencePtrOutputWithContext 

func (o GameServerClusterConnectionInfoGkeClusterReferencePtrOutput) ToGameServerClusterConnectionInfoGkeClusterReferencePtrOutputWithContext(ctx context.Context) GameServerClusterConnectionInfoGkeClusterReferencePtrOutput

type GameServerClusterConnectionInfoInput 

type GameServerClusterConnectionInfoInput interface {
	pulumi.Input

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

GameServerClusterConnectionInfoInput is an input type that accepts GameServerClusterConnectionInfoArgs and GameServerClusterConnectionInfoOutput values. You can construct a concrete instance of `GameServerClusterConnectionInfoInput` via: 

GameServerClusterConnectionInfoArgs{...}

type GameServerClusterConnectionInfoOutput 

type GameServerClusterConnectionInfoOutput struct{ *pulumi.OutputState }

func (GameServerClusterConnectionInfoOutput) ElementType 

func (GameServerClusterConnectionInfoOutput) ElementType() reflect.Type

func (GameServerClusterConnectionInfoOutput) GkeClusterReference 

func (o GameServerClusterConnectionInfoOutput) GkeClusterReference() GameServerClusterConnectionInfoGkeClusterReferenceOutput

Reference of the GKE cluster where the game servers are installed. Structure is documented below.

func (GameServerClusterConnectionInfoOutput) Namespace 

func (o GameServerClusterConnectionInfoOutput) Namespace() pulumi.StringOutput

Namespace designated on the game server cluster where the game server instances will be created. The namespace existence will be validated during creation.

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
}

GameServerClusterConnectionInfoPtrInput is an input type that accepts GameServerClusterConnectionInfoArgs, GameServerClusterConnectionInfoPtr and GameServerClusterConnectionInfoPtrOutput values. You can construct a concrete instance of `GameServerClusterConnectionInfoPtrInput` via: 

        GameServerClusterConnectionInfoArgs{...}

or:

        nil

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() GameServerClusterConnectionInfoGkeClusterReferencePtrOutput

Reference of the GKE cluster where the game servers are installed. Structure is documented below.

func (GameServerClusterConnectionInfoPtrOutput) Namespace 

func (o GameServerClusterConnectionInfoPtrOutput) Namespace() pulumi.StringPtrOutput

Namespace designated on the game server cluster where the game server instances will be created. The namespace existence will be validated during creation.

func (GameServerClusterConnectionInfoPtrOutput) ToGameServerClusterConnectionInfoPtrOutput 

func (o GameServerClusterConnectionInfoPtrOutput) ToGameServerClusterConnectionInfoPtrOutput() GameServerClusterConnectionInfoPtrOutput

func (GameServerClusterConnectionInfoPtrOutput) ToGameServerClusterConnectionInfoPtrOutputWithContext 

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

type GameServerClusterInput 

type GameServerClusterInput interface {
	pulumi.Input

	ToGameServerClusterOutput() GameServerClusterOutput
	ToGameServerClusterOutputWithContext(ctx context.Context) GameServerClusterOutput
}

type GameServerClusterMap 

type GameServerClusterMap map[string]GameServerClusterInput

func (GameServerClusterMap) ElementType 

func (GameServerClusterMap) ElementType() reflect.Type

func (GameServerClusterMap) ToGameServerClusterMapOutput 

func (i GameServerClusterMap) ToGameServerClusterMapOutput() GameServerClusterMapOutput

func (GameServerClusterMap) ToGameServerClusterMapOutputWithContext 

func (i GameServerClusterMap) ToGameServerClusterMapOutputWithContext(ctx context.Context) GameServerClusterMapOutput

type GameServerClusterMapInput 

type GameServerClusterMapInput interface {
	pulumi.Input

	ToGameServerClusterMapOutput() GameServerClusterMapOutput
	ToGameServerClusterMapOutputWithContext(context.Context) GameServerClusterMapOutput
}

GameServerClusterMapInput is an input type that accepts GameServerClusterMap and GameServerClusterMapOutput values. You can construct a concrete instance of `GameServerClusterMapInput` via: 

GameServerClusterMap{ "key": GameServerClusterArgs{...} }

type GameServerClusterMapOutput 

type GameServerClusterMapOutput struct{ *pulumi.OutputState }

func (GameServerClusterMapOutput) ElementType 

func (GameServerClusterMapOutput) ElementType() reflect.Type

func (GameServerClusterMapOutput) MapIndex 

func (o GameServerClusterMapOutput) MapIndex(k pulumi.StringInput) GameServerClusterOutput

func (GameServerClusterMapOutput) ToGameServerClusterMapOutput 

func (o GameServerClusterMapOutput) ToGameServerClusterMapOutput() GameServerClusterMapOutput

func (GameServerClusterMapOutput) ToGameServerClusterMapOutputWithContext 

func (o GameServerClusterMapOutput) ToGameServerClusterMapOutputWithContext(ctx context.Context) GameServerClusterMapOutput

type GameServerClusterOutput 

type GameServerClusterOutput struct{ *pulumi.OutputState }

func (GameServerClusterOutput) ElementType 

func (GameServerClusterOutput) ElementType() reflect.Type

func (GameServerClusterOutput) ToGameServerClusterOutput 

func (o GameServerClusterOutput) ToGameServerClusterOutput() GameServerClusterOutput

func (GameServerClusterOutput) ToGameServerClusterOutputWithContext 

func (o GameServerClusterOutput) ToGameServerClusterOutputWithContext(ctx context.Context) GameServerClusterOutput

func (GameServerClusterOutput) ToGameServerClusterPtrOutput 

func (o GameServerClusterOutput) ToGameServerClusterPtrOutput() GameServerClusterPtrOutput

func (GameServerClusterOutput) ToGameServerClusterPtrOutputWithContext 

func (o GameServerClusterOutput) ToGameServerClusterPtrOutputWithContext(ctx context.Context) GameServerClusterPtrOutput

type GameServerClusterPtrInput 

type GameServerClusterPtrInput interface {
	pulumi.Input

	ToGameServerClusterPtrOutput() GameServerClusterPtrOutput
	ToGameServerClusterPtrOutputWithContext(ctx context.Context) GameServerClusterPtrOutput
}

type GameServerClusterPtrOutput 

type GameServerClusterPtrOutput struct{ *pulumi.OutputState }

func (GameServerClusterPtrOutput) Elem added in v5.21.0 

func (o GameServerClusterPtrOutput) Elem() GameServerClusterOutput

func (GameServerClusterPtrOutput) ElementType 

func (GameServerClusterPtrOutput) ElementType() reflect.Type

func (GameServerClusterPtrOutput) ToGameServerClusterPtrOutput 

func (o GameServerClusterPtrOutput) ToGameServerClusterPtrOutput() GameServerClusterPtrOutput

func (GameServerClusterPtrOutput) ToGameServerClusterPtrOutputWithContext 

func (o GameServerClusterPtrOutput) ToGameServerClusterPtrOutputWithContext(ctx context.Context) GameServerClusterPtrOutput

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.
	// Structure is documented below.
	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.
	// Structure is documented below.
	FleetConfigs GameServerConfigFleetConfigArrayOutput `pulumi:"fleetConfigs"`
	// Set of labels to group by.
	Labels pulumi.StringMapOutput `pulumi:"labels"`
	// Location of the Deployment.
	Location pulumi.StringPtrOutput `pulumi:"location"`
	// The name of the ScalingConfig
	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.
	// Structure is documented below.
	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

## Example Usage ### Game Service Config Basic

```go package main

import ( 

"encoding/json"

"github.com/pulumi/pulumi-gcp/sdk/v5/go/gcp/gameservices"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		defaultGameServerDeployment, err := gameservices.NewGameServerDeployment(ctx, "defaultGameServerDeployment", &gameservices.GameServerDeploymentArgs{
			DeploymentId: pulumi.String("tf-test-deployment"),
			Description:  pulumi.String("a deployment description"),
		})
		if err != nil {
			return err
		}
		tmpJSON0, err := json.Marshal(map[string]interface{}{
			"replicas":   1,
			"scheduling": "Packed",
			"template": map[string]interface{}{
				"metadata": map[string]interface{}{
					"name": "tf-test-game-server-template",
				},
				"spec": map[string]interface{}{
					"ports": []map[string]interface{}{
						map[string]interface{}{
							"name":          "default",
							"portPolicy":    "Dynamic",
							"containerPort": 7654,
							"protocol":      "UDP",
						},
					},
					"template": map[string]interface{}{
						"spec": map[string]interface{}{
							"containers": []map[string]interface{}{
								map[string]interface{}{
									"name":  "simple-udp-server",
									"image": "gcr.io/agones-images/udp-server:0.14",
								},
							},
						},
					},
				},
			},
		})
		if err != nil {
			return err
		}
		json0 := string(tmpJSON0)
		tmpJSON1, err := json.Marshal(map[string]interface{}{
			"policy": map[string]interface{}{
				"type": "Webhook",
				"webhook": map[string]interface{}{
					"service": map[string]interface{}{
						"name":      "autoscaler-webhook-service",
						"namespace": "default",
						"path":      "scale",
					},
				},
			},
		})
		if err != nil {
			return err
		}
		json1 := string(tmpJSON1)
		_, err = gameservices.NewGameServerConfig(ctx, "defaultGameServerConfig", &gameservices.GameServerConfigArgs{
			ConfigId:     pulumi.String("tf-test-config"),
			DeploymentId: defaultGameServerDeployment.DeploymentId,
			Description:  pulumi.String("a config description"),
			FleetConfigs: gameservices.GameServerConfigFleetConfigArray{
				&gameservices.GameServerConfigFleetConfigArgs{
					Name:      pulumi.String("something-unique"),
					FleetSpec: pulumi.String(json0),
				},
			},
			ScalingConfigs: gameservices.GameServerConfigScalingConfigArray{
				&gameservices.GameServerConfigScalingConfigArgs{
					Name:                pulumi.String("scaling-config-name"),
					FleetAutoscalerSpec: pulumi.String(json1),
					Selectors: gameservices.GameServerConfigScalingConfigSelectorArray{
						&gameservices.GameServerConfigScalingConfigSelectorArgs{
							Labels: pulumi.StringMap{
								"one": pulumi.String("two"),
							},
						},
					},
					Schedules: gameservices.GameServerConfigScalingConfigScheduleArray{
						&gameservices.GameServerConfigScalingConfigScheduleArgs{
							CronJobDuration: pulumi.String("3.500s"),
							CronSpec:        pulumi.String("0 0 * * 0"),
						},
					},
				},
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

## Import

GameServerConfig can be imported using any of these accepted formats

```sh 

$ pulumi import gcp:gameservices/gameServerConfig:GameServerConfig default projects/{{project}}/locations/{{location}}/gameServerDeployments/{{deployment_id}}/configs/{{config_id}}

```

```sh 

$ pulumi import gcp:gameservices/gameServerConfig:GameServerConfig default {{project}}/{{location}}/{{deployment_id}}/{{config_id}}

```

```sh 

$ pulumi import gcp:gameservices/gameServerConfig:GameServerConfig default {{location}}/{{deployment_id}}/{{config_id}}

```

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.

func (*GameServerConfig) ElementType 

func (*GameServerConfig) ElementType() reflect.Type

func (*GameServerConfig) ToGameServerConfigOutput 

func (i *GameServerConfig) ToGameServerConfigOutput() GameServerConfigOutput

func (*GameServerConfig) ToGameServerConfigOutputWithContext 

func (i *GameServerConfig) ToGameServerConfigOutputWithContext(ctx context.Context) GameServerConfigOutput

func (*GameServerConfig) ToGameServerConfigPtrOutput 

func (i *GameServerConfig) ToGameServerConfigPtrOutput() GameServerConfigPtrOutput

func (*GameServerConfig) ToGameServerConfigPtrOutputWithContext 

func (i *GameServerConfig) ToGameServerConfigPtrOutputWithContext(ctx context.Context) GameServerConfigPtrOutput

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.
	// Structure is documented below.
	FleetConfigs GameServerConfigFleetConfigArrayInput
	// Set of labels to group by.
	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.
	// Structure is documented below.
	ScalingConfigs GameServerConfigScalingConfigArrayInput
}

The set of arguments for constructing a GameServerConfig resource.

func (GameServerConfigArgs) ElementType 

func (GameServerConfigArgs) ElementType() reflect.Type

type GameServerConfigArray 

type GameServerConfigArray []GameServerConfigInput

func (GameServerConfigArray) ElementType 

func (GameServerConfigArray) ElementType() reflect.Type

func (GameServerConfigArray) ToGameServerConfigArrayOutput 

func (i GameServerConfigArray) ToGameServerConfigArrayOutput() GameServerConfigArrayOutput

func (GameServerConfigArray) ToGameServerConfigArrayOutputWithContext 

func (i GameServerConfigArray) ToGameServerConfigArrayOutputWithContext(ctx context.Context) GameServerConfigArrayOutput

type GameServerConfigArrayInput 

type GameServerConfigArrayInput interface {
	pulumi.Input

	ToGameServerConfigArrayOutput() GameServerConfigArrayOutput
	ToGameServerConfigArrayOutputWithContext(context.Context) GameServerConfigArrayOutput
}

GameServerConfigArrayInput is an input type that accepts GameServerConfigArray and GameServerConfigArrayOutput values. You can construct a concrete instance of `GameServerConfigArrayInput` via: 

GameServerConfigArray{ GameServerConfigArgs{...} }

type GameServerConfigArrayOutput 

type GameServerConfigArrayOutput struct{ *pulumi.OutputState }

func (GameServerConfigArrayOutput) ElementType 

func (GameServerConfigArrayOutput) ElementType() reflect.Type

func (GameServerConfigArrayOutput) Index 

func (o GameServerConfigArrayOutput) Index(i pulumi.IntInput) GameServerConfigOutput

func (GameServerConfigArrayOutput) ToGameServerConfigArrayOutput 

func (o GameServerConfigArrayOutput) ToGameServerConfigArrayOutput() GameServerConfigArrayOutput

func (GameServerConfigArrayOutput) ToGameServerConfigArrayOutputWithContext 

func (o GameServerConfigArrayOutput) ToGameServerConfigArrayOutputWithContext(ctx context.Context) GameServerConfigArrayOutput

type GameServerConfigFleetConfig 

type GameServerConfigFleetConfig struct {
	// The fleet spec, which is sent to Agones to configure fleet.
	// The spec can be passed as inline json but it is recommended to use a file reference
	// instead. File references can contain the json or yaml format of the fleet spec. Eg:
	// * fleetSpec = jsonencode(yamldecode(file("fleet_configs.yaml")))
	// * fleetSpec = file("fleet_configs.json")
	//   The format of the spec can be found :
	//   `https://agones.dev/site/docs/reference/fleet/`.
	FleetSpec string `pulumi:"fleetSpec"`
	// The name of the ScalingConfig
	Name *string `pulumi:"name"`
}

type GameServerConfigFleetConfigArgs 

type GameServerConfigFleetConfigArgs struct {
	// The fleet spec, which is sent to Agones to configure fleet.
	// The spec can be passed as inline json but it is recommended to use a file reference
	// instead. File references can contain the json or yaml format of the fleet spec. Eg:
	// * fleetSpec = jsonencode(yamldecode(file("fleet_configs.yaml")))
	// * fleetSpec = file("fleet_configs.json")
	//   The format of the spec can be found :
	//   `https://agones.dev/site/docs/reference/fleet/`.
	FleetSpec pulumi.StringInput `pulumi:"fleetSpec"`
	// The name of the ScalingConfig
	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
}

GameServerConfigFleetConfigArrayInput is an input type that accepts GameServerConfigFleetConfigArray and GameServerConfigFleetConfigArrayOutput values. You can construct a concrete instance of `GameServerConfigFleetConfigArrayInput` via: 

GameServerConfigFleetConfigArray{ GameServerConfigFleetConfigArgs{...} }

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
}

GameServerConfigFleetConfigInput is an input type that accepts GameServerConfigFleetConfigArgs and GameServerConfigFleetConfigOutput values. You can construct a concrete instance of `GameServerConfigFleetConfigInput` via: 

GameServerConfigFleetConfigArgs{...}

type GameServerConfigFleetConfigOutput 

type GameServerConfigFleetConfigOutput struct{ *pulumi.OutputState }

func (GameServerConfigFleetConfigOutput) ElementType 

func (GameServerConfigFleetConfigOutput) ElementType() reflect.Type

func (GameServerConfigFleetConfigOutput) FleetSpec 

func (o GameServerConfigFleetConfigOutput) FleetSpec() pulumi.StringOutput

The fleet spec, which is sent to Agones to configure fleet. The spec can be passed as inline json but it is recommended to use a file reference instead. File references can contain the json or yaml format of the fleet spec. Eg:

func (GameServerConfigFleetConfigOutput) Name 

func (o GameServerConfigFleetConfigOutput) Name() pulumi.StringPtrOutput

The name of the ScalingConfig

func (GameServerConfigFleetConfigOutput) ToGameServerConfigFleetConfigOutput 

func (o GameServerConfigFleetConfigOutput) ToGameServerConfigFleetConfigOutput() GameServerConfigFleetConfigOutput

func (GameServerConfigFleetConfigOutput) ToGameServerConfigFleetConfigOutputWithContext 

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

type GameServerConfigInput 

type GameServerConfigInput interface {
	pulumi.Input

	ToGameServerConfigOutput() GameServerConfigOutput
	ToGameServerConfigOutputWithContext(ctx context.Context) GameServerConfigOutput
}

type GameServerConfigMap 

type GameServerConfigMap map[string]GameServerConfigInput

func (GameServerConfigMap) ElementType 

func (GameServerConfigMap) ElementType() reflect.Type

func (GameServerConfigMap) ToGameServerConfigMapOutput 

func (i GameServerConfigMap) ToGameServerConfigMapOutput() GameServerConfigMapOutput

func (GameServerConfigMap) ToGameServerConfigMapOutputWithContext 

func (i GameServerConfigMap) ToGameServerConfigMapOutputWithContext(ctx context.Context) GameServerConfigMapOutput

type GameServerConfigMapInput 

type GameServerConfigMapInput interface {
	pulumi.Input

	ToGameServerConfigMapOutput() GameServerConfigMapOutput
	ToGameServerConfigMapOutputWithContext(context.Context) GameServerConfigMapOutput
}

GameServerConfigMapInput is an input type that accepts GameServerConfigMap and GameServerConfigMapOutput values. You can construct a concrete instance of `GameServerConfigMapInput` via: 

GameServerConfigMap{ "key": GameServerConfigArgs{...} }

type GameServerConfigMapOutput 

type GameServerConfigMapOutput struct{ *pulumi.OutputState }

func (GameServerConfigMapOutput) ElementType 

func (GameServerConfigMapOutput) ElementType() reflect.Type

func (GameServerConfigMapOutput) MapIndex 

func (o GameServerConfigMapOutput) MapIndex(k pulumi.StringInput) GameServerConfigOutput

func (GameServerConfigMapOutput) ToGameServerConfigMapOutput 

func (o GameServerConfigMapOutput) ToGameServerConfigMapOutput() GameServerConfigMapOutput

func (GameServerConfigMapOutput) ToGameServerConfigMapOutputWithContext 

func (o GameServerConfigMapOutput) ToGameServerConfigMapOutputWithContext(ctx context.Context) GameServerConfigMapOutput

type GameServerConfigOutput 

type GameServerConfigOutput struct{ *pulumi.OutputState }

func (GameServerConfigOutput) ElementType 

func (GameServerConfigOutput) ElementType() reflect.Type

func (GameServerConfigOutput) ToGameServerConfigOutput 

func (o GameServerConfigOutput) ToGameServerConfigOutput() GameServerConfigOutput

func (GameServerConfigOutput) ToGameServerConfigOutputWithContext 

func (o GameServerConfigOutput) ToGameServerConfigOutputWithContext(ctx context.Context) GameServerConfigOutput

func (GameServerConfigOutput) ToGameServerConfigPtrOutput 

func (o GameServerConfigOutput) ToGameServerConfigPtrOutput() GameServerConfigPtrOutput

func (GameServerConfigOutput) ToGameServerConfigPtrOutputWithContext 

func (o GameServerConfigOutput) ToGameServerConfigPtrOutputWithContext(ctx context.Context) GameServerConfigPtrOutput

type GameServerConfigPtrInput 

type GameServerConfigPtrInput interface {
	pulumi.Input

	ToGameServerConfigPtrOutput() GameServerConfigPtrOutput
	ToGameServerConfigPtrOutputWithContext(ctx context.Context) GameServerConfigPtrOutput
}

type GameServerConfigPtrOutput 

type GameServerConfigPtrOutput struct{ *pulumi.OutputState }

func (GameServerConfigPtrOutput) Elem added in v5.21.0 

func (o GameServerConfigPtrOutput) Elem() GameServerConfigOutput

func (GameServerConfigPtrOutput) ElementType 

func (GameServerConfigPtrOutput) ElementType() reflect.Type

func (GameServerConfigPtrOutput) ToGameServerConfigPtrOutput 

func (o GameServerConfigPtrOutput) ToGameServerConfigPtrOutput() GameServerConfigPtrOutput

func (GameServerConfigPtrOutput) ToGameServerConfigPtrOutputWithContext 

func (o GameServerConfigPtrOutput) ToGameServerConfigPtrOutputWithContext(ctx context.Context) GameServerConfigPtrOutput

type GameServerConfigScalingConfig 

type GameServerConfigScalingConfig struct {
	// Fleet autoscaler spec, which is sent to Agones.
	// Example spec can be found :
	// https://agones.dev/site/docs/reference/fleetautoscaler/
	FleetAutoscalerSpec string `pulumi:"fleetAutoscalerSpec"`
	// The name of the ScalingConfig
	Name string `pulumi:"name"`
	// The schedules to which this scaling config applies.
	// Structure is documented below.
	Schedules []GameServerConfigScalingConfigSchedule `pulumi:"schedules"`
	// Labels used to identify the clusters to which this scaling config
	// applies. A cluster is subject to this scaling config if its labels match
	// any of the selector entries.
	// Structure is documented below.
	Selectors []GameServerConfigScalingConfigSelector `pulumi:"selectors"`
}

type GameServerConfigScalingConfigArgs 

type GameServerConfigScalingConfigArgs struct {
	// Fleet autoscaler spec, which is sent to Agones.
	// Example spec can be found :
	// https://agones.dev/site/docs/reference/fleetautoscaler/
	FleetAutoscalerSpec pulumi.StringInput `pulumi:"fleetAutoscalerSpec"`
	// The name of the ScalingConfig
	Name pulumi.StringInput `pulumi:"name"`
	// The schedules to which this scaling config applies.
	// Structure is documented below.
	Schedules GameServerConfigScalingConfigScheduleArrayInput `pulumi:"schedules"`
	// Labels used to identify the clusters to which this scaling config
	// applies. A cluster is subject to this scaling config if its labels match
	// any of the selector entries.
	// Structure is documented below.
	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
}

GameServerConfigScalingConfigArrayInput is an input type that accepts GameServerConfigScalingConfigArray and GameServerConfigScalingConfigArrayOutput values. You can construct a concrete instance of `GameServerConfigScalingConfigArrayInput` via: 

GameServerConfigScalingConfigArray{ GameServerConfigScalingConfigArgs{...} }

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
}

GameServerConfigScalingConfigInput is an input type that accepts GameServerConfigScalingConfigArgs and GameServerConfigScalingConfigOutput values. You can construct a concrete instance of `GameServerConfigScalingConfigInput` via: 

GameServerConfigScalingConfigArgs{...}

type GameServerConfigScalingConfigOutput 

type GameServerConfigScalingConfigOutput struct{ *pulumi.OutputState }

func (GameServerConfigScalingConfigOutput) ElementType 

func (GameServerConfigScalingConfigOutput) ElementType() reflect.Type

func (GameServerConfigScalingConfigOutput) FleetAutoscalerSpec 

func (o GameServerConfigScalingConfigOutput) FleetAutoscalerSpec() pulumi.StringOutput

Fleet autoscaler spec, which is sent to Agones. Example spec can be found : https://agones.dev/site/docs/reference/fleetautoscaler/

func (GameServerConfigScalingConfigOutput) Name 

func (o GameServerConfigScalingConfigOutput) Name() pulumi.StringOutput

The name of the ScalingConfig

func (GameServerConfigScalingConfigOutput) Schedules 

func (o GameServerConfigScalingConfigOutput) Schedules() GameServerConfigScalingConfigScheduleArrayOutput

The schedules to which this scaling config applies. Structure is documented below.

func (GameServerConfigScalingConfigOutput) Selectors 

func (o GameServerConfigScalingConfigOutput) Selectors() GameServerConfigScalingConfigSelectorArrayOutput

Labels used to identify the clusters to which this scaling config applies. A cluster is subject to this scaling config if its labels match any of the selector entries. Structure is documented below.

func (GameServerConfigScalingConfigOutput) ToGameServerConfigScalingConfigOutput 

func (o GameServerConfigScalingConfigOutput) ToGameServerConfigScalingConfigOutput() GameServerConfigScalingConfigOutput

func (GameServerConfigScalingConfigOutput) ToGameServerConfigScalingConfigOutputWithContext 

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

type GameServerConfigScalingConfigSchedule 

type GameServerConfigScalingConfigSchedule struct {
	// The duration for the cron job event. The duration of the event is effective
	// after the cron job's start time.
	// A duration in seconds with up to nine fractional digits, terminated by 's'. Example: "3.5s".
	CronJobDuration *string `pulumi:"cronJobDuration"`
	// The cron definition of the scheduled event. See
	// https://en.wikipedia.org/wiki/Cron. Cron spec specifies the local time as
	// defined by the realm.
	CronSpec *string `pulumi:"cronSpec"`
	// The end time of the event.
	// A timestamp in RFC3339 UTC "Zulu" format, accurate to nanoseconds. Example: "2014-10-02T15:01:23.045123456Z".
	EndTime *string `pulumi:"endTime"`
	// The start time of the event.
	// A timestamp in RFC3339 UTC "Zulu" format, accurate to nanoseconds. Example: "2014-10-02T15:01:23.045123456Z".
	StartTime *string `pulumi:"startTime"`
}

type GameServerConfigScalingConfigScheduleArgs 

type GameServerConfigScalingConfigScheduleArgs struct {
	// The duration for the cron job event. The duration of the event is effective
	// after the cron job's start time.
	// A duration in seconds with up to nine fractional digits, terminated by 's'. Example: "3.5s".
	CronJobDuration pulumi.StringPtrInput `pulumi:"cronJobDuration"`
	// The cron definition of the scheduled event. See
	// https://en.wikipedia.org/wiki/Cron. Cron spec specifies the local time as
	// defined by the realm.
	CronSpec pulumi.StringPtrInput `pulumi:"cronSpec"`
	// The end time of the event.
	// A timestamp in RFC3339 UTC "Zulu" format, accurate to nanoseconds. Example: "2014-10-02T15:01:23.045123456Z".
	EndTime pulumi.StringPtrInput `pulumi:"endTime"`
	// The start time of the event.
	// A timestamp in RFC3339 UTC "Zulu" format, accurate to nanoseconds. Example: "2014-10-02T15:01:23.045123456Z".
	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
}

GameServerConfigScalingConfigScheduleArrayInput is an input type that accepts GameServerConfigScalingConfigScheduleArray and GameServerConfigScalingConfigScheduleArrayOutput values. You can construct a concrete instance of `GameServerConfigScalingConfigScheduleArrayInput` via: 

GameServerConfigScalingConfigScheduleArray{ GameServerConfigScalingConfigScheduleArgs{...} }

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
}

GameServerConfigScalingConfigScheduleInput is an input type that accepts GameServerConfigScalingConfigScheduleArgs and GameServerConfigScalingConfigScheduleOutput values. You can construct a concrete instance of `GameServerConfigScalingConfigScheduleInput` via: 

GameServerConfigScalingConfigScheduleArgs{...}

type GameServerConfigScalingConfigScheduleOutput 

type GameServerConfigScalingConfigScheduleOutput struct{ *pulumi.OutputState }

func (GameServerConfigScalingConfigScheduleOutput) CronJobDuration 

func (o GameServerConfigScalingConfigScheduleOutput) CronJobDuration() pulumi.StringPtrOutput

The duration for the cron job event. The duration of the event is effective after the cron job's start time. A duration in seconds with up to nine fractional digits, terminated by 's'. Example: "3.5s".

func (GameServerConfigScalingConfigScheduleOutput) CronSpec 

func (o GameServerConfigScalingConfigScheduleOutput) CronSpec() pulumi.StringPtrOutput

The cron definition of the scheduled event. See https://en.wikipedia.org/wiki/Cron. Cron spec specifies the local time as defined by the realm.

func (GameServerConfigScalingConfigScheduleOutput) ElementType 

func (GameServerConfigScalingConfigScheduleOutput) ElementType() reflect.Type

func (GameServerConfigScalingConfigScheduleOutput) EndTime 

func (o GameServerConfigScalingConfigScheduleOutput) EndTime() pulumi.StringPtrOutput

The end time of the event. A timestamp in RFC3339 UTC "Zulu" format, accurate to nanoseconds. Example: "2014-10-02T15:01:23.045123456Z".

func (GameServerConfigScalingConfigScheduleOutput) StartTime 

func (o GameServerConfigScalingConfigScheduleOutput) StartTime() pulumi.StringPtrOutput

The start time of the event. A timestamp in RFC3339 UTC "Zulu" format, accurate to nanoseconds. Example: "2014-10-02T15:01:23.045123456Z".

func (GameServerConfigScalingConfigScheduleOutput) ToGameServerConfigScalingConfigScheduleOutput 

func (o GameServerConfigScalingConfigScheduleOutput) ToGameServerConfigScalingConfigScheduleOutput() GameServerConfigScalingConfigScheduleOutput

func (GameServerConfigScalingConfigScheduleOutput) ToGameServerConfigScalingConfigScheduleOutputWithContext 

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

type GameServerConfigScalingConfigSelector 

type GameServerConfigScalingConfigSelector struct {
	// Set of labels to group by.
	Labels map[string]string `pulumi:"labels"`
}

type GameServerConfigScalingConfigSelectorArgs 

type GameServerConfigScalingConfigSelectorArgs struct {
	// Set of labels to group by.
	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
}

GameServerConfigScalingConfigSelectorArrayInput is an input type that accepts GameServerConfigScalingConfigSelectorArray and GameServerConfigScalingConfigSelectorArrayOutput values. You can construct a concrete instance of `GameServerConfigScalingConfigSelectorArrayInput` via: 

GameServerConfigScalingConfigSelectorArray{ GameServerConfigScalingConfigSelectorArgs{...} }

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
}

GameServerConfigScalingConfigSelectorInput is an input type that accepts GameServerConfigScalingConfigSelectorArgs and GameServerConfigScalingConfigSelectorOutput values. You can construct a concrete instance of `GameServerConfigScalingConfigSelectorInput` via: 

GameServerConfigScalingConfigSelectorArgs{...}

type GameServerConfigScalingConfigSelectorOutput 

type GameServerConfigScalingConfigSelectorOutput struct{ *pulumi.OutputState }

func (GameServerConfigScalingConfigSelectorOutput) ElementType 

func (GameServerConfigScalingConfigSelectorOutput) ElementType() reflect.Type

func (GameServerConfigScalingConfigSelectorOutput) Labels 

func (o GameServerConfigScalingConfigSelectorOutput) Labels() pulumi.StringMapOutput

Set of labels to group by.

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.
	// Structure is documented below.
	FleetConfigs GameServerConfigFleetConfigArrayInput
	// Set of labels to group by.
	Labels pulumi.StringMapInput
	// Location of the Deployment.
	Location pulumi.StringPtrInput
	// The name of the ScalingConfig
	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.
	// Structure is documented below.
	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

## Example Usage ### Game Service Deployment Basic

```go package main

import ( 

"github.com/pulumi/pulumi-gcp/sdk/v5/go/gcp/gameservices"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := gameservices.NewGameServerDeployment(ctx, "_default", &gameservices.GameServerDeploymentArgs{
			DeploymentId: pulumi.String("tf-test-deployment"),
			Description:  pulumi.String("a deployment description"),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

## Import

GameServerDeployment can be imported using any of these accepted formats

```sh 

$ pulumi import gcp:gameservices/gameServerDeployment:GameServerDeployment default projects/{{project}}/locations/{{location}}/gameServerDeployments/{{deployment_id}}

```

```sh 

$ pulumi import gcp:gameservices/gameServerDeployment:GameServerDeployment default {{project}}/{{location}}/{{deployment_id}}

```

```sh 

$ pulumi import gcp:gameservices/gameServerDeployment:GameServerDeployment default {{location}}/{{deployment_id}}

```

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.

func (*GameServerDeployment) ElementType 

func (*GameServerDeployment) ElementType() reflect.Type

func (*GameServerDeployment) ToGameServerDeploymentOutput 

func (i *GameServerDeployment) ToGameServerDeploymentOutput() GameServerDeploymentOutput

func (*GameServerDeployment) ToGameServerDeploymentOutputWithContext 

func (i *GameServerDeployment) ToGameServerDeploymentOutputWithContext(ctx context.Context) GameServerDeploymentOutput

func (*GameServerDeployment) ToGameServerDeploymentPtrOutput 

func (i *GameServerDeployment) ToGameServerDeploymentPtrOutput() GameServerDeploymentPtrOutput

func (*GameServerDeployment) ToGameServerDeploymentPtrOutputWithContext 

func (i *GameServerDeployment) ToGameServerDeploymentPtrOutputWithContext(ctx context.Context) GameServerDeploymentPtrOutput

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 GameServerDeploymentArray 

type GameServerDeploymentArray []GameServerDeploymentInput

func (GameServerDeploymentArray) ElementType 

func (GameServerDeploymentArray) ElementType() reflect.Type

func (GameServerDeploymentArray) ToGameServerDeploymentArrayOutput 

func (i GameServerDeploymentArray) ToGameServerDeploymentArrayOutput() GameServerDeploymentArrayOutput

func (GameServerDeploymentArray) ToGameServerDeploymentArrayOutputWithContext 

func (i GameServerDeploymentArray) ToGameServerDeploymentArrayOutputWithContext(ctx context.Context) GameServerDeploymentArrayOutput

type GameServerDeploymentArrayInput 

type GameServerDeploymentArrayInput interface {
	pulumi.Input

	ToGameServerDeploymentArrayOutput() GameServerDeploymentArrayOutput
	ToGameServerDeploymentArrayOutputWithContext(context.Context) GameServerDeploymentArrayOutput
}

GameServerDeploymentArrayInput is an input type that accepts GameServerDeploymentArray and GameServerDeploymentArrayOutput values. You can construct a concrete instance of `GameServerDeploymentArrayInput` via: 

GameServerDeploymentArray{ GameServerDeploymentArgs{...} }

type GameServerDeploymentArrayOutput 

type GameServerDeploymentArrayOutput struct{ *pulumi.OutputState }

func (GameServerDeploymentArrayOutput) ElementType 

func (GameServerDeploymentArrayOutput) ElementType() reflect.Type

func (GameServerDeploymentArrayOutput) Index 

func (o GameServerDeploymentArrayOutput) Index(i pulumi.IntInput) GameServerDeploymentOutput

func (GameServerDeploymentArrayOutput) ToGameServerDeploymentArrayOutput 

func (o GameServerDeploymentArrayOutput) ToGameServerDeploymentArrayOutput() GameServerDeploymentArrayOutput

func (GameServerDeploymentArrayOutput) ToGameServerDeploymentArrayOutputWithContext 

func (o GameServerDeploymentArrayOutput) ToGameServerDeploymentArrayOutputWithContext(ctx context.Context) GameServerDeploymentArrayOutput

type GameServerDeploymentInput 

type GameServerDeploymentInput interface {
	pulumi.Input

	ToGameServerDeploymentOutput() GameServerDeploymentOutput
	ToGameServerDeploymentOutputWithContext(ctx context.Context) GameServerDeploymentOutput
}

type GameServerDeploymentMap 

type GameServerDeploymentMap map[string]GameServerDeploymentInput

func (GameServerDeploymentMap) ElementType 

func (GameServerDeploymentMap) ElementType() reflect.Type

func (GameServerDeploymentMap) ToGameServerDeploymentMapOutput 

func (i GameServerDeploymentMap) ToGameServerDeploymentMapOutput() GameServerDeploymentMapOutput

func (GameServerDeploymentMap) ToGameServerDeploymentMapOutputWithContext 

func (i GameServerDeploymentMap) ToGameServerDeploymentMapOutputWithContext(ctx context.Context) GameServerDeploymentMapOutput

type GameServerDeploymentMapInput 

type GameServerDeploymentMapInput interface {
	pulumi.Input

	ToGameServerDeploymentMapOutput() GameServerDeploymentMapOutput
	ToGameServerDeploymentMapOutputWithContext(context.Context) GameServerDeploymentMapOutput
}

GameServerDeploymentMapInput is an input type that accepts GameServerDeploymentMap and GameServerDeploymentMapOutput values. You can construct a concrete instance of `GameServerDeploymentMapInput` via: 

GameServerDeploymentMap{ "key": GameServerDeploymentArgs{...} }

type GameServerDeploymentMapOutput 

type GameServerDeploymentMapOutput struct{ *pulumi.OutputState }

func (GameServerDeploymentMapOutput) ElementType 

func (GameServerDeploymentMapOutput) ElementType() reflect.Type

func (GameServerDeploymentMapOutput) MapIndex 

func (o GameServerDeploymentMapOutput) MapIndex(k pulumi.StringInput) GameServerDeploymentOutput

func (GameServerDeploymentMapOutput) ToGameServerDeploymentMapOutput 

func (o GameServerDeploymentMapOutput) ToGameServerDeploymentMapOutput() GameServerDeploymentMapOutput

func (GameServerDeploymentMapOutput) ToGameServerDeploymentMapOutputWithContext 

func (o GameServerDeploymentMapOutput) ToGameServerDeploymentMapOutputWithContext(ctx context.Context) GameServerDeploymentMapOutput

type GameServerDeploymentOutput 

type GameServerDeploymentOutput struct{ *pulumi.OutputState }

func (GameServerDeploymentOutput) ElementType 

func (GameServerDeploymentOutput) ElementType() reflect.Type

func (GameServerDeploymentOutput) ToGameServerDeploymentOutput 

func (o GameServerDeploymentOutput) ToGameServerDeploymentOutput() GameServerDeploymentOutput

func (GameServerDeploymentOutput) ToGameServerDeploymentOutputWithContext 

func (o GameServerDeploymentOutput) ToGameServerDeploymentOutputWithContext(ctx context.Context) GameServerDeploymentOutput

func (GameServerDeploymentOutput) ToGameServerDeploymentPtrOutput 

func (o GameServerDeploymentOutput) ToGameServerDeploymentPtrOutput() GameServerDeploymentPtrOutput

func (GameServerDeploymentOutput) ToGameServerDeploymentPtrOutputWithContext 

func (o GameServerDeploymentOutput) ToGameServerDeploymentPtrOutputWithContext(ctx context.Context) GameServerDeploymentPtrOutput

type GameServerDeploymentPtrInput 

type GameServerDeploymentPtrInput interface {
	pulumi.Input

	ToGameServerDeploymentPtrOutput() GameServerDeploymentPtrOutput
	ToGameServerDeploymentPtrOutputWithContext(ctx context.Context) GameServerDeploymentPtrOutput
}

type GameServerDeploymentPtrOutput 

type GameServerDeploymentPtrOutput struct{ *pulumi.OutputState }

func (GameServerDeploymentPtrOutput) Elem added in v5.21.0 

func (o GameServerDeploymentPtrOutput) Elem() GameServerDeploymentOutput

func (GameServerDeploymentPtrOutput) ElementType 

func (GameServerDeploymentPtrOutput) ElementType() reflect.Type

func (GameServerDeploymentPtrOutput) ToGameServerDeploymentPtrOutput 

func (o GameServerDeploymentPtrOutput) ToGameServerDeploymentPtrOutput() GameServerDeploymentPtrOutput

func (GameServerDeploymentPtrOutput) ToGameServerDeploymentPtrOutputWithContext 

func (o GameServerDeploymentPtrOutput) ToGameServerDeploymentPtrOutputWithContext(ctx context.Context) GameServerDeploymentPtrOutput

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 gameServerConfigOverrides 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.
	// Structure is documented below.
	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

## Example Usage ### Game Service Deployment Rollout Basic

```go package main

import ( 

"encoding/json"

"github.com/pulumi/pulumi-gcp/sdk/v5/go/gcp/gameservices"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		defaultGameServerDeployment, err := gameservices.NewGameServerDeployment(ctx, "defaultGameServerDeployment", &gameservices.GameServerDeploymentArgs{
			DeploymentId: pulumi.String("tf-test-deployment"),
			Description:  pulumi.String("a deployment description"),
		})
		if err != nil {
			return err
		}
		tmpJSON0, err := json.Marshal(map[string]interface{}{
			"replicas":   1,
			"scheduling": "Packed",
			"template": map[string]interface{}{
				"metadata": map[string]interface{}{
					"name": "tf-test-game-server-template",
				},
				"spec": map[string]interface{}{
					"ports": []map[string]interface{}{
						map[string]interface{}{
							"name":          "default",
							"portPolicy":    "Dynamic",
							"containerPort": 7654,
							"protocol":      "UDP",
						},
					},
					"template": map[string]interface{}{
						"spec": map[string]interface{}{
							"containers": []map[string]interface{}{
								map[string]interface{}{
									"name":  "simple-udp-server",
									"image": "gcr.io/agones-images/udp-server:0.14",
								},
							},
						},
					},
				},
			},
		})
		if err != nil {
			return err
		}
		json0 := string(tmpJSON0)
		defaultGameServerConfig, err := gameservices.NewGameServerConfig(ctx, "defaultGameServerConfig", &gameservices.GameServerConfigArgs{
			ConfigId:     pulumi.String("tf-test-config"),
			DeploymentId: defaultGameServerDeployment.DeploymentId,
			Description:  pulumi.String("a config description"),
			FleetConfigs: gameservices.GameServerConfigFleetConfigArray{
				&gameservices.GameServerConfigFleetConfigArgs{
					Name:      pulumi.String("some-non-guid"),
					FleetSpec: pulumi.String(json0),
				},
			},
		})
		if err != nil {
			return err
		}
		_, err = gameservices.NewGameServerDeploymentRollout(ctx, "defaultGameServerDeploymentRollout", &gameservices.GameServerDeploymentRolloutArgs{
			DeploymentId:            defaultGameServerDeployment.DeploymentId,
			DefaultGameServerConfig: defaultGameServerConfig.Name,
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

## Import

GameServerDeploymentRollout can be imported using any of these accepted formats

```sh 

$ pulumi import gcp:gameservices/gameServerDeploymentRollout:GameServerDeploymentRollout default projects/{{project}}/locations/global/gameServerDeployments/{{deployment_id}}/rollout

```

```sh 

$ pulumi import gcp:gameservices/gameServerDeploymentRollout:GameServerDeploymentRollout default {{project}}/{{deployment_id}}

```

```sh 

$ pulumi import gcp:gameservices/gameServerDeploymentRollout:GameServerDeploymentRollout default {{deployment_id}}

```

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.

func (*GameServerDeploymentRollout) ElementType 

func (*GameServerDeploymentRollout) ElementType() reflect.Type

func (*GameServerDeploymentRollout) ToGameServerDeploymentRolloutOutput 

func (i *GameServerDeploymentRollout) ToGameServerDeploymentRolloutOutput() GameServerDeploymentRolloutOutput

func (*GameServerDeploymentRollout) ToGameServerDeploymentRolloutOutputWithContext 

func (i *GameServerDeploymentRollout) ToGameServerDeploymentRolloutOutputWithContext(ctx context.Context) GameServerDeploymentRolloutOutput

func (*GameServerDeploymentRollout) ToGameServerDeploymentRolloutPtrOutput 

func (i *GameServerDeploymentRollout) ToGameServerDeploymentRolloutPtrOutput() GameServerDeploymentRolloutPtrOutput

func (*GameServerDeploymentRollout) ToGameServerDeploymentRolloutPtrOutputWithContext 

func (i *GameServerDeploymentRollout) ToGameServerDeploymentRolloutPtrOutputWithContext(ctx context.Context) GameServerDeploymentRolloutPtrOutput

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 gameServerConfigOverrides 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.
	// Structure is documented below.
	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 GameServerDeploymentRolloutArray 

type GameServerDeploymentRolloutArray []GameServerDeploymentRolloutInput

func (GameServerDeploymentRolloutArray) ElementType 

func (GameServerDeploymentRolloutArray) ElementType() reflect.Type

func (GameServerDeploymentRolloutArray) ToGameServerDeploymentRolloutArrayOutput 

func (i GameServerDeploymentRolloutArray) ToGameServerDeploymentRolloutArrayOutput() GameServerDeploymentRolloutArrayOutput

func (GameServerDeploymentRolloutArray) ToGameServerDeploymentRolloutArrayOutputWithContext 

func (i GameServerDeploymentRolloutArray) ToGameServerDeploymentRolloutArrayOutputWithContext(ctx context.Context) GameServerDeploymentRolloutArrayOutput

type GameServerDeploymentRolloutArrayInput 

type GameServerDeploymentRolloutArrayInput interface {
	pulumi.Input

	ToGameServerDeploymentRolloutArrayOutput() GameServerDeploymentRolloutArrayOutput
	ToGameServerDeploymentRolloutArrayOutputWithContext(context.Context) GameServerDeploymentRolloutArrayOutput
}

GameServerDeploymentRolloutArrayInput is an input type that accepts GameServerDeploymentRolloutArray and GameServerDeploymentRolloutArrayOutput values. You can construct a concrete instance of `GameServerDeploymentRolloutArrayInput` via: 

GameServerDeploymentRolloutArray{ GameServerDeploymentRolloutArgs{...} }

type GameServerDeploymentRolloutArrayOutput 

type GameServerDeploymentRolloutArrayOutput struct{ *pulumi.OutputState }

func (GameServerDeploymentRolloutArrayOutput) ElementType 

func (GameServerDeploymentRolloutArrayOutput) ElementType() reflect.Type

func (GameServerDeploymentRolloutArrayOutput) Index 

func (o GameServerDeploymentRolloutArrayOutput) Index(i pulumi.IntInput) GameServerDeploymentRolloutOutput

func (GameServerDeploymentRolloutArrayOutput) ToGameServerDeploymentRolloutArrayOutput 

func (o GameServerDeploymentRolloutArrayOutput) ToGameServerDeploymentRolloutArrayOutput() GameServerDeploymentRolloutArrayOutput

func (GameServerDeploymentRolloutArrayOutput) ToGameServerDeploymentRolloutArrayOutputWithContext 

func (o GameServerDeploymentRolloutArrayOutput) ToGameServerDeploymentRolloutArrayOutputWithContext(ctx context.Context) GameServerDeploymentRolloutArrayOutput

type GameServerDeploymentRolloutGameServerConfigOverride 

type GameServerDeploymentRolloutGameServerConfigOverride struct {
	// Version of the configuration.
	ConfigVersion *string `pulumi:"configVersion"`
	// Selection by realms.
	// Structure is documented below.
	RealmsSelector *GameServerDeploymentRolloutGameServerConfigOverrideRealmsSelector `pulumi:"realmsSelector"`
}

type GameServerDeploymentRolloutGameServerConfigOverrideArgs 

type GameServerDeploymentRolloutGameServerConfigOverrideArgs struct {
	// Version of the configuration.
	ConfigVersion pulumi.StringPtrInput `pulumi:"configVersion"`
	// Selection by realms.
	// Structure is documented below.
	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
}

GameServerDeploymentRolloutGameServerConfigOverrideArrayInput is an input type that accepts GameServerDeploymentRolloutGameServerConfigOverrideArray and GameServerDeploymentRolloutGameServerConfigOverrideArrayOutput values. You can construct a concrete instance of `GameServerDeploymentRolloutGameServerConfigOverrideArrayInput` via: 

GameServerDeploymentRolloutGameServerConfigOverrideArray{ GameServerDeploymentRolloutGameServerConfigOverrideArgs{...} }

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
}

GameServerDeploymentRolloutGameServerConfigOverrideInput is an input type that accepts GameServerDeploymentRolloutGameServerConfigOverrideArgs and GameServerDeploymentRolloutGameServerConfigOverrideOutput values. You can construct a concrete instance of `GameServerDeploymentRolloutGameServerConfigOverrideInput` via: 

GameServerDeploymentRolloutGameServerConfigOverrideArgs{...}

type GameServerDeploymentRolloutGameServerConfigOverrideOutput 

type GameServerDeploymentRolloutGameServerConfigOverrideOutput struct{ *pulumi.OutputState }

func (GameServerDeploymentRolloutGameServerConfigOverrideOutput) ConfigVersion 

func (o GameServerDeploymentRolloutGameServerConfigOverrideOutput) ConfigVersion() pulumi.StringPtrOutput

Version of the configuration.

func (GameServerDeploymentRolloutGameServerConfigOverrideOutput) ElementType 

func (GameServerDeploymentRolloutGameServerConfigOverrideOutput) ElementType() reflect.Type

func (GameServerDeploymentRolloutGameServerConfigOverrideOutput) RealmsSelector 

func (o GameServerDeploymentRolloutGameServerConfigOverrideOutput) RealmsSelector() GameServerDeploymentRolloutGameServerConfigOverrideRealmsSelectorPtrOutput

Selection by realms. Structure is documented below.

func (GameServerDeploymentRolloutGameServerConfigOverrideOutput) ToGameServerDeploymentRolloutGameServerConfigOverrideOutput 

func (o GameServerDeploymentRolloutGameServerConfigOverrideOutput) ToGameServerDeploymentRolloutGameServerConfigOverrideOutput() GameServerDeploymentRolloutGameServerConfigOverrideOutput

func (GameServerDeploymentRolloutGameServerConfigOverrideOutput) ToGameServerDeploymentRolloutGameServerConfigOverrideOutputWithContext 

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

type GameServerDeploymentRolloutGameServerConfigOverrideRealmsSelector 

type GameServerDeploymentRolloutGameServerConfigOverrideRealmsSelector struct {
	// List of realms to match against.
	Realms []string `pulumi:"realms"`
}

type GameServerDeploymentRolloutGameServerConfigOverrideRealmsSelectorArgs 

type GameServerDeploymentRolloutGameServerConfigOverrideRealmsSelectorArgs struct {
	// List of realms to match against.
	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
}

GameServerDeploymentRolloutGameServerConfigOverrideRealmsSelectorInput is an input type that accepts GameServerDeploymentRolloutGameServerConfigOverrideRealmsSelectorArgs and GameServerDeploymentRolloutGameServerConfigOverrideRealmsSelectorOutput values. You can construct a concrete instance of `GameServerDeploymentRolloutGameServerConfigOverrideRealmsSelectorInput` via: 

GameServerDeploymentRolloutGameServerConfigOverrideRealmsSelectorArgs{...}

type GameServerDeploymentRolloutGameServerConfigOverrideRealmsSelectorOutput 

type GameServerDeploymentRolloutGameServerConfigOverrideRealmsSelectorOutput struct{ *pulumi.OutputState }

func (GameServerDeploymentRolloutGameServerConfigOverrideRealmsSelectorOutput) ElementType 

func (GameServerDeploymentRolloutGameServerConfigOverrideRealmsSelectorOutput) ElementType() reflect.Type

func (GameServerDeploymentRolloutGameServerConfigOverrideRealmsSelectorOutput) Realms 

func (o GameServerDeploymentRolloutGameServerConfigOverrideRealmsSelectorOutput) Realms() pulumi.StringArrayOutput

List of realms to match against.

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
}

GameServerDeploymentRolloutGameServerConfigOverrideRealmsSelectorPtrInput is an input type that accepts GameServerDeploymentRolloutGameServerConfigOverrideRealmsSelectorArgs, GameServerDeploymentRolloutGameServerConfigOverrideRealmsSelectorPtr and GameServerDeploymentRolloutGameServerConfigOverrideRealmsSelectorPtrOutput values. You can construct a concrete instance of `GameServerDeploymentRolloutGameServerConfigOverrideRealmsSelectorPtrInput` via: 

        GameServerDeploymentRolloutGameServerConfigOverrideRealmsSelectorArgs{...}

or:

        nil

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

List of realms to match against.

func (GameServerDeploymentRolloutGameServerConfigOverrideRealmsSelectorPtrOutput) ToGameServerDeploymentRolloutGameServerConfigOverrideRealmsSelectorPtrOutput 

func (o GameServerDeploymentRolloutGameServerConfigOverrideRealmsSelectorPtrOutput) ToGameServerDeploymentRolloutGameServerConfigOverrideRealmsSelectorPtrOutput() GameServerDeploymentRolloutGameServerConfigOverrideRealmsSelectorPtrOutput

func (GameServerDeploymentRolloutGameServerConfigOverrideRealmsSelectorPtrOutput) ToGameServerDeploymentRolloutGameServerConfigOverrideRealmsSelectorPtrOutputWithContext 

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

type GameServerDeploymentRolloutInput 

type GameServerDeploymentRolloutInput interface {
	pulumi.Input

	ToGameServerDeploymentRolloutOutput() GameServerDeploymentRolloutOutput
	ToGameServerDeploymentRolloutOutputWithContext(ctx context.Context) GameServerDeploymentRolloutOutput
}

type GameServerDeploymentRolloutMap 

type GameServerDeploymentRolloutMap map[string]GameServerDeploymentRolloutInput

func (GameServerDeploymentRolloutMap) ElementType 

func (GameServerDeploymentRolloutMap) ElementType() reflect.Type

func (GameServerDeploymentRolloutMap) ToGameServerDeploymentRolloutMapOutput 

func (i GameServerDeploymentRolloutMap) ToGameServerDeploymentRolloutMapOutput() GameServerDeploymentRolloutMapOutput

func (GameServerDeploymentRolloutMap) ToGameServerDeploymentRolloutMapOutputWithContext 

func (i GameServerDeploymentRolloutMap) ToGameServerDeploymentRolloutMapOutputWithContext(ctx context.Context) GameServerDeploymentRolloutMapOutput

type GameServerDeploymentRolloutMapInput 

type GameServerDeploymentRolloutMapInput interface {
	pulumi.Input

	ToGameServerDeploymentRolloutMapOutput() GameServerDeploymentRolloutMapOutput
	ToGameServerDeploymentRolloutMapOutputWithContext(context.Context) GameServerDeploymentRolloutMapOutput
}

GameServerDeploymentRolloutMapInput is an input type that accepts GameServerDeploymentRolloutMap and GameServerDeploymentRolloutMapOutput values. You can construct a concrete instance of `GameServerDeploymentRolloutMapInput` via: 

GameServerDeploymentRolloutMap{ "key": GameServerDeploymentRolloutArgs{...} }

type GameServerDeploymentRolloutMapOutput 

type GameServerDeploymentRolloutMapOutput struct{ *pulumi.OutputState }

func (GameServerDeploymentRolloutMapOutput) ElementType 

func (GameServerDeploymentRolloutMapOutput) ElementType() reflect.Type

func (GameServerDeploymentRolloutMapOutput) MapIndex 

func (o GameServerDeploymentRolloutMapOutput) MapIndex(k pulumi.StringInput) GameServerDeploymentRolloutOutput

func (GameServerDeploymentRolloutMapOutput) ToGameServerDeploymentRolloutMapOutput 

func (o GameServerDeploymentRolloutMapOutput) ToGameServerDeploymentRolloutMapOutput() GameServerDeploymentRolloutMapOutput

func (GameServerDeploymentRolloutMapOutput) ToGameServerDeploymentRolloutMapOutputWithContext 

func (o GameServerDeploymentRolloutMapOutput) ToGameServerDeploymentRolloutMapOutputWithContext(ctx context.Context) GameServerDeploymentRolloutMapOutput

type GameServerDeploymentRolloutOutput 

type GameServerDeploymentRolloutOutput struct{ *pulumi.OutputState }

func (GameServerDeploymentRolloutOutput) ElementType 

func (GameServerDeploymentRolloutOutput) ElementType() reflect.Type

func (GameServerDeploymentRolloutOutput) ToGameServerDeploymentRolloutOutput 

func (o GameServerDeploymentRolloutOutput) ToGameServerDeploymentRolloutOutput() GameServerDeploymentRolloutOutput

func (GameServerDeploymentRolloutOutput) ToGameServerDeploymentRolloutOutputWithContext 

func (o GameServerDeploymentRolloutOutput) ToGameServerDeploymentRolloutOutputWithContext(ctx context.Context) GameServerDeploymentRolloutOutput

func (GameServerDeploymentRolloutOutput) ToGameServerDeploymentRolloutPtrOutput 

func (o GameServerDeploymentRolloutOutput) ToGameServerDeploymentRolloutPtrOutput() GameServerDeploymentRolloutPtrOutput

func (GameServerDeploymentRolloutOutput) ToGameServerDeploymentRolloutPtrOutputWithContext 

func (o GameServerDeploymentRolloutOutput) ToGameServerDeploymentRolloutPtrOutputWithContext(ctx context.Context) GameServerDeploymentRolloutPtrOutput

type GameServerDeploymentRolloutPtrInput 

type GameServerDeploymentRolloutPtrInput interface {
	pulumi.Input

	ToGameServerDeploymentRolloutPtrOutput() GameServerDeploymentRolloutPtrOutput
	ToGameServerDeploymentRolloutPtrOutputWithContext(ctx context.Context) GameServerDeploymentRolloutPtrOutput
}

type GameServerDeploymentRolloutPtrOutput 

type GameServerDeploymentRolloutPtrOutput struct{ *pulumi.OutputState }

func (GameServerDeploymentRolloutPtrOutput) Elem added in v5.21.0 

func (o GameServerDeploymentRolloutPtrOutput) Elem() GameServerDeploymentRolloutOutput

func (GameServerDeploymentRolloutPtrOutput) ElementType 

func (GameServerDeploymentRolloutPtrOutput) ElementType() reflect.Type

func (GameServerDeploymentRolloutPtrOutput) ToGameServerDeploymentRolloutPtrOutput 

func (o GameServerDeploymentRolloutPtrOutput) ToGameServerDeploymentRolloutPtrOutput() GameServerDeploymentRolloutPtrOutput

func (GameServerDeploymentRolloutPtrOutput) ToGameServerDeploymentRolloutPtrOutputWithContext 

func (o GameServerDeploymentRolloutPtrOutput) ToGameServerDeploymentRolloutPtrOutputWithContext(ctx context.Context) GameServerDeploymentRolloutPtrOutput

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 gameServerConfigOverrides 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.
	// Structure is documented below.
	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 GetGameServerDeploymentRolloutGameServerConfigOverride 

type GetGameServerDeploymentRolloutGameServerConfigOverride struct {
	ConfigVersion   string                                                                 `pulumi:"configVersion"`
	RealmsSelectors []GetGameServerDeploymentRolloutGameServerConfigOverrideRealmsSelector `pulumi:"realmsSelectors"`
}

type GetGameServerDeploymentRolloutGameServerConfigOverrideArgs 

type GetGameServerDeploymentRolloutGameServerConfigOverrideArgs struct {
	ConfigVersion   pulumi.StringInput                                                             `pulumi:"configVersion"`
	RealmsSelectors GetGameServerDeploymentRolloutGameServerConfigOverrideRealmsSelectorArrayInput `pulumi:"realmsSelectors"`
}

func (GetGameServerDeploymentRolloutGameServerConfigOverrideArgs) ElementType 

func (GetGameServerDeploymentRolloutGameServerConfigOverrideArgs) ElementType() reflect.Type

func (GetGameServerDeploymentRolloutGameServerConfigOverrideArgs) ToGetGameServerDeploymentRolloutGameServerConfigOverrideOutput 

func (i GetGameServerDeploymentRolloutGameServerConfigOverrideArgs) ToGetGameServerDeploymentRolloutGameServerConfigOverrideOutput() GetGameServerDeploymentRolloutGameServerConfigOverrideOutput

func (GetGameServerDeploymentRolloutGameServerConfigOverrideArgs) ToGetGameServerDeploymentRolloutGameServerConfigOverrideOutputWithContext 

func (i GetGameServerDeploymentRolloutGameServerConfigOverrideArgs) ToGetGameServerDeploymentRolloutGameServerConfigOverrideOutputWithContext(ctx context.Context) GetGameServerDeploymentRolloutGameServerConfigOverrideOutput

type GetGameServerDeploymentRolloutGameServerConfigOverrideArray 

type GetGameServerDeploymentRolloutGameServerConfigOverrideArray []GetGameServerDeploymentRolloutGameServerConfigOverrideInput

func (GetGameServerDeploymentRolloutGameServerConfigOverrideArray) ElementType 

func (GetGameServerDeploymentRolloutGameServerConfigOverrideArray) ElementType() reflect.Type

func (GetGameServerDeploymentRolloutGameServerConfigOverrideArray) ToGetGameServerDeploymentRolloutGameServerConfigOverrideArrayOutput 

func (i GetGameServerDeploymentRolloutGameServerConfigOverrideArray) ToGetGameServerDeploymentRolloutGameServerConfigOverrideArrayOutput() GetGameServerDeploymentRolloutGameServerConfigOverrideArrayOutput

func (GetGameServerDeploymentRolloutGameServerConfigOverrideArray) ToGetGameServerDeploymentRolloutGameServerConfigOverrideArrayOutputWithContext 

func (i GetGameServerDeploymentRolloutGameServerConfigOverrideArray) ToGetGameServerDeploymentRolloutGameServerConfigOverrideArrayOutputWithContext(ctx context.Context) GetGameServerDeploymentRolloutGameServerConfigOverrideArrayOutput

type GetGameServerDeploymentRolloutGameServerConfigOverrideArrayInput 

type GetGameServerDeploymentRolloutGameServerConfigOverrideArrayInput interface {
	pulumi.Input

	ToGetGameServerDeploymentRolloutGameServerConfigOverrideArrayOutput() GetGameServerDeploymentRolloutGameServerConfigOverrideArrayOutput
	ToGetGameServerDeploymentRolloutGameServerConfigOverrideArrayOutputWithContext(context.Context) GetGameServerDeploymentRolloutGameServerConfigOverrideArrayOutput
}

GetGameServerDeploymentRolloutGameServerConfigOverrideArrayInput is an input type that accepts GetGameServerDeploymentRolloutGameServerConfigOverrideArray and GetGameServerDeploymentRolloutGameServerConfigOverrideArrayOutput values. You can construct a concrete instance of `GetGameServerDeploymentRolloutGameServerConfigOverrideArrayInput` via: 

GetGameServerDeploymentRolloutGameServerConfigOverrideArray{ GetGameServerDeploymentRolloutGameServerConfigOverrideArgs{...} }

type GetGameServerDeploymentRolloutGameServerConfigOverrideArrayOutput 

type GetGameServerDeploymentRolloutGameServerConfigOverrideArrayOutput struct{ *pulumi.OutputState }

func (GetGameServerDeploymentRolloutGameServerConfigOverrideArrayOutput) ElementType 

func (GetGameServerDeploymentRolloutGameServerConfigOverrideArrayOutput) ElementType() reflect.Type

func (GetGameServerDeploymentRolloutGameServerConfigOverrideArrayOutput) Index 

func (o GetGameServerDeploymentRolloutGameServerConfigOverrideArrayOutput) Index(i pulumi.IntInput) GetGameServerDeploymentRolloutGameServerConfigOverrideOutput

func (GetGameServerDeploymentRolloutGameServerConfigOverrideArrayOutput) ToGetGameServerDeploymentRolloutGameServerConfigOverrideArrayOutput 

func (o GetGameServerDeploymentRolloutGameServerConfigOverrideArrayOutput) ToGetGameServerDeploymentRolloutGameServerConfigOverrideArrayOutput() GetGameServerDeploymentRolloutGameServerConfigOverrideArrayOutput

func (GetGameServerDeploymentRolloutGameServerConfigOverrideArrayOutput) ToGetGameServerDeploymentRolloutGameServerConfigOverrideArrayOutputWithContext 

func (o GetGameServerDeploymentRolloutGameServerConfigOverrideArrayOutput) ToGetGameServerDeploymentRolloutGameServerConfigOverrideArrayOutputWithContext(ctx context.Context) GetGameServerDeploymentRolloutGameServerConfigOverrideArrayOutput

type GetGameServerDeploymentRolloutGameServerConfigOverrideInput 

type GetGameServerDeploymentRolloutGameServerConfigOverrideInput interface {
	pulumi.Input

	ToGetGameServerDeploymentRolloutGameServerConfigOverrideOutput() GetGameServerDeploymentRolloutGameServerConfigOverrideOutput
	ToGetGameServerDeploymentRolloutGameServerConfigOverrideOutputWithContext(context.Context) GetGameServerDeploymentRolloutGameServerConfigOverrideOutput
}

GetGameServerDeploymentRolloutGameServerConfigOverrideInput is an input type that accepts GetGameServerDeploymentRolloutGameServerConfigOverrideArgs and GetGameServerDeploymentRolloutGameServerConfigOverrideOutput values. You can construct a concrete instance of `GetGameServerDeploymentRolloutGameServerConfigOverrideInput` via: 

GetGameServerDeploymentRolloutGameServerConfigOverrideArgs{...}

type GetGameServerDeploymentRolloutGameServerConfigOverrideOutput 

type GetGameServerDeploymentRolloutGameServerConfigOverrideOutput struct{ *pulumi.OutputState }

func (GetGameServerDeploymentRolloutGameServerConfigOverrideOutput) ConfigVersion 

func (o GetGameServerDeploymentRolloutGameServerConfigOverrideOutput) ConfigVersion() pulumi.StringOutput

func (GetGameServerDeploymentRolloutGameServerConfigOverrideOutput) ElementType 

func (GetGameServerDeploymentRolloutGameServerConfigOverrideOutput) ElementType() reflect.Type

func (GetGameServerDeploymentRolloutGameServerConfigOverrideOutput) RealmsSelectors 

func (o GetGameServerDeploymentRolloutGameServerConfigOverrideOutput) RealmsSelectors() GetGameServerDeploymentRolloutGameServerConfigOverrideRealmsSelectorArrayOutput

func (GetGameServerDeploymentRolloutGameServerConfigOverrideOutput) ToGetGameServerDeploymentRolloutGameServerConfigOverrideOutput 

func (o GetGameServerDeploymentRolloutGameServerConfigOverrideOutput) ToGetGameServerDeploymentRolloutGameServerConfigOverrideOutput() GetGameServerDeploymentRolloutGameServerConfigOverrideOutput

func (GetGameServerDeploymentRolloutGameServerConfigOverrideOutput) ToGetGameServerDeploymentRolloutGameServerConfigOverrideOutputWithContext 

func (o GetGameServerDeploymentRolloutGameServerConfigOverrideOutput) ToGetGameServerDeploymentRolloutGameServerConfigOverrideOutputWithContext(ctx context.Context) GetGameServerDeploymentRolloutGameServerConfigOverrideOutput

type GetGameServerDeploymentRolloutGameServerConfigOverrideRealmsSelector 

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

type GetGameServerDeploymentRolloutGameServerConfigOverrideRealmsSelectorArgs 

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

func (GetGameServerDeploymentRolloutGameServerConfigOverrideRealmsSelectorArgs) ElementType 

func (GetGameServerDeploymentRolloutGameServerConfigOverrideRealmsSelectorArgs) ElementType() reflect.Type

func (GetGameServerDeploymentRolloutGameServerConfigOverrideRealmsSelectorArgs) ToGetGameServerDeploymentRolloutGameServerConfigOverrideRealmsSelectorOutput 

func (i GetGameServerDeploymentRolloutGameServerConfigOverrideRealmsSelectorArgs) ToGetGameServerDeploymentRolloutGameServerConfigOverrideRealmsSelectorOutput() GetGameServerDeploymentRolloutGameServerConfigOverrideRealmsSelectorOutput

func (GetGameServerDeploymentRolloutGameServerConfigOverrideRealmsSelectorArgs) ToGetGameServerDeploymentRolloutGameServerConfigOverrideRealmsSelectorOutputWithContext 

func (i GetGameServerDeploymentRolloutGameServerConfigOverrideRealmsSelectorArgs) ToGetGameServerDeploymentRolloutGameServerConfigOverrideRealmsSelectorOutputWithContext(ctx context.Context) GetGameServerDeploymentRolloutGameServerConfigOverrideRealmsSelectorOutput

type GetGameServerDeploymentRolloutGameServerConfigOverrideRealmsSelectorArray 

type GetGameServerDeploymentRolloutGameServerConfigOverrideRealmsSelectorArray []GetGameServerDeploymentRolloutGameServerConfigOverrideRealmsSelectorInput

func (GetGameServerDeploymentRolloutGameServerConfigOverrideRealmsSelectorArray) ElementType 

func (GetGameServerDeploymentRolloutGameServerConfigOverrideRealmsSelectorArray) ElementType() reflect.Type

func (GetGameServerDeploymentRolloutGameServerConfigOverrideRealmsSelectorArray) ToGetGameServerDeploymentRolloutGameServerConfigOverrideRealmsSelectorArrayOutput 

func (i GetGameServerDeploymentRolloutGameServerConfigOverrideRealmsSelectorArray) ToGetGameServerDeploymentRolloutGameServerConfigOverrideRealmsSelectorArrayOutput() GetGameServerDeploymentRolloutGameServerConfigOverrideRealmsSelectorArrayOutput

func (GetGameServerDeploymentRolloutGameServerConfigOverrideRealmsSelectorArray) ToGetGameServerDeploymentRolloutGameServerConfigOverrideRealmsSelectorArrayOutputWithContext 

func (i GetGameServerDeploymentRolloutGameServerConfigOverrideRealmsSelectorArray) ToGetGameServerDeploymentRolloutGameServerConfigOverrideRealmsSelectorArrayOutputWithContext(ctx context.Context) GetGameServerDeploymentRolloutGameServerConfigOverrideRealmsSelectorArrayOutput

type GetGameServerDeploymentRolloutGameServerConfigOverrideRealmsSelectorArrayInput 

type GetGameServerDeploymentRolloutGameServerConfigOverrideRealmsSelectorArrayInput interface {
	pulumi.Input

	ToGetGameServerDeploymentRolloutGameServerConfigOverrideRealmsSelectorArrayOutput() GetGameServerDeploymentRolloutGameServerConfigOverrideRealmsSelectorArrayOutput
	ToGetGameServerDeploymentRolloutGameServerConfigOverrideRealmsSelectorArrayOutputWithContext(context.Context) GetGameServerDeploymentRolloutGameServerConfigOverrideRealmsSelectorArrayOutput
}

GetGameServerDeploymentRolloutGameServerConfigOverrideRealmsSelectorArrayInput is an input type that accepts GetGameServerDeploymentRolloutGameServerConfigOverrideRealmsSelectorArray and GetGameServerDeploymentRolloutGameServerConfigOverrideRealmsSelectorArrayOutput values. You can construct a concrete instance of `GetGameServerDeploymentRolloutGameServerConfigOverrideRealmsSelectorArrayInput` via: 

GetGameServerDeploymentRolloutGameServerConfigOverrideRealmsSelectorArray{ GetGameServerDeploymentRolloutGameServerConfigOverrideRealmsSelectorArgs{...} }

type GetGameServerDeploymentRolloutGameServerConfigOverrideRealmsSelectorArrayOutput 

type GetGameServerDeploymentRolloutGameServerConfigOverrideRealmsSelectorArrayOutput struct{ *pulumi.OutputState }

func (GetGameServerDeploymentRolloutGameServerConfigOverrideRealmsSelectorArrayOutput) ElementType 

func (GetGameServerDeploymentRolloutGameServerConfigOverrideRealmsSelectorArrayOutput) ElementType() reflect.Type

func (GetGameServerDeploymentRolloutGameServerConfigOverrideRealmsSelectorArrayOutput) Index 

func (o GetGameServerDeploymentRolloutGameServerConfigOverrideRealmsSelectorArrayOutput) Index(i pulumi.IntInput) GetGameServerDeploymentRolloutGameServerConfigOverrideRealmsSelectorOutput

func (GetGameServerDeploymentRolloutGameServerConfigOverrideRealmsSelectorArrayOutput) ToGetGameServerDeploymentRolloutGameServerConfigOverrideRealmsSelectorArrayOutput 

func (o GetGameServerDeploymentRolloutGameServerConfigOverrideRealmsSelectorArrayOutput) ToGetGameServerDeploymentRolloutGameServerConfigOverrideRealmsSelectorArrayOutput() GetGameServerDeploymentRolloutGameServerConfigOverrideRealmsSelectorArrayOutput

func (GetGameServerDeploymentRolloutGameServerConfigOverrideRealmsSelectorArrayOutput) ToGetGameServerDeploymentRolloutGameServerConfigOverrideRealmsSelectorArrayOutputWithContext 

func (o GetGameServerDeploymentRolloutGameServerConfigOverrideRealmsSelectorArrayOutput) ToGetGameServerDeploymentRolloutGameServerConfigOverrideRealmsSelectorArrayOutputWithContext(ctx context.Context) GetGameServerDeploymentRolloutGameServerConfigOverrideRealmsSelectorArrayOutput

type GetGameServerDeploymentRolloutGameServerConfigOverrideRealmsSelectorInput 

type GetGameServerDeploymentRolloutGameServerConfigOverrideRealmsSelectorInput interface {
	pulumi.Input

	ToGetGameServerDeploymentRolloutGameServerConfigOverrideRealmsSelectorOutput() GetGameServerDeploymentRolloutGameServerConfigOverrideRealmsSelectorOutput
	ToGetGameServerDeploymentRolloutGameServerConfigOverrideRealmsSelectorOutputWithContext(context.Context) GetGameServerDeploymentRolloutGameServerConfigOverrideRealmsSelectorOutput
}

GetGameServerDeploymentRolloutGameServerConfigOverrideRealmsSelectorInput is an input type that accepts GetGameServerDeploymentRolloutGameServerConfigOverrideRealmsSelectorArgs and GetGameServerDeploymentRolloutGameServerConfigOverrideRealmsSelectorOutput values. You can construct a concrete instance of `GetGameServerDeploymentRolloutGameServerConfigOverrideRealmsSelectorInput` via: 

GetGameServerDeploymentRolloutGameServerConfigOverrideRealmsSelectorArgs{...}

type GetGameServerDeploymentRolloutGameServerConfigOverrideRealmsSelectorOutput 

type GetGameServerDeploymentRolloutGameServerConfigOverrideRealmsSelectorOutput struct{ *pulumi.OutputState }

func (GetGameServerDeploymentRolloutGameServerConfigOverrideRealmsSelectorOutput) ElementType 

func (GetGameServerDeploymentRolloutGameServerConfigOverrideRealmsSelectorOutput) ElementType() reflect.Type

func (GetGameServerDeploymentRolloutGameServerConfigOverrideRealmsSelectorOutput) Realms 

func (o GetGameServerDeploymentRolloutGameServerConfigOverrideRealmsSelectorOutput) Realms() pulumi.StringArrayOutput

func (GetGameServerDeploymentRolloutGameServerConfigOverrideRealmsSelectorOutput) ToGetGameServerDeploymentRolloutGameServerConfigOverrideRealmsSelectorOutput 

func (o GetGameServerDeploymentRolloutGameServerConfigOverrideRealmsSelectorOutput) ToGetGameServerDeploymentRolloutGameServerConfigOverrideRealmsSelectorOutput() GetGameServerDeploymentRolloutGameServerConfigOverrideRealmsSelectorOutput

func (GetGameServerDeploymentRolloutGameServerConfigOverrideRealmsSelectorOutput) ToGetGameServerDeploymentRolloutGameServerConfigOverrideRealmsSelectorOutputWithContext 

func (o GetGameServerDeploymentRolloutGameServerConfigOverrideRealmsSelectorOutput) ToGetGameServerDeploymentRolloutGameServerConfigOverrideRealmsSelectorOutputWithContext(ctx context.Context) GetGameServerDeploymentRolloutGameServerConfigOverrideRealmsSelectorOutput

type LookupGameServerDeploymentRolloutArgs 

type LookupGameServerDeploymentRolloutArgs struct {
	// The deployment to get the rollout state from. Only 1 rollout must be associated with each deployment.
	DeploymentId string `pulumi:"deploymentId"`
}

A collection of arguments for invoking getGameServerDeploymentRollout.

type LookupGameServerDeploymentRolloutOutputArgs added in v5.21.0 

type LookupGameServerDeploymentRolloutOutputArgs struct {
	// The deployment to get the rollout state from. Only 1 rollout must be associated with each deployment.
	DeploymentId pulumi.StringInput `pulumi:"deploymentId"`
}

A collection of arguments for invoking getGameServerDeploymentRollout.

func (LookupGameServerDeploymentRolloutOutputArgs) ElementType added in v5.21.0 

func (LookupGameServerDeploymentRolloutOutputArgs) ElementType() reflect.Type

type LookupGameServerDeploymentRolloutResult 

type LookupGameServerDeploymentRolloutResult struct {
	DefaultGameServerConfig   string                                                   `pulumi:"defaultGameServerConfig"`
	DeploymentId              string                                                   `pulumi:"deploymentId"`
	GameServerConfigOverrides []GetGameServerDeploymentRolloutGameServerConfigOverride `pulumi:"gameServerConfigOverrides"`
	// The provider-assigned unique ID for this managed resource.
	Id   string `pulumi:"id"`
	Name string `pulumi:"name"`
	// The ID of the project in which the resource belongs.
	// If it is not provided, the provider project is used.
	Project string `pulumi:"project"`
}

A collection of values returned by getGameServerDeploymentRollout.

func LookupGameServerDeploymentRollout 

func LookupGameServerDeploymentRollout(ctx *pulumi.Context, args *LookupGameServerDeploymentRolloutArgs, opts ...pulumi.InvokeOption) (*LookupGameServerDeploymentRolloutResult, error)

Use this data source to get the rollout state.

https://cloud.google.com/game-servers/docs/reference/rest/v1beta/GameServerDeploymentRollout

## Example Usage

```go package main

import ( 

"github.com/pulumi/pulumi-gcp/sdk/v5/go/gcp/gameservices"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := gameservices.LookupGameServerDeploymentRollout(ctx, &gameservices.LookupGameServerDeploymentRolloutArgs{
			DeploymentId: "tf-test-deployment-s8sn12jt2c",
		}, nil)
		if err != nil {
			return err
		}
		return nil
	})
}

```

type LookupGameServerDeploymentRolloutResultOutput added in v5.21.0 

type LookupGameServerDeploymentRolloutResultOutput struct{ *pulumi.OutputState }

A collection of values returned by getGameServerDeploymentRollout.

func LookupGameServerDeploymentRolloutOutput added in v5.21.0 

func LookupGameServerDeploymentRolloutOutput(ctx *pulumi.Context, args LookupGameServerDeploymentRolloutOutputArgs, opts ...pulumi.InvokeOption) LookupGameServerDeploymentRolloutResultOutput

func (LookupGameServerDeploymentRolloutResultOutput) DefaultGameServerConfig added in v5.21.0 

func (o LookupGameServerDeploymentRolloutResultOutput) DefaultGameServerConfig() pulumi.StringOutput

func (LookupGameServerDeploymentRolloutResultOutput) DeploymentId added in v5.21.0 

func (o LookupGameServerDeploymentRolloutResultOutput) DeploymentId() pulumi.StringOutput

func (LookupGameServerDeploymentRolloutResultOutput) ElementType added in v5.21.0 

func (LookupGameServerDeploymentRolloutResultOutput) ElementType() reflect.Type

func (LookupGameServerDeploymentRolloutResultOutput) GameServerConfigOverrides added in v5.21.0 

func (o LookupGameServerDeploymentRolloutResultOutput) GameServerConfigOverrides() GetGameServerDeploymentRolloutGameServerConfigOverrideArrayOutput

func (LookupGameServerDeploymentRolloutResultOutput) Id added in v5.21.0 

func (o LookupGameServerDeploymentRolloutResultOutput) Id() pulumi.StringOutput

The provider-assigned unique ID for this managed resource.

func (LookupGameServerDeploymentRolloutResultOutput) Name added in v5.21.0 

func (o LookupGameServerDeploymentRolloutResultOutput) Name() pulumi.StringOutput

func (LookupGameServerDeploymentRolloutResultOutput) Project added in v5.21.0 

func (o LookupGameServerDeploymentRolloutResultOutput) Project() pulumi.StringOutput

The ID of the project in which the resource belongs. If it is not provided, the provider project is used.

func (LookupGameServerDeploymentRolloutResultOutput) ToLookupGameServerDeploymentRolloutResultOutput added in v5.21.0 

func (o LookupGameServerDeploymentRolloutResultOutput) ToLookupGameServerDeploymentRolloutResultOutput() LookupGameServerDeploymentRolloutResultOutput

func (LookupGameServerDeploymentRolloutResultOutput) ToLookupGameServerDeploymentRolloutResultOutputWithContext added in v5.21.0 

func (o LookupGameServerDeploymentRolloutResultOutput) ToLookupGameServerDeploymentRolloutResultOutputWithContext(ctx context.Context) LookupGameServerDeploymentRolloutResultOutput

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

## Example Usage ### Game Service Realm Basic

```go package main

import ( 

"github.com/pulumi/pulumi-gcp/sdk/v5/go/gcp/gameservices"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := gameservices.NewRealm(ctx, "_default", &gameservices.RealmArgs{
			Description: pulumi.String("one of the nine"),
			Location:    pulumi.String("global"),
			RealmId:     pulumi.String("tf-test-realm"),
			TimeZone:    pulumi.String("EST"),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

## Import

Realm can be imported using any of these accepted formats

```sh 

$ pulumi import gcp:gameservices/realm:Realm default projects/{{project}}/locations/{{location}}/realms/{{realm_id}}

```

```sh 

$ pulumi import gcp:gameservices/realm:Realm default {{project}}/{{location}}/{{realm_id}}

```

```sh 

$ pulumi import gcp:gameservices/realm:Realm default {{location}}/{{realm_id}}

```

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.

func (*Realm) ElementType 

func (*Realm) ElementType() reflect.Type

func (*Realm) ToRealmOutput 

func (i *Realm) ToRealmOutput() RealmOutput

func (*Realm) ToRealmOutputWithContext 

func (i *Realm) ToRealmOutputWithContext(ctx context.Context) RealmOutput

func (*Realm) ToRealmPtrOutput 

func (i *Realm) ToRealmPtrOutput() RealmPtrOutput

func (*Realm) ToRealmPtrOutputWithContext 

func (i *Realm) ToRealmPtrOutputWithContext(ctx context.Context) RealmPtrOutput

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 RealmArray 

type RealmArray []RealmInput

func (RealmArray) ElementType 

func (RealmArray) ElementType() reflect.Type

func (RealmArray) ToRealmArrayOutput 

func (i RealmArray) ToRealmArrayOutput() RealmArrayOutput

func (RealmArray) ToRealmArrayOutputWithContext 

func (i RealmArray) ToRealmArrayOutputWithContext(ctx context.Context) RealmArrayOutput

type RealmArrayInput 

type RealmArrayInput interface {
	pulumi.Input

	ToRealmArrayOutput() RealmArrayOutput
	ToRealmArrayOutputWithContext(context.Context) RealmArrayOutput
}

RealmArrayInput is an input type that accepts RealmArray and RealmArrayOutput values. You can construct a concrete instance of `RealmArrayInput` via: 

RealmArray{ RealmArgs{...} }

type RealmArrayOutput 

type RealmArrayOutput struct{ *pulumi.OutputState }

func (RealmArrayOutput) ElementType 

func (RealmArrayOutput) ElementType() reflect.Type

func (RealmArrayOutput) Index 

func (o RealmArrayOutput) Index(i pulumi.IntInput) RealmOutput

func (RealmArrayOutput) ToRealmArrayOutput 

func (o RealmArrayOutput) ToRealmArrayOutput() RealmArrayOutput

func (RealmArrayOutput) ToRealmArrayOutputWithContext 

func (o RealmArrayOutput) ToRealmArrayOutputWithContext(ctx context.Context) RealmArrayOutput

type RealmInput 

type RealmInput interface {
	pulumi.Input

	ToRealmOutput() RealmOutput
	ToRealmOutputWithContext(ctx context.Context) RealmOutput
}

type RealmMap 

type RealmMap map[string]RealmInput

func (RealmMap) ElementType 

func (RealmMap) ElementType() reflect.Type

func (RealmMap) ToRealmMapOutput 

func (i RealmMap) ToRealmMapOutput() RealmMapOutput

func (RealmMap) ToRealmMapOutputWithContext 

func (i RealmMap) ToRealmMapOutputWithContext(ctx context.Context) RealmMapOutput

type RealmMapInput 

type RealmMapInput interface {
	pulumi.Input

	ToRealmMapOutput() RealmMapOutput
	ToRealmMapOutputWithContext(context.Context) RealmMapOutput
}

RealmMapInput is an input type that accepts RealmMap and RealmMapOutput values. You can construct a concrete instance of `RealmMapInput` via: 

RealmMap{ "key": RealmArgs{...} }

type RealmMapOutput 

type RealmMapOutput struct{ *pulumi.OutputState }

func (RealmMapOutput) ElementType 

func (RealmMapOutput) ElementType() reflect.Type

func (RealmMapOutput) MapIndex 

func (o RealmMapOutput) MapIndex(k pulumi.StringInput) RealmOutput

func (RealmMapOutput) ToRealmMapOutput 

func (o RealmMapOutput) ToRealmMapOutput() RealmMapOutput

func (RealmMapOutput) ToRealmMapOutputWithContext 

func (o RealmMapOutput) ToRealmMapOutputWithContext(ctx context.Context) RealmMapOutput

type RealmOutput 

type RealmOutput struct{ *pulumi.OutputState }

func (RealmOutput) ElementType 

func (RealmOutput) ElementType() reflect.Type

func (RealmOutput) ToRealmOutput 

func (o RealmOutput) ToRealmOutput() RealmOutput

func (RealmOutput) ToRealmOutputWithContext 

func (o RealmOutput) ToRealmOutputWithContext(ctx context.Context) RealmOutput

func (RealmOutput) ToRealmPtrOutput 

func (o RealmOutput) ToRealmPtrOutput() RealmPtrOutput

func (RealmOutput) ToRealmPtrOutputWithContext 

func (o RealmOutput) ToRealmPtrOutputWithContext(ctx context.Context) RealmPtrOutput

type RealmPtrInput 

type RealmPtrInput interface {
	pulumi.Input

	ToRealmPtrOutput() RealmPtrOutput
	ToRealmPtrOutputWithContext(ctx context.Context) RealmPtrOutput
}

type RealmPtrOutput 

type RealmPtrOutput struct{ *pulumi.OutputState }

func (RealmPtrOutput) Elem added in v5.21.0 

func (o RealmPtrOutput) Elem() RealmOutput

func (RealmPtrOutput) ElementType 

func (RealmPtrOutput) ElementType() reflect.Type

func (RealmPtrOutput) ToRealmPtrOutput 

func (o RealmPtrOutput) ToRealmPtrOutput() RealmPtrOutput

func (RealmPtrOutput) ToRealmPtrOutputWithContext 

func (o RealmPtrOutput) ToRealmPtrOutputWithContext(ctx context.Context) RealmPtrOutput

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.