@aws-cdk/aws-gamelift-alpha 2.49.1-alpha.0 → 2.51.0-alpha.0

package/.warnings.jsii.js

@@ -50,6 +50,160 @@ function _aws_cdk_aws_gamelift_alpha_ScriptProps(p) {
 }
 function _aws_cdk_aws_gamelift_alpha_Script(p) {
 }
+function _aws_cdk_aws_gamelift_alpha_AutoScalingPolicy(p) {
+}
+function _aws_cdk_aws_gamelift_alpha_InstanceDefinition(p) {
+}
+function _aws_cdk_aws_gamelift_alpha_DeleteOption(p) {
+}
+function _aws_cdk_aws_gamelift_alpha_BalancingStrategy(p) {
+}
+function _aws_cdk_aws_gamelift_alpha_IGameServerGroup(p) {
+}
+function _aws_cdk_aws_gamelift_alpha_GameServerGroupBase(p) {
+}
+function _aws_cdk_aws_gamelift_alpha_GameServerGroupAttributes(p) {
+}
+function _aws_cdk_aws_gamelift_alpha_GameServerGroupProps(p) {
+    if (p == null)
+        return;
+    visitedObjects.add(p);
+    try {
+        if (p.instanceDefinitions != null)
+            for (const o of p.instanceDefinitions)
+                if (!visitedObjects.has(o))
+                    _aws_cdk_aws_gamelift_alpha_InstanceDefinition(o);
+        if (!visitedObjects.has(p.autoScalingPolicy))
+            _aws_cdk_aws_gamelift_alpha_AutoScalingPolicy(p.autoScalingPolicy);
+        if (!visitedObjects.has(p.balancingStrategy))
+            _aws_cdk_aws_gamelift_alpha_BalancingStrategy(p.balancingStrategy);
+        if (!visitedObjects.has(p.deleteOption))
+            _aws_cdk_aws_gamelift_alpha_DeleteOption(p.deleteOption);
+    }
+    finally {
+        visitedObjects.delete(p);
+    }
+}
+function _aws_cdk_aws_gamelift_alpha_GameServerGroup(p) {
+}
+function _aws_cdk_aws_gamelift_alpha_Protocol(p) {
+}
+function _aws_cdk_aws_gamelift_alpha_PortProps(p) {
+    if (p == null)
+        return;
+    visitedObjects.add(p);
+    try {
+        if (!visitedObjects.has(p.protocol))
+            _aws_cdk_aws_gamelift_alpha_Protocol(p.protocol);
+    }
+    finally {
+        visitedObjects.delete(p);
+    }
+}
+function _aws_cdk_aws_gamelift_alpha_Port(p) {
+}
+function _aws_cdk_aws_gamelift_alpha_IPeer(p) {
+}
+function _aws_cdk_aws_gamelift_alpha_Peer(p) {
+}
+function _aws_cdk_aws_gamelift_alpha_IngressRule(p) {
+    if (p == null)
+        return;
+    visitedObjects.add(p);
+    try {
+        if (!visitedObjects.has(p.port))
+            _aws_cdk_aws_gamelift_alpha_Port(p.port);
+        if (!visitedObjects.has(p.source))
+            _aws_cdk_aws_gamelift_alpha_IPeer(p.source);
+    }
+    finally {
+        visitedObjects.delete(p);
+    }
+}
+function _aws_cdk_aws_gamelift_alpha_LocationCapacity(p) {
+}
+function _aws_cdk_aws_gamelift_alpha_Location(p) {
+    if (p == null)
+        return;
+    visitedObjects.add(p);
+    try {
+        if (!visitedObjects.has(p.capacity))
+            _aws_cdk_aws_gamelift_alpha_LocationCapacity(p.capacity);
+    }
+    finally {
+        visitedObjects.delete(p);
+    }
+}
+function _aws_cdk_aws_gamelift_alpha_ServerProcess(p) {
+}
+function _aws_cdk_aws_gamelift_alpha_RuntimeConfiguration(p) {
+    if (p == null)
+        return;
+    visitedObjects.add(p);
+    try {
+        if (p.serverProcesses != null)
+            for (const o of p.serverProcesses)
+                if (!visitedObjects.has(o))
+                    _aws_cdk_aws_gamelift_alpha_ServerProcess(o);
+    }
+    finally {
+        visitedObjects.delete(p);
+    }
+}
+function _aws_cdk_aws_gamelift_alpha_ResourceCreationLimitPolicy(p) {
+}
+function _aws_cdk_aws_gamelift_alpha_IFleet(p) {
+}
+function _aws_cdk_aws_gamelift_alpha_FleetProps(p) {
+    if (p == null)
+        return;
+    visitedObjects.add(p);
+    try {
+        if (!visitedObjects.has(p.runtimeConfiguration))
+            _aws_cdk_aws_gamelift_alpha_RuntimeConfiguration(p.runtimeConfiguration);
+        if (p.locations != null)
+            for (const o of p.locations)
+                if (!visitedObjects.has(o))
+                    _aws_cdk_aws_gamelift_alpha_Location(o);
+        if (!visitedObjects.has(p.resourceCreationLimitPolicy))
+            _aws_cdk_aws_gamelift_alpha_ResourceCreationLimitPolicy(p.resourceCreationLimitPolicy);
+    }
+    finally {
+        visitedObjects.delete(p);
+    }
+}
+function _aws_cdk_aws_gamelift_alpha_FleetAttributes(p) {
+}
+function _aws_cdk_aws_gamelift_alpha_FleetBase(p) {
+}
+function _aws_cdk_aws_gamelift_alpha_IBuildFleet(p) {
+}
+function _aws_cdk_aws_gamelift_alpha_BuildFleetProps(p) {
+    if (p == null)
+        return;
+    visitedObjects.add(p);
+    try {
+        if (!visitedObjects.has(p.content))
+            _aws_cdk_aws_gamelift_alpha_IBuild(p.content);
+        if (p.ingressRules != null)
+            for (const o of p.ingressRules)
+                if (!visitedObjects.has(o))
+                    _aws_cdk_aws_gamelift_alpha_IngressRule(o);
+        if (!visitedObjects.has(p.runtimeConfiguration))
+            _aws_cdk_aws_gamelift_alpha_RuntimeConfiguration(p.runtimeConfiguration);
+        if (p.locations != null)
+            for (const o of p.locations)
+                if (!visitedObjects.has(o))
+                    _aws_cdk_aws_gamelift_alpha_Location(o);
+        if (!visitedObjects.has(p.resourceCreationLimitPolicy))
+            _aws_cdk_aws_gamelift_alpha_ResourceCreationLimitPolicy(p.resourceCreationLimitPolicy);
+    }
+    finally {
+        visitedObjects.delete(p);
+    }
+}
+function _aws_cdk_aws_gamelift_alpha_BuildFleet(p) {
+}
 function print(name, deprecationMessage) {
     const deprecated = process.env.JSII_DEPRECATED;
     const deprecationMode = ["warn", "fail", "quiet"].includes(deprecated) ? deprecated : "warn";
@@ -86,4 +240,4 @@ class DeprecationError extends Error {
         });
     }
 }
-module.exports = { print, getPropertyDescriptor, DeprecationError, _aws_cdk_aws_gamelift_alpha_Content, _aws_cdk_aws_gamelift_alpha_ContentConfig, _aws_cdk_aws_gamelift_alpha_S3Content, _aws_cdk_aws_gamelift_alpha_AssetContent, _aws_cdk_aws_gamelift_alpha_IBuild, _aws_cdk_aws_gamelift_alpha_BuildBase, _aws_cdk_aws_gamelift_alpha_OperatingSystem, _aws_cdk_aws_gamelift_alpha_BuildAttributes, _aws_cdk_aws_gamelift_alpha_BuildProps, _aws_cdk_aws_gamelift_alpha_Build, _aws_cdk_aws_gamelift_alpha_IScript, _aws_cdk_aws_gamelift_alpha_ScriptBase, _aws_cdk_aws_gamelift_alpha_ScriptAttributes, _aws_cdk_aws_gamelift_alpha_ScriptProps, _aws_cdk_aws_gamelift_alpha_Script };
+module.exports = { print, getPropertyDescriptor, DeprecationError, _aws_cdk_aws_gamelift_alpha_Content, _aws_cdk_aws_gamelift_alpha_ContentConfig, _aws_cdk_aws_gamelift_alpha_S3Content, _aws_cdk_aws_gamelift_alpha_AssetContent, _aws_cdk_aws_gamelift_alpha_IBuild, _aws_cdk_aws_gamelift_alpha_BuildBase, _aws_cdk_aws_gamelift_alpha_OperatingSystem, _aws_cdk_aws_gamelift_alpha_BuildAttributes, _aws_cdk_aws_gamelift_alpha_BuildProps, _aws_cdk_aws_gamelift_alpha_Build, _aws_cdk_aws_gamelift_alpha_IScript, _aws_cdk_aws_gamelift_alpha_ScriptBase, _aws_cdk_aws_gamelift_alpha_ScriptAttributes, _aws_cdk_aws_gamelift_alpha_ScriptProps, _aws_cdk_aws_gamelift_alpha_Script, _aws_cdk_aws_gamelift_alpha_AutoScalingPolicy, _aws_cdk_aws_gamelift_alpha_InstanceDefinition, _aws_cdk_aws_gamelift_alpha_DeleteOption, _aws_cdk_aws_gamelift_alpha_BalancingStrategy, _aws_cdk_aws_gamelift_alpha_IGameServerGroup, _aws_cdk_aws_gamelift_alpha_GameServerGroupBase, _aws_cdk_aws_gamelift_alpha_GameServerGroupAttributes, _aws_cdk_aws_gamelift_alpha_GameServerGroupProps, _aws_cdk_aws_gamelift_alpha_GameServerGroup, _aws_cdk_aws_gamelift_alpha_Protocol, _aws_cdk_aws_gamelift_alpha_PortProps, _aws_cdk_aws_gamelift_alpha_Port, _aws_cdk_aws_gamelift_alpha_IPeer, _aws_cdk_aws_gamelift_alpha_Peer, _aws_cdk_aws_gamelift_alpha_IngressRule, _aws_cdk_aws_gamelift_alpha_LocationCapacity, _aws_cdk_aws_gamelift_alpha_Location, _aws_cdk_aws_gamelift_alpha_ServerProcess, _aws_cdk_aws_gamelift_alpha_RuntimeConfiguration, _aws_cdk_aws_gamelift_alpha_ResourceCreationLimitPolicy, _aws_cdk_aws_gamelift_alpha_IFleet, _aws_cdk_aws_gamelift_alpha_FleetProps, _aws_cdk_aws_gamelift_alpha_FleetAttributes, _aws_cdk_aws_gamelift_alpha_FleetBase, _aws_cdk_aws_gamelift_alpha_IBuildFleet, _aws_cdk_aws_gamelift_alpha_BuildFleetProps, _aws_cdk_aws_gamelift_alpha_BuildFleet };

package/README.md

@@ -46,13 +46,6 @@ configuration or game server fleet management system.
 
 ## GameLift Hosting
 
-### Defining a GameLift Fleet
-
-GameLift helps you deploy, operate, and scale dedicated game servers for
-session-based multiplayer games. It helps you regulate the resources needed to
-host your games, finds available game servers to host new game sessions, and
-puts players into games.
-
 ### Uploading builds and scripts to GameLift
 
 Before deploying your GameLift-enabled multiplayer game servers for hosting with the GameLift service, you need to upload
@@ -103,3 +96,420 @@ new gamelift.Script(this, 'Script', {
   content: gamelift.Content.fromBucket(bucket, "sample-asset-key")
 });
 ```
+
+### Defining a GameLift Fleet
+
+#### Creating a custom game server fleet
+
+Your uploaded game servers are hosted on GameLift virtual computing resources,
+called instances. You set up your hosting resources by creating a fleet of
+instances and deploying them to run your game servers. You can design a fleet
+to fit your game's needs.
+
+```ts
+new gamelift.BuildFleet(this, 'Game server fleet', {
+  fleetName: 'test-fleet',
+  content: gamelift.Build.fromAsset(this, 'Build', path.join(__dirname, 'CustomerGameServer')),
+  instanceType: ec2.InstanceType.of(ec2.InstanceClass.C4, ec2.InstanceSize.LARGE),
+  runtimeConfiguration: {
+    serverProcesses: [{
+      launchPath: 'test-launch-path',
+    }],
+  },
+});
+```
+
+### Managing game servers launch configuration
+
+GameLift uses a fleet's runtime configuration to determine the type and number
+of processes to run on each instance in the fleet. At a minimum, a runtime
+configuration contains one server process configuration that represents one
+game server executable. You can also define additional server process
+configurations to run other types of processes related to your game. Each
+server process configuration contains the following information:
+
+* The file name and path of an executable in your game build.
+
+* Optionally Parameters to pass to the process on launch.
+
+* The number of processes to run concurrently.
+
+A GameLift instance is limited to 50 processes running concurrently.
+
+```ts
+declare const build: gamelift.Build;
+// Server processes can be delcared in a declarative way through the constructor
+const fleet = new gamelift.BuildFleet(this, 'Game server fleet', {
+  fleetName: 'test-fleet',
+  content: build,
+  instanceType: ec2.InstanceType.of(ec2.InstanceClass.C4, ec2.InstanceSize.LARGE),
+  runtimeConfiguration: {
+    serverProcesses: [{
+      launchPath: '/local/game/GameLiftExampleServer.x86_64',
+      parameters: '-logFile /local/game/logs/myserver1935.log -port 1935',
+      concurrentExecutions: 100,
+    }]
+  }
+});
+```
+
+See [Managing how game servers are launched for hosting](https://docs.aws.amazon.com/gamelift/latest/developerguide/fleets-multiprocess.html)
+in the *Amazon GameLift Developer Guide*.
+
+### Defining an instance type
+
+GameLift uses Amazon Elastic Compute Cloud (Amazon EC2) resources, called
+instances, to deploy your game servers and host game sessions for your players.
+When setting up a new fleet, you decide what type of instances your game needs
+and how to run game server processes on them (using a runtime configuration). All instances in a fleet use the same type of resources and the same runtime
+configuration. You can edit a fleet's runtime configuration and other fleet
+properties, but the type of resources cannot be changed.
+
+```ts
+declare const build: gamelift.Build;
+new gamelift.BuildFleet(this, 'Game server fleet', {
+  fleetName: 'test-fleet',
+  content: build,
+  instanceType: ec2.InstanceType.of(ec2.InstanceClass.C5, ec2.InstanceSize.LARGE),
+  runtimeConfiguration: {
+    serverProcesses: [{
+      launchPath: '/local/game/GameLiftExampleServer.x86_64',
+    }]
+  }
+});
+```
+
+### Using Spot instances
+
+When setting up your hosting resources, you have the option of using Spot
+Instances, On-Demand Instances, or a combination.
+
+By default, fleet are using on demand capacity.
+
+```ts
+declare const build: gamelift.Build;
+new gamelift.BuildFleet(this, 'Game server fleet', {
+  fleetName: 'test-fleet',
+  content: build,
+  instanceType: ec2.InstanceType.of(ec2.InstanceClass.C4, ec2.InstanceSize.LARGE),
+  runtimeConfiguration: {
+    serverProcesses: [{
+      launchPath: '/local/game/GameLiftExampleServer.x86_64',
+    }]
+  },
+  useSpot: true
+});
+```
+
+### Allowing Ingress traffic
+
+The allowed IP address ranges and port settings that allow inbound traffic to
+access game sessions on this fleet.
+
+New game sessions are assigned an IP address/port number combination, which
+must fall into the fleet's allowed ranges. Fleets with custom game builds must
+have permissions explicitly set. For Realtime Servers fleets, GameLift
+automatically opens two port ranges, one for TCP messaging and one for UDP.
+
+```ts
+declare const build: gamelift.Build;
+
+const fleet = new gamelift.BuildFleet(this, 'Game server fleet', {
+  fleetName: 'test-fleet',
+  content: build,
+  instanceType: ec2.InstanceType.of(ec2.InstanceClass.C4, ec2.InstanceSize.LARGE),
+  runtimeConfiguration: {
+    serverProcesses: [{
+      launchPath: '/local/game/GameLiftExampleServer.x86_64',
+    }]
+  },
+  ingressRules: [{
+    source: gamelift.Peer.anyIpv4(),
+    port: gamelift.Port.tcpRange(100, 200),
+  }]
+});
+// Allowing a specific CIDR for port 1111 on UDP Protocol
+fleet.addIngressRule(gamelift.Peer.ipv4('1.2.3.4/32'), gamelift.Port.udp(1111));
+```
+
+### Managing locations
+
+A single Amazon GameLift fleet has a home Region by default (the Region you
+deploy it to), but it can deploy resources to any number of GameLift supported
+Regions. Select Regions based on where your players are located and your
+latency needs.
+
+By default, home region is used as default location but we can add new locations if needed and define desired capacity
+
+```ts
+declare const build: gamelift.Build;
+
+// Locations can be added directly through constructor
+const fleet = new gamelift.BuildFleet(this, 'Game server fleet', {
+  fleetName: 'test-fleet',
+  content: build,
+  instanceType: ec2.InstanceType.of(ec2.InstanceClass.C4, ec2.InstanceSize.LARGE),
+  runtimeConfiguration: {
+    serverProcesses: [{
+      launchPath: '/local/game/GameLiftExampleServer.x86_64',
+    }]
+  },
+  locations: [ {
+    region: 'eu-west-1',
+    capacity: {
+      desiredCapacity: 5,
+      minSize: 2,
+      maxSize: 10
+    }
+  }, {
+    region: 'us-east-1',
+    capacity: {
+      desiredCapacity: 5,
+      minSize: 2,
+      maxSize: 10
+    }
+  }]
+});
+
+// Or through dedicated methods
+fleet.addLocation('ap-southeast-1', 5, 2, 10);
+```
+
+### Specifying an IAM role for a Fleet
+
+Some GameLift features require you to extend limited access to your AWS
+resources. This is done by creating an AWS IAM role. The GameLift Fleet class
+automatically created an IAM role with all the minimum necessary permissions
+for GameLift to access your ressources. If you wish, you may
+specify your own IAM role.
+
+```ts
+declare const build: gamelift.Build;
+const role = new iam.Role(this, 'Role', {
+  assumedBy: new iam.CompositePrincipal(new iam.ServicePrincipal('gamelift.amazonaws.com'))
+});
+role.addManagedPolicy(iam.ManagedPolicy.fromAwsManagedPolicyName('CloudWatchAgentServerPolicy'));
+
+const fleet = new gamelift.BuildFleet(this, 'Game server fleet', {
+  fleetName: 'test-fleet',
+  content: build,
+  instanceType: ec2.InstanceType.of(ec2.InstanceClass.C5, ec2.InstanceSize.LARGE),
+  runtimeConfiguration: {
+    serverProcesses: [{
+      launchPath: '/local/game/GameLiftExampleServer.x86_64',
+    }]
+  },
+  role: role
+});
+
+// Actions can also be grantted through dedicated method
+fleet.grant(role, 'gamelift:ListFleets');
+```
+
+### Monitoring your Fleet
+
+GameLift is integrated with CloudWatch, so you can monitor the performance of
+your game servers via logs and metrics.
+
+#### Metrics
+
+GameLift Fleet sends metrics to CloudWatch so that you can collect and analyze
+the activity of your Fleet, including game  and player sessions and server
+processes.
+
+You can then use CloudWatch alarms to alert you, for example, when matches has
+been rejected (potential matches that were rejected by at least one player
+since the last report) exceed a certain thresold which could means that you may
+have an issue in your matchmaking rules.
+
+CDK provides methods for accessing GameLift Fleet metrics with default configuration,
+such as `metricActiveInstances`, or `metricIdleInstances` (see [`IFleet`](https://docs.aws.amazon.com/cdk/api/latest/docs/@aws-cdk_aws-gamelift.IFleet.html)
+for a full list). CDK also provides a generic `metric` method that can be used
+to produce metric configurations for any metric provided by GameLift Fleet,
+Game sessions or server processes; the configurations are pre-populated with
+the correct dimensions for the matchmaking configuration.
+
+```ts
+declare const fleet: gamelift.BuildFleet;
+// Alarm that triggers when the per-second average of not used instances exceed 10%
+const instancesUsedRatio = new cloudwatch.MathExpression({
+  expression: '1 - (activeInstances / idleInstances)',
+  usingMetrics: {
+    activeInstances: fleet.metric('ActiveInstances', { statistic: cloudwatch.Statistic.SUM }),
+    idleInstances: fleet.metricIdleInstances(),
+  },
+});
+new cloudwatch.Alarm(this, 'Alarm', {
+  metric: instancesUsedRatio,
+  threshold: 0.1,
+  evaluationPeriods: 3,
+});
+```
+
+See: [Monitoring Using CloudWatch Metrics](https://docs.aws.amazon.com/gamelift/latest/developerguide/monitoring-cloudwatch.html)
+in the *Amazon GameLift Developer Guide*.
+
+## GameLift FleetIQ
+
+The GameLift FleetIQ solution is a game hosting layer that supplements the full
+set of computing resource management tools that you get with Amazon EC2 and
+Auto Scaling. This solution lets you directly manage your Amazon EC2 and Auto
+Scaling resources and integrate as needed with other AWS services.
+
+### Defining a Game Server Group
+
+When using GameLift FleetIQ, you prepare to launch Amazon EC2 instances as
+usual: make an Amazon Machine Image (AMI) with your game server software,
+create an Amazon EC2 launch template, and define configuration settings for an
+Auto Scaling group. However, instead of creating an Auto Scaling group
+directly, you create a GameLift FleetIQ game server group with your Amazon EC2
+and Auto Scaling resources and configuration. All game server groups must have
+at least two instance types defined for it.
+
+Once a game server group and Auto Scaling group are up and running with
+instances deployed, when updating a Game Server Group instance, only certain
+properties in the Auto Scaling group may be overwrite. For all other Auto
+Scaling group properties, such as MinSize, MaxSize, and LaunchTemplate, you can
+modify these directly on the Auto Scaling group using the AWS Console or
+dedicated Api.
+
+```ts
+declare const launchTemplate: ec2.ILaunchTemplate;
+declare const vpc: ec2.IVpc;
+
+new gamelift.GameServerGroup(this, 'Game server group', {
+  gameServerGroupName: 'sample-gameservergroup-name',
+  instanceDefinitions: [{
+    instanceType: ec2.InstanceType.of(ec2.InstanceClass.C5, ec2.InstanceSize.LARGE),
+  },
+  {
+    instanceType: ec2.InstanceType.of(ec2.InstanceClass.C4, ec2.InstanceSize.LARGE),
+  }],
+  launchTemplate: launchTemplate,
+  vpc: vpc
+});
+```
+
+See [Manage game server groups](https://docs.aws.amazon.com/gamelift/latest/fleetiqguide/gsg-integrate-gameservergroup.html)
+in the *Amazon GameLift FleetIQ Developer Guide*.
+
+### Scaling Policy
+
+The scaling policy uses the metric `PercentUtilizedGameServers` to maintain a
+buffer of idle game servers that can immediately accommodate new games and
+players.
+
+```ts
+declare const launchTemplate: ec2.ILaunchTemplate;
+declare const vpc: ec2.IVpc;
+
+new gamelift.GameServerGroup(this, 'Game server group', {
+  gameServerGroupName: 'sample-gameservergroup-name',
+  instanceDefinitions: [{
+    instanceType: ec2.InstanceType.of(ec2.InstanceClass.C5, ec2.InstanceSize.LARGE),
+  },
+  {
+    instanceType: ec2.InstanceType.of(ec2.InstanceClass.C4, ec2.InstanceSize.LARGE),
+  }],
+  launchTemplate: launchTemplate,
+  vpc: vpc,
+  autoScalingPolicy: {
+    estimatedInstanceWarmup: Duration.minutes(5),
+    targetTrackingConfiguration: 5
+  }
+});
+```
+
+See [Manage game server groups](https://docs.aws.amazon.com/gamelift/latest/fleetiqguide/gsg-integrate-gameservergroup.html)
+in the *Amazon GameLift FleetIQ Developer Guide*.
+
+### Specifying an IAM role for GameLift
+
+The GameLift FleetIQ class automatically creates an IAM role with all the minimum necessary
+permissions for GameLift to access your Amazon EC2 Auto Scaling groups. If you wish, you may
+specify your own IAM role. It must have the correct permissions, or FleetIQ creation or ressource usage may fail.
+
+```ts
+declare const launchTemplate: ec2.ILaunchTemplate;
+declare const vpc: ec2.IVpc;
+
+const role = new iam.Role(this, 'Role', {
+  assumedBy: new iam.CompositePrincipal(new iam.ServicePrincipal('gamelift.amazonaws.com'),
+  new iam.ServicePrincipal('autoscaling.amazonaws.com'))
+});
+role.addManagedPolicy(iam.ManagedPolicy.fromAwsManagedPolicyName('GameLiftGameServerGroupPolicy'));
+
+new gamelift.GameServerGroup(this, 'Game server group', {
+  gameServerGroupName: 'sample-gameservergroup-name',
+  instanceDefinitions: [{
+    instanceType: ec2.InstanceType.of(ec2.InstanceClass.C5, ec2.InstanceSize.LARGE),
+  },
+  {
+    instanceType: ec2.InstanceType.of(ec2.InstanceClass.C4, ec2.InstanceSize.LARGE),
+  }],
+  launchTemplate: launchTemplate,
+  vpc: vpc,
+  role: role
+});
+```
+
+See [Controlling Access](https://docs.aws.amazon.com/gamelift/latest/fleetiqguide/gsg-iam-permissions-roles.html)
+in the *Amazon GameLift FleetIQ Developer Guide*.
+
+### Specifying VPC Subnets
+
+GameLift FleetIQ use by default, all supported GameLift FleetIQ Availability
+Zones in your chosen region. You can override this parameter to specify VPCs
+subnets that you've set up.
+
+This property cannot be updated after the game server group is created, and the
+corresponding Auto Scaling group will always use the property value that is set
+with this request, even if the Auto Scaling group is updated directly.
+
+```ts
+declare const launchTemplate: ec2.ILaunchTemplate;
+declare const vpc: ec2.IVpc;
+
+new gamelift.GameServerGroup(this, 'GameServerGroup', {
+  gameServerGroupName: 'sample-gameservergroup-name',
+  instanceDefinitions: [{
+    instanceType: ec2.InstanceType.of(ec2.InstanceClass.C5, ec2.InstanceSize.LARGE),
+  },
+  {
+    instanceType: ec2.InstanceType.of(ec2.InstanceClass.C4, ec2.InstanceSize.LARGE),
+  }],
+  launchTemplate: launchTemplate,
+  vpc: vpc,
+  vpcSubnets: { subnetType: ec2.SubnetType.PUBLIC }
+});
+```
+
+### Monitoring
+
+GameLift FleetIQ sends metrics to CloudWatch so that you can collect and
+analyze the activity of your Game server fleet, including the number of
+utilized game servers, and the number of game server interruption due to
+limited Spot availability.
+
+You can then use CloudWatch alarms to alert you, for example, when the portion
+of game servers that are currently supporting game executions exceed a certain
+thresold which could means that your autoscaling policy need to be adjust to
+add more instances to match with player demand.
+
+CDK provides a generic `metric` method that can be used
+to produce metric configurations for any metric provided by GameLift FleetIQ;
+the configurations are pre-populated with the correct dimensions for the
+matchmaking configuration.
+
+```ts
+declare const gameServerGroup: gamelift.IGameServerGroup;
+// Alarm that triggers when the percent of utilized game servers exceed 90%
+new cloudwatch.Alarm(this, 'Alarm', {
+  metric: gameServerGroup.metric('UtilizedGameServers'),
+  threshold: 0.9,
+  evaluationPeriods: 2,
+});
+```
+
+See: [Monitoring with CloudWatch](https://docs.aws.amazon.com/gamelift/latest/fleetiqguide/gsg-metrics.html)
+in the *Amazon GameLift FleetIQ Developer Guide*.

package/lib/build-fleet.d.ts

@@ -0,0 +1,81 @@
+import * as iam from 'aws-cdk-lib/aws-iam';
+import { Construct } from 'constructs';
+import { IBuild } from './build';
+import { FleetBase, FleetProps, IFleet } from './fleet-base';
+import { Port, IPeer, IngressRule } from './ingress-rule';
+/**
+ * Represents a GameLift Fleet used to run a custom game build.
+ */
+export interface IBuildFleet extends IFleet {
+}
+/**
+ * Properties for a new Gamelift build fleet
+ */
+export interface BuildFleetProps extends FleetProps {
+    /**
+       * A build to be deployed on the fleet.
+       * The build must have been successfully uploaded to Amazon GameLift and be in a `READY` status.
+       *
+       * This fleet setting cannot be changed once the fleet is created.
+       */
+    readonly content: IBuild;
+    /**
+     * The allowed IP address ranges and port settings that allow inbound traffic to access game sessions on this fleet.
+     *
+     * This property must be set before players can connect to game sessions.
+     *
+     * @default no inbound traffic allowed
+     */
+    readonly ingressRules?: IngressRule[];
+}
+/**
+ * A fleet contains Amazon Elastic Compute Cloud (Amazon EC2) instances that GameLift hosts.
+ * A fleet uses the configuration and scaling logic that you define to run your game server build. You can use a fleet directly without a queue.
+ * You can also associate multiple fleets with a GameLift queue.
+ *
+ * For example, you can use Spot Instance fleets configured with your preferred locations, along with a backup On-Demand Instance fleet with the same locations.
+ * Using multiple Spot Instance fleets of different instance types reduces the chance of needing On-Demand Instance placement.
+ *
+ * @resource AWS::GameLift::Fleet
+ */
+export declare class BuildFleet extends FleetBase implements IBuildFleet {
+    /**
+     * Import an existing fleet from its identifier.
+     */
+    static fromBuildFleetId(scope: Construct, id: string, buildFleetId: string): IBuildFleet;
+    /**
+     * Import an existing fleet from its ARN.
+     */
+    static fromBuildFleetArn(scope: Construct, id: string, buildFleetArn: string): IBuildFleet;
+    /**
+     * The Identifier of the fleet.
+     */
+    readonly fleetId: string;
+    /**
+     * The ARN of the fleet.
+     */
+    readonly fleetArn: string;
+    /**
+     * The build content of the fleet
+     */
+    readonly content: IBuild;
+    /**
+     * The IAM role GameLift assumes by fleet instances to access AWS ressources.
+     */
+    readonly role: iam.IRole;
+    /**
+     * The principal this GameLift fleet is using.
+     */
+    readonly grantPrincipal: iam.IPrincipal;
+    private readonly ingressRules;
+    constructor(scope: Construct, id: string, props: BuildFleetProps);
+    /**
+     * Adds an ingress rule to allow inbound traffic to access game sessions on this fleet.
+     *
+     * @param source A range of allowed IP addresses
+     * @param port The port range used for ingress traffic
+     */
+    addIngressRule(source: IPeer, port: Port): void;
+    private addInternalIngressRule;
+    private parseIngressRules;
+}