types

package
v1.37.2 Latest Latest
Warning

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

 Go to latest Published: Dec 2, 2024 License: Apache-2.0 Imports: 4 Imported by: 1

Documentation

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

This section is empty.

Types

type AcceptanceType 

type AcceptanceType string
const (
	AcceptanceTypeAccept AcceptanceType = "ACCEPT"
	AcceptanceTypeReject AcceptanceType = "REJECT"
)

Enum values for AcceptanceType

func (AcceptanceType) Values added in v0.29.0 

func (AcceptanceType) Values() []AcceptanceType

Values returns all known values for AcceptanceType. Note that this can be expanded in the future, and so it is only as up to date as the client.

The ordering of this slice is not guaranteed to be stable across updates.

type Alias 

type Alias struct {

	// The Amazon Resource Name ([ARN] ) that is assigned to a Amazon GameLift alias
	// resource and uniquely identifies it. ARNs are unique across all Regions. Format
	// is arn:aws:gamelift:::alias/alias-a1234567-b8c9-0d1e-2fa3-b45c6d7e8912 . In a
	// GameLift alias ARN, the resource ID matches the alias ID value.
	//
	// [ARN]: https://docs.aws.amazon.com/AmazonS3/latest/dev/s3-arn-format.html
	AliasArn *string

	// A unique identifier for the alias. Alias IDs are unique within a Region.
	AliasId *string

	// A time stamp indicating when this data object was created. Format is a number
	// expressed in Unix time as milliseconds (for example "1469498468.057" ).
	CreationTime *time.Time

	// A human-readable description of an alias.
	Description *string

	// The time that this data object was last modified. Format is a number expressed
	// in Unix time as milliseconds (for example "1469498468.057" ).
	LastUpdatedTime *time.Time

	// A descriptive label that is associated with an alias. Alias names do not need
	// to be unique.
	Name *string

	// The routing configuration, including routing type and fleet target, for the
	// alias.
	RoutingStrategy *RoutingStrategy
	// contains filtered or unexported fields
}

Properties that describe an alias resource.

All APIs by task

type AnywhereConfiguration added in v1.16.0 

type AnywhereConfiguration struct {

	// The cost to run your fleet per hour. Amazon GameLift uses the provided cost of
	// your fleet to balance usage in queues. For more information about queues, see [Setting up queues]
	// in the Amazon GameLift Developer Guide.
	//
	// [Setting up queues]: https://docs.aws.amazon.com/gamelift/latest/developerguide/queues-intro.html
	//
	// This member is required.
	Cost *string
	// contains filtered or unexported fields
}

Amazon GameLift configuration options for your Anywhere fleets.

type AttributeValue 

type AttributeValue struct {

	// For number values, expressed as double.
	N *float64

	// For single string values. Maximum string length is 100 characters.
	S *string

	// For a map of up to 10 data type:value pairs. Maximum length for each string
	// value is 100 characters.
	SDM map[string]float64

	// For a list of up to 100 strings. Maximum length for each string is 100
	// characters. Duplicate values are not recognized; all occurrences of the repeated
	// value after the first of a repeated value are ignored.
	SL []string
	// contains filtered or unexported fields
}

Values for use in player attribute key-value pairs. This object lets you specify an attribute value using any of the valid data types: string, number, string array, or data map. Each AttributeValue object can use only one of the available properties.

type AwsCredentials 

type AwsCredentials struct {

	// The access key ID that identifies the temporary security credentials.
	AccessKeyId *string

	// The secret access key that can be used to sign requests.
	SecretAccessKey *string

	// The token that users must pass to the service API to use the temporary
	// credentials.
	SessionToken *string
	// contains filtered or unexported fields
}

Amazon Web Services account security credentials that allow interactions with Amazon GameLift resources. The credentials are temporary and valid for a limited time span. You can request fresh credentials at any time.

Amazon Web Services security credentials consist of three parts: an access key ID, a secret access key, and a session token. You must use all three parts together to authenticate your access requests.

You need Amazon Web Services credentials for the following tasks:

  • To upload a game server build directly to Amazon GameLift S3 storage using CreateBuild . To get access for this task, call RequestUploadCredentials.

  • To remotely connect to an active Amazon GameLift fleet instances. To get remote access, call GetComputeAccess.

type BackfillMode 

type BackfillMode string
const (
	BackfillModeAutomatic BackfillMode = "AUTOMATIC"
	BackfillModeManual    BackfillMode = "MANUAL"
)

Enum values for BackfillMode

func (BackfillMode) Values added in v0.29.0 

func (BackfillMode) Values() []BackfillMode

Values returns all known values for BackfillMode. Note that this can be expanded in the future, and so it is only as up to date as the client.

The ordering of this slice is not guaranteed to be stable across updates.

type BalancingStrategy 

type BalancingStrategy string
const (
	BalancingStrategySpotOnly      BalancingStrategy = "SPOT_ONLY"
	BalancingStrategySpotPreferred BalancingStrategy = "SPOT_PREFERRED"
	BalancingStrategyOnDemandOnly  BalancingStrategy = "ON_DEMAND_ONLY"
)

Enum values for BalancingStrategy

func (BalancingStrategy) Values added in v0.29.0 

func (BalancingStrategy) Values() []BalancingStrategy

Values returns all known values for BalancingStrategy. Note that this can be expanded in the future, and so it is only as up to date as the client.

The ordering of this slice is not guaranteed to be stable across updates.

type Build 

type Build struct {

	// The Amazon Resource Name ([ARN] ) that is assigned to a Amazon GameLift build
	// resource and uniquely identifies it. ARNs are unique across all Regions. Format
	// is arn:aws:gamelift:::build/build-a1234567-b8c9-0d1e-2fa3-b45c6d7e8912 . In a
	// GameLift build ARN, the resource ID matches the BuildId value.
	//
	// [ARN]: https://docs.aws.amazon.com/AmazonS3/latest/dev/s3-arn-format.html
	BuildArn *string

	// A unique identifier for the build.
	BuildId *string

	// A time stamp indicating when this data object was created. Format is a number
	// expressed in Unix time as milliseconds (for example "1469498468.057" ).
	CreationTime *time.Time

	// A descriptive label that is associated with a build. Build names do not need to
	// be unique. It can be set using [CreateBuild]or [UpdateBuild].
	//
	// [CreateBuild]: https://docs.aws.amazon.com/gamelift/latest/apireference/API_CreateBuild.html
	// [UpdateBuild]: https://docs.aws.amazon.com/gamelift/latest/apireference/UpdateBuild
	Name *string

	// Operating system that the game server binaries are built to run on. This value
	// determines the type of fleet resources that you can use for this build.
	//
	// Amazon Linux 2 (AL2) will reach end of support on 6/30/2025. See more details
	// in the [Amazon Linux 2 FAQs]. For game servers that are hosted on AL2 and use Amazon GameLift server
	// SDK 4.x., first update the game server build to server SDK 5.x, and then deploy
	// to AL2023 instances. See [Migrate to Amazon GameLift server SDK version 5.]
	//
	// [Amazon Linux 2 FAQs]: https://aws.amazon.com/amazon-linux-2/faqs/
	// [Migrate to Amazon GameLift server SDK version 5.]: https://docs.aws.amazon.com/gamelift/latest/developerguide/reference-serversdk5-migration.html
	OperatingSystem OperatingSystem

	// The Amazon GameLift Server SDK version used to develop your game server.
	ServerSdkVersion *string

	// File size of the uploaded game build, expressed in bytes. When the build status
	// is INITIALIZED or when using a custom Amazon S3 storage location, this value is
	// 0.
	SizeOnDisk *int64

	// Current status of the build.
	//
	// Possible build statuses include the following:
	//
	//   - INITIALIZED -- A new build has been defined, but no files have been
	//   uploaded. You cannot create fleets for builds that are in this status. When a
	//   build is successfully created, the build status is set to this value.
	//
	//   - READY -- The game build has been successfully uploaded. You can now create
	//   new fleets for this build.
	//
	//   - FAILED -- The game build upload failed. You cannot create new fleets for
	//   this build.
	Status BuildStatus

	// Version information that is associated with a build or script. Version strings
	// do not need to be unique.
	Version *string
	// contains filtered or unexported fields
}

Properties describing a custom game build.

All APIs by task

type BuildStatus 

type BuildStatus string
const (
	BuildStatusInitialized BuildStatus = "INITIALIZED"
	BuildStatusReady       BuildStatus = "READY"
	BuildStatusFailed      BuildStatus = "FAILED"
)

Enum values for BuildStatus

func (BuildStatus) Values added in v0.29.0 

func (BuildStatus) Values() []BuildStatus

Values returns all known values for BuildStatus. Note that this can be expanded in the future, and so it is only as up to date as the client.

The ordering of this slice is not guaranteed to be stable across updates.

type CertificateConfiguration 

type CertificateConfiguration struct {

	// Indicates whether a TLS/SSL certificate is generated for a fleet.
	//
	// Valid values include:
	//
	//   - GENERATED -- Generate a TLS/SSL certificate for this fleet.
	//
	//   - DISABLED -- (default) Do not generate a TLS/SSL certificate for this fleet.
	//
	// This member is required.
	CertificateType CertificateType
	// contains filtered or unexported fields
}

Determines whether a TLS/SSL certificate is generated for a fleet. This feature must be enabled when creating the fleet. All instances in a fleet share the same certificate. The certificate can be retrieved by calling the Amazon GameLift Server SDKoperation GetInstanceCertificate .

type CertificateType 

type CertificateType string
const (
	CertificateTypeDisabled  CertificateType = "DISABLED"
	CertificateTypeGenerated CertificateType = "GENERATED"
)

Enum values for CertificateType

func (CertificateType) Values added in v0.29.0 

func (CertificateType) Values() []CertificateType

Values returns all known values for CertificateType. Note that this can be expanded in the future, and so it is only as up to date as the client.

The ordering of this slice is not guaranteed to be stable across updates.

type ClaimFilterOption added in v1.19.0 

type ClaimFilterOption struct {

	// List of instance statuses that game servers may be claimed on. If provided, the
	// list must contain the ACTIVE status.
	InstanceStatuses []FilterInstanceStatus
	// contains filtered or unexported fields
}
This data type is used with the Amazon GameLift FleetIQ and game server

groups.

Filters which game servers may be claimed when calling ClaimGameServer .

type ComparisonOperatorType 

type ComparisonOperatorType string
const (
	ComparisonOperatorTypeGreaterThanOrEqualToThreshold ComparisonOperatorType = "GreaterThanOrEqualToThreshold"
	ComparisonOperatorTypeGreaterThanThreshold          ComparisonOperatorType = "GreaterThanThreshold"
	ComparisonOperatorTypeLessThanThreshold             ComparisonOperatorType = "LessThanThreshold"
	ComparisonOperatorTypeLessThanOrEqualToThreshold    ComparisonOperatorType = "LessThanOrEqualToThreshold"
)

Enum values for ComparisonOperatorType

func (ComparisonOperatorType) Values added in v0.29.0 

func (ComparisonOperatorType) Values() []ComparisonOperatorType

Values returns all known values for ComparisonOperatorType. Note that this can be expanded in the future, and so it is only as up to date as the client.

The ordering of this slice is not guaranteed to be stable across updates.

type Compute added in v1.16.0 

type Compute struct {

	// The ARN that is assigned to a compute resource and uniquely identifies it. ARNs
	// are unique across locations. Instances in managed EC2 fleets are not assigned a
	// Compute ARN.
	ComputeArn *string

	// A descriptive label for the compute resource. For instances in a managed EC2
	// fleet, the compute name is the same value as the InstanceId ID.
	ComputeName *string

	// Current status of the compute. A compute must have an ACTIVE status to host
	// game sessions.
	ComputeStatus ComputeStatus

	// A set of attributes for each container in the compute.
	ContainerAttributes []ContainerAttribute

	// A time stamp indicating when this data object was created. Format is a number
	// expressed in Unix time as milliseconds (for example "1469498468.057" ).
	CreationTime *time.Time

	// The DNS name of a compute resource. Amazon GameLift requires a DNS name or IP
	// address for a compute.
	DnsName *string

	// The Amazon Resource Name (ARN) of the fleet that the compute belongs to.
	FleetArn *string

	// A unique identifier for the fleet that the compute belongs to.
	FleetId *string

	//  The endpoint of the Amazon GameLift Agent.
	GameLiftAgentEndpoint *string

	// The Amazon GameLift SDK endpoint connection for a registered compute resource
	// in an Anywhere fleet. The game servers on the compute use this endpoint to
	// connect to the Amazon GameLift service.
	GameLiftServiceSdkEndpoint *string

	// The game server container group definition for the compute.
	GameServerContainerGroupDefinitionArn *string

	//  The InstanceID of the EC2 instance that is hosting the compute.
	InstanceId *string

	// The IP address of a compute resource. Amazon GameLift requires a DNS name or IP
	// address for a compute.
	IpAddress *string

	// The name of the custom location you added to the fleet that this compute
	// resource resides in.
	Location *string

	// The type of operating system on the compute resource.
	//
	// Amazon Linux 2 (AL2) will reach end of support on 6/30/2025. See more details
	// in the [Amazon Linux 2 FAQs]. For game servers that are hosted on AL2 and use Amazon GameLift server
	// SDK 4.x., first update the game server build to server SDK 5.x, and then deploy
	// to AL2023 instances. See [Migrate to Amazon GameLift server SDK version 5.]
	//
	// [Amazon Linux 2 FAQs]: https://aws.amazon.com/amazon-linux-2/faqs/
	// [Migrate to Amazon GameLift server SDK version 5.]: https://docs.aws.amazon.com/gamelift/latest/developerguide/reference-serversdk5-migration.html
	OperatingSystem OperatingSystem

	// The Amazon EC2 instance type that the fleet uses. For registered computes in an
	// Amazon GameLift Anywhere fleet, this property is empty.
	Type EC2InstanceType
	// contains filtered or unexported fields
}

An Amazon GameLift compute resource for hosting your game servers. Computes in an Amazon GameLift fleet differs depending on the fleet's compute type property as follows:

  • For managed EC2 fleets, a compute is an EC2 instance.

  • For Anywhere fleets, a compute is a computing resource that you provide and is registered to the fleet.

type ComputeStatus added in v1.16.0 

type ComputeStatus string
const (
	ComputeStatusPending     ComputeStatus = "PENDING"
	ComputeStatusActive      ComputeStatus = "ACTIVE"
	ComputeStatusTerminating ComputeStatus = "TERMINATING"
	ComputeStatusImpaired    ComputeStatus = "IMPAIRED"
)

Enum values for ComputeStatus

func (ComputeStatus) Values added in v1.16.0 

func (ComputeStatus) Values() []ComputeStatus

Values returns all known values for ComputeStatus. Note that this can be expanded in the future, and so it is only as up to date as the client.

The ordering of this slice is not guaranteed to be stable across updates.

type ComputeType added in v1.16.0 

type ComputeType string
const (
	ComputeTypeEc2      ComputeType = "EC2"
	ComputeTypeAnywhere ComputeType = "ANYWHERE"
)

Enum values for ComputeType

func (ComputeType) Values added in v1.16.0 

func (ComputeType) Values() []ComputeType

Values returns all known values for ComputeType. Note that this can be expanded in the future, and so it is only as up to date as the client.

The ordering of this slice is not guaranteed to be stable across updates.

type ConflictException 

type ConflictException struct {
	Message *string

	ErrorCodeOverride *string
	// contains filtered or unexported fields
}

The requested operation would cause a conflict with the current state of a service resource associated with the request. Resolve the conflict before retrying this request.

func (*ConflictException) Error 

func (e *ConflictException) Error() string

func (*ConflictException) ErrorCode 

func (e *ConflictException) ErrorCode() string

func (*ConflictException) ErrorFault 

func (e *ConflictException) ErrorFault() smithy.ErrorFault

func (*ConflictException) ErrorMessage 

func (e *ConflictException) ErrorMessage() string

type ConnectionPortRange added in v1.31.0 

type ConnectionPortRange struct {

	// Starting value for the port range.
	//
	// This member is required.
	FromPort *int32

	// Ending value for the port. Port numbers are end-inclusive. This value must be
	// equal to or greater than FromPort .
	//
	// This member is required.
	ToPort *int32
	// contains filtered or unexported fields
}

The set of port numbers to open on each instance in a container fleet. Connection ports are used by inbound traffic to connect with processes that are running in containers on the fleet.

type ContainerAttribute added in v1.37.0 

type ContainerAttribute struct {

	// The identifier for a container that's running in a compute.
	ContainerName *string

	// The runtime ID for the container that's running in a compute. This value is
	// unique within the compute.
	ContainerRuntimeId *string
	// contains filtered or unexported fields
}

A unique identifier for a container in a container fleet compute.

Returned by: DescribeCompute

type ContainerDependency added in v1.31.0 

type ContainerDependency struct {

	// The condition that the dependency container must reach before the dependent
	// container can start. Valid conditions include:
	//
	//   - START - The dependency container must have started.
	//
	//   - COMPLETE - The dependency container has run to completion (exits). Use this
	//   condition with nonessential containers, such as those that run a script and then
	//   exit. The dependency container can't be an essential container.
	//
	//   - SUCCESS - The dependency container has run to completion and exited with a
	//   zero status. The dependency container can't be an essential container.
	//
	//   - HEALTHY - The dependency container has passed its Docker health check. Use
	//   this condition with dependency containers that have health checks configured.
	//   This condition is confirmed at container group startup only.
	//
	// This member is required.
	Condition ContainerDependencyCondition

	// A descriptive label for the container definition that this container depends on.
	//
	// This member is required.
	ContainerName *string
	// contains filtered or unexported fields
}

A container's dependency on another container in the same container group. The dependency impacts how the dependent container is able to start or shut down based the status of the other container.

For example, ContainerA is configured with the following dependency: a START dependency on ContainerB. This means that ContainerA can't start until ContainerB has started. It also means that ContainerA must shut down before ContainerB.

eiifcbfhgrdurhnucnufkgbnbnnerrvbtjvljdetkehcPart of: GameServerContainerDefinition, GameServerContainerDefinitionInput, SupportContainerDefinition, SupportContainerDefinitionInput

type ContainerDependencyCondition added in v1.31.0 

type ContainerDependencyCondition string
const (
	ContainerDependencyConditionStart    ContainerDependencyCondition = "START"
	ContainerDependencyConditionComplete ContainerDependencyCondition = "COMPLETE"
	ContainerDependencyConditionSuccess  ContainerDependencyCondition = "SUCCESS"
	ContainerDependencyConditionHealthy  ContainerDependencyCondition = "HEALTHY"
)

Enum values for ContainerDependencyCondition

func (ContainerDependencyCondition) Values added in v1.31.0 

func (ContainerDependencyCondition) Values() []ContainerDependencyCondition

Values returns all known values for ContainerDependencyCondition. Note that this can be expanded in the future, and so it is only as up to date as the client.

The ordering of this slice is not guaranteed to be stable across updates.

type ContainerEnvironment added in v1.31.0 

type ContainerEnvironment struct {

	// The environment variable name.
	//
	// This member is required.
	Name *string

	// The environment variable value.
	//
	// This member is required.
	Value *string
	// contains filtered or unexported fields
}

An environment variable to set inside a container, in the form of a key-value pair.

Part of: GameServerContainerDefinition, GameServerContainerDefinitionInput, SupportContainerDefinition, SupportContainerDefinitionInput

type ContainerFleet added in v1.37.0 

type ContainerFleet struct {

	// Indicates whether the fleet uses On-Demand or Spot instances for this fleet.
	// Learn more about when to use [On-Demand versus Spot Instances]. You can't update this fleet property.
	//
	// By default, this property is set to ON_DEMAND .
	//
	// [On-Demand versus Spot Instances]: https://docs.aws.amazon.com/gamelift/latest/developerguide/gamelift-ec2-instances.html#gamelift-ec2-instances-spot
	BillingType ContainerFleetBillingType

	// A time stamp indicating when this data object was created. Format is a number
	// expressed in Unix time as milliseconds (for example "1469498468.057" ).
	CreationTime *time.Time

	// Information about the most recent deployment for the container fleet.
	DeploymentDetails *DeploymentDetails

	// A meaningful description of the container fleet.
	Description *string

	// The Amazon Resource Name ([ARN] ) that is assigned to a Amazon GameLift fleet
	// resource and uniquely identifies it. ARNs are unique across all Regions. Format
	// is arn:aws:gamelift:::fleet/fleet-a1234567-b8c9-0d1e-2fa3-b45c6d7e8912 . In a
	// GameLift fleet ARN, the resource ID matches the FleetId value.
	//
	// [ARN]: https://docs.aws.amazon.com/AmazonS3/latest/dev/s3-arn-format.html
	FleetArn *string

	// A unique identifier for the container fleet to retrieve.
	FleetId *string

	// The unique identifier for an Identity and Access Management (IAM) role with
	// permissions to run your containers on resources that are managed by Amazon
	// GameLift. See [Set up an IAM service role]. This fleet property can't be changed.
	//
	// [Set up an IAM service role]: https://docs.aws.amazon.com/gamelift/latest/developerguide/setting-up-role.html
	FleetRoleArn *string

	// The Amazon Resource Name ([ARN] ) that is assigned to the fleet's game server
	// container group. The ARN value also identifies the specific container group
	// definition version in use.
	//
	// [ARN]: https://docs.aws.amazon.com/AmazonS3/latest/dev/s3-arn-format.html
	GameServerContainerGroupDefinitionArn *string

	// The name of the fleet's game server container group definition, which describes
	// how to deploy containers with your game server build and support software onto
	// each fleet instance.
	GameServerContainerGroupDefinitionName *string

	// The number of times to replicate the game server container group on each fleet
	// instance.
	GameServerContainerGroupsPerInstance *int32

	// A policy that limits the number of game sessions that each individual player
	// can create on instances in this fleet. The limit applies for a specified span of
	// time.
	GameSessionCreationLimitPolicy *GameSessionCreationLimitPolicy

	// The set of port numbers to open on each instance in a container fleet.
	// Connection ports are used by inbound traffic to connect with processes that are
	// running in containers on the fleet.
	InstanceConnectionPortRange *ConnectionPortRange

	// The IP address ranges and port settings that allow inbound traffic to access
	// game server processes and other processes on this fleet.
	InstanceInboundPermissions []IpPermission

	// The Amazon EC2 instance type to use for all instances in the fleet. Instance
	// type determines the computing resources and processing power that's available to
	// host your game servers. This includes including CPU, memory, storage, and
	// networking capacity. You can't update this fleet property.
	InstanceType *string

	// Information about the container fleet's remote locations where fleet instances
	// are deployed.
	LocationAttributes []ContainerFleetLocationAttributes

	// The method that is used to collect container logs for the fleet. Amazon
	// GameLift saves all standard output for each container in logs, including game
	// session logs.
	//
	//   - CLOUDWATCH -- Send logs to an Amazon CloudWatch log group that you define.
	//   Each container emits a log stream, which is organized in the log group.
	//
	//   - S3 -- Store logs in an Amazon S3 bucket that you define.
	//
	//   - NONE -- Don't collect container logs.
	LogConfiguration *LogConfiguration

	// The calculated maximum number of game server container group that can be
	// deployed on each fleet instance. The calculation depends on the resource needs
	// of the container group and the CPU and memory resources of the fleet's instance
	// type.
	MaximumGameServerContainerGroupsPerInstance *int32

	// The name of an Amazon Web Services CloudWatch metric group to add this fleet
	// to. Metric groups aggregate metrics for multiple fleets.
	MetricGroups []string

	// Determines whether Amazon GameLift can shut down game sessions on the fleet
	// that are actively running and hosting players. Amazon GameLift might prompt an
	// instance shutdown when scaling down fleet capacity or when retiring unhealthy
	// instances. You can also set game session protection for individual game sessions
	// using UpdateGameSession.
	//
	//   - NoProtection -- Game sessions can be shut down during active gameplay.
	//
	//   - FullProtection -- Game sessions in ACTIVE status can't be shut down.
	NewGameSessionProtectionPolicy ProtectionPolicy

	// The Amazon Resource Name ([ARN] ) that is assigned to the fleet's per-instance
	// container group. The ARN value also identifies the specific container group
	// definition version in use.
	//
	// [ARN]: https://docs.aws.amazon.com/AmazonS3/latest/dev/s3-arn-format.html
	PerInstanceContainerGroupDefinitionArn *string

	// The name of the fleet's per-instance container group definition.
	PerInstanceContainerGroupDefinitionName *string

	// The current status of the container fleet.
	//
	//   - PENDING -- A new container fleet has been requested.
	//
	//   - CREATING -- A new container fleet resource is being created.
	//
	//   - CREATED -- A new container fleet resource has been created. No fleet
	//   instances have been deployed.
	//
	//   - ACTIVATING -- New container fleet instances are being deployed.
	//
	//   - ACTIVE -- The container fleet has been deployed and is ready to host game
	//   sessions.
	//
	//   - UPDATING -- Updates to the container fleet is being updated. A deployment is
	//   in progress.
	Status ContainerFleetStatus
	// contains filtered or unexported fields
}

Describes an Amazon GameLift managed container fleet.

type ContainerFleetBillingType added in v1.37.0 

type ContainerFleetBillingType string
const (
	ContainerFleetBillingTypeOnDemand ContainerFleetBillingType = "ON_DEMAND"
	ContainerFleetBillingTypeSpot     ContainerFleetBillingType = "SPOT"
)

Enum values for ContainerFleetBillingType

func (ContainerFleetBillingType) Values added in v1.37.0 

func (ContainerFleetBillingType) Values() []ContainerFleetBillingType

Values returns all known values for ContainerFleetBillingType. Note that this can be expanded in the future, and so it is only as up to date as the client.

The ordering of this slice is not guaranteed to be stable across updates.

type ContainerFleetLocationAttributes added in v1.37.0 

type ContainerFleetLocationAttributes struct {

	// A location identifier.
	Location *string

	// The status of fleet activity in the location.
	//
	//   - PENDING -- A new container fleet has been requested.
	//
	//   - CREATING -- A new container fleet resource is being created.
	//
	//   - CREATED -- A new container fleet resource has been created. No fleet
	//   instances have been deployed.
	//
	//   - ACTIVATING -- New container fleet instances are being deployed.
	//
	//   - ACTIVE -- The container fleet has been deployed and is ready to host game
	//   sessions.
	//
	//   - UPDATING -- Updates to the container fleet is being updated. A deployment is
	//   in progress.
	Status ContainerFleetLocationStatus
	// contains filtered or unexported fields
}

Details about a location in a multi-location container fleet.

type ContainerFleetLocationStatus added in v1.37.0 

type ContainerFleetLocationStatus string
const (
	ContainerFleetLocationStatusPending    ContainerFleetLocationStatus = "PENDING"
	ContainerFleetLocationStatusCreating   ContainerFleetLocationStatus = "CREATING"
	ContainerFleetLocationStatusCreated    ContainerFleetLocationStatus = "CREATED"
	ContainerFleetLocationStatusActivating ContainerFleetLocationStatus = "ACTIVATING"
	ContainerFleetLocationStatusActive     ContainerFleetLocationStatus = "ACTIVE"
	ContainerFleetLocationStatusUpdating   ContainerFleetLocationStatus = "UPDATING"
	ContainerFleetLocationStatusDeleting   ContainerFleetLocationStatus = "DELETING"
)

Enum values for ContainerFleetLocationStatus

func (ContainerFleetLocationStatus) Values added in v1.37.0 

func (ContainerFleetLocationStatus) Values() []ContainerFleetLocationStatus

Values returns all known values for ContainerFleetLocationStatus. Note that this can be expanded in the future, and so it is only as up to date as the client.

The ordering of this slice is not guaranteed to be stable across updates.

type ContainerFleetRemoveAttribute added in v1.37.0 

type ContainerFleetRemoveAttribute string
const (
	ContainerFleetRemoveAttributePerInstanceContainerGroupDefinition ContainerFleetRemoveAttribute = "PER_INSTANCE_CONTAINER_GROUP_DEFINITION"
)

Enum values for ContainerFleetRemoveAttribute

func (ContainerFleetRemoveAttribute) Values added in v1.37.0 

func (ContainerFleetRemoveAttribute) Values() []ContainerFleetRemoveAttribute

Values returns all known values for ContainerFleetRemoveAttribute. Note that this can be expanded in the future, and so it is only as up to date as the client.

The ordering of this slice is not guaranteed to be stable across updates.

type ContainerFleetStatus added in v1.37.0 

type ContainerFleetStatus string
const (
	ContainerFleetStatusPending    ContainerFleetStatus = "PENDING"
	ContainerFleetStatusCreating   ContainerFleetStatus = "CREATING"
	ContainerFleetStatusCreated    ContainerFleetStatus = "CREATED"
	ContainerFleetStatusActivating ContainerFleetStatus = "ACTIVATING"
	ContainerFleetStatusActive     ContainerFleetStatus = "ACTIVE"
	ContainerFleetStatusUpdating   ContainerFleetStatus = "UPDATING"
	ContainerFleetStatusDeleting   ContainerFleetStatus = "DELETING"
)

Enum values for ContainerFleetStatus

func (ContainerFleetStatus) Values added in v1.37.0 

func (ContainerFleetStatus) Values() []ContainerFleetStatus

Values returns all known values for ContainerFleetStatus. Note that this can be expanded in the future, and so it is only as up to date as the client.

The ordering of this slice is not guaranteed to be stable across updates.

type ContainerGroupDefinition added in v1.31.0 

type ContainerGroupDefinition struct {

	// A descriptive identifier for the container group definition. The name value is
	// unique in an Amazon Web Services Region.
	//
	// This member is required.
	Name *string

	// The Amazon Resource Name ([ARN] ) that is assigned to an Amazon GameLift
	// ContainerGroupDefinition resource. It uniquely identifies the resource across
	// all Amazon Web Services Regions. Format is
	// arn:aws:gamelift:[region]::containergroupdefinition/[container group definition
	// name]:[version] .
	//
	// [ARN]: https://docs.aws.amazon.com/AmazonS3/latest/dev/s3-arn-format.html
	ContainerGroupDefinitionArn *string

	// The type of container group. Container group type determines how Amazon
	// GameLift deploys the container group on each fleet instance.
	ContainerGroupType ContainerGroupType

	// A time stamp indicating when this data object was created. Format is a number
	// expressed in Unix time as milliseconds (for example "1469498468.057" ).
	CreationTime *time.Time

	// The definition for the game server container in this group. This property is
	// used only when the container group type is GAME_SERVER . This container
	// definition specifies a container image with the game server build.
	GameServerContainerDefinition *GameServerContainerDefinition

	// The platform that all containers in the container group definition run on.
	//
	// Amazon Linux 2 (AL2) will reach end of support on 6/30/2025. See more details
	// in the [Amazon Linux 2 FAQs]. For game servers that are hosted on AL2 and use Amazon GameLift server
	// SDK 4.x, first update the game server build to server SDK 5.x, and then deploy
	// to AL2023 instances. See [Migrate to Amazon GameLift server SDK version 5.]
	//
	// [Amazon Linux 2 FAQs]: https://aws.amazon.com/amazon-linux-2/faqs/
	// [Migrate to Amazon GameLift server SDK version 5.]: https://docs.aws.amazon.com/gamelift/latest/developerguide/reference-serversdk5-migration.html
	OperatingSystem ContainerOperatingSystem

	// Current status of the container group definition resource. Values include:
	//
	//   - COPYING -- Amazon GameLift is in the process of making copies of all
	//   container images that are defined in the group. While in this state, the
	//   resource can't be used to create a container fleet.
	//
	//   - READY -- Amazon GameLift has copied the registry images for all containers
	//   that are defined in the group. You can use a container group definition in this
	//   status to create a container fleet.
	//
	//   - FAILED -- Amazon GameLift failed to create a valid container group
	//   definition resource. For more details on the cause of the failure, see
	//   StatusReason . A container group definition resource in failed status will be
	//   deleted within a few minutes.
	Status ContainerGroupDefinitionStatus

	// Additional information about a container group definition that's in FAILED
	// status. Possible reasons include:
	//
	//   - An internal issue prevented Amazon GameLift from creating the container
	//   group definition resource. Delete the failed resource and call CreateContainerGroupDefinitionagain.
	//
	//   - An access-denied message means that you don't have permissions to access
	//   the container image on ECR. See [IAM permission examples]for help setting up required IAM permissions
	//   for Amazon GameLift.
	//
	//   - The ImageUri value for at least one of the containers in the container group
	//   definition was invalid or not found in the current Amazon Web Services account.
	//
	//   - At least one of the container images referenced in the container group
	//   definition exceeds the allowed size. For size limits, see [Amazon GameLift endpoints and quotas].
	//
	//   - At least one of the container images referenced in the container group
	//   definition uses a different operating system than the one defined for the
	//   container group.
	//
	// [IAM permission examples]: https://docs.aws.amazon.com/gamelift/latest/developerguide/gamelift-iam-policy-examples.html
	// [Amazon GameLift endpoints and quotas]: https://docs.aws.amazon.com/general/latest/gr/gamelift.html
	StatusReason *string

	// The set of definitions for support containers in this group. A container group
	// definition might have zero support container definitions. Support container can
	// be used in any type of container group.
	SupportContainerDefinitions []SupportContainerDefinition

	// The amount of memory (in MiB) on a fleet instance to allocate for the container
	// group. All containers in the group share these resources.
	//
	// You can set a limit for each container definition in the group. If individual
	// containers have limits, this total value must be greater than any individual
	// container's memory limit.
	TotalMemoryLimitMebibytes *int32

	// The amount of vCPU units on a fleet instance to allocate for the container
	// group (1 vCPU is equal to 1024 CPU units). All containers in the group share
	// these resources. You can set a limit for each container definition in the group.
	// If individual containers have limits, this total value must be equal to or
	// greater than the sum of the limits for each container in the group.
	TotalVcpuLimit *float64

	// An optional description that was provided for a container group definition
	// update. Each version can have a unique description.
	VersionDescription *string

	// Indicates the version of a particular container group definition. This number
	// is incremented automatically when you update a container group definition. You
	// can view, update, or delete individual versions or the entire container group
	// definition.
	VersionNumber *int32
	// contains filtered or unexported fields
}

The properties that describe a container group resource. You can update all properties of a container group definition properties. Updates to a container group definition are saved as new versions.

Used with: CreateContainerGroupDefinition

Returned by: DescribeContainerGroupDefinition, ListContainerGroupDefinitions, UpdateContainerGroupDefinition

type ContainerGroupDefinitionStatus added in v1.31.0 

type ContainerGroupDefinitionStatus string
const (
	ContainerGroupDefinitionStatusReady   ContainerGroupDefinitionStatus = "READY"
	ContainerGroupDefinitionStatusCopying ContainerGroupDefinitionStatus = "COPYING"
	ContainerGroupDefinitionStatusFailed  ContainerGroupDefinitionStatus = "FAILED"
)

Enum values for ContainerGroupDefinitionStatus

func (ContainerGroupDefinitionStatus) Values added in v1.31.0 

func (ContainerGroupDefinitionStatus) Values() []ContainerGroupDefinitionStatus

Values returns all known values for ContainerGroupDefinitionStatus. Note that this can be expanded in the future, and so it is only as up to date as the client.

The ordering of this slice is not guaranteed to be stable across updates.

type ContainerGroupType added in v1.37.0 

type ContainerGroupType string
const (
	ContainerGroupTypeGameServer  ContainerGroupType = "GAME_SERVER"
	ContainerGroupTypePerInstance ContainerGroupType = "PER_INSTANCE"
)

Enum values for ContainerGroupType

func (ContainerGroupType) Values added in v1.37.0 

func (ContainerGroupType) Values() []ContainerGroupType

Values returns all known values for ContainerGroupType. Note that this can be expanded in the future, and so it is only as up to date as the client.

The ordering of this slice is not guaranteed to be stable across updates.

type ContainerHealthCheck added in v1.31.0 

type ContainerHealthCheck struct {

	// A string array that specifies the command that the container runs to determine
	// if it's healthy.
	//
	// This member is required.
	Command []string

	// The time period (in seconds) between each health check.
	Interval *int32

	// The number of times to retry a failed health check before flagging the
	// container unhealthy. The first run of the command does not count as a retry.
	Retries *int32

	// The optional grace period (in seconds) to give a container time to bootstrap
	// before the first failed health check counts toward the number of retries.
	StartPeriod *int32

	// The time period (in seconds) to wait for a health check to succeed before
	// counting a failed health check.
	Timeout *int32
	// contains filtered or unexported fields
}

Instructions on when and how to check the health of a support container in a container fleet. These properties override any Docker health checks that are set in the container image. For more information on container health checks, see HealthCheck commandin the Amazon Elastic Container Service API. Game server containers don't have a health check parameter; Amazon GameLift automatically handles health checks for these containers.

The following example instructs the container to initiate a health check command every 60 seconds and wait 10 seconds for it to succeed. If it fails, retry the command 3 times before flagging the container as unhealthy. It also tells the container to wait 100 seconds after launch before counting failed health checks. 

{"Command": [ "CMD-SHELL", "ps cax | grep "processmanager" || exit 1" ],
"Interval": 60, "Timeout": 10, "Retries": 3, "StartPeriod": 100 }

Part of: SupportContainerDefinition, SupportContainerDefinitionInput

type ContainerIdentifier added in v1.37.0 

type ContainerIdentifier struct {

	// The identifier for a container that's running in a compute.
	ContainerName *string

	// The runtime ID for the container that's running in a compute. This value is
	// unique within the compute. It is returned as a ContainerAttribute value in a
	// Compute object.
	ContainerRuntimeId *string
	// contains filtered or unexported fields
}

A unique identifier for a container in a compute on a managed container fleet instance. This information makes it possible to remotely connect to a specific container on a fleet instance.

Related to: ContainerAttribute

Use with: GetComputeAccess

type ContainerMountPoint added in v1.37.0 

type ContainerMountPoint struct {

	// The path to the source file or directory.
	//
	// This member is required.
	InstancePath *string

	// The type of access for the container.
	AccessLevel ContainerMountPointAccessLevel

	// The mount path on the container. If this property isn't set, the instance path
	// is used.
	ContainerPath *string
	// contains filtered or unexported fields
}

A mount point that binds a container to a file or directory on the host system.

Part of: GameServerContainerDefinition, GameServerContainerDefinitionInput, SupportContainerDefinition, SupportContainerDefinitionInput

type ContainerMountPointAccessLevel added in v1.37.0 

type ContainerMountPointAccessLevel string
const (
	ContainerMountPointAccessLevelReadOnly     ContainerMountPointAccessLevel = "READ_ONLY"
	ContainerMountPointAccessLevelReadAndWrite ContainerMountPointAccessLevel = "READ_AND_WRITE"
)

Enum values for ContainerMountPointAccessLevel

func (ContainerMountPointAccessLevel) Values added in v1.37.0 

func (ContainerMountPointAccessLevel) Values() []ContainerMountPointAccessLevel

Values returns all known values for ContainerMountPointAccessLevel. Note that this can be expanded in the future, and so it is only as up to date as the client.

The ordering of this slice is not guaranteed to be stable across updates.

type ContainerOperatingSystem added in v1.31.0 

type ContainerOperatingSystem string
const (
	ContainerOperatingSystemAmazonLinux2023 ContainerOperatingSystem = "AMAZON_LINUX_2023"
)

Enum values for ContainerOperatingSystem

func (ContainerOperatingSystem) Values added in v1.31.0 

func (ContainerOperatingSystem) Values() []ContainerOperatingSystem

Values returns all known values for ContainerOperatingSystem. Note that this can be expanded in the future, and so it is only as up to date as the client.

The ordering of this slice is not guaranteed to be stable across updates.

type ContainerPortConfiguration added in v1.31.0 

type ContainerPortConfiguration struct {

	// A set of one or more container port number ranges. The ranges can't overlap.
	//
	// This member is required.
	ContainerPortRanges []ContainerPortRange
	// contains filtered or unexported fields
}

A set of port ranges that can be opened on the container. A process that's running in the container can bind to a port number, making it accessible to inbound traffic. Container ports map to a container fleet's connection ports.

Part of: GameServerContainerDefinition, GameServerContainerDefinitionInput, SupportContainerDefinition, SupportContainerDefinitionInput

type ContainerPortRange added in v1.31.0 

type ContainerPortRange struct {

	// A starting value for the range of allowed port numbers.
	//
	// This member is required.
	FromPort *int32

	// The network protocol that these ports support.
	//
	// This member is required.
	Protocol IpProtocol

	// An ending value for the range of allowed port numbers. Port numbers are
	// end-inclusive. This value must be equal to or greater than FromPort .
	//
	// This member is required.
	ToPort *int32
	// contains filtered or unexported fields
}

A set of one or more port numbers that can be opened on the container.

Part of: ContainerPortConfiguration

type DeploymentConfiguration added in v1.37.0 

type DeploymentConfiguration struct {

	// Determines what actions to take if a deployment fails. If the fleet is
	// multi-location, this strategy applies across all fleet locations. With a
	// rollback strategy, updated fleet instances are rolled back to the last
	// successful deployment. Alternatively, you can maintain a few impaired containers
	// for the purpose of debugging, while all other tasks return to the last
	// successful deployment.
	ImpairmentStrategy DeploymentImpairmentStrategy

	// Sets a minimum level of healthy tasks to maintain during deployment activity.
	MinimumHealthyPercentage *int32

	// Determines how fleet deployment activity affects active game sessions on the
	// fleet. With protection, a deployment honors game session protection, and delays
	// actions that would interrupt a protected active game session until the game
	// session ends. Without protection, deployment activity can shut down all running
	// tasks, including active game sessions, regardless of game session protection.
	ProtectionStrategy DeploymentProtectionStrategy
	// contains filtered or unexported fields
}

Set of rules for processing a deployment for a container fleet update.

type DeploymentDetails added in v1.37.0 

type DeploymentDetails struct {

	// A unique identifier for a fleet deployment.
	LatestDeploymentId *string
	// contains filtered or unexported fields
}

Information about the most recent deployment for the container fleet.

type DeploymentImpairmentStrategy added in v1.37.0 

type DeploymentImpairmentStrategy string
const (
	DeploymentImpairmentStrategyMaintain DeploymentImpairmentStrategy = "MAINTAIN"
	DeploymentImpairmentStrategyRollback DeploymentImpairmentStrategy = "ROLLBACK"
)

Enum values for DeploymentImpairmentStrategy

func (DeploymentImpairmentStrategy) Values added in v1.37.0 

func (DeploymentImpairmentStrategy) Values() []DeploymentImpairmentStrategy

Values returns all known values for DeploymentImpairmentStrategy. Note that this can be expanded in the future, and so it is only as up to date as the client.

The ordering of this slice is not guaranteed to be stable across updates.

type DeploymentProtectionStrategy added in v1.37.0 

type DeploymentProtectionStrategy string
const (
	DeploymentProtectionStrategyWithProtection   DeploymentProtectionStrategy = "WITH_PROTECTION"
	DeploymentProtectionStrategyIgnoreProtection DeploymentProtectionStrategy = "IGNORE_PROTECTION"
)

Enum values for DeploymentProtectionStrategy

func (DeploymentProtectionStrategy) Values added in v1.37.0 

func (DeploymentProtectionStrategy) Values() []DeploymentProtectionStrategy

Values returns all known values for DeploymentProtectionStrategy. Note that this can be expanded in the future, and so it is only as up to date as the client.

The ordering of this slice is not guaranteed to be stable across updates.

type DeploymentStatus added in v1.37.0 

type DeploymentStatus string
const (
	DeploymentStatusInProgress         DeploymentStatus = "IN_PROGRESS"
	DeploymentStatusImpaired           DeploymentStatus = "IMPAIRED"
	DeploymentStatusComplete           DeploymentStatus = "COMPLETE"
	DeploymentStatusRollbackInProgress DeploymentStatus = "ROLLBACK_IN_PROGRESS"
	DeploymentStatusRollbackComplete   DeploymentStatus = "ROLLBACK_COMPLETE"
	DeploymentStatusCancelled          DeploymentStatus = "CANCELLED"
	DeploymentStatusPending            DeploymentStatus = "PENDING"
)

Enum values for DeploymentStatus

func (DeploymentStatus) Values added in v1.37.0 

func (DeploymentStatus) Values() []DeploymentStatus

Values returns all known values for DeploymentStatus. Note that this can be expanded in the future, and so it is only as up to date as the client.

The ordering of this slice is not guaranteed to be stable across updates.

type DesiredPlayerSession 

type DesiredPlayerSession struct {

	// Developer-defined information related to a player. Amazon GameLift does not use
	// this data, so it can be formatted as needed for use in the game.
	PlayerData *string

	// A unique identifier for a player to associate with the player session.
	PlayerId *string
	// contains filtered or unexported fields
}

Player information for use when creating player sessions using a game session placement request.

type EC2InstanceCounts 

type EC2InstanceCounts struct {

	// Actual number of instances that are ready to host game sessions.
	ACTIVE *int32

	// Requested number of active instances. Amazon GameLift takes action as needed to
	// maintain the desired number of instances. Capacity is scaled up or down by
	// changing the desired instances. A change in the desired instances value can take
	// up to 1 minute to be reflected when viewing a fleet's capacity settings.
	DESIRED *int32

	// Number of active instances that are not currently hosting a game session.
	IDLE *int32

	// The maximum instance count value allowed.
	MAXIMUM *int32

	// The minimum instance count value allowed.
	MINIMUM *int32

	// Number of instances that are starting but not yet active.
	PENDING *int32

	// Number of instances that are no longer active but haven't yet been terminated.
	TERMINATING *int32
	// contains filtered or unexported fields
}

Resource capacity settings. Fleet capacity is measured in Amazon EC2 instances. Pending and terminating counts are non-zero when the fleet capacity is adjusting to a scaling event or if access to resources is temporarily affected.

type EC2InstanceLimit 

type EC2InstanceLimit struct {

	// The number of instances for the specified type and location that are currently
	// being used by the Amazon Web Services account.
	CurrentInstances *int32

	// The name of an Amazon EC2 instance type. See [Amazon Elastic Compute Cloud Instance Types] for detailed descriptions.
	//
	// [Amazon Elastic Compute Cloud Instance Types]: http://aws.amazon.com/ec2/instance-types/
	EC2InstanceType EC2InstanceType

	// The number of instances that is allowed for the specified instance type and
	// location.
	InstanceLimit *int32

	// An Amazon Web Services Region code, such as us-west-2 .
	Location *string
	// contains filtered or unexported fields
}

The Amazon GameLift service limits for an Amazon EC2 instance type and current utilization. Amazon GameLift allows Amazon Web Services accounts a maximum number of instances, per instance type, per Amazon Web Services Region or location, for use with Amazon GameLift. You can request an limit increase for your account by using the Service limits page in the Amazon GameLift console.

type EC2InstanceType 

type EC2InstanceType string
const (
	EC2InstanceTypeT2Micro      EC2InstanceType = "t2.micro"
	EC2InstanceTypeT2Small      EC2InstanceType = "t2.small"
	EC2InstanceTypeT2Medium     EC2InstanceType = "t2.medium"
	EC2InstanceTypeT2Large      EC2InstanceType = "t2.large"
	EC2InstanceTypeC3Large      EC2InstanceType = "c3.large"
	EC2InstanceTypeC3Xlarge     EC2InstanceType = "c3.xlarge"
	EC2InstanceTypeC32xlarge    EC2InstanceType = "c3.2xlarge"
	EC2InstanceTypeC34xlarge    EC2InstanceType = "c3.4xlarge"
	EC2InstanceTypeC38xlarge    EC2InstanceType = "c3.8xlarge"
	EC2InstanceTypeC4Large      EC2InstanceType = "c4.large"
	EC2InstanceTypeC4Xlarge     EC2InstanceType = "c4.xlarge"
	EC2InstanceTypeC42xlarge    EC2InstanceType = "c4.2xlarge"
	EC2InstanceTypeC44xlarge    EC2InstanceType = "c4.4xlarge"
	EC2InstanceTypeC48xlarge    EC2InstanceType = "c4.8xlarge"
	EC2InstanceTypeC5Large      EC2InstanceType = "c5.large"
	EC2InstanceTypeC5Xlarge     EC2InstanceType = "c5.xlarge"
	EC2InstanceTypeC52xlarge    EC2InstanceType = "c5.2xlarge"
	EC2InstanceTypeC54xlarge    EC2InstanceType = "c5.4xlarge"
	EC2InstanceTypeC59xlarge    EC2InstanceType = "c5.9xlarge"
	EC2InstanceTypeC512xlarge   EC2InstanceType = "c5.12xlarge"
	EC2InstanceTypeC518xlarge   EC2InstanceType = "c5.18xlarge"
	EC2InstanceTypeC524xlarge   EC2InstanceType = "c5.24xlarge"
	EC2InstanceTypeC5aLarge     EC2InstanceType = "c5a.large"
	EC2InstanceTypeC5aXlarge    EC2InstanceType = "c5a.xlarge"
	EC2InstanceTypeC5a2xlarge   EC2InstanceType = "c5a.2xlarge"
	EC2InstanceTypeC5a4xlarge   EC2InstanceType = "c5a.4xlarge"
	EC2InstanceTypeC5a8xlarge   EC2InstanceType = "c5a.8xlarge"
	EC2InstanceTypeC5a12xlarge  EC2InstanceType = "c5a.12xlarge"
	EC2InstanceTypeC5a16xlarge  EC2InstanceType = "c5a.16xlarge"
	EC2InstanceTypeC5a24xlarge  EC2InstanceType = "c5a.24xlarge"
	EC2InstanceTypeR3Large      EC2InstanceType = "r3.large"
	EC2InstanceTypeR3Xlarge     EC2InstanceType = "r3.xlarge"
	EC2InstanceTypeR32xlarge    EC2InstanceType = "r3.2xlarge"
	EC2InstanceTypeR34xlarge    EC2InstanceType = "r3.4xlarge"
	EC2InstanceTypeR38xlarge    EC2InstanceType = "r3.8xlarge"
	EC2InstanceTypeR4Large      EC2InstanceType = "r4.large"
	EC2InstanceTypeR4Xlarge     EC2InstanceType = "r4.xlarge"
	EC2InstanceTypeR42xlarge    EC2InstanceType = "r4.2xlarge"
	EC2InstanceTypeR44xlarge    EC2InstanceType = "r4.4xlarge"
	EC2InstanceTypeR48xlarge    EC2InstanceType = "r4.8xlarge"
	EC2InstanceTypeR416xlarge   EC2InstanceType = "r4.16xlarge"
	EC2InstanceTypeR5Large      EC2InstanceType = "r5.large"
	EC2InstanceTypeR5Xlarge     EC2InstanceType = "r5.xlarge"
	EC2InstanceTypeR52xlarge    EC2InstanceType = "r5.2xlarge"
	EC2InstanceTypeR54xlarge    EC2InstanceType = "r5.4xlarge"
	EC2InstanceTypeR58xlarge    EC2InstanceType = "r5.8xlarge"
	EC2InstanceTypeR512xlarge   EC2InstanceType = "r5.12xlarge"
	EC2InstanceTypeR516xlarge   EC2InstanceType = "r5.16xlarge"
	EC2InstanceTypeR524xlarge   EC2InstanceType = "r5.24xlarge"
	EC2InstanceTypeR5aLarge     EC2InstanceType = "r5a.large"
	EC2InstanceTypeR5aXlarge    EC2InstanceType = "r5a.xlarge"
	EC2InstanceTypeR5a2xlarge   EC2InstanceType = "r5a.2xlarge"
	EC2InstanceTypeR5a4xlarge   EC2InstanceType = "r5a.4xlarge"
	EC2InstanceTypeR5a8xlarge   EC2InstanceType = "r5a.8xlarge"
	EC2InstanceTypeR5a12xlarge  EC2InstanceType = "r5a.12xlarge"
	EC2InstanceTypeR5a16xlarge  EC2InstanceType = "r5a.16xlarge"
	EC2InstanceTypeR5a24xlarge  EC2InstanceType = "r5a.24xlarge"
	EC2InstanceTypeM3Medium     EC2InstanceType = "m3.medium"
	EC2InstanceTypeM3Large      EC2InstanceType = "m3.large"
	EC2InstanceTypeM3Xlarge     EC2InstanceType = "m3.xlarge"
	EC2InstanceTypeM32xlarge    EC2InstanceType = "m3.2xlarge"
	EC2InstanceTypeM4Large      EC2InstanceType = "m4.large"
	EC2InstanceTypeM4Xlarge     EC2InstanceType = "m4.xlarge"
	EC2InstanceTypeM42xlarge    EC2InstanceType = "m4.2xlarge"
	EC2InstanceTypeM44xlarge    EC2InstanceType = "m4.4xlarge"
	EC2InstanceTypeM410xlarge   EC2InstanceType = "m4.10xlarge"
	EC2InstanceTypeM5Large      EC2InstanceType = "m5.large"
	EC2InstanceTypeM5Xlarge     EC2InstanceType = "m5.xlarge"
	EC2InstanceTypeM52xlarge    EC2InstanceType = "m5.2xlarge"
	EC2InstanceTypeM54xlarge    EC2InstanceType = "m5.4xlarge"
	EC2InstanceTypeM58xlarge    EC2InstanceType = "m5.8xlarge"
	EC2InstanceTypeM512xlarge   EC2InstanceType = "m5.12xlarge"
	EC2InstanceTypeM516xlarge   EC2InstanceType = "m5.16xlarge"
	EC2InstanceTypeM524xlarge   EC2InstanceType = "m5.24xlarge"
	EC2InstanceTypeM5aLarge     EC2InstanceType = "m5a.large"
	EC2InstanceTypeM5aXlarge    EC2InstanceType = "m5a.xlarge"
	EC2InstanceTypeM5a2xlarge   EC2InstanceType = "m5a.2xlarge"
	EC2InstanceTypeM5a4xlarge   EC2InstanceType = "m5a.4xlarge"
	EC2InstanceTypeM5a8xlarge   EC2InstanceType = "m5a.8xlarge"
	EC2InstanceTypeM5a12xlarge  EC2InstanceType = "m5a.12xlarge"
	EC2InstanceTypeM5a16xlarge  EC2InstanceType = "m5a.16xlarge"
	EC2InstanceTypeM5a24xlarge  EC2InstanceType = "m5a.24xlarge"
	EC2InstanceTypeC5dLarge     EC2InstanceType = "c5d.large"
	EC2InstanceTypeC5dXlarge    EC2InstanceType = "c5d.xlarge"
	EC2InstanceTypeC5d2xlarge   EC2InstanceType = "c5d.2xlarge"
	EC2InstanceTypeC5d4xlarge   EC2InstanceType = "c5d.4xlarge"
	EC2InstanceTypeC5d9xlarge   EC2InstanceType = "c5d.9xlarge"
	EC2InstanceTypeC5d12xlarge  EC2InstanceType = "c5d.12xlarge"
	EC2InstanceTypeC5d18xlarge  EC2InstanceType = "c5d.18xlarge"
	EC2InstanceTypeC5d24xlarge  EC2InstanceType = "c5d.24xlarge"
	EC2InstanceTypeC6aLarge     EC2InstanceType = "c6a.large"
	EC2InstanceTypeC6aXlarge    EC2InstanceType = "c6a.xlarge"
	EC2InstanceTypeC6a2xlarge   EC2InstanceType = "c6a.2xlarge"
	EC2InstanceTypeC6a4xlarge   EC2InstanceType = "c6a.4xlarge"
	EC2InstanceTypeC6a8xlarge   EC2InstanceType = "c6a.8xlarge"
	EC2InstanceTypeC6a12xlarge  EC2InstanceType = "c6a.12xlarge"
	EC2InstanceTypeC6a16xlarge  EC2InstanceType = "c6a.16xlarge"
	EC2InstanceTypeC6a24xlarge  EC2InstanceType = "c6a.24xlarge"
	EC2InstanceTypeC6iLarge     EC2InstanceType = "c6i.large"
	EC2InstanceTypeC6iXlarge    EC2InstanceType = "c6i.xlarge"
	EC2InstanceTypeC6i2xlarge   EC2InstanceType = "c6i.2xlarge"
	EC2InstanceTypeC6i4xlarge   EC2InstanceType = "c6i.4xlarge"
	EC2InstanceTypeC6i8xlarge   EC2InstanceType = "c6i.8xlarge"
	EC2InstanceTypeC6i12xlarge  EC2InstanceType = "c6i.12xlarge"
	EC2InstanceTypeC6i16xlarge  EC2InstanceType = "c6i.16xlarge"
	EC2InstanceTypeC6i24xlarge  EC2InstanceType = "c6i.24xlarge"
	EC2InstanceTypeR5dLarge     EC2InstanceType = "r5d.large"
	EC2InstanceTypeR5dXlarge    EC2InstanceType = "r5d.xlarge"
	EC2InstanceTypeR5d2xlarge   EC2InstanceType = "r5d.2xlarge"
	EC2InstanceTypeR5d4xlarge   EC2InstanceType = "r5d.4xlarge"
	EC2InstanceTypeR5d8xlarge   EC2InstanceType = "r5d.8xlarge"
	EC2InstanceTypeR5d12xlarge  EC2InstanceType = "r5d.12xlarge"
	EC2InstanceTypeR5d16xlarge  EC2InstanceType = "r5d.16xlarge"
	EC2InstanceTypeR5d24xlarge  EC2InstanceType = "r5d.24xlarge"
	EC2InstanceTypeM6gMedium    EC2InstanceType = "m6g.medium"
	EC2InstanceTypeM6gLarge     EC2InstanceType = "m6g.large"
	EC2InstanceTypeM6gXlarge    EC2InstanceType = "m6g.xlarge"
	EC2InstanceTypeM6g2xlarge   EC2InstanceType = "m6g.2xlarge"
	EC2InstanceTypeM6g4xlarge   EC2InstanceType = "m6g.4xlarge"
	EC2InstanceTypeM6g8xlarge   EC2InstanceType = "m6g.8xlarge"
	EC2InstanceTypeM6g12xlarge  EC2InstanceType = "m6g.12xlarge"
	EC2InstanceTypeM6g16xlarge  EC2InstanceType = "m6g.16xlarge"
	EC2InstanceTypeC6gMedium    EC2InstanceType = "c6g.medium"
	EC2InstanceTypeC6gLarge     EC2InstanceType = "c6g.large"
	EC2InstanceTypeC6gXlarge    EC2InstanceType = "c6g.xlarge"
	EC2InstanceTypeC6g2xlarge   EC2InstanceType = "c6g.2xlarge"
	EC2InstanceTypeC6g4xlarge   EC2InstanceType = "c6g.4xlarge"
	EC2InstanceTypeC6g8xlarge   EC2InstanceType = "c6g.8xlarge"
	EC2InstanceTypeC6g12xlarge  EC2InstanceType = "c6g.12xlarge"
	EC2InstanceTypeC6g16xlarge  EC2InstanceType = "c6g.16xlarge"
	EC2InstanceTypeR6gMedium    EC2InstanceType = "r6g.medium"
	EC2InstanceTypeR6gLarge     EC2InstanceType = "r6g.large"
	EC2InstanceTypeR6gXlarge    EC2InstanceType = "r6g.xlarge"
	EC2InstanceTypeR6g2xlarge   EC2InstanceType = "r6g.2xlarge"
	EC2InstanceTypeR6g4xlarge   EC2InstanceType = "r6g.4xlarge"
	EC2InstanceTypeR6g8xlarge   EC2InstanceType = "r6g.8xlarge"
	EC2InstanceTypeR6g12xlarge  EC2InstanceType = "r6g.12xlarge"
	EC2InstanceTypeR6g16xlarge  EC2InstanceType = "r6g.16xlarge"
	EC2InstanceTypeC6gnMedium   EC2InstanceType = "c6gn.medium"
	EC2InstanceTypeC6gnLarge    EC2InstanceType = "c6gn.large"
	EC2InstanceTypeC6gnXlarge   EC2InstanceType = "c6gn.xlarge"
	EC2InstanceTypeC6gn2xlarge  EC2InstanceType = "c6gn.2xlarge"
	EC2InstanceTypeC6gn4xlarge  EC2InstanceType = "c6gn.4xlarge"
	EC2InstanceTypeC6gn8xlarge  EC2InstanceType = "c6gn.8xlarge"
	EC2InstanceTypeC6gn12xlarge EC2InstanceType = "c6gn.12xlarge"
	EC2InstanceTypeC6gn16xlarge EC2InstanceType = "c6gn.16xlarge"
	EC2InstanceTypeC7gMedium    EC2InstanceType = "c7g.medium"
	EC2InstanceTypeC7gLarge     EC2InstanceType = "c7g.large"
	EC2InstanceTypeC7gXlarge    EC2InstanceType = "c7g.xlarge"
	EC2InstanceTypeC7g2xlarge   EC2InstanceType = "c7g.2xlarge"
	EC2InstanceTypeC7g4xlarge   EC2InstanceType = "c7g.4xlarge"
	EC2InstanceTypeC7g8xlarge   EC2InstanceType = "c7g.8xlarge"
	EC2InstanceTypeC7g12xlarge  EC2InstanceType = "c7g.12xlarge"
	EC2InstanceTypeC7g16xlarge  EC2InstanceType = "c7g.16xlarge"
	EC2InstanceTypeR7gMedium    EC2InstanceType = "r7g.medium"
	EC2InstanceTypeR7gLarge     EC2InstanceType = "r7g.large"
	EC2InstanceTypeR7gXlarge    EC2InstanceType = "r7g.xlarge"
	EC2InstanceTypeR7g2xlarge   EC2InstanceType = "r7g.2xlarge"
	EC2InstanceTypeR7g4xlarge   EC2InstanceType = "r7g.4xlarge"
	EC2InstanceTypeR7g8xlarge   EC2InstanceType = "r7g.8xlarge"
	EC2InstanceTypeR7g12xlarge  EC2InstanceType = "r7g.12xlarge"
	EC2InstanceTypeR7g16xlarge  EC2InstanceType = "r7g.16xlarge"
	EC2InstanceTypeM7gMedium    EC2InstanceType = "m7g.medium"
	EC2InstanceTypeM7gLarge     EC2InstanceType = "m7g.large"
	EC2InstanceTypeM7gXlarge    EC2InstanceType = "m7g.xlarge"
	EC2InstanceTypeM7g2xlarge   EC2InstanceType = "m7g.2xlarge"
	EC2InstanceTypeM7g4xlarge   EC2InstanceType = "m7g.4xlarge"
	EC2InstanceTypeM7g8xlarge   EC2InstanceType = "m7g.8xlarge"
	EC2InstanceTypeM7g12xlarge  EC2InstanceType = "m7g.12xlarge"
	EC2InstanceTypeM7g16xlarge  EC2InstanceType = "m7g.16xlarge"
	EC2InstanceTypeG5gXlarge    EC2InstanceType = "g5g.xlarge"
	EC2InstanceTypeG5g2xlarge   EC2InstanceType = "g5g.2xlarge"
	EC2InstanceTypeG5g4xlarge   EC2InstanceType = "g5g.4xlarge"
	EC2InstanceTypeG5g8xlarge   EC2InstanceType = "g5g.8xlarge"
	EC2InstanceTypeG5g16xlarge  EC2InstanceType = "g5g.16xlarge"
)

Enum values for EC2InstanceType

func (EC2InstanceType) Values added in v0.29.0 

func (EC2InstanceType) Values() []EC2InstanceType

Values returns all known values for EC2InstanceType. Note that this can be expanded in the future, and so it is only as up to date as the client.

The ordering of this slice is not guaranteed to be stable across updates.

type Event 

type Event struct {

	// The number of times that this event occurred.
	Count *int64

	// The type of event being logged.
	//
	// Fleet state transition events:
	//
	//   - FLEET_CREATED -- A fleet resource was successfully created with a status of
	//   NEW . Event messaging includes the fleet ID.
	//
	//   - FLEET_STATE_DOWNLOADING -- Fleet status changed from NEW to DOWNLOADING .
	//   Amazon GameLift is downloading the compressed build and running install scripts.
	//
	//   - FLEET_STATE_VALIDATING -- Fleet status changed from DOWNLOADING to
	//   VALIDATING . Amazon GameLift has successfully installed build and is now
	//   validating the build files.
	//
	//   - FLEET_STATE_BUILDING -- Fleet status changed from VALIDATING to BUILDING .
	//   Amazon GameLift has successfully verified the build files and is now launching a
	//   fleet instance.
	//
	//   - FLEET_STATE_ACTIVATING -- Fleet status changed from BUILDING to ACTIVATING .
	//   Amazon GameLift is launching a game server process on the fleet instance and is
	//   testing its connectivity with the Amazon GameLift service.
	//
	//   - FLEET_STATE_ACTIVE -- The fleet's status changed from ACTIVATING to ACTIVE .
	//   The fleet is now ready to host game sessions.
	//
	//   - FLEET_STATE_ERROR -- The Fleet's status changed to ERROR . Describe the
	//   fleet event message for more details.
	//
	// Fleet creation events (ordered by fleet creation activity):
	//
	//   - FLEET_BINARY_DOWNLOAD_FAILED -- The build failed to download to the fleet
	//   instance.
	//
	//   - FLEET_CREATION_EXTRACTING_BUILD -- The game server build was successfully
	//   downloaded to an instance, and Amazon GameLiftis now extracting the build files
	//   from the uploaded build. Failure at this stage prevents a fleet from moving to
	//   ACTIVE status. Logs for this stage display a list of the files that are
	//   extracted and saved on the instance. Access the logs by using the URL in
	//   PreSignedLogUrl.
	//
	//   - FLEET_CREATION_RUNNING_INSTALLER -- The game server build files were
	//   successfully extracted, and Amazon GameLift is now running the build's install
	//   script (if one is included). Failure in this stage prevents a fleet from moving
	//   to ACTIVE status. Logs for this stage list the installation steps and whether or
	//   not the install completed successfully. Access the logs by using the URL in
	//   PreSignedLogUrl.
	//
	//   - FLEET_CREATION_COMPLETED_INSTALLER -- The game server build files were
	//   successfully installed and validation of the installation will begin soon.
	//
	//   - FLEET_CREATION_FAILED_INSTALLER -- The installed failed while attempting to
	//   install the build files. This event indicates that the failure occurred before
	//   Amazon GameLift could start validation.
	//
	//   - FLEET_CREATION_VALIDATING_RUNTIME_CONFIG -- The build process was
	//   successful, and the GameLift is now verifying that the game server launch paths,
	//   which are specified in the fleet's runtime configuration, exist. If any listed
	//   launch path exists, Amazon GameLift tries to launch a game server process and
	//   waits for the process to report ready. Failures in this stage prevent a fleet
	//   from moving to ACTIVE status. Logs for this stage list the launch paths in the
	//   runtime configuration and indicate whether each is found. Access the logs by
	//   using the URL in PreSignedLogUrl.
	//
	//   - FLEET_VALIDATION_LAUNCH_PATH_NOT_FOUND -- Validation of the runtime
	//   configuration failed because the executable specified in a launch path does not
	//   exist on the instance.
	//
	//   - FLEET_VALIDATION_EXECUTABLE_RUNTIME_FAILURE -- Validation of the runtime
	//   configuration failed because the executable specified in a launch path failed to
	//   run on the fleet instance.
	//
	//   - FLEET_VALIDATION_TIMED_OUT -- Validation of the fleet at the end of
	//   creation timed out. Try fleet creation again.
	//
	//   - FLEET_ACTIVATION_FAILED -- The fleet failed to successfully complete one of
	//   the steps in the fleet activation process. This event code indicates that the
	//   game build was successfully downloaded to a fleet instance, built, and
	//   validated, but was not able to start a server process. For more information, see
	//   [Debug Fleet Creation Issues].
	//
	//   - FLEET_ACTIVATION_FAILED_NO_INSTANCES -- Fleet creation was not able to
	//   obtain any instances based on the input fleet attributes. Try again at a
	//   different time or choose a different combination of fleet attributes such as
	//   fleet type, instance type, etc.
	//
	//   - FLEET_INITIALIZATION_FAILED -- A generic exception occurred during fleet
	//   creation. Describe the fleet event message for more details.
	//
	// VPC peering events:
	//
	//   - FLEET_VPC_PEERING_SUCCEEDED -- A VPC peering connection has been
	//   established between the VPC for an Amazon GameLift fleet and a VPC in your
	//   Amazon Web Services account.
	//
	//   - FLEET_VPC_PEERING_FAILED -- A requested VPC peering connection has failed.
	//   Event details and status information provide additional detail. A common reason
	//   for peering failure is that the two VPCs have overlapping CIDR blocks of IPv4
	//   addresses. To resolve this, change the CIDR block for the VPC in your Amazon Web
	//   Services account. For more information on VPC peering failures, see [https://docs.aws.amazon.com/AmazonVPC/latest/PeeringGuide/invalid-peering-configurations.html]
	//
	//   - FLEET_VPC_PEERING_DELETED -- A VPC peering connection has been successfully
	//   deleted.
	//
	// Container group events:
	//
	//   - CONTAINER_GROUP_REGISTRATION_FAILED – A game server container group
	//   started, but timed out before calling RegisterCompute .
	//
	//   - CONTAINER_GROUP_CRASHED A game server container group started and
	//   terminated without calling RegisterCompute .
	//
	// Spot instance events:
	//
	//   - INSTANCE_INTERRUPTED -- A spot instance was interrupted by EC2 with a
	//   two-minute notification.
	//
	//   - INSTANCE_RECYCLED -- A spot instance was determined to have a high risk of
	//   interruption and is scheduled to be recycled once it has no active game
	//   sessions.
	//
	// Server process events:
	//
	//   - SERVER_PROCESS_INVALID_PATH -- The game server executable or script could
	//   not be found based on the Fleet runtime configuration. Check that the launch
	//   path is correct based on the operating system of the Fleet.
	//
	//   - SERVER_PROCESS_SDK_INITIALIZATION_TIMEOUT -- The server process did not
	//   call InitSDK() within the time expected (5 minutes). Check your game session
	//   log to see why InitSDK() was not called in time.
	//
	//   - SERVER_PROCESS_PROCESS_READY_TIMEOUT -- The server process did not call
	//   ProcessReady() within the time expected (5 minutes) after calling InitSDK() .
	//   Check your game session log to see why ProcessReady() was not called in time.
	//
	//   - SERVER_PROCESS_CRASHED -- The server process exited without calling
	//   ProcessEnding() . Check your game session log to see why ProcessEnding() was
	//   not called.
	//
	//   - SERVER_PROCESS_TERMINATED_UNHEALTHY -- The server process did not report a
	//   valid health check for too long and was therefore terminated by GameLift. Check
	//   your game session log to see if the thread became stuck processing a synchronous
	//   task for too long.
	//
	//   - SERVER_PROCESS_FORCE_TERMINATED -- The server process did not exit cleanly
	//   within the time expected after OnProcessTerminate() was sent. Check your game
	//   session log to see why termination took longer than expected.
	//
	//   - SERVER_PROCESS_PROCESS_EXIT_TIMEOUT -- The server process did not exit
	//   cleanly within the time expected (30 seconds) after calling ProcessEnding() .
	//   Check your game session log to see why termination took longer than expected.
	//
	// Game session events:
	//
	//   - GAME_SESSION_ACTIVATION_TIMEOUT -- GameSession failed to activate within
	//   the expected time. Check your game session log to see why
	//   ActivateGameSession() took longer to complete than expected.
	//
	// Other fleet events:
	//
	//   - FLEET_SCALING_EVENT -- A change was made to the fleet's capacity settings
	//   (desired instances, minimum/maximum scaling limits). Event messaging includes
	//   the new capacity settings.
	//
	//   - FLEET_NEW_GAME_SESSION_PROTECTION_POLICY_UPDATED -- A change was made to
	//   the fleet's game session protection policy setting. Event messaging includes
	//   both the old and new policy setting.
	//
	//   - FLEET_DELETED -- A request to delete a fleet was initiated.
	//
	//   - GENERIC_EVENT -- An unspecified event has occurred.
	//
	// [Debug Fleet Creation Issues]: https://docs.aws.amazon.com/gamelift/latest/developerguide/fleets-creating-debug.html#fleets-creating-debug-creation
	// [https://docs.aws.amazon.com/AmazonVPC/latest/PeeringGuide/invalid-peering-configurations.html]: https://docs.aws.amazon.com/AmazonVPC/latest/PeeringGuide/invalid-peering-configurations.html
	EventCode EventCode

	// A unique identifier for a fleet event.
	EventId *string

	// Time stamp indicating when this event occurred. Format is a number expressed in
	// Unix time as milliseconds (for example "1469498468.057" ).
	EventTime *time.Time

	// Additional information related to the event.
	Message *string

	// Location of stored logs with additional detail that is related to the event.
	// This is useful for debugging issues. The URL is valid for 15 minutes. You can
	// also access fleet creation logs through the Amazon GameLift console.
	PreSignedLogUrl *string

	// A unique identifier for an event resource, such as a fleet ID.
	ResourceId *string
	// contains filtered or unexported fields
}

Log entry describing an event that involves Amazon GameLift resources (such as a fleet). In addition to tracking activity, event codes and messages can provide additional information for troubleshooting and debugging problems.

type EventCode 

type EventCode string
const (
	EventCodeGenericEvent                               EventCode = "GENERIC_EVENT"
	EventCodeFleetCreated                               EventCode = "FLEET_CREATED"
	EventCodeFleetDeleted                               EventCode = "FLEET_DELETED"
	EventCodeFleetScalingEvent                          EventCode = "FLEET_SCALING_EVENT"
	EventCodeFleetStateDownloading                      EventCode = "FLEET_STATE_DOWNLOADING"
	EventCodeFleetStateValidating                       EventCode = "FLEET_STATE_VALIDATING"
	EventCodeFleetStateBuilding                         EventCode = "FLEET_STATE_BUILDING"
	EventCodeFleetStateActivating                       EventCode = "FLEET_STATE_ACTIVATING"
	EventCodeFleetStateActive                           EventCode = "FLEET_STATE_ACTIVE"
	EventCodeFleetStateError                            EventCode = "FLEET_STATE_ERROR"
	EventCodeFleetStatePending                          EventCode = "FLEET_STATE_PENDING"
	EventCodeFleetStateCreating                         EventCode = "FLEET_STATE_CREATING"
	EventCodeFleetStateCreated                          EventCode = "FLEET_STATE_CREATED"
	EventCodeFleetStateUpdating                         EventCode = "FLEET_STATE_UPDATING"
	EventCodeFleetInitializationFailed                  EventCode = "FLEET_INITIALIZATION_FAILED"
	EventCodeFleetBinaryDownloadFailed                  EventCode = "FLEET_BINARY_DOWNLOAD_FAILED"
	EventCodeFleetValidationLaunchPathNotFound          EventCode = "FLEET_VALIDATION_LAUNCH_PATH_NOT_FOUND"
	EventCodeFleetValidationExecutableRuntimeFailure    EventCode = "FLEET_VALIDATION_EXECUTABLE_RUNTIME_FAILURE"
	EventCodeFleetValidationTimedOut                    EventCode = "FLEET_VALIDATION_TIMED_OUT"
	EventCodeFleetActivationFailed                      EventCode = "FLEET_ACTIVATION_FAILED"
	EventCodeFleetActivationFailedNoInstances           EventCode = "FLEET_ACTIVATION_FAILED_NO_INSTANCES"
	EventCodeFleetNewGameSessionProtectionPolicyUpdated EventCode = "FLEET_NEW_GAME_SESSION_PROTECTION_POLICY_UPDATED"
	EventCodeServerProcessInvalidPath                   EventCode = "SERVER_PROCESS_INVALID_PATH"
	EventCodeServerProcessSdkInitializationTimeout      EventCode = "SERVER_PROCESS_SDK_INITIALIZATION_TIMEOUT"
	EventCodeServerProcessProcessReadyTimeout           EventCode = "SERVER_PROCESS_PROCESS_READY_TIMEOUT"
	EventCodeServerProcessCrashed                       EventCode = "SERVER_PROCESS_CRASHED"
	EventCodeServerProcessTerminatedUnhealthy           EventCode = "SERVER_PROCESS_TERMINATED_UNHEALTHY"
	EventCodeServerProcessForceTerminated               EventCode = "SERVER_PROCESS_FORCE_TERMINATED"
	EventCodeServerProcessProcessExitTimeout            EventCode = "SERVER_PROCESS_PROCESS_EXIT_TIMEOUT"
	EventCodeServerProcessSdkInitializationFailed       EventCode = "SERVER_PROCESS_SDK_INITIALIZATION_FAILED"
	EventCodeServerProcessMisconfiguredContainerPort    EventCode = "SERVER_PROCESS_MISCONFIGURED_CONTAINER_PORT"
	EventCodeGameSessionActivationTimeout               EventCode = "GAME_SESSION_ACTIVATION_TIMEOUT"
	EventCodeFleetCreationExtractingBuild               EventCode = "FLEET_CREATION_EXTRACTING_BUILD"
	EventCodeFleetCreationRunningInstaller              EventCode = "FLEET_CREATION_RUNNING_INSTALLER"
	EventCodeFleetCreationValidatingRuntimeConfig       EventCode = "FLEET_CREATION_VALIDATING_RUNTIME_CONFIG"
	EventCodeFleetVpcPeeringSucceeded                   EventCode = "FLEET_VPC_PEERING_SUCCEEDED"
	EventCodeFleetVpcPeeringFailed                      EventCode = "FLEET_VPC_PEERING_FAILED"
	EventCodeFleetVpcPeeringDeleted                     EventCode = "FLEET_VPC_PEERING_DELETED"
	EventCodeInstanceInterrupted                        EventCode = "INSTANCE_INTERRUPTED"
	EventCodeInstanceRecycled                           EventCode = "INSTANCE_RECYCLED"
	EventCodeInstanceReplacedUnhealthy                  EventCode = "INSTANCE_REPLACED_UNHEALTHY"
	EventCodeFleetCreationCompletedInstaller            EventCode = "FLEET_CREATION_COMPLETED_INSTALLER"
	EventCodeFleetCreationFailedInstaller               EventCode = "FLEET_CREATION_FAILED_INSTALLER"
	EventCodeComputeLogUploadFailed                     EventCode = "COMPUTE_LOG_UPLOAD_FAILED"
	EventCodeGameServerContainerGroupCrashed            EventCode = "GAME_SERVER_CONTAINER_GROUP_CRASHED"
	EventCodePerInstanceContainerGroupCrashed           EventCode = "PER_INSTANCE_CONTAINER_GROUP_CRASHED"
	EventCodeGameServerContainerGroupReplacedUnhealthy  EventCode = "GAME_SERVER_CONTAINER_GROUP_REPLACED_UNHEALTHY"
	EventCodeLocationStatePending                       EventCode = "LOCATION_STATE_PENDING"
	EventCodeLocationStateCreating                      EventCode = "LOCATION_STATE_CREATING"
	EventCodeLocationStateCreated                       EventCode = "LOCATION_STATE_CREATED"
	EventCodeLocationStateActivating                    EventCode = "LOCATION_STATE_ACTIVATING"
	EventCodeLocationStateActive                        EventCode = "LOCATION_STATE_ACTIVE"
	EventCodeLocationStateUpdating                      EventCode = "LOCATION_STATE_UPDATING"
	EventCodeLocationStateError                         EventCode = "LOCATION_STATE_ERROR"
	EventCodeLocationStateDeleting                      EventCode = "LOCATION_STATE_DELETING"
	EventCodeLocationStateDeleted                       EventCode = "LOCATION_STATE_DELETED"
)

Enum values for EventCode

func (EventCode) Values added in v0.29.0 

func (EventCode) Values() []EventCode

Values returns all known values for EventCode. Note that this can be expanded in the future, and so it is only as up to date as the client.

The ordering of this slice is not guaranteed to be stable across updates.

type FilterConfiguration added in v1.2.0 

type FilterConfiguration struct {

	//  A list of locations to allow game session placement in, in the form of Amazon
	// Web Services Region codes such as us-west-2 .
	AllowedLocations []string
	// contains filtered or unexported fields
}

A list of fleet locations where a game session queue can place new game sessions. You can use a filter to temporarily turn off placements for specific locations. For queues that have multi-location fleets, you can use a filter configuration allow placement with some, but not all of these locations.

type FilterInstanceStatus added in v1.19.0 

type FilterInstanceStatus string
const (
	FilterInstanceStatusActive   FilterInstanceStatus = "ACTIVE"
	FilterInstanceStatusDraining FilterInstanceStatus = "DRAINING"
)

Enum values for FilterInstanceStatus

func (FilterInstanceStatus) Values added in v1.19.0 

func (FilterInstanceStatus) Values() []FilterInstanceStatus

Values returns all known values for FilterInstanceStatus. Note that this can be expanded in the future, and so it is only as up to date as the client.

The ordering of this slice is not guaranteed to be stable across updates.

type FleetAction 

type FleetAction string
const (
	FleetActionAutoScaling FleetAction = "AUTO_SCALING"
)

Enum values for FleetAction

func (FleetAction) Values added in v0.29.0 

func (FleetAction) Values() []FleetAction

Values returns all known values for FleetAction. Note that this can be expanded in the future, and so it is only as up to date as the client.

The ordering of this slice is not guaranteed to be stable across updates.

type FleetAttributes 

type FleetAttributes struct {

	// Amazon GameLift Anywhere configuration options.
	AnywhereConfiguration *AnywhereConfiguration

	//  The Amazon Resource Name ([ARN] ) associated with the Amazon GameLift build resource
	// that is deployed on instances in this fleet. In a GameLift build ARN, the
	// resource ID matches the BuildId value. This attribute is used with fleets where
	// ComputeType is "EC2".
	//
	// [ARN]: https://docs.aws.amazon.com/AmazonS3/latest/dev/s3-arn-format.html
	BuildArn *string

	// A unique identifier for the build resource that is deployed on instances in
	// this fleet. This attribute is used with fleets where ComputeType is "EC2".
	BuildId *string

	// Determines whether a TLS/SSL certificate is generated for a fleet. This feature
	// must be enabled when creating the fleet. All instances in a fleet share the same
	// certificate.
	CertificateConfiguration *CertificateConfiguration

	// The type of compute resource used to host your game servers. You can use your
	// own compute resources with Amazon GameLift Anywhere or use Amazon EC2 instances
	// with managed Amazon GameLift.
	ComputeType ComputeType

	// A time stamp indicating when this data object was created. Format is a number
	// expressed in Unix time as milliseconds (for example "1469498468.057" ).
	CreationTime *time.Time

	// A human-readable description of the fleet.
	Description *string

	// The Amazon Resource Name ([ARN] ) that is assigned to a Amazon GameLift fleet
	// resource and uniquely identifies it. ARNs are unique across all Regions. Format
	// is arn:aws:gamelift:::fleet/fleet-a1234567-b8c9-0d1e-2fa3-b45c6d7e8912 . In a
	// GameLift fleet ARN, the resource ID matches the FleetId value.
	//
	// [ARN]: https://docs.aws.amazon.com/AmazonS3/latest/dev/s3-arn-format.html
	FleetArn *string

	// A unique identifier for the fleet.
	FleetId *string

	// Indicates whether the fleet uses On-Demand or Spot instances. For more
	// information, see [On-Demand versus Spot Instances]. This fleet property can't be changed after the fleet is
	// created.
	//
	// [On-Demand versus Spot Instances]: https://docs.aws.amazon.com/gamelift/latest/developerguide/gamelift-ec2-instances.html#gamelift-ec2-instances-spot
	FleetType FleetType

	// A unique identifier for an IAM role that manages access to your Amazon Web
	// Services services. With an instance role ARN set, any application that runs on
	// an instance in this fleet can assume the role, including install scripts, server
	// processes, and daemons (background processes). Create a role or look up a role's
	// ARN by using the [IAM dashboard]in the Amazon Web Services Management Console. Learn more
	// about using on-box credentials for your game servers at [Access external resources from a game server]. This attribute is
	// used with fleets where ComputeType is "EC2".
	//
	// [IAM dashboard]: https://console.aws.amazon.com/iam/
	// [Access external resources from a game server]: https://docs.aws.amazon.com/gamelift/latest/developerguide/gamelift-sdk-server-resources.html
	InstanceRoleArn *string

	// Indicates that fleet instances maintain a shared credentials file for the IAM
	// role defined in InstanceRoleArn . Shared credentials allow applications that are
	// deployed with the game server executable to communicate with other Amazon Web
	// Services resources. This property is used only when the game server is
	// integrated with the server SDK version 5.x. For more information about using
	// shared credentials, see [Communicate with other Amazon Web Services resources from your fleets]. This attribute is used with fleets where ComputeType
	// is "EC2".
	//
	// [Communicate with other Amazon Web Services resources from your fleets]: https://docs.aws.amazon.com/gamelift/latest/developerguide/gamelift-sdk-server-resources.html
	InstanceRoleCredentialsProvider InstanceRoleCredentialsProvider

	// The Amazon EC2 instance type that the fleet uses. Instance type determines the
	// computing resources of each instance in the fleet, including CPU, memory,
	// storage, and networking capacity. See [Amazon Elastic Compute Cloud Instance Types]for detailed descriptions. This attribute
	// is used with fleets where ComputeType is "EC2".
	//
	// [Amazon Elastic Compute Cloud Instance Types]: http://aws.amazon.com/ec2/instance-types/
	InstanceType EC2InstanceType

	//  This parameter is no longer used. Game session log paths are now defined using
	// the Amazon GameLift server API ProcessReady() logParameters . See more
	// information in the [Server API Reference].
	//
	// [Server API Reference]: https://docs.aws.amazon.com/gamelift/latest/developerguide/gamelift-sdk-server-api-ref.html#gamelift-sdk-server-api-ref-dataypes-process
	LogPaths []string

	// Name of a metric group that metrics for this fleet are added to. In Amazon
	// CloudWatch, you can view aggregated metrics for fleets that are in a metric
	// group. A fleet can be included in only one metric group at a time. This
	// attribute is used with fleets where ComputeType is "EC2".
	MetricGroups []string

	// A descriptive label that is associated with a fleet. Fleet names do not need to
	// be unique.
	Name *string

	// The type of game session protection to set on all new instances that are
	// started in the fleet. This attribute is used with fleets where ComputeType is
	// "EC2".
	//
	//   - NoProtection -- The game session can be terminated during a scale-down
	//   event.
	//
	//   - FullProtection -- If the game session is in an ACTIVE status, it cannot be
	//   terminated during a scale-down event.
	NewGameSessionProtectionPolicy ProtectionPolicy

	// The operating system of the fleet's computing resources. A fleet's operating
	// system is determined by the OS of the build or script that is deployed on this
	// fleet. This attribute is used with fleets where ComputeType is "EC2".
	//
	// Amazon Linux 2 (AL2) will reach end of support on 6/30/2025. See more details
	// in the [Amazon Linux 2 FAQs]. For game servers that are hosted on AL2 and use Amazon GameLift server
	// SDK 4.x, first update the game server build to server SDK 5.x, and then deploy
	// to AL2023 instances. See [Migrate to Amazon GameLift server SDK version 5.]
	//
	// [Amazon Linux 2 FAQs]: https://aws.amazon.com/amazon-linux-2/faqs/
	// [Migrate to Amazon GameLift server SDK version 5.]: https://docs.aws.amazon.com/gamelift/latest/developerguide/reference-serversdk5-migration.html
	OperatingSystem OperatingSystem

	// A policy that puts limits on the number of game sessions that a player can
	// create within a specified span of time. With this policy, you can control
	// players' ability to consume available resources.
	//
	// The policy is evaluated when a player tries to create a new game session. On
	// receiving a CreateGameSession request, Amazon GameLift checks that the player
	// (identified by CreatorId ) has created fewer than game session limit in the
	// specified time period.
	ResourceCreationLimitPolicy *ResourceCreationLimitPolicy

	//  The Amazon Resource Name ([ARN] ) associated with the GameLift script resource that
	// is deployed on instances in this fleet. In a GameLift script ARN, the resource
	// ID matches the ScriptId value.
	//
	// [ARN]: https://docs.aws.amazon.com/AmazonS3/latest/dev/s3-arn-format.html
	ScriptArn *string

	// A unique identifier for the Realtime script resource that is deployed on
	// instances in this fleet. This attribute is used with fleets where ComputeType
	// is "EC2".
	ScriptId *string

	//  This parameter is no longer used. Server launch parameters are now defined
	// using the fleet's runtime configuration. Requests that use this parameter
	// continue to be valid.
	ServerLaunchParameters *string

	//  This parameter is no longer used. Server launch paths are now defined using
	// the fleet's [RuntimeConfiguration]. Requests that use this parameter continue to be valid.
	//
	// [RuntimeConfiguration]: https://docs.aws.amazon.com/gamelift/latest/apireference/RuntimeConfiguration.html
	ServerLaunchPath *string

	// Current status of the fleet. Possible fleet statuses include the following:
	//
	//   - NEW -- A new fleet resource has been defined and Amazon GameLift has
	//   started creating the fleet. Desired instances is set to 1.
	//
	//   - DOWNLOADING/VALIDATING/BUILDING -- Amazon GameLift is download the game
	//   server build, running install scripts, and then validating the build files. When
	//   complete, Amazon GameLift launches a fleet instance.
	//
	//   - ACTIVATING -- Amazon GameLift is launching a game server process and
	//   testing its connectivity with the Amazon GameLift service.
	//
	//   - ACTIVE -- The fleet is now ready to host game sessions.
	//
	//   - ERROR -- An error occurred when downloading, validating, building, or
	//   activating the fleet.
	//
	//   - DELETING -- Hosts are responding to a delete fleet request.
	//
	//   - TERMINATED -- The fleet no longer exists.
	Status FleetStatus

	// A list of fleet activity that has been suspended using [StopFleetActions]. This includes fleet
	// auto-scaling. This attribute is used with fleets where ComputeType is "EC2".
	//
	// [StopFleetActions]: https://docs.aws.amazon.com/gamelift/latest/apireference/API_StopFleetActions.html
	StoppedActions []FleetAction

	// A time stamp indicating when this data object was terminated. Format is a
	// number expressed in Unix time as milliseconds (for example "1469498468.057" ).
	TerminationTime *time.Time
	// contains filtered or unexported fields
}

Describes an Amazon GameLift fleet of game hosting resources. Attributes differ based on the fleet's compute type, as follows:

  • EC2 fleet attributes identify a Build resource (for fleets with customer game server builds) or a Script resource (for Realtime Servers fleets).

  • Amazon GameLift Anywhere fleets have an abbreviated set of attributes, because most fleet configurations are set directly on the fleet's computes. Attributes include fleet identifiers and descriptive properties, creation/termination time, and fleet status.

Returned by: DescribeFleetAttributes

type FleetCapacity 

type FleetCapacity struct {

	// The Amazon Resource Name ([ARN] ) that is assigned to a Amazon GameLift fleet
	// resource and uniquely identifies it. ARNs are unique across all Regions. Format
	// is arn:aws:gamelift:::fleet/fleet-a1234567-b8c9-0d1e-2fa3-b45c6d7e8912 .
	//
	// [ARN]: https://docs.aws.amazon.com/AmazonS3/latest/dev/s3-arn-format.html
	FleetArn *string

	// A unique identifier for the fleet associated with the location.
	FleetId *string

	// The number and status of game server container groups deployed in a container
	// fleet.
	GameServerContainerGroupCounts *GameServerContainerGroupCounts

	// The current number of instances in the fleet, listed by instance status. Counts
	// for pending and terminating instances might be non-zero if the fleet is
	// adjusting to a scaling event or if access to resources is temporarily affected.
	InstanceCounts *EC2InstanceCounts

	// The Amazon EC2 instance type that is used for instances in a fleet. Instance
	// type determines the computing resources in use, including CPU, memory, storage,
	// and networking capacity. See [Amazon Elastic Compute Cloud Instance Types]for detailed descriptions.
	//
	// [Amazon Elastic Compute Cloud Instance Types]: http://aws.amazon.com/ec2/instance-types/
	InstanceType EC2InstanceType

	// The fleet location for the instance count information, expressed as an Amazon
	// Web Services Region code, such as us-west-2 .
	Location *string
	// contains filtered or unexported fields
}

Current resource capacity settings for managed EC2 fleets and managed container fleets. For multi-location fleets, location values might refer to a fleet's remote location or its home Region.

Returned by: DescribeFleetCapacity, DescribeFleetLocationCapacity, UpdateFleetCapacity

type FleetCapacityExceededException 

type FleetCapacityExceededException struct {
	Message *string

	ErrorCodeOverride *string
	// contains filtered or unexported fields
}

The specified fleet has no available instances to fulfill a CreateGameSession request. Clients can retry such requests immediately or after a waiting period.

func (*FleetCapacityExceededException) Error 

func (e *FleetCapacityExceededException) Error() string

func (*FleetCapacityExceededException) ErrorCode 

func (e *FleetCapacityExceededException) ErrorCode() string

func (*FleetCapacityExceededException) ErrorFault 

func (e *FleetCapacityExceededException) ErrorFault() smithy.ErrorFault

func (*FleetCapacityExceededException) ErrorMessage 

func (e *FleetCapacityExceededException) ErrorMessage() string

type FleetDeployment added in v1.37.0 

type FleetDeployment struct {

	// A time stamp indicating when this data object was created. Format is a number
	// expressed in Unix time as milliseconds (for example "1469498468.057" ).
	CreationTime *time.Time

	// Instructions for how to deploy updates to a container fleet and what actions to
	// take if the deployment fails.
	DeploymentConfiguration *DeploymentConfiguration

	// A unique identifier for the deployment.
	DeploymentId *string

	// The status of fleet deployment activity in the location.
	//
	//   - IN_PROGRESS -- The deployment is in progress.
	//
	//   - IMPAIRED -- The deployment failed and the fleet has some impaired
	//   containers.
	//
	//   - COMPLETE -- The deployment has completed successfully.
	//
	//   - ROLLBACK_IN_PROGRESS -- The deployment failed and rollback has been
	//   initiated.
	//
	//   - ROLLBACK_IN_COMPLETE -- The deployment failed and rollback has been
	//   completed.
	//
	//   - CANCELLED -- The deployment was cancelled.
	DeploymentStatus DeploymentStatus

	// A unique identifier for the container fleet.
	FleetId *string

	// The unique identifier for the version of the game server container group
	// definition that is being deployed.
	GameServerBinaryArn *string

	// The unique identifier for the version of the per-instance container group
	// definition that is being deployed.
	PerInstanceBinaryArn *string

	// The unique identifier for the version of the game server container group
	// definition to roll back to if deployment fails.
	RollbackGameServerBinaryArn *string

	// The unique identifier for the version of the per-instance container group
	// definition to roll back to if deployment fails.
	RollbackPerInstanceBinaryArn *string
	// contains filtered or unexported fields
}

Describes a container fleet deployment with updates to the fleet.

type FleetStatus 

type FleetStatus string
const (
	FleetStatusNew         FleetStatus = "NEW"
	FleetStatusDownloading FleetStatus = "DOWNLOADING"
	FleetStatusValidating  FleetStatus = "VALIDATING"
	FleetStatusBuilding    FleetStatus = "BUILDING"
	FleetStatusActivating  FleetStatus = "ACTIVATING"
	FleetStatusActive      FleetStatus = "ACTIVE"
	FleetStatusDeleting    FleetStatus = "DELETING"
	FleetStatusError       FleetStatus = "ERROR"
	FleetStatusTerminated  FleetStatus = "TERMINATED"
	FleetStatusNotFound    FleetStatus = "NOT_FOUND"
)

Enum values for FleetStatus

func (FleetStatus) Values added in v0.29.0 

func (FleetStatus) Values() []FleetStatus

Values returns all known values for FleetStatus. Note that this can be expanded in the future, and so it is only as up to date as the client.

The ordering of this slice is not guaranteed to be stable across updates.

type FleetType 

type FleetType string
const (
	FleetTypeOnDemand FleetType = "ON_DEMAND"
	FleetTypeSpot     FleetType = "SPOT"
)

Enum values for FleetType

func (FleetType) Values added in v0.29.0 

func (FleetType) Values() []FleetType

Values returns all known values for FleetType. Note that this can be expanded in the future, and so it is only as up to date as the client.

The ordering of this slice is not guaranteed to be stable across updates.

type FleetUtilization 

type FleetUtilization struct {

	// The number of active game sessions that are currently being hosted across all
	// instances in the fleet location.
	ActiveGameSessionCount *int32

	// The number of server processes in ACTIVE status that are currently running
	// across all instances in the fleet location.
	ActiveServerProcessCount *int32

	// The number of active player sessions that are currently being hosted across all
	// instances in the fleet location.
	CurrentPlayerSessionCount *int32

	// The Amazon Resource Name ([ARN] ) that is assigned to a Amazon GameLift fleet
	// resource and uniquely identifies it. ARNs are unique across all Regions. Format
	// is arn:aws:gamelift:::fleet/fleet-a1234567-b8c9-0d1e-2fa3-b45c6d7e8912 .
	//
	// [ARN]: https://docs.aws.amazon.com/AmazonS3/latest/dev/s3-arn-format.html
	FleetArn *string

	// A unique identifier for the fleet associated with the location.
	FleetId *string

	// The fleet location for the fleet utilization information, expressed as an
	// Amazon Web Services Region code, such as us-west-2 .
	Location *string

	// The maximum number of players allowed across all game sessions that are
	// currently being hosted across all instances in the fleet location.
	MaximumPlayerSessionCount *int32
	// contains filtered or unexported fields
}

Current resource utilization statistics in a specified fleet or location. The location value might refer to a fleet's remote location or its home region.

type FlexMatchMode added in v0.31.0 

type FlexMatchMode string
const (
	FlexMatchModeStandalone FlexMatchMode = "STANDALONE"
	FlexMatchModeWithQueue  FlexMatchMode = "WITH_QUEUE"
)

Enum values for FlexMatchMode

func (FlexMatchMode) Values added in v0.31.0 

func (FlexMatchMode) Values() []FlexMatchMode

Values returns all known values for FlexMatchMode. Note that this can be expanded in the future, and so it is only as up to date as the client.

The ordering of this slice is not guaranteed to be stable across updates.

type GameProperty 

type GameProperty struct {

	// The game property identifier.
	//
	// This member is required.
	Key *string

	// The game property value.
	//
	// This member is required.
	Value *string
	// contains filtered or unexported fields
}

This key-value pair can store custom data about a game session. For example, you might use a GameProperty to track a game session's map, level of difficulty, or remaining time. The difficulty level could be specified like this: {"Key": "difficulty", "Value":"Novice"} .

You can set game properties when creating a game session. You can also modify game properties of an active game session. When searching for game sessions, you can filter on game property keys and values. You can't delete game properties from a game session.

For examples of working with game properties, see Create a game session with properties.

type GameServer 

type GameServer struct {

	// Indicates when an available game server has been reserved for gameplay but has
	// not yet started hosting a game. Once it is claimed, the game server remains in
	// CLAIMED status for a maximum of one minute. During this time, game clients
	// connect to the game server to start the game and trigger the game server to
	// update its utilization status. After one minute, the game server claim status
	// reverts to null.
	ClaimStatus GameServerClaimStatus

	// The port and IP address that must be used to establish a client connection to
	// the game server.
	ConnectionInfo *string

	// A set of custom game server properties, formatted as a single string value.
	// This data is passed to a game client or service when it requests information on
	// game servers.
	GameServerData *string

	// The ARN identifier for the game server group where the game server is located.
	GameServerGroupArn *string

	// A unique identifier for the game server group where the game server is running.
	GameServerGroupName *string

	// A custom string that uniquely identifies the game server. Game server IDs are
	// developer-defined and are unique across all game server groups in an Amazon Web
	// Services account.
	GameServerId *string

	// The unique identifier for the instance where the game server is running. This
	// ID is available in the instance metadata. EC2 instance IDs use a 17-character
	// format, for example: i-1234567890abcdef0 .
	InstanceId *string

	// Timestamp that indicates the last time the game server was claimed. The format
	// is a number expressed in Unix time as milliseconds (for example "1469498468.057"
	// ). This value is used to calculate when a claimed game server's status should
	// revert to null.
	LastClaimTime *time.Time

	// Timestamp that indicates the last time the game server was updated with health
	// status. The format is a number expressed in Unix time as milliseconds (for
	// example "1469498468.057" ). After game server registration, this property is
	// only changed when a game server update specifies a health check value.
	LastHealthCheckTime *time.Time

	// Timestamp that indicates when the game server registered. The format is a
	// number expressed in Unix time as milliseconds (for example "1469498468.057" ).
	RegistrationTime *time.Time

	// Indicates whether the game server is currently available for new games or is
	// busy. Possible statuses include:
	//
	//   - AVAILABLE - The game server is available to be claimed. A game server that
	//   has been claimed remains in this status until it reports game hosting activity.
	//
	//   - UTILIZED - The game server is currently hosting a game session with players.
	UtilizationStatus GameServerUtilizationStatus
	// contains filtered or unexported fields
}
This data type is used with the Amazon GameLift FleetIQ and game server

groups.

Properties describing a game server that is running on an instance in a game server group.

A game server is created by a successful call to RegisterGameServer and deleted by calling DeregisterGameServer . A game server is claimed to host a game session by calling ClaimGameServer .

type GameServerClaimStatus 

type GameServerClaimStatus string
const (
	GameServerClaimStatusClaimed GameServerClaimStatus = "CLAIMED"
)

Enum values for GameServerClaimStatus

func (GameServerClaimStatus) Values added in v0.29.0 

func (GameServerClaimStatus) Values() []GameServerClaimStatus

Values returns all known values for GameServerClaimStatus. Note that this can be expanded in the future, and so it is only as up to date as the client.

The ordering of this slice is not guaranteed to be stable across updates.

type GameServerContainerDefinition added in v1.37.0 

type GameServerContainerDefinition struct {

	// The container definition identifier. Container names are unique within a
	// container group definition.
	ContainerName *string

	// Indicates that the container relies on the status of other containers in the
	// same container group during startup and shutdown sequences. A container might
	// have dependencies on multiple containers.
	DependsOn []ContainerDependency

	// A set of environment variables that's passed to the container on startup. See
	// the [ContainerDefinition::environment]parameter in the Amazon Elastic Container Service API Reference.
	//
	// [ContainerDefinition::environment]: https://docs.aws.amazon.com/AmazonECS/latest/APIReference/API_ContainerDefinition.html#ECS-Type-ContainerDefinition-environment
	EnvironmentOverride []ContainerEnvironment

	// The URI to the image that Amazon GameLift uses when deploying this container to
	// a container fleet. For a more specific identifier, see ResolvedImageDigest .
	ImageUri *string

	// A mount point that binds a path inside the container to a file or directory on
	// the host system and lets it access the file or directory.
	MountPoints []ContainerMountPoint

	// The set of ports that are available to bind to processes in the container. For
	// example, a game server process requires a container port to allow game clients
	// to connect to it. Container ports aren't directly accessed by inbound traffic.
	// Amazon GameLift maps these container ports to externally accessible connection
	// ports, which are assigned as needed from the container fleet's
	// ConnectionPortRange .
	PortConfiguration *ContainerPortConfiguration

	// A unique and immutable identifier for the container image. The digest is a SHA
	// 256 hash of the container image manifest.
	ResolvedImageDigest *string

	// The Amazon GameLift server SDK version that the game server is integrated with.
	// Only game servers using 5.2.0 or higher are compatible with container fleets.
	ServerSdkVersion *string
	// contains filtered or unexported fields
}

Describes the game server container in an existing game server container group. A game server container identifies a container image with your game server build. A game server container is automatically considered essential; if an essential container fails, the entire container group restarts.

You can update a container definition and deploy the updates to an existing fleet. When creating or updating a game server container group definition, use the property GameServerContainerDefinitionInput.

Part of: ContainerGroupDefinition

Returned by: DescribeContainerGroupDefinition, ListContainerGroupDefinitions, UpdateContainerGroupDefinition

type GameServerContainerDefinitionInput added in v1.37.0 

type GameServerContainerDefinitionInput struct {

	// A string that uniquely identifies the container definition within a container
	// group.
	//
	// This member is required.
	ContainerName *string

	// The location of the container image to deploy to a container fleet. Provide an
	// image in an Amazon Elastic Container Registry public or private repository. The
	// repository must be in the same Amazon Web Services account and Amazon Web
	// Services Region where you're creating the container group definition. For limits
	// on image size, see [Amazon GameLift endpoints and quotas]. You can use any of the following image URI formats:
	//
	//   - Image ID only: [AWS account].dkr.ecr.[AWS region].amazonaws.com/[repository
	//   ID]
	//
	//   - Image ID and digest: [AWS account].dkr.ecr.[AWS
	//   region].amazonaws.com/[repository ID]@[digest]
	//
	//   - Image ID and tag: [AWS account].dkr.ecr.[AWS
	//   region].amazonaws.com/[repository ID]:[tag]
	//
	// [Amazon GameLift endpoints and quotas]: https://docs.aws.amazon.com/general/latest/gr/gamelift.html
	//
	// This member is required.
	ImageUri *string

	// A set of ports that Amazon GameLift can assign to processes in the container.
	// Processes, must be assigned a container port to accept inbound traffic
	// connections. For example, a game server process requires a container port to
	// allow game clients to connect to it. Container ports aren't directly accessed by
	// inbound traffic. Instead, Amazon GameLift maps container ports to externally
	// accessible connection ports (see the container fleet property
	// ConnectionPortRange ).
	//
	// This member is required.
	PortConfiguration *ContainerPortConfiguration

	// The Amazon GameLift server SDK version that the game server is integrated with.
	// Only game servers using 5.2.0 or higher are compatible with container fleets.
	//
	// This member is required.
	ServerSdkVersion *string

	// Establishes dependencies between this container and the status of other
	// containers in the same container group. A container can have dependencies on
	// multiple different containers.
	//
	// You can use dependencies to establish a startup/shutdown sequence across the
	// container group. For example, you might specify that ContainerB has a START
	// dependency on ContainerA. This dependency means that ContainerB can't start
	// until after ContainerA has started. This dependency is reversed on shutdown,
	// which means that ContainerB must shut down before ContainerA can shut down.
	DependsOn []ContainerDependency

	// A set of environment variables to pass to the container on startup. See the [ContainerDefinition::environment]
	// parameter in the Amazon Elastic Container Service API Reference.
	//
	// [ContainerDefinition::environment]: https://docs.aws.amazon.com/AmazonECS/latest/APIReference/API_ContainerDefinition.html#ECS-Type-ContainerDefinition-environment
	EnvironmentOverride []ContainerEnvironment

	// A mount point that binds a path inside the container to a file or directory on
	// the host system and lets it access the file or directory.
	MountPoints []ContainerMountPoint
	// contains filtered or unexported fields
}

Describes the configuration for a container that runs your game server executable. This definition includes container configuration, resources, and start instructions. Use this data type when creating or updating a game server container group definition. For properties of a deployed container, see GameServerContainerDefinition. A game server container is automatically considered essential; if an essential container fails, the entire container group restarts.

Use with: CreateContainerGroupDefinition, UpdateContainerGroupDefinition

type GameServerContainerGroupCounts added in v1.37.0 

type GameServerContainerGroupCounts struct {

	//  The number of container groups that have active game sessions.
	ACTIVE *int32

	//  The number of container groups that have no active game sessions.
	IDLE *int32

	//  The number of container groups that are starting up but haven't yet
	// registered.
	PENDING *int32

	//  The number of container groups that are in the process of shutting down.
	TERMINATING *int32
	// contains filtered or unexported fields
}

The number and status of game server container groups that are deployed across a container fleet. Combine this count with the number of server processes that each game server container group runs to learn how many game sessions the fleet is capable of hosting concurrently. For example, if a fleet has 50 game server container groups, and the game server container in each group runs 1 game server process, then the fleet has the capacity to run host 50 game sessions at a time.

Returned by: DescribeFleetCapacity, DescribeFleetLocationCapacity

type GameServerGroup 

type GameServerGroup struct {

	// A generated unique ID for the Amazon EC2 Auto Scaling group that is associated
	// with this game server group.
	AutoScalingGroupArn *string

	// Indicates how Amazon GameLift FleetIQ balances the use of Spot Instances and
	// On-Demand Instances in the game server group. Method options include the
	// following:
	//
	//   - SPOT_ONLY - Only Spot Instances are used in the game server group. If Spot
	//   Instances are unavailable or not viable for game hosting, the game server group
	//   provides no hosting capacity until Spot Instances can again be used. Until then,
	//   no new instances are started, and the existing nonviable Spot Instances are
	//   terminated (after current gameplay ends) and are not replaced.
	//
	//   - SPOT_PREFERRED - (default value) Spot Instances are used whenever available
	//   in the game server group. If Spot Instances are unavailable, the game server
	//   group continues to provide hosting capacity by falling back to On-Demand
	//   Instances. Existing nonviable Spot Instances are terminated (after current
	//   gameplay ends) and are replaced with new On-Demand Instances.
	//
	//   - ON_DEMAND_ONLY - Only On-Demand Instances are used in the game server group.
	//   No Spot Instances are used, even when available, while this balancing strategy
	//   is in force.
	BalancingStrategy BalancingStrategy

	// A time stamp indicating when this data object was created. Format is a number
	// expressed in Unix time as milliseconds (for example "1469498468.057" ).
	CreationTime *time.Time

	// A generated unique ID for the game server group.
	GameServerGroupArn *string

	// A developer-defined identifier for the game server group. The name is unique
	// for each Region in each Amazon Web Services account.
	GameServerGroupName *string

	// A flag that indicates whether instances in the game server group are protected
	// from early termination. Unprotected instances that have active game servers
	// running might be terminated during a scale-down event, causing players to be
	// dropped from the game. Protected instances cannot be terminated while there are
	// active game servers running except in the event of a forced game server group
	// deletion (see ). An exception to this is with Spot Instances, which can be
	// terminated by Amazon Web Services regardless of protection status.
	GameServerProtectionPolicy GameServerProtectionPolicy

	// The set of Amazon EC2 instance types that Amazon GameLift FleetIQ can use when
	// balancing and automatically scaling instances in the corresponding Auto Scaling
	// group.
	InstanceDefinitions []InstanceDefinition

	// A timestamp that indicates when this game server group was last updated.
	LastUpdatedTime *time.Time

	// The Amazon Resource Name ([ARN] ) for an IAM role that allows Amazon GameLift to
	// access your Amazon EC2 Auto Scaling groups.
	//
	// [ARN]: https://docs.aws.amazon.com/AmazonS3/latest/dev/s3-arn-format.html
	RoleArn *string

	// The current status of the game server group. Possible statuses include:
	//
	//   - NEW - Amazon GameLift FleetIQ has validated the CreateGameServerGroup()
	//   request.
	//
	//   - ACTIVATING - Amazon GameLift FleetIQ is setting up a game server group,
	//   which includes creating an Auto Scaling group in your Amazon Web Services
	//   account.
	//
	//   - ACTIVE - The game server group has been successfully created.
	//
	//   - DELETE_SCHEDULED - A request to delete the game server group has been
	//   received.
	//
	//   - DELETING - Amazon GameLift FleetIQ has received a valid
	//   DeleteGameServerGroup() request and is processing it. Amazon GameLift FleetIQ
	//   must first complete and release hosts before it deletes the Auto Scaling group
	//   and the game server group.
	//
	//   - DELETED - The game server group has been successfully deleted.
	//
	//   - ERROR - The asynchronous processes of activating or deleting a game server
	//   group has failed, resulting in an error state.
	Status GameServerGroupStatus

	// Additional information about the current game server group status. This
	// information might provide additional insight on groups that are in ERROR status.
	StatusReason *string

	// A list of activities that are currently suspended for this game server group.
	// If this property is empty, all activities are occurring.
	SuspendedActions []GameServerGroupAction
	// contains filtered or unexported fields
}
This data type is used with the Amazon GameLift FleetIQ and game server

groups.

Properties that describe a game server group resource. A game server group manages certain properties related to a corresponding Amazon EC2 Auto Scaling group.

A game server group is created by a successful call to CreateGameServerGroup and deleted by calling DeleteGameServerGroup . Game server group activity can be temporarily suspended and resumed by calling SuspendGameServerGroup and ResumeGameServerGroup , respectively.

type GameServerGroupAction 

type GameServerGroupAction string
const (
	GameServerGroupActionReplaceInstanceTypes GameServerGroupAction = "REPLACE_INSTANCE_TYPES"
)

Enum values for GameServerGroupAction

func (GameServerGroupAction) Values added in v0.29.0 

func (GameServerGroupAction) Values() []GameServerGroupAction

Values returns all known values for GameServerGroupAction. Note that this can be expanded in the future, and so it is only as up to date as the client.

The ordering of this slice is not guaranteed to be stable across updates.

type GameServerGroupAutoScalingPolicy 

type GameServerGroupAutoScalingPolicy struct {

	// Settings for a target-based scaling policy applied to Auto Scaling group. These
	// settings are used to create a target-based policy that tracks the Amazon
	// GameLift FleetIQ metric "PercentUtilizedGameServers" and specifies a target
	// value for the metric. As player usage changes, the policy triggers to adjust the
	// game server group capacity so that the metric returns to the target value.
	//
	// This member is required.
	TargetTrackingConfiguration *TargetTrackingConfiguration

	// Length of time, in seconds, it takes for a new instance to start new game
	// server processes and register with Amazon GameLift FleetIQ. Specifying a warm-up
	// time can be useful, particularly with game servers that take a long time to
	// start up, because it avoids prematurely starting new instances.
	EstimatedInstanceWarmup *int32
	// contains filtered or unexported fields
}
This data type is used with the Amazon GameLift FleetIQ and game server

groups.

Configuration settings for intelligent automatic scaling that uses target tracking. These settings are used to add an Auto Scaling policy when creating the corresponding Auto Scaling group. After the Auto Scaling group is created, all updates to Auto Scaling policies, including changing this policy and adding or removing other policies, is done directly on the Auto Scaling group.

type GameServerGroupDeleteOption 

type GameServerGroupDeleteOption string
const (
	GameServerGroupDeleteOptionSafeDelete  GameServerGroupDeleteOption = "SAFE_DELETE"
	GameServerGroupDeleteOptionForceDelete GameServerGroupDeleteOption = "FORCE_DELETE"
	GameServerGroupDeleteOptionRetain      GameServerGroupDeleteOption = "RETAIN"
)

Enum values for GameServerGroupDeleteOption

func (GameServerGroupDeleteOption) Values added in v0.29.0 

func (GameServerGroupDeleteOption) Values() []GameServerGroupDeleteOption

Values returns all known values for GameServerGroupDeleteOption. Note that this can be expanded in the future, and so it is only as up to date as the client.

The ordering of this slice is not guaranteed to be stable across updates.

type GameServerGroupInstanceType 

type GameServerGroupInstanceType string
const (
	GameServerGroupInstanceTypeC4Large     GameServerGroupInstanceType = "c4.large"
	GameServerGroupInstanceTypeC4Xlarge    GameServerGroupInstanceType = "c4.xlarge"
	GameServerGroupInstanceTypeC42xlarge   GameServerGroupInstanceType = "c4.2xlarge"
	GameServerGroupInstanceTypeC44xlarge   GameServerGroupInstanceType = "c4.4xlarge"
	GameServerGroupInstanceTypeC48xlarge   GameServerGroupInstanceType = "c4.8xlarge"
	GameServerGroupInstanceTypeC5Large     GameServerGroupInstanceType = "c5.large"
	GameServerGroupInstanceTypeC5Xlarge    GameServerGroupInstanceType = "c5.xlarge"
	GameServerGroupInstanceTypeC52xlarge   GameServerGroupInstanceType = "c5.2xlarge"
	GameServerGroupInstanceTypeC54xlarge   GameServerGroupInstanceType = "c5.4xlarge"
	GameServerGroupInstanceTypeC59xlarge   GameServerGroupInstanceType = "c5.9xlarge"
	GameServerGroupInstanceTypeC512xlarge  GameServerGroupInstanceType = "c5.12xlarge"
	GameServerGroupInstanceTypeC518xlarge  GameServerGroupInstanceType = "c5.18xlarge"
	GameServerGroupInstanceTypeC524xlarge  GameServerGroupInstanceType = "c5.24xlarge"
	GameServerGroupInstanceTypeC5aLarge    GameServerGroupInstanceType = "c5a.large"
	GameServerGroupInstanceTypeC5aXlarge   GameServerGroupInstanceType = "c5a.xlarge"
	GameServerGroupInstanceTypeC5a2xlarge  GameServerGroupInstanceType = "c5a.2xlarge"
	GameServerGroupInstanceTypeC5a4xlarge  GameServerGroupInstanceType = "c5a.4xlarge"
	GameServerGroupInstanceTypeC5a8xlarge  GameServerGroupInstanceType = "c5a.8xlarge"
	GameServerGroupInstanceTypeC5a12xlarge GameServerGroupInstanceType = "c5a.12xlarge"
	GameServerGroupInstanceTypeC5a16xlarge GameServerGroupInstanceType = "c5a.16xlarge"
	GameServerGroupInstanceTypeC5a24xlarge GameServerGroupInstanceType = "c5a.24xlarge"
	GameServerGroupInstanceTypeC6gMedium   GameServerGroupInstanceType = "c6g.medium"
	GameServerGroupInstanceTypeC6gLarge    GameServerGroupInstanceType = "c6g.large"
	GameServerGroupInstanceTypeC6gXlarge   GameServerGroupInstanceType = "c6g.xlarge"
	GameServerGroupInstanceTypeC6g2xlarge  GameServerGroupInstanceType = "c6g.2xlarge"
	GameServerGroupInstanceTypeC6g4xlarge  GameServerGroupInstanceType = "c6g.4xlarge"
	GameServerGroupInstanceTypeC6g8xlarge  GameServerGroupInstanceType = "c6g.8xlarge"
	GameServerGroupInstanceTypeC6g12xlarge GameServerGroupInstanceType = "c6g.12xlarge"
	GameServerGroupInstanceTypeC6g16xlarge GameServerGroupInstanceType = "c6g.16xlarge"
	GameServerGroupInstanceTypeR4Large     GameServerGroupInstanceType = "r4.large"
	GameServerGroupInstanceTypeR4Xlarge    GameServerGroupInstanceType = "r4.xlarge"
	GameServerGroupInstanceTypeR42xlarge   GameServerGroupInstanceType = "r4.2xlarge"
	GameServerGroupInstanceTypeR44xlarge   GameServerGroupInstanceType = "r4.4xlarge"
	GameServerGroupInstanceTypeR48xlarge   GameServerGroupInstanceType = "r4.8xlarge"
	GameServerGroupInstanceTypeR416xlarge  GameServerGroupInstanceType = "r4.16xlarge"
	GameServerGroupInstanceTypeR5Large     GameServerGroupInstanceType = "r5.large"
	GameServerGroupInstanceTypeR5Xlarge    GameServerGroupInstanceType = "r5.xlarge"
	GameServerGroupInstanceTypeR52xlarge   GameServerGroupInstanceType = "r5.2xlarge"
	GameServerGroupInstanceTypeR54xlarge   GameServerGroupInstanceType = "r5.4xlarge"
	GameServerGroupInstanceTypeR58xlarge   GameServerGroupInstanceType = "r5.8xlarge"
	GameServerGroupInstanceTypeR512xlarge  GameServerGroupInstanceType = "r5.12xlarge"
	GameServerGroupInstanceTypeR516xlarge  GameServerGroupInstanceType = "r5.16xlarge"
	GameServerGroupInstanceTypeR524xlarge  GameServerGroupInstanceType = "r5.24xlarge"
	GameServerGroupInstanceTypeR5aLarge    GameServerGroupInstanceType = "r5a.large"
	GameServerGroupInstanceTypeR5aXlarge   GameServerGroupInstanceType = "r5a.xlarge"
	GameServerGroupInstanceTypeR5a2xlarge  GameServerGroupInstanceType = "r5a.2xlarge"
	GameServerGroupInstanceTypeR5a4xlarge  GameServerGroupInstanceType = "r5a.4xlarge"
	GameServerGroupInstanceTypeR5a8xlarge  GameServerGroupInstanceType = "r5a.8xlarge"
	GameServerGroupInstanceTypeR5a12xlarge GameServerGroupInstanceType = "r5a.12xlarge"
	GameServerGroupInstanceTypeR5a16xlarge GameServerGroupInstanceType = "r5a.16xlarge"
	GameServerGroupInstanceTypeR5a24xlarge GameServerGroupInstanceType = "r5a.24xlarge"
	GameServerGroupInstanceTypeR6gMedium   GameServerGroupInstanceType = "r6g.medium"
	GameServerGroupInstanceTypeR6gLarge    GameServerGroupInstanceType = "r6g.large"
	GameServerGroupInstanceTypeR6gXlarge   GameServerGroupInstanceType = "r6g.xlarge"
	GameServerGroupInstanceTypeR6g2xlarge  GameServerGroupInstanceType = "r6g.2xlarge"
	GameServerGroupInstanceTypeR6g4xlarge  GameServerGroupInstanceType = "r6g.4xlarge"
	GameServerGroupInstanceTypeR6g8xlarge  GameServerGroupInstanceType = "r6g.8xlarge"
	GameServerGroupInstanceTypeR6g12xlarge GameServerGroupInstanceType = "r6g.12xlarge"
	GameServerGroupInstanceTypeR6g16xlarge GameServerGroupInstanceType = "r6g.16xlarge"
	GameServerGroupInstanceTypeM4Large     GameServerGroupInstanceType = "m4.large"
	GameServerGroupInstanceTypeM4Xlarge    GameServerGroupInstanceType = "m4.xlarge"
	GameServerGroupInstanceTypeM42xlarge   GameServerGroupInstanceType = "m4.2xlarge"
	GameServerGroupInstanceTypeM44xlarge   GameServerGroupInstanceType = "m4.4xlarge"
	GameServerGroupInstanceTypeM410xlarge  GameServerGroupInstanceType = "m4.10xlarge"
	GameServerGroupInstanceTypeM5Large     GameServerGroupInstanceType = "m5.large"
	GameServerGroupInstanceTypeM5Xlarge    GameServerGroupInstanceType = "m5.xlarge"
	GameServerGroupInstanceTypeM52xlarge   GameServerGroupInstanceType = "m5.2xlarge"
	GameServerGroupInstanceTypeM54xlarge   GameServerGroupInstanceType = "m5.4xlarge"
	GameServerGroupInstanceTypeM58xlarge   GameServerGroupInstanceType = "m5.8xlarge"
	GameServerGroupInstanceTypeM512xlarge  GameServerGroupInstanceType = "m5.12xlarge"
	GameServerGroupInstanceTypeM516xlarge  GameServerGroupInstanceType = "m5.16xlarge"
	GameServerGroupInstanceTypeM524xlarge  GameServerGroupInstanceType = "m5.24xlarge"
	GameServerGroupInstanceTypeM5aLarge    GameServerGroupInstanceType = "m5a.large"
	GameServerGroupInstanceTypeM5aXlarge   GameServerGroupInstanceType = "m5a.xlarge"
	GameServerGroupInstanceTypeM5a2xlarge  GameServerGroupInstanceType = "m5a.2xlarge"
	GameServerGroupInstanceTypeM5a4xlarge  GameServerGroupInstanceType = "m5a.4xlarge"
	GameServerGroupInstanceTypeM5a8xlarge  GameServerGroupInstanceType = "m5a.8xlarge"
	GameServerGroupInstanceTypeM5a12xlarge GameServerGroupInstanceType = "m5a.12xlarge"
	GameServerGroupInstanceTypeM5a16xlarge GameServerGroupInstanceType = "m5a.16xlarge"
	GameServerGroupInstanceTypeM5a24xlarge GameServerGroupInstanceType = "m5a.24xlarge"
	GameServerGroupInstanceTypeM6gMedium   GameServerGroupInstanceType = "m6g.medium"
	GameServerGroupInstanceTypeM6gLarge    GameServerGroupInstanceType = "m6g.large"
	GameServerGroupInstanceTypeM6gXlarge   GameServerGroupInstanceType = "m6g.xlarge"
	GameServerGroupInstanceTypeM6g2xlarge  GameServerGroupInstanceType = "m6g.2xlarge"
	GameServerGroupInstanceTypeM6g4xlarge  GameServerGroupInstanceType = "m6g.4xlarge"
	GameServerGroupInstanceTypeM6g8xlarge  GameServerGroupInstanceType = "m6g.8xlarge"
	GameServerGroupInstanceTypeM6g12xlarge GameServerGroupInstanceType = "m6g.12xlarge"
	GameServerGroupInstanceTypeM6g16xlarge GameServerGroupInstanceType = "m6g.16xlarge"
)

Enum values for GameServerGroupInstanceType

func (GameServerGroupInstanceType) Values added in v0.29.0 

func (GameServerGroupInstanceType) Values() []GameServerGroupInstanceType

Values returns all known values for GameServerGroupInstanceType. Note that this can be expanded in the future, and so it is only as up to date as the client.

The ordering of this slice is not guaranteed to be stable across updates.

type GameServerGroupStatus 

type GameServerGroupStatus string
const (
	GameServerGroupStatusNew             GameServerGroupStatus = "NEW"
	GameServerGroupStatusActivating      GameServerGroupStatus = "ACTIVATING"
	GameServerGroupStatusActive          GameServerGroupStatus = "ACTIVE"
	GameServerGroupStatusDeleteScheduled GameServerGroupStatus = "DELETE_SCHEDULED"
	GameServerGroupStatusDeleting        GameServerGroupStatus = "DELETING"
	GameServerGroupStatusDeleted         GameServerGroupStatus = "DELETED"
	GameServerGroupStatusError           GameServerGroupStatus = "ERROR"
)

Enum values for GameServerGroupStatus

func (GameServerGroupStatus) Values added in v0.29.0 

func (GameServerGroupStatus) Values() []GameServerGroupStatus

Values returns all known values for GameServerGroupStatus. Note that this can be expanded in the future, and so it is only as up to date as the client.

The ordering of this slice is not guaranteed to be stable across updates.

type GameServerHealthCheck 

type GameServerHealthCheck string
const (
	GameServerHealthCheckHealthy GameServerHealthCheck = "HEALTHY"
)

Enum values for GameServerHealthCheck

func (GameServerHealthCheck) Values added in v0.29.0 

func (GameServerHealthCheck) Values() []GameServerHealthCheck

Values returns all known values for GameServerHealthCheck. Note that this can be expanded in the future, and so it is only as up to date as the client.

The ordering of this slice is not guaranteed to be stable across updates.

type GameServerInstance added in v0.29.0 

type GameServerInstance struct {

	// A generated unique identifier for the game server group that includes the game
	// server instance.
	GameServerGroupArn *string

	// A developer-defined identifier for the game server group that includes the game
	// server instance. The name is unique for each Region in each Amazon Web Services
	// account.
	GameServerGroupName *string

	// The unique identifier for the instance where the game server is running. This
	// ID is available in the instance metadata. EC2 instance IDs use a 17-character
	// format, for example: i-1234567890abcdef0 .
	InstanceId *string

	// Current status of the game server instance
	InstanceStatus GameServerInstanceStatus
	// contains filtered or unexported fields
}
This data type is used with the Amazon GameLift FleetIQ and game server

groups.

Additional properties, including status, that describe an EC2 instance in a game server group. Instance configurations are set with game server group properties (see DescribeGameServerGroup and with the EC2 launch template that was used when creating the game server group.

Retrieve game server instances for a game server group by calling DescribeGameServerInstances .

type GameServerInstanceStatus added in v0.29.0 

type GameServerInstanceStatus string
const (
	GameServerInstanceStatusActive          GameServerInstanceStatus = "ACTIVE"
	GameServerInstanceStatusDraining        GameServerInstanceStatus = "DRAINING"
	GameServerInstanceStatusSpotTerminating GameServerInstanceStatus = "SPOT_TERMINATING"
)

Enum values for GameServerInstanceStatus

func (GameServerInstanceStatus) Values added in v0.29.0 

func (GameServerInstanceStatus) Values() []GameServerInstanceStatus

Values returns all known values for GameServerInstanceStatus. Note that this can be expanded in the future, and so it is only as up to date as the client.

The ordering of this slice is not guaranteed to be stable across updates.

type GameServerProtectionPolicy 

type GameServerProtectionPolicy string
const (
	GameServerProtectionPolicyNoProtection   GameServerProtectionPolicy = "NO_PROTECTION"
	GameServerProtectionPolicyFullProtection GameServerProtectionPolicy = "FULL_PROTECTION"
)

Enum values for GameServerProtectionPolicy

func (GameServerProtectionPolicy) Values added in v0.29.0 

func (GameServerProtectionPolicy) Values() []GameServerProtectionPolicy

Values returns all known values for GameServerProtectionPolicy. Note that this can be expanded in the future, and so it is only as up to date as the client.

The ordering of this slice is not guaranteed to be stable across updates.

type GameServerUtilizationStatus 

type GameServerUtilizationStatus string
const (
	GameServerUtilizationStatusAvailable GameServerUtilizationStatus = "AVAILABLE"
	GameServerUtilizationStatusUtilized  GameServerUtilizationStatus = "UTILIZED"
)

Enum values for GameServerUtilizationStatus

func (GameServerUtilizationStatus) Values added in v0.29.0 

func (GameServerUtilizationStatus) Values() []GameServerUtilizationStatus

Values returns all known values for GameServerUtilizationStatus. Note that this can be expanded in the future, and so it is only as up to date as the client.

The ordering of this slice is not guaranteed to be stable across updates.

type GameSession 

type GameSession struct {

	// A time stamp indicating when this data object was created. Format is a number
	// expressed in Unix time as milliseconds (for example "1469498468.057" ).
	CreationTime *time.Time

	// A unique identifier for a player. This ID is used to enforce a resource
	// protection policy (if one exists), that limits the number of game sessions a
	// player can create.
	CreatorId *string

	// Number of players currently in the game session.
	CurrentPlayerSessionCount *int32

	// The DNS identifier assigned to the instance that is running the game session.
	// Values have the following format:
	//
	//   - TLS-enabled fleets: ..amazongamelift.com .
	//
	//   - Non-TLS-enabled fleets: ec2-.compute.amazonaws.com . (See [Amazon EC2 Instance IP Addressing].)
	//
	// When connecting to a game session that is running on a TLS-enabled fleet, you
	// must use the DNS name, not the IP address.
	//
	// [Amazon EC2 Instance IP Addressing]: https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/using-instance-addressing.html#concepts-public-addresses
	DnsName *string

	// The Amazon Resource Name ([ARN] ) associated with the GameLift fleet that this game
	// session is running on.
	//
	// [ARN]: https://docs.aws.amazon.com/AmazonS3/latest/dev/s3-arn-format.html
	FleetArn *string

	// A unique identifier for the fleet that the game session is running on.
	FleetId *string

	// A set of key-value pairs that can store custom data in a game session. For
	// example: {"Key": "difficulty", "Value": "novice"} .
	GameProperties []GameProperty

	// A set of custom game session properties, formatted as a single string value.
	// This data is passed to a game server process with a request to start a new game
	// session. For more information, see [Start a game session].
	//
	// [Start a game session]: https://docs.aws.amazon.com/gamelift/latest/developerguide/gamelift-sdk-server-api.html#gamelift-sdk-server-startsession
	GameSessionData *string

	// A unique identifier for the game session. A game session ARN has the following
	// format: arn:aws:gamelift:::gamesession// .
	GameSessionId *string

	// The IP address of the game session. To connect to a Amazon GameLift game
	// server, an app needs both the IP address and port number.
	IpAddress *string

	// The fleet location where the game session is running. This value might specify
	// the fleet's home Region or a remote location. Location is expressed as an Amazon
	// Web Services Region code such as us-west-2 .
	Location *string

	// Information about the matchmaking process that resulted in the game session, if
	// matchmaking was used. Data is in JSON syntax, formatted as a string. Information
	// includes the matchmaker ID as well as player attributes and team assignments.
	// For more details on matchmaker data, see [Match Data]. Matchmaker data is updated whenever
	// new players are added during a successful backfill (see [StartMatchBackfill]).
	//
	// [Match Data]: https://docs.aws.amazon.com/gamelift/latest/flexmatchguide/match-server.html#match-server-data
	// [StartMatchBackfill]: https://docs.aws.amazon.com/gamelift/latest/apireference/API_StartMatchBackfill.html
	MatchmakerData *string

	// The maximum number of players that can be connected simultaneously to the game
	// session.
	MaximumPlayerSessionCount *int32

	// A descriptive label that is associated with a game session. Session names do
	// not need to be unique.
	Name *string

	// Indicates whether or not the game session is accepting new players.
	PlayerSessionCreationPolicy PlayerSessionCreationPolicy

	// The port number for the game session. To connect to a Amazon GameLift game
	// server, an app needs both the IP address and port number.
	Port *int32

	// Current status of the game session. A game session must have an ACTIVE status
	// to have player sessions.
	Status GameSessionStatus

	// Provides additional information about game session status. INTERRUPTED
	// indicates that the game session was hosted on a spot instance that was
	// reclaimed, causing the active game session to be terminated.
	StatusReason GameSessionStatusReason

	// A time stamp indicating when this data object was terminated. Format is a
	// number expressed in Unix time as milliseconds (for example "1469498468.057" ).
	TerminationTime *time.Time
	// contains filtered or unexported fields
}

Properties describing a game session.

A game session in ACTIVE status can host players. When a game session ends, its status is set to TERMINATED .

Amazon GameLift retains a game session resource for 30 days after the game session ends. You can reuse idempotency token values after this time. Game session logs are retained for 14 days.

All APIs by task

type GameSessionConnectionInfo 

type GameSessionConnectionInfo struct {

	// The DNS identifier assigned to the instance that is running the game session.
	// Values have the following format:
	//
	//   - TLS-enabled fleets: ..amazongamelift.com .
	//
	//   - Non-TLS-enabled fleets: ec2-.compute.amazonaws.com . (See [Amazon EC2 Instance IP Addressing].)
	//
	// When connecting to a game session that is running on a TLS-enabled fleet, you
	// must use the DNS name, not the IP address.
	//
	// [Amazon EC2 Instance IP Addressing]: https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/using-instance-addressing.html#concepts-public-addresses
	DnsName *string

	// A unique identifier for the game session. Use the game session ID.
	GameSessionArn *string

	// The IP address of the game session. To connect to a Amazon GameLift game
	// server, an app needs both the IP address and port number.
	IpAddress *string

	// A collection of player session IDs, one for each player ID that was included in
	// the original matchmaking request.
	MatchedPlayerSessions []MatchedPlayerSession

	// The port number for the game session. To connect to a Amazon GameLift game
	// server, an app needs both the IP address and port number.
	Port *int32
	// contains filtered or unexported fields
}

Connection information for a new game session that is created in response to a start matchmaking request. Once a match is made, the FlexMatch engine creates a new game session for it. This information, including the game session endpoint and player sessions for each player in the original matchmaking request, is added to the matchmaking ticket.

type GameSessionCreationLimitPolicy added in v1.37.0 

type GameSessionCreationLimitPolicy struct {

	// A policy that puts limits on the number of game sessions that a player can
	// create within a specified span of time. With this policy, you can control
	// players' ability to consume available resources.
	//
	// The policy evaluates when a player tries to create a new game session. On
	// receiving a CreateGameSession request, Amazon GameLift checks that the player
	// (identified by CreatorId ) has created fewer than game session limit in the
	// specified time period.
	NewGameSessionsPerCreator *int32

	// The time span used in evaluating the resource creation limit policy.
	PolicyPeriodInMinutes *int32
	// contains filtered or unexported fields
}

A policy that puts limits on the number of game sessions that a player can create within a specified span of time. With this policy, you can control players' ability to consume available resources.

The policy is evaluated when a player tries to create a new game session. On receiving a CreateGameSession request, Amazon GameLift checks that the player (identified by CreatorId ) has created fewer than game session limit in the specified time period.

type GameSessionDetail 

type GameSessionDetail struct {

	// Object that describes a game session.
	GameSession *GameSession

	// Current status of protection for the game session.
	//
	//   - NoProtection -- The game session can be terminated during a scale-down
	//   event.
	//
	//   - FullProtection -- If the game session is in an ACTIVE status, it cannot be
	//   terminated during a scale-down event.
	ProtectionPolicy ProtectionPolicy
	// contains filtered or unexported fields
}

A game session's properties plus the protection policy currently in force.

type GameSessionFullException 

type GameSessionFullException struct {
	Message *string

	ErrorCodeOverride *string
	// contains filtered or unexported fields
}

The game instance is currently full and cannot allow the requested player(s) to join. Clients can retry such requests immediately or after a waiting period.

func (*GameSessionFullException) Error 

func (e *GameSessionFullException) Error() string

func (*GameSessionFullException) ErrorCode 

func (e *GameSessionFullException) ErrorCode() string

func (*GameSessionFullException) ErrorFault 

func (e *GameSessionFullException) ErrorFault() smithy.ErrorFault

func (*GameSessionFullException) ErrorMessage 

func (e *GameSessionFullException) ErrorMessage() string

type GameSessionPlacement 

type GameSessionPlacement struct {

	// The DNS identifier assigned to the instance that is running the game session.
	// Values have the following format:
	//
	//   - TLS-enabled fleets: ..amazongamelift.com .
	//
	//   - Non-TLS-enabled fleets: ec2-.compute.amazonaws.com . (See [Amazon EC2 Instance IP Addressing].)
	//
	// When connecting to a game session that is running on a TLS-enabled fleet, you
	// must use the DNS name, not the IP address.
	//
	// [Amazon EC2 Instance IP Addressing]: https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/using-instance-addressing.html#concepts-public-addresses
	DnsName *string

	// Time stamp indicating when this request was completed, canceled, or timed out.
	EndTime *time.Time

	// A set of key-value pairs that can store custom data in a game session. For
	// example: {"Key": "difficulty", "Value": "novice"} .
	GameProperties []GameProperty

	// Identifier for the game session created by this placement request. This
	// identifier is unique across all Regions. This value isn't final until placement
	// status is FULFILLED .
	GameSessionArn *string

	// A set of custom game session properties, formatted as a single string value.
	// This data is passed to a game server process with a request to start a new game
	// session. For more information, see [Start a game session].
	//
	// [Start a game session]: https://docs.aws.amazon.com/gamelift/latest/developerguide/gamelift-sdk-server-api.html#gamelift-sdk-server-startsession
	GameSessionData *string

	// A unique identifier for the game session. This value isn't final until
	// placement status is FULFILLED .
	GameSessionId *string

	// A descriptive label that is associated with a game session. Session names do
	// not need to be unique.
	GameSessionName *string

	// A descriptive label that is associated with game session queue. Queue names
	// must be unique within each Region.
	GameSessionQueueName *string

	// Name of the Region where the game session created by this placement request is
	// running. This value isn't final until placement status is FULFILLED .
	GameSessionRegion *string

	// The IP address of the game session. To connect to a Amazon GameLift game
	// server, an app needs both the IP address and port number. This value isn't final
	// until placement status is FULFILLED .
	IpAddress *string

	// Information on the matchmaking process for this game. Data is in JSON syntax,
	// formatted as a string. It identifies the matchmaking configuration used to
	// create the match, and contains data on all players assigned to the match,
	// including player attributes and team assignments. For more details on matchmaker
	// data, see [Match Data].
	//
	// [Match Data]: https://docs.aws.amazon.com/gamelift/latest/flexmatchguide/match-server.html#match-server-data
	MatchmakerData *string

	// The maximum number of players that can be connected simultaneously to the game
	// session.
	MaximumPlayerSessionCount *int32

	// A collection of information on player sessions created in response to the game
	// session placement request. These player sessions are created only after a new
	// game session is successfully placed (placement status is FULFILLED ). This
	// information includes the player ID, provided in the placement request, and a
	// corresponding player session ID.
	PlacedPlayerSessions []PlacedPlayerSession

	// A unique identifier for a game session placement.
	PlacementId *string

	// A set of values, expressed in milliseconds, that indicates the amount of
	// latency that a player experiences when connected to @aws; Regions.
	PlayerLatencies []PlayerLatency

	// The port number for the game session. To connect to a Amazon GameLift game
	// server, an app needs both the IP address and port number. This value isn't final
	// until placement status is FULFILLED .
	Port *int32

	// Time stamp indicating when this request was placed in the queue. Format is a
	// number expressed in Unix time as milliseconds (for example "1469498468.057" ).
	StartTime *time.Time

	// Current status of the game session placement request.
	//
	//   - PENDING -- The placement request is in the queue waiting to be processed.
	//   Game session properties are not yet final.
	//
	//   - FULFILLED -- A new game session has been successfully placed. Game session
	//   properties are now final.
	//
	//   - CANCELLED -- The placement request was canceled.
	//
	//   - TIMED_OUT -- A new game session was not successfully created before the
	//   time limit expired. You can resubmit as a new placement request as needed.
	//
	//   - FAILED -- Amazon GameLift is not able to complete the process of placing
	//   the game session. Common reasons are the game session terminated before the
	//   placement process was completed, or an unexpected internal error.
	Status GameSessionPlacementState
	// contains filtered or unexported fields
}

Represents a potential game session placement, including the full details of the original placement request and the current status.

If the game session placement status is PENDING , the properties for game session ID/ARN, region, IP address/DNS, and port aren't final. A game session is not active and ready to accept players until placement status reaches FULFILLED . When the placement is in PENDING status, Amazon GameLift may attempt to place a game session multiple times before succeeding. With each attempt it creates a GameSession object and updates this placement object with the new game session properties..

type GameSessionPlacementState 

type GameSessionPlacementState string
const (
	GameSessionPlacementStatePending   GameSessionPlacementState = "PENDING"
	GameSessionPlacementStateFulfilled GameSessionPlacementState = "FULFILLED"
	GameSessionPlacementStateCancelled GameSessionPlacementState = "CANCELLED"
	GameSessionPlacementStateTimedOut  GameSessionPlacementState = "TIMED_OUT"
	GameSessionPlacementStateFailed    GameSessionPlacementState = "FAILED"
)

Enum values for GameSessionPlacementState

func (GameSessionPlacementState) Values added in v0.29.0 

func (GameSessionPlacementState) Values() []GameSessionPlacementState

Values returns all known values for GameSessionPlacementState. Note that this can be expanded in the future, and so it is only as up to date as the client.

The ordering of this slice is not guaranteed to be stable across updates.

type GameSessionQueue 

type GameSessionQueue struct {

	//  Information that is added to all events that are related to this game session
	// queue.
	CustomEventData *string

	// A list of fleets and/or fleet aliases that can be used to fulfill game session
	// placement requests in the queue. Destinations are identified by either a fleet
	// ARN or a fleet alias ARN, and are listed in order of placement preference.
	Destinations []GameSessionQueueDestination

	// A list of locations where a queue is allowed to place new game sessions.
	// Locations are specified in the form of Amazon Web Services Region codes, such as
	// us-west-2 . If this parameter is not set, game sessions can be placed in any
	// queue location.
	FilterConfiguration *FilterConfiguration

	// The Amazon Resource Name ([ARN] ) that is assigned to a Amazon GameLift game session
	// queue resource and uniquely identifies it. ARNs are unique across all Regions.
	// Format is arn:aws:gamelift:::gamesessionqueue/ . In a Amazon GameLift game
	// session queue ARN, the resource ID matches the Name value.
	//
	// [ARN]: https://docs.aws.amazon.com/AmazonS3/latest/dev/s3-arn-format.html
	GameSessionQueueArn *string

	// A descriptive label that is associated with game session queue. Queue names
	// must be unique within each Region.
	Name *string

	// An SNS topic ARN that is set up to receive game session placement
	// notifications. See [Setting up notifications for game session placement].
	//
	// [Setting up notifications for game session placement]: https://docs.aws.amazon.com/gamelift/latest/developerguide/queue-notification.html
	NotificationTarget *string

	// A set of policies that enforce a sliding cap on player latency when processing
	// game sessions placement requests. Use multiple policies to gradually relax the
	// cap over time if Amazon GameLift can't make a placement. Policies are evaluated
	// in order starting with the lowest maximum latency value.
	PlayerLatencyPolicies []PlayerLatencyPolicy

	// Custom settings to use when prioritizing destinations and locations for game
	// session placements. This configuration replaces the FleetIQ default
	// prioritization process. Priority types that are not explicitly named will be
	// automatically applied at the end of the prioritization process.
	PriorityConfiguration *PriorityConfiguration

	// The maximum time, in seconds, that a new game session placement request remains
	// in the queue. When a request exceeds this time, the game session placement
	// changes to a TIMED_OUT status.
	TimeoutInSeconds *int32
	// contains filtered or unexported fields
}

Configuration for a game session placement mechanism that processes requests for new game sessions. A queue can be used on its own or as part of a matchmaking solution.

type GameSessionQueueDestination 

type GameSessionQueueDestination struct {

	// The Amazon Resource Name (ARN) that is assigned to fleet or fleet alias. ARNs,
	// which include a fleet ID or alias ID and a Region name, provide a unique
	// identifier across all Regions.
	DestinationArn *string
	// contains filtered or unexported fields
}

A fleet or alias designated in a game session queue. Queues fulfill requests for new game sessions by placing a new game session on any of the queue's destinations.

type GameSessionStatus 

type GameSessionStatus string
const (
	GameSessionStatusActive      GameSessionStatus = "ACTIVE"
	GameSessionStatusActivating  GameSessionStatus = "ACTIVATING"
	GameSessionStatusTerminated  GameSessionStatus = "TERMINATED"
	GameSessionStatusTerminating GameSessionStatus = "TERMINATING"
	GameSessionStatusError       GameSessionStatus = "ERROR"
)

Enum values for GameSessionStatus

func (GameSessionStatus) Values added in v0.29.0 

func (GameSessionStatus) Values() []GameSessionStatus

Values returns all known values for GameSessionStatus. Note that this can be expanded in the future, and so it is only as up to date as the client.

The ordering of this slice is not guaranteed to be stable across updates.

type GameSessionStatusReason 

type GameSessionStatusReason string
const (
	GameSessionStatusReasonInterrupted GameSessionStatusReason = "INTERRUPTED"
)

Enum values for GameSessionStatusReason

func (GameSessionStatusReason) Values added in v0.29.0 

func (GameSessionStatusReason) Values() []GameSessionStatusReason

Values returns all known values for GameSessionStatusReason. Note that this can be expanded in the future, and so it is only as up to date as the client.

The ordering of this slice is not guaranteed to be stable across updates.

type IdempotentParameterMismatchException 

type IdempotentParameterMismatchException struct {
	Message *string

	ErrorCodeOverride *string
	// contains filtered or unexported fields
}

A game session with this custom ID string already exists in this fleet. Resolve this conflict before retrying this request.

func (*IdempotentParameterMismatchException) Error 

func (e *IdempotentParameterMismatchException) Error() string

func (*IdempotentParameterMismatchException) ErrorCode 

func (e *IdempotentParameterMismatchException) ErrorCode() string

func (*IdempotentParameterMismatchException) ErrorFault 

func (e *IdempotentParameterMismatchException) ErrorFault() smithy.ErrorFault

func (*IdempotentParameterMismatchException) ErrorMessage 

func (e *IdempotentParameterMismatchException) ErrorMessage() string

type Instance 

type Instance struct {

	// A time stamp indicating when this data object was created. Format is a number
	// expressed in Unix time as milliseconds (for example "1469498468.057" ).
	CreationTime *time.Time

	// The DNS identifier assigned to the instance that is running the game session.
	// Values have the following format:
	//
	//   - TLS-enabled fleets: ..amazongamelift.com .
	//
	//   - Non-TLS-enabled fleets: ec2-.compute.amazonaws.com . (See [Amazon EC2 Instance IP Addressing].)
	//
	// When connecting to a game session that is running on a TLS-enabled fleet, you
	// must use the DNS name, not the IP address.
	//
	// [Amazon EC2 Instance IP Addressing]: https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/using-instance-addressing.html#concepts-public-addresses
	DnsName *string

	// The Amazon Resource Name ([ARN] ) that is assigned to a Amazon GameLift fleet
	// resource and uniquely identifies it. ARNs are unique across all Regions. Format
	// is arn:aws:gamelift:::fleet/fleet-a1234567-b8c9-0d1e-2fa3-b45c6d7e8912 .
	//
	// [ARN]: https://docs.aws.amazon.com/AmazonS3/latest/dev/s3-arn-format.html
	FleetArn *string

	// A unique identifier for the fleet that the instance belongs to.
	FleetId *string

	// A unique identifier for the instance.
	InstanceId *string

	// IP address that is assigned to the instance.
	IpAddress *string

	// The fleet location of the instance, expressed as an Amazon Web Services Region
	// code, such as us-west-2 .
	Location *string

	// Operating system that is running on this EC2 instance.
	//
	// Amazon Linux 2 (AL2) will reach end of support on 6/30/2025. See more details
	// in the [Amazon Linux 2 FAQs]. For game servers that are hosted on AL2 and use Amazon GameLift server
	// SDK 4.x., first update the game server build to server SDK 5.x, and then deploy
	// to AL2023 instances. See [Migrate to Amazon GameLift server SDK version 5.]
	//
	// [Amazon Linux 2 FAQs]: https://aws.amazon.com/amazon-linux-2/faqs/
	// [Migrate to Amazon GameLift server SDK version 5.]: https://docs.aws.amazon.com/gamelift/latest/developerguide/reference-serversdk5-migration.html
	OperatingSystem OperatingSystem

	// Current status of the instance. Possible statuses include the following:
	//
	//   - PENDING -- The instance is in the process of being created and launching
	//   server processes as defined in the fleet's run-time configuration.
	//
	//   - ACTIVE -- The instance has been successfully created and at least one
	//   server process has successfully launched and reported back to Amazon GameLift
	//   that it is ready to host a game session. The instance is now considered ready to
	//   host game sessions.
	//
	//   - TERMINATING -- The instance is in the process of shutting down. This may
	//   happen to reduce capacity during a scaling down event or to recycle resources in
	//   the event of a problem.
	Status InstanceStatus

	// EC2 instance type that defines the computing resources of this instance.
	Type EC2InstanceType
	// contains filtered or unexported fields
}

Represents a virtual computing instance that runs game server processes and hosts game sessions. In Amazon GameLift, one or more instances make up a managed EC2 fleet.

type InstanceAccess 

type InstanceAccess struct {

	// Security credentials that are required to access the instance.
	Credentials *InstanceCredentials

	// A unique identifier for the fleet containing the instance to be accessed.
	FleetId *string

	// A unique identifier for the instance to be accessed.
	InstanceId *string

	// IP address assigned to the instance.
	IpAddress *string

	// Operating system that is running on the instance.
	OperatingSystem OperatingSystem
	// contains filtered or unexported fields
}

Information and credentials that you can use to remotely connect to an instance in an EC2 managed fleet. This data type is returned in response to a call to GetInstanceAccess.

type InstanceCredentials 

type InstanceCredentials struct {

	// Secret string. For Windows instances, the secret is a password for use with
	// Windows Remote Desktop. For Linux instances, it's a private key for use with
	// SSH.
	Secret *string

	// A user name for logging in.
	UserName *string
	// contains filtered or unexported fields
}

A set of credentials that allow remote access to an instance in an EC2 managed fleet. These credentials are returned in response to a call to GetInstanceAccess, which requests access for instances that are running game servers with the Amazon GameLift server SDK version 4.x or earlier.

type InstanceDefinition 

type InstanceDefinition struct {

	// An Amazon EC2 instance type designation.
	//
	// This member is required.
	InstanceType GameServerGroupInstanceType

	// Instance weighting that indicates how much this instance type contributes to
	// the total capacity of a game server group. Instance weights are used by Amazon
	// GameLift FleetIQ to calculate the instance type's cost per unit hour and better
	// identify the most cost-effective options. For detailed information on weighting
	// instance capacity, see [Instance Weighting]in the Amazon Elastic Compute Cloud Auto Scaling User
	// Guide. Default value is "1".
	//
	// [Instance Weighting]: https://docs.aws.amazon.com/autoscaling/ec2/userguide/asg-instance-weighting.html
	WeightedCapacity *string
	// contains filtered or unexported fields
}
This data type is used with the Amazon GameLift FleetIQ and game server

groups.

An allowed instance type for a game server group. All game server groups must have at least two instance types defined for it. Amazon GameLift FleetIQ periodically evaluates each defined instance type for viability. It then updates the Auto Scaling group with the list of viable instance types.

type InstanceRoleCredentialsProvider added in v1.26.0 

type InstanceRoleCredentialsProvider string
const (
	InstanceRoleCredentialsProviderSharedCredentialFile InstanceRoleCredentialsProvider = "SHARED_CREDENTIAL_FILE"
)

Enum values for InstanceRoleCredentialsProvider

func (InstanceRoleCredentialsProvider) Values added in v1.26.0 

func (InstanceRoleCredentialsProvider) Values() []InstanceRoleCredentialsProvider

Values returns all known values for InstanceRoleCredentialsProvider. Note that this can be expanded in the future, and so it is only as up to date as the client.

The ordering of this slice is not guaranteed to be stable across updates.

type InstanceStatus 

type InstanceStatus string
const (
	InstanceStatusPending     InstanceStatus = "PENDING"
	InstanceStatusActive      InstanceStatus = "ACTIVE"
	InstanceStatusTerminating InstanceStatus = "TERMINATING"
)

Enum values for InstanceStatus

func (InstanceStatus) Values added in v0.29.0 

func (InstanceStatus) Values() []InstanceStatus

Values returns all known values for InstanceStatus. Note that this can be expanded in the future, and so it is only as up to date as the client.

The ordering of this slice is not guaranteed to be stable across updates.

type InternalServiceException 

type InternalServiceException struct {
	Message *string

	ErrorCodeOverride *string
	// contains filtered or unexported fields
}

The service encountered an unrecoverable internal failure while processing the request. Clients can retry such requests immediately or after a waiting period.

func (*InternalServiceException) Error 

func (e *InternalServiceException) Error() string

func (*InternalServiceException) ErrorCode 

func (e *InternalServiceException) ErrorCode() string

func (*InternalServiceException) ErrorFault 

func (e *InternalServiceException) ErrorFault() smithy.ErrorFault

func (*InternalServiceException) ErrorMessage 

func (e *InternalServiceException) ErrorMessage() string

type InvalidFleetStatusException 

type InvalidFleetStatusException struct {
	Message *string

	ErrorCodeOverride *string
	// contains filtered or unexported fields
}

The requested operation would cause a conflict with the current state of a resource associated with the request and/or the fleet. Resolve the conflict before retrying.

func (*InvalidFleetStatusException) Error 

func (e *InvalidFleetStatusException) Error() string

func (*InvalidFleetStatusException) ErrorCode 

func (e *InvalidFleetStatusException) ErrorCode() string

func (*InvalidFleetStatusException) ErrorFault 

func (e *InvalidFleetStatusException) ErrorFault() smithy.ErrorFault

func (*InvalidFleetStatusException) ErrorMessage 

func (e *InvalidFleetStatusException) ErrorMessage() string

type InvalidGameSessionStatusException 

type InvalidGameSessionStatusException struct {
	Message *string

	ErrorCodeOverride *string
	// contains filtered or unexported fields
}

The requested operation would cause a conflict with the current state of a resource associated with the request and/or the game instance. Resolve the conflict before retrying.

func (*InvalidGameSessionStatusException) Error 

func (e *InvalidGameSessionStatusException) Error() string

func (*InvalidGameSessionStatusException) ErrorCode 

func (e *InvalidGameSessionStatusException) ErrorCode() string

func (*InvalidGameSessionStatusException) ErrorFault 

func (e *InvalidGameSessionStatusException) ErrorFault() smithy.ErrorFault

func (*InvalidGameSessionStatusException) ErrorMessage 

func (e *InvalidGameSessionStatusException) ErrorMessage() string

type InvalidRequestException 

type InvalidRequestException struct {
	Message *string

	ErrorCodeOverride *string
	// contains filtered or unexported fields
}

One or more parameter values in the request are invalid. Correct the invalid parameter values before retrying.

func (*InvalidRequestException) Error 

func (e *InvalidRequestException) Error() string

func (*InvalidRequestException) ErrorCode 

func (e *InvalidRequestException) ErrorCode() string

func (*InvalidRequestException) ErrorFault 

func (e *InvalidRequestException) ErrorFault() smithy.ErrorFault

func (*InvalidRequestException) ErrorMessage 

func (e *InvalidRequestException) ErrorMessage() string

type IpPermission 

type IpPermission struct {

	// A starting value for a range of allowed port numbers.
	//
	// For fleets using Linux builds, only ports 22 and 1026-60000 are valid.
	//
	// For fleets using Windows builds, only ports 1026-60000 are valid.
	//
	// This member is required.
	FromPort *int32

	// A range of allowed IP addresses. This value must be expressed in CIDR notation.
	// Example: " 000.000.000.000/[subnet mask] " or optionally the shortened version "
	// 0.0.0.0/[subnet mask] ".
	//
	// This member is required.
	IpRange *string

	// The network communication protocol used by the fleet.
	//
	// This member is required.
	Protocol IpProtocol

	// An ending value for a range of allowed port numbers. Port numbers are
	// end-inclusive. This value must be equal to or greater than FromPort .
	//
	// For fleets using Linux builds, only ports 22 and 1026-60000 are valid.
	//
	// For fleets using Windows builds, only ports 1026-60000 are valid.
	//
	// This member is required.
	ToPort *int32
	// contains filtered or unexported fields
}

A range of IP addresses and port settings that allow inbound traffic to connect to processes on an instance in a fleet. Processes are assigned an IP address/port number combination, which must fall into the fleet's allowed ranges. For managed container fleets, the port settings must use the same port numbers as the fleet's connection ports.

For Realtime Servers fleets, Amazon GameLift automatically opens two port ranges, one for TCP messaging and one for UDP.

type IpProtocol 

type IpProtocol string
const (
	IpProtocolTcp IpProtocol = "TCP"
	IpProtocolUdp IpProtocol = "UDP"
)

Enum values for IpProtocol

func (IpProtocol) Values added in v0.29.0 

func (IpProtocol) Values() []IpProtocol

Values returns all known values for IpProtocol. Note that this can be expanded in the future, and so it is only as up to date as the client.

The ordering of this slice is not guaranteed to be stable across updates.

type LaunchTemplateSpecification 

type LaunchTemplateSpecification struct {

	// A unique identifier for an existing Amazon EC2 launch template.
	LaunchTemplateId *string

	// A readable identifier for an existing Amazon EC2 launch template.
	LaunchTemplateName *string

	// The version of the Amazon EC2 launch template to use. If no version is
	// specified, the default version will be used. With Amazon EC2, you can specify a
	// default version for a launch template. If none is set, the default is the first
	// version created.
	Version *string
	// contains filtered or unexported fields
}
This data type is used with the Amazon GameLift FleetIQ and game server

groups.

An Amazon Elastic Compute Cloud launch template that contains configuration settings and game server code to be deployed to all instances in a game server group. The launch template is specified when creating a new game server group.

type LimitExceededException 

type LimitExceededException struct {
	Message *string

	ErrorCodeOverride *string
	// contains filtered or unexported fields
}

The requested operation would cause the resource to exceed the allowed service limit. Resolve the issue before retrying.

func (*LimitExceededException) Error 

func (e *LimitExceededException) Error() string

func (*LimitExceededException) ErrorCode 

func (e *LimitExceededException) ErrorCode() string

func (*LimitExceededException) ErrorFault 

func (e *LimitExceededException) ErrorFault() smithy.ErrorFault

func (*LimitExceededException) ErrorMessage 

func (e *LimitExceededException) ErrorMessage() string

type ListComputeInputStatus added in v1.37.0 

type ListComputeInputStatus string
const (
	ListComputeInputStatusActive   ListComputeInputStatus = "ACTIVE"
	ListComputeInputStatusImpaired ListComputeInputStatus = "IMPAIRED"
)

Enum values for ListComputeInputStatus

func (ListComputeInputStatus) Values added in v1.37.0 

func (ListComputeInputStatus) Values() []ListComputeInputStatus

Values returns all known values for ListComputeInputStatus. Note that this can be expanded in the future, and so it is only as up to date as the client.

The ordering of this slice is not guaranteed to be stable across updates.

type LocationAttributes added in v1.2.0 

type LocationAttributes struct {

	// A fleet location and its current life-cycle state.
	LocationState *LocationState

	// A list of fleet actions that have been suspended in the fleet location.
	StoppedActions []FleetAction

	// The status of fleet activity updates to the location. The status PENDING_UPDATE
	// indicates that StopFleetActions or StartFleetActions has been requested but the
	// update has not yet been completed for the location.
	UpdateStatus LocationUpdateStatus
	// contains filtered or unexported fields
}

Details about a location in a multi-location fleet.

type LocationConfiguration added in v1.2.0 

type LocationConfiguration struct {

	// An Amazon Web Services Region code, such as us-west-2 . For a list of supported
	// Regions and Local Zones, see [Amazon GameLift service locations]for managed hosting.
	//
	// [Amazon GameLift service locations]: https://docs.aws.amazon.com/gamelift/latest/developerguide/gamelift-regions.html
	//
	// This member is required.
	Location *string
	// contains filtered or unexported fields
}

A remote location where a multi-location fleet can deploy game servers for game hosting.

type LocationFilter added in v1.16.0 

type LocationFilter string
const (
	LocationFilterAws    LocationFilter = "AWS"
	LocationFilterCustom LocationFilter = "CUSTOM"
)

Enum values for LocationFilter

func (LocationFilter) Values added in v1.16.0 

func (LocationFilter) Values() []LocationFilter

Values returns all known values for LocationFilter. Note that this can be expanded in the future, and so it is only as up to date as the client.

The ordering of this slice is not guaranteed to be stable across updates.

type LocationModel added in v1.16.0 

type LocationModel struct {

	// The Amazon Resource Name ([ARN] ) that is assigned to a Amazon GameLift location
	// resource and uniquely identifies it. ARNs are unique across all Regions. Format
	// is arn:aws:gamelift:::location/location-a1234567-b8c9-0d1e-2fa3-b45c6d7e8912 .
	//
	// [ARN]: https://docs.aws.amazon.com/AmazonS3/latest/dev/s3-arn-format.html
	LocationArn *string

	// The location's name.
	LocationName *string
	// contains filtered or unexported fields
}

Properties of a custom location for use in an Amazon GameLift Anywhere fleet. This data type is returned in response to a call to CreateLocation.

type LocationState added in v1.2.0 

type LocationState struct {

	// The fleet location, expressed as an Amazon Web Services Region code such as
	// us-west-2 .
	Location *string

	// The life-cycle status of a fleet location.
	Status FleetStatus
	// contains filtered or unexported fields
}

A fleet location and its life-cycle state. A location state object might be used to describe a fleet's remote location or home Region. Life-cycle state tracks the progress of launching the first instance in a new location and preparing it for game hosting, and then removing all instances and deleting the location from the fleet.

  • NEW -- A new fleet location has been defined and desired instances is set to 1.

  • DOWNLOADING/VALIDATING/BUILDING/ACTIVATING -- Amazon GameLift is setting up the new fleet location, creating new instances with the game build or Realtime script and starting server processes.

  • ACTIVE -- Hosts can now accept game sessions.

  • ERROR -- An error occurred when downloading, validating, building, or activating the fleet location.

  • DELETING -- Hosts are responding to a delete fleet location request.

  • TERMINATED -- The fleet location no longer exists.

  • NOT_FOUND -- The fleet location was not found. This could be because the custom location was removed or not created.

type LocationUpdateStatus added in v1.2.0 

type LocationUpdateStatus string
const (
	LocationUpdateStatusPendingUpdate LocationUpdateStatus = "PENDING_UPDATE"
)

Enum values for LocationUpdateStatus

func (LocationUpdateStatus) Values added in v1.2.0 

func (LocationUpdateStatus) Values() []LocationUpdateStatus

Values returns all known values for LocationUpdateStatus. Note that this can be expanded in the future, and so it is only as up to date as the client.

The ordering of this slice is not guaranteed to be stable across updates.

type LocationalDeployment added in v1.37.0 

type LocationalDeployment struct {

	// The status of fleet deployment activity in the location.
	//
	//   - IN_PROGRESS -- The deployment is in progress.
	//
	//   - IMPAIRED -- The deployment failed and the fleet has some impaired
	//   containers.
	//
	//   - COMPLETE -- The deployment has completed successfully.
	//
	//   - ROLLBACK_IN_PROGRESS -- The deployment failed and rollback has been
	//   initiated.
	//
	//   - ROLLBACK_IN_COMPLETE -- The deployment failed and rollback has been
	//   completed.
	//
	//   - CANCELLED -- The deployment was cancelled.
	DeploymentStatus DeploymentStatus
	// contains filtered or unexported fields
}

For a multi-location container fleet, describes the progress of a deployment across all fleet locations.

type LogConfiguration added in v1.37.0 

type LogConfiguration struct {

	// The type of log collection to use for a fleet.
	//
	//   - CLOUDWATCH -- (default value) Send logs to an Amazon CloudWatch log group
	//   that you define. Each container emits a log stream, which is organized in the
	//   log group.
	//
	//   - S3 -- Store logs in an Amazon S3 bucket that you define.
	//
	//   - NONE -- Don't collect container logs.
	LogDestination LogDestination

	// If log destination is CLOUDWATCH , logs are sent to the specified log group in
	// Amazon CloudWatch.
	LogGroupArn *string

	// If log destination is S3 , logs are sent to the specified Amazon S3 bucket name.
	S3BucketName *string
	// contains filtered or unexported fields
}

A method for collecting container logs for the fleet. Amazon GameLift saves all standard output for each container in logs, including game session logs. You can select from the following methods:

type LogDestination added in v1.37.0 

type LogDestination string
const (
	LogDestinationNone       LogDestination = "NONE"
	LogDestinationCloudwatch LogDestination = "CLOUDWATCH"
	LogDestinationS3         LogDestination = "S3"
)

Enum values for LogDestination

func (LogDestination) Values added in v1.37.0 

func (LogDestination) Values() []LogDestination

Values returns all known values for LogDestination. Note that this can be expanded in the future, and so it is only as up to date as the client.

The ordering of this slice is not guaranteed to be stable across updates.

type MatchedPlayerSession 

type MatchedPlayerSession struct {

	// A unique identifier for a player
	PlayerId *string

	// A unique identifier for a player session
	PlayerSessionId *string
	// contains filtered or unexported fields
}

Represents a new player session that is created as a result of a successful FlexMatch match. A successful match automatically creates new player sessions for every player ID in the original matchmaking request.

When players connect to the match's game session, they must include both player ID and player session ID in order to claim their assigned player slot.

type MatchmakingConfiguration 

type MatchmakingConfiguration struct {

	// A flag that indicates whether a match that was created with this configuration
	// must be accepted by the matched players. To require acceptance, set to TRUE.
	// When this option is enabled, matchmaking tickets use the status
	// REQUIRES_ACCEPTANCE to indicate when a completed potential match is waiting for
	// player acceptance.
	AcceptanceRequired *bool

	// The length of time (in seconds) to wait for players to accept a proposed match,
	// if acceptance is required. If any player rejects the match or fails to accept
	// before the timeout, the ticket continues to look for an acceptable match.
	AcceptanceTimeoutSeconds *int32

	// The number of player slots in a match to keep open for future players. For
	// example, if the configuration's rule set specifies a match for a single
	// 12-person team, and the additional player count is set to 2, only 10 players are
	// selected for the match. This parameter is not used when FlexMatchMode is set to
	// STANDALONE .
	AdditionalPlayerCount *int32

	// The method used to backfill game sessions created with this matchmaking
	// configuration. MANUAL indicates that the game makes backfill requests or does
	// not use the match backfill feature. AUTOMATIC indicates that GameLift creates
	// backfill requests whenever a game session has one or more open slots. Learn more
	// about manual and automatic backfill in [Backfill existing games with FlexMatch]. Automatic backfill is not available
	// when FlexMatchMode is set to STANDALONE .
	//
	// [Backfill existing games with FlexMatch]: https://docs.aws.amazon.com/gamelift/latest/flexmatchguide/match-backfill.html
	BackfillMode BackfillMode

	// The Amazon Resource Name ([ARN] ) that is assigned to a Amazon GameLift matchmaking
	// configuration resource and uniquely identifies it. ARNs are unique across all
	// Regions. Format is arn:aws:gamelift:::matchmakingconfiguration/ . In a Amazon
	// GameLift configuration ARN, the resource ID matches the Name value.
	//
	// [ARN]: https://docs.aws.amazon.com/AmazonS3/latest/dev/s3-arn-format.html
	ConfigurationArn *string

	// A time stamp indicating when this data object was created. Format is a number
	// expressed in Unix time as milliseconds (for example "1469498468.057" ).
	CreationTime *time.Time

	// Information to attach to all events related to the matchmaking configuration.
	CustomEventData *string

	// A descriptive label that is associated with matchmaking configuration.
	Description *string

	// Indicates whether this matchmaking configuration is being used with Amazon
	// GameLift hosting or as a standalone matchmaking solution.
	//
	//   - STANDALONE - FlexMatch forms matches and returns match information,
	//   including players and team assignments, in a [MatchmakingSucceeded]event.
	//
	//   - WITH_QUEUE - FlexMatch forms matches and uses the specified Amazon GameLift
	//   queue to start a game session for the match.
	//
	// [MatchmakingSucceeded]: https://docs.aws.amazon.com/gamelift/latest/flexmatchguide/match-events.html#match-events-matchmakingsucceeded
	FlexMatchMode FlexMatchMode

	// A set of key-value pairs that can store custom data in a game session. For
	// example: {"Key": "difficulty", "Value": "novice"} . This information is added to
	// the new GameSession object that is created for a successful match. This
	// parameter is not used when FlexMatchMode is set to STANDALONE .
	GameProperties []GameProperty

	// A set of custom game session properties, formatted as a single string value.
	// This data is passed to a game server process with a request to start a new game
	// session. For more information, see [Start a game session]. This information is added to the new
	// GameSession object that is created for a successful match. This parameter is not
	// used when FlexMatchMode is set to STANDALONE .
	//
	// [Start a game session]: https://docs.aws.amazon.com/gamelift/latest/developerguide/gamelift-sdk-server-api.html#gamelift-sdk-server-startsession
	GameSessionData *string

	// The Amazon Resource Name ([ARN] ) that is assigned to a Amazon GameLift game session
	// queue resource and uniquely identifies it. ARNs are unique across all Regions.
	// Format is arn:aws:gamelift:::gamesessionqueue/ . Queues can be located in any
	// Region. Queues are used to start new Amazon GameLift-hosted game sessions for
	// matches that are created with this matchmaking configuration. This property is
	// not set when FlexMatchMode is set to STANDALONE .
	//
	// [ARN]: https://docs.aws.amazon.com/AmazonS3/latest/dev/s3-arn-format.html
	GameSessionQueueArns []string

	// A unique identifier for the matchmaking configuration. This name is used to
	// identify the configuration associated with a matchmaking request or ticket.
	Name *string

	// An SNS topic ARN that is set up to receive matchmaking notifications.
	NotificationTarget *string

	// The maximum duration, in seconds, that a matchmaking ticket can remain in
	// process before timing out. Requests that fail due to timing out can be
	// resubmitted as needed.
	RequestTimeoutSeconds *int32

	// The Amazon Resource Name ([ARN] ) associated with the GameLift matchmaking rule set
	// resource that this configuration uses.
	//
	// [ARN]: https://docs.aws.amazon.com/AmazonS3/latest/dev/s3-arn-format.html
	RuleSetArn *string

	// A unique identifier for the matchmaking rule set to use with this
	// configuration. A matchmaking configuration can only use rule sets that are
	// defined in the same Region.
	RuleSetName *string
	// contains filtered or unexported fields
}

Guidelines for use with FlexMatch to match players into games. All matchmaking requests must specify a matchmaking configuration.

type MatchmakingConfigurationStatus 

type MatchmakingConfigurationStatus string
const (
	MatchmakingConfigurationStatusCancelled          MatchmakingConfigurationStatus = "CANCELLED"
	MatchmakingConfigurationStatusCompleted          MatchmakingConfigurationStatus = "COMPLETED"
	MatchmakingConfigurationStatusFailed             MatchmakingConfigurationStatus = "FAILED"
	MatchmakingConfigurationStatusPlacing            MatchmakingConfigurationStatus = "PLACING"
	MatchmakingConfigurationStatusQueued             MatchmakingConfigurationStatus = "QUEUED"
	MatchmakingConfigurationStatusRequiresAcceptance MatchmakingConfigurationStatus = "REQUIRES_ACCEPTANCE"
	MatchmakingConfigurationStatusSearching          MatchmakingConfigurationStatus = "SEARCHING"
	MatchmakingConfigurationStatusTimedOut           MatchmakingConfigurationStatus = "TIMED_OUT"
)

Enum values for MatchmakingConfigurationStatus

func (MatchmakingConfigurationStatus) Values added in v0.29.0 

func (MatchmakingConfigurationStatus) Values() []MatchmakingConfigurationStatus

Values returns all known values for MatchmakingConfigurationStatus. Note that this can be expanded in the future, and so it is only as up to date as the client.

The ordering of this slice is not guaranteed to be stable across updates.

type MatchmakingRuleSet 

type MatchmakingRuleSet struct {

	// A collection of matchmaking rules, formatted as a JSON string. Comments are not
	// allowed in JSON, but most elements support a description field.
	//
	// This member is required.
	RuleSetBody *string

	// A time stamp indicating when this data object was created. Format is a number
	// expressed in Unix time as milliseconds (for example "1469498468.057" ).
	CreationTime *time.Time

	// The Amazon Resource Name ([ARN] ) that is assigned to a Amazon GameLift matchmaking
	// rule set resource and uniquely identifies it. ARNs are unique across all
	// Regions. Format is arn:aws:gamelift:::matchmakingruleset/ . In a GameLift rule
	// set ARN, the resource ID matches the RuleSetName value.
	//
	// [ARN]: https://docs.aws.amazon.com/AmazonS3/latest/dev/s3-arn-format.html
	RuleSetArn *string

	// A unique identifier for the matchmaking rule set
	RuleSetName *string
	// contains filtered or unexported fields
}

Set of rule statements, used with FlexMatch, that determine how to build your player matches. Each rule set describes a type of group to be created and defines the parameters for acceptable player matches.

A rule set may define the following elements for a match. For detailed information and examples showing how to construct a rule set, see Build a FlexMatch rule set.

  • Teams -- Required. A rule set must define one or multiple teams for the match and set minimum and maximum team sizes. For example, a rule set might describe a 4x4 match that requires all eight slots to be filled.

  • Player attributes -- Optional. These attributes specify a set of player characteristics to evaluate when looking for a match. Matchmaking requests that use a rule set with player attributes must provide the corresponding attribute values. For example, an attribute might specify a player's skill or level.

  • Rules -- Optional. Rules define how to evaluate potential players for a match based on player attributes. A rule might specify minimum requirements for individual players, teams, or entire matches. For example, a rule might require each player to meet a certain skill level, each team to have at least one player in a certain role, or the match to have a minimum average skill level. or may describe an entire group--such as all teams must be evenly matched or have at least one player in a certain role.

  • Expansions -- Optional. Expansions allow you to relax the rules after a period of time when no acceptable matches are found. This feature lets you balance getting players into games in a reasonable amount of time instead of making them wait indefinitely for the best possible match. For example, you might use an expansion to increase the maximum skill variance between players after 30 seconds.

type MatchmakingTicket 

type MatchmakingTicket struct {

	// The Amazon Resource Name ([ARN] ) associated with the GameLift matchmaking
	// configuration resource that is used with this ticket.
	//
	// [ARN]: https://docs.aws.amazon.com/AmazonS3/latest/dev/s3-arn-format.html
	ConfigurationArn *string

	// Name of the matchmaking configuration that is used with this ticket.
	// Matchmaking configurations determine how players are grouped into a match and
	// how a new game session is created for the match.
	ConfigurationName *string

	// Time stamp indicating when the matchmaking request stopped being processed due
	// to successful completion, timeout, or cancellation. Format is a number expressed
	// in Unix time as milliseconds (for example "1469498468.057" ).
	EndTime *time.Time

	// Average amount of time (in seconds) that players are currently waiting for a
	// match. If there is not enough recent data, this property may be empty.
	EstimatedWaitTime *int32

	// Connection information for a new game session. Once a match is made, the
	// FlexMatch engine creates a new game session for it. This information is added to
	// the matchmaking ticket, which you can be retrieve by calling [DescribeMatchmaking].
	//
	// [DescribeMatchmaking]: https://docs.aws.amazon.com/gamelift/latest/apireference/API_DescribeMatchmaking.html
	GameSessionConnectionInfo *GameSessionConnectionInfo

	// A set of Player objects, each representing a player to find matches for.
	// Players are identified by a unique player ID and may include latency data for
	// use during matchmaking. If the ticket is in status COMPLETED , the Player
	// objects include the team the players were assigned to in the resulting match.
	Players []Player

	// Time stamp indicating when this matchmaking request was received. Format is a
	// number expressed in Unix time as milliseconds (for example "1469498468.057" ).
	StartTime *time.Time

	// Current status of the matchmaking request.
	//
	//   - QUEUED -- The matchmaking request has been received and is currently
	//   waiting to be processed.
	//
	//   - SEARCHING -- The matchmaking request is currently being processed.
	//
	//   - REQUIRES_ACCEPTANCE -- A match has been proposed and the players must
	//   accept the match. This status is used only with requests that use a matchmaking
	//   configuration with a player acceptance requirement.
	//
	//   - PLACING -- The FlexMatch engine has matched players and is in the process
	//   of placing a new game session for the match.
	//
	//   - COMPLETED -- Players have been matched and a game session is ready to host
	//   the players. A ticket in this state contains the necessary connection
	//   information for players.
	//
	//   - FAILED -- The matchmaking request was not completed.
	//
	//   - CANCELLED -- The matchmaking request was canceled. This may be the result
	//   of a StopMatchmaking operation or a proposed match that one or more players
	//   failed to accept.
	//
	//   - TIMED_OUT -- The matchmaking request was not successful within the duration
	//   specified in the matchmaking configuration.
	//
	// Matchmaking requests that fail to successfully complete (statuses FAILED,
	// CANCELLED, TIMED_OUT) can be resubmitted as new requests with new ticket IDs.
	Status MatchmakingConfigurationStatus

	// Additional information about the current status.
	StatusMessage *string

	// Code to explain the current status. For example, a status reason may indicate
	// when a ticket has returned to SEARCHING status after a proposed match fails to
	// receive player acceptances.
	StatusReason *string

	// A unique identifier for a matchmaking ticket.
	TicketId *string
	// contains filtered or unexported fields
}

Ticket generated to track the progress of a matchmaking request. Each ticket is uniquely identified by a ticket ID, supplied by the requester, when creating a matchmaking request.

type MetricName 

type MetricName string
const (
	MetricNameActivatingGameSessions            MetricName = "ActivatingGameSessions"
	MetricNameActiveGameSessions                MetricName = "ActiveGameSessions"
	MetricNameActiveInstances                   MetricName = "ActiveInstances"
	MetricNameAvailableGameSessions             MetricName = "AvailableGameSessions"
	MetricNameAvailablePlayerSessions           MetricName = "AvailablePlayerSessions"
	MetricNameCurrentPlayerSessions             MetricName = "CurrentPlayerSessions"
	MetricNameIdleInstances                     MetricName = "IdleInstances"
	MetricNamePercentAvailableGameSessions      MetricName = "PercentAvailableGameSessions"
	MetricNamePercentIdleInstances              MetricName = "PercentIdleInstances"
	MetricNameQueueDepth                        MetricName = "QueueDepth"
	MetricNameWaitTime                          MetricName = "WaitTime"
	MetricNameConcurrentActivatableGameSessions MetricName = "ConcurrentActivatableGameSessions"
)

Enum values for MetricName

func (MetricName) Values added in v0.29.0 

func (MetricName) Values() []MetricName

Values returns all known values for MetricName. Note that this can be expanded in the future, and so it is only as up to date as the client.

The ordering of this slice is not guaranteed to be stable across updates.

type NotFoundException 

type NotFoundException struct {
	Message *string

	ErrorCodeOverride *string
	// contains filtered or unexported fields
}

The requested resources was not found. The resource was either not created yet or deleted.

func (*NotFoundException) Error 

func (e *NotFoundException) Error() string

func (*NotFoundException) ErrorCode 

func (e *NotFoundException) ErrorCode() string

func (*NotFoundException) ErrorFault 

func (e *NotFoundException) ErrorFault() smithy.ErrorFault

func (*NotFoundException) ErrorMessage 

func (e *NotFoundException) ErrorMessage() string

type NotReadyException added in v1.31.0 

type NotReadyException struct {
	Message *string

	ErrorCodeOverride *string
	// contains filtered or unexported fields
}
The operation failed because Amazon GameLift has not yet finished validating

this compute. We recommend attempting 8 to 10 retries over 3 to 5 minutes with exponential backoffs and jitter .

func (*NotReadyException) Error added in v1.31.0 

func (e *NotReadyException) Error() string

func (*NotReadyException) ErrorCode added in v1.31.0 

func (e *NotReadyException) ErrorCode() string

func (*NotReadyException) ErrorFault added in v1.31.0 

func (e *NotReadyException) ErrorFault() smithy.ErrorFault

func (*NotReadyException) ErrorMessage added in v1.31.0 

func (e *NotReadyException) ErrorMessage() string

type OperatingSystem 

type OperatingSystem string
const (
	OperatingSystemWindows2012     OperatingSystem = "WINDOWS_2012"
	OperatingSystemAmazonLinux     OperatingSystem = "AMAZON_LINUX"
	OperatingSystemAmazonLinux2    OperatingSystem = "AMAZON_LINUX_2"
	OperatingSystemWindows2016     OperatingSystem = "WINDOWS_2016"
	OperatingSystemAmazonLinux2023 OperatingSystem = "AMAZON_LINUX_2023"
)

Enum values for OperatingSystem

func (OperatingSystem) Values added in v0.29.0 

func (OperatingSystem) Values() []OperatingSystem

Values returns all known values for OperatingSystem. Note that this can be expanded in the future, and so it is only as up to date as the client.

The ordering of this slice is not guaranteed to be stable across updates.

type OutOfCapacityException 

type OutOfCapacityException struct {
	Message *string

	ErrorCodeOverride *string
	// contains filtered or unexported fields
}

The specified game server group has no available game servers to fulfill a ClaimGameServer request. Clients can retry such requests immediately or after a waiting period.

func (*OutOfCapacityException) Error 

func (e *OutOfCapacityException) Error() string

func (*OutOfCapacityException) ErrorCode 

func (e *OutOfCapacityException) ErrorCode() string

func (*OutOfCapacityException) ErrorFault 

func (e *OutOfCapacityException) ErrorFault() smithy.ErrorFault

func (*OutOfCapacityException) ErrorMessage 

func (e *OutOfCapacityException) ErrorMessage() string

type PlacedPlayerSession 

type PlacedPlayerSession struct {

	// A unique identifier for a player that is associated with this player session.
	PlayerId *string

	// A unique identifier for a player session.
	PlayerSessionId *string
	// contains filtered or unexported fields
}

Information about a player session. This object contains only the player ID and player session ID. To retrieve full details on a player session, call DescribePlayerSessionswith the player session ID.

type Player 

type Player struct {

	// A set of values, expressed in milliseconds, that indicates the amount of
	// latency that a player experiences when connected to @aws; Regions. If this
	// property is present, FlexMatch considers placing the match only in Regions for
	// which latency is reported.
	//
	// If a matchmaker has a rule that evaluates player latency, players must report
	// latency in order to be matched. If no latency is reported in this scenario,
	// FlexMatch assumes that no Regions are available to the player and the ticket is
	// not matchable.
	LatencyInMs map[string]int32

	// A collection of key:value pairs containing player information for use in
	// matchmaking. Player attribute keys must match the playerAttributes used in a
	// matchmaking rule set. Example: "PlayerAttributes": {"skill": {"N": "23"},
	// "gameMode": {"S": "deathmatch"}} .
	//
	// You can provide up to 10 PlayerAttributes .
	PlayerAttributes map[string]AttributeValue

	// A unique identifier for a player
	PlayerId *string

	// Name of the team that the player is assigned to in a match. Team names are
	// defined in a matchmaking rule set.
	Team *string
	// contains filtered or unexported fields
}

Represents a player in matchmaking. When starting a matchmaking request, a player has a player ID, attributes, and may have latency data. Team information is added after a match has been successfully completed.

type PlayerLatency 

type PlayerLatency struct {

	// Amount of time that represents the time lag experienced by the player when
	// connected to the specified Region.
	LatencyInMilliseconds *float32

	// A unique identifier for a player associated with the latency data.
	PlayerId *string

	// Name of the Region that is associated with the latency value.
	RegionIdentifier *string
	// contains filtered or unexported fields
}

Regional latency information for a player, used when requesting a new game session. This value indicates the amount of time lag that exists when the player is connected to a fleet in the specified Region. The relative difference between a player's latency values for multiple Regions are used to determine which fleets are best suited to place a new game session for the player.

type PlayerLatencyPolicy 

type PlayerLatencyPolicy struct {

	// The maximum latency value that is allowed for any player, in milliseconds. All
	// policies must have a value set for this property.
	MaximumIndividualPlayerLatencyMilliseconds *int32

	// The length of time, in seconds, that the policy is enforced while placing a new
	// game session. A null value for this property means that the policy is enforced
	// until the queue times out.
	PolicyDurationSeconds *int32
	// contains filtered or unexported fields
}

Sets a latency cap for individual players when placing a game session. With a latency policy in force, a game session cannot be placed in a fleet location where a player reports latency higher than the cap. Latency policies are used only with placement request that provide player latency information. Player latency policies can be stacked to gradually relax latency requirements over time.

type PlayerSession 

type PlayerSession struct {

	// A time stamp indicating when this data object was created. Format is a number
	// expressed in Unix time as milliseconds (for example "1469498468.057" ).
	CreationTime *time.Time

	// The DNS identifier assigned to the instance that is running the game session.
	// Values have the following format:
	//
	//   - TLS-enabled fleets: ..amazongamelift.com .
	//
	//   - Non-TLS-enabled fleets: ec2-.compute.amazonaws.com . (See [Amazon EC2 Instance IP Addressing].)
	//
	// When connecting to a game session that is running on a TLS-enabled fleet, you
	// must use the DNS name, not the IP address.
	//
	// [Amazon EC2 Instance IP Addressing]: https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/using-instance-addressing.html#concepts-public-addresses
	DnsName *string

	//  The Amazon Resource Name ([ARN] ) associated with the GameLift fleet that the
	// player's game session is running on.
	//
	// [ARN]: https://docs.aws.amazon.com/AmazonS3/latest/dev/s3-arn-format.html
	FleetArn *string

	// A unique identifier for the fleet that the player's game session is running on.
	FleetId *string

	// A unique identifier for the game session that the player session is connected
	// to.
	GameSessionId *string

	// The IP address of the game session. To connect to a Amazon GameLift game
	// server, an app needs both the IP address and port number.
	IpAddress *string

	// Developer-defined information related to a player. Amazon GameLift does not use
	// this data, so it can be formatted as needed for use in the game.
	PlayerData *string

	// A unique identifier for a player that is associated with this player session.
	PlayerId *string

	// A unique identifier for a player session.
	PlayerSessionId *string

	// Port number for the game session. To connect to a Amazon GameLift server
	// process, an app needs both the IP address and port number.
	Port *int32

	// Current status of the player session.
	//
	// Possible player session statuses include the following:
	//
	//   - RESERVED -- The player session request has been received, but the player
	//   has not yet connected to the server process and/or been validated.
	//
	//   - ACTIVE -- The player has been validated by the server process and is
	//   currently connected.
	//
	//   - COMPLETED -- The player connection has been dropped.
	//
	//   - TIMEDOUT -- A player session request was received, but the player did not
	//   connect and/or was not validated within the timeout limit (60 seconds).
	Status PlayerSessionStatus

	// A time stamp indicating when this data object was terminated. Format is a
	// number expressed in Unix time as milliseconds (for example "1469498468.057" ).
	TerminationTime *time.Time
	// contains filtered or unexported fields
}

Represents a player session. Player sessions are created either for a specific game session, or as part of a game session placement or matchmaking request. A player session can represents a reserved player slot in a game session (when status is RESERVED ) or actual player activity in a game session (when status is ACTIVE ). A player session object, including player data, is automatically passed to a game session when the player connects to the game session and is validated. After the game session ends, player sessions information is retained for 30 days and then removed.

All APIs by task

type PlayerSessionCreationPolicy 

type PlayerSessionCreationPolicy string
const (
	PlayerSessionCreationPolicyAcceptAll PlayerSessionCreationPolicy = "ACCEPT_ALL"
	PlayerSessionCreationPolicyDenyAll   PlayerSessionCreationPolicy = "DENY_ALL"
)

Enum values for PlayerSessionCreationPolicy

func (PlayerSessionCreationPolicy) Values added in v0.29.0 

func (PlayerSessionCreationPolicy) Values() []PlayerSessionCreationPolicy

Values returns all known values for PlayerSessionCreationPolicy. Note that this can be expanded in the future, and so it is only as up to date as the client.

The ordering of this slice is not guaranteed to be stable across updates.

type PlayerSessionStatus 

type PlayerSessionStatus string
const (
	PlayerSessionStatusReserved  PlayerSessionStatus = "RESERVED"
	PlayerSessionStatusActive    PlayerSessionStatus = "ACTIVE"
	PlayerSessionStatusCompleted PlayerSessionStatus = "COMPLETED"
	PlayerSessionStatusTimedout  PlayerSessionStatus = "TIMEDOUT"
)

Enum values for PlayerSessionStatus

func (PlayerSessionStatus) Values added in v0.29.0 

func (PlayerSessionStatus) Values() []PlayerSessionStatus

Values returns all known values for PlayerSessionStatus. Note that this can be expanded in the future, and so it is only as up to date as the client.

The ordering of this slice is not guaranteed to be stable across updates.

type PolicyType 

type PolicyType string
const (
	PolicyTypeRuleBased   PolicyType = "RuleBased"
	PolicyTypeTargetBased PolicyType = "TargetBased"
)

Enum values for PolicyType

func (PolicyType) Values added in v0.29.0 

func (PolicyType) Values() []PolicyType

Values returns all known values for PolicyType. Note that this can be expanded in the future, and so it is only as up to date as the client.

The ordering of this slice is not guaranteed to be stable across updates.

type PriorityConfiguration added in v1.2.0 

type PriorityConfiguration struct {

	// The prioritization order to use for fleet locations, when the PriorityOrder
	// property includes LOCATION . Locations are identified by Amazon Web Services
	// Region codes such as us-west-2 . Each location can only be listed once.
	LocationOrder []string

	// The recommended sequence to use when prioritizing where to place new game
	// sessions. Each type can only be listed once.
	//
	//   - LATENCY -- FleetIQ prioritizes locations where the average player latency
	//   (provided in each game session request) is lowest.
	//
	//   - COST -- FleetIQ prioritizes destinations with the lowest current hosting
	//   costs. Cost is evaluated based on the location, instance type, and fleet type
	//   (Spot or On-Demand) for each destination in the queue.
	//
	//   - DESTINATION -- FleetIQ prioritizes based on the order that destinations are
	//   listed in the queue configuration.
	//
	//   - LOCATION -- FleetIQ prioritizes based on the provided order of locations, as
	//   defined in LocationOrder .
	PriorityOrder []PriorityType
	// contains filtered or unexported fields
}

Custom prioritization settings for use by a game session queue when placing new game sessions with available game servers. When defined, this configuration replaces the default FleetIQ prioritization process, which is as follows:

  • If player latency data is included in a game session request, destinations and locations are prioritized first based on lowest average latency (1), then on lowest hosting cost (2), then on destination list order (3), and finally on location (alphabetical) (4). This approach ensures that the queue's top priority is to place game sessions where average player latency is lowest, and--if latency is the same--where the hosting cost is less, etc.

  • If player latency data is not included, destinations and locations are prioritized first on destination list order (1), and then on location (alphabetical) (2). This approach ensures that the queue's top priority is to place game sessions on the first destination fleet listed. If that fleet has multiple locations, the game session is placed on the first location (when listed alphabetically).

Changing the priority order will affect how game sessions are placed.

type PriorityType added in v1.2.0 

type PriorityType string
const (
	PriorityTypeLatency     PriorityType = "LATENCY"
	PriorityTypeCost        PriorityType = "COST"
	PriorityTypeDestination PriorityType = "DESTINATION"
	PriorityTypeLocation    PriorityType = "LOCATION"
)

Enum values for PriorityType

func (PriorityType) Values added in v1.2.0 

func (PriorityType) Values() []PriorityType

Values returns all known values for PriorityType. Note that this can be expanded in the future, and so it is only as up to date as the client.

The ordering of this slice is not guaranteed to be stable across updates.

type ProtectionPolicy 

type ProtectionPolicy string
const (
	ProtectionPolicyNoProtection   ProtectionPolicy = "NoProtection"
	ProtectionPolicyFullProtection ProtectionPolicy = "FullProtection"
)

Enum values for ProtectionPolicy

func (ProtectionPolicy) Values added in v0.29.0 

func (ProtectionPolicy) Values() []ProtectionPolicy

Values returns all known values for ProtectionPolicy. Note that this can be expanded in the future, and so it is only as up to date as the client.

The ordering of this slice is not guaranteed to be stable across updates.

type ResourceCreationLimitPolicy 

type ResourceCreationLimitPolicy struct {

	// A policy that puts limits on the number of game sessions that a player can
	// create within a specified span of time. With this policy, you can control
	// players' ability to consume available resources.
	//
	// The policy is evaluated when a player tries to create a new game session. On
	// receiving a CreateGameSession request, Amazon GameLift checks that the player
	// (identified by CreatorId ) has created fewer than game session limit in the
	// specified time period.
	NewGameSessionsPerCreator *int32

	// The time span used in evaluating the resource creation limit policy.
	PolicyPeriodInMinutes *int32
	// contains filtered or unexported fields
}

A policy that puts limits on the number of game sessions that a player can create within a specified span of time. With this policy, you can control players' ability to consume available resources.

The policy is evaluated when a player tries to create a new game session. On receiving a CreateGameSession request, Amazon GameLift checks that the player (identified by CreatorId ) has created fewer than game session limit in the specified time period.

type RoutingStrategy 

type RoutingStrategy struct {

	// A unique identifier for the fleet that the alias points to. This value is the
	// fleet ID, not the fleet ARN.
	FleetId *string

	// The message text to be used with a terminal routing strategy.
	Message *string

	// The type of routing strategy for the alias.
	//
	// Possible routing types include the following:
	//
	//   - SIMPLE - The alias resolves to one specific fleet. Use this type when
	//   routing to active fleets.
	//
	//   - TERMINAL - The alias does not resolve to a fleet but instead can be used to
	//   display a message to the user. A terminal alias throws a
	//   TerminalRoutingStrategyException with the message embedded.
	Type RoutingStrategyType
	// contains filtered or unexported fields
}

The routing configuration for a fleet alias.

All APIs by task

type RoutingStrategyType 

type RoutingStrategyType string
const (
	RoutingStrategyTypeSimple   RoutingStrategyType = "SIMPLE"
	RoutingStrategyTypeTerminal RoutingStrategyType = "TERMINAL"
)

Enum values for RoutingStrategyType

func (RoutingStrategyType) Values added in v0.29.0 

func (RoutingStrategyType) Values() []RoutingStrategyType

Values returns all known values for RoutingStrategyType. Note that this can be expanded in the future, and so it is only as up to date as the client.

The ordering of this slice is not guaranteed to be stable across updates.

type RuntimeConfiguration 

type RuntimeConfiguration struct {

	// The maximum amount of time (in seconds) allowed to launch a new game session
	// and have it report ready to host players. During this time, the game session is
	// in status ACTIVATING . If the game session does not become active before the
	// timeout, it is ended and the game session status is changed to TERMINATED .
	GameSessionActivationTimeoutSeconds *int32

	// The number of game sessions in status ACTIVATING to allow on an instance. This
	// setting limits the instance resources that can be used for new game activations
	// at any one time.
	MaxConcurrentGameSessionActivations *int32

	// A collection of server process configurations that identify what server
	// processes to run on fleet computes.
	ServerProcesses []ServerProcess
	// contains filtered or unexported fields
}

A set of instructions that define the set of server processes to run on computes in a fleet. Server processes run either an executable in a custom game build or a Realtime Servers script. Amazon GameLift launches the processes, manages their life cycle, and replaces them as needed. Computes check regularly for an updated runtime configuration.

An Amazon GameLift instance is limited to 50 processes running concurrently. To calculate the total number of processes defined in a runtime configuration, add the values of the ConcurrentExecutions parameter for each server process. Learn more about Running Multiple Processes on a Fleet.

type S3Location 

type S3Location struct {

	// An Amazon S3 bucket identifier. Thename of the S3 bucket.
	//
	// Amazon GameLift doesn't support uploading from Amazon S3 buckets with names
	// that contain a dot (.).
	Bucket *string

	// The name of the zip file that contains the build files or script files.
	Key *string

	// The version of the file, if object versioning is turned on for the bucket.
	// Amazon GameLift uses this information when retrieving files from an S3 bucket
	// that you own. Use this parameter to specify a specific version of the file. If
	// not set, the latest version of the file is retrieved.
	ObjectVersion *string

	// The Amazon Resource Name ([ARN] ) for an IAM role that allows Amazon GameLift to
	// access the S3 bucket.
	//
	// [ARN]: https://docs.aws.amazon.com/AmazonS3/latest/dev/s3-arn-format.html
	RoleArn *string
	// contains filtered or unexported fields
}

The location in Amazon S3 where build or script files are stored for access by Amazon GameLift.

type ScalingAdjustmentType 

type ScalingAdjustmentType string
const (
	ScalingAdjustmentTypeChangeInCapacity        ScalingAdjustmentType = "ChangeInCapacity"
	ScalingAdjustmentTypeExactCapacity           ScalingAdjustmentType = "ExactCapacity"
	ScalingAdjustmentTypePercentChangeInCapacity ScalingAdjustmentType = "PercentChangeInCapacity"
)

Enum values for ScalingAdjustmentType

func (ScalingAdjustmentType) Values added in v0.29.0 

func (ScalingAdjustmentType) Values() []ScalingAdjustmentType

Values returns all known values for ScalingAdjustmentType. Note that this can be expanded in the future, and so it is only as up to date as the client.

The ordering of this slice is not guaranteed to be stable across updates.

type ScalingPolicy 

type ScalingPolicy struct {

	// Comparison operator to use when measuring a metric against the threshold value.
	ComparisonOperator ComparisonOperatorType

	// Length of time (in minutes) the metric must be at or beyond the threshold
	// before a scaling event is triggered.
	EvaluationPeriods *int32

	// The Amazon Resource Name ([ARN] ) that is assigned to a Amazon GameLift fleet
	// resource and uniquely identifies it. ARNs are unique across all Regions. Format
	// is arn:aws:gamelift:::fleet/fleet-a1234567-b8c9-0d1e-2fa3-b45c6d7e8912 .
	//
	// [ARN]: https://docs.aws.amazon.com/AmazonS3/latest/dev/s3-arn-format.html
	FleetArn *string

	// A unique identifier for the fleet that is associated with this scaling policy.
	FleetId *string

	//  The fleet location.
	Location *string

	// Name of the Amazon GameLift-defined metric that is used to trigger a scaling
	// adjustment. For detailed descriptions of fleet metrics, see [Monitor Amazon GameLift with Amazon CloudWatch].
	//
	//   - ActivatingGameSessions -- Game sessions in the process of being created.
	//
	//   - ActiveGameSessions -- Game sessions that are currently running.
	//
	//   - ActiveInstances -- Fleet instances that are currently running at least one
	//   game session.
	//
	//   - AvailableGameSessions -- Additional game sessions that fleet could host
	//   simultaneously, given current capacity.
	//
	//   - AvailablePlayerSessions -- Empty player slots in currently active game
	//   sessions. This includes game sessions that are not currently accepting players.
	//   Reserved player slots are not included.
	//
	//   - CurrentPlayerSessions -- Player slots in active game sessions that are
	//   being used by a player or are reserved for a player.
	//
	//   - IdleInstances -- Active instances that are currently hosting zero game
	//   sessions.
	//
	//   - PercentAvailableGameSessions -- Unused percentage of the total number of
	//   game sessions that a fleet could host simultaneously, given current capacity.
	//   Use this metric for a target-based scaling policy.
	//
	//   - PercentIdleInstances -- Percentage of the total number of active instances
	//   that are hosting zero game sessions.
	//
	//   - QueueDepth -- Pending game session placement requests, in any queue, where
	//   the current fleet is the top-priority destination.
	//
	//   - WaitTime -- Current wait time for pending game session placement requests,
	//   in any queue, where the current fleet is the top-priority destination.
	//
	// [Monitor Amazon GameLift with Amazon CloudWatch]: https://docs.aws.amazon.com/gamelift/latest/developerguide/monitoring-cloudwatch.html
	MetricName MetricName

	// A descriptive label that is associated with a fleet's scaling policy. Policy
	// names do not need to be unique.
	Name *string

	// The type of scaling policy to create. For a target-based policy, set the
	// parameter MetricName to 'PercentAvailableGameSessions' and specify a
	// TargetConfiguration. For a rule-based policy set the following parameters:
	// MetricName, ComparisonOperator, Threshold, EvaluationPeriods,
	// ScalingAdjustmentType, and ScalingAdjustment.
	PolicyType PolicyType

	// Amount of adjustment to make, based on the scaling adjustment type.
	ScalingAdjustment *int32

	// The type of adjustment to make to a fleet's instance count.
	//
	//   - ChangeInCapacity -- add (or subtract) the scaling adjustment value from the
	//   current instance count. Positive values scale up while negative values scale
	//   down.
	//
	//   - ExactCapacity -- set the instance count to the scaling adjustment value.
	//
	//   - PercentChangeInCapacity -- increase or reduce the current instance count by
	//   the scaling adjustment, read as a percentage. Positive values scale up while
	//   negative values scale down.
	ScalingAdjustmentType ScalingAdjustmentType

	// Current status of the scaling policy. The scaling policy can be in force only
	// when in an ACTIVE status. Scaling policies can be suspended for individual
	// fleets. If the policy is suspended for a fleet, the policy status does not
	// change.
	//
	//   - ACTIVE -- The scaling policy can be used for auto-scaling a fleet.
	//
	//   - UPDATE_REQUESTED -- A request to update the scaling policy has been
	//   received.
	//
	//   - UPDATING -- A change is being made to the scaling policy.
	//
	//   - DELETE_REQUESTED -- A request to delete the scaling policy has been
	//   received.
	//
	//   - DELETING -- The scaling policy is being deleted.
	//
	//   - DELETED -- The scaling policy has been deleted.
	//
	//   - ERROR -- An error occurred in creating the policy. It should be removed and
	//   recreated.
	Status ScalingStatusType

	// An object that contains settings for a target-based scaling policy.
	TargetConfiguration *TargetConfiguration

	// Metric value used to trigger a scaling event.
	Threshold *float64

	// The current status of the fleet's scaling policies in a requested fleet
	// location. The status PENDING_UPDATE indicates that an update was requested for
	// the fleet but has not yet been completed for the location.
	UpdateStatus LocationUpdateStatus
	// contains filtered or unexported fields
}

Rule that controls how a fleet is scaled. Scaling policies are uniquely identified by the combination of name and fleet ID.

type ScalingStatusType 

type ScalingStatusType string
const (
	ScalingStatusTypeActive          ScalingStatusType = "ACTIVE"
	ScalingStatusTypeUpdateRequested ScalingStatusType = "UPDATE_REQUESTED"
	ScalingStatusTypeUpdating        ScalingStatusType = "UPDATING"
	ScalingStatusTypeDeleteRequested ScalingStatusType = "DELETE_REQUESTED"
	ScalingStatusTypeDeleting        ScalingStatusType = "DELETING"
	ScalingStatusTypeDeleted         ScalingStatusType = "DELETED"
	ScalingStatusTypeError           ScalingStatusType = "ERROR"
)

Enum values for ScalingStatusType

func (ScalingStatusType) Values added in v0.29.0 

func (ScalingStatusType) Values() []ScalingStatusType

Values returns all known values for ScalingStatusType. Note that this can be expanded in the future, and so it is only as up to date as the client.

The ordering of this slice is not guaranteed to be stable across updates.

type Script 

type Script struct {

	// A time stamp indicating when this data object was created. Format is a number
	// expressed in Unix time as milliseconds (for example "1469498468.057" ).
	CreationTime *time.Time

	// A descriptive label that is associated with a script. Script names do not need
	// to be unique.
	Name *string

	// The Amazon Resource Name ([ARN] ) that is assigned to a Amazon GameLift script
	// resource and uniquely identifies it. ARNs are unique across all Regions. In a
	// GameLift script ARN, the resource ID matches the ScriptId value.
	//
	// [ARN]: https://docs.aws.amazon.com/AmazonS3/latest/dev/s3-arn-format.html
	ScriptArn *string

	// A unique identifier for the Realtime script
	ScriptId *string

	// The file size of the uploaded Realtime script, expressed in bytes. When files
	// are uploaded from an S3 location, this value remains at "0".
	SizeOnDisk *int64

	// The location of the Amazon S3 bucket where a zipped file containing your
	// Realtime scripts is stored. The storage location must specify the Amazon S3
	// bucket name, the zip file name (the "key"), and a role ARN that allows Amazon
	// GameLift to access the Amazon S3 storage location. The S3 bucket must be in the
	// same Region where you want to create a new script. By default, Amazon GameLift
	// uploads the latest version of the zip file; if you have S3 object versioning
	// turned on, you can use the ObjectVersion parameter to specify an earlier
	// version.
	StorageLocation *S3Location

	// Version information that is associated with a build or script. Version strings
	// do not need to be unique.
	Version *string
	// contains filtered or unexported fields
}

Properties describing a Realtime script.

All APIs by task

type ServerProcess 

type ServerProcess struct {

	// The number of server processes using this configuration that run concurrently
	// on each instance or compute.
	//
	// This member is required.
	ConcurrentExecutions *int32

	// The location of a game build executable or Realtime script. Game builds and
	// Realtime scripts are installed on instances at the root:
	//
	//   - Windows (custom game builds only): C:\game . Example: "
	//   C:\game\MyGame\server.exe "
	//
	//   - Linux: /local/game . Examples: " /local/game/MyGame/server.exe " or "
	//   /local/game/MyRealtimeScript.js "
	//
	// Amazon GameLift doesn't support the use of setup scripts that launch the game
	// executable. For custom game builds, this parameter must indicate the executable
	// that calls the server SDK operations initSDK() and ProcessReady() .
	//
	// This member is required.
	LaunchPath *string

	// An optional list of parameters to pass to the server executable or Realtime
	// script on launch.
	Parameters *string
	// contains filtered or unexported fields
}

A set of instructions for launching server processes on fleet computes. Server processes run either an executable in a custom game build or a Realtime Servers script. Server process configurations are part of a fleet's runtime configuration.

type SortOrder 

type SortOrder string
const (
	SortOrderAscending  SortOrder = "ASCENDING"
	SortOrderDescending SortOrder = "DESCENDING"
)

Enum values for SortOrder

func (SortOrder) Values added in v0.29.0 

func (SortOrder) Values() []SortOrder

Values returns all known values for SortOrder. Note that this can be expanded in the future, and so it is only as up to date as the client.

The ordering of this slice is not guaranteed to be stable across updates.

type SupportContainerDefinition added in v1.37.0 

type SupportContainerDefinition struct {

	// The container definition identifier. Container names are unique within a
	// container group definition.
	ContainerName *string

	// Indicates that the container relies on the status of other containers in the
	// same container group during its startup and shutdown sequences. A container
	// might have dependencies on multiple containers.
	DependsOn []ContainerDependency

	// A set of environment variables that's passed to the container on startup. See
	// the [ContainerDefinition::environment]parameter in the Amazon Elastic Container Service API Reference.
	//
	// [ContainerDefinition::environment]: https://docs.aws.amazon.com/AmazonECS/latest/APIReference/API_ContainerDefinition.html#ECS-Type-ContainerDefinition-environment
	EnvironmentOverride []ContainerEnvironment

	// Indicates whether the container is vital to the container group. If an
	// essential container fails, the entire container group restarts.
	Essential *bool

	// A configuration for a non-terminal health check. A support container
	// automatically restarts if it stops functioning or if it fails this health check.
	HealthCheck *ContainerHealthCheck

	// The URI to the image that Amazon GameLift deploys to a container fleet. For a
	// more specific identifier, see ResolvedImageDigest .
	ImageUri *string

	// The amount of memory that Amazon GameLift makes available to the container. If
	// memory limits aren't set for an individual container, the container shares the
	// container group's total memory allocation.
	//
	// Related data type: ContainerGroupDefinition$TotalMemoryLimitMebibytes
	MemoryHardLimitMebibytes *int32

	// A mount point that binds a path inside the container to a file or directory on
	// the host system and lets it access the file or directory.
	MountPoints []ContainerMountPoint

	// A set of ports that allow access to the container from external users.
	// Processes running in the container can bind to a one of these ports. Container
	// ports aren't directly accessed by inbound traffic. Amazon GameLift maps these
	// container ports to externally accessible connection ports, which are assigned as
	// needed from the container fleet's ConnectionPortRange .
	PortConfiguration *ContainerPortConfiguration

	// A unique and immutable identifier for the container image. The digest is a SHA
	// 256 hash of the container image manifest.
	ResolvedImageDigest *string

	// The number of vCPU units that are reserved for the container. If no resources
	// are reserved, the container shares the total vCPU limit for the container group.
	//
	// Related data type: ContainerGroupDefinition$TotalVcpuLimit
	Vcpu *float64
	// contains filtered or unexported fields
}

Describes a support container in a container group. A support container might be in a game server container group or a per-instance container group. Support containers don't run game server processes.

You can update a support container definition and deploy the updates to an existing fleet. When creating or updating a game server container group definition, use the property GameServerContainerDefinitionInput.

Part of: ContainerGroupDefinition

Returned by: DescribeContainerGroupDefinition, ListContainerGroupDefinitions, UpdateContainerGroupDefinition

type SupportContainerDefinitionInput added in v1.37.0 

type SupportContainerDefinitionInput struct {

	// A string that uniquely identifies the container definition within a container
	// group.
	//
	// This member is required.
	ContainerName *string

	// The location of the container image to deploy to a container fleet. Provide an
	// image in an Amazon Elastic Container Registry public or private repository. The
	// repository must be in the same Amazon Web Services account and Amazon Web
	// Services Region where you're creating the container group definition. For limits
	// on image size, see [Amazon GameLift endpoints and quotas]. You can use any of the following image URI formats:
	//
	//   - Image ID only: [AWS account].dkr.ecr.[AWS region].amazonaws.com/[repository
	//   ID]
	//
	//   - Image ID and digest: [AWS account].dkr.ecr.[AWS
	//   region].amazonaws.com/[repository ID]@[digest]
	//
	//   - Image ID and tag: [AWS account].dkr.ecr.[AWS
	//   region].amazonaws.com/[repository ID]:[tag]
	//
	// [Amazon GameLift endpoints and quotas]: https://docs.aws.amazon.com/general/latest/gr/gamelift.html
	//
	// This member is required.
	ImageUri *string

	// Establishes dependencies between this container and the status of other
	// containers in the same container group. A container can have dependencies on
	// multiple different containers.
	//
	// .
	//
	// You can use dependencies to establish a startup/shutdown sequence across the
	// container group. For example, you might specify that ContainerB has a START
	// dependency on ContainerA. This dependency means that ContainerB can't start
	// until after ContainerA has started. This dependency is reversed on shutdown,
	// which means that ContainerB must shut down before ContainerA can shut down.
	DependsOn []ContainerDependency

	// A set of environment variables to pass to the container on startup. See the [ContainerDefinition::environment]
	// parameter in the Amazon Elastic Container Service API Reference.
	//
	// [ContainerDefinition::environment]: https://docs.aws.amazon.com/AmazonECS/latest/APIReference/API_ContainerDefinition.html#ECS-Type-ContainerDefinition-environment
	EnvironmentOverride []ContainerEnvironment

	// Flags the container as vital for the container group to function properly. If
	// an essential container fails, the entire container group restarts. At least one
	// support container in a per-instance container group must be essential. When
	// flagging a container as essential, also configure a health check so that the
	// container can signal that it's healthy.
	Essential *bool

	// Configuration for a non-terminal health check. A container automatically
	// restarts if it stops functioning. With a health check, you can define additional
	// reasons to flag a container as unhealthy and restart it. If an essential
	// container fails a health check, the entire container group restarts.
	HealthCheck *ContainerHealthCheck

	// A specified amount of memory (in MiB) to reserve for this container. If you
	// don't specify a container-specific memory limit, the container shares the
	// container group's total memory allocation.
	//
	// Related data type: ContainerGroupDefinition TotalMemoryLimitMebibytes
	MemoryHardLimitMebibytes *int32

	// A mount point that binds a path inside the container to a file or directory on
	// the host system and lets it access the file or directory.
	MountPoints []ContainerMountPoint

	// A set of ports that Amazon GameLift can assign to processes in the container.
	// Any processes that accept inbound traffic connections must be assigned a port
	// from this set. The container port range must be large enough to assign one to
	// each process in the container that needs one.
	//
	// Container ports aren't directly accessed by inbound traffic. Amazon GameLift
	// maps these container ports to externally accessible connection ports, which are
	// assigned as needed from the container fleet's ConnectionPortRange .
	PortConfiguration *ContainerPortConfiguration

	// The number of vCPU units to reserve for this container. The container can use
	// more resources when needed, if available. If you don't reserve CPU units for
	// this container, it shares the container group's total vCPU limit.
	//
	// Related data type: ContainerGroupDefinition TotalCpuLimit
	Vcpu *float64
	// contains filtered or unexported fields
}

Describes a support container in a container group. You can define a support container in either a game server container group or a per-instance container group. Support containers don't run game server processes.

This definition includes container configuration, resources, and start instructions. Use this data type when creating or updating a container group definition. For properties of a deployed support container, see SupportContainerDefinition.

Use with: CreateContainerGroupDefinition, UpdateContainerGroupDefinition

type Tag 

type Tag struct {

	// The key for a developer-defined key value pair for tagging an Amazon Web
	// Services resource.
	//
	// This member is required.
	Key *string

	// The value for a developer-defined key value pair for tagging an Amazon Web
	// Services resource.
	//
	// This member is required.
	Value *string
	// contains filtered or unexported fields
}

A label that you can assign to a Amazon GameLift resource.

Learn more

Tagging Amazon Web Services Resourcesin the Amazon Web Services General Reference

Amazon Web Services Tagging Strategies

All APIs by task

type TaggingFailedException 

type TaggingFailedException struct {
	Message *string

	ErrorCodeOverride *string
	// contains filtered or unexported fields
}

The requested tagging operation did not succeed. This may be due to invalid tag format or the maximum tag limit may have been exceeded. Resolve the issue before retrying.

func (*TaggingFailedException) Error 

func (e *TaggingFailedException) Error() string

func (*TaggingFailedException) ErrorCode 

func (e *TaggingFailedException) ErrorCode() string

func (*TaggingFailedException) ErrorFault 

func (e *TaggingFailedException) ErrorFault() smithy.ErrorFault

func (*TaggingFailedException) ErrorMessage 

func (e *TaggingFailedException) ErrorMessage() string

type TargetConfiguration 

type TargetConfiguration struct {

	// Desired value to use with a target-based scaling policy. The value must be
	// relevant for whatever metric the scaling policy is using. For example, in a
	// policy using the metric PercentAvailableGameSessions, the target value should be
	// the preferred size of the fleet's buffer (the percent of capacity that should be
	// idle and ready for new game sessions).
	//
	// This member is required.
	TargetValue *float64
	// contains filtered or unexported fields
}

Settings for a target-based scaling policy. A target-based policy tracks a particular fleet metric specifies a target value for the metric. As player usage changes, the policy triggers Amazon GameLift to adjust capacity so that the metric returns to the target value. The target configuration specifies settings as needed for the target based policy, including the target value.

type TargetTrackingConfiguration 

type TargetTrackingConfiguration struct {

	// Desired value to use with a game server group target-based scaling policy.
	//
	// This member is required.
	TargetValue *float64
	// contains filtered or unexported fields
}
This data type is used with the Amazon GameLift FleetIQ and game server

groups.

Settings for a target-based scaling policy as part of a GameServerGroupAutoScalingPolicy . These settings are used to create a target-based policy that tracks the Amazon GameLift FleetIQ metric "PercentUtilizedGameServers" and specifies a target value for the metric. As player usage changes, the policy triggers to adjust the game server group capacity so that the metric returns to the target value.

type TerminalRoutingStrategyException 

type TerminalRoutingStrategyException struct {
	Message *string

	ErrorCodeOverride *string
	// contains filtered or unexported fields
}

The service is unable to resolve the routing for a particular alias because it has a terminal RoutingStrategy associated with it. The message returned in this exception is the message defined in the routing strategy itself. Such requests should only be retried if the routing strategy for the specified alias is modified.

func (*TerminalRoutingStrategyException) Error 

func (e *TerminalRoutingStrategyException) Error() string

func (*TerminalRoutingStrategyException) ErrorCode 

func (e *TerminalRoutingStrategyException) ErrorCode() string

func (*TerminalRoutingStrategyException) ErrorFault 

func (e *TerminalRoutingStrategyException) ErrorFault() smithy.ErrorFault

func (*TerminalRoutingStrategyException) ErrorMessage 

func (e *TerminalRoutingStrategyException) ErrorMessage() string

type UnauthorizedException 

type UnauthorizedException struct {
	Message *string

	ErrorCodeOverride *string
	// contains filtered or unexported fields
}

The client failed authentication. Clients should not retry such requests.

func (*UnauthorizedException) Error 

func (e *UnauthorizedException) Error() string

func (*UnauthorizedException) ErrorCode 

func (e *UnauthorizedException) ErrorCode() string

func (*UnauthorizedException) ErrorFault 

func (e *UnauthorizedException) ErrorFault() smithy.ErrorFault

func (*UnauthorizedException) ErrorMessage 

func (e *UnauthorizedException) ErrorMessage() string

type UnsupportedRegionException 

type UnsupportedRegionException struct {
	Message *string

	ErrorCodeOverride *string
	// contains filtered or unexported fields
}

The requested operation is not supported in the Region specified.

func (*UnsupportedRegionException) Error 

func (e *UnsupportedRegionException) Error() string

func (*UnsupportedRegionException) ErrorCode 

func (e *UnsupportedRegionException) ErrorCode() string

func (*UnsupportedRegionException) ErrorFault 

func (e *UnsupportedRegionException) ErrorFault() smithy.ErrorFault

func (*UnsupportedRegionException) ErrorMessage 

func (e *UnsupportedRegionException) ErrorMessage() string

type VpcPeeringAuthorization 

type VpcPeeringAuthorization struct {

	// Time stamp indicating when this authorization was issued. Format is a number
	// expressed in Unix time as milliseconds (for example "1469498468.057" ).
	CreationTime *time.Time

	// Time stamp indicating when this authorization expires (24 hours after
	// issuance). Format is a number expressed in Unix time as milliseconds (for
	// example "1469498468.057" ).
	ExpirationTime *time.Time

	// A unique identifier for the Amazon Web Services account that you use to manage
	// your Amazon GameLift fleet. You can find your Account ID in the Amazon Web
	// Services Management Console under account settings.
	GameLiftAwsAccountId *string

	// The authorization's peer VPC Amazon Web Services account ID.
	PeerVpcAwsAccountId *string

	// A unique identifier for a VPC with resources to be accessed by your Amazon
	// GameLift fleet. The VPC must be in the same Region as your fleet. To look up a
	// VPC ID, use the [VPC Dashboard]in the Amazon Web Services Management Console. Learn more about
	// VPC peering in [VPC Peering with Amazon GameLift Fleets].
	//
	// [VPC Dashboard]: https://console.aws.amazon.com/vpc/
	// [VPC Peering with Amazon GameLift Fleets]: https://docs.aws.amazon.com/gamelift/latest/developerguide/vpc-peering.html
	PeerVpcId *string
	// contains filtered or unexported fields
}

Represents an authorization for a VPC peering connection between the VPC for an Amazon GameLift fleet and another VPC on an account you have access to. This authorization must exist and be valid for the peering connection to be established. Authorizations are valid for 24 hours after they are issued.

All APIs by task

type VpcPeeringConnection 

type VpcPeeringConnection struct {

	// The Amazon Resource Name ([ARN] ) associated with the GameLift fleet resource for
	// this connection.
	//
	// [ARN]: https://docs.aws.amazon.com/AmazonS3/latest/dev/s3-arn-format.html
	FleetArn *string

	// A unique identifier for the fleet. This ID determines the ID of the Amazon
	// GameLift VPC for your fleet.
	FleetId *string

	// A unique identifier for the VPC that contains the Amazon GameLift fleet for
	// this connection. This VPC is managed by Amazon GameLift and does not appear in
	// your Amazon Web Services account.
	GameLiftVpcId *string

	// CIDR block of IPv4 addresses assigned to the VPC peering connection for the
	// GameLift VPC. The peered VPC also has an IPv4 CIDR block associated with it;
	// these blocks cannot overlap or the peering connection cannot be created.
	IpV4CidrBlock *string

	// A unique identifier for a VPC with resources to be accessed by your Amazon
	// GameLift fleet. The VPC must be in the same Region as your fleet. To look up a
	// VPC ID, use the [VPC Dashboard]in the Amazon Web Services Management Console. Learn more about
	// VPC peering in [VPC Peering with Amazon GameLift Fleets].
	//
	// [VPC Dashboard]: https://console.aws.amazon.com/vpc/
	// [VPC Peering with Amazon GameLift Fleets]: https://docs.aws.amazon.com/gamelift/latest/developerguide/vpc-peering.html
	PeerVpcId *string

	// The status information about the connection. Status indicates if a connection
	// is pending, successful, or failed.
	Status *VpcPeeringConnectionStatus

	// A unique identifier that is automatically assigned to the connection record.
	// This ID is referenced in VPC peering connection events, and is used when
	// deleting a connection.
	VpcPeeringConnectionId *string
	// contains filtered or unexported fields
}

Represents a peering connection between a VPC on one of your Amazon Web Services accounts and the VPC for your Amazon GameLift fleets. This record may be for an active peering connection or a pending connection that has not yet been established.

All APIs by task

type VpcPeeringConnectionStatus 

type VpcPeeringConnectionStatus struct {

	// Code indicating the status of a VPC peering connection.
	Code *string

	// Additional messaging associated with the connection status.
	Message *string
	// contains filtered or unexported fields
}

Represents status information for a VPC peering connection. Status codes and messages are provided from EC2 (see VpcPeeringConnectionStateReason). Connection status information is also communicated as a fleet event.

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.