awsec2

README

Amazon EC2 Construct Library

The aws-cdk-lib/aws-ec2 package contains primitives for setting up networking and instances.

import ec2 "github.com/aws/aws-cdk-go/awscdk"

VPC

Most projects need a Virtual Private Cloud to provide security by means of network partitioning. This is achieved by creating an instance of Vpc:

vpc := ec2.NewVpc(this, jsii.String("VPC"))

All default constructs require EC2 instances to be launched inside a VPC, so you should generally start by defining a VPC whenever you need to launch instances for your project.

Subnet Types

A VPC consists of one or more subnets that instances can be placed into. CDK distinguishes three different subnet types:

• Public (SubnetType.PUBLIC) - public subnets connect directly to the Internet using an Internet Gateway. If you want your instances to have a public IP address and be directly reachable from the Internet, you must place them in a public subnet.
• Private with Internet Access (SubnetType.PRIVATE_WITH_EGRESS) - instances in private subnets are not directly routable from the Internet, and you must provide a way to connect out to the Internet. By default, a NAT gateway is created in every public subnet for maximum availability. Be aware that you will be charged for NAT gateways. Alternatively you can set natGateways:0 and provide your own egress configuration (i.e through Transit Gateway)
• Isolated (SubnetType.PRIVATE_ISOLATED) - isolated subnets do not route from or to the Internet, and as such do not require NAT gateways. They can only connect to or be connected to from other instances in the same VPC. A default VPC configuration will not include isolated subnets,

A default VPC configuration will create public and private subnets. However, if natGateways:0 and subnetConfiguration is undefined, default VPC configuration will create public and isolated subnets. See Advanced Subnet Configuration below for information on how to change the default subnet configuration.

Constructs using the VPC will "launch instances" (or more accurately, create Elastic Network Interfaces) into one or more of the subnets. They all accept a property called subnetSelection (sometimes called vpcSubnets) to allow you to select in what subnet to place the ENIs, usually defaulting to private subnets if the property is omitted.

If you would like to save on the cost of NAT gateways, you can use isolated subnets instead of private subnets (as described in Advanced Subnet Configuration). If you need private instances to have internet connectivity, another option is to reduce the number of NAT gateways created by setting the natGateways property to a lower value (the default is one NAT gateway per availability zone). Be aware that this may have availability implications for your application.

Read more about subnets.

Control over availability zones

By default, a VPC will spread over at most 3 Availability Zones available to it. To change the number of Availability Zones that the VPC will spread over, specify the maxAzs property when defining it.

The number of Availability Zones that are available depends on the region and account of the Stack containing the VPC. If the region and account are specified on the Stack, the CLI will look up the existing Availability Zones and get an accurate count. The result of this operation will be written to a file called cdk.context.json. You must commit this file to source control so that the lookup values are available in non-privileged environments such as CI build steps, and to ensure your template builds are repeatable.

If region and account are not specified, the stack could be deployed anywhere and it will have to make a safe choice, limiting itself to 2 Availability Zones.

Therefore, to get the VPC to spread over 3 or more availability zones, you must specify the environment where the stack will be deployed.

You can gain full control over the availability zones selection strategy by overriding the Stack's get availabilityZones() method:

// This example is only available in TypeScript

class MyStack extends Stack {

  constructor(scope: Construct, id: string, props?: StackProps) {
    super(scope, id, props);

    // ...
  }

  get availabilityZones(): string[] {
    return ['us-west-2a', 'us-west-2b'];
  }

}

Note that overriding the get availabilityZones() method will override the default behavior for all constructs defined within the Stack.

Choosing subnets for resources

When creating resources that create Elastic Network Interfaces (such as databases or instances), there is an option to choose which subnets to place them in. For example, a VPC endpoint by default is placed into a subnet in every availability zone, but you can override which subnets to use. The property is typically called one of subnets, vpcSubnets or subnetSelection.

The example below will place the endpoint into two AZs (us-east-1a and us-east-1c), in Isolated subnets:

var vpc vpc


ec2.NewInterfaceVpcEndpoint(this, jsii.String("VPC Endpoint"), &InterfaceVpcEndpointProps{
	Vpc: Vpc,
	Service: ec2.NewInterfaceVpcEndpointService(jsii.String("com.amazonaws.vpce.us-east-1.vpce-svc-uuddlrlrbastrtsvc"), jsii.Number(443)),
	Subnets: &SubnetSelection{
		SubnetType: ec2.SubnetType_PRIVATE_ISOLATED,
		AvailabilityZones: []*string{
			jsii.String("us-east-1a"),
			jsii.String("us-east-1c"),
		},
	},
})

You can also specify specific subnet objects for granular control:

var vpc vpc
var subnet1 subnet
var subnet2 subnet


ec2.NewInterfaceVpcEndpoint(this, jsii.String("VPC Endpoint"), &InterfaceVpcEndpointProps{
	Vpc: Vpc,
	Service: ec2.NewInterfaceVpcEndpointService(jsii.String("com.amazonaws.vpce.us-east-1.vpce-svc-uuddlrlrbastrtsvc"), jsii.Number(443)),
	Subnets: &SubnetSelection{
		Subnets: []iSubnet{
			subnet1,
			subnet2,
		},
	},
})

Which subnets are selected is evaluated as follows:

• subnets: if specific subnet objects are supplied, these are selected, and no other logic is used.

• subnetType/subnetGroupName: otherwise, a set of subnets is selected by supplying either type or name:

  • subnetType will select all subnets of the given type.
  • subnetGroupName should be used to distinguish between multiple groups of subnets of the same type (for example, you may want to separate your application instances and your RDS instances into two distinct groups of Isolated subnets).
  • If neither are given, the first available subnet group of a given type that exists in the VPC will be used, in this order: Private, then Isolated, then Public. In short: by default ENIs will preferentially be placed in subnets not connected to the Internet.

• availabilityZones/onePerAz: finally, some availability-zone based filtering may be done. This filtering by availability zones will only be possible if the VPC has been created or looked up in a non-environment agnostic stack (so account and region have been set and availability zones have been looked up).

  • availabilityZones: only the specific subnets from the selected subnet groups that are in the given availability zones will be returned.
  • onePerAz: per availability zone, a maximum of one subnet will be returned (Useful for resource types that do not allow creating two ENIs in the same availability zone).

• subnetFilters: additional filtering on subnets using any number of user-provided filters which extend SubnetFilter. The following methods on the SubnetFilter class can be used to create a filter:

  • byIds: chooses subnets from a list of ids
  • availabilityZones: chooses subnets in the provided list of availability zones
  • onePerAz: chooses at most one subnet per availability zone
  • containsIpAddresses: chooses a subnet which contains any of the listed ip addresses
  • byCidrMask: chooses subnets that have the provided CIDR netmask

Using NAT instances

By default, the Vpc construct will create NAT gateways for you, which are managed by AWS. If you would prefer to use your own managed NAT instances instead, specify a different value for the natGatewayProvider property, as follows:

// Configure the `natGatewayProvider` when defining a Vpc
natGatewayProvider := ec2.NatProvider_Instance(&NatInstanceProps{
	InstanceType: ec2.NewInstanceType(jsii.String("t3.small")),
})

vpc := ec2.NewVpc(this, jsii.String("MyVpc"), &VpcProps{
	NatGatewayProvider: NatGatewayProvider,

	// The 'natGateways' parameter now controls the number of NAT instances
	NatGateways: jsii.Number(2),
})

The construct will automatically search for the most recent NAT gateway AMI. If you prefer to use a custom AMI, use machineImage: MachineImage.genericLinux({ ... }) and configure the right AMI ID for the regions you want to deploy to.

By default, the NAT instances will route all traffic. To control what traffic gets routed, pass a custom value for defaultAllowedTraffic and access the NatInstanceProvider.connections member after having passed the NAT provider to the VPC:

var instanceType instanceType


provider := ec2.NatProvider_Instance(&NatInstanceProps{
	InstanceType: InstanceType,
	DefaultAllowedTraffic: ec2.NatTrafficDirection_OUTBOUND_ONLY,
})
ec2.NewVpc(this, jsii.String("TheVPC"), &VpcProps{
	NatGatewayProvider: provider,
})
provider.connections.AllowFrom(ec2.Peer_Ipv4(jsii.String("1.2.3.4/8")), ec2.Port_Tcp(jsii.Number(80)))

Ip Address Management

The VPC spans a supernet IP range, which contains the non-overlapping IPs of its contained subnets. Possible sources for this IP range are:

• You specify an IP range directly by specifying a CIDR
• You allocate an IP range of a given size automatically from AWS IPAM

By default the Vpc will allocate the 10.0.0.0/16 address range which will be exhaustively spread across all subnets in the subnet configuration. This behavior can be changed by passing an object that implements IIpAddresses to the ipAddress property of a Vpc. See the subsequent sections for the options.

Be aware that if you don't explicitly reserve subnet groups in subnetConfiguration, the address space will be fully allocated! If you predict you may need to add more subnet groups later, add them early on and set reserved: true (see the "Advanced Subnet Configuration" section for more information).

Specifying a CIDR directly

Use IpAddresses.cidr to define a Cidr range for your Vpc directly in code:

import "github.com/aws/aws-cdk-go/awscdk"


ec2.NewVpc(this, jsii.String("TheVPC"), &VpcProps{
	IpAddresses: awscdk.IpAddresses_Cidr(jsii.String("10.0.1.0/20")),
})

Space will be allocated to subnets in the following order:

• First, spaces is allocated for all subnets groups that explicitly have a cidrMask set as part of their configuration (including reserved subnets).
• Afterwards, any remaining space is divided evenly between the rest of the subnets (if any).

The argument to IpAddresses.cidr may not be a token, and concrete Cidr values are generated in the synthesized CloudFormation template.

Allocating an IP range from AWS IPAM

Amazon VPC IP Address Manager (IPAM) manages a large IP space, from which chunks can be allocated for use in the Vpc. For information on Amazon VPC IP Address Manager please see the official documentation. An example of allocating from AWS IPAM looks like this:

import "github.com/aws/aws-cdk-go/awscdk"

var pool cfnIPAMPool


ec2.NewVpc(this, jsii.String("TheVPC"), &VpcProps{
	IpAddresses: awscdk.IpAddresses_AwsIpamAllocation(&AwsIpamProps{
		Ipv4IpamPoolId: pool.ref,
		Ipv4NetmaskLength: jsii.Number(18),
		DefaultSubnetIpv4NetmaskLength: jsii.Number(24),
	}),
})

IpAddresses.awsIpamAllocation requires the following:

• ipv4IpamPoolId, the id of an IPAM Pool from which the VPC range should be allocated.
• ipv4NetmaskLength, the size of the IP range that will be requested from the Pool at deploy time.
• defaultSubnetIpv4NetmaskLength, the size of subnets in groups that don't have cidrMask set.

With this method of IP address management, no attempt is made to guess at subnet group sizes or to exhaustively allocate the IP range. All subnet groups must have an explicit cidrMask set as part of their subnet configuration, or defaultSubnetIpv4NetmaskLength must be set for a default size. If not, synthesis will fail and you must provide one or the other.

Reserving availability zones

There are situations where the IP space for availability zones will need to be reserved. This is useful in situations where availability zones would need to be added after the vpc is originally deployed, without causing IP renumbering for availability zones subnets. The IP space for reserving n availability zones can be done by setting the reservedAzs to n in vpc props, as shown below:

vpc := ec2.NewVpc(this, jsii.String("TheVPC"), &VpcProps{
	Cidr: jsii.String("10.0.0.0/21"),
	MaxAzs: jsii.Number(3),
	ReservedAzs: jsii.Number(1),
})

In the example above, the subnets for reserved availability zones is not actually provisioned but its IP space is still reserved. If, in the future, new availability zones needs to be provisioned, then we would decrement the value of reservedAzs and increment the maxAzs or availabilityZones accordingly. This action would not cause the IP address of subnets to get renumbered, but rather the IP space that was previously reserved will be used for the new availability zones subnets.

Advanced Subnet Configuration

If the default VPC configuration (public and private subnets spanning the size of the VPC) don't suffice for you, you can configure what subnets to create by specifying the subnetConfiguration property. It allows you to configure the number and size of all subnets. Specifying an advanced subnet configuration could look like this:

vpc := ec2.NewVpc(this, jsii.String("TheVPC"), &VpcProps{
	// 'IpAddresses' configures the IP range and size of the entire VPC.
	// The IP space will be divided based on configuration for the subnets.
	IpAddresses: ec2.IpAddresses_Cidr(jsii.String("10.0.0.0/21")),

	// 'maxAzs' configures the maximum number of availability zones to use.
	// If you want to specify the exact availability zones you want the VPC
	// to use, use `availabilityZones` instead.
	MaxAzs: jsii.Number(3),

	// 'subnetConfiguration' specifies the "subnet groups" to create.
	// Every subnet group will have a subnet for each AZ, so this
	// configuration will create `3 groups × 3 AZs = 9` subnets.
	SubnetConfiguration: []subnetConfiguration{
		&subnetConfiguration{
			// 'subnetType' controls Internet access, as described above.
			SubnetType: ec2.SubnetType_PUBLIC,

			// 'name' is used to name this particular subnet group. You will have to
			// use the name for subnet selection if you have more than one subnet
			// group of the same type.
			Name: jsii.String("Ingress"),

			// 'cidrMask' specifies the IP addresses in the range of of individual
			// subnets in the group. Each of the subnets in this group will contain
			// `2^(32 address bits - 24 subnet bits) - 2 reserved addresses = 254`
			// usable IP addresses.
			//
			// If 'cidrMask' is left out the available address space is evenly
			// divided across the remaining subnet groups.
			CidrMask: jsii.Number(24),
		},
		&subnetConfiguration{
			CidrMask: jsii.Number(24),
			Name: jsii.String("Application"),
			SubnetType: ec2.SubnetType_PRIVATE_WITH_EGRESS,
		},
		&subnetConfiguration{
			CidrMask: jsii.Number(28),
			Name: jsii.String("Database"),
			SubnetType: ec2.SubnetType_PRIVATE_ISOLATED,

			// 'reserved' can be used to reserve IP address space. No resources will
			// be created for this subnet, but the IP range will be kept available for
			// future creation of this subnet, or even for future subdivision.
			Reserved: jsii.Boolean(true),
		},
	},
})

The example above is one possible configuration, but the user can use the constructs above to implement many other network configurations.

The Vpc from the above configuration in a Region with three availability zones will be the following:

Subnet Name	Type	IP Block	AZ	Features
IngressSubnet1	PUBLIC	10.0.0.0/24	#1	NAT Gateway
IngressSubnet2	PUBLIC	10.0.1.0/24	#2	NAT Gateway
IngressSubnet3	PUBLIC	10.0.2.0/24	#3	NAT Gateway
ApplicationSubnet1	PRIVATE	10.0.3.0/24	#1	Route to NAT in IngressSubnet1
ApplicationSubnet2	PRIVATE	10.0.4.0/24	#2	Route to NAT in IngressSubnet2
ApplicationSubnet3	PRIVATE	10.0.5.0/24	#3	Route to NAT in IngressSubnet3
DatabaseSubnet1	ISOLATED	10.0.6.0/28	#1	Only routes within the VPC
DatabaseSubnet2	ISOLATED	10.0.6.16/28	#2	Only routes within the VPC
DatabaseSubnet3	ISOLATED	10.0.6.32/28	#3	Only routes within the VPC

Accessing the Internet Gateway

If you need access to the internet gateway, you can get its ID like so:

var vpc vpc


igwId := vpc.InternetGatewayId

For a VPC with only ISOLATED subnets, this value will be undefined.

This is only supported for VPCs created in the stack - currently you're unable to get the ID for imported VPCs. To do that you'd have to specifically look up the Internet Gateway by name, which would require knowing the name beforehand.

This can be useful for configuring routing using a combination of gateways: for more information see Routing below.

Disabling the creation of the default internet gateway

If you need to control the creation of the internet gateway explicitly, you can disable the creation of the default one using the createInternetGateway property:

vpc := ec2.NewVpc(this, jsii.String("VPC"), &VpcProps{
	CreateInternetGateway: jsii.Boolean(false),
	SubnetConfiguration: []subnetConfiguration{
		&subnetConfiguration{
			SubnetType: ec2.SubnetType_PUBLIC,
			Name: jsii.String("Public"),
		},
	},
})

Routing

It's possible to add routes to any subnets using the addRoute() method. If for example you want an isolated subnet to have a static route via the default Internet Gateway created for the public subnet - perhaps for routing a VPN connection - you can do so like this:

vpc := ec2.NewVpc(this, jsii.String("VPC"), &VpcProps{
	SubnetConfiguration: []subnetConfiguration{
		&subnetConfiguration{
			SubnetType: ec2.SubnetType_PUBLIC,
			Name: jsii.String("Public"),
		},
		&subnetConfiguration{
			SubnetType: ec2.SubnetType_PRIVATE_ISOLATED,
			Name: jsii.String("Isolated"),
		},
	},
})

(vpc.IsolatedSubnets[0].(subnet)).AddRoute(jsii.String("StaticRoute"), &AddRouteOptions{
	RouterId: vpc.InternetGatewayId,
	RouterType: ec2.RouterType_GATEWAY,
	DestinationCidrBlock: jsii.String("8.8.8.8/32"),
})

Note that we cast to Subnet here because the list of subnets only returns an ISubnet.

Reserving subnet IP space

There are situations where the IP space for a subnet or number of subnets will need to be reserved. This is useful in situations where subnets would need to be added after the vpc is originally deployed, without causing IP renumbering for existing subnets. The IP space for a subnet may be reserved by setting the reserved subnetConfiguration property to true, as shown below:

vpc := ec2.NewVpc(this, jsii.String("TheVPC"), &VpcProps{
	NatGateways: jsii.Number(1),
	SubnetConfiguration: []subnetConfiguration{
		&subnetConfiguration{
			CidrMask: jsii.Number(26),
			Name: jsii.String("Public"),
			SubnetType: ec2.SubnetType_PUBLIC,
		},
		&subnetConfiguration{
			CidrMask: jsii.Number(26),
			Name: jsii.String("Application1"),
			SubnetType: ec2.SubnetType_PRIVATE_WITH_EGRESS,
		},
		&subnetConfiguration{
			CidrMask: jsii.Number(26),
			Name: jsii.String("Application2"),
			SubnetType: ec2.SubnetType_PRIVATE_WITH_EGRESS,
			Reserved: jsii.Boolean(true),
		},
		&subnetConfiguration{
			CidrMask: jsii.Number(27),
			Name: jsii.String("Database"),
			SubnetType: ec2.SubnetType_PRIVATE_ISOLATED,
		},
	},
})

In the example above, the subnet for Application2 is not actually provisioned but its IP space is still reserved. If in the future this subnet needs to be provisioned, then the reserved: true property should be removed. Reserving parts of the IP space prevents the other subnets from getting renumbered.

Sharing VPCs between stacks

If you are creating multiple Stacks inside the same CDK application, you can reuse a VPC defined in one Stack in another by simply passing the VPC instance around:

/**
 * Stack1 creates the VPC
 */
type stack1 struct {
	stack
	vpc vpc
}

func newStack1(scope app, id *string, props stackProps) *stack1 {
	this := &stack1{}
	cdk.NewStack_Override(this, scope, id, props)

	this.vpc = ec2.NewVpc(this, jsii.String("VPC"))
	return this
}

type stack2Props struct {
	stackProps
	vpc *iVpc
}

/**
 * Stack2 consumes the VPC
 */
type stack2 struct {
	stack
}

func newStack2(scope app, id *string, props stack2Props) *stack2 {
	this := &stack2{}
	cdk.NewStack_Override(this, scope, id, props)

	// Pass the VPC to a construct that needs it
	// Pass the VPC to a construct that needs it
	NewConstructThatTakesAVpc(this, jsii.String("Construct"), &constructThatTakesAVpcProps{
		vpc: props.vpc,
	})
	return this
}

stack1 := NewStack1(app, jsii.String("Stack1"))
stack2 := NewStack2(app, jsii.String("Stack2"), &stack2Props{
	vpc: stack1.vpc,
})

Importing an existing VPC

If your VPC is created outside your CDK app, you can use Vpc.fromLookup(). The CDK CLI will search for the specified VPC in the the stack's region and account, and import the subnet configuration. Looking up can be done by VPC ID, but more flexibly by searching for a specific tag on the VPC.

Subnet types will be determined from the aws-cdk:subnet-type tag on the subnet if it exists, or the presence of a route to an Internet Gateway otherwise. Subnet names will be determined from the aws-cdk:subnet-name tag on the subnet if it exists, or will mirror the subnet type otherwise (i.e. a public subnet will have the name "Public").

The result of the Vpc.fromLookup() operation will be written to a file called cdk.context.json. You must commit this file to source control so that the lookup values are available in non-privileged environments such as CI build steps, and to ensure your template builds are repeatable.

Here's how Vpc.fromLookup() can be used:

vpc := ec2.Vpc_FromLookup(stack, jsii.String("VPC"), &VpcLookupOptions{
	// This imports the default VPC but you can also
	// specify a 'vpcName' or 'tags'.
	IsDefault: jsii.Boolean(true),
})

Vpc.fromLookup is the recommended way to import VPCs. If for whatever reason you do not want to use the context mechanism to look up a VPC at synthesis time, you can also use Vpc.fromVpcAttributes. This has the following limitations:

• Every subnet group in the VPC must have a subnet in each availability zone (for example, each AZ must have both a public and private subnet). Asymmetric VPCs are not supported.
• All VpcId, SubnetId, RouteTableId, ... parameters must either be known at synthesis time, or they must come from deploy-time list parameters whose deploy-time lengths are known at synthesis time.

Using Vpc.fromVpcAttributes() looks like this:

vpc := ec2.Vpc_FromVpcAttributes(this, jsii.String("VPC"), &VpcAttributes{
	VpcId: jsii.String("vpc-1234"),
	AvailabilityZones: []*string{
		jsii.String("us-east-1a"),
		jsii.String("us-east-1b"),
	},

	// Either pass literals for all IDs
	PublicSubnetIds: []*string{
		jsii.String("s-12345"),
		jsii.String("s-67890"),
	},

	// OR: import a list of known length
	PrivateSubnetIds: awscdk.Fn_ImportListValue(jsii.String("PrivateSubnetIds"), jsii.Number(2)),

	// OR: split an imported string to a list of known length
	IsolatedSubnetIds: awscdk.Fn_Split(jsii.String(","), ssm.StringParameter_ValueForStringParameter(this, jsii.String("MyParameter")), jsii.Number(2)),
})

For each subnet group the import function accepts optional parameters for subnet names, route table ids and IPv4 CIDR blocks. When supplied, the length of these lists are required to match the length of the list of subnet ids, allowing the lists to be zipped together to form ISubnet instances.

Public subnet group example (for private or isolated subnet groups, use the properties with the respective prefix):

vpc := ec2.Vpc_FromVpcAttributes(this, jsii.String("VPC"), &VpcAttributes{
	VpcId: jsii.String("vpc-1234"),
	AvailabilityZones: []*string{
		jsii.String("us-east-1a"),
		jsii.String("us-east-1b"),
		jsii.String("us-east-1c"),
	},
	PublicSubnetIds: []*string{
		jsii.String("s-12345"),
		jsii.String("s-34567"),
		jsii.String("s-56789"),
	},
	PublicSubnetNames: []*string{
		jsii.String("Subnet A"),
		jsii.String("Subnet B"),
		jsii.String("Subnet C"),
	},
	PublicSubnetRouteTableIds: []*string{
		jsii.String("rt-12345"),
		jsii.String("rt-34567"),
		jsii.String("rt-56789"),
	},
	PublicSubnetIpv4CidrBlocks: []*string{
		jsii.String("10.0.0.0/24"),
		jsii.String("10.0.1.0/24"),
		jsii.String("10.0.2.0/24"),
	},
})

The above example will create an IVpc instance with three public subnets:

| Subnet id | Availability zone | Subnet name | Route table id | IPv4 CIDR | | --------- | ----------------- | ----------- | -------------- | ----------- | | s-12345 | us-east-1a | Subnet A | rt-12345 | 10.0.0.0/24 | | s-34567 | us-east-1b | Subnet B | rt-34567 | 10.0.1.0/24 | | s-56789 | us-east-1c | Subnet B | rt-56789 | 10.0.2.0/24 |

Restricting access to the VPC default security group

AWS Security best practices recommend that the VPC default security group should not allow inbound and outbound traffic. When the @aws-cdk/aws-ec2:restrictDefaultSecurityGroup feature flag is set to true (default for new projects) this will be enabled by default. If you do not have this feature flag set you can either set the feature flag or you can set the restrictDefaultSecurityGroup property to true.

ec2.NewVpc(this, jsii.String("VPC"), &VpcProps{
	RestrictDefaultSecurityGroup: jsii.Boolean(true),
})

If you set this property to true and then later remove it or set it to false the default ingress/egress will be restored on the default security group.

Allowing Connections

In AWS, all network traffic in and out of Elastic Network Interfaces (ENIs) is controlled by Security Groups. You can think of Security Groups as a firewall with a set of rules. By default, Security Groups allow no incoming (ingress) traffic and all outgoing (egress) traffic. You can add ingress rules to them to allow incoming traffic streams. To exert fine-grained control over egress traffic, set allowAllOutbound: false on the SecurityGroup, after which you can add egress traffic rules.

You can manipulate Security Groups directly:

mySecurityGroup := ec2.NewSecurityGroup(this, jsii.String("SecurityGroup"), &SecurityGroupProps{
	Vpc: Vpc,
	Description: jsii.String("Allow ssh access to ec2 instances"),
	AllowAllOutbound: jsii.Boolean(true),
})
mySecurityGroup.AddIngressRule(ec2.Peer_AnyIpv4(), ec2.Port_Tcp(jsii.Number(22)), jsii.String("allow ssh access from the world"))

All constructs that create ENIs on your behalf (typically constructs that create EC2 instances or other VPC-connected resources) will all have security groups automatically assigned. Those constructs have an attribute called connections, which is an object that makes it convenient to update the security groups. If you want to allow connections between two constructs that have security groups, you have to add an Egress rule to one Security Group, and an Ingress rule to the other. The connections object will automatically take care of this for you:

var loadBalancer applicationLoadBalancer
var appFleet autoScalingGroup
var dbFleet autoScalingGroup


// Allow connections from anywhere
loadBalancer.Connections.AllowFromAnyIpv4(ec2.Port_Tcp(jsii.Number(443)), jsii.String("Allow inbound HTTPS"))

// The same, but an explicit IP address
loadBalancer.Connections.AllowFrom(ec2.Peer_Ipv4(jsii.String("1.2.3.4/32")), ec2.Port_Tcp(jsii.Number(443)), jsii.String("Allow inbound HTTPS"))

// Allow connection between AutoScalingGroups
appFleet.connections.AllowTo(dbFleet, ec2.Port_Tcp(jsii.Number(443)), jsii.String("App can call database"))

Connection Peers

There are various classes that implement the connection peer part:

var appFleet autoScalingGroup
var dbFleet autoScalingGroup


// Simple connection peers
peer := ec2.Peer_Ipv4(jsii.String("10.0.0.0/16"))
peer = ec2.Peer_AnyIpv4()
peer = ec2.Peer_Ipv6(jsii.String("::0/0"))
peer = ec2.Peer_AnyIpv6()
peer = ec2.Peer_PrefixList(jsii.String("pl-12345"))
appFleet.connections.AllowTo(peer, ec2.Port_Tcp(jsii.Number(443)), jsii.String("Allow outbound HTTPS"))

Any object that has a security group can itself be used as a connection peer:

var fleet1 autoScalingGroup
var fleet2 autoScalingGroup
var appFleet autoScalingGroup


// These automatically create appropriate ingress and egress rules in both security groups
fleet1.connections.AllowTo(fleet2, ec2.Port_Tcp(jsii.Number(80)), jsii.String("Allow between fleets"))

appFleet.connections.AllowFromAnyIpv4(ec2.Port_Tcp(jsii.Number(80)), jsii.String("Allow from load balancer"))

Port Ranges

The connections that are allowed are specified by port ranges. A number of classes provide the connection specifier:

ec2.Port_Tcp(jsii.Number(80))
ec2.Port_TcpRange(jsii.Number(60000), jsii.Number(65535))
ec2.Port_AllTcp()
ec2.Port_AllIcmp()
ec2.Port_AllIcmpV6()
ec2.Port_AllTraffic()

NOTE: Not all protocols have corresponding helper methods. In the absence of a helper method, you can instantiate Port yourself with your own settings. You are also welcome to contribute new helper methods.

Default Ports

Some Constructs have default ports associated with them. For example, the listener of a load balancer does (it's the public port), or instances of an RDS database (it's the port the database is accepting connections on).

If the object you're calling the peering method on has a default port associated with it, you can call allowDefaultPortFrom() and omit the port specifier. If the argument has an associated default port, call allowDefaultPortTo().

For example:

var listener applicationListener
var appFleet autoScalingGroup
var rdsDatabase databaseCluster


// Port implicit in listener
listener.Connections.AllowDefaultPortFromAnyIpv4(jsii.String("Allow public"))

// Port implicit in peer
appFleet.connections.AllowDefaultPortTo(rdsDatabase, jsii.String("Fleet can access database"))

Security group rules

By default, security group wills be added inline to the security group in the output cloud formation template, if applicable. This includes any static rules by ip address and port range. This optimization helps to minimize the size of the template.

In some environments this is not desirable, for example if your security group access is controlled via tags. You can disable inline rules per security group or globally via the context key @aws-cdk/aws-ec2.securityGroupDisableInlineRules.

mySecurityGroupWithoutInlineRules := ec2.NewSecurityGroup(this, jsii.String("SecurityGroup"), &SecurityGroupProps{
	Vpc: Vpc,
	Description: jsii.String("Allow ssh access to ec2 instances"),
	AllowAllOutbound: jsii.Boolean(true),
	DisableInlineRules: jsii.Boolean(true),
})
//This will add the rule as an external cloud formation construct
mySecurityGroupWithoutInlineRules.AddIngressRule(ec2.Peer_AnyIpv4(), ec2.Port_Tcp(jsii.Number(22)), jsii.String("allow ssh access from the world"))

Importing an existing security group

If you know the ID and the configuration of the security group to import, you can use SecurityGroup.fromSecurityGroupId:

sg := ec2.SecurityGroup_FromSecurityGroupId(this, jsii.String("SecurityGroupImport"), jsii.String("sg-1234"), &SecurityGroupImportOptions{
	AllowAllOutbound: jsii.Boolean(true),
})

Alternatively, use lookup methods to import security groups if you do not know the ID or the configuration details. Method SecurityGroup.fromLookupByName looks up a security group if the security group ID is unknown.

sg := ec2.SecurityGroup_FromLookupByName(this, jsii.String("SecurityGroupLookup"), jsii.String("security-group-name"), vpc)

If the security group ID is known and configuration details are unknown, use method SecurityGroup.fromLookupById instead. This method will lookup property allowAllOutbound from the current configuration of the security group.

sg := ec2.SecurityGroup_FromLookupById(this, jsii.String("SecurityGroupLookup"), jsii.String("sg-1234"))

The result of SecurityGroup.fromLookupByName and SecurityGroup.fromLookupById operations will be written to a file called cdk.context.json. You must commit this file to source control so that the lookup values are available in non-privileged environments such as CI build steps, and to ensure your template builds are repeatable.

Cross Stack Connections

If you are attempting to add a connection from a peer in one stack to a peer in a different stack, sometimes it is necessary to ensure that you are making the connection in a specific stack in order to avoid a cyclic reference. If there are no other dependencies between stacks then it will not matter in which stack you make the connection, but if there are existing dependencies (i.e. stack1 already depends on stack2), then it is important to make the connection in the dependent stack (i.e. stack1).

Whenever you make a connections function call, the ingress and egress security group rules will be added to the stack that the calling object exists in. So if you are doing something like peer1.connections.allowFrom(peer2), then the security group rules (both ingress and egress) will be created in peer1's Stack.

As an example, if we wanted to allow a connection from a security group in one stack (egress) to a security group in a different stack (ingress), we would make the connection like:

If Stack1 depends on Stack2

// Stack 1
var stack1 stack
var stack2 stack


sg1 := ec2.NewSecurityGroup(stack1, jsii.String("SG1"), &SecurityGroupProps{
	AllowAllOutbound: jsii.Boolean(false),
	 // if this is `true` then no egress rule will be created
	Vpc: Vpc,
})

// Stack 2
sg2 := ec2.NewSecurityGroup(stack2, jsii.String("SG2"), &SecurityGroupProps{
	AllowAllOutbound: jsii.Boolean(false),
	 // if this is `true` then no egress rule will be created
	Vpc: Vpc,
})

// `connections.allowTo` on `sg1` since we want the
// rules to be created in Stack1
sg1.connections.AllowTo(sg2, ec2.Port_Tcp(jsii.Number(3333)))

In this case both the Ingress Rule for sg2 and the Egress Rule for sg1 will both be created in Stack 1 which avoids the cyclic reference.

If Stack2 depends on Stack1

// Stack 1
var stack1 stack
var stack2 stack


sg1 := ec2.NewSecurityGroup(stack1, jsii.String("SG1"), &SecurityGroupProps{
	AllowAllOutbound: jsii.Boolean(false),
	 // if this is `true` then no egress rule will be created
	Vpc: Vpc,
})

// Stack 2
sg2 := ec2.NewSecurityGroup(stack2, jsii.String("SG2"), &SecurityGroupProps{
	AllowAllOutbound: jsii.Boolean(false),
	 // if this is `true` then no egress rule will be created
	Vpc: Vpc,
})

// `connections.allowFrom` on `sg2` since we want the
// rules to be created in Stack2
sg2.connections.AllowFrom(sg1, ec2.Port_Tcp(jsii.Number(3333)))

In this case both the Ingress Rule for sg2 and the Egress Rule for sg1 will both be created in Stack 2 which avoids the cyclic reference.

Machine Images (AMIs)

AMIs control the OS that gets launched when you start your EC2 instance. The EC2 library contains constructs to select the AMI you want to use.

Depending on the type of AMI, you select it a different way. Here are some examples of images you might want to use:

// Pick the right Amazon Linux edition. All arguments shown are optional
// and will default to these values when omitted.
amznLinux := ec2.MachineImage_LatestAmazonLinux(&AmazonLinuxImageProps{
	Generation: ec2.AmazonLinuxGeneration_AMAZON_LINUX,
	Edition: ec2.AmazonLinuxEdition_STANDARD,
	Virtualization: ec2.AmazonLinuxVirt_HVM,
	Storage: ec2.AmazonLinuxStorage_GENERAL_PURPOSE,
	CpuType: ec2.AmazonLinuxCpuType_X86_64,
})

// Pick a Windows edition to use
windows := ec2.MachineImage_LatestWindows(ec2.WindowsVersion_WINDOWS_SERVER_2019_ENGLISH_FULL_BASE)

// Read AMI id from SSM parameter store
ssm := ec2.MachineImage_FromSsmParameter(jsii.String("/my/ami"), &SsmParameterImageOptions{
	Os: ec2.OperatingSystemType_LINUX,
})

// Look up the most recent image matching a set of AMI filters.
// In this case, look up the NAT instance AMI, by using a wildcard
// in the 'name' field:
natAmi := ec2.MachineImage_Lookup(&LookupMachineImageProps{
	Name: jsii.String("amzn-ami-vpc-nat-*"),
	Owners: []*string{
		jsii.String("amazon"),
	},
})

// For other custom (Linux) images, instantiate a `GenericLinuxImage` with
// a map giving the AMI to in for each region:
linux := ec2.MachineImage_GenericLinux(map[string]*string{
	"us-east-1": jsii.String("ami-97785bed"),
	"eu-west-1": jsii.String("ami-12345678"),
})

// For other custom (Windows) images, instantiate a `GenericWindowsImage` with
// a map giving the AMI to in for each region:
genericWindows := ec2.MachineImage_GenericWindows(map[string]*string{
	"us-east-1": jsii.String("ami-97785bed"),
	"eu-west-1": jsii.String("ami-12345678"),
})

NOTE: The AMIs selected by MachineImage.lookup() will be cached in cdk.context.json, so that your AutoScalingGroup instances aren't replaced while you are making unrelated changes to your CDK app.

To query for the latest AMI again, remove the relevant cache entry from cdk.context.json, or use the cdk context command. For more information, see Runtime Context in the CDK developer guide.

MachineImage.genericLinux(), MachineImage.genericWindows() will use CfnMapping in an agnostic stack.

Special VPC configurations

VPN connections to a VPC

Create your VPC with VPN connections by specifying the vpnConnections props (keys are construct ids):

vpc := ec2.NewVpc(this, jsii.String("MyVpc"), &VpcProps{
	VpnConnections: map[string]vpnConnectionOptions{
		"dynamic": &vpnConnectionOptions{
			 // Dynamic routing (BGP)
			"ip": jsii.String("1.2.3.4"),
		},
		"static": &vpnConnectionOptions{
			 // Static routing
			"ip": jsii.String("4.5.6.7"),
			"staticRoutes": []*string{
				jsii.String("192.168.10.0/24"),
				jsii.String("192.168.20.0/24"),
			},
		},
	},
})

To create a VPC that can accept VPN connections, set vpnGateway to true:

vpc := ec2.NewVpc(this, jsii.String("MyVpc"), &VpcProps{
	VpnGateway: jsii.Boolean(true),
})

VPN connections can then be added:

vpc.addVpnConnection(jsii.String("Dynamic"), &VpnConnectionOptions{
	Ip: jsii.String("1.2.3.4"),
})

By default, routes will be propagated on the route tables associated with the private subnets. If no private subnets exist, isolated subnets are used. If no isolated subnets exist, public subnets are used. Use the Vpc property vpnRoutePropagation to customize this behavior.

VPN connections expose metrics (cloudwatch.Metric) across all tunnels in the account/region and per connection:

// Across all tunnels in the account/region
allDataOut := ec2.VpnConnection_MetricAllTunnelDataOut()

// For a specific vpn connection
vpnConnection := vpc.addVpnConnection(jsii.String("Dynamic"), &VpnConnectionOptions{
	Ip: jsii.String("1.2.3.4"),
})
state := vpnConnection.metricTunnelState()

VPC endpoints

A VPC endpoint enables you to privately connect your VPC to supported AWS services and VPC endpoint services powered by PrivateLink without requiring an internet gateway, NAT device, VPN connection, or AWS Direct Connect connection. Instances in your VPC do not require public IP addresses to communicate with resources in the service. Traffic between your VPC and the other service does not leave the Amazon network.

Endpoints are virtual devices. They are horizontally scaled, redundant, and highly available VPC components that allow communication between instances in your VPC and services without imposing availability risks or bandwidth constraints on your network traffic.

// Add gateway endpoints when creating the VPC
vpc := ec2.NewVpc(this, jsii.String("MyVpc"), &VpcProps{
	GatewayEndpoints: map[string]gatewayVpcEndpointOptions{
		"S3": &gatewayVpcEndpointOptions{
			"service": ec2.GatewayVpcEndpointAwsService_S3(),
		},
	},
})

// Alternatively gateway endpoints can be added on the VPC
dynamoDbEndpoint := vpc.addGatewayEndpoint(jsii.String("DynamoDbEndpoint"), &gatewayVpcEndpointOptions{
	Service: ec2.GatewayVpcEndpointAwsService_DYNAMODB(),
})

// This allows to customize the endpoint policy
dynamoDbEndpoint.AddToPolicy(
iam.NewPolicyStatement(&PolicyStatementProps{
	 // Restrict to listing and describing tables
	Principals: []iPrincipal{
		iam.NewAnyPrincipal(),
	},
	Actions: []*string{
		jsii.String("dynamodb:DescribeTable"),
		jsii.String("dynamodb:ListTables"),
	},
	Resources: []*string{
		jsii.String("*"),
	},
}))

// Add an interface endpoint
vpc.addInterfaceEndpoint(jsii.String("EcrDockerEndpoint"), &InterfaceVpcEndpointOptions{
	Service: ec2.InterfaceVpcEndpointAwsService_ECR_DOCKER(),
})

By default, CDK will place a VPC endpoint in one subnet per AZ. If you wish to override the AZs CDK places the VPC endpoint in, use the subnets parameter as follows:

var vpc vpc


ec2.NewInterfaceVpcEndpoint(this, jsii.String("VPC Endpoint"), &InterfaceVpcEndpointProps{
	Vpc: Vpc,
	Service: ec2.NewInterfaceVpcEndpointService(jsii.String("com.amazonaws.vpce.us-east-1.vpce-svc-uuddlrlrbastrtsvc"), jsii.Number(443)),
	// Choose which availability zones to place the VPC endpoint in, based on
	// available AZs
	Subnets: &SubnetSelection{
		AvailabilityZones: []*string{
			jsii.String("us-east-1a"),
			jsii.String("us-east-1c"),
		},
	},
})

Per the AWS documentation, not all VPC endpoint services are available in all AZs. If you specify the parameter lookupSupportedAzs, CDK attempts to discover which AZs an endpoint service is available in, and will ensure the VPC endpoint is not placed in a subnet that doesn't match those AZs. These AZs will be stored in cdk.context.json.

var vpc vpc


ec2.NewInterfaceVpcEndpoint(this, jsii.String("VPC Endpoint"), &InterfaceVpcEndpointProps{
	Vpc: Vpc,
	Service: ec2.NewInterfaceVpcEndpointService(jsii.String("com.amazonaws.vpce.us-east-1.vpce-svc-uuddlrlrbastrtsvc"), jsii.Number(443)),
	// Choose which availability zones to place the VPC endpoint in, based on
	// available AZs
	LookupSupportedAzs: jsii.Boolean(true),
})

Pre-defined AWS services are defined in the InterfaceVpcEndpointAwsService class, and can be used to create VPC endpoints without having to configure name, ports, etc. For example, a Keyspaces endpoint can be created for use in your VPC:

var vpc vpc


ec2.NewInterfaceVpcEndpoint(this, jsii.String("VPC Endpoint"), &InterfaceVpcEndpointProps{
	Vpc: Vpc,
	Service: ec2.InterfaceVpcEndpointAwsService_KEYSPACES(),
})

Security groups for interface VPC endpoints

By default, interface VPC endpoints create a new security group and traffic is not automatically allowed from the VPC CIDR.

Use the connections object to allow traffic to flow to the endpoint:

var myEndpoint interfaceVpcEndpoint


myEndpoint.Connections.AllowDefaultPortFromAnyIpv4()

Alternatively, existing security groups can be used by specifying the securityGroups prop.

VPC endpoint services

A VPC endpoint service enables you to expose a Network Load Balancer(s) as a provider service to consumers, who connect to your service over a VPC endpoint. You can restrict access to your service via allowed principals (anything that extends ArnPrincipal), and require that new connections be manually accepted. You can also enable Contributor Insight rules.

var networkLoadBalancer1 networkLoadBalancer
var networkLoadBalancer2 networkLoadBalancer


ec2.NewVpcEndpointService(this, jsii.String("EndpointService"), &VpcEndpointServiceProps{
	VpcEndpointServiceLoadBalancers: []iVpcEndpointServiceLoadBalancer{
		networkLoadBalancer1,
		networkLoadBalancer2,
	},
	AcceptanceRequired: jsii.Boolean(true),
	AllowedPrincipals: []arnPrincipal{
		iam.NewArnPrincipal(jsii.String("arn:aws:iam::123456789012:root")),
	},
	ContributorInsights: jsii.Boolean(true),
})

Endpoint services support private DNS, which makes it easier for clients to connect to your service by automatically setting up DNS in their VPC. You can enable private DNS on an endpoint service like so:

import "github.com/aws/aws-cdk-go/awscdk"
var zone publicHostedZone
var vpces vpcEndpointService


awscdk.NewVpcEndpointServiceDomainName(this, jsii.String("EndpointDomain"), &VpcEndpointServiceDomainNameProps{
	EndpointService: vpces,
	DomainName: jsii.String("my-stuff.aws-cdk.dev"),
	PublicHostedZone: zone,
})

Note: The domain name must be owned (registered through Route53) by the account the endpoint service is in, or delegated to the account. The VpcEndpointServiceDomainName will handle the AWS side of domain verification, the process for which can be found here

Client VPN endpoint

AWS Client VPN is a managed client-based VPN service that enables you to securely access your AWS resources and resources in your on-premises network. With Client VPN, you can access your resources from any location using an OpenVPN-based VPN client.

Use the addClientVpnEndpoint() method to add a client VPN endpoint to a VPC:

vpc.addClientVpnEndpoint(jsii.String("Endpoint"), &ClientVpnEndpointOptions{
	Cidr: jsii.String("10.100.0.0/16"),
	ServerCertificateArn: jsii.String("arn:aws:acm:us-east-1:123456789012:certificate/server-certificate-id"),
	// Mutual authentication
	ClientCertificateArn: jsii.String("arn:aws:acm:us-east-1:123456789012:certificate/client-certificate-id"),
	// User-based authentication
	UserBasedAuthentication: ec2.ClientVpnUserBasedAuthentication_Federated(samlProvider),
})

The endpoint must use at least one authentication method:

• Mutual authentication with a client certificate
• User-based authentication (directory or federated)

If user-based authentication is used, the self-service portal URL is made available via a CloudFormation output.

By default, a new security group is created, and logging is enabled. Moreover, a rule to authorize all users to the VPC CIDR is created.

To customize authorization rules, set the authorizeAllUsersToVpcCidr prop to false and use addAuthorizationRule():

endpoint := vpc.addClientVpnEndpoint(jsii.String("Endpoint"), &ClientVpnEndpointOptions{
	Cidr: jsii.String("10.100.0.0/16"),
	ServerCertificateArn: jsii.String("arn:aws:acm:us-east-1:123456789012:certificate/server-certificate-id"),
	UserBasedAuthentication: ec2.ClientVpnUserBasedAuthentication_Federated(samlProvider),
	AuthorizeAllUsersToVpcCidr: jsii.Boolean(false),
})

endpoint.AddAuthorizationRule(jsii.String("Rule"), &ClientVpnAuthorizationRuleOptions{
	Cidr: jsii.String("10.0.10.0/32"),
	GroupId: jsii.String("group-id"),
})

Use addRoute() to configure network routes:

endpoint := vpc.addClientVpnEndpoint(jsii.String("Endpoint"), &ClientVpnEndpointOptions{
	Cidr: jsii.String("10.100.0.0/16"),
	ServerCertificateArn: jsii.String("arn:aws:acm:us-east-1:123456789012:certificate/server-certificate-id"),
	UserBasedAuthentication: ec2.ClientVpnUserBasedAuthentication_Federated(samlProvider),
})

// Client-to-client access
endpoint.AddRoute(jsii.String("Route"), &ClientVpnRouteOptions{
	Cidr: jsii.String("10.100.0.0/16"),
	Target: ec2.ClientVpnRouteTarget_Local(),
})

Use the connections object of the endpoint to allow traffic to other security groups.

Instances

You can use the Instance class to start up a single EC2 instance. For production setups, we recommend you use an AutoScalingGroup from the aws-autoscaling module instead, as AutoScalingGroups will take care of restarting your instance if it ever fails.

var vpc vpc
var instanceType instanceType


// Amazon Linux 2
// Amazon Linux 2
ec2.NewInstance(this, jsii.String("Instance2"), &InstanceProps{
	Vpc: Vpc,
	InstanceType: InstanceType,
	MachineImage: ec2.MachineImage_LatestAmazonLinux2(),
})

// Amazon Linux 2 with kernel 5.x
// Amazon Linux 2 with kernel 5.x
ec2.NewInstance(this, jsii.String("Instance3"), &InstanceProps{
	Vpc: Vpc,
	InstanceType: InstanceType,
	MachineImage: ec2.MachineImage_*LatestAmazonLinux2(&AmazonLinux2ImageSsmParameterProps{
		Kernel: ec2.AmazonLinux2Kernel_KERNEL_5_10(),
	}),
})

// Amazon Linux 2023
// Amazon Linux 2023
ec2.NewInstance(this, jsii.String("Instance4"), &InstanceProps{
	Vpc: Vpc,
	InstanceType: InstanceType,
	MachineImage: ec2.MachineImage_LatestAmazonLinux2023(),
})

// Graviton 3 Processor
// Graviton 3 Processor
ec2.NewInstance(this, jsii.String("Instance5"), &InstanceProps{
	Vpc: Vpc,
	InstanceType: ec2.*instanceType_Of(ec2.InstanceClass_C7G, ec2.InstanceSize_LARGE),
	MachineImage: ec2.MachineImage_*LatestAmazonLinux2023(&AmazonLinux2023ImageSsmParameterProps{
		CpuType: ec2.AmazonLinuxCpuType_ARM_64,
	}),
})

Latest Amazon Linux Images

Rather than specifying a specific AMI ID to use, it is possible to specify a SSM Parameter that contains the AMI ID. AWS publishes a set of public parameters that contain the latest Amazon Linux AMIs. To make it easier to query a particular image parameter, the CDK provides a couple of constructs AmazonLinux2ImageSsmParameter, AmazonLinux2022ImageSsmParameter, & AmazonLinux2023SsmParameter. For example to use the latest al2023 image:

var vpc vpc


ec2.NewInstance(this, jsii.String("LatestAl2023"), &InstanceProps{
	Vpc: Vpc,
	InstanceType: ec2.InstanceType_Of(ec2.InstanceClass_C7G, ec2.InstanceSize_LARGE),
	MachineImage: ec2.MachineImage_LatestAmazonLinux2023(),
})

Warning Since this retrieves the value from an SSM parameter at deployment time, the value will be resolved each time the stack is deployed. This means that if the parameter contains a different value on your next deployment, the instance will be replaced.

It is also possible to perform the lookup once at synthesis time and then cache the value in CDK context. This way the value will not change on future deployments unless you manually refresh the context.

var vpc vpc


ec2.NewInstance(this, jsii.String("LatestAl2023"), &InstanceProps{
	Vpc: Vpc,
	InstanceType: ec2.InstanceType_Of(ec2.InstanceClass_C7G, ec2.InstanceSize_LARGE),
	MachineImage: ec2.MachineImage_LatestAmazonLinux2023(&AmazonLinux2023ImageSsmParameterProps{
		CachedInContext: jsii.Boolean(true),
	}),
})

// or
// or
ec2.NewInstance(this, jsii.String("LatestAl2023"), &InstanceProps{
	Vpc: Vpc,
	InstanceType: ec2.InstanceType_*Of(ec2.InstanceClass_C7G, ec2.InstanceSize_LARGE),
	// context cache is turned on by default
	MachineImage: ec2.NewAmazonLinux2023ImageSsmParameter(),
})

Kernel Versions

Each Amazon Linux AMI uses a specific kernel version. Most Amazon Linux generations come with an AMI using the "default" kernel and then 1 or more AMIs using a specific kernel version, which may or may not be different from the default kernel version.

For example, Amazon Linux 2 has two different AMIs available from the SSM parameters.

• /aws/service/ami-amazon-linux-latest/amzn2-ami-hvm-x86_64-ebs

  • This is the "default" kernel which uses kernel-4.14

• /aws/service/ami-amazon-linux-latest/amzn2-ami-kernel-5.10-hvm-x86_64-ebs

If a new Amazon Linux generation AMI is published with a new kernel version, then a new SSM parameter will be created with the new version (e.g. /aws/service/ami-amazon-linux-latest/amzn2-ami-kernel-5.15-hvm-x86_64-ebs), but the "default" AMI may or may not be updated.

If you would like to make sure you always have the latest kernel version, then either specify the specific latest kernel version or opt-in to using the CDK latest kernel version.

var vpc vpc


ec2.NewInstance(this, jsii.String("LatestAl2023"), &InstanceProps{
	Vpc: Vpc,
	InstanceType: ec2.InstanceType_Of(ec2.InstanceClass_C7G, ec2.InstanceSize_LARGE),
	// context cache is turned on by default
	MachineImage: ec2.NewAmazonLinux2023ImageSsmParameter(&AmazonLinux2023ImageSsmParameterProps{
		Kernel: ec2.AmazonLinux2023Kernel_KERNEL_6_1(),
	}),
})

CDK managed latest

var vpc vpc


ec2.NewInstance(this, jsii.String("LatestAl2023"), &InstanceProps{
	Vpc: Vpc,
	InstanceType: ec2.InstanceType_Of(ec2.InstanceClass_C7G, ec2.InstanceSize_LARGE),
	// context cache is turned on by default
	MachineImage: ec2.NewAmazonLinux2023ImageSsmParameter(&AmazonLinux2023ImageSsmParameterProps{
		Kernel: ec2.AmazonLinux2023Kernel_CDK_LATEST(),
	}),
})

// or

// or
ec2.NewInstance(this, jsii.String("LatestAl2023"), &InstanceProps{
	Vpc: Vpc,
	InstanceType: ec2.InstanceType_*Of(ec2.InstanceClass_C7G, ec2.InstanceSize_LARGE),
	MachineImage: ec2.MachineImage_LatestAmazonLinux2023(),
})

When using the CDK managed latest version, when a new kernel version is made available the LATEST will be updated to point to the new kernel version. You then would be required to update the newest CDK version for it to take effect.

Configuring Instances using CloudFormation Init (cfn-init)

CloudFormation Init allows you to configure your instances by writing files to them, installing software packages, starting services and running arbitrary commands. By default, if any of the instance setup commands throw an error; the deployment will fail and roll back to the previously known good state. The following documentation also applies to AutoScalingGroups.

For the full set of capabilities of this system, see the documentation for AWS::CloudFormation::Init. Here is an example of applying some configuration to an instance:

var vpc vpc
var instanceType instanceType
var machineImage iMachineImage


ec2.NewInstance(this, jsii.String("Instance"), &InstanceProps{
	Vpc: Vpc,
	InstanceType: InstanceType,
	MachineImage: MachineImage,

	// Showing the most complex setup, if you have simpler requirements
	// you can use `CloudFormationInit.fromElements()`.
	Init: ec2.CloudFormationInit_FromConfigSets(&ConfigSetProps{
		ConfigSets: map[string][]*string{
			// Applies the configs below in this order
			"default": []*string{
				jsii.String("yumPreinstall"),
				jsii.String("config"),
			},
		},
		Configs: map[string]initConfig{
			"yumPreinstall": ec2.NewInitConfig([]InitElement{
				ec2.InitPackage_yum(jsii.String("git")),
			}),
			"config": ec2.NewInitConfig([]InitElement{
				ec2.InitFile_fromObject(jsii.String("/etc/stack.json"), map[string]interface{}{
					"stackId": awscdk.*stack_of(this).stackId,
					"stackName": awscdk.*stack_of(this).stackName,
					"region": awscdk.*stack_of(this).region,
				}),
				ec2.InitGroup_fromName(jsii.String("my-group")),
				ec2.InitUser_fromName(jsii.String("my-user")),
				ec2.InitPackage_rpm(jsii.String("http://mirrors.ukfast.co.uk/sites/dl.fedoraproject.org/pub/epel/8/Everything/x86_64/Packages/r/rubygem-git-1.5.0-2.el8.noarch.rpm")),
			}),
		},
	}),
	InitOptions: &ApplyCloudFormationInitOptions{
		// Optional, which configsets to activate (['default'] by default)
		ConfigSets: []*string{
			jsii.String("default"),
		},

		// Optional, how long the installation is expected to take (5 minutes by default)
		Timeout: awscdk.Duration_Minutes(jsii.Number(30)),

		// Optional, whether to include the --url argument when running cfn-init and cfn-signal commands (false by default)
		IncludeUrl: jsii.Boolean(true),

		// Optional, whether to include the --role argument when running cfn-init and cfn-signal commands (false by default)
		IncludeRole: jsii.Boolean(true),
	},
})

InitCommand can not be used to start long-running processes. At deploy time, cfn-init will always wait for the process to exit before continuing, causing the CloudFormation deployment to fail because the signal hasn't been received within the expected timeout.

Instead, you should install a service configuration file onto your machine InitFile, and then use InitService to start it.

If your Linux OS is using SystemD (like Amazon Linux 2 or higher), the CDK has helpers to create a long-running service using CFN Init. You can create a SystemD-compatible config file using InitService.systemdConfigFile(), and start it immediately. The following examples shows how to start a trivial Python 3 web server:

var vpc vpc
var instanceType instanceType


ec2.NewInstance(this, jsii.String("Instance"), &InstanceProps{
	Vpc: Vpc,
	InstanceType: InstanceType,
	MachineImage: ec2.MachineImage_LatestAmazonLinux2023(),

	Init: ec2.CloudFormationInit_FromElements(ec2.InitService_SystemdConfigFile(jsii.String("simpleserver"), &SystemdConfigFileOptions{
		Command: jsii.String("/usr/bin/python3 -m http.server 8080"),
		Cwd: jsii.String("/var/www/html"),
	}), ec2.InitService_Enable(jsii.String("simpleserver"), &InitServiceOptions{
		ServiceManager: ec2.ServiceManager_SYSTEMD,
	}), ec2.InitFile_FromString(jsii.String("/var/www/html/index.html"), jsii.String("Hello! It's working!"))),
})

You can have services restarted after the init process has made changes to the system. To do that, instantiate an InitServiceRestartHandle and pass it to the config elements that need to trigger the restart and the service itself. For example, the following config writes a config file for nginx, extracts an archive to the root directory, and then restarts nginx so that it picks up the new config and files:

var myBucket bucket


handle := ec2.NewInitServiceRestartHandle()

ec2.CloudFormationInit_FromElements(ec2.InitFile_FromString(jsii.String("/etc/nginx/nginx.conf"), jsii.String("..."), &InitFileOptions{
	ServiceRestartHandles: []initServiceRestartHandle{
		handle,
	},
}), ec2.InitSource_FromS3Object(jsii.String("/var/www/html"), myBucket, jsii.String("html.zip"), &InitSourceOptions{
	ServiceRestartHandles: []*initServiceRestartHandle{
		handle,
	},
}), ec2.InitService_Enable(jsii.String("nginx"), &InitServiceOptions{
	ServiceRestartHandle: handle,
}))

Bastion Hosts

A bastion host functions as an instance used to access servers and resources in a VPC without open up the complete VPC on a network level. You can use bastion hosts using a standard SSH connection targeting port 22 on the host. As an alternative, you can connect the SSH connection feature of AWS Systems Manager Session Manager, which does not need an opened security group. (https://aws.amazon.com/about-aws/whats-new/2019/07/session-manager-launches-tunneling-support-for-ssh-and-scp/)

A default bastion host for use via SSM can be configured like:

host := ec2.NewBastionHostLinux(this, jsii.String("BastionHost"), &BastionHostLinuxProps{
	Vpc: Vpc,
})

If you want to connect from the internet using SSH, you need to place the host into a public subnet. You can then configure allowed source hosts.

host := ec2.NewBastionHostLinux(this, jsii.String("BastionHost"), &BastionHostLinuxProps{
	Vpc: Vpc,
	SubnetSelection: &SubnetSelection{
		SubnetType: ec2.SubnetType_PUBLIC,
	},
})
host.AllowSshAccessFrom(ec2.Peer_Ipv4(jsii.String("1.2.3.4/32")))

As there are no SSH public keys deployed on this machine, you need to use EC2 Instance Connect with the command aws ec2-instance-connect send-ssh-public-key to provide your SSH public key.

EBS volume for the bastion host can be encrypted like:

host := ec2.NewBastionHostLinux(this, jsii.String("BastionHost"), &BastionHostLinuxProps{
	Vpc: Vpc,
	BlockDevices: []blockDevice{
		&blockDevice{
			DeviceName: jsii.String("EBSBastionHost"),
			Volume: ec2.BlockDeviceVolume_Ebs(jsii.Number(10), &EbsDeviceOptions{
				Encrypted: jsii.Boolean(true),
			}),
		},
	},
})

Block Devices

To add EBS block device mappings, specify the blockDevices property. The following example sets the EBS-backed root device (/dev/sda1) size to 50 GiB, and adds another EBS-backed device mapped to /dev/sdm that is 100 GiB in size:

var vpc vpc
var instanceType instanceType
var machineImage iMachineImage


ec2.NewInstance(this, jsii.String("Instance"), &InstanceProps{
	Vpc: Vpc,
	InstanceType: InstanceType,
	MachineImage: MachineImage,

	// ...

	BlockDevices: []blockDevice{
		&blockDevice{
			DeviceName: jsii.String("/dev/sda1"),
			Volume: ec2.BlockDeviceVolume_Ebs(jsii.Number(50)),
		},
		&blockDevice{
			DeviceName: jsii.String("/dev/sdm"),
			Volume: ec2.BlockDeviceVolume_*Ebs(jsii.Number(100)),
		},
	},
})

It is also possible to encrypt the block devices. In this example we will create an customer managed key encrypted EBS-backed root device:

import "github.com/aws/aws-cdk-go/awscdk"

var vpc vpc
var instanceType instanceType
var machineImage iMachineImage


kmsKey := awscdk.NewKey(this, jsii.String("KmsKey"))

ec2.NewInstance(this, jsii.String("Instance"), &InstanceProps{
	Vpc: Vpc,
	InstanceType: InstanceType,
	MachineImage: MachineImage,

	// ...

	BlockDevices: []blockDevice{
		&blockDevice{
			DeviceName: jsii.String("/dev/sda1"),
			Volume: ec2.BlockDeviceVolume_Ebs(jsii.Number(50), &EbsDeviceOptions{
				Encrypted: jsii.Boolean(true),
				KmsKey: kmsKey,
			}),
		},
	},
})

Volumes

Whereas a BlockDeviceVolume is an EBS volume that is created and destroyed as part of the creation and destruction of a specific instance. A Volume is for when you want an EBS volume separate from any particular instance. A Volume is an EBS block device that can be attached to, or detached from, any instance at any time. Some types of Volumes can also be attached to multiple instances at the same time to allow you to have shared storage between those instances.

A notable restriction is that a Volume can only be attached to instances in the same availability zone as the Volume itself.

The following demonstrates how to create a 500 GiB encrypted Volume in the us-west-2a availability zone, and give a role the ability to attach that Volume to a specific instance:

var instance instance
var role role


volume := ec2.NewVolume(this, jsii.String("Volume"), &VolumeProps{
	AvailabilityZone: jsii.String("us-west-2a"),
	Size: awscdk.Size_Gibibytes(jsii.Number(500)),
	Encrypted: jsii.Boolean(true),
})

volume.grantAttachVolume(role, []iInstance{
	instance,
})

Instances Attaching Volumes to Themselves

If you need to grant an instance the ability to attach/detach an EBS volume to/from itself, then using grantAttachVolume and grantDetachVolume as outlined above will lead to an unresolvable circular reference between the instance role and the instance. In this case, use grantAttachVolumeByResourceTag and grantDetachVolumeByResourceTag as follows:

var instance instance
var volume volume


attachGrant := volume.grantAttachVolumeByResourceTag(instance.GrantPrincipal, []construct{
	instance,
})
detachGrant := volume.grantDetachVolumeByResourceTag(instance.GrantPrincipal, []construct{
	instance,
})

Attaching Volumes

The Amazon EC2 documentation for Linux Instances and Windows Instances contains information on how to attach and detach your Volumes to/from instances, and how to format them for use.

The following is a sample skeleton of EC2 UserData that can be used to attach a Volume to the Linux instance that it is running on:

var instance instance
var volume volume


volume.grantAttachVolumeByResourceTag(instance.GrantPrincipal, []construct{
	instance,
})
targetDevice := "/dev/xvdz"
instance.UserData.AddCommands(jsii.String("TOKEN=$(curl -SsfX PUT \"http://169.254.169.254/latest/api/token\" -H \"X-aws-ec2-metadata-token-ttl-seconds: 21600\")"), jsii.String("INSTANCE_ID=$(curl -SsfH \"X-aws-ec2-metadata-token: $TOKEN\" http://169.254.169.254/latest/meta-data/instance-id)"),
// Attach the volume to /dev/xvdz
fmt.Sprintf("aws --region %v ec2 attach-volume --volume-id %v --instance-id $INSTANCE_ID --device %v", awscdk.stack_Of(this).Region, volume.VolumeId, targetDevice),
// Wait until the volume has attached
fmt.Sprintf("while ! test -e %v; do sleep 1; done", targetDevice))

Tagging Volumes

You can configure tag propagation on volume creation.

var vpc vpc
var instanceType instanceType
var machineImage iMachineImage


ec2.NewInstance(this, jsii.String("Instance"), &InstanceProps{
	Vpc: Vpc,
	MachineImage: MachineImage,
	InstanceType: InstanceType,
	PropagateTagsToVolumeOnCreation: jsii.Boolean(true),
})

Throughput on GP3 Volumes

You can specify the throughput of a GP3 volume from 125 (default) to 1000.

ec2.NewVolume(this, jsii.String("Volume"), &VolumeProps{
	AvailabilityZone: jsii.String("us-east-1a"),
	Size: awscdk.Size_Gibibytes(jsii.Number(125)),
	VolumeType: ec2.EbsDeviceVolumeType_GP3,
	Throughput: jsii.Number(125),
})

Configuring Instance Metadata Service (IMDS)

Toggling IMDSv1

You can configure EC2 Instance Metadata Service options to either allow both IMDSv1 and IMDSv2 or enforce IMDSv2 when interacting with the IMDS.

To do this for a single Instance, you can use the requireImdsv2 property. The example below demonstrates IMDSv2 being required on a single Instance:

var vpc vpc
var instanceType instanceType
var machineImage iMachineImage


ec2.NewInstance(this, jsii.String("Instance"), &InstanceProps{
	Vpc: Vpc,
	InstanceType: InstanceType,
	MachineImage: MachineImage,

	// ...

	RequireImdsv2: jsii.Boolean(true),
})

You can also use the either the InstanceRequireImdsv2Aspect for EC2 instances or the LaunchTemplateRequireImdsv2Aspect for EC2 launch templates to apply the operation to multiple instances or launch templates, respectively.

The following example demonstrates how to use the InstanceRequireImdsv2Aspect to require IMDSv2 for all EC2 instances in a stack:

aspect := ec2.NewInstanceRequireImdsv2Aspect()
awscdk.Aspects_Of(this).Add(aspect)

Associating a Public IP Address with an Instance

All subnets have an attribute that determines whether instances launched into that subnet are assigned a public IPv4 address. This attribute is set to true by default for default public subnets. Thus, an EC2 instance launched into a default public subnet will be assigned a public IPv4 address. Nondefault public subnets have this attribute set to false by default and any EC2 instance launched into a nondefault public subnet will not be assigned a public IPv4 address automatically. To automatically assign a public IPv4 address to an instance launched into a nondefault public subnet, you can set the associatePublicIpAddress property on the Instance construct to true. Alternatively, to not automatically assign a public IPv4 address to an instance launched into a default public subnet, you can set associatePublicIpAddress to false. Including this property, removing this property, or updating the value of this property on an existing instance will result in replacement of the instance.

vpc := ec2.NewVpc(this, jsii.String("VPC"), &VpcProps{
	Cidr: jsii.String("10.0.0.0/16"),
	NatGateways: jsii.Number(0),
	MaxAzs: jsii.Number(3),
	SubnetConfiguration: []subnetConfiguration{
		&subnetConfiguration{
			Name: jsii.String("public-subnet-1"),
			SubnetType: ec2.SubnetType_PUBLIC,
			CidrMask: jsii.Number(24),
		},
	},
})

instance := ec2.NewInstance(this, jsii.String("Instance"), &InstanceProps{
	Vpc: Vpc,
	VpcSubnets: &SubnetSelection{
		SubnetGroupName: jsii.String("public-subnet-1"),
	},
	InstanceType: ec2.InstanceType_Of(ec2.InstanceClass_T3, ec2.InstanceSize_NANO),
	MachineImage: ec2.NewAmazonLinuxImage(&AmazonLinuxImageProps{
		Generation: ec2.AmazonLinuxGeneration_AMAZON_LINUX_2,
	}),
	DetailedMonitoring: jsii.Boolean(true),
	AssociatePublicIpAddress: jsii.Boolean(true),
})

VPC Flow Logs

VPC Flow Logs is a feature that enables you to capture information about the IP traffic going to and from network interfaces in your VPC. Flow log data can be published to Amazon CloudWatch Logs and Amazon S3. After you've created a flow log, you can retrieve and view its data in the chosen destination. (https://docs.aws.amazon.com/vpc/latest/userguide/flow-logs.html).

By default, a flow log will be created with CloudWatch Logs as the destination.

You can create a flow log like this:

var vpc vpc


ec2.NewFlowLog(this, jsii.String("FlowLog"), &FlowLogProps{
	ResourceType: ec2.FlowLogResourceType_FromVpc(vpc),
})

Or you can add a Flow Log to a VPC by using the addFlowLog method like this:

vpc := ec2.NewVpc(this, jsii.String("Vpc"))

vpc.addFlowLog(jsii.String("FlowLog"))

You can also add multiple flow logs with different destinations.

vpc := ec2.NewVpc(this, jsii.String("Vpc"))

vpc.addFlowLog(jsii.String("FlowLogS3"), &FlowLogOptions{
	Destination: ec2.FlowLogDestination_ToS3(),
})

// Only reject traffic and interval every minute.
vpc.addFlowLog(jsii.String("FlowLogCloudWatch"), &FlowLogOptions{
	TrafficType: ec2.FlowLogTrafficType_REJECT,
	MaxAggregationInterval: ec2.FlowLogMaxAggregationInterval_ONE_MINUTE,
})

Custom Formatting

You can also custom format flow logs.

vpc := ec2.NewVpc(this, jsii.String("Vpc"))

vpc.addFlowLog(jsii.String("FlowLog"), &FlowLogOptions{
	LogFormat: []logFormat{
		ec2.*logFormat_DST_PORT(),
		ec2.*logFormat_SRC_PORT(),
	},
})

// If you just want to add a field to the default field
vpc.addFlowLog(jsii.String("FlowLog"), &FlowLogOptions{
	LogFormat: []*logFormat{
		ec2.*logFormat_VERSION(),
		ec2.*logFormat_ALL_DEFAULT_FIELDS(),
	},
})

// If AWS CDK does not support the new fields
vpc.addFlowLog(jsii.String("FlowLog"), &FlowLogOptions{
	LogFormat: []*logFormat{
		ec2.*logFormat_SRC_PORT(),
		ec2.*logFormat_Custom(jsii.String("${new-field}")),
	},
})

By default, the CDK will create the necessary resources for the destination. For the CloudWatch Logs destination it will create a CloudWatch Logs Log Group as well as the IAM role with the necessary permissions to publish to the log group. In the case of an S3 destination, it will create the S3 bucket.

If you want to customize any of the destination resources you can provide your own as part of the destination.

CloudWatch Logs

var vpc vpc


logGroup := logs.NewLogGroup(this, jsii.String("MyCustomLogGroup"))

role := iam.NewRole(this, jsii.String("MyCustomRole"), &RoleProps{
	AssumedBy: iam.NewServicePrincipal(jsii.String("vpc-flow-logs.amazonaws.com")),
})

ec2.NewFlowLog(this, jsii.String("FlowLog"), &FlowLogProps{
	ResourceType: ec2.FlowLogResourceType_FromVpc(vpc),
	Destination: ec2.FlowLogDestination_ToCloudWatchLogs(logGroup, role),
})

S3

var vpc vpc


bucket := s3.NewBucket(this, jsii.String("MyCustomBucket"))

ec2.NewFlowLog(this, jsii.String("FlowLog"), &FlowLogProps{
	ResourceType: ec2.FlowLogResourceType_FromVpc(vpc),
	Destination: ec2.FlowLogDestination_ToS3(bucket),
})

ec2.NewFlowLog(this, jsii.String("FlowLogWithKeyPrefix"), &FlowLogProps{
	ResourceType: ec2.FlowLogResourceType_*FromVpc(vpc),
	Destination: ec2.FlowLogDestination_*ToS3(bucket, jsii.String("prefix/")),
})

When the S3 destination is configured, AWS will automatically create an S3 bucket policy that allows the service to write logs to the bucket. This makes it impossible to later update that bucket policy. To have CDK create the bucket policy so that future updates can be made, the @aws-cdk/aws-s3:createDefaultLoggingPolicy feature flag can be used. This can be set in the cdk.json file.

{
  "context": {
    "@aws-cdk/aws-s3:createDefaultLoggingPolicy": true
  }
}

User Data

User data enables you to run a script when your instances start up. In order to configure these scripts you can add commands directly to the script or you can use the UserData's convenience functions to aid in the creation of your script.

A user data could be configured to run a script found in an asset through the following:

import "github.com/aws/aws-cdk-go/awscdk"

var instance instance


asset := awscdk.NewAsset(this, jsii.String("Asset"), &AssetProps{
	Path: jsii.String("./configure.sh"),
})

localPath := instance.UserData.AddS3DownloadCommand(&S3DownloadOptions{
	Bucket: asset.Bucket,
	BucketKey: asset.S3ObjectKey,
	Region: jsii.String("us-east-1"),
})
instance.UserData.AddExecuteFileCommand(&ExecuteFileOptions{
	FilePath: localPath,
	Arguments: jsii.String("--verbose -y"),
})
asset.GrantRead(instance.Role)

Persisting user data

By default, EC2 UserData is run once on only the first time that an instance is started. It is possible to make the user data script run on every start of the instance.

When creating a Windows UserData you can use the persist option to set whether or not to add <persist>true</persist> to the user data script. it can be used as follows:

windowsUserData := ec2.UserData_ForWindows(&WindowsUserDataOptions{
	Persist: jsii.Boolean(true),
})

For a Linux instance, this can be accomplished by using a Multipart user data to configure cloud-config as detailed in: https://aws.amazon.com/premiumsupport/knowledge-center/execute-user-data-ec2/

Multipart user data

In addition, to above the MultipartUserData can be used to change instance startup behavior. Multipart user data are composed from separate parts forming archive. The most common parts are scripts executed during instance set-up. However, there are other kinds, too.

The advantage of multipart archive is in flexibility when it's needed to add additional parts or to use specialized parts to fine tune instance startup. Some services (like AWS Batch) support only MultipartUserData.

The parts can be executed at different moment of instance start-up and can serve a different purpose. This is controlled by contentType property. For common scripts, text/x-shellscript; charset="utf-8" can be used as content type.

In order to create archive the MultipartUserData has to be instantiated. Than, user can add parts to multipart archive using addPart. The MultipartBody contains methods supporting creation of body parts.

If the very custom part is required, it can be created using MultipartUserData.fromRawBody, in this case full control over content type, transfer encoding, and body properties is given to the user.

Below is an example for creating multipart user data with single body part responsible for installing awscli and configuring maximum size of storage used by Docker containers:

bootHookConf := ec2.UserData_ForLinux()
bootHookConf.AddCommands(jsii.String("cloud-init-per once docker_options echo 'OPTIONS=\"${OPTIONS} --storage-opt dm.basesize=40G\"' >> /etc/sysconfig/docker"))

setupCommands := ec2.UserData_ForLinux()
setupCommands.AddCommands(jsii.String("sudo yum install awscli && echo Packages installed らと > /var/tmp/setup"))

multipartUserData := ec2.NewMultipartUserData()
// The docker has to be configured at early stage, so content type is overridden to boothook
multipartUserData.AddPart(ec2.MultipartBody_FromUserData(bootHookConf, jsii.String("text/cloud-boothook; charset=\"us-ascii\"")))
// Execute the rest of setup
multipartUserData.AddPart(ec2.MultipartBody_FromUserData(setupCommands))

ec2.NewLaunchTemplate(this, jsii.String(""), &LaunchTemplateProps{
	UserData: multipartUserData,
	BlockDevices: []blockDevice{
	},
})

For more information see Specifying Multiple User Data Blocks Using a MIME Multi Part Archive

Using add*Command on MultipartUserData

To use the add*Command methods, that are inherited from the UserData interface, on MultipartUserData you must add a part to the MultipartUserData and designate it as the receiver for these methods. This is accomplished by using the addUserDataPart() method on MultipartUserData with the makeDefault argument set to true:

multipartUserData := ec2.NewMultipartUserData()
commandsUserData := ec2.UserData_ForLinux()
multipartUserData.AddUserDataPart(commandsUserData, ec2.MultipartBody_SHELL_SCRIPT(), jsii.Boolean(true))

// Adding commands to the multipartUserData adds them to commandsUserData, and vice-versa.
multipartUserData.AddCommands(jsii.String("touch /root/multi.txt"))
commandsUserData.AddCommands(jsii.String("touch /root/userdata.txt"))

When used on an EC2 instance, the above multipartUserData will create both multi.txt and userdata.txt in /root.

Importing existing subnet

To import an existing Subnet, call Subnet.fromSubnetAttributes() or Subnet.fromSubnetId(). Only if you supply the subnet's Availability Zone and Route Table Ids when calling Subnet.fromSubnetAttributes() will you be able to use the CDK features that use these values (such as selecting one subnet per AZ).

Importing an existing subnet looks like this:

// Supply all properties
subnet1 := ec2.Subnet_FromSubnetAttributes(this, jsii.String("SubnetFromAttributes"), &SubnetAttributes{
	SubnetId: jsii.String("s-1234"),
	AvailabilityZone: jsii.String("pub-az-4465"),
	RouteTableId: jsii.String("rt-145"),
})

// Supply only subnet id
subnet2 := ec2.Subnet_FromSubnetId(this, jsii.String("SubnetFromId"), jsii.String("s-1234"))

Launch Templates

A Launch Template is a standardized template that contains the configuration information to launch an instance. They can be used when launching instances on their own, through Amazon EC2 Auto Scaling, EC2 Fleet, and Spot Fleet. Launch templates enable you to store launch parameters so that you do not have to specify them every time you launch an instance. For information on Launch Templates please see the official documentation.

The following demonstrates how to create a launch template with an Amazon Machine Image, security group, and an instance profile.

var vpc vpc


role := iam.NewRole(this, jsii.String("Role"), &RoleProps{
	AssumedBy: iam.NewServicePrincipal(jsii.String("ec2.amazonaws.com")),
})
instanceProfile := iam.NewInstanceProfile(this, jsii.String("InstanceProfile"), &InstanceProfileProps{
	Role: Role,
})

template := ec2.NewLaunchTemplate(this, jsii.String("LaunchTemplate"), &LaunchTemplateProps{
	MachineImage: ec2.MachineImage_LatestAmazonLinux2023(),
	SecurityGroup: ec2.NewSecurityGroup(this, jsii.String("LaunchTemplateSG"), &SecurityGroupProps{
		Vpc: vpc,
	}),
	InstanceProfile: InstanceProfile,
})

And the following demonstrates how to enable metadata options support.

ec2.NewLaunchTemplate(this, jsii.String("LaunchTemplate"), &LaunchTemplateProps{
	HttpEndpoint: jsii.Boolean(true),
	HttpProtocolIpv6: jsii.Boolean(true),
	HttpPutResponseHopLimit: jsii.Number(1),
	HttpTokens: ec2.LaunchTemplateHttpTokens_REQUIRED,
	InstanceMetadataTags: jsii.Boolean(true),
})

And the following demonstrates how to add one or more security groups to launch template.

var vpc vpc


sg1 := ec2.NewSecurityGroup(this, jsii.String("sg1"), &SecurityGroupProps{
	Vpc: vpc,
})
sg2 := ec2.NewSecurityGroup(this, jsii.String("sg2"), &SecurityGroupProps{
	Vpc: vpc,
})

launchTemplate := ec2.NewLaunchTemplate(this, jsii.String("LaunchTemplate"), &LaunchTemplateProps{
	MachineImage: ec2.MachineImage_LatestAmazonLinux2023(),
	SecurityGroup: sg1,
})

launchTemplate.AddSecurityGroup(sg2)

To use AWS Systems Manager parameters instead of AMI IDs in launch templates and resolve the AMI IDs at instance launch time:

launchTemplate := ec2.NewLaunchTemplate(this, jsii.String("LaunchTemplate"), &LaunchTemplateProps{
	MachineImage: ec2.MachineImage_ResolveSsmParameterAtLaunch(jsii.String("parameterName")),
})

Detailed Monitoring

The following demonstrates how to enable Detailed Monitoring for an EC2 instance. Keep in mind that Detailed Monitoring results in additional charges.

var vpc vpc
var instanceType instanceType


ec2.NewInstance(this, jsii.String("Instance1"), &InstanceProps{
	Vpc: Vpc,
	InstanceType: InstanceType,
	MachineImage: ec2.MachineImage_LatestAmazonLinux2023(),
	DetailedMonitoring: jsii.Boolean(true),
})

Connecting to your instances using SSM Session Manager

SSM Session Manager makes it possible to connect to your instances from the AWS Console, without preparing SSH keys.

To do so, you need to:

• Use an image with SSM agent installed and configured. Many images come with SSM Agent preinstalled, otherwise you may need to manually put instructions to install SSM Agent into your instance's UserData or use EC2 Init).
• Create the instance with ssmSessionPermissions: true.

If these conditions are met, you can connect to the instance from the EC2 Console. Example:

var vpc vpc
var instanceType instanceType


ec2.NewInstance(this, jsii.String("Instance1"), &InstanceProps{
	Vpc: Vpc,
	InstanceType: InstanceType,

	// Amazon Linux 2023 comes with SSM Agent by default
	MachineImage: ec2.MachineImage_LatestAmazonLinux2023(),

	// Turn on SSM
	SsmSessionPermissions: jsii.Boolean(true),
})

Managed Prefix Lists

Create and manage customer-managed prefix lists. If you don't specify anything in this construct, it will manage IPv4 addresses.

You can also create an empty Prefix List with only the maximum number of entries specified, as shown in the following code. If nothing is specified, maxEntries=1.

ec2.NewPrefixList(this, jsii.String("EmptyPrefixList"), &PrefixListProps{
	MaxEntries: jsii.Number(100),
})

maxEntries can also be omitted as follows. In this case maxEntries: 2, will be set.

ec2.NewPrefixList(this, jsii.String("PrefixList"), &PrefixListProps{
	Entries: []entryProperty{
		&entryProperty{
			Cidr: jsii.String("10.0.0.1/32"),
		},
		&entryProperty{
			Cidr: jsii.String("10.0.0.2/32"),
			Description: jsii.String("sample1"),
		},
	},
})

For more information see Work with customer-managed prefix lists

Documentation

Index

• func AmazonLinux2022ImageSsmParameter_SsmParameterName(props *AmazonLinux2022ImageSsmParameterProps) *string
• func AmazonLinux2023ImageSsmParameter_SsmParameterName(props *AmazonLinux2023ImageSsmParameterProps) *string
• func AmazonLinux2ImageSsmParameter_SsmParameterName(props *AmazonLinux2ImageSsmParameterProps) *string
• func AmazonLinuxImage_SsmParameterName(props *AmazonLinuxImageProps) *string
• func BastionHostLinux_IsConstruct(x interface{}) *bool
• func BastionHostLinux_IsOwnedResource(construct constructs.IConstruct) *bool
• func BastionHostLinux_IsResource(construct constructs.IConstruct) *bool
• func CfnCapacityReservationFleet_CFN_RESOURCE_TYPE_NAME() *string
• func CfnCapacityReservationFleet_IsCfnElement(x interface{}) *bool
• func CfnCapacityReservationFleet_IsCfnResource(construct constructs.IConstruct) *bool
• func CfnCapacityReservationFleet_IsConstruct(x interface{}) *bool
• func CfnCapacityReservation_CFN_RESOURCE_TYPE_NAME() *string
• func CfnCapacityReservation_IsCfnElement(x interface{}) *bool
• func CfnCapacityReservation_IsCfnResource(construct constructs.IConstruct) *bool
• func CfnCapacityReservation_IsConstruct(x interface{}) *bool
• func CfnCarrierGateway_CFN_RESOURCE_TYPE_NAME() *string
• func CfnCarrierGateway_IsCfnElement(x interface{}) *bool
• func CfnCarrierGateway_IsCfnResource(construct constructs.IConstruct) *bool
• func CfnCarrierGateway_IsConstruct(x interface{}) *bool
• func CfnClientVpnAuthorizationRule_CFN_RESOURCE_TYPE_NAME() *string
• func CfnClientVpnAuthorizationRule_IsCfnElement(x interface{}) *bool
• func CfnClientVpnAuthorizationRule_IsCfnResource(construct constructs.IConstruct) *bool
• func CfnClientVpnAuthorizationRule_IsConstruct(x interface{}) *bool
• func CfnClientVpnEndpoint_CFN_RESOURCE_TYPE_NAME() *string
• func CfnClientVpnEndpoint_IsCfnElement(x interface{}) *bool
• func CfnClientVpnEndpoint_IsCfnResource(construct constructs.IConstruct) *bool
• func CfnClientVpnEndpoint_IsConstruct(x interface{}) *bool
• func CfnClientVpnRoute_CFN_RESOURCE_TYPE_NAME() *string
• func CfnClientVpnRoute_IsCfnElement(x interface{}) *bool
• func CfnClientVpnRoute_IsCfnResource(construct constructs.IConstruct) *bool
• func CfnClientVpnRoute_IsConstruct(x interface{}) *bool
• func CfnClientVpnTargetNetworkAssociation_CFN_RESOURCE_TYPE_NAME() *string
• func CfnClientVpnTargetNetworkAssociation_IsCfnElement(x interface{}) *bool
• func CfnClientVpnTargetNetworkAssociation_IsCfnResource(construct constructs.IConstruct) *bool
• func CfnClientVpnTargetNetworkAssociation_IsConstruct(x interface{}) *bool
• func CfnCustomerGateway_CFN_RESOURCE_TYPE_NAME() *string
• func CfnCustomerGateway_IsCfnElement(x interface{}) *bool
• func CfnCustomerGateway_IsCfnResource(construct constructs.IConstruct) *bool
• func CfnCustomerGateway_IsConstruct(x interface{}) *bool
• func CfnDHCPOptions_CFN_RESOURCE_TYPE_NAME() *string
• func CfnDHCPOptions_IsCfnElement(x interface{}) *bool
• func CfnDHCPOptions_IsCfnResource(construct constructs.IConstruct) *bool
• func CfnDHCPOptions_IsConstruct(x interface{}) *bool
• func CfnEC2Fleet_CFN_RESOURCE_TYPE_NAME() *string
• func CfnEC2Fleet_IsCfnElement(x interface{}) *bool
• func CfnEC2Fleet_IsCfnResource(construct constructs.IConstruct) *bool
• func CfnEC2Fleet_IsConstruct(x interface{}) *bool
• func CfnEIPAssociation_CFN_RESOURCE_TYPE_NAME() *string
• func CfnEIPAssociation_IsCfnElement(x interface{}) *bool
• func CfnEIPAssociation_IsCfnResource(construct constructs.IConstruct) *bool
• func CfnEIPAssociation_IsConstruct(x interface{}) *bool
• func CfnEIP_CFN_RESOURCE_TYPE_NAME() *string
• func CfnEIP_IsCfnElement(x interface{}) *bool
• func CfnEIP_IsCfnResource(construct constructs.IConstruct) *bool
• func CfnEIP_IsConstruct(x interface{}) *bool
• func CfnEgressOnlyInternetGateway_CFN_RESOURCE_TYPE_NAME() *string
• func CfnEgressOnlyInternetGateway_IsCfnElement(x interface{}) *bool
• func CfnEgressOnlyInternetGateway_IsCfnResource(construct constructs.IConstruct) *bool
• func CfnEgressOnlyInternetGateway_IsConstruct(x interface{}) *bool
• func CfnEnclaveCertificateIamRoleAssociation_CFN_RESOURCE_TYPE_NAME() *string
• func CfnEnclaveCertificateIamRoleAssociation_IsCfnElement(x interface{}) *bool
• func CfnEnclaveCertificateIamRoleAssociation_IsCfnResource(construct constructs.IConstruct) *bool
• func CfnEnclaveCertificateIamRoleAssociation_IsConstruct(x interface{}) *bool
• func CfnFlowLog_CFN_RESOURCE_TYPE_NAME() *string
• func CfnFlowLog_IsCfnElement(x interface{}) *bool
• func CfnFlowLog_IsCfnResource(construct constructs.IConstruct) *bool
• func CfnFlowLog_IsConstruct(x interface{}) *bool
• func CfnGatewayRouteTableAssociation_CFN_RESOURCE_TYPE_NAME() *string
• func CfnGatewayRouteTableAssociation_IsCfnElement(x interface{}) *bool
• func CfnGatewayRouteTableAssociation_IsCfnResource(construct constructs.IConstruct) *bool
• func CfnGatewayRouteTableAssociation_IsConstruct(x interface{}) *bool
• func CfnHost_CFN_RESOURCE_TYPE_NAME() *string
• func CfnHost_IsCfnElement(x interface{}) *bool
• func CfnHost_IsCfnResource(construct constructs.IConstruct) *bool
• func CfnHost_IsConstruct(x interface{}) *bool
• func CfnIPAMAllocation_CFN_RESOURCE_TYPE_NAME() *string
• func CfnIPAMAllocation_IsCfnElement(x interface{}) *bool
• func CfnIPAMAllocation_IsCfnResource(construct constructs.IConstruct) *bool
• func CfnIPAMAllocation_IsConstruct(x interface{}) *bool
• func CfnIPAMPoolCidr_CFN_RESOURCE_TYPE_NAME() *string
• func CfnIPAMPoolCidr_IsCfnElement(x interface{}) *bool
• func CfnIPAMPoolCidr_IsCfnResource(construct constructs.IConstruct) *bool
• func CfnIPAMPoolCidr_IsConstruct(x interface{}) *bool
• func CfnIPAMPool_CFN_RESOURCE_TYPE_NAME() *string
• func CfnIPAMPool_IsCfnElement(x interface{}) *bool
• func CfnIPAMPool_IsCfnResource(construct constructs.IConstruct) *bool
• func CfnIPAMPool_IsConstruct(x interface{}) *bool
• func CfnIPAMResourceDiscoveryAssociation_CFN_RESOURCE_TYPE_NAME() *string
• func CfnIPAMResourceDiscoveryAssociation_IsCfnElement(x interface{}) *bool
• func CfnIPAMResourceDiscoveryAssociation_IsCfnResource(construct constructs.IConstruct) *bool
• func CfnIPAMResourceDiscoveryAssociation_IsConstruct(x interface{}) *bool
• func CfnIPAMResourceDiscovery_CFN_RESOURCE_TYPE_NAME() *string
• func CfnIPAMResourceDiscovery_IsCfnElement(x interface{}) *bool
• func CfnIPAMResourceDiscovery_IsCfnResource(construct constructs.IConstruct) *bool
• func CfnIPAMResourceDiscovery_IsConstruct(x interface{}) *bool
• func CfnIPAMScope_CFN_RESOURCE_TYPE_NAME() *string
• func CfnIPAMScope_IsCfnElement(x interface{}) *bool
• func CfnIPAMScope_IsCfnResource(construct constructs.IConstruct) *bool
• func CfnIPAMScope_IsConstruct(x interface{}) *bool
• func CfnIPAM_CFN_RESOURCE_TYPE_NAME() *string
• func CfnIPAM_IsCfnElement(x interface{}) *bool
• func CfnIPAM_IsCfnResource(construct constructs.IConstruct) *bool
• func CfnIPAM_IsConstruct(x interface{}) *bool
• func CfnInstanceConnectEndpoint_CFN_RESOURCE_TYPE_NAME() *string
• func CfnInstanceConnectEndpoint_IsCfnElement(x interface{}) *bool
• func CfnInstanceConnectEndpoint_IsCfnResource(construct constructs.IConstruct) *bool
• func CfnInstanceConnectEndpoint_IsConstruct(x interface{}) *bool
• func CfnInstance_CFN_RESOURCE_TYPE_NAME() *string
• func CfnInstance_IsCfnElement(x interface{}) *bool
• func CfnInstance_IsCfnResource(construct constructs.IConstruct) *bool
• func CfnInstance_IsConstruct(x interface{}) *bool
• func CfnInternetGateway_CFN_RESOURCE_TYPE_NAME() *string
• func CfnInternetGateway_IsCfnElement(x interface{}) *bool
• func CfnInternetGateway_IsCfnResource(construct constructs.IConstruct) *bool
• func CfnInternetGateway_IsConstruct(x interface{}) *bool
• func CfnKeyPair_CFN_RESOURCE_TYPE_NAME() *string
• func CfnKeyPair_IsCfnElement(x interface{}) *bool
• func CfnKeyPair_IsCfnResource(construct constructs.IConstruct) *bool
• func CfnKeyPair_IsConstruct(x interface{}) *bool
• func CfnLaunchTemplate_CFN_RESOURCE_TYPE_NAME() *string
• func CfnLaunchTemplate_IsCfnElement(x interface{}) *bool
• func CfnLaunchTemplate_IsCfnResource(construct constructs.IConstruct) *bool
• func CfnLaunchTemplate_IsConstruct(x interface{}) *bool
• func CfnLocalGatewayRouteTableVPCAssociation_CFN_RESOURCE_TYPE_NAME() *string
• func CfnLocalGatewayRouteTableVPCAssociation_IsCfnElement(x interface{}) *bool
• func CfnLocalGatewayRouteTableVPCAssociation_IsCfnResource(construct constructs.IConstruct) *bool
• func CfnLocalGatewayRouteTableVPCAssociation_IsConstruct(x interface{}) *bool
• func CfnLocalGatewayRouteTableVirtualInterfaceGroupAssociation_CFN_RESOURCE_TYPE_NAME() *string
• func CfnLocalGatewayRouteTableVirtualInterfaceGroupAssociation_IsCfnElement(x interface{}) *bool
• func CfnLocalGatewayRouteTableVirtualInterfaceGroupAssociation_IsCfnResource(construct constructs.IConstruct) *bool
• func CfnLocalGatewayRouteTableVirtualInterfaceGroupAssociation_IsConstruct(x interface{}) *bool
• func CfnLocalGatewayRouteTable_CFN_RESOURCE_TYPE_NAME() *string
• func CfnLocalGatewayRouteTable_IsCfnElement(x interface{}) *bool
• func CfnLocalGatewayRouteTable_IsCfnResource(construct constructs.IConstruct) *bool
• func CfnLocalGatewayRouteTable_IsConstruct(x interface{}) *bool
• func CfnLocalGatewayRoute_CFN_RESOURCE_TYPE_NAME() *string
• func CfnLocalGatewayRoute_IsCfnElement(x interface{}) *bool
• func CfnLocalGatewayRoute_IsCfnResource(construct constructs.IConstruct) *bool
• func CfnLocalGatewayRoute_IsConstruct(x interface{}) *bool
• func CfnNatGateway_CFN_RESOURCE_TYPE_NAME() *string
• func CfnNatGateway_IsCfnElement(x interface{}) *bool
• func CfnNatGateway_IsCfnResource(construct constructs.IConstruct) *bool
• func CfnNatGateway_IsConstruct(x interface{}) *bool
• func CfnNetworkAclEntry_CFN_RESOURCE_TYPE_NAME() *string
• func CfnNetworkAclEntry_IsCfnElement(x interface{}) *bool
• func CfnNetworkAclEntry_IsCfnResource(construct constructs.IConstruct) *bool
• func CfnNetworkAclEntry_IsConstruct(x interface{}) *bool
• func CfnNetworkAcl_CFN_RESOURCE_TYPE_NAME() *string
• func CfnNetworkAcl_IsCfnElement(x interface{}) *bool
• func CfnNetworkAcl_IsCfnResource(construct constructs.IConstruct) *bool
• func CfnNetworkAcl_IsConstruct(x interface{}) *bool
• func CfnNetworkInsightsAccessScopeAnalysis_CFN_RESOURCE_TYPE_NAME() *string
• func CfnNetworkInsightsAccessScopeAnalysis_IsCfnElement(x interface{}) *bool
• func CfnNetworkInsightsAccessScopeAnalysis_IsCfnResource(construct constructs.IConstruct) *bool
• func CfnNetworkInsightsAccessScopeAnalysis_IsConstruct(x interface{}) *bool
• func CfnNetworkInsightsAccessScope_CFN_RESOURCE_TYPE_NAME() *string
• func CfnNetworkInsightsAccessScope_IsCfnElement(x interface{}) *bool
• func CfnNetworkInsightsAccessScope_IsCfnResource(construct constructs.IConstruct) *bool
• func CfnNetworkInsightsAccessScope_IsConstruct(x interface{}) *bool
• func CfnNetworkInsightsAnalysis_CFN_RESOURCE_TYPE_NAME() *string
• func CfnNetworkInsightsAnalysis_IsCfnElement(x interface{}) *bool
• func CfnNetworkInsightsAnalysis_IsCfnResource(construct constructs.IConstruct) *bool
• func CfnNetworkInsightsAnalysis_IsConstruct(x interface{}) *bool
• func CfnNetworkInsightsPath_CFN_RESOURCE_TYPE_NAME() *string
• func CfnNetworkInsightsPath_IsCfnElement(x interface{}) *bool
• func CfnNetworkInsightsPath_IsCfnResource(construct constructs.IConstruct) *bool
• func CfnNetworkInsightsPath_IsConstruct(x interface{}) *bool
• func CfnNetworkInterfaceAttachment_CFN_RESOURCE_TYPE_NAME() *string
• func CfnNetworkInterfaceAttachment_IsCfnElement(x interface{}) *bool
• func CfnNetworkInterfaceAttachment_IsCfnResource(construct constructs.IConstruct) *bool
• func CfnNetworkInterfaceAttachment_IsConstruct(x interface{}) *bool
• func CfnNetworkInterfacePermission_CFN_RESOURCE_TYPE_NAME() *string
• func CfnNetworkInterfacePermission_IsCfnElement(x interface{}) *bool
• func CfnNetworkInterfacePermission_IsCfnResource(construct constructs.IConstruct) *bool
• func CfnNetworkInterfacePermission_IsConstruct(x interface{}) *bool
• func CfnNetworkInterface_CFN_RESOURCE_TYPE_NAME() *string
• func CfnNetworkInterface_IsCfnElement(x interface{}) *bool
• func CfnNetworkInterface_IsCfnResource(construct constructs.IConstruct) *bool
• func CfnNetworkInterface_IsConstruct(x interface{}) *bool
• func CfnNetworkPerformanceMetricSubscription_CFN_RESOURCE_TYPE_NAME() *string
• func CfnNetworkPerformanceMetricSubscription_IsCfnElement(x interface{}) *bool
• func CfnNetworkPerformanceMetricSubscription_IsCfnResource(construct constructs.IConstruct) *bool
• func CfnNetworkPerformanceMetricSubscription_IsConstruct(x interface{}) *bool
• func CfnPlacementGroup_CFN_RESOURCE_TYPE_NAME() *string
• func CfnPlacementGroup_IsCfnElement(x interface{}) *bool
• func CfnPlacementGroup_IsCfnResource(construct constructs.IConstruct) *bool
• func CfnPlacementGroup_IsConstruct(x interface{}) *bool
• func CfnPrefixList_CFN_RESOURCE_TYPE_NAME() *string
• func CfnPrefixList_IsCfnElement(x interface{}) *bool
• func CfnPrefixList_IsCfnResource(construct constructs.IConstruct) *bool
• func CfnPrefixList_IsConstruct(x interface{}) *bool
• func CfnRouteTable_CFN_RESOURCE_TYPE_NAME() *string
• func CfnRouteTable_IsCfnElement(x interface{}) *bool
• func CfnRouteTable_IsCfnResource(construct constructs.IConstruct) *bool
• func CfnRouteTable_IsConstruct(x interface{}) *bool
• func CfnRoute_CFN_RESOURCE_TYPE_NAME() *string
• func CfnRoute_IsCfnElement(x interface{}) *bool
• func CfnRoute_IsCfnResource(construct constructs.IConstruct) *bool
• func CfnRoute_IsConstruct(x interface{}) *bool
• func CfnSecurityGroupEgress_CFN_RESOURCE_TYPE_NAME() *string
• func CfnSecurityGroupEgress_IsCfnElement(x interface{}) *bool
• func CfnSecurityGroupEgress_IsCfnResource(construct constructs.IConstruct) *bool
• func CfnSecurityGroupEgress_IsConstruct(x interface{}) *bool
• func CfnSecurityGroupIngress_CFN_RESOURCE_TYPE_NAME() *string
• func CfnSecurityGroupIngress_IsCfnElement(x interface{}) *bool
• func CfnSecurityGroupIngress_IsCfnResource(construct constructs.IConstruct) *bool
• func CfnSecurityGroupIngress_IsConstruct(x interface{}) *bool
• func CfnSecurityGroup_CFN_RESOURCE_TYPE_NAME() *string
• func CfnSecurityGroup_IsCfnElement(x interface{}) *bool
• func CfnSecurityGroup_IsCfnResource(construct constructs.IConstruct) *bool
• func CfnSecurityGroup_IsConstruct(x interface{}) *bool
• func CfnSpotFleet_CFN_RESOURCE_TYPE_NAME() *string
• func CfnSpotFleet_IsCfnElement(x interface{}) *bool
• func CfnSpotFleet_IsCfnResource(construct constructs.IConstruct) *bool
• func CfnSpotFleet_IsConstruct(x interface{}) *bool
• func CfnSubnetCidrBlock_CFN_RESOURCE_TYPE_NAME() *string
• func CfnSubnetCidrBlock_IsCfnElement(x interface{}) *bool
• func CfnSubnetCidrBlock_IsCfnResource(construct constructs.IConstruct) *bool
• func CfnSubnetCidrBlock_IsConstruct(x interface{}) *bool
• func CfnSubnetNetworkAclAssociation_CFN_RESOURCE_TYPE_NAME() *string
• func CfnSubnetNetworkAclAssociation_IsCfnElement(x interface{}) *bool
• func CfnSubnetNetworkAclAssociation_IsCfnResource(construct constructs.IConstruct) *bool
• func CfnSubnetNetworkAclAssociation_IsConstruct(x interface{}) *bool
• func CfnSubnetRouteTableAssociation_CFN_RESOURCE_TYPE_NAME() *string
• func CfnSubnetRouteTableAssociation_IsCfnElement(x interface{}) *bool
• func CfnSubnetRouteTableAssociation_IsCfnResource(construct constructs.IConstruct) *bool
• func CfnSubnetRouteTableAssociation_IsConstruct(x interface{}) *bool
• func CfnSubnet_CFN_RESOURCE_TYPE_NAME() *string
• func CfnSubnet_IsCfnElement(x interface{}) *bool
• func CfnSubnet_IsCfnResource(construct constructs.IConstruct) *bool
• func CfnSubnet_IsConstruct(x interface{}) *bool
• func CfnTrafficMirrorFilterRule_CFN_RESOURCE_TYPE_NAME() *string
• func CfnTrafficMirrorFilterRule_IsCfnElement(x interface{}) *bool
• func CfnTrafficMirrorFilterRule_IsCfnResource(construct constructs.IConstruct) *bool
• func CfnTrafficMirrorFilterRule_IsConstruct(x interface{}) *bool
• func CfnTrafficMirrorFilter_CFN_RESOURCE_TYPE_NAME() *string
• func CfnTrafficMirrorFilter_IsCfnElement(x interface{}) *bool
• func CfnTrafficMirrorFilter_IsCfnResource(construct constructs.IConstruct) *bool
• func CfnTrafficMirrorFilter_IsConstruct(x interface{}) *bool
• func CfnTrafficMirrorSession_CFN_RESOURCE_TYPE_NAME() *string
• func CfnTrafficMirrorSession_IsCfnElement(x interface{}) *bool
• func CfnTrafficMirrorSession_IsCfnResource(construct constructs.IConstruct) *bool
• func CfnTrafficMirrorSession_IsConstruct(x interface{}) *bool
• func CfnTrafficMirrorTarget_CFN_RESOURCE_TYPE_NAME() *string
• func CfnTrafficMirrorTarget_IsCfnElement(x interface{}) *bool
• func CfnTrafficMirrorTarget_IsCfnResource(construct constructs.IConstruct) *bool
• func CfnTrafficMirrorTarget_IsConstruct(x interface{}) *bool
• func CfnTransitGatewayAttachment_CFN_RESOURCE_TYPE_NAME() *string
• func CfnTransitGatewayAttachment_IsCfnElement(x interface{}) *bool
• func CfnTransitGatewayAttachment_IsCfnResource(construct constructs.IConstruct) *bool
• func CfnTransitGatewayAttachment_IsConstruct(x interface{}) *bool
• func CfnTransitGatewayConnect_CFN_RESOURCE_TYPE_NAME() *string
• func CfnTransitGatewayConnect_IsCfnElement(x interface{}) *bool
• func CfnTransitGatewayConnect_IsCfnResource(construct constructs.IConstruct) *bool
• func CfnTransitGatewayConnect_IsConstruct(x interface{}) *bool
• func CfnTransitGatewayMulticastDomainAssociation_CFN_RESOURCE_TYPE_NAME() *string
• func CfnTransitGatewayMulticastDomainAssociation_IsCfnElement(x interface{}) *bool
• func CfnTransitGatewayMulticastDomainAssociation_IsCfnResource(construct constructs.IConstruct) *bool
• func CfnTransitGatewayMulticastDomainAssociation_IsConstruct(x interface{}) *bool
• func CfnTransitGatewayMulticastDomain_CFN_RESOURCE_TYPE_NAME() *string
• func CfnTransitGatewayMulticastDomain_IsCfnElement(x interface{}) *bool
• func CfnTransitGatewayMulticastDomain_IsCfnResource(construct constructs.IConstruct) *bool
• func CfnTransitGatewayMulticastDomain_IsConstruct(x interface{}) *bool
• func CfnTransitGatewayMulticastGroupMember_CFN_RESOURCE_TYPE_NAME() *string
• func CfnTransitGatewayMulticastGroupMember_IsCfnElement(x interface{}) *bool
• func CfnTransitGatewayMulticastGroupMember_IsCfnResource(construct constructs.IConstruct) *bool
• func CfnTransitGatewayMulticastGroupMember_IsConstruct(x interface{}) *bool
• func CfnTransitGatewayMulticastGroupSource_CFN_RESOURCE_TYPE_NAME() *string
• func CfnTransitGatewayMulticastGroupSource_IsCfnElement(x interface{}) *bool
• func CfnTransitGatewayMulticastGroupSource_IsCfnResource(construct constructs.IConstruct) *bool
• func CfnTransitGatewayMulticastGroupSource_IsConstruct(x interface{}) *bool
• func CfnTransitGatewayPeeringAttachment_CFN_RESOURCE_TYPE_NAME() *string
• func CfnTransitGatewayPeeringAttachment_IsCfnElement(x interface{}) *bool
• func CfnTransitGatewayPeeringAttachment_IsCfnResource(construct constructs.IConstruct) *bool
• func CfnTransitGatewayPeeringAttachment_IsConstruct(x interface{}) *bool
• func CfnTransitGatewayRouteTableAssociation_CFN_RESOURCE_TYPE_NAME() *string
• func CfnTransitGatewayRouteTableAssociation_IsCfnElement(x interface{}) *bool
• func CfnTransitGatewayRouteTableAssociation_IsCfnResource(construct constructs.IConstruct) *bool
• func CfnTransitGatewayRouteTableAssociation_IsConstruct(x interface{}) *bool
• func CfnTransitGatewayRouteTablePropagation_CFN_RESOURCE_TYPE_NAME() *string
• func CfnTransitGatewayRouteTablePropagation_IsCfnElement(x interface{}) *bool
• func CfnTransitGatewayRouteTablePropagation_IsCfnResource(construct constructs.IConstruct) *bool
• func CfnTransitGatewayRouteTablePropagation_IsConstruct(x interface{}) *bool
• func CfnTransitGatewayRouteTable_CFN_RESOURCE_TYPE_NAME() *string
• func CfnTransitGatewayRouteTable_IsCfnElement(x interface{}) *bool
• func CfnTransitGatewayRouteTable_IsCfnResource(construct constructs.IConstruct) *bool
• func CfnTransitGatewayRouteTable_IsConstruct(x interface{}) *bool
• func CfnTransitGatewayRoute_CFN_RESOURCE_TYPE_NAME() *string
• func CfnTransitGatewayRoute_IsCfnElement(x interface{}) *bool
• func CfnTransitGatewayRoute_IsCfnResource(construct constructs.IConstruct) *bool
• func CfnTransitGatewayRoute_IsConstruct(x interface{}) *bool
• func CfnTransitGatewayVpcAttachment_CFN_RESOURCE_TYPE_NAME() *string
• func CfnTransitGatewayVpcAttachment_IsCfnElement(x interface{}) *bool
• func CfnTransitGatewayVpcAttachment_IsCfnResource(construct constructs.IConstruct) *bool
• func CfnTransitGatewayVpcAttachment_IsConstruct(x interface{}) *bool
• func CfnTransitGateway_CFN_RESOURCE_TYPE_NAME() *string
• func CfnTransitGateway_IsCfnElement(x interface{}) *bool
• func CfnTransitGateway_IsCfnResource(construct constructs.IConstruct) *bool
• func CfnTransitGateway_IsConstruct(x interface{}) *bool
• func CfnVPCCidrBlock_CFN_RESOURCE_TYPE_NAME() *string
• func CfnVPCCidrBlock_IsCfnElement(x interface{}) *bool
• func CfnVPCCidrBlock_IsCfnResource(construct constructs.IConstruct) *bool
• func CfnVPCCidrBlock_IsConstruct(x interface{}) *bool
• func CfnVPCDHCPOptionsAssociation_CFN_RESOURCE_TYPE_NAME() *string
• func CfnVPCDHCPOptionsAssociation_IsCfnElement(x interface{}) *bool
• func CfnVPCDHCPOptionsAssociation_IsCfnResource(construct constructs.IConstruct) *bool
• func CfnVPCDHCPOptionsAssociation_IsConstruct(x interface{}) *bool
• func CfnVPCEndpointConnectionNotification_CFN_RESOURCE_TYPE_NAME() *string
• func CfnVPCEndpointConnectionNotification_IsCfnElement(x interface{}) *bool
• func CfnVPCEndpointConnectionNotification_IsCfnResource(construct constructs.IConstruct) *bool
• func CfnVPCEndpointConnectionNotification_IsConstruct(x interface{}) *bool
• func CfnVPCEndpointServicePermissions_CFN_RESOURCE_TYPE_NAME() *string
• func CfnVPCEndpointServicePermissions_IsCfnElement(x interface{}) *bool
• func CfnVPCEndpointServicePermissions_IsCfnResource(construct constructs.IConstruct) *bool
• func CfnVPCEndpointServicePermissions_IsConstruct(x interface{}) *bool
• func CfnVPCEndpointService_CFN_RESOURCE_TYPE_NAME() *string
• func CfnVPCEndpointService_IsCfnElement(x interface{}) *bool
• func CfnVPCEndpointService_IsCfnResource(construct constructs.IConstruct) *bool
• func CfnVPCEndpointService_IsConstruct(x interface{}) *bool
• func CfnVPCEndpoint_CFN_RESOURCE_TYPE_NAME() *string
• func CfnVPCEndpoint_IsCfnElement(x interface{}) *bool
• func CfnVPCEndpoint_IsCfnResource(construct constructs.IConstruct) *bool
• func CfnVPCEndpoint_IsConstruct(x interface{}) *bool
• func CfnVPCGatewayAttachment_CFN_RESOURCE_TYPE_NAME() *string
• func CfnVPCGatewayAttachment_IsCfnElement(x interface{}) *bool
• func CfnVPCGatewayAttachment_IsCfnResource(construct constructs.IConstruct) *bool
• func CfnVPCGatewayAttachment_IsConstruct(x interface{}) *bool
• func CfnVPCPeeringConnection_CFN_RESOURCE_TYPE_NAME() *string
• func CfnVPCPeeringConnection_IsCfnElement(x interface{}) *bool
• func CfnVPCPeeringConnection_IsCfnResource(construct constructs.IConstruct) *bool
• func CfnVPCPeeringConnection_IsConstruct(x interface{}) *bool
• func CfnVPC_CFN_RESOURCE_TYPE_NAME() *string
• func CfnVPC_IsCfnElement(x interface{}) *bool
• func CfnVPC_IsCfnResource(construct constructs.IConstruct) *bool
• func CfnVPC_IsConstruct(x interface{}) *bool
• func CfnVPNConnectionRoute_CFN_RESOURCE_TYPE_NAME() *string
• func CfnVPNConnectionRoute_IsCfnElement(x interface{}) *bool
• func CfnVPNConnectionRoute_IsCfnResource(construct constructs.IConstruct) *bool
• func CfnVPNConnectionRoute_IsConstruct(x interface{}) *bool
• func CfnVPNConnection_CFN_RESOURCE_TYPE_NAME() *string
• func CfnVPNConnection_IsCfnElement(x interface{}) *bool
• func CfnVPNConnection_IsCfnResource(construct constructs.IConstruct) *bool
• func CfnVPNConnection_IsConstruct(x interface{}) *bool
• func CfnVPNGatewayRoutePropagation_CFN_RESOURCE_TYPE_NAME() *string
• func CfnVPNGatewayRoutePropagation_IsCfnElement(x interface{}) *bool
• func CfnVPNGatewayRoutePropagation_IsCfnResource(construct constructs.IConstruct) *bool
• func CfnVPNGatewayRoutePropagation_IsConstruct(x interface{}) *bool
• func CfnVPNGateway_CFN_RESOURCE_TYPE_NAME() *string
• func CfnVPNGateway_IsCfnElement(x interface{}) *bool
• func CfnVPNGateway_IsCfnResource(construct constructs.IConstruct) *bool
• func CfnVPNGateway_IsConstruct(x interface{}) *bool
• func CfnVerifiedAccessEndpoint_CFN_RESOURCE_TYPE_NAME() *string
• func CfnVerifiedAccessEndpoint_IsCfnElement(x interface{}) *bool
• func CfnVerifiedAccessEndpoint_IsCfnResource(construct constructs.IConstruct) *bool
• func CfnVerifiedAccessEndpoint_IsConstruct(x interface{}) *bool
• func CfnVerifiedAccessGroup_CFN_RESOURCE_TYPE_NAME() *string
• func CfnVerifiedAccessGroup_IsCfnElement(x interface{}) *bool
• func CfnVerifiedAccessGroup_IsCfnResource(construct constructs.IConstruct) *bool
• func CfnVerifiedAccessGroup_IsConstruct(x interface{}) *bool
• func CfnVerifiedAccessInstance_CFN_RESOURCE_TYPE_NAME() *string
• func CfnVerifiedAccessInstance_IsCfnElement(x interface{}) *bool
• func CfnVerifiedAccessInstance_IsCfnResource(construct constructs.IConstruct) *bool
• func CfnVerifiedAccessInstance_IsConstruct(x interface{}) *bool
• func CfnVerifiedAccessTrustProvider_CFN_RESOURCE_TYPE_NAME() *string
• func CfnVerifiedAccessTrustProvider_IsCfnElement(x interface{}) *bool
• func CfnVerifiedAccessTrustProvider_IsCfnResource(construct constructs.IConstruct) *bool
• func CfnVerifiedAccessTrustProvider_IsConstruct(x interface{}) *bool
• func CfnVolumeAttachment_CFN_RESOURCE_TYPE_NAME() *string
• func CfnVolumeAttachment_IsCfnElement(x interface{}) *bool
• func CfnVolumeAttachment_IsCfnResource(construct constructs.IConstruct) *bool
• func CfnVolumeAttachment_IsConstruct(x interface{}) *bool
• func CfnVolume_CFN_RESOURCE_TYPE_NAME() *string
• func CfnVolume_IsCfnElement(x interface{}) *bool
• func CfnVolume_IsCfnResource(construct constructs.IConstruct) *bool
• func CfnVolume_IsConstruct(x interface{}) *bool
• func ClientVpnAuthorizationRule_IsConstruct(x interface{}) *bool
• func ClientVpnAuthorizationRule_IsOwnedResource(construct constructs.IConstruct) *bool
• func ClientVpnAuthorizationRule_IsResource(construct constructs.IConstruct) *bool
• func ClientVpnEndpoint_IsConstruct(x interface{}) *bool
• func ClientVpnEndpoint_IsOwnedResource(construct constructs.IConstruct) *bool
• func ClientVpnEndpoint_IsResource(construct constructs.IConstruct) *bool
• func ClientVpnRoute_IsConstruct(x interface{}) *bool
• func ClientVpnRoute_IsOwnedResource(construct constructs.IConstruct) *bool
• func ClientVpnRoute_IsResource(construct constructs.IConstruct) *bool
• func FlowLog_IsConstruct(x interface{}) *bool
• func FlowLog_IsOwnedResource(construct constructs.IConstruct) *bool
• func FlowLog_IsResource(construct constructs.IConstruct) *bool
• func GatewayVpcEndpoint_IsConstruct(x interface{}) *bool
• func GatewayVpcEndpoint_IsOwnedResource(construct constructs.IConstruct) *bool
• func GatewayVpcEndpoint_IsResource(construct constructs.IConstruct) *bool
• func Instance_IsConstruct(x interface{}) *bool
• func Instance_IsOwnedResource(construct constructs.IConstruct) *bool
• func Instance_IsResource(construct constructs.IConstruct) *bool
• func InterfaceVpcEndpoint_IsConstruct(x interface{}) *bool
• func InterfaceVpcEndpoint_IsOwnedResource(construct constructs.IConstruct) *bool
• func InterfaceVpcEndpoint_IsResource(construct constructs.IConstruct) *bool
• func LaunchTemplateSpecialVersions_DEFAULT_VERSION() *string
• func LaunchTemplateSpecialVersions_LATEST_VERSION() *string
• func LaunchTemplate_IsConstruct(x interface{}) *bool
• func LaunchTemplate_IsOwnedResource(construct constructs.IConstruct) *bool
• func LaunchTemplate_IsResource(construct constructs.IConstruct) *bool
• func MultipartBody_CLOUD_BOOTHOOK() *string
• func MultipartBody_SHELL_SCRIPT() *string
• func NetworkAclEntry_IsConstruct(x interface{}) *bool
• func NetworkAclEntry_IsOwnedResource(construct constructs.IConstruct) *bool
• func NetworkAclEntry_IsResource(construct constructs.IConstruct) *bool
• func NetworkAcl_IsConstruct(x interface{}) *bool
• func NetworkAcl_IsOwnedResource(construct constructs.IConstruct) *bool
• func NetworkAcl_IsResource(construct constructs.IConstruct) *bool
• func NewAclCidr_Override(a AclCidr)
• func NewAclTraffic_Override(a AclTraffic)
• func NewAmazonLinux2022ImageSsmParameter_Override(a AmazonLinux2022ImageSsmParameter, ...)
• func NewAmazonLinux2022Kernel_Override(a AmazonLinux2022Kernel, version *string)
• func NewAmazonLinux2023ImageSsmParameter_Override(a AmazonLinux2023ImageSsmParameter, ...)
• func NewAmazonLinux2023Kernel_Override(a AmazonLinux2023Kernel, version *string)
• func NewAmazonLinux2ImageSsmParameter_Override(a AmazonLinux2ImageSsmParameter, props *AmazonLinux2ImageSsmParameterProps)
• func NewAmazonLinux2Kernel_Override(a AmazonLinux2Kernel, version *string)
• func NewAmazonLinuxImageSsmParameterBase_Override(a AmazonLinuxImageSsmParameterBase, ...)
• func NewAmazonLinuxImage_Override(a AmazonLinuxImage, props *AmazonLinuxImageProps)
• func NewBastionHostLinux_Override(b BastionHostLinux, scope constructs.Construct, id *string, ...)
• func NewBlockDeviceVolume_Override(b BlockDeviceVolume, ebsDevice *EbsDeviceProps, virtualName *string)
• func NewCfnCapacityReservationFleet_Override(c CfnCapacityReservationFleet, scope constructs.Construct, id *string, ...)
• func NewCfnCapacityReservation_Override(c CfnCapacityReservation, scope constructs.Construct, id *string, ...)
• func NewCfnCarrierGateway_Override(c CfnCarrierGateway, scope constructs.Construct, id *string, ...)
• func NewCfnClientVpnAuthorizationRule_Override(c CfnClientVpnAuthorizationRule, scope constructs.Construct, id *string, ...)
• func NewCfnClientVpnEndpoint_Override(c CfnClientVpnEndpoint, scope constructs.Construct, id *string, ...)
• func NewCfnClientVpnRoute_Override(c CfnClientVpnRoute, scope constructs.Construct, id *string, ...)
• func NewCfnClientVpnTargetNetworkAssociation_Override(c CfnClientVpnTargetNetworkAssociation, scope constructs.Construct, id *string, ...)
• func NewCfnCustomerGateway_Override(c CfnCustomerGateway, scope constructs.Construct, id *string, ...)
• func NewCfnDHCPOptions_Override(c CfnDHCPOptions, scope constructs.Construct, id *string, ...)
• func NewCfnEC2Fleet_Override(c CfnEC2Fleet, scope constructs.Construct, id *string, props *CfnEC2FleetProps)
• func NewCfnEIPAssociation_Override(c CfnEIPAssociation, scope constructs.Construct, id *string, ...)
• func NewCfnEIP_Override(c CfnEIP, scope constructs.Construct, id *string, props *CfnEIPProps)
• func NewCfnEgressOnlyInternetGateway_Override(c CfnEgressOnlyInternetGateway, scope constructs.Construct, id *string, ...)
• func NewCfnEnclaveCertificateIamRoleAssociation_Override(c CfnEnclaveCertificateIamRoleAssociation, scope constructs.Construct, ...)
• func NewCfnFlowLog_Override(c CfnFlowLog, scope constructs.Construct, id *string, props *CfnFlowLogProps)
• func NewCfnGatewayRouteTableAssociation_Override(c CfnGatewayRouteTableAssociation, scope constructs.Construct, id *string, ...)
• func NewCfnHost_Override(c CfnHost, scope constructs.Construct, id *string, props *CfnHostProps)
• func NewCfnIPAMAllocation_Override(c CfnIPAMAllocation, scope constructs.Construct, id *string, ...)
• func NewCfnIPAMPoolCidr_Override(c CfnIPAMPoolCidr, scope constructs.Construct, id *string, ...)
• func NewCfnIPAMPool_Override(c CfnIPAMPool, scope constructs.Construct, id *string, props *CfnIPAMPoolProps)
• func NewCfnIPAMResourceDiscoveryAssociation_Override(c CfnIPAMResourceDiscoveryAssociation, scope constructs.Construct, id *string, ...)
• func NewCfnIPAMResourceDiscovery_Override(c CfnIPAMResourceDiscovery, scope constructs.Construct, id *string, ...)
• func NewCfnIPAMScope_Override(c CfnIPAMScope, scope constructs.Construct, id *string, ...)
• func NewCfnIPAM_Override(c CfnIPAM, scope constructs.Construct, id *string, props *CfnIPAMProps)
• func NewCfnInstanceConnectEndpoint_Override(c CfnInstanceConnectEndpoint, scope constructs.Construct, id *string, ...)
• func NewCfnInstance_Override(c CfnInstance, scope constructs.Construct, id *string, props *CfnInstanceProps)
• func NewCfnInternetGateway_Override(c CfnInternetGateway, scope constructs.Construct, id *string, ...)
• func NewCfnKeyPair_Override(c CfnKeyPair, scope constructs.Construct, id *string, props *CfnKeyPairProps)
• func NewCfnLaunchTemplate_Override(c CfnLaunchTemplate, scope constructs.Construct, id *string, ...)
• func NewCfnLocalGatewayRouteTableVPCAssociation_Override(c CfnLocalGatewayRouteTableVPCAssociation, scope constructs.Construct, ...)
• func NewCfnLocalGatewayRouteTableVirtualInterfaceGroupAssociation_Override(c CfnLocalGatewayRouteTableVirtualInterfaceGroupAssociation, ...)
• func NewCfnLocalGatewayRouteTable_Override(c CfnLocalGatewayRouteTable, scope constructs.Construct, id *string, ...)
• func NewCfnLocalGatewayRoute_Override(c CfnLocalGatewayRoute, scope constructs.Construct, id *string, ...)
• func NewCfnNatGateway_Override(c CfnNatGateway, scope constructs.Construct, id *string, ...)
• func NewCfnNetworkAclEntry_Override(c CfnNetworkAclEntry, scope constructs.Construct, id *string, ...)
• func NewCfnNetworkAcl_Override(c CfnNetworkAcl, scope constructs.Construct, id *string, ...)
• func NewCfnNetworkInsightsAccessScopeAnalysis_Override(c CfnNetworkInsightsAccessScopeAnalysis, scope constructs.Construct, ...)
• func NewCfnNetworkInsightsAccessScope_Override(c CfnNetworkInsightsAccessScope, scope constructs.Construct, id *string, ...)
• func NewCfnNetworkInsightsAnalysis_Override(c CfnNetworkInsightsAnalysis, scope constructs.Construct, id *string, ...)
• func NewCfnNetworkInsightsPath_Override(c CfnNetworkInsightsPath, scope constructs.Construct, id *string, ...)
• func NewCfnNetworkInterfaceAttachment_Override(c CfnNetworkInterfaceAttachment, scope constructs.Construct, id *string, ...)
• func NewCfnNetworkInterfacePermission_Override(c CfnNetworkInterfacePermission, scope constructs.Construct, id *string, ...)
• func NewCfnNetworkInterface_Override(c CfnNetworkInterface, scope constructs.Construct, id *string, ...)
• func NewCfnNetworkPerformanceMetricSubscription_Override(c CfnNetworkPerformanceMetricSubscription, scope constructs.Construct, ...)
• func NewCfnPlacementGroup_Override(c CfnPlacementGroup, scope constructs.Construct, id *string, ...)
• func NewCfnPrefixList_Override(c CfnPrefixList, scope constructs.Construct, id *string, ...)
• func NewCfnRouteTable_Override(c CfnRouteTable, scope constructs.Construct, id *string, ...)
• func NewCfnRoute_Override(c CfnRoute, scope constructs.Construct, id *string, props *CfnRouteProps)
• func NewCfnSecurityGroupEgress_Override(c CfnSecurityGroupEgress, scope constructs.Construct, id *string, ...)
• func NewCfnSecurityGroupIngress_Override(c CfnSecurityGroupIngress, scope constructs.Construct, id *string, ...)
• func NewCfnSecurityGroup_Override(c CfnSecurityGroup, scope constructs.Construct, id *string, ...)
• func NewCfnSpotFleet_Override(c CfnSpotFleet, scope constructs.Construct, id *string, ...)
• func NewCfnSubnetCidrBlock_Override(c CfnSubnetCidrBlock, scope constructs.Construct, id *string, ...)
• func NewCfnSubnetNetworkAclAssociation_Override(c CfnSubnetNetworkAclAssociation, scope constructs.Construct, id *string, ...)
• func NewCfnSubnetRouteTableAssociation_Override(c CfnSubnetRouteTableAssociation, scope constructs.Construct, id *string, ...)
• func NewCfnSubnet_Override(c CfnSubnet, scope constructs.Construct, id *string, props *CfnSubnetProps)
• func NewCfnTrafficMirrorFilterRule_Override(c CfnTrafficMirrorFilterRule, scope constructs.Construct, id *string, ...)
• func NewCfnTrafficMirrorFilter_Override(c CfnTrafficMirrorFilter, scope constructs.Construct, id *string, ...)
• func NewCfnTrafficMirrorSession_Override(c CfnTrafficMirrorSession, scope constructs.Construct, id *string, ...)
• func NewCfnTrafficMirrorTarget_Override(c CfnTrafficMirrorTarget, scope constructs.Construct, id *string, ...)
• func NewCfnTransitGatewayAttachment_Override(c CfnTransitGatewayAttachment, scope constructs.Construct, id *string, ...)
• func NewCfnTransitGatewayConnect_Override(c CfnTransitGatewayConnect, scope constructs.Construct, id *string, ...)
• func NewCfnTransitGatewayMulticastDomainAssociation_Override(c CfnTransitGatewayMulticastDomainAssociation, scope constructs.Construct, ...)
• func NewCfnTransitGatewayMulticastDomain_Override(c CfnTransitGatewayMulticastDomain, scope constructs.Construct, id *string, ...)
• func NewCfnTransitGatewayMulticastGroupMember_Override(c CfnTransitGatewayMulticastGroupMember, scope constructs.Construct, ...)
• func NewCfnTransitGatewayMulticastGroupSource_Override(c CfnTransitGatewayMulticastGroupSource, scope constructs.Construct, ...)
• func NewCfnTransitGatewayPeeringAttachment_Override(c CfnTransitGatewayPeeringAttachment, scope constructs.Construct, id *string, ...)
• func NewCfnTransitGatewayRouteTableAssociation_Override(c CfnTransitGatewayRouteTableAssociation, scope constructs.Construct, ...)
• func NewCfnTransitGatewayRouteTablePropagation_Override(c CfnTransitGatewayRouteTablePropagation, scope constructs.Construct, ...)
• func NewCfnTransitGatewayRouteTable_Override(c CfnTransitGatewayRouteTable, scope constructs.Construct, id *string, ...)
• func NewCfnTransitGatewayRoute_Override(c CfnTransitGatewayRoute, scope constructs.Construct, id *string, ...)
• func NewCfnTransitGatewayVpcAttachment_Override(c CfnTransitGatewayVpcAttachment, scope constructs.Construct, id *string, ...)
• func NewCfnTransitGateway_Override(c CfnTransitGateway, scope constructs.Construct, id *string, ...)
• func NewCfnVPCCidrBlock_Override(c CfnVPCCidrBlock, scope constructs.Construct, id *string, ...)
• func NewCfnVPCDHCPOptionsAssociation_Override(c CfnVPCDHCPOptionsAssociation, scope constructs.Construct, id *string, ...)
• func NewCfnVPCEndpointConnectionNotification_Override(c CfnVPCEndpointConnectionNotification, scope constructs.Construct, id *string, ...)
• func NewCfnVPCEndpointServicePermissions_Override(c CfnVPCEndpointServicePermissions, scope constructs.Construct, id *string, ...)
• func NewCfnVPCEndpointService_Override(c CfnVPCEndpointService, scope constructs.Construct, id *string, ...)
• func NewCfnVPCEndpoint_Override(c CfnVPCEndpoint, scope constructs.Construct, id *string, ...)
• func NewCfnVPCGatewayAttachment_Override(c CfnVPCGatewayAttachment, scope constructs.Construct, id *string, ...)
• func NewCfnVPCPeeringConnection_Override(c CfnVPCPeeringConnection, scope constructs.Construct, id *string, ...)
• func NewCfnVPC_Override(c CfnVPC, scope constructs.Construct, id *string, props *CfnVPCProps)
• func NewCfnVPNConnectionRoute_Override(c CfnVPNConnectionRoute, scope constructs.Construct, id *string, ...)
• func NewCfnVPNConnection_Override(c CfnVPNConnection, scope constructs.Construct, id *string, ...)
• func NewCfnVPNGatewayRoutePropagation_Override(c CfnVPNGatewayRoutePropagation, scope constructs.Construct, id *string, ...)
• func NewCfnVPNGateway_Override(c CfnVPNGateway, scope constructs.Construct, id *string, ...)
• func NewCfnVerifiedAccessEndpoint_Override(c CfnVerifiedAccessEndpoint, scope constructs.Construct, id *string, ...)
• func NewCfnVerifiedAccessGroup_Override(c CfnVerifiedAccessGroup, scope constructs.Construct, id *string, ...)
• func NewCfnVerifiedAccessInstance_Override(c CfnVerifiedAccessInstance, scope constructs.Construct, id *string, ...)
• func NewCfnVerifiedAccessTrustProvider_Override(c CfnVerifiedAccessTrustProvider, scope constructs.Construct, id *string, ...)
• func NewCfnVolumeAttachment_Override(c CfnVolumeAttachment, scope constructs.Construct, id *string, ...)
• func NewCfnVolume_Override(c CfnVolume, scope constructs.Construct, id *string, props *CfnVolumeProps)
• func NewClientVpnAuthorizationRule_Override(c ClientVpnAuthorizationRule, scope constructs.Construct, id *string, ...)
• func NewClientVpnEndpoint_Override(c ClientVpnEndpoint, scope constructs.Construct, id *string, ...)
• func NewClientVpnRouteTarget_Override(c ClientVpnRouteTarget)
• func NewClientVpnRoute_Override(c ClientVpnRoute, scope constructs.Construct, id *string, ...)
• func NewClientVpnUserBasedAuthentication_Override(c ClientVpnUserBasedAuthentication)
• func NewConnections_Override(c Connections, props *ConnectionsProps)
• func NewFlowLogDestination_Override(f FlowLogDestination)
• func NewFlowLogResourceType_Override(f FlowLogResourceType)
• func NewFlowLog_Override(f FlowLog, scope constructs.Construct, id *string, props *FlowLogProps)
• func NewGatewayVpcEndpointAwsService_Override(g GatewayVpcEndpointAwsService, name *string, prefix *string)
• func NewGatewayVpcEndpoint_Override(g GatewayVpcEndpoint, scope constructs.Construct, id *string, ...)
• func NewGenericLinuxImage_Override(g GenericLinuxImage, amiMap *map[string]*string, props *GenericLinuxImageProps)
• func NewGenericSSMParameterImage_Override(g GenericSSMParameterImage, parameterName *string, os OperatingSystemType, ...)
• func NewGenericWindowsImage_Override(g GenericWindowsImage, amiMap *map[string]*string, ...)
• func NewInitCommandWaitDuration_Override(i InitCommandWaitDuration)
• func NewInitConfig_Override(i InitConfig, elements *[]InitElement)
• func NewInitElement_Override(i InitElement)
• func NewInitFile_Override(i InitFile, fileName *string, options *InitFileOptions)
• func NewInitGroup_Override(i InitGroup, groupName *string, groupId *float64)
• func NewInitPackage_Override(i InitPackage, type_ *string, versions *[]*string, packageName *string, ...)
• func NewInitServiceRestartHandle_Override(i InitServiceRestartHandle)
• func NewInitSource_Override(i InitSource, targetDirectory *string, ...)
• func NewInitUser_Override(i InitUser, userName *string, userOptions *InitUserOptions)
• func NewInstanceRequireImdsv2Aspect_Override(i InstanceRequireImdsv2Aspect, props *InstanceRequireImdsv2AspectProps)
• func NewInstanceType_Override(i InstanceType, instanceTypeIdentifier *string)
• func NewInstance_Override(i Instance, scope constructs.Construct, id *string, props *InstanceProps)
• func NewInterfaceVpcEndpointAwsService_Override(i InterfaceVpcEndpointAwsService, name *string, prefix *string, port *float64)
• func NewInterfaceVpcEndpointService_Override(i InterfaceVpcEndpointService, name *string, port *float64)
• func NewInterfaceVpcEndpoint_Override(i InterfaceVpcEndpoint, scope constructs.Construct, id *string, ...)
• func NewLaunchTemplateRequireImdsv2Aspect_Override(l LaunchTemplateRequireImdsv2Aspect, ...)
• func NewLaunchTemplateSpecialVersions_Override(l LaunchTemplateSpecialVersions)
• func NewLaunchTemplate_Override(l LaunchTemplate, scope constructs.Construct, id *string, ...)
• func NewLogFormat_Override(l LogFormat, value *string)
• func NewLookupMachineImage_Override(l LookupMachineImage, props *LookupMachineImageProps)
• func NewMachineImage_Override(m MachineImage)
• func NewMultipartBody_Override(m MultipartBody)
• func NewMultipartUserData_Override(m MultipartUserData, opts *MultipartUserDataOptions)
• func NewNatInstanceImage_Override(n NatInstanceImage)
• func NewNatInstanceProvider_Override(n NatInstanceProvider, props *NatInstanceProps)
• func NewNatProvider_Override(n NatProvider)
• func NewNetworkAclEntry_Override(n NetworkAclEntry, scope constructs.Construct, id *string, ...)
• func NewNetworkAcl_Override(n NetworkAcl, scope constructs.Construct, id *string, props *NetworkAclProps)
• func NewPeer_Override(p Peer)
• func NewPlacementGroup_Override(p PlacementGroup, scope constructs.Construct, id *string, ...)
• func NewPort_Override(p Port, props *PortProps)
• func NewPrefixList_Override(p PrefixList, scope constructs.Construct, id *string, props *PrefixListProps)
• func NewPrivateSubnet_Override(p PrivateSubnet, scope constructs.Construct, id *string, ...)
• func NewPublicSubnet_Override(p PublicSubnet, scope constructs.Construct, id *string, ...)
• func NewResolveSsmParameterAtLaunchImage_Override(r ResolveSsmParameterAtLaunchImage, parameterName *string, ...)
• func NewSecurityGroup_Override(s SecurityGroup, scope constructs.Construct, id *string, ...)
• func NewSubnetFilter_Override(s SubnetFilter)
• func NewSubnetNetworkAclAssociation_Override(s SubnetNetworkAclAssociation, scope constructs.Construct, id *string, ...)
• func NewSubnet_Override(s Subnet, scope constructs.Construct, id *string, props *SubnetProps)
• func NewUserData_Override(u UserData)
• func NewVolume_Override(v Volume, scope constructs.Construct, id *string, props *VolumeProps)
• func NewVpcEndpointService_Override(v VpcEndpointService, scope constructs.Construct, id *string, ...)
• func NewVpcEndpoint_Override(v VpcEndpoint, scope constructs.Construct, id *string, ...)
• func NewVpc_Override(v Vpc, scope constructs.Construct, id *string, props *VpcProps)
• func NewVpnConnectionBase_Override(v VpnConnectionBase, scope constructs.Construct, id *string, ...)
• func NewVpnConnection_Override(v VpnConnection, scope constructs.Construct, id *string, ...)
• func NewVpnGateway_Override(v VpnGateway, scope constructs.Construct, id *string, props *VpnGatewayProps)
• func NewWindowsImage_Override(w WindowsImage, version WindowsVersion, props *WindowsImageProps)
• func PlacementGroup_IsConstruct(x interface{}) *bool
• func PlacementGroup_IsOwnedResource(construct constructs.IConstruct) *bool
• func PlacementGroup_IsResource(construct constructs.IConstruct) *bool
• func PrefixList_IsConstruct(x interface{}) *bool
• func PrefixList_IsOwnedResource(construct constructs.IConstruct) *bool
• func PrefixList_IsResource(construct constructs.IConstruct) *bool
• func PrivateSubnet_IsConstruct(x interface{}) *bool
• func PrivateSubnet_IsOwnedResource(construct constructs.IConstruct) *bool
• func PrivateSubnet_IsResource(construct constructs.IConstruct) *bool
• func PrivateSubnet_IsVpcSubnet(x interface{}) *bool
• func PublicSubnet_IsConstruct(x interface{}) *bool
• func PublicSubnet_IsOwnedResource(construct constructs.IConstruct) *bool
• func PublicSubnet_IsResource(construct constructs.IConstruct) *bool
• func PublicSubnet_IsVpcSubnet(x interface{}) *bool
• func SecurityGroup_IsConstruct(x interface{}) *bool
• func SecurityGroup_IsOwnedResource(construct constructs.IConstruct) *bool
• func SecurityGroup_IsResource(construct constructs.IConstruct) *bool
• func SecurityGroup_IsSecurityGroup(x interface{}) *bool
• func SubnetNetworkAclAssociation_IsConstruct(x interface{}) *bool
• func SubnetNetworkAclAssociation_IsOwnedResource(construct constructs.IConstruct) *bool
• func SubnetNetworkAclAssociation_IsResource(construct constructs.IConstruct) *bool
• func Subnet_IsConstruct(x interface{}) *bool
• func Subnet_IsOwnedResource(construct constructs.IConstruct) *bool
• func Subnet_IsResource(construct constructs.IConstruct) *bool
• func Subnet_IsVpcSubnet(x interface{}) *bool
• func Volume_IsConstruct(x interface{}) *bool
• func Volume_IsOwnedResource(construct constructs.IConstruct) *bool
• func Volume_IsResource(construct constructs.IConstruct) *bool
• func VpcEndpointService_IsConstruct(x interface{}) *bool
• func VpcEndpointService_IsOwnedResource(construct constructs.IConstruct) *bool
• func VpcEndpointService_IsResource(construct constructs.IConstruct) *bool
• func VpcEndpoint_IsConstruct(x interface{}) *bool
• func VpcEndpoint_IsOwnedResource(construct constructs.IConstruct) *bool
• func VpcEndpoint_IsResource(construct constructs.IConstruct) *bool
• func Vpc_DEFAULT_CIDR_RANGE() *string
• func Vpc_DEFAULT_SUBNETS() *[]*SubnetConfiguration
• func Vpc_DEFAULT_SUBNETS_NO_NAT() *[]*SubnetConfiguration
• func Vpc_IsConstruct(x interface{}) *bool
• func Vpc_IsOwnedResource(construct constructs.IConstruct) *bool
• func Vpc_IsResource(construct constructs.IConstruct) *bool
• func VpnConnectionBase_IsConstruct(x interface{}) *bool
• func VpnConnectionBase_IsOwnedResource(construct constructs.IConstruct) *bool
• func VpnConnectionBase_IsResource(construct constructs.IConstruct) *bool
• func VpnConnection_IsConstruct(x interface{}) *bool
• func VpnConnection_IsOwnedResource(construct constructs.IConstruct) *bool
• func VpnConnection_IsResource(construct constructs.IConstruct) *bool
• func VpnConnection_MetricAll(metricName *string, props *awscloudwatch.MetricOptions) awscloudwatch.Metric
• func VpnConnection_MetricAllTunnelDataIn(props *awscloudwatch.MetricOptions) awscloudwatch.Metric
• func VpnConnection_MetricAllTunnelDataOut(props *awscloudwatch.MetricOptions) awscloudwatch.Metric
• func VpnConnection_MetricAllTunnelState(props *awscloudwatch.MetricOptions) awscloudwatch.Metric
• func VpnGateway_IsConstruct(x interface{}) *bool
• func VpnGateway_IsOwnedResource(construct constructs.IConstruct) *bool
• func VpnGateway_IsResource(construct constructs.IConstruct) *bool
• type AclCidr
  • func AclCidr_AnyIpv4() AclCidr
  • func AclCidr_AnyIpv6() AclCidr
  • func AclCidr_Ipv4(ipv4Cidr *string) AclCidr
  • func AclCidr_Ipv6(ipv6Cidr *string) AclCidr
• type AclCidrConfig
• type AclIcmp
• type AclPortRange
• type AclTraffic
  • func AclTraffic_AllTraffic() AclTraffic
  • func AclTraffic_Icmp(props *AclIcmp) AclTraffic
  • func AclTraffic_Icmpv6(props *AclIcmp) AclTraffic
  • func AclTraffic_TcpPort(port *float64) AclTraffic
  • func AclTraffic_TcpPortRange(startPort *float64, endPort *float64) AclTraffic
  • func AclTraffic_UdpPort(port *float64) AclTraffic
  • func AclTraffic_UdpPortRange(startPort *float64, endPort *float64) AclTraffic
• type AclTrafficConfig
• type Action
• type AddRouteOptions
• type AddressFamily
• type AllocateCidrRequest
• type AllocatedSubnet
• type AmazonLinux2022ImageSsmParameter
  • func NewAmazonLinux2022ImageSsmParameter(props *AmazonLinux2022ImageSsmParameterProps) AmazonLinux2022ImageSsmParameter
• type AmazonLinux2022ImageSsmParameterProps
• type AmazonLinux2022Kernel
  • func AmazonLinux2022Kernel_CDK_LATEST() AmazonLinux2022Kernel
  • func AmazonLinux2022Kernel_DEFAULT() AmazonLinux2022Kernel
  • func AmazonLinux2022Kernel_KERNEL_5_15() AmazonLinux2022Kernel
  • func NewAmazonLinux2022Kernel(version *string) AmazonLinux2022Kernel
• type AmazonLinux2023ImageSsmParameter
  • func NewAmazonLinux2023ImageSsmParameter(props *AmazonLinux2023ImageSsmParameterProps) AmazonLinux2023ImageSsmParameter
• type AmazonLinux2023ImageSsmParameterProps
• type AmazonLinux2023Kernel
  • func AmazonLinux2023Kernel_CDK_LATEST() AmazonLinux2023Kernel
  • func AmazonLinux2023Kernel_DEFAULT() AmazonLinux2023Kernel
  • func AmazonLinux2023Kernel_KERNEL_6_1() AmazonLinux2023Kernel
  • func NewAmazonLinux2023Kernel(version *string) AmazonLinux2023Kernel
• type AmazonLinux2ImageSsmParameter
  • func NewAmazonLinux2ImageSsmParameter(props *AmazonLinux2ImageSsmParameterProps) AmazonLinux2ImageSsmParameter
• type AmazonLinux2ImageSsmParameterProps
• type AmazonLinux2Kernel
  • func AmazonLinux2Kernel_CDK_LATEST() AmazonLinux2Kernel
  • func AmazonLinux2Kernel_DEFAULT() AmazonLinux2Kernel
  • func AmazonLinux2Kernel_KERNEL_5_10() AmazonLinux2Kernel
  • func NewAmazonLinux2Kernel(version *string) AmazonLinux2Kernel
• type AmazonLinuxCpuType
• type AmazonLinuxEdition
• type AmazonLinuxGeneration
• type AmazonLinuxImage
  • func NewAmazonLinuxImage(props *AmazonLinuxImageProps) AmazonLinuxImage
• type AmazonLinuxImageProps
• type AmazonLinuxImageSsmParameterBase
• type AmazonLinuxImageSsmParameterBaseOptions
• type AmazonLinuxImageSsmParameterBaseProps
• type AmazonLinuxImageSsmParameterCommonOptions
• type AmazonLinuxKernel
• type AmazonLinuxStorage
• type AmazonLinuxVirt
• type ApplyCloudFormationInitOptions
• type AttachInitOptions
• type AwsIpamProps
• type BastionHostLinux
  • func NewBastionHostLinux(scope constructs.Construct, id *string, props *BastionHostLinuxProps) BastionHostLinux
• type BastionHostLinuxProps
• type BlockDevice
• type BlockDeviceVolume
  • func BlockDeviceVolume_Ebs(volumeSize *float64, options *EbsDeviceOptions) BlockDeviceVolume
  • func BlockDeviceVolume_EbsFromSnapshot(snapshotId *string, options *EbsDeviceSnapshotOptions) BlockDeviceVolume
  • func BlockDeviceVolume_Ephemeral(volumeIndex *float64) BlockDeviceVolume
  • func NewBlockDeviceVolume(ebsDevice *EbsDeviceProps, virtualName *string) BlockDeviceVolume
• type CfnCapacityReservation
  • func NewCfnCapacityReservation(scope constructs.Construct, id *string, props *CfnCapacityReservationProps) CfnCapacityReservation
• type CfnCapacityReservationFleet
  • func NewCfnCapacityReservationFleet(scope constructs.Construct, id *string, ...) CfnCapacityReservationFleet
• type CfnCapacityReservationFleetProps
• type CfnCapacityReservationFleet_InstanceTypeSpecificationProperty
• type CfnCapacityReservationFleet_TagSpecificationProperty
• type CfnCapacityReservationProps
• type CfnCapacityReservation_TagSpecificationProperty
• type CfnCarrierGateway
  • func NewCfnCarrierGateway(scope constructs.Construct, id *string, props *CfnCarrierGatewayProps) CfnCarrierGateway
• type CfnCarrierGatewayProps
• type CfnClientVpnAuthorizationRule
  • func NewCfnClientVpnAuthorizationRule(scope constructs.Construct, id *string, ...) CfnClientVpnAuthorizationRule
• type CfnClientVpnAuthorizationRuleProps
• type CfnClientVpnEndpoint
  • func NewCfnClientVpnEndpoint(scope constructs.Construct, id *string, props *CfnClientVpnEndpointProps) CfnClientVpnEndpoint
• type CfnClientVpnEndpointProps
• type CfnClientVpnEndpoint_CertificateAuthenticationRequestProperty
• type CfnClientVpnEndpoint_ClientAuthenticationRequestProperty
• type CfnClientVpnEndpoint_ClientConnectOptionsProperty
• type CfnClientVpnEndpoint_ClientLoginBannerOptionsProperty
• type CfnClientVpnEndpoint_ConnectionLogOptionsProperty
• type CfnClientVpnEndpoint_DirectoryServiceAuthenticationRequestProperty
• type CfnClientVpnEndpoint_FederatedAuthenticationRequestProperty
• type CfnClientVpnEndpoint_TagSpecificationProperty
• type CfnClientVpnRoute
  • func NewCfnClientVpnRoute(scope constructs.Construct, id *string, props *CfnClientVpnRouteProps) CfnClientVpnRoute
• type CfnClientVpnRouteProps
• type CfnClientVpnTargetNetworkAssociation
  • func NewCfnClientVpnTargetNetworkAssociation(scope constructs.Construct, id *string, ...) CfnClientVpnTargetNetworkAssociation
• type CfnClientVpnTargetNetworkAssociationProps
• type CfnCustomerGateway
  • func NewCfnCustomerGateway(scope constructs.Construct, id *string, props *CfnCustomerGatewayProps) CfnCustomerGateway
• type CfnCustomerGatewayProps
• type CfnDHCPOptions
  • func NewCfnDHCPOptions(scope constructs.Construct, id *string, props *CfnDHCPOptionsProps) CfnDHCPOptions
• type CfnDHCPOptionsProps
• type CfnEC2Fleet
  • func NewCfnEC2Fleet(scope constructs.Construct, id *string, props *CfnEC2FleetProps) CfnEC2Fleet
• type CfnEC2FleetProps
• type CfnEC2Fleet_AcceleratorCountRequestProperty
• type CfnEC2Fleet_AcceleratorTotalMemoryMiBRequestProperty
• type CfnEC2Fleet_BaselineEbsBandwidthMbpsRequestProperty
• type CfnEC2Fleet_CapacityRebalanceProperty
• type CfnEC2Fleet_CapacityReservationOptionsRequestProperty
• type CfnEC2Fleet_FleetLaunchTemplateConfigRequestProperty
• type CfnEC2Fleet_FleetLaunchTemplateOverridesRequestProperty
• type CfnEC2Fleet_FleetLaunchTemplateSpecificationRequestProperty
• type CfnEC2Fleet_InstanceRequirementsRequestProperty
• type CfnEC2Fleet_MaintenanceStrategiesProperty
• type CfnEC2Fleet_MemoryGiBPerVCpuRequestProperty
• type CfnEC2Fleet_MemoryMiBRequestProperty
• type CfnEC2Fleet_NetworkBandwidthGbpsRequestProperty
• type CfnEC2Fleet_NetworkInterfaceCountRequestProperty
• type CfnEC2Fleet_OnDemandOptionsRequestProperty
• type CfnEC2Fleet_PlacementProperty
• type CfnEC2Fleet_SpotOptionsRequestProperty
• type CfnEC2Fleet_TagSpecificationProperty
• type CfnEC2Fleet_TargetCapacitySpecificationRequestProperty
• type CfnEC2Fleet_TotalLocalStorageGBRequestProperty
• type CfnEC2Fleet_VCpuCountRangeRequestProperty
• type CfnEIP
  • func NewCfnEIP(scope constructs.Construct, id *string, props *CfnEIPProps) CfnEIP
• type CfnEIPAssociation
  • func NewCfnEIPAssociation(scope constructs.Construct, id *string, props *CfnEIPAssociationProps) CfnEIPAssociation
• type CfnEIPAssociationProps
• type CfnEIPProps
• type CfnEgressOnlyInternetGateway
  • func NewCfnEgressOnlyInternetGateway(scope constructs.Construct, id *string, ...) CfnEgressOnlyInternetGateway
• type CfnEgressOnlyInternetGatewayProps
• type CfnEnclaveCertificateIamRoleAssociation
  • func NewCfnEnclaveCertificateIamRoleAssociation(scope constructs.Construct, id *string, ...) CfnEnclaveCertificateIamRoleAssociation
• type CfnEnclaveCertificateIamRoleAssociationProps
• type CfnFlowLog
  • func NewCfnFlowLog(scope constructs.Construct, id *string, props *CfnFlowLogProps) CfnFlowLog
• type CfnFlowLogProps
• type CfnFlowLog_DestinationOptionsProperty
• type CfnGatewayRouteTableAssociation
  • func NewCfnGatewayRouteTableAssociation(scope constructs.Construct, id *string, ...) CfnGatewayRouteTableAssociation
• type CfnGatewayRouteTableAssociationProps
• type CfnHost
  • func NewCfnHost(scope constructs.Construct, id *string, props *CfnHostProps) CfnHost
• type CfnHostProps
• type CfnIPAM
  • func NewCfnIPAM(scope constructs.Construct, id *string, props *CfnIPAMProps) CfnIPAM
• type CfnIPAMAllocation
  • func NewCfnIPAMAllocation(scope constructs.Construct, id *string, props *CfnIPAMAllocationProps) CfnIPAMAllocation
• type CfnIPAMAllocationProps
• type CfnIPAMPool
  • func NewCfnIPAMPool(scope constructs.Construct, id *string, props *CfnIPAMPoolProps) CfnIPAMPool
• type CfnIPAMPoolCidr
  • func NewCfnIPAMPoolCidr(scope constructs.Construct, id *string, props *CfnIPAMPoolCidrProps) CfnIPAMPoolCidr
• type CfnIPAMPoolCidrProps
• type CfnIPAMPoolProps
• type CfnIPAMPool_ProvisionedCidrProperty
• type CfnIPAMProps
• type CfnIPAMResourceDiscovery
  • func NewCfnIPAMResourceDiscovery(scope constructs.Construct, id *string, props *CfnIPAMResourceDiscoveryProps) CfnIPAMResourceDiscovery
• type CfnIPAMResourceDiscoveryAssociation
  • func NewCfnIPAMResourceDiscoveryAssociation(scope constructs.Construct, id *string, ...) CfnIPAMResourceDiscoveryAssociation
• type CfnIPAMResourceDiscoveryAssociationProps
• type CfnIPAMResourceDiscoveryProps
• type CfnIPAMResourceDiscovery_IpamOperatingRegionProperty
• type CfnIPAMScope
  • func NewCfnIPAMScope(scope constructs.Construct, id *string, props *CfnIPAMScopeProps) CfnIPAMScope
• type CfnIPAMScopeProps
• type CfnIPAM_IpamOperatingRegionProperty
• type CfnInstance
  • func NewCfnInstance(scope constructs.Construct, id *string, props *CfnInstanceProps) CfnInstance
• type CfnInstanceConnectEndpoint
  • func NewCfnInstanceConnectEndpoint(scope constructs.Construct, id *string, props *CfnInstanceConnectEndpointProps) CfnInstanceConnectEndpoint
• type CfnInstanceConnectEndpointProps
• type CfnInstanceProps
• type CfnInstance_AssociationParameterProperty
• type CfnInstance_BlockDeviceMappingProperty
• type CfnInstance_CpuOptionsProperty
• type CfnInstance_CreditSpecificationProperty
• type CfnInstance_EbsProperty
• type CfnInstance_ElasticGpuSpecificationProperty
• type CfnInstance_ElasticInferenceAcceleratorProperty
• type CfnInstance_EnclaveOptionsProperty
• type CfnInstance_HibernationOptionsProperty
• type CfnInstance_InstanceIpv6AddressProperty
• type CfnInstance_LaunchTemplateSpecificationProperty
• type CfnInstance_LicenseSpecificationProperty
• type CfnInstance_NetworkInterfaceProperty
• type CfnInstance_NoDeviceProperty
• type CfnInstance_PrivateDnsNameOptionsProperty
• type CfnInstance_PrivateIpAddressSpecificationProperty
• type CfnInstance_SsmAssociationProperty
• type CfnInstance_VolumeProperty
• type CfnInternetGateway
  • func NewCfnInternetGateway(scope constructs.Construct, id *string, props *CfnInternetGatewayProps) CfnInternetGateway
• type CfnInternetGatewayProps
• type CfnKeyPair
  • func NewCfnKeyPair(scope constructs.Construct, id *string, props *CfnKeyPairProps) CfnKeyPair
• type CfnKeyPairProps
• type CfnLaunchTemplate
  • func NewCfnLaunchTemplate(scope constructs.Construct, id *string, props *CfnLaunchTemplateProps) CfnLaunchTemplate
• type CfnLaunchTemplateProps
• type CfnLaunchTemplate_AcceleratorCountProperty
• type CfnLaunchTemplate_AcceleratorTotalMemoryMiBProperty
• type CfnLaunchTemplate_BaselineEbsBandwidthMbpsProperty
• type CfnLaunchTemplate_BlockDeviceMappingProperty
• type CfnLaunchTemplate_CapacityReservationSpecificationProperty
• type CfnLaunchTemplate_CapacityReservationTargetProperty
• type CfnLaunchTemplate_CpuOptionsProperty
• type CfnLaunchTemplate_CreditSpecificationProperty
• type CfnLaunchTemplate_EbsProperty
• type CfnLaunchTemplate_ElasticGpuSpecificationProperty
• type CfnLaunchTemplate_EnclaveOptionsProperty
• type CfnLaunchTemplate_HibernationOptionsProperty
• type CfnLaunchTemplate_IamInstanceProfileProperty
• type CfnLaunchTemplate_InstanceMarketOptionsProperty
• type CfnLaunchTemplate_InstanceRequirementsProperty
• type CfnLaunchTemplate_Ipv4PrefixSpecificationProperty
• type CfnLaunchTemplate_Ipv6AddProperty
• type CfnLaunchTemplate_Ipv6PrefixSpecificationProperty
• type CfnLaunchTemplate_LaunchTemplateDataProperty
• type CfnLaunchTemplate_LaunchTemplateElasticInferenceAcceleratorProperty
• type CfnLaunchTemplate_LaunchTemplateTagSpecificationProperty
• type CfnLaunchTemplate_LicenseSpecificationProperty
• type CfnLaunchTemplate_MaintenanceOptionsProperty
• type CfnLaunchTemplate_MemoryGiBPerVCpuProperty
• type CfnLaunchTemplate_MemoryMiBProperty
• type CfnLaunchTemplate_MetadataOptionsProperty
• type CfnLaunchTemplate_MonitoringProperty
• type CfnLaunchTemplate_NetworkBandwidthGbpsProperty
• type CfnLaunchTemplate_NetworkInterfaceCountProperty
• type CfnLaunchTemplate_NetworkInterfaceProperty
• type CfnLaunchTemplate_PlacementProperty
• type CfnLaunchTemplate_PrivateDnsNameOptionsProperty
• type CfnLaunchTemplate_PrivateIpAddProperty
• type CfnLaunchTemplate_SpotOptionsProperty
• type CfnLaunchTemplate_TagSpecificationProperty
• type CfnLaunchTemplate_TotalLocalStorageGBProperty
• type CfnLaunchTemplate_VCpuCountProperty
• type CfnLocalGatewayRoute
  • func NewCfnLocalGatewayRoute(scope constructs.Construct, id *string, props *CfnLocalGatewayRouteProps) CfnLocalGatewayRoute
• type CfnLocalGatewayRouteProps
• type CfnLocalGatewayRouteTable
  • func NewCfnLocalGatewayRouteTable(scope constructs.Construct, id *string, props *CfnLocalGatewayRouteTableProps) CfnLocalGatewayRouteTable
• type CfnLocalGatewayRouteTableProps
• type CfnLocalGatewayRouteTableVPCAssociation
  • func NewCfnLocalGatewayRouteTableVPCAssociation(scope constructs.Construct, id *string, ...) CfnLocalGatewayRouteTableVPCAssociation
• type CfnLocalGatewayRouteTableVPCAssociationProps
• type CfnLocalGatewayRouteTableVirtualInterfaceGroupAssociation
  • func NewCfnLocalGatewayRouteTableVirtualInterfaceGroupAssociation(scope constructs.Construct, id *string, ...) CfnLocalGatewayRouteTableVirtualInterfaceGroupAssociation
• type CfnLocalGatewayRouteTableVirtualInterfaceGroupAssociationProps
• type CfnNatGateway
  • func NewCfnNatGateway(scope constructs.Construct, id *string, props *CfnNatGatewayProps) CfnNatGateway
• type CfnNatGatewayProps
• type CfnNetworkAcl
  • func NewCfnNetworkAcl(scope constructs.Construct, id *string, props *CfnNetworkAclProps) CfnNetworkAcl
• type CfnNetworkAclEntry
  • func NewCfnNetworkAclEntry(scope constructs.Construct, id *string, props *CfnNetworkAclEntryProps) CfnNetworkAclEntry
• type CfnNetworkAclEntryProps
• type CfnNetworkAclEntry_IcmpProperty
• type CfnNetworkAclEntry_PortRangeProperty
• type CfnNetworkAclProps
• type CfnNetworkInsightsAccessScope
  • func NewCfnNetworkInsightsAccessScope(scope constructs.Construct, id *string, ...) CfnNetworkInsightsAccessScope
• type CfnNetworkInsightsAccessScopeAnalysis
  • func NewCfnNetworkInsightsAccessScopeAnalysis(scope constructs.Construct, id *string, ...) CfnNetworkInsightsAccessScopeAnalysis
• type CfnNetworkInsightsAccessScopeAnalysisProps
• type CfnNetworkInsightsAccessScopeProps
• type CfnNetworkInsightsAccessScope_AccessScopePathRequestProperty
• type CfnNetworkInsightsAccessScope_PacketHeaderStatementRequestProperty
• type CfnNetworkInsightsAccessScope_PathStatementRequestProperty
• type CfnNetworkInsightsAccessScope_ResourceStatementRequestProperty
• type CfnNetworkInsightsAccessScope_ThroughResourcesStatementRequestProperty
• type CfnNetworkInsightsAnalysis
  • func NewCfnNetworkInsightsAnalysis(scope constructs.Construct, id *string, props *CfnNetworkInsightsAnalysisProps) CfnNetworkInsightsAnalysis
• type CfnNetworkInsightsAnalysisProps
• type CfnNetworkInsightsAnalysis_AdditionalDetailProperty
• type CfnNetworkInsightsAnalysis_AlternatePathHintProperty
• type CfnNetworkInsightsAnalysis_AnalysisAclRuleProperty
• type CfnNetworkInsightsAnalysis_AnalysisComponentProperty
• type CfnNetworkInsightsAnalysis_AnalysisLoadBalancerListenerProperty
• type CfnNetworkInsightsAnalysis_AnalysisLoadBalancerTargetProperty
• type CfnNetworkInsightsAnalysis_AnalysisPacketHeaderProperty
• type CfnNetworkInsightsAnalysis_AnalysisRouteTableRouteProperty
• type CfnNetworkInsightsAnalysis_AnalysisSecurityGroupRuleProperty
• type CfnNetworkInsightsAnalysis_ExplanationProperty
• type CfnNetworkInsightsAnalysis_PathComponentProperty
• type CfnNetworkInsightsAnalysis_PortRangeProperty
• type CfnNetworkInsightsAnalysis_TransitGatewayRouteTableRouteProperty
• type CfnNetworkInsightsPath
  • func NewCfnNetworkInsightsPath(scope constructs.Construct, id *string, props *CfnNetworkInsightsPathProps) CfnNetworkInsightsPath
• type CfnNetworkInsightsPathProps
• type CfnNetworkInsightsPath_FilterPortRangeProperty
• type CfnNetworkInsightsPath_PathFilterProperty
• type CfnNetworkInterface
  • func NewCfnNetworkInterface(scope constructs.Construct, id *string, props *CfnNetworkInterfaceProps) CfnNetworkInterface
• type CfnNetworkInterfaceAttachment
  • func NewCfnNetworkInterfaceAttachment(scope constructs.Construct, id *string, ...) CfnNetworkInterfaceAttachment
• type CfnNetworkInterfaceAttachmentProps
• type CfnNetworkInterfacePermission
  • func NewCfnNetworkInterfacePermission(scope constructs.Construct, id *string, ...) CfnNetworkInterfacePermission
• type CfnNetworkInterfacePermissionProps
• type CfnNetworkInterfaceProps
• type CfnNetworkInterface_InstanceIpv6AddressProperty
• type CfnNetworkInterface_Ipv4PrefixSpecificationProperty
• type CfnNetworkInterface_Ipv6PrefixSpecificationProperty
• type CfnNetworkInterface_PrivateIpAddressSpecificationProperty
• type CfnNetworkPerformanceMetricSubscription
  • func NewCfnNetworkPerformanceMetricSubscription(scope constructs.Construct, id *string, ...) CfnNetworkPerformanceMetricSubscription
• type CfnNetworkPerformanceMetricSubscriptionProps
• type CfnPlacementGroup
  • func NewCfnPlacementGroup(scope constructs.Construct, id *string, props *CfnPlacementGroupProps) CfnPlacementGroup
• type CfnPlacementGroupProps
• type CfnPrefixList
  • func NewCfnPrefixList(scope constructs.Construct, id *string, props *CfnPrefixListProps) CfnPrefixList
• type CfnPrefixListProps
• type CfnPrefixList_EntryProperty
• type CfnRoute
  • func NewCfnRoute(scope constructs.Construct, id *string, props *CfnRouteProps) CfnRoute
• type CfnRouteProps
• type CfnRouteTable
  • func NewCfnRouteTable(scope constructs.Construct, id *string, props *CfnRouteTableProps) CfnRouteTable
• type CfnRouteTableProps
• type CfnSecurityGroup
  • func NewCfnSecurityGroup(scope constructs.Construct, id *string, props *CfnSecurityGroupProps) CfnSecurityGroup
• type CfnSecurityGroupEgress
  • func NewCfnSecurityGroupEgress(scope constructs.Construct, id *string, props *CfnSecurityGroupEgressProps) CfnSecurityGroupEgress
• type CfnSecurityGroupEgressProps
• type CfnSecurityGroupIngress
  • func NewCfnSecurityGroupIngress(scope constructs.Construct, id *string, props *CfnSecurityGroupIngressProps) CfnSecurityGroupIngress
• type CfnSecurityGroupIngressProps
• type CfnSecurityGroupProps
• type CfnSecurityGroup_EgressProperty
• type CfnSecurityGroup_IngressProperty
• type CfnSpotFleet
  • func NewCfnSpotFleet(scope constructs.Construct, id *string, props *CfnSpotFleetProps) CfnSpotFleet
• type CfnSpotFleetProps
• type CfnSpotFleet_AcceleratorCountRequestProperty
• type CfnSpotFleet_AcceleratorTotalMemoryMiBRequestProperty
• type CfnSpotFleet_BaselineEbsBandwidthMbpsRequestProperty
• type CfnSpotFleet_BlockDeviceMappingProperty
• type CfnSpotFleet_ClassicLoadBalancerProperty
• type CfnSpotFleet_ClassicLoadBalancersConfigProperty
• type CfnSpotFleet_EbsBlockDeviceProperty
• type CfnSpotFleet_FleetLaunchTemplateSpecificationProperty
• type CfnSpotFleet_GroupIdentifierProperty
• type CfnSpotFleet_IamInstanceProfileSpecificationProperty
• type CfnSpotFleet_InstanceIpv6AddressProperty
• type CfnSpotFleet_InstanceNetworkInterfaceSpecificationProperty
• type CfnSpotFleet_InstanceRequirementsRequestProperty
• type CfnSpotFleet_LaunchTemplateConfigProperty
• type CfnSpotFleet_LaunchTemplateOverridesProperty
• type CfnSpotFleet_LoadBalancersConfigProperty
• type CfnSpotFleet_MemoryGiBPerVCpuRequestProperty
• type CfnSpotFleet_MemoryMiBRequestProperty
• type CfnSpotFleet_NetworkBandwidthGbpsRequestProperty
• type CfnSpotFleet_NetworkInterfaceCountRequestProperty
• type CfnSpotFleet_PrivateIpAddressSpecificationProperty
• type CfnSpotFleet_SpotCapacityRebalanceProperty
• type CfnSpotFleet_SpotFleetLaunchSpecificationProperty
• type CfnSpotFleet_SpotFleetMonitoringProperty
• type CfnSpotFleet_SpotFleetRequestConfigDataProperty
• type CfnSpotFleet_SpotFleetTagSpecificationProperty
• type CfnSpotFleet_SpotMaintenanceStrategiesProperty
• type CfnSpotFleet_SpotPlacementProperty
• type CfnSpotFleet_TargetGroupProperty
• type CfnSpotFleet_TargetGroupsConfigProperty
• type CfnSpotFleet_TotalLocalStorageGBRequestProperty
• type CfnSpotFleet_VCpuCountRangeRequestProperty
• type CfnSubnet
  • func NewCfnSubnet(scope constructs.Construct, id *string, props *CfnSubnetProps) CfnSubnet
• type CfnSubnetCidrBlock
  • func NewCfnSubnetCidrBlock(scope constructs.Construct, id *string, props *CfnSubnetCidrBlockProps) CfnSubnetCidrBlock
• type CfnSubnetCidrBlockProps
• type CfnSubnetNetworkAclAssociation
  • func NewCfnSubnetNetworkAclAssociation(scope constructs.Construct, id *string, ...) CfnSubnetNetworkAclAssociation
• type CfnSubnetNetworkAclAssociationProps
• type CfnSubnetProps
• type CfnSubnetRouteTableAssociation
  • func NewCfnSubnetRouteTableAssociation(scope constructs.Construct, id *string, ...) CfnSubnetRouteTableAssociation
• type CfnSubnetRouteTableAssociationProps
• type CfnSubnet_PrivateDnsNameOptionsOnLaunchProperty
• type CfnTrafficMirrorFilter
  • func NewCfnTrafficMirrorFilter(scope constructs.Construct, id *string, props *CfnTrafficMirrorFilterProps) CfnTrafficMirrorFilter
• type CfnTrafficMirrorFilterProps
• type CfnTrafficMirrorFilterRule
  • func NewCfnTrafficMirrorFilterRule(scope constructs.Construct, id *string, props *CfnTrafficMirrorFilterRuleProps) CfnTrafficMirrorFilterRule
• type CfnTrafficMirrorFilterRuleProps
• type CfnTrafficMirrorFilterRule_TrafficMirrorPortRangeProperty
• type CfnTrafficMirrorSession
  • func NewCfnTrafficMirrorSession(scope constructs.Construct, id *string, props *CfnTrafficMirrorSessionProps) CfnTrafficMirrorSession
• type CfnTrafficMirrorSessionProps
• type CfnTrafficMirrorTarget
  • func NewCfnTrafficMirrorTarget(scope constructs.Construct, id *string, props *CfnTrafficMirrorTargetProps) CfnTrafficMirrorTarget
• type CfnTrafficMirrorTargetProps
• type CfnTransitGateway
  • func NewCfnTransitGateway(scope constructs.Construct, id *string, props *CfnTransitGatewayProps) CfnTransitGateway
• type CfnTransitGatewayAttachment
  • func NewCfnTransitGatewayAttachment(scope constructs.Construct, id *string, ...) CfnTransitGatewayAttachment
• type CfnTransitGatewayAttachmentProps
• type CfnTransitGatewayAttachment_OptionsProperty
• type CfnTransitGatewayConnect
  • func NewCfnTransitGatewayConnect(scope constructs.Construct, id *string, props *CfnTransitGatewayConnectProps) CfnTransitGatewayConnect
• type CfnTransitGatewayConnectProps
• type CfnTransitGatewayConnect_TransitGatewayConnectOptionsProperty
• type CfnTransitGatewayMulticastDomain
  • func NewCfnTransitGatewayMulticastDomain(scope constructs.Construct, id *string, ...) CfnTransitGatewayMulticastDomain
• type CfnTransitGatewayMulticastDomainAssociation
  • func NewCfnTransitGatewayMulticastDomainAssociation(scope constructs.Construct, id *string, ...) CfnTransitGatewayMulticastDomainAssociation
• type CfnTransitGatewayMulticastDomainAssociationProps
• type CfnTransitGatewayMulticastDomainProps
• type CfnTransitGatewayMulticastDomain_OptionsProperty
• type CfnTransitGatewayMulticastGroupMember
  • func NewCfnTransitGatewayMulticastGroupMember(scope constructs.Construct, id *string, ...) CfnTransitGatewayMulticastGroupMember
• type CfnTransitGatewayMulticastGroupMemberProps
• type CfnTransitGatewayMulticastGroupSource
  • func NewCfnTransitGatewayMulticastGroupSource(scope constructs.Construct, id *string, ...) CfnTransitGatewayMulticastGroupSource
• type CfnTransitGatewayMulticastGroupSourceProps
• type CfnTransitGatewayPeeringAttachment
  • func NewCfnTransitGatewayPeeringAttachment(scope constructs.Construct, id *string, ...) CfnTransitGatewayPeeringAttachment
• type CfnTransitGatewayPeeringAttachmentProps
• type CfnTransitGatewayPeeringAttachment_PeeringAttachmentStatusProperty
• type CfnTransitGatewayProps
• type CfnTransitGatewayRoute
  • func NewCfnTransitGatewayRoute(scope constructs.Construct, id *string, props *CfnTransitGatewayRouteProps) CfnTransitGatewayRoute
• type CfnTransitGatewayRouteProps
• type CfnTransitGatewayRouteTable
  • func NewCfnTransitGatewayRouteTable(scope constructs.Construct, id *string, ...) CfnTransitGatewayRouteTable
• type CfnTransitGatewayRouteTableAssociation
  • func NewCfnTransitGatewayRouteTableAssociation(scope constructs.Construct, id *string, ...) CfnTransitGatewayRouteTableAssociation
• type CfnTransitGatewayRouteTableAssociationProps
• type CfnTransitGatewayRouteTablePropagation
  • func NewCfnTransitGatewayRouteTablePropagation(scope constructs.Construct, id *string, ...) CfnTransitGatewayRouteTablePropagation
• type CfnTransitGatewayRouteTablePropagationProps
• type CfnTransitGatewayRouteTableProps
• type CfnTransitGatewayVpcAttachment
  • func NewCfnTransitGatewayVpcAttachment(scope constructs.Construct, id *string, ...) CfnTransitGatewayVpcAttachment
• type CfnTransitGatewayVpcAttachmentProps
• type CfnTransitGatewayVpcAttachment_OptionsProperty
• type CfnVPC
  • func NewCfnVPC(scope constructs.Construct, id *string, props *CfnVPCProps) CfnVPC
• type CfnVPCCidrBlock
  • func NewCfnVPCCidrBlock(scope constructs.Construct, id *string, props *CfnVPCCidrBlockProps) CfnVPCCidrBlock
• type CfnVPCCidrBlockProps
• type CfnVPCDHCPOptionsAssociation
  • func NewCfnVPCDHCPOptionsAssociation(scope constructs.Construct, id *string, ...) CfnVPCDHCPOptionsAssociation
• type CfnVPCDHCPOptionsAssociationProps
• type CfnVPCEndpoint
  • func NewCfnVPCEndpoint(scope constructs.Construct, id *string, props *CfnVPCEndpointProps) CfnVPCEndpoint
• type CfnVPCEndpointConnectionNotification
  • func NewCfnVPCEndpointConnectionNotification(scope constructs.Construct, id *string, ...) CfnVPCEndpointConnectionNotification
• type CfnVPCEndpointConnectionNotificationProps
• type CfnVPCEndpointProps
• type CfnVPCEndpointService
  • func NewCfnVPCEndpointService(scope constructs.Construct, id *string, props *CfnVPCEndpointServiceProps) CfnVPCEndpointService
• type CfnVPCEndpointServicePermissions
  • func NewCfnVPCEndpointServicePermissions(scope constructs.Construct, id *string, ...) CfnVPCEndpointServicePermissions
• type CfnVPCEndpointServicePermissionsProps
• type CfnVPCEndpointServiceProps
• type CfnVPCGatewayAttachment
  • func NewCfnVPCGatewayAttachment(scope constructs.Construct, id *string, props *CfnVPCGatewayAttachmentProps) CfnVPCGatewayAttachment
• type CfnVPCGatewayAttachmentProps
• type CfnVPCPeeringConnection
  • func NewCfnVPCPeeringConnection(scope constructs.Construct, id *string, props *CfnVPCPeeringConnectionProps) CfnVPCPeeringConnection
• type CfnVPCPeeringConnectionProps
• type CfnVPCProps
• type CfnVPNConnection
  • func NewCfnVPNConnection(scope constructs.Construct, id *string, props *CfnVPNConnectionProps) CfnVPNConnection
• type CfnVPNConnectionProps
• type CfnVPNConnectionRoute
  • func NewCfnVPNConnectionRoute(scope constructs.Construct, id *string, props *CfnVPNConnectionRouteProps) CfnVPNConnectionRoute
• type CfnVPNConnectionRouteProps
• type CfnVPNConnection_VpnTunnelOptionsSpecificationProperty
• type CfnVPNGateway
  • func NewCfnVPNGateway(scope constructs.Construct, id *string, props *CfnVPNGatewayProps) CfnVPNGateway
• type CfnVPNGatewayProps
• type CfnVPNGatewayRoutePropagation
  • func NewCfnVPNGatewayRoutePropagation(scope constructs.Construct, id *string, ...) CfnVPNGatewayRoutePropagation
• type CfnVPNGatewayRoutePropagationProps
• type CfnVerifiedAccessEndpoint
  • func NewCfnVerifiedAccessEndpoint(scope constructs.Construct, id *string, props *CfnVerifiedAccessEndpointProps) CfnVerifiedAccessEndpoint
• type CfnVerifiedAccessEndpointProps
• type CfnVerifiedAccessEndpoint_LoadBalancerOptionsProperty
• type CfnVerifiedAccessEndpoint_NetworkInterfaceOptionsProperty
• type CfnVerifiedAccessGroup
  • func NewCfnVerifiedAccessGroup(scope constructs.Construct, id *string, props *CfnVerifiedAccessGroupProps) CfnVerifiedAccessGroup
• type CfnVerifiedAccessGroupProps
• type CfnVerifiedAccessInstance
  • func NewCfnVerifiedAccessInstance(scope constructs.Construct, id *string, props *CfnVerifiedAccessInstanceProps) CfnVerifiedAccessInstance
• type CfnVerifiedAccessInstanceProps
• type CfnVerifiedAccessInstance_CloudWatchLogsProperty
• type CfnVerifiedAccessInstance_KinesisDataFirehoseProperty
• type CfnVerifiedAccessInstance_S3Property
• type CfnVerifiedAccessInstance_VerifiedAccessLogsProperty
• type CfnVerifiedAccessInstance_VerifiedAccessTrustProviderProperty
• type CfnVerifiedAccessTrustProvider
  • func NewCfnVerifiedAccessTrustProvider(scope constructs.Construct, id *string, ...) CfnVerifiedAccessTrustProvider
• type CfnVerifiedAccessTrustProviderProps
• type CfnVerifiedAccessTrustProvider_DeviceOptionsProperty
• type CfnVerifiedAccessTrustProvider_OidcOptionsProperty
• type CfnVolume
  • func NewCfnVolume(scope constructs.Construct, id *string, props *CfnVolumeProps) CfnVolume
• type CfnVolumeAttachment
  • func NewCfnVolumeAttachment(scope constructs.Construct, id *string, props *CfnVolumeAttachmentProps) CfnVolumeAttachment
• type CfnVolumeAttachmentProps
• type CfnVolumeProps
• type ClientVpnAuthorizationRule
  • func NewClientVpnAuthorizationRule(scope constructs.Construct, id *string, props *ClientVpnAuthorizationRuleProps) ClientVpnAuthorizationRule
• type ClientVpnAuthorizationRuleOptions
• type ClientVpnAuthorizationRuleProps
• type ClientVpnEndpoint
  • func NewClientVpnEndpoint(scope constructs.Construct, id *string, props *ClientVpnEndpointProps) ClientVpnEndpoint
• type ClientVpnEndpointAttributes
• type ClientVpnEndpointOptions
• type ClientVpnEndpointProps
• type ClientVpnRoute
  • func NewClientVpnRoute(scope constructs.Construct, id *string, props *ClientVpnRouteProps) ClientVpnRoute
• type ClientVpnRouteOptions
• type ClientVpnRouteProps
• type ClientVpnRouteTarget
  • func ClientVpnRouteTarget_Local() ClientVpnRouteTarget
  • func ClientVpnRouteTarget_Subnet(subnet ISubnet) ClientVpnRouteTarget
• type ClientVpnSessionTimeout
• type ClientVpnUserBasedAuthentication
  • func ClientVpnUserBasedAuthentication_ActiveDirectory(directoryId *string) ClientVpnUserBasedAuthentication
  • func ClientVpnUserBasedAuthentication_Federated(samlProvider awsiam.ISamlProvider, ...) ClientVpnUserBasedAuthentication
• type CloudFormationInit
  • func CloudFormationInit_FromConfig(config InitConfig) CloudFormationInit
  • func CloudFormationInit_FromConfigSets(props *ConfigSetProps) CloudFormationInit
  • func CloudFormationInit_FromElements(elements ...InitElement) CloudFormationInit
• type CommonNetworkAclEntryOptions
• type ConfigSetProps
• type ConfigureNatOptions
• type ConnectionRule
• type Connections
  • func NewConnections(props *ConnectionsProps) Connections
• type ConnectionsProps
• type CpuCredits
• type DefaultInstanceTenancy
• type DestinationOptions
• type EbsDeviceOptions
• type EbsDeviceOptionsBase
• type EbsDeviceProps
• type EbsDeviceSnapshotOptions
• type EbsDeviceVolumeType
• type EnableVpnGatewayOptions
• type ExecuteFileOptions
• type FlowLog
  • func NewFlowLog(scope constructs.Construct, id *string, props *FlowLogProps) FlowLog
• type FlowLogDestination
  • func FlowLogDestination_ToCloudWatchLogs(logGroup awslogs.ILogGroup, iamRole awsiam.IRole) FlowLogDestination
  • func FlowLogDestination_ToS3(bucket awss3.IBucket, keyPrefix *string, options *S3DestinationOptions) FlowLogDestination
• type FlowLogDestinationConfig
• type FlowLogDestinationType
• type FlowLogFileFormat
• type FlowLogMaxAggregationInterval
• type FlowLogOptions
• type FlowLogProps
• type FlowLogResourceType
  • func FlowLogResourceType_FromNetworkInterfaceId(id *string) FlowLogResourceType
  • func FlowLogResourceType_FromSubnet(subnet ISubnet) FlowLogResourceType
  • func FlowLogResourceType_FromVpc(vpc IVpc) FlowLogResourceType
• type FlowLogTrafficType
• type GatewayConfig
• type GatewayVpcEndpoint
  • func NewGatewayVpcEndpoint(scope constructs.Construct, id *string, props *GatewayVpcEndpointProps) GatewayVpcEndpoint
• type GatewayVpcEndpointAwsService
  • func GatewayVpcEndpointAwsService_DYNAMODB() GatewayVpcEndpointAwsService
  • func GatewayVpcEndpointAwsService_S3() GatewayVpcEndpointAwsService
  • func NewGatewayVpcEndpointAwsService(name *string, prefix *string) GatewayVpcEndpointAwsService
• type GatewayVpcEndpointOptions
• type GatewayVpcEndpointProps
• type GenericLinuxImage
  • func NewGenericLinuxImage(amiMap *map[string]*string, props *GenericLinuxImageProps) GenericLinuxImage
• type GenericLinuxImageProps
• type GenericSSMParameterImage
  • func NewGenericSSMParameterImage(parameterName *string, os OperatingSystemType, userData UserData) GenericSSMParameterImage
• type GenericWindowsImage
  • func NewGenericWindowsImage(amiMap *map[string]*string, props *GenericWindowsImageProps) GenericWindowsImage
• type GenericWindowsImageProps
• type IClientVpnConnectionHandler
• type IClientVpnEndpoint
  • func ClientVpnEndpoint_FromEndpointAttributes(scope constructs.Construct, id *string, attrs *ClientVpnEndpointAttributes) IClientVpnEndpoint
• type IConnectable
• type IFlowLog
  • func FlowLog_FromFlowLogId(scope constructs.Construct, id *string, flowLogId *string) IFlowLog
• type IGatewayVpcEndpoint
  • func GatewayVpcEndpoint_FromGatewayVpcEndpointId(scope constructs.Construct, id *string, gatewayVpcEndpointId *string) IGatewayVpcEndpoint
• type IGatewayVpcEndpointService
• type IInstance
• type IInterfaceVpcEndpoint
  • func InterfaceVpcEndpoint_FromInterfaceVpcEndpointAttributes(scope constructs.Construct, id *string, attrs *InterfaceVpcEndpointAttributes) IInterfaceVpcEndpoint
• type IInterfaceVpcEndpointService
• type IIpAddresses
  • func IpAddresses_AwsIpamAllocation(props *AwsIpamProps) IIpAddresses
  • func IpAddresses_Cidr(cidrBlock *string) IIpAddresses
• type ILaunchTemplate
  • func LaunchTemplate_FromLaunchTemplateAttributes(scope constructs.Construct, id *string, attrs *LaunchTemplateAttributes) ILaunchTemplate
• type IMachineImage
  • func MachineImage_FromSsmParameter(parameterName *string, options *SsmParameterImageOptions) IMachineImage
  • func MachineImage_GenericLinux(amiMap *map[string]*string, props *GenericLinuxImageProps) IMachineImage
  • func MachineImage_GenericWindows(amiMap *map[string]*string, props *GenericWindowsImageProps) IMachineImage
  • func MachineImage_LatestAmazonLinux(props *AmazonLinuxImageProps) IMachineImage
  • func MachineImage_LatestAmazonLinux2(props *AmazonLinux2ImageSsmParameterProps) IMachineImage
  • func MachineImage_LatestAmazonLinux2022(props *AmazonLinux2022ImageSsmParameterProps) IMachineImage
  • func MachineImage_LatestAmazonLinux2023(props *AmazonLinux2023ImageSsmParameterProps) IMachineImage
  • func MachineImage_LatestWindows(version WindowsVersion, props *WindowsImageProps) IMachineImage
  • func MachineImage_Lookup(props *LookupMachineImageProps) IMachineImage
  • func MachineImage_ResolveSsmParameterAtLaunch(parameterName *string, options *SsmParameterImageOptions) IMachineImage
• type INetworkAcl
  • func NetworkAcl_FromNetworkAclId(scope constructs.Construct, id *string, networkAclId *string) INetworkAcl
• type INetworkAclEntry
• type IPeer
  • func Peer_AnyIpv4() IPeer
  • func Peer_AnyIpv6() IPeer
  • func Peer_Ipv4(cidrIp *string) IPeer
  • func Peer_Ipv6(cidrIp *string) IPeer
  • func Peer_PrefixList(prefixListId *string) IPeer
  • func Peer_SecurityGroupId(securityGroupId *string, sourceSecurityGroupOwnerId *string) IPeer
• type IPlacementGroup
  • func PlacementGroup_FromPlacementGroupName(scope constructs.Construct, id *string, placementGroupName *string) IPlacementGroup
• type IPrefixList
  • func PrefixList_FromPrefixListId(scope constructs.Construct, id *string, prefixListId *string) IPrefixList
• type IPrivateSubnet
  • func PrivateSubnet_FromPrivateSubnetAttributes(scope constructs.Construct, id *string, attrs *PrivateSubnetAttributes) IPrivateSubnet
• type IPublicSubnet
  • func PublicSubnet_FromPublicSubnetAttributes(scope constructs.Construct, id *string, attrs *PublicSubnetAttributes) IPublicSubnet
• type IRouteTable
• type ISecurityGroup
  • func SecurityGroup_FromLookupById(scope constructs.Construct, id *string, securityGroupId *string) ISecurityGroup
  • func SecurityGroup_FromLookupByName(scope constructs.Construct, id *string, securityGroupName *string, vpc IVpc) ISecurityGroup
  • func SecurityGroup_FromSecurityGroupId(scope constructs.Construct, id *string, securityGroupId *string, ...) ISecurityGroup
• type ISubnet
  • func PrivateSubnet_FromSubnetAttributes(scope constructs.Construct, id *string, attrs *SubnetAttributes) ISubnet
  • func PrivateSubnet_FromSubnetId(scope constructs.Construct, id *string, subnetId *string) ISubnet
  • func PublicSubnet_FromSubnetAttributes(scope constructs.Construct, id *string, attrs *SubnetAttributes) ISubnet
  • func PublicSubnet_FromSubnetId(scope constructs.Construct, id *string, subnetId *string) ISubnet
  • func Subnet_FromSubnetAttributes(scope constructs.Construct, id *string, attrs *SubnetAttributes) ISubnet
  • func Subnet_FromSubnetId(scope constructs.Construct, id *string, subnetId *string) ISubnet
• type ISubnetNetworkAclAssociation
  • func SubnetNetworkAclAssociation_FromSubnetNetworkAclAssociationAssociationId(scope constructs.Construct, id *string, ...) ISubnetNetworkAclAssociation
• type IVolume
  • func Volume_FromVolumeAttributes(scope constructs.Construct, id *string, attrs *VolumeAttributes) IVolume
• type IVpc
  • func Vpc_FromLookup(scope constructs.Construct, id *string, options *VpcLookupOptions) IVpc
  • func Vpc_FromVpcAttributes(scope constructs.Construct, id *string, attrs *VpcAttributes) IVpc
• type IVpcEndpoint
• type IVpcEndpointService
• type IVpcEndpointServiceLoadBalancer
• type IVpnConnection
  • func VpnConnection_FromVpnConnectionAttributes(scope constructs.Construct, id *string, attrs *VpnConnectionAttributes) IVpnConnection
• type IVpnGateway
• type InitCommand
  • func InitCommand_ArgvCommand(argv *[]*string, options *InitCommandOptions) InitCommand
  • func InitCommand_ShellCommand(shellCommand *string, options *InitCommandOptions) InitCommand
• type InitCommandOptions
• type InitCommandWaitDuration
  • func InitCommandWaitDuration_Forever() InitCommandWaitDuration
  • func InitCommandWaitDuration_None() InitCommandWaitDuration
  • func InitCommandWaitDuration_Of(duration awscdk.Duration) InitCommandWaitDuration
• type InitConfig
  • func NewInitConfig(elements *[]InitElement) InitConfig
• type InitElement
• type InitFile
  • func InitFile_FromAsset(targetFileName *string, path *string, options *InitFileAssetOptions) InitFile
  • func InitFile_FromExistingAsset(targetFileName *string, asset awss3assets.Asset, options *InitFileOptions) InitFile
  • func InitFile_FromFileInline(targetFileName *string, sourceFileName *string, options *InitFileOptions) InitFile
  • func InitFile_FromObject(fileName *string, obj *map[string]interface{}, options *InitFileOptions) InitFile
  • func InitFile_FromS3Object(fileName *string, bucket awss3.IBucket, key *string, options *InitFileOptions) InitFile
  • func InitFile_FromString(fileName *string, content *string, options *InitFileOptions) InitFile
  • func InitFile_FromUrl(fileName *string, url *string, options *InitFileOptions) InitFile
  • func InitFile_Symlink(fileName *string, target *string, options *InitFileOptions) InitFile
  • func InitService_SystemdConfigFile(serviceName *string, options *SystemdConfigFileOptions) InitFile
• type InitFileAssetOptions
• type InitFileOptions
• type InitGroup
  • func InitGroup_FromName(groupName *string, groupId *float64) InitGroup
  • func NewInitGroup(groupName *string, groupId *float64) InitGroup
• type InitPackage
  • func InitPackage_Apt(packageName *string, options *NamedPackageOptions) InitPackage
  • func InitPackage_Msi(location *string, options *LocationPackageOptions) InitPackage
  • func InitPackage_Python(packageName *string, options *NamedPackageOptions) InitPackage
  • func InitPackage_Rpm(location *string, options *LocationPackageOptions) InitPackage
  • func InitPackage_RubyGem(gemName *string, options *NamedPackageOptions) InitPackage
  • func InitPackage_Yum(packageName *string, options *NamedPackageOptions) InitPackage
  • func NewInitPackage(type_ *string, versions *[]*string, packageName *string, ...) InitPackage
• type InitService
  • func InitService_Disable(serviceName *string) InitService
  • func InitService_Enable(serviceName *string, options *InitServiceOptions) InitService
• type InitServiceOptions
• type InitServiceRestartHandle
  • func NewInitServiceRestartHandle() InitServiceRestartHandle
• type InitSource
  • func InitSource_FromAsset(targetDirectory *string, path *string, options *InitSourceAssetOptions) InitSource
  • func InitSource_FromExistingAsset(targetDirectory *string, asset awss3assets.Asset, options *InitSourceOptions) InitSource
  • func InitSource_FromGitHub(targetDirectory *string, owner *string, repo *string, refSpec *string, ...) InitSource
  • func InitSource_FromS3Object(targetDirectory *string, bucket awss3.IBucket, key *string, ...) InitSource
  • func InitSource_FromUrl(targetDirectory *string, url *string, options *InitSourceOptions) InitSource
• type InitSourceAssetOptions
• type InitSourceOptions
• type InitUser
  • func InitUser_FromName(userName *string, options *InitUserOptions) InitUser
  • func NewInitUser(userName *string, userOptions *InitUserOptions) InitUser
• type InitUserOptions
• type Instance
  • func NewInstance(scope constructs.Construct, id *string, props *InstanceProps) Instance
• type InstanceArchitecture
• type InstanceClass
• type InstanceInitiatedShutdownBehavior
• type InstanceProps
• type InstanceRequireImdsv2Aspect
  • func NewInstanceRequireImdsv2Aspect(props *InstanceRequireImdsv2AspectProps) InstanceRequireImdsv2Aspect
• type InstanceRequireImdsv2AspectProps
• type InstanceSize
• type InstanceType
  • func InstanceType_Of(instanceClass InstanceClass, instanceSize InstanceSize) InstanceType
  • func NewInstanceType(instanceTypeIdentifier *string) InstanceType
• type InterfaceVpcEndpoint
  • func NewInterfaceVpcEndpoint(scope constructs.Construct, id *string, props *InterfaceVpcEndpointProps) InterfaceVpcEndpoint
• type InterfaceVpcEndpointAttributes
• type InterfaceVpcEndpointAwsService
  • func InterfaceVpcEndpointAwsService_ACCESS_ANALYZER() InterfaceVpcEndpointAwsService
  • func InterfaceVpcEndpointAwsService_ACCOUNT_MANAGEMENT() InterfaceVpcEndpointAwsService
  • func InterfaceVpcEndpointAwsService_AIRFLOW_API() InterfaceVpcEndpointAwsService
  • func InterfaceVpcEndpointAwsService_AIRFLOW_ENV() InterfaceVpcEndpointAwsService
  • func InterfaceVpcEndpointAwsService_AIRFLOW_OPS() InterfaceVpcEndpointAwsService
  • func InterfaceVpcEndpointAwsService_APIGATEWAY() InterfaceVpcEndpointAwsService
  • func InterfaceVpcEndpointAwsService_APPLICATION_AUTOSCALING() InterfaceVpcEndpointAwsService
  • func InterfaceVpcEndpointAwsService_APPLICATION_MIGRATION_SERVICE() InterfaceVpcEndpointAwsService
  • func InterfaceVpcEndpointAwsService_APPSTREAM_API() InterfaceVpcEndpointAwsService
  • func InterfaceVpcEndpointAwsService_APPSTREAM_STREAMING() InterfaceVpcEndpointAwsService
  • func InterfaceVpcEndpointAwsService_APP_MESH() InterfaceVpcEndpointAwsService
  • func InterfaceVpcEndpointAwsService_APP_RUNNER() InterfaceVpcEndpointAwsService
  • func InterfaceVpcEndpointAwsService_APP_RUNNER_REQUESTS() InterfaceVpcEndpointAwsService
  • func InterfaceVpcEndpointAwsService_APP_SYNC() InterfaceVpcEndpointAwsService
  • func InterfaceVpcEndpointAwsService_ATHENA() InterfaceVpcEndpointAwsService
  • func InterfaceVpcEndpointAwsService_AUDIT_MANAGER() InterfaceVpcEndpointAwsService
  • func InterfaceVpcEndpointAwsService_AUTOSCALING() InterfaceVpcEndpointAwsService
  • func InterfaceVpcEndpointAwsService_AUTOSCALING_PLANS() InterfaceVpcEndpointAwsService
  • func InterfaceVpcEndpointAwsService_BACKUP() InterfaceVpcEndpointAwsService
  • func InterfaceVpcEndpointAwsService_BACKUP_GATEWAY() InterfaceVpcEndpointAwsService
  • func InterfaceVpcEndpointAwsService_BATCH() InterfaceVpcEndpointAwsService
  • func InterfaceVpcEndpointAwsService_BILLING_CONDUCTOR() InterfaceVpcEndpointAwsService
  • func InterfaceVpcEndpointAwsService_BRAKET() InterfaceVpcEndpointAwsService
  • func InterfaceVpcEndpointAwsService_CLOUDFORMATION() InterfaceVpcEndpointAwsService
  • func InterfaceVpcEndpointAwsService_CLOUDHSM() InterfaceVpcEndpointAwsService
  • func InterfaceVpcEndpointAwsService_CLOUDTRAIL() InterfaceVpcEndpointAwsService
  • func InterfaceVpcEndpointAwsService_CLOUDWATCH() InterfaceVpcEndpointAwsService
  • func InterfaceVpcEndpointAwsService_CLOUDWATCH_EVENTS() InterfaceVpcEndpointAwsService
  • func InterfaceVpcEndpointAwsService_CLOUDWATCH_EVIDENTLY() InterfaceVpcEndpointAwsService
  • func InterfaceVpcEndpointAwsService_CLOUDWATCH_EVIDENTLY_DATAPLANE() InterfaceVpcEndpointAwsService
  • func InterfaceVpcEndpointAwsService_CLOUDWATCH_LOGS() InterfaceVpcEndpointAwsService
  • func InterfaceVpcEndpointAwsService_CLOUDWATCH_MONITORING() InterfaceVpcEndpointAwsService
  • func InterfaceVpcEndpointAwsService_CLOUDWATCH_RUM() InterfaceVpcEndpointAwsService
  • func InterfaceVpcEndpointAwsService_CLOUDWATCH_RUM_DATAPLANE() InterfaceVpcEndpointAwsService
  • func InterfaceVpcEndpointAwsService_CLOUDWATCH_SYNTHETICS() InterfaceVpcEndpointAwsService
  • func InterfaceVpcEndpointAwsService_CLOUD_CONTROL_API() InterfaceVpcEndpointAwsService
  • func InterfaceVpcEndpointAwsService_CLOUD_CONTROL_API_FIPS() InterfaceVpcEndpointAwsService
  • func InterfaceVpcEndpointAwsService_CLOUD_DIRECTORY() InterfaceVpcEndpointAwsService
  • func InterfaceVpcEndpointAwsService_CODEARTIFACT_API() InterfaceVpcEndpointAwsService
  • func InterfaceVpcEndpointAwsService_CODEARTIFACT_REPOSITORIES() InterfaceVpcEndpointAwsService
  • func InterfaceVpcEndpointAwsService_CODEBUILD() InterfaceVpcEndpointAwsService
  • func InterfaceVpcEndpointAwsService_CODEBUILD_FIPS() InterfaceVpcEndpointAwsService
  • func InterfaceVpcEndpointAwsService_CODECOMMIT() InterfaceVpcEndpointAwsService
  • func InterfaceVpcEndpointAwsService_CODECOMMIT_FIPS() InterfaceVpcEndpointAwsService
  • func InterfaceVpcEndpointAwsService_CODECOMMIT_GIT() InterfaceVpcEndpointAwsService
  • func InterfaceVpcEndpointAwsService_CODECOMMIT_GIT_FIPS() InterfaceVpcEndpointAwsService
  • func InterfaceVpcEndpointAwsService_CODEDEPLOY() InterfaceVpcEndpointAwsService
  • func InterfaceVpcEndpointAwsService_CODEDEPLOY_COMMANDS_SECURE() InterfaceVpcEndpointAwsService
  • func InterfaceVpcEndpointAwsService_CODEGURU_PROFILER() InterfaceVpcEndpointAwsService
  • func InterfaceVpcEndpointAwsService_CODEGURU_REVIEWER() InterfaceVpcEndpointAwsService
  • func InterfaceVpcEndpointAwsService_CODEPIPELINE() InterfaceVpcEndpointAwsService
  • func InterfaceVpcEndpointAwsService_CODESTAR_CONNECTIONS() InterfaceVpcEndpointAwsService
  • func InterfaceVpcEndpointAwsService_COMPREHEND() InterfaceVpcEndpointAwsService
  • func InterfaceVpcEndpointAwsService_COMPREHEND_MEDICAL() InterfaceVpcEndpointAwsService
  • func InterfaceVpcEndpointAwsService_CONFIG() InterfaceVpcEndpointAwsService
  • func InterfaceVpcEndpointAwsService_CONNECT_APP_INTEGRATIONS() InterfaceVpcEndpointAwsService
  • func InterfaceVpcEndpointAwsService_CONNECT_CASES() InterfaceVpcEndpointAwsService
  • func InterfaceVpcEndpointAwsService_CONNECT_CONNECT_CAMPAIGNS() InterfaceVpcEndpointAwsService
  • func InterfaceVpcEndpointAwsService_CONNECT_PROFILE() InterfaceVpcEndpointAwsService
  • func InterfaceVpcEndpointAwsService_CONNECT_VOICEID() InterfaceVpcEndpointAwsService
  • func InterfaceVpcEndpointAwsService_CONNECT_WISDOM() InterfaceVpcEndpointAwsService
  • func InterfaceVpcEndpointAwsService_DATABASE_MIGRATION_SERVICE() InterfaceVpcEndpointAwsService
  • func InterfaceVpcEndpointAwsService_DATABASE_MIGRATION_SERVICE_FIPS() InterfaceVpcEndpointAwsService
  • func InterfaceVpcEndpointAwsService_DATASYNC() InterfaceVpcEndpointAwsService
  • func InterfaceVpcEndpointAwsService_DATA_EXCHANGE() InterfaceVpcEndpointAwsService
  • func InterfaceVpcEndpointAwsService_DEVOPS_GURU() InterfaceVpcEndpointAwsService
  • func InterfaceVpcEndpointAwsService_EBS_DIRECT() InterfaceVpcEndpointAwsService
  • func InterfaceVpcEndpointAwsService_EC2() InterfaceVpcEndpointAwsService
  • func InterfaceVpcEndpointAwsService_EC2_MESSAGES() InterfaceVpcEndpointAwsService
  • func InterfaceVpcEndpointAwsService_ECR() InterfaceVpcEndpointAwsService
  • func InterfaceVpcEndpointAwsService_ECR_DOCKER() InterfaceVpcEndpointAwsService
  • func InterfaceVpcEndpointAwsService_ECS() InterfaceVpcEndpointAwsService
  • func InterfaceVpcEndpointAwsService_ECS_AGENT() InterfaceVpcEndpointAwsService
  • func InterfaceVpcEndpointAwsService_ECS_TELEMETRY() InterfaceVpcEndpointAwsService
  • func InterfaceVpcEndpointAwsService_EKS() InterfaceVpcEndpointAwsService
  • func InterfaceVpcEndpointAwsService_ELASTICACHE() InterfaceVpcEndpointAwsService
  • func InterfaceVpcEndpointAwsService_ELASTICACHE_FIPS() InterfaceVpcEndpointAwsService
  • func InterfaceVpcEndpointAwsService_ELASTIC_BEANSTALK() InterfaceVpcEndpointAwsService
  • func InterfaceVpcEndpointAwsService_ELASTIC_BEANSTALK_HEALTH() InterfaceVpcEndpointAwsService
  • func InterfaceVpcEndpointAwsService_ELASTIC_DISASTER_RECOVERY() InterfaceVpcEndpointAwsService
  • func InterfaceVpcEndpointAwsService_ELASTIC_FILESYSTEM() InterfaceVpcEndpointAwsService
  • func InterfaceVpcEndpointAwsService_ELASTIC_FILESYSTEM_FIPS() InterfaceVpcEndpointAwsService
  • func InterfaceVpcEndpointAwsService_ELASTIC_INFERENCE_RUNTIME() InterfaceVpcEndpointAwsService
  • func InterfaceVpcEndpointAwsService_ELASTIC_LOAD_BALANCING() InterfaceVpcEndpointAwsService
  • func InterfaceVpcEndpointAwsService_EMAIL_SMTP() InterfaceVpcEndpointAwsService
  • func InterfaceVpcEndpointAwsService_EMR() InterfaceVpcEndpointAwsService
  • func InterfaceVpcEndpointAwsService_EMR_EKS() InterfaceVpcEndpointAwsService
  • func InterfaceVpcEndpointAwsService_EMR_SERVERLESS() InterfaceVpcEndpointAwsService
  • func InterfaceVpcEndpointAwsService_EVENTBRIDGE() InterfaceVpcEndpointAwsService
  • func InterfaceVpcEndpointAwsService_FAULT_INJECTION_SIMULATOR() InterfaceVpcEndpointAwsService
  • func InterfaceVpcEndpointAwsService_FINSPACE() InterfaceVpcEndpointAwsService
  • func InterfaceVpcEndpointAwsService_FINSPACE_API() InterfaceVpcEndpointAwsService
  • func InterfaceVpcEndpointAwsService_FORECAST() InterfaceVpcEndpointAwsService
  • func InterfaceVpcEndpointAwsService_FORECAST_FIPS() InterfaceVpcEndpointAwsService
  • func InterfaceVpcEndpointAwsService_FORECAST_QUERY() InterfaceVpcEndpointAwsService
  • func InterfaceVpcEndpointAwsService_FORECAST_QUERY_FIPS() InterfaceVpcEndpointAwsService
  • func InterfaceVpcEndpointAwsService_FRAUD_DETECTOR() InterfaceVpcEndpointAwsService
  • func InterfaceVpcEndpointAwsService_FSX() InterfaceVpcEndpointAwsService
  • func InterfaceVpcEndpointAwsService_FSX_FIPS() InterfaceVpcEndpointAwsService
  • func InterfaceVpcEndpointAwsService_GLUE() InterfaceVpcEndpointAwsService
  • func InterfaceVpcEndpointAwsService_GLUE_DATABREW() InterfaceVpcEndpointAwsService
  • func InterfaceVpcEndpointAwsService_GRAFANA() InterfaceVpcEndpointAwsService
  • func InterfaceVpcEndpointAwsService_GRAFANA_WORKSPACE() InterfaceVpcEndpointAwsService
  • func InterfaceVpcEndpointAwsService_GROUNDSTATION() InterfaceVpcEndpointAwsService
  • func InterfaceVpcEndpointAwsService_HEALTHLAKE() InterfaceVpcEndpointAwsService
  • func InterfaceVpcEndpointAwsService_IAM_IDENTITY_CENTER() InterfaceVpcEndpointAwsService
  • func InterfaceVpcEndpointAwsService_IAM_ROLES_ANYWHERE() InterfaceVpcEndpointAwsService
  • func InterfaceVpcEndpointAwsService_IMAGE_BUILDER() InterfaceVpcEndpointAwsService
  • func InterfaceVpcEndpointAwsService_INSPECTOR() InterfaceVpcEndpointAwsService
  • func InterfaceVpcEndpointAwsService_IOT_CORE() InterfaceVpcEndpointAwsService
  • func InterfaceVpcEndpointAwsService_IOT_CORE_DEVICE_ADVISOR() InterfaceVpcEndpointAwsService
  • func InterfaceVpcEndpointAwsService_IOT_CORE_FOR_LORAWAN() InterfaceVpcEndpointAwsService
  • func InterfaceVpcEndpointAwsService_IOT_GREENGRASS() InterfaceVpcEndpointAwsService
  • func InterfaceVpcEndpointAwsService_IOT_LORAWAN_CUPS() InterfaceVpcEndpointAwsService
  • func InterfaceVpcEndpointAwsService_IOT_LORAWAN_LNS() InterfaceVpcEndpointAwsService
  • func InterfaceVpcEndpointAwsService_IOT_ROBORUNNER() InterfaceVpcEndpointAwsService
  • func InterfaceVpcEndpointAwsService_IOT_SITEWISE_API() InterfaceVpcEndpointAwsService
  • func InterfaceVpcEndpointAwsService_IOT_SITEWISE_DATA() InterfaceVpcEndpointAwsService
  • func InterfaceVpcEndpointAwsService_IOT_TWINMAKER_API() InterfaceVpcEndpointAwsService
  • func InterfaceVpcEndpointAwsService_IOT_TWINMAKER_DATA() InterfaceVpcEndpointAwsService
  • func InterfaceVpcEndpointAwsService_KENDRA() InterfaceVpcEndpointAwsService
  • func InterfaceVpcEndpointAwsService_KENDRA_RANKING() InterfaceVpcEndpointAwsService
  • func InterfaceVpcEndpointAwsService_KEYSPACES() InterfaceVpcEndpointAwsService
  • func InterfaceVpcEndpointAwsService_KEYSPACES_FIPS() InterfaceVpcEndpointAwsService
  • func InterfaceVpcEndpointAwsService_KINESIS_FIREHOSE() InterfaceVpcEndpointAwsService
  • func InterfaceVpcEndpointAwsService_KINESIS_STREAMS() InterfaceVpcEndpointAwsService
  • func InterfaceVpcEndpointAwsService_KMS() InterfaceVpcEndpointAwsService
  • func InterfaceVpcEndpointAwsService_KMS_FIPS() InterfaceVpcEndpointAwsService
  • func InterfaceVpcEndpointAwsService_LAKE_FORMATION() InterfaceVpcEndpointAwsService
  • func InterfaceVpcEndpointAwsService_LAMBDA() InterfaceVpcEndpointAwsService
  • func InterfaceVpcEndpointAwsService_LEX_MODELS() InterfaceVpcEndpointAwsService
  • func InterfaceVpcEndpointAwsService_LEX_RUNTIME() InterfaceVpcEndpointAwsService
  • func InterfaceVpcEndpointAwsService_LICENSE_MANAGER() InterfaceVpcEndpointAwsService
  • func InterfaceVpcEndpointAwsService_LICENSE_MANAGER_FIPS() InterfaceVpcEndpointAwsService
  • func InterfaceVpcEndpointAwsService_LOOKOUT_EQUIPMENT() InterfaceVpcEndpointAwsService
  • func InterfaceVpcEndpointAwsService_LOOKOUT_METRICS() InterfaceVpcEndpointAwsService
  • func InterfaceVpcEndpointAwsService_LOOKOUT_VISION() InterfaceVpcEndpointAwsService
  • func InterfaceVpcEndpointAwsService_MACIE() InterfaceVpcEndpointAwsService
  • func InterfaceVpcEndpointAwsService_MAINFRAME_MODERNIZATION() InterfaceVpcEndpointAwsService
  • func InterfaceVpcEndpointAwsService_MEMORY_DB() InterfaceVpcEndpointAwsService
  • func InterfaceVpcEndpointAwsService_MEMORY_DB_FIPS() InterfaceVpcEndpointAwsService
  • func InterfaceVpcEndpointAwsService_MIGRATIONHUB_ORCHESTRATOR() InterfaceVpcEndpointAwsService
  • func InterfaceVpcEndpointAwsService_MIGRATIONHUB_REFACTOR_SPACES() InterfaceVpcEndpointAwsService
  • func InterfaceVpcEndpointAwsService_MIGRATIONHUB_STRATEGY() InterfaceVpcEndpointAwsService
  • func InterfaceVpcEndpointAwsService_NIMBLE_STUDIO() InterfaceVpcEndpointAwsService
  • func InterfaceVpcEndpointAwsService_OMICS_ANALYTICS() InterfaceVpcEndpointAwsService
  • func InterfaceVpcEndpointAwsService_OMICS_CONTROL_STORAGE() InterfaceVpcEndpointAwsService
  • func InterfaceVpcEndpointAwsService_OMICS_STORAGE() InterfaceVpcEndpointAwsService
  • func InterfaceVpcEndpointAwsService_OMICS_TAGS() InterfaceVpcEndpointAwsService
  • func InterfaceVpcEndpointAwsService_OMICS_WORKFLOWS() InterfaceVpcEndpointAwsService
  • func InterfaceVpcEndpointAwsService_PANORAMA() InterfaceVpcEndpointAwsService
  • func InterfaceVpcEndpointAwsService_PINPOINT() InterfaceVpcEndpointAwsService
  • func InterfaceVpcEndpointAwsService_POLLY() InterfaceVpcEndpointAwsService
  • func InterfaceVpcEndpointAwsService_PRIVATE_5G() InterfaceVpcEndpointAwsService
  • func InterfaceVpcEndpointAwsService_PRIVATE_CERTIFICATE_AUTHORITY() InterfaceVpcEndpointAwsService
  • func InterfaceVpcEndpointAwsService_PROMETHEUS() InterfaceVpcEndpointAwsService
  • func InterfaceVpcEndpointAwsService_PROMETHEUS_WORKSPACES() InterfaceVpcEndpointAwsService
  • func InterfaceVpcEndpointAwsService_PROTON() InterfaceVpcEndpointAwsService
  • func InterfaceVpcEndpointAwsService_QLDB() InterfaceVpcEndpointAwsService
  • func InterfaceVpcEndpointAwsService_RDS() InterfaceVpcEndpointAwsService
  • func InterfaceVpcEndpointAwsService_RDS_DATA() InterfaceVpcEndpointAwsService
  • func InterfaceVpcEndpointAwsService_REDSHIFT() InterfaceVpcEndpointAwsService
  • func InterfaceVpcEndpointAwsService_REDSHIFT_DATA() InterfaceVpcEndpointAwsService
  • func InterfaceVpcEndpointAwsService_REDSHIFT_FIPS() InterfaceVpcEndpointAwsService
  • func InterfaceVpcEndpointAwsService_REKOGNITION() InterfaceVpcEndpointAwsService
  • func InterfaceVpcEndpointAwsService_REKOGNITION_FIPS() InterfaceVpcEndpointAwsService
  • func InterfaceVpcEndpointAwsService_ROBOMAKER() InterfaceVpcEndpointAwsService
  • func InterfaceVpcEndpointAwsService_S3() InterfaceVpcEndpointAwsService
  • func InterfaceVpcEndpointAwsService_S3_MULTI_REGION_ACCESS_POINTS() InterfaceVpcEndpointAwsService
  • func InterfaceVpcEndpointAwsService_S3_OUTPOSTS() InterfaceVpcEndpointAwsService
  • func InterfaceVpcEndpointAwsService_SAGEMAKER_API() InterfaceVpcEndpointAwsService
  • func InterfaceVpcEndpointAwsService_SAGEMAKER_FEATURESTORE_RUNTIME() InterfaceVpcEndpointAwsService
  • func InterfaceVpcEndpointAwsService_SAGEMAKER_METRICS() InterfaceVpcEndpointAwsService
  • func InterfaceVpcEndpointAwsService_SAGEMAKER_NOTEBOOK() InterfaceVpcEndpointAwsService
  • func InterfaceVpcEndpointAwsService_SAGEMAKER_RUNTIME() InterfaceVpcEndpointAwsService
  • func InterfaceVpcEndpointAwsService_SAGEMAKER_RUNTIME_FIPS() InterfaceVpcEndpointAwsService
  • func InterfaceVpcEndpointAwsService_SAGEMAKER_STUDIO() InterfaceVpcEndpointAwsService
  • func InterfaceVpcEndpointAwsService_SECRETS_MANAGER() InterfaceVpcEndpointAwsService
  • func InterfaceVpcEndpointAwsService_SECURITYHUB() InterfaceVpcEndpointAwsService
  • func InterfaceVpcEndpointAwsService_SERVER_MIGRATION_SERVICE() InterfaceVpcEndpointAwsService
  • func InterfaceVpcEndpointAwsService_SERVER_MIGRATION_SERVICE_AWSCONNECTOR() InterfaceVpcEndpointAwsService
  • func InterfaceVpcEndpointAwsService_SERVER_MIGRATION_SERVICE_FIPS() InterfaceVpcEndpointAwsService
  • func InterfaceVpcEndpointAwsService_SERVICE_CATALOG() InterfaceVpcEndpointAwsService
  • func InterfaceVpcEndpointAwsService_SERVICE_CATALOG_APPREGISTRY() InterfaceVpcEndpointAwsService
  • func InterfaceVpcEndpointAwsService_SES() InterfaceVpcEndpointAwsService
  • func InterfaceVpcEndpointAwsService_SNOW_DEVICE_MANAGEMENT() InterfaceVpcEndpointAwsService
  • func InterfaceVpcEndpointAwsService_SNS() InterfaceVpcEndpointAwsService
  • func InterfaceVpcEndpointAwsService_SQS() InterfaceVpcEndpointAwsService
  • func InterfaceVpcEndpointAwsService_SSM() InterfaceVpcEndpointAwsService
  • func InterfaceVpcEndpointAwsService_SSM_CONTACTS() InterfaceVpcEndpointAwsService
  • func InterfaceVpcEndpointAwsService_SSM_INCIDENTS() InterfaceVpcEndpointAwsService
  • func InterfaceVpcEndpointAwsService_SSM_MESSAGES() InterfaceVpcEndpointAwsService
  • func InterfaceVpcEndpointAwsService_STEP_FUNCTIONS() InterfaceVpcEndpointAwsService
  • func InterfaceVpcEndpointAwsService_STEP_FUNCTIONS_SYNC() InterfaceVpcEndpointAwsService
  • func InterfaceVpcEndpointAwsService_STORAGE_GATEWAY() InterfaceVpcEndpointAwsService
  • func InterfaceVpcEndpointAwsService_STS() InterfaceVpcEndpointAwsService
  • func InterfaceVpcEndpointAwsService_TEXTRACT() InterfaceVpcEndpointAwsService
  • func InterfaceVpcEndpointAwsService_TEXTRACT_FIPS() InterfaceVpcEndpointAwsService
  • func InterfaceVpcEndpointAwsService_TRANSCRIBE() InterfaceVpcEndpointAwsService
  • func InterfaceVpcEndpointAwsService_TRANSCRIBE_STREAMING() InterfaceVpcEndpointAwsService
  • func InterfaceVpcEndpointAwsService_TRANSFER() InterfaceVpcEndpointAwsService
  • func InterfaceVpcEndpointAwsService_TRANSFER_SERVER() InterfaceVpcEndpointAwsService
  • func InterfaceVpcEndpointAwsService_TRANSLATE() InterfaceVpcEndpointAwsService
  • func InterfaceVpcEndpointAwsService_VERIFIED_PERMISSIONS() InterfaceVpcEndpointAwsService
  • func InterfaceVpcEndpointAwsService_WORKSPACES() InterfaceVpcEndpointAwsService
  • func InterfaceVpcEndpointAwsService_XRAY() InterfaceVpcEndpointAwsService
  • func NewInterfaceVpcEndpointAwsService(name *string, prefix *string, port *float64) InterfaceVpcEndpointAwsService
• type InterfaceVpcEndpointOptions
• type InterfaceVpcEndpointProps
• type InterfaceVpcEndpointService
  • func NewInterfaceVpcEndpointService(name *string, port *float64) InterfaceVpcEndpointService
• type IpAddresses
• type LaunchTemplate
  • func NewLaunchTemplate(scope constructs.Construct, id *string, props *LaunchTemplateProps) LaunchTemplate
• type LaunchTemplateAttributes
• type LaunchTemplateHttpTokens
• type LaunchTemplateProps
• type LaunchTemplateRequireImdsv2Aspect
  • func NewLaunchTemplateRequireImdsv2Aspect(props *LaunchTemplateRequireImdsv2AspectProps) LaunchTemplateRequireImdsv2Aspect
• type LaunchTemplateRequireImdsv2AspectProps
• type LaunchTemplateSpecialVersions
  • func NewLaunchTemplateSpecialVersions() LaunchTemplateSpecialVersions
• type LaunchTemplateSpotOptions
• type LinuxUserDataOptions
• type LocationPackageOptions
• type LogFormat
  • func LogFormat_ACCOUNT_ID() LogFormat
  • func LogFormat_ACTION() LogFormat
  • func LogFormat_ALL_DEFAULT_FIELDS() LogFormat
  • func LogFormat_AZ_ID() LogFormat
  • func LogFormat_BYTES() LogFormat
  • func LogFormat_Custom(formatString *string) LogFormat
  • func LogFormat_DST_ADDR() LogFormat
  • func LogFormat_DST_PORT() LogFormat
  • func LogFormat_END_TIMESTAMP() LogFormat
  • func LogFormat_FLOW_DIRECTION() LogFormat
  • func LogFormat_Field(field *string) LogFormat
  • func LogFormat_INSTANCE_ID() LogFormat
  • func LogFormat_INTERFACE_ID() LogFormat
  • func LogFormat_LOG_STATUS() LogFormat
  • func LogFormat_PACKETS() LogFormat
  • func LogFormat_PKT_DST_ADDR() LogFormat
  • func LogFormat_PKT_DST_AWS_SERVICE() LogFormat
  • func LogFormat_PKT_SRC_ADDR() LogFormat
  • func LogFormat_PKT_SRC_AWS_SERVICE() LogFormat
  • func LogFormat_PROTOCOL() LogFormat
  • func LogFormat_REGION() LogFormat
  • func LogFormat_SRC_ADDR() LogFormat
  • func LogFormat_SRC_PORT() LogFormat
  • func LogFormat_START_TIMESTAMP() LogFormat
  • func LogFormat_SUBLOCATION_ID() LogFormat
  • func LogFormat_SUBLOCATION_TYPE() LogFormat
  • func LogFormat_SUBNET_ID() LogFormat
  • func LogFormat_TCP_FLAGS() LogFormat
  • func LogFormat_TRAFFIC_PATH() LogFormat
  • func LogFormat_TRAFFIC_TYPE() LogFormat
  • func LogFormat_VERSION() LogFormat
  • func LogFormat_VPC_ID() LogFormat
  • func NewLogFormat(value *string) LogFormat
• type LookupMachineImage
  • func NewLookupMachineImage(props *LookupMachineImageProps) LookupMachineImage
• type LookupMachineImageProps
• type MachineImage
• type MachineImageConfig
• type MultipartBody
  • func MultipartBody_FromRawBody(opts *MultipartBodyOptions) MultipartBody
  • func MultipartBody_FromUserData(userData UserData, contentType *string) MultipartBody
• type MultipartBodyOptions
• type MultipartUserData
  • func NewMultipartUserData(opts *MultipartUserDataOptions) MultipartUserData
• type MultipartUserDataOptions
• type NamedPackageOptions
• type NatGatewayProps
• type NatInstanceImage
  • func NewNatInstanceImage() NatInstanceImage
• type NatInstanceProps
• type NatInstanceProvider
  • func NatInstanceProvider_Instance(props *NatInstanceProps) NatInstanceProvider
  • func NatProvider_Instance(props *NatInstanceProps) NatInstanceProvider
  • func NewNatInstanceProvider(props *NatInstanceProps) NatInstanceProvider
• type NatProvider
  • func NatInstanceProvider_Gateway(props *NatGatewayProps) NatProvider
  • func NatProvider_Gateway(props *NatGatewayProps) NatProvider
• type NatTrafficDirection
• type NetworkAcl
  • func NewNetworkAcl(scope constructs.Construct, id *string, props *NetworkAclProps) NetworkAcl
• type NetworkAclEntry
  • func NewNetworkAclEntry(scope constructs.Construct, id *string, props *NetworkAclEntryProps) NetworkAclEntry
• type NetworkAclEntryProps
• type NetworkAclProps
• type OperatingSystemType
• type Peer
  • func NewPeer() Peer
• type PlacementGroup
  • func NewPlacementGroup(scope constructs.Construct, id *string, props *PlacementGroupProps) PlacementGroup
• type PlacementGroupProps
• type PlacementGroupSpreadLevel
• type PlacementGroupStrategy
• type Port
  • func NewPort(props *PortProps) Port
  • func Port_Ah() Port
  • func Port_AllIcmp() Port
  • func Port_AllIcmpV6() Port
  • func Port_AllTcp() Port
  • func Port_AllTraffic() Port
  • func Port_AllUdp() Port
  • func Port_Esp() Port
  • func Port_IcmpPing() Port
  • func Port_IcmpType(type_ *float64) Port
  • func Port_IcmpTypeAndCode(type_ *float64, code *float64) Port
  • func Port_Tcp(port *float64) Port
  • func Port_TcpRange(startPort *float64, endPort *float64) Port
  • func Port_Udp(port *float64) Port
  • func Port_UdpRange(startPort *float64, endPort *float64) Port
• type PortProps
• type PrefixList
  • func NewPrefixList(scope constructs.Construct, id *string, props *PrefixListProps) PrefixList
• type PrefixListOptions
• type PrefixListProps
• type PrivateSubnet
  • func NewPrivateSubnet(scope constructs.Construct, id *string, props *PrivateSubnetProps) PrivateSubnet
• type PrivateSubnetAttributes
• type PrivateSubnetProps
• type Protocol
• type PublicSubnet
  • func NewPublicSubnet(scope constructs.Construct, id *string, props *PublicSubnetProps) PublicSubnet
• type PublicSubnetAttributes
• type PublicSubnetProps
• type RequestedSubnet
• type ResolveSsmParameterAtLaunchImage
  • func NewResolveSsmParameterAtLaunchImage(parameterName *string, props *SsmParameterImageOptions) ResolveSsmParameterAtLaunchImage
• type RouterType
• type RuleScope
• type S3DestinationOptions
• type S3DownloadOptions
• type SecurityGroup
  • func NewSecurityGroup(scope constructs.Construct, id *string, props *SecurityGroupProps) SecurityGroup
• type SecurityGroupImportOptions
• type SecurityGroupProps
• type SelectedSubnets
• type ServiceManager
• type SpotInstanceInterruption
• type SpotRequestType
• type SsmParameterImageOptions
• type Subnet
  • func NewSubnet(scope constructs.Construct, id *string, props *SubnetProps) Subnet
• type SubnetAttributes
• type SubnetConfiguration
• type SubnetFilter
  • func SubnetFilter_AvailabilityZones(availabilityZones *[]*string) SubnetFilter
  • func SubnetFilter_ByCidrMask(mask *float64) SubnetFilter
  • func SubnetFilter_ByIds(subnetIds *[]*string) SubnetFilter
  • func SubnetFilter_ContainsIpAddresses(ipv4addrs *[]*string) SubnetFilter
  • func SubnetFilter_OnePerAz() SubnetFilter
• type SubnetIpamOptions
• type SubnetNetworkAclAssociation
  • func NewSubnetNetworkAclAssociation(scope constructs.Construct, id *string, ...) SubnetNetworkAclAssociation
• type SubnetNetworkAclAssociationProps
• type SubnetProps
• type SubnetSelection
• type SubnetType
• type SystemdConfigFileOptions
• type TrafficDirection
• type TransportProtocol
• type UserData
  • func MultipartUserData_Custom(content *string) UserData
  • func MultipartUserData_ForLinux(options *LinuxUserDataOptions) UserData
  • func MultipartUserData_ForOperatingSystem(os OperatingSystemType) UserData
  • func MultipartUserData_ForWindows(options *WindowsUserDataOptions) UserData
  • func UserData_Custom(content *string) UserData
  • func UserData_ForLinux(options *LinuxUserDataOptions) UserData
  • func UserData_ForOperatingSystem(os OperatingSystemType) UserData
  • func UserData_ForWindows(options *WindowsUserDataOptions) UserData
• type Volume
  • func NewVolume(scope constructs.Construct, id *string, props *VolumeProps) Volume
• type VolumeAttributes
• type VolumeProps
• type Vpc
  • func NewVpc(scope constructs.Construct, id *string, props *VpcProps) Vpc
• type VpcAttributes
• type VpcEndpoint
• type VpcEndpointService
  • func NewVpcEndpointService(scope constructs.Construct, id *string, props *VpcEndpointServiceProps) VpcEndpointService
• type VpcEndpointServiceProps
• type VpcEndpointType
• type VpcIpamOptions
• type VpcLookupOptions
• type VpcProps
• type VpnConnection
  • func NewVpnConnection(scope constructs.Construct, id *string, props *VpnConnectionProps) VpnConnection
• type VpnConnectionAttributes
• type VpnConnectionBase
• type VpnConnectionOptions
• type VpnConnectionProps
• type VpnConnectionType
• type VpnGateway
  • func NewVpnGateway(scope constructs.Construct, id *string, props *VpnGatewayProps) VpnGateway
• type VpnGatewayProps
• type VpnPort
• type VpnTunnelOption
• type WindowsImage
  • func NewWindowsImage(version WindowsVersion, props *WindowsImageProps) WindowsImage
• type WindowsImageProps
• type WindowsUserDataOptions
• type WindowsVersion

Functions

func AmazonLinux2022ImageSsmParameter_SsmParameterName

func AmazonLinux2022ImageSsmParameter_SsmParameterName(props *AmazonLinux2022ImageSsmParameterProps) *string

Generates a SSM Parameter name for a specific amazon linux 2022 AMI.

Example values:

"/aws/service/ami-amazon-linux-latest/al2022-ami-kernel-5.15-x86_64",
"/aws/service/ami-amazon-linux-latest/al2022-ami-kernel-default-x86_64",
"/aws/service/ami-amazon-linux-latest/al2022-ami-minimal-kernel-5.15-arm64",
"/aws/service/ami-amazon-linux-latest/al2022-ami-minimal-kernel-5.15-x86_64",
"/aws/service/ami-amazon-linux-latest/al2022-ami-kernel-5.15-arm64",
"/aws/service/ami-amazon-linux-latest/al2022-ami-minimal-kernel-default-arm64",
"/aws/service/ami-amazon-linux-latest/al2022-ami-minimal-kernel-default-x86_64",

"/aws/service/ami-amazon-linux-latest/al2022-ami-kernel-default-arm64",.

func AmazonLinux2023ImageSsmParameter_SsmParameterName

func AmazonLinux2023ImageSsmParameter_SsmParameterName(props *AmazonLinux2023ImageSsmParameterProps) *string

Generates a SSM Parameter name for a specific amazon linux 2022 AMI.

Example values:

"/aws/service/ami-amazon-linux-latest/al2023-ami-kernel-6.1-arm64",
"/aws/service/ami-amazon-linux-latest/al2023-ami-kernel-6.1-x86_64",
"/aws/service/ami-amazon-linux-latest/al2023-ami-minimal-kernel-6.1-arm64",
"/aws/service/ami-amazon-linux-latest/al2023-ami-minimal-kernel-6.1-x86_64",
"/aws/service/ami-amazon-linux-latest/al2023-ami-minimal-kernel-default-arm64",
"/aws/service/ami-amazon-linux-latest/al2023-ami-kernel-default-x86_64",
"/aws/service/ami-amazon-linux-latest/al2023-ami-minimal-kernel-default-x86_64",

"/aws/service/ami-amazon-linux-latest/al2023-ami-kernel-default-arm64",.

func AmazonLinux2ImageSsmParameter_SsmParameterName

func AmazonLinux2ImageSsmParameter_SsmParameterName(props *AmazonLinux2ImageSsmParameterProps) *string

Generates a SSM Parameter name for a specific amazon linux 2 AMI.

Example values:

"/aws/service/ami-amazon-linux-latest/amzn2-ami-hvm-x86_64-ebs",
"/aws/service/ami-amazon-linux-latest/amzn2-ami-hvm-x86_64-gp2",
"/aws/service/ami-amazon-linux-latest/amzn2-ami-kernel-5.10-hvm-x86_64-ebs",
"/aws/service/ami-amazon-linux-latest/amzn2-ami-hvm-arm64-gp2",
"/aws/service/ami-amazon-linux-latest/amzn2-ami-minimal-hvm-arm64-ebs",
"/aws/service/ami-amazon-linux-latest/amzn2-ami-kernel-5.10-hvm-arm64-gp2",
"/aws/service/ami-amazon-linux-latest/amzn2-ami-kernel-5.10-hvm-x86_64-gp2",

"/aws/service/ami-amazon-linux-latest/amzn2-ami-minimal-hvm-x86_64-ebs".

func AmazonLinuxImage_SsmParameterName

func AmazonLinuxImage_SsmParameterName(props *AmazonLinuxImageProps) *string

Return the SSM parameter name that will contain the Amazon Linux image with the given attributes.

func BastionHostLinux_IsConstruct

func BastionHostLinux_IsConstruct(x interface{}) *bool

Checks if `x` is a construct.

Use this method instead of `instanceof` to properly detect `Construct` instances, even when the construct library is symlinked.

Explanation: in JavaScript, multiple copies of the `constructs` library on disk are seen as independent, completely different libraries. As a consequence, the class `Construct` in each copy of the `constructs` library is seen as a different class, and an instance of one class will not test as `instanceof` the other class. `npm install` will not create installations like this, but users may manually symlink construct libraries together or use a monorepo tool: in those cases, multiple copies of the `constructs` library can be accidentally installed, and `instanceof` will behave unpredictably. It is safest to avoid using `instanceof`, and using this type-testing method instead.

Returns: true if `x` is an object created from a class which extends `Construct`.

func BastionHostLinux_IsOwnedResource

func BastionHostLinux_IsOwnedResource(construct constructs.IConstruct) *bool

Returns true if the construct was created by CDK, and false otherwise.

func BastionHostLinux_IsResource

func BastionHostLinux_IsResource(construct constructs.IConstruct) *bool

Check whether the given construct is a Resource.

func CfnCapacityReservationFleet_CFN_RESOURCE_TYPE_NAME

func CfnCapacityReservationFleet_CFN_RESOURCE_TYPE_NAME() *string

func CfnCapacityReservationFleet_IsCfnElement

func CfnCapacityReservationFleet_IsCfnElement(x interface{}) *bool

Returns `true` if a construct is a stack element (i.e. part of the synthesized cloudformation template).

Uses duck-typing instead of `instanceof` to allow stack elements from different versions of this library to be included in the same stack.

Returns: The construct as a stack element or undefined if it is not a stack element.

func CfnCapacityReservationFleet_IsCfnResource

func CfnCapacityReservationFleet_IsCfnResource(construct constructs.IConstruct) *bool

Check whether the given construct is a CfnResource.

func CfnCapacityReservationFleet_IsConstruct

func CfnCapacityReservationFleet_IsConstruct(x interface{}) *bool

Checks if `x` is a construct.

Use this method instead of `instanceof` to properly detect `Construct` instances, even when the construct library is symlinked.

Explanation: in JavaScript, multiple copies of the `constructs` library on disk are seen as independent, completely different libraries. As a consequence, the class `Construct` in each copy of the `constructs` library is seen as a different class, and an instance of one class will not test as `instanceof` the other class. `npm install` will not create installations like this, but users may manually symlink construct libraries together or use a monorepo tool: in those cases, multiple copies of the `constructs` library can be accidentally installed, and `instanceof` will behave unpredictably. It is safest to avoid using `instanceof`, and using this type-testing method instead.

Returns: true if `x` is an object created from a class which extends `Construct`.

func CfnCapacityReservation_CFN_RESOURCE_TYPE_NAME

func CfnCapacityReservation_CFN_RESOURCE_TYPE_NAME() *string

func CfnCapacityReservation_IsCfnElement

func CfnCapacityReservation_IsCfnElement(x interface{}) *bool

Returns `true` if a construct is a stack element (i.e. part of the synthesized cloudformation template).

Uses duck-typing instead of `instanceof` to allow stack elements from different versions of this library to be included in the same stack.

Returns: The construct as a stack element or undefined if it is not a stack element.

func CfnCapacityReservation_IsCfnResource

func CfnCapacityReservation_IsCfnResource(construct constructs.IConstruct) *bool

Check whether the given construct is a CfnResource.

func CfnCapacityReservation_IsConstruct

func CfnCapacityReservation_IsConstruct(x interface{}) *bool

Checks if `x` is a construct.

Use this method instead of `instanceof` to properly detect `Construct` instances, even when the construct library is symlinked.

Explanation: in JavaScript, multiple copies of the `constructs` library on disk are seen as independent, completely different libraries. As a consequence, the class `Construct` in each copy of the `constructs` library is seen as a different class, and an instance of one class will not test as `instanceof` the other class. `npm install` will not create installations like this, but users may manually symlink construct libraries together or use a monorepo tool: in those cases, multiple copies of the `constructs` library can be accidentally installed, and `instanceof` will behave unpredictably. It is safest to avoid using `instanceof`, and using this type-testing method instead.

Returns: true if `x` is an object created from a class which extends `Construct`.

func CfnCarrierGateway_CFN_RESOURCE_TYPE_NAME

func CfnCarrierGateway_CFN_RESOURCE_TYPE_NAME() *string

func CfnCarrierGateway_IsCfnElement

func CfnCarrierGateway_IsCfnElement(x interface{}) *bool

Returns `true` if a construct is a stack element (i.e. part of the synthesized cloudformation template).

Uses duck-typing instead of `instanceof` to allow stack elements from different versions of this library to be included in the same stack.

Returns: The construct as a stack element or undefined if it is not a stack element.

func CfnCarrierGateway_IsCfnResource

func CfnCarrierGateway_IsCfnResource(construct constructs.IConstruct) *bool

Check whether the given construct is a CfnResource.

func CfnCarrierGateway_IsConstruct

func CfnCarrierGateway_IsConstruct(x interface{}) *bool

Checks if `x` is a construct.

Use this method instead of `instanceof` to properly detect `Construct` instances, even when the construct library is symlinked.

Explanation: in JavaScript, multiple copies of the `constructs` library on disk are seen as independent, completely different libraries. As a consequence, the class `Construct` in each copy of the `constructs` library is seen as a different class, and an instance of one class will not test as `instanceof` the other class. `npm install` will not create installations like this, but users may manually symlink construct libraries together or use a monorepo tool: in those cases, multiple copies of the `constructs` library can be accidentally installed, and `instanceof` will behave unpredictably. It is safest to avoid using `instanceof`, and using this type-testing method instead.

Returns: true if `x` is an object created from a class which extends `Construct`.

func CfnClientVpnAuthorizationRule_CFN_RESOURCE_TYPE_NAME

func CfnClientVpnAuthorizationRule_CFN_RESOURCE_TYPE_NAME() *string

func CfnClientVpnAuthorizationRule_IsCfnElement

func CfnClientVpnAuthorizationRule_IsCfnElement(x interface{}) *bool

Returns `true` if a construct is a stack element (i.e. part of the synthesized cloudformation template).

Uses duck-typing instead of `instanceof` to allow stack elements from different versions of this library to be included in the same stack.

Returns: The construct as a stack element or undefined if it is not a stack element.

func CfnClientVpnAuthorizationRule_IsCfnResource

func CfnClientVpnAuthorizationRule_IsCfnResource(construct constructs.IConstruct) *bool

Check whether the given construct is a CfnResource.

func CfnClientVpnAuthorizationRule_IsConstruct

func CfnClientVpnAuthorizationRule_IsConstruct(x interface{}) *bool

Checks if `x` is a construct.

Use this method instead of `instanceof` to properly detect `Construct` instances, even when the construct library is symlinked.

Explanation: in JavaScript, multiple copies of the `constructs` library on disk are seen as independent, completely different libraries. As a consequence, the class `Construct` in each copy of the `constructs` library is seen as a different class, and an instance of one class will not test as `instanceof` the other class. `npm install` will not create installations like this, but users may manually symlink construct libraries together or use a monorepo tool: in those cases, multiple copies of the `constructs` library can be accidentally installed, and `instanceof` will behave unpredictably. It is safest to avoid using `instanceof`, and using this type-testing method instead.

Returns: true if `x` is an object created from a class which extends `Construct`.

func CfnClientVpnEndpoint_CFN_RESOURCE_TYPE_NAME

func CfnClientVpnEndpoint_CFN_RESOURCE_TYPE_NAME() *string

func CfnClientVpnEndpoint_IsCfnElement

func CfnClientVpnEndpoint_IsCfnElement(x interface{}) *bool

Returns `true` if a construct is a stack element (i.e. part of the synthesized cloudformation template).

Uses duck-typing instead of `instanceof` to allow stack elements from different versions of this library to be included in the same stack.

Returns: The construct as a stack element or undefined if it is not a stack element.

func CfnClientVpnEndpoint_IsCfnResource

func CfnClientVpnEndpoint_IsCfnResource(construct constructs.IConstruct) *bool

Check whether the given construct is a CfnResource.

func CfnClientVpnEndpoint_IsConstruct

func CfnClientVpnEndpoint_IsConstruct(x interface{}) *bool

Checks if `x` is a construct.

Use this method instead of `instanceof` to properly detect `Construct` instances, even when the construct library is symlinked.

Explanation: in JavaScript, multiple copies of the `constructs` library on disk are seen as independent, completely different libraries. As a consequence, the class `Construct` in each copy of the `constructs` library is seen as a different class, and an instance of one class will not test as `instanceof` the other class. `npm install` will not create installations like this, but users may manually symlink construct libraries together or use a monorepo tool: in those cases, multiple copies of the `constructs` library can be accidentally installed, and `instanceof` will behave unpredictably. It is safest to avoid using `instanceof`, and using this type-testing method instead.

Returns: true if `x` is an object created from a class which extends `Construct`.

func CfnClientVpnRoute_CFN_RESOURCE_TYPE_NAME

func CfnClientVpnRoute_CFN_RESOURCE_TYPE_NAME() *string

func CfnClientVpnRoute_IsCfnElement

func CfnClientVpnRoute_IsCfnElement(x interface{}) *bool

Returns `true` if a construct is a stack element (i.e. part of the synthesized cloudformation template).

Uses duck-typing instead of `instanceof` to allow stack elements from different versions of this library to be included in the same stack.

Returns: The construct as a stack element or undefined if it is not a stack element.

func CfnClientVpnRoute_IsCfnResource

func CfnClientVpnRoute_IsCfnResource(construct constructs.IConstruct) *bool

Check whether the given construct is a CfnResource.

func CfnClientVpnRoute_IsConstruct

func CfnClientVpnRoute_IsConstruct(x interface{}) *bool

Checks if `x` is a construct.

Use this method instead of `instanceof` to properly detect `Construct` instances, even when the construct library is symlinked.

Explanation: in JavaScript, multiple copies of the `constructs` library on disk are seen as independent, completely different libraries. As a consequence, the class `Construct` in each copy of the `constructs` library is seen as a different class, and an instance of one class will not test as `instanceof` the other class. `npm install` will not create installations like this, but users may manually symlink construct libraries together or use a monorepo tool: in those cases, multiple copies of the `constructs` library can be accidentally installed, and `instanceof` will behave unpredictably. It is safest to avoid using `instanceof`, and using this type-testing method instead.

Returns: true if `x` is an object created from a class which extends `Construct`.

func CfnClientVpnTargetNetworkAssociation_CFN_RESOURCE_TYPE_NAME

func CfnClientVpnTargetNetworkAssociation_CFN_RESOURCE_TYPE_NAME() *string

func CfnClientVpnTargetNetworkAssociation_IsCfnElement

func CfnClientVpnTargetNetworkAssociation_IsCfnElement(x interface{}) *bool

Returns `true` if a construct is a stack element (i.e. part of the synthesized cloudformation template).

Uses duck-typing instead of `instanceof` to allow stack elements from different versions of this library to be included in the same stack.

Returns: The construct as a stack element or undefined if it is not a stack element.

func CfnClientVpnTargetNetworkAssociation_IsCfnResource

func CfnClientVpnTargetNetworkAssociation_IsCfnResource(construct constructs.IConstruct) *bool

Check whether the given construct is a CfnResource.

func CfnClientVpnTargetNetworkAssociation_IsConstruct

func CfnClientVpnTargetNetworkAssociation_IsConstruct(x interface{}) *bool

Checks if `x` is a construct.

Use this method instead of `instanceof` to properly detect `Construct` instances, even when the construct library is symlinked.

Explanation: in JavaScript, multiple copies of the `constructs` library on disk are seen as independent, completely different libraries. As a consequence, the class `Construct` in each copy of the `constructs` library is seen as a different class, and an instance of one class will not test as `instanceof` the other class. `npm install` will not create installations like this, but users may manually symlink construct libraries together or use a monorepo tool: in those cases, multiple copies of the `constructs` library can be accidentally installed, and `instanceof` will behave unpredictably. It is safest to avoid using `instanceof`, and using this type-testing method instead.

Returns: true if `x` is an object created from a class which extends `Construct`.

func CfnCustomerGateway_CFN_RESOURCE_TYPE_NAME

func CfnCustomerGateway_CFN_RESOURCE_TYPE_NAME() *string

func CfnCustomerGateway_IsCfnElement

func CfnCustomerGateway_IsCfnElement(x interface{}) *bool

Returns `true` if a construct is a stack element (i.e. part of the synthesized cloudformation template).

Uses duck-typing instead of `instanceof` to allow stack elements from different versions of this library to be included in the same stack.

Returns: The construct as a stack element or undefined if it is not a stack element.

func CfnCustomerGateway_IsCfnResource

func CfnCustomerGateway_IsCfnResource(construct constructs.IConstruct) *bool

Check whether the given construct is a CfnResource.

func CfnCustomerGateway_IsConstruct

func CfnCustomerGateway_IsConstruct(x interface{}) *bool

Checks if `x` is a construct.

Use this method instead of `instanceof` to properly detect `Construct` instances, even when the construct library is symlinked.

Explanation: in JavaScript, multiple copies of the `constructs` library on disk are seen as independent, completely different libraries. As a consequence, the class `Construct` in each copy of the `constructs` library is seen as a different class, and an instance of one class will not test as `instanceof` the other class. `npm install` will not create installations like this, but users may manually symlink construct libraries together or use a monorepo tool: in those cases, multiple copies of the `constructs` library can be accidentally installed, and `instanceof` will behave unpredictably. It is safest to avoid using `instanceof`, and using this type-testing method instead.

Returns: true if `x` is an object created from a class which extends `Construct`.

func CfnDHCPOptions_CFN_RESOURCE_TYPE_NAME

func CfnDHCPOptions_CFN_RESOURCE_TYPE_NAME() *string

func CfnDHCPOptions_IsCfnElement

func CfnDHCPOptions_IsCfnElement(x interface{}) *bool

Returns `true` if a construct is a stack element (i.e. part of the synthesized cloudformation template).

Uses duck-typing instead of `instanceof` to allow stack elements from different versions of this library to be included in the same stack.

Returns: The construct as a stack element or undefined if it is not a stack element.

func CfnDHCPOptions_IsCfnResource

func CfnDHCPOptions_IsCfnResource(construct constructs.IConstruct) *bool

Check whether the given construct is a CfnResource.

func CfnDHCPOptions_IsConstruct

func CfnDHCPOptions_IsConstruct(x interface{}) *bool

Checks if `x` is a construct.

Use this method instead of `instanceof` to properly detect `Construct` instances, even when the construct library is symlinked.

Explanation: in JavaScript, multiple copies of the `constructs` library on disk are seen as independent, completely different libraries. As a consequence, the class `Construct` in each copy of the `constructs` library is seen as a different class, and an instance of one class will not test as `instanceof` the other class. `npm install` will not create installations like this, but users may manually symlink construct libraries together or use a monorepo tool: in those cases, multiple copies of the `constructs` library can be accidentally installed, and `instanceof` will behave unpredictably. It is safest to avoid using `instanceof`, and using this type-testing method instead.

Returns: true if `x` is an object created from a class which extends `Construct`.

func CfnEC2Fleet_CFN_RESOURCE_TYPE_NAME

func CfnEC2Fleet_CFN_RESOURCE_TYPE_NAME() *string

func CfnEC2Fleet_IsCfnElement

func CfnEC2Fleet_IsCfnElement(x interface{}) *bool

Returns `true` if a construct is a stack element (i.e. part of the synthesized cloudformation template).

Uses duck-typing instead of `instanceof` to allow stack elements from different versions of this library to be included in the same stack.

Returns: The construct as a stack element or undefined if it is not a stack element.

func CfnEC2Fleet_IsCfnResource

func CfnEC2Fleet_IsCfnResource(construct constructs.IConstruct) *bool

Check whether the given construct is a CfnResource.

func CfnEC2Fleet_IsConstruct

func CfnEC2Fleet_IsConstruct(x interface{}) *bool

Checks if `x` is a construct.

Use this method instead of `instanceof` to properly detect `Construct` instances, even when the construct library is symlinked.

Explanation: in JavaScript, multiple copies of the `constructs` library on disk are seen as independent, completely different libraries. As a consequence, the class `Construct` in each copy of the `constructs` library is seen as a different class, and an instance of one class will not test as `instanceof` the other class. `npm install` will not create installations like this, but users may manually symlink construct libraries together or use a monorepo tool: in those cases, multiple copies of the `constructs` library can be accidentally installed, and `instanceof` will behave unpredictably. It is safest to avoid using `instanceof`, and using this type-testing method instead.

Returns: true if `x` is an object created from a class which extends `Construct`.

func CfnEIPAssociation_CFN_RESOURCE_TYPE_NAME

func CfnEIPAssociation_CFN_RESOURCE_TYPE_NAME() *string

func CfnEIPAssociation_IsCfnElement

func CfnEIPAssociation_IsCfnElement(x interface{}) *bool

Returns `true` if a construct is a stack element (i.e. part of the synthesized cloudformation template).

Uses duck-typing instead of `instanceof` to allow stack elements from different versions of this library to be included in the same stack.

Returns: The construct as a stack element or undefined if it is not a stack element.

func CfnEIPAssociation_IsCfnResource

func CfnEIPAssociation_IsCfnResource(construct constructs.IConstruct) *bool

Check whether the given construct is a CfnResource.

func CfnEIPAssociation_IsConstruct

func CfnEIPAssociation_IsConstruct(x interface{}) *bool

Checks if `x` is a construct.

Use this method instead of `instanceof` to properly detect `Construct` instances, even when the construct library is symlinked.

Explanation: in JavaScript, multiple copies of the `constructs` library on disk are seen as independent, completely different libraries. As a consequence, the class `Construct` in each copy of the `constructs` library is seen as a different class, and an instance of one class will not test as `instanceof` the other class. `npm install` will not create installations like this, but users may manually symlink construct libraries together or use a monorepo tool: in those cases, multiple copies of the `constructs` library can be accidentally installed, and `instanceof` will behave unpredictably. It is safest to avoid using `instanceof`, and using this type-testing method instead.

Returns: true if `x` is an object created from a class which extends `Construct`.

func CfnEIP_CFN_RESOURCE_TYPE_NAME

func CfnEIP_CFN_RESOURCE_TYPE_NAME() *string

func CfnEIP_IsCfnElement

func CfnEIP_IsCfnElement(x interface{}) *bool

Returns `true` if a construct is a stack element (i.e. part of the synthesized cloudformation template).

Uses duck-typing instead of `instanceof` to allow stack elements from different versions of this library to be included in the same stack.

Returns: The construct as a stack element or undefined if it is not a stack element.

func CfnEIP_IsCfnResource

func CfnEIP_IsCfnResource(construct constructs.IConstruct) *bool

Check whether the given construct is a CfnResource.

func CfnEIP_IsConstruct

func CfnEIP_IsConstruct(x interface{}) *bool

Checks if `x` is a construct.

Use this method instead of `instanceof` to properly detect `Construct` instances, even when the construct library is symlinked.

Explanation: in JavaScript, multiple copies of the `constructs` library on disk are seen as independent, completely different libraries. As a consequence, the class `Construct` in each copy of the `constructs` library is seen as a different class, and an instance of one class will not test as `instanceof` the other class. `npm install` will not create installations like this, but users may manually symlink construct libraries together or use a monorepo tool: in those cases, multiple copies of the `constructs` library can be accidentally installed, and `instanceof` will behave unpredictably. It is safest to avoid using `instanceof`, and using this type-testing method instead.

Returns: true if `x` is an object created from a class which extends `Construct`.

func CfnEgressOnlyInternetGateway_CFN_RESOURCE_TYPE_NAME

func CfnEgressOnlyInternetGateway_CFN_RESOURCE_TYPE_NAME() *string

func CfnEgressOnlyInternetGateway_IsCfnElement

func CfnEgressOnlyInternetGateway_IsCfnElement(x interface{}) *bool

Returns `true` if a construct is a stack element (i.e. part of the synthesized cloudformation template).

Uses duck-typing instead of `instanceof` to allow stack elements from different versions of this library to be included in the same stack.

Returns: The construct as a stack element or undefined if it is not a stack element.

func CfnEgressOnlyInternetGateway_IsCfnResource

func CfnEgressOnlyInternetGateway_IsCfnResource(construct constructs.IConstruct) *bool

Check whether the given construct is a CfnResource.

func CfnEgressOnlyInternetGateway_IsConstruct

func CfnEgressOnlyInternetGateway_IsConstruct(x interface{}) *bool

Checks if `x` is a construct.

Use this method instead of `instanceof` to properly detect `Construct` instances, even when the construct library is symlinked.

Explanation: in JavaScript, multiple copies of the `constructs` library on disk are seen as independent, completely different libraries. As a consequence, the class `Construct` in each copy of the `constructs` library is seen as a different class, and an instance of one class will not test as `instanceof` the other class. `npm install` will not create installations like this, but users may manually symlink construct libraries together or use a monorepo tool: in those cases, multiple copies of the `constructs` library can be accidentally installed, and `instanceof` will behave unpredictably. It is safest to avoid using `instanceof`, and using this type-testing method instead.

Returns: true if `x` is an object created from a class which extends `Construct`.

func CfnEnclaveCertificateIamRoleAssociation_CFN_RESOURCE_TYPE_NAME

func CfnEnclaveCertificateIamRoleAssociation_CFN_RESOURCE_TYPE_NAME() *string

func CfnEnclaveCertificateIamRoleAssociation_IsCfnElement

func CfnEnclaveCertificateIamRoleAssociation_IsCfnElement(x interface{}) *bool

Returns `true` if a construct is a stack element (i.e. part of the synthesized cloudformation template).

Uses duck-typing instead of `instanceof` to allow stack elements from different versions of this library to be included in the same stack.

Returns: The construct as a stack element or undefined if it is not a stack element.

func CfnEnclaveCertificateIamRoleAssociation_IsCfnResource

func CfnEnclaveCertificateIamRoleAssociation_IsCfnResource(construct constructs.IConstruct) *bool

Check whether the given construct is a CfnResource.

func CfnEnclaveCertificateIamRoleAssociation_IsConstruct

func CfnEnclaveCertificateIamRoleAssociation_IsConstruct(x interface{}) *bool

Checks if `x` is a construct.

Use this method instead of `instanceof` to properly detect `Construct` instances, even when the construct library is symlinked.

Explanation: in JavaScript, multiple copies of the `constructs` library on disk are seen as independent, completely different libraries. As a consequence, the class `Construct` in each copy of the `constructs` library is seen as a different class, and an instance of one class will not test as `instanceof` the other class. `npm install` will not create installations like this, but users may manually symlink construct libraries together or use a monorepo tool: in those cases, multiple copies of the `constructs` library can be accidentally installed, and `instanceof` will behave unpredictably. It is safest to avoid using `instanceof`, and using this type-testing method instead.

Returns: true if `x` is an object created from a class which extends `Construct`.

func CfnFlowLog_CFN_RESOURCE_TYPE_NAME

func CfnFlowLog_CFN_RESOURCE_TYPE_NAME() *string

func CfnFlowLog_IsCfnElement

func CfnFlowLog_IsCfnElement(x interface{}) *bool

Returns `true` if a construct is a stack element (i.e. part of the synthesized cloudformation template).

Uses duck-typing instead of `instanceof` to allow stack elements from different versions of this library to be included in the same stack.

Returns: The construct as a stack element or undefined if it is not a stack element.

func CfnFlowLog_IsCfnResource

func CfnFlowLog_IsCfnResource(construct constructs.IConstruct) *bool

Check whether the given construct is a CfnResource.

func CfnFlowLog_IsConstruct

func CfnFlowLog_IsConstruct(x interface{}) *bool

Checks if `x` is a construct.

Use this method instead of `instanceof` to properly detect `Construct` instances, even when the construct library is symlinked.

Explanation: in JavaScript, multiple copies of the `constructs` library on disk are seen as independent, completely different libraries. As a consequence, the class `Construct` in each copy of the `constructs` library is seen as a different class, and an instance of one class will not test as `instanceof` the other class. `npm install` will not create installations like this, but users may manually symlink construct libraries together or use a monorepo tool: in those cases, multiple copies of the `constructs` library can be accidentally installed, and `instanceof` will behave unpredictably. It is safest to avoid using `instanceof`, and using this type-testing method instead.

Returns: true if `x` is an object created from a class which extends `Construct`.

func CfnGatewayRouteTableAssociation_CFN_RESOURCE_TYPE_NAME

func CfnGatewayRouteTableAssociation_CFN_RESOURCE_TYPE_NAME() *string

func CfnGatewayRouteTableAssociation_IsCfnElement

func CfnGatewayRouteTableAssociation_IsCfnElement(x interface{}) *bool

Returns `true` if a construct is a stack element (i.e. part of the synthesized cloudformation template).

Uses duck-typing instead of `instanceof` to allow stack elements from different versions of this library to be included in the same stack.

Returns: The construct as a stack element or undefined if it is not a stack element.

func CfnGatewayRouteTableAssociation_IsCfnResource

func CfnGatewayRouteTableAssociation_IsCfnResource(construct constructs.IConstruct) *bool

Check whether the given construct is a CfnResource.

func CfnGatewayRouteTableAssociation_IsConstruct

func CfnGatewayRouteTableAssociation_IsConstruct(x interface{}) *bool

Checks if `x` is a construct.

Use this method instead of `instanceof` to properly detect `Construct` instances, even when the construct library is symlinked.

Explanation: in JavaScript, multiple copies of the `constructs` library on disk are seen as independent, completely different libraries. As a consequence, the class `Construct` in each copy of the `constructs` library is seen as a different class, and an instance of one class will not test as `instanceof` the other class. `npm install` will not create installations like this, but users may manually symlink construct libraries together or use a monorepo tool: in those cases, multiple copies of the `constructs` library can be accidentally installed, and `instanceof` will behave unpredictably. It is safest to avoid using `instanceof`, and using this type-testing method instead.

Returns: true if `x` is an object created from a class which extends `Construct`.

func CfnHost_CFN_RESOURCE_TYPE_NAME

func CfnHost_CFN_RESOURCE_TYPE_NAME() *string

func CfnHost_IsCfnElement

func CfnHost_IsCfnElement(x interface{}) *bool

Returns `true` if a construct is a stack element (i.e. part of the synthesized cloudformation template).

Uses duck-typing instead of `instanceof` to allow stack elements from different versions of this library to be included in the same stack.

Returns: The construct as a stack element or undefined if it is not a stack element.

func CfnHost_IsCfnResource

func CfnHost_IsCfnResource(construct constructs.IConstruct) *bool

Check whether the given construct is a CfnResource.

func CfnHost_IsConstruct

func CfnHost_IsConstruct(x interface{}) *bool

Checks if `x` is a construct.

Use this method instead of `instanceof` to properly detect `Construct` instances, even when the construct library is symlinked.

Explanation: in JavaScript, multiple copies of the `constructs` library on disk are seen as independent, completely different libraries. As a consequence, the class `Construct` in each copy of the `constructs` library is seen as a different class, and an instance of one class will not test as `instanceof` the other class. `npm install` will not create installations like this, but users may manually symlink construct libraries together or use a monorepo tool: in those cases, multiple copies of the `constructs` library can be accidentally installed, and `instanceof` will behave unpredictably. It is safest to avoid using `instanceof`, and using this type-testing method instead.

Returns: true if `x` is an object created from a class which extends `Construct`.

func CfnIPAMAllocation_CFN_RESOURCE_TYPE_NAME

func CfnIPAMAllocation_CFN_RESOURCE_TYPE_NAME() *string

func CfnIPAMAllocation_IsCfnElement

func CfnIPAMAllocation_IsCfnElement(x interface{}) *bool

Returns `true` if a construct is a stack element (i.e. part of the synthesized cloudformation template).

Uses duck-typing instead of `instanceof` to allow stack elements from different versions of this library to be included in the same stack.

Returns: The construct as a stack element or undefined if it is not a stack element.

func CfnIPAMAllocation_IsCfnResource

func CfnIPAMAllocation_IsCfnResource(construct constructs.IConstruct) *bool

Check whether the given construct is a CfnResource.

func CfnIPAMAllocation_IsConstruct

func CfnIPAMAllocation_IsConstruct(x interface{}) *bool

Checks if `x` is a construct.

Use this method instead of `instanceof` to properly detect `Construct` instances, even when the construct library is symlinked.

Explanation: in JavaScript, multiple copies of the `constructs` library on disk are seen as independent, completely different libraries. As a consequence, the class `Construct` in each copy of the `constructs` library is seen as a different class, and an instance of one class will not test as `instanceof` the other class. `npm install` will not create installations like this, but users may manually symlink construct libraries together or use a monorepo tool: in those cases, multiple copies of the `constructs` library can be accidentally installed, and `instanceof` will behave unpredictably. It is safest to avoid using `instanceof`, and using this type-testing method instead.

Returns: true if `x` is an object created from a class which extends `Construct`.

func CfnIPAMPoolCidr_CFN_RESOURCE_TYPE_NAME

func CfnIPAMPoolCidr_CFN_RESOURCE_TYPE_NAME() *string

func CfnIPAMPoolCidr_IsCfnElement

func CfnIPAMPoolCidr_IsCfnElement(x interface{}) *bool

Returns `true` if a construct is a stack element (i.e. part of the synthesized cloudformation template).

Uses duck-typing instead of `instanceof` to allow stack elements from different versions of this library to be included in the same stack.

Returns: The construct as a stack element or undefined if it is not a stack element.

func CfnIPAMPoolCidr_IsCfnResource

func CfnIPAMPoolCidr_IsCfnResource(construct constructs.IConstruct) *bool

Check whether the given construct is a CfnResource.

func CfnIPAMPoolCidr_IsConstruct

func CfnIPAMPoolCidr_IsConstruct(x interface{}) *bool

Checks if `x` is a construct.

Use this method instead of `instanceof` to properly detect `Construct` instances, even when the construct library is symlinked.

Explanation: in JavaScript, multiple copies of the `constructs` library on disk are seen as independent, completely different libraries. As a consequence, the class `Construct` in each copy of the `constructs` library is seen as a different class, and an instance of one class will not test as `instanceof` the other class. `npm install` will not create installations like this, but users may manually symlink construct libraries together or use a monorepo tool: in those cases, multiple copies of the `constructs` library can be accidentally installed, and `instanceof` will behave unpredictably. It is safest to avoid using `instanceof`, and using this type-testing method instead.

Returns: true if `x` is an object created from a class which extends `Construct`.

func CfnIPAMPool_CFN_RESOURCE_TYPE_NAME

func CfnIPAMPool_CFN_RESOURCE_TYPE_NAME() *string

func CfnIPAMPool_IsCfnElement

func CfnIPAMPool_IsCfnElement(x interface{}) *bool

Returns `true` if a construct is a stack element (i.e. part of the synthesized cloudformation template).

Uses duck-typing instead of `instanceof` to allow stack elements from different versions of this library to be included in the same stack.

Returns: The construct as a stack element or undefined if it is not a stack element.

func CfnIPAMPool_IsCfnResource

func CfnIPAMPool_IsCfnResource(construct constructs.IConstruct) *bool

Check whether the given construct is a CfnResource.

func CfnIPAMPool_IsConstruct

func CfnIPAMPool_IsConstruct(x interface{}) *bool

Checks if `x` is a construct.

Use this method instead of `instanceof` to properly detect `Construct` instances, even when the construct library is symlinked.

Explanation: in JavaScript, multiple copies of the `constructs` library on disk are seen as independent, completely different libraries. As a consequence, the class `Construct` in each copy of the `constructs` library is seen as a different class, and an instance of one class will not test as `instanceof` the other class. `npm install` will not create installations like this, but users may manually symlink construct libraries together or use a monorepo tool: in those cases, multiple copies of the `constructs` library can be accidentally installed, and `instanceof` will behave unpredictably. It is safest to avoid using `instanceof`, and using this type-testing method instead.

Returns: true if `x` is an object created from a class which extends `Construct`.

func CfnIPAMResourceDiscoveryAssociation_CFN_RESOURCE_TYPE_NAME

func CfnIPAMResourceDiscoveryAssociation_CFN_RESOURCE_TYPE_NAME() *string

func CfnIPAMResourceDiscoveryAssociation_IsCfnElement

func CfnIPAMResourceDiscoveryAssociation_IsCfnElement(x interface{}) *bool

Returns `true` if a construct is a stack element (i.e. part of the synthesized cloudformation template).

Uses duck-typing instead of `instanceof` to allow stack elements from different versions of this library to be included in the same stack.

Returns: The construct as a stack element or undefined if it is not a stack element.

func CfnIPAMResourceDiscoveryAssociation_IsCfnResource

func CfnIPAMResourceDiscoveryAssociation_IsCfnResource(construct constructs.IConstruct) *bool

Check whether the given construct is a CfnResource.

func CfnIPAMResourceDiscoveryAssociation_IsConstruct

func CfnIPAMResourceDiscoveryAssociation_IsConstruct(x interface{}) *bool

Checks if `x` is a construct.

Use this method instead of `instanceof` to properly detect `Construct` instances, even when the construct library is symlinked.

Explanation: in JavaScript, multiple copies of the `constructs` library on disk are seen as independent, completely different libraries. As a consequence, the class `Construct` in each copy of the `constructs` library is seen as a different class, and an instance of one class will not test as `instanceof` the other class. `npm install` will not create installations like this, but users may manually symlink construct libraries together or use a monorepo tool: in those cases, multiple copies of the `constructs` library can be accidentally installed, and `instanceof` will behave unpredictably. It is safest to avoid using `instanceof`, and using this type-testing method instead.

Returns: true if `x` is an object created from a class which extends `Construct`.

func CfnIPAMResourceDiscovery_CFN_RESOURCE_TYPE_NAME

func CfnIPAMResourceDiscovery_CFN_RESOURCE_TYPE_NAME() *string

func CfnIPAMResourceDiscovery_IsCfnElement

func CfnIPAMResourceDiscovery_IsCfnElement(x interface{}) *bool

Returns `true` if a construct is a stack element (i.e. part of the synthesized cloudformation template).

Uses duck-typing instead of `instanceof` to allow stack elements from different versions of this library to be included in the same stack.

Returns: The construct as a stack element or undefined if it is not a stack element.

func CfnIPAMResourceDiscovery_IsCfnResource

func CfnIPAMResourceDiscovery_IsCfnResource(construct constructs.IConstruct) *bool

Check whether the given construct is a CfnResource.

func CfnIPAMResourceDiscovery_IsConstruct

func CfnIPAMResourceDiscovery_IsConstruct(x interface{}) *bool

Checks if `x` is a construct.

Use this method instead of `instanceof` to properly detect `Construct` instances, even when the construct library is symlinked.

Explanation: in JavaScript, multiple copies of the `constructs` library on disk are seen as independent, completely different libraries. As a consequence, the class `Construct` in each copy of the `constructs` library is seen as a different class, and an instance of one class will not test as `instanceof` the other class. `npm install` will not create installations like this, but users may manually symlink construct libraries together or use a monorepo tool: in those cases, multiple copies of the `constructs` library can be accidentally installed, and `instanceof` will behave unpredictably. It is safest to avoid using `instanceof`, and using this type-testing method instead.

Returns: true if `x` is an object created from a class which extends `Construct`.

func CfnIPAMScope_CFN_RESOURCE_TYPE_NAME

func CfnIPAMScope_CFN_RESOURCE_TYPE_NAME() *string

func CfnIPAMScope_IsCfnElement

func CfnIPAMScope_IsCfnElement(x interface{}) *bool

Returns `true` if a construct is a stack element (i.e. part of the synthesized cloudformation template).

Uses duck-typing instead of `instanceof` to allow stack elements from different versions of this library to be included in the same stack.

Returns: The construct as a stack element or undefined if it is not a stack element.

func CfnIPAMScope_IsCfnResource

func CfnIPAMScope_IsCfnResource(construct constructs.IConstruct) *bool

Check whether the given construct is a CfnResource.

func CfnIPAMScope_IsConstruct