Namespace Amazon.CDK.AWS.EC2
Amazon EC2 Construct Library
---
The @aws-cdk/aws-ec2 package contains primitives for setting up networking and
instances.
// Example automatically generated. See https://github.com/aws/jsii/issues/826
using Amazon.CDK.AWS.EC2;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:
// Example automatically generated. See https://github.com/aws/jsii/issues/826
Vpc vpc = new Vpc(this, "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:
A default VPC configuration will create public and private subnets, but not 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.
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. 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.
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:
// Example automatically generated. See https://github.com/aws/jsii/issues/826
// Configure the `natGatewayProvider` when defining a Vpc
NatProvider natGatewayProvider = NatProvider.Instance(new NatInstanceProps {
InstanceType = new InstanceType("t3.small")
});
Vpc vpc = new Vpc(this, "MyVpc", new VpcProps {
NatGatewayProvider = natGatewayProvider,
// The 'natGateways' parameter now controls the number of NAT instances
NatGateways = 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.
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:
// Example automatically generated. See https://github.com/aws/jsii/issues/826
Vpc vpc = new Vpc(this, "TheVPC", new VpcProps {
// 'cidr' configures the IP range and size of the entire VPC.
// The IP space will be divided over the configured subnets.
Cidr = "10.0.0.0/21",
// 'maxAzs' configures the maximum number of availability zones to use
MaxAzs = 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 = new [] { new SubnetConfiguration {
// 'subnetType' controls Internet access, as described above.
SubnetType = 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 = "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 = 24
}, new SubnetConfiguration {
CidrMask = 24,
Name = "Application",
SubnetType = SubnetType.PRIVATE
}, new SubnetConfiguration {
CidrMask = 28,
Name = "Database",
SubnetType = SubnetType.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 = 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 |
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:
// Example automatically generated. See https://github.com/aws/jsii/issues/826
Vpc vpc = new Vpc(this, "TheVPC", new VpcProps {
NatGateways = 1,
SubnetConfiguration = new [] { new SubnetConfiguration {
CidrMask = 26,
Name = "Public",
SubnetType = SubnetType.PUBLIC
}, new SubnetConfiguration {
CidrMask = 26,
Name = "Application1",
SubnetType = SubnetType.PRIVATE
}, new SubnetConfiguration {
CidrMask = 26,
Name = "Application2",
SubnetType = SubnetType.PRIVATE,
Reserved = true
}, new SubnetConfiguration {
CidrMask = 27,
Name = "Database",
SubnetType = SubnetType.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:
// Example automatically generated. See https://github.com/aws/jsii/issues/826
/**
* Stack1 creates the VPC
*/
class Stack1 : Stack
{
public Vpc Vpc { get; }
public MyClass(App scope, string id, StackProps? props=null) : base(scope, id, props)
{
Vpc = new Vpc(this, "VPC");
}
}
class Stack2Props : StackProps
{
public IVpc Vpc { get; set; }
}
/**
* Stack2 consumes the VPC
*/
class Stack2 : Stack
{
public MyClass(App scope, string id, Stack2Props props) : base(scope, id, props)
{
// Pass the VPC to a construct that needs it
// Pass the VPC to a construct that needs it
new ConstructThatTakesAVpc(this, "Construct", new ConstructThatTakesAVpcProps {
Vpc = props.Vpc
});
}
}
Stack1 stack1 = new Stack1(app, "Stack1");
Stack2 stack2 = new Stack2(app, "Stack2", new 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").
Here's how Vpc.fromLookup() can be used:
// Example automatically generated. See https://github.com/aws/jsii/issues/826
IVpc vpc = Vpc.FromLookup(stack, "VPC", new VpcLookupOptions {
// This imports the default VPC but you can also
// specify a 'vpcName' or 'tags'.
IsDefault = true
});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:
// Example automatically generated. See https://github.com/aws/jsii/issues/826
SecurityGroup mySecurityGroup = new SecurityGroup(this, "SecurityGroup", new SecurityGroupProps {
Vpc = vpc,
Description = "Allow ssh access to ec2 instances",
AllowAllOutbound = true
});
mySecurityGroup.AddIngressRule(Peer.AnyIpv4(), Port.Tcp(22), "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:
// Example automatically generated. See https://github.com/aws/jsii/issues/826
// Allow connections from anywhere
loadBalancer.Connections.AllowFromAnyIpv4(Port.Tcp(443), "Allow inbound HTTPS");
// The same, but an explicit IP address
loadBalancer.Connections.AllowFrom(Peer.Ipv4("1.2.3.4/32"), Port.Tcp(443), "Allow inbound HTTPS");
// Allow connection between AutoScalingGroups
appFleet.Connections.AllowTo(dbFleet, Port.Tcp(443), "App can call database");Connection Peers
There are various classes that implement the connection peer part:
// Example automatically generated. See https://github.com/aws/jsii/issues/826
// Simple connection peers
IPeer peer = Peer.Ipv4("10.0.0.0/16");
peer = Peer.AnyIpv4();
peer = Peer.Ipv6("::0/0");
peer = Peer.AnyIpv6();
peer = Peer.PrefixList("pl-12345");
appFleet.Connections.AllowTo(peer, Port.Tcp(443), "Allow outbound HTTPS");Any object that has a security group can itself be used as a connection peer:
// Example automatically generated. See https://github.com/aws/jsii/issues/826
// These automatically create appropriate ingress and egress rules in both security groups
fleet1.Connections.AllowTo(fleet2, Port.Tcp(80), "Allow between fleets");
appFleet.Connections.AllowFromAnyIpv4(Port.Tcp(80), "Allow from load balancer");Port Ranges
The connections that are allowed are specified by port ranges. A number of classes provide the connection specifier:
// Example automatically generated. See https://github.com/aws/jsii/issues/826
Port.Tcp(80);
Port.TcpRange(60000, 65535);
Port.AllTcp();
Port.AllTraffic();NOTE: This set is not complete yet; for example, there is no library support for ICMP at the moment.
However, you can write your own classes to implement those.
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:
// Example automatically generated. See https://github.com/aws/jsii/issues/826
// Port implicit in listener
listener.Connections.AllowDefaultPortFromAnyIpv4("Allow public");
// Port implicit in peer
appFleet.Connections.AllowDefaultPortTo(rdsDatabase, "Fleet can access database");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 things you might want to use:
// Example automatically generated. See https://github.com/aws/jsii/issues/826
// Pick the right Amazon Linux edition. All arguments shown are optional
// and will default to these values when omitted.
IMachineImage amznLinux = MachineImage.LatestAmazonLinux(new AmazonLinuxImageProps {
Generation = AmazonLinuxGeneration.AMAZON_LINUX,
Edition = AmazonLinuxEdition.STANDARD,
Virtualization = AmazonLinuxVirt.HVM,
Storage = AmazonLinuxStorage.GENERAL_PURPOSE
});
// Pick a Windows edition to use
IMachineImage windows = MachineImage.LatestWindows(WindowsVersion.WINDOWS_SERVER_2019_ENGLISH_FULL_BASE);
// 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:
IMachineImage natAmi = MachineImage.Lookup(new LookupMachineImageProps {
Name = "amzn-ami-vpc-nat-*",
Owners = new [] { "amazon" }
});
// For other custom (Linux) images, instantiate a `GenericLinuxImage` with
// a map giving the AMI to in for each region:
IMachineImage linux = MachineImage.GenericLinux(new Dictionary<string, string> {
{ "us-east-1", "ami-97785bed" },
{ "eu-west-1", "ami-12345678" }
});
// For other custom (Windows) images, instantiate a `GenericWindowsImage` with
// a map giving the AMI to in for each region:
IMachineImage genericWindows = MachineImage.GenericWindows(new Dictionary<string, string> {
{ "us-east-1", "ami-97785bed" },
{ "eu-west-1", "ami-12345678" }
});NOTE: The AMIs selected by <code>MachineImage.lookup()</code> 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.
VPN connections to a VPC
Create your VPC with VPN connections by specifying the vpnConnections props (keys are construct ids):
// Example automatically generated. See https://github.com/aws/jsii/issues/826
Vpc vpc = new Vpc(this, "MyVpc", new VpcProps {
VpnConnections = new Dictionary<string, VpnConnectionOptions> {
{ "dynamic", new VpnConnectionOptions { // Dynamic routing (BGP)
Ip = "1.2.3.4" } },
{ "static", new VpnConnectionOptions { // Static routing
Ip = "4.5.6.7",
StaticRoutes = new [] { "192.168.10.0/24", "192.168.20.0/24" } } }
}
});To create a VPC that can accept VPN connections, set vpnGateway to true:
// Example automatically generated. See https://github.com/aws/jsii/issues/826
Vpc vpc = new Vpc(this, "MyVpc", new VpcProps {
VpnGateway = true
});VPN connections can then be added:
// Example automatically generated. See https://github.com/aws/jsii/issues/826
vpc.AddVpnConnection("Dynamic", new VpnConnectionOptions {
Ip = "1.2.3.4"
});By default, routes will be propagated on the route tables associated with the private subnets. If no
private subnets exists, isolated subnets are used. If no isolated subnets exists, 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:
// Example automatically generated. See https://github.com/aws/jsii/issues/826
// Across all tunnels in the account/region
Metric allDataOut = VpnConnection.MetricAllTunnelDataOut();
// For a specific vpn connection
VpnConnection vpnConnection = vpc.AddVpnConnection("Dynamic", new VpnConnectionOptions {
Ip = "1.2.3.4"
});
Metric 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.
// Example automatically generated. See https://github.com/aws/jsii/issues/826
// Add gateway endpoints when creating the VPC
Vpc vpc = new Vpc(this, "MyVpc", new VpcProps {
GatewayEndpoints = new Dictionary<string, GatewayVpcEndpointOptions> {
{ "S3", new GatewayVpcEndpointOptions {
Service = GatewayVpcEndpointAwsService.S3
} }
}
});
// Alternatively gateway endpoints can be added on the VPC
GatewayVpcEndpoint dynamoDbEndpoint = vpc.AddGatewayEndpoint("DynamoDbEndpoint", new GatewayVpcEndpointOptions {
Service = GatewayVpcEndpointAwsService.DYNAMODB
});
// This allows to customize the endpoint policy
dynamoDbEndpoint.AddToPolicy(
new PolicyStatement(new PolicyStatementProps { // Restrict to listing and describing tables
Principals = new [] { new AnyPrincipal() },
Actions = new [] { "dynamodb:DescribeTable", "dynamodb:ListTables" },
Resources = new [] { "*" } }));
// Add an interface endpoint
vpc.AddInterfaceEndpoint("EcrDockerEndpoint", new Dictionary<string, IInterfaceVpcEndpointService> {
{ "service", InterfaceVpcEndpointAwsService.ECR_DOCKER }
});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:
// Example automatically generated. See https://github.com/aws/jsii/issues/826
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 whitelisted principals (anything that extends ArnPrincipal), and require that new connections be manually accepted.
// Example automatically generated without compilation. See https://github.com/aws/jsii/issues/826
new VpcEndpointService(this, "EndpointService", new Struct {
VpcEndpointServiceLoadBalancers = new [] { networkLoadBalancer1, networkLoadBalancer2 },
AcceptanceRequired = true,
WhitelistedPrincipals = new [] { new ArnPrincipal("arn:aws:iam::123456789012:root") }
});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 targetting 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:
// Example automatically generated. See https://github.com/aws/jsii/issues/826
BastionHostLinux host = new BastionHostLinux(this, "BastionHost", new 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.
// Example automatically generated. See https://github.com/aws/jsii/issues/826
BastionHostLinux host = new BastionHostLinux(this, "BastionHost", new BastionHostLinuxProps {
Vpc = vpc,
SubnetSelection = new SubnetSelection { SubnetType = SubnetType.PUBLIC }
});
host.AllowSshAccessFrom(Peer.Ipv4("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.
Block Devices
To add EBS block device mappings, specify the blockDeviceMappings property. The follow 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:
// Example automatically generated without compilation. See https://github.com/aws/jsii/issues/826
new Instance(this, "Instance", new Dictionary<string, Array> {
// ...
{ "blockDeviceMappings", new [] { new Struct {
DeviceName = "/dev/sda1",
Volume = BlockDeviceVolume.Ebs(50)
}, new Struct {
DeviceName = "/dev/sdm",
Volume = BlockDeviceVolume.Ebs(100)
} } }
});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:
// Example automatically generated without compilation. See https://github.com/aws/jsii/issues/826
new FlowLog(this, "FlowLog", new FlowLogProps {
ResourceType = FlowLogResourceType.FromVpc(vpc)
});Or you can add a Flow Log to a VPC by using the addFlowLog method like this:
// Example automatically generated. See https://github.com/aws/jsii/issues/826
Vpc vpc = new Vpc(this, "Vpc");
vpc.AddFlowLog("FlowLog");You can also add multiple flow logs with different destinations.
// Example automatically generated. See https://github.com/aws/jsii/issues/826
Vpc vpc = new Vpc(this, "Vpc");
vpc.AddFlowLog("FlowLogS3", new FlowLogOptions {
Destination = FlowLogDestination.ToS3()
});
vpc.AddFlowLog("FlowLogCloudWatch", new FlowLogOptions {
TrafficType = FlowLogTrafficType.REJECT
});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
// Example automatically generated without compilation. See https://github.com/aws/jsii/issues/826
var logGroup = new logs.LogGroup(this, "MyCustomLogGroup");
Role role = new Role(this, "MyCustomRole", new RoleProps {
AssumedBy = new ServicePrincipal("vpc-flow-logs.amazonaws.com")
});
new FlowLog(this, "FlowLog", new FlowLogProps {
ResourceType = FlowLogResourceType.FromVpc(vpc),
Destination = FlowLogDestination.ToCloudWatchLogs(logGroup, role)
});S3
// Example automatically generated without compilation. See https://github.com/aws/jsii/issues/826
var bucket = new s3.Bucket(this, "MyCustomBucket");
new FlowLog(this, "FlowLog", new FlowLogProps {
ResourceType = FlowLogResourceType.FromVpc(vpc),
Destination = FlowLogDestination.ToS3(bucket)
});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:
// Example automatically generated without compilation. See https://github.com/aws/jsii/issues/826
var asset = new Asset(this, "Asset", new Struct { Path = path.Join(__dirname, "configure.sh") });
Instance instance = new Instance(this, "Instance", new Dictionary<string, object> { });
string localPath = instance.UserData.AddS3DownloadCommand(new S3DownloadOptions {
Bucket = asset.Bucket,
BucketKey = asset.S3ObjectKey
});
instance.UserData.AddExecuteFileCommand(new ExecuteFileOptions {
FilePath = localPath,
Arguments = "--verbose -y"
});
asset.GrantRead(instance.Role);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:
// Example automatically generated without compilation. See https://github.com/aws/jsii/issues/826
// Supply all properties
var subnet = Subnet.FromSubnetAttributes(this, "SubnetFromAttributes", new Struct {
SubnetId = "s-1234",
AvailabilityZone = "pub-az-4465",
RouteTableId = "rt-145"
});
// Supply only subnet id
var subnet = Subnet.FromSubnetId(this, "SubnetFromId", "s-1234");Classes
| AclCidr | Either an IPv4 or an IPv6 CIDR. |
| AclCidrConfig | Acl Configuration for CIDR. |
| AclIcmp | Properties to create Icmp. |
| AclPortRange | Properties to create PortRange. |
| AclTraffic | The traffic that is configured using a Network ACL entry. |
| AclTrafficConfig | Acl Configuration for traffic. |
| Action | What action to apply to traffic matching the ACL. |
| AddRouteOptions | Options for adding a new route to a subnet. |
| AmazonLinuxEdition | Amazon Linux edition. |
| AmazonLinuxGeneration | What generation of Amazon Linux to use. |
| AmazonLinuxImage | Selects the latest version of Amazon Linux. |
| AmazonLinuxImageProps | Amazon Linux image properties. |
| AmazonLinuxStorage | |
| AmazonLinuxVirt | Virtualization type for Amazon Linux. |
| BastionHostLinux | This creates a linux bastion host you can use to connect to other instances or services in your VPC. |
| BastionHostLinuxProps | Properties of the bastion host. |
| BlockDevice | Block device. |
| BlockDeviceVolume | Describes a block device mapping for an EC2 instance or Auto Scaling group. |
| CfnCapacityReservation | A CloudFormation |
| CfnCapacityReservation.TagSpecificationProperty | |
| CfnCapacityReservationProps | Properties for defining a |
| CfnClientVpnAuthorizationRule | A CloudFormation |
| CfnClientVpnAuthorizationRuleProps | Properties for defining a |
| CfnClientVpnEndpoint | A CloudFormation |
| CfnClientVpnEndpoint.CertificateAuthenticationRequestProperty | |
| CfnClientVpnEndpoint.ClientAuthenticationRequestProperty | |
| CfnClientVpnEndpoint.ConnectionLogOptionsProperty | |
| CfnClientVpnEndpoint.DirectoryServiceAuthenticationRequestProperty | |
| CfnClientVpnEndpoint.TagSpecificationProperty | |
| CfnClientVpnEndpointProps | Properties for defining a |
| CfnClientVpnRoute | A CloudFormation |
| CfnClientVpnRouteProps | Properties for defining a |
| CfnClientVpnTargetNetworkAssociation | A CloudFormation |
| CfnClientVpnTargetNetworkAssociationProps | Properties for defining a |
| CfnCustomerGateway | A CloudFormation |
| CfnCustomerGatewayProps | Properties for defining a |
| CfnDHCPOptions | A CloudFormation |
| CfnDHCPOptionsProps | Properties for defining a |
| CfnEC2Fleet | A CloudFormation |
| CfnEC2Fleet.FleetLaunchTemplateConfigRequestProperty | |
| CfnEC2Fleet.FleetLaunchTemplateOverridesRequestProperty | |
| CfnEC2Fleet.FleetLaunchTemplateSpecificationRequestProperty | |
| CfnEC2Fleet.OnDemandOptionsRequestProperty | |
| CfnEC2Fleet.SpotOptionsRequestProperty | |
| CfnEC2Fleet.TagRequestProperty | |
| CfnEC2Fleet.TagSpecificationProperty | |
| CfnEC2Fleet.TargetCapacitySpecificationRequestProperty | |
| CfnEC2FleetProps | Properties for defining a |
| CfnEgressOnlyInternetGateway | A CloudFormation |
| CfnEgressOnlyInternetGatewayProps | Properties for defining a |
| CfnEIP | A CloudFormation |
| CfnEIPAssociation | A CloudFormation |
| CfnEIPAssociationProps | Properties for defining a |
| CfnEIPProps | Properties for defining a |
| CfnFlowLog | A CloudFormation |
| CfnFlowLogProps | Properties for defining a |
| CfnGatewayRouteTableAssociation | A CloudFormation |
| CfnGatewayRouteTableAssociationProps | Properties for defining a |
| CfnHost | A CloudFormation |
| CfnHostProps | Properties for defining a |
| CfnInstance | A CloudFormation |
| CfnInstance.AssociationParameterProperty | |
| CfnInstance.BlockDeviceMappingProperty | |
| CfnInstance.CpuOptionsProperty | |
| CfnInstance.CreditSpecificationProperty | |
| CfnInstance.EbsProperty | |
| CfnInstance.ElasticGpuSpecificationProperty | |
| CfnInstance.ElasticInferenceAcceleratorProperty | |
| CfnInstance.HibernationOptionsProperty | |
| CfnInstance.InstanceIpv6AddressProperty | |
| CfnInstance.LaunchTemplateSpecificationProperty | |
| CfnInstance.LicenseSpecificationProperty | |
| CfnInstance.NetworkInterfaceProperty | |
| CfnInstance.NoDeviceProperty | |
| CfnInstance.PrivateIpAddressSpecificationProperty | |
| CfnInstance.SsmAssociationProperty | |
| CfnInstance.VolumeProperty | |
| CfnInstanceProps | Properties for defining a |
| CfnInternetGateway | A CloudFormation |
| CfnInternetGatewayProps | Properties for defining a |
| CfnLaunchTemplate | A CloudFormation |
| CfnLaunchTemplate.BlockDeviceMappingProperty | |
| CfnLaunchTemplate.CapacityReservationSpecificationProperty | |
| CfnLaunchTemplate.CapacityReservationTargetProperty | |
| CfnLaunchTemplate.CpuOptionsProperty | |
| CfnLaunchTemplate.CreditSpecificationProperty | |
| CfnLaunchTemplate.EbsProperty | |
| CfnLaunchTemplate.ElasticGpuSpecificationProperty | |
| CfnLaunchTemplate.HibernationOptionsProperty | |
| CfnLaunchTemplate.IamInstanceProfileProperty | |
| CfnLaunchTemplate.InstanceMarketOptionsProperty | |
| CfnLaunchTemplate.Ipv6AddProperty | |
| CfnLaunchTemplate.LaunchTemplateDataProperty | |
| CfnLaunchTemplate.LaunchTemplateElasticInferenceAcceleratorProperty | |
| CfnLaunchTemplate.LicenseSpecificationProperty | |
| CfnLaunchTemplate.MetadataOptionsProperty | |
| CfnLaunchTemplate.MonitoringProperty | |
| CfnLaunchTemplate.NetworkInterfaceProperty | |
| CfnLaunchTemplate.PlacementProperty | |
| CfnLaunchTemplate.PrivateIpAddProperty | |
| CfnLaunchTemplate.SpotOptionsProperty | |
| CfnLaunchTemplate.TagSpecificationProperty | |
| CfnLaunchTemplateProps | Properties for defining a |
| CfnLocalGatewayRoute | A CloudFormation |
| CfnLocalGatewayRouteProps | Properties for defining a |
| CfnLocalGatewayRouteTableVPCAssociation | A CloudFormation |
| CfnLocalGatewayRouteTableVPCAssociation.TagsProperty | |
| CfnLocalGatewayRouteTableVPCAssociationProps | Properties for defining a |
| CfnNatGateway | A CloudFormation |
| CfnNatGatewayProps | Properties for defining a |
| CfnNetworkAcl | A CloudFormation |
| CfnNetworkAclEntry | A CloudFormation |
| CfnNetworkAclEntry.IcmpProperty | |
| CfnNetworkAclEntry.PortRangeProperty | |
| CfnNetworkAclEntryProps | Properties for defining a |
| CfnNetworkAclProps | Properties for defining a |
| CfnNetworkInterface | A CloudFormation |
| CfnNetworkInterface.InstanceIpv6AddressProperty | |
| CfnNetworkInterface.PrivateIpAddressSpecificationProperty | |
| CfnNetworkInterfaceAttachment | A CloudFormation |
| CfnNetworkInterfaceAttachmentProps | Properties for defining a |
| CfnNetworkInterfacePermission | A CloudFormation |
| CfnNetworkInterfacePermissionProps | Properties for defining a |
| CfnNetworkInterfaceProps | Properties for defining a |
| CfnPlacementGroup | A CloudFormation |
| CfnPlacementGroupProps | Properties for defining a |
| CfnRoute | A CloudFormation |
| CfnRouteProps | Properties for defining a |
| CfnRouteTable | A CloudFormation |
| CfnRouteTableProps | Properties for defining a |
| CfnSecurityGroup | A CloudFormation |
| CfnSecurityGroup.EgressProperty | |
| CfnSecurityGroup.IngressProperty | |
| CfnSecurityGroupEgress | A CloudFormation |
| CfnSecurityGroupEgressProps | Properties for defining a |
| CfnSecurityGroupIngress | A CloudFormation |
| CfnSecurityGroupIngressProps | Properties for defining a |
| CfnSecurityGroupProps | Properties for defining a |
| CfnSpotFleet | A CloudFormation |
| CfnSpotFleet.BlockDeviceMappingProperty | |
| CfnSpotFleet.ClassicLoadBalancerProperty | |
| CfnSpotFleet.ClassicLoadBalancersConfigProperty | |
| CfnSpotFleet.EbsBlockDeviceProperty | |
| CfnSpotFleet.FleetLaunchTemplateSpecificationProperty | |
| CfnSpotFleet.GroupIdentifierProperty | |
| CfnSpotFleet.IamInstanceProfileSpecificationProperty | |
| CfnSpotFleet.InstanceIpv6AddressProperty | |
| CfnSpotFleet.InstanceNetworkInterfaceSpecificationProperty | |
| CfnSpotFleet.LaunchTemplateConfigProperty | |
| CfnSpotFleet.LaunchTemplateOverridesProperty | |
| CfnSpotFleet.LoadBalancersConfigProperty | |
| CfnSpotFleet.PrivateIpAddressSpecificationProperty | |
| CfnSpotFleet.SpotFleetLaunchSpecificationProperty | |
| CfnSpotFleet.SpotFleetMonitoringProperty | |
| CfnSpotFleet.SpotFleetRequestConfigDataProperty | |
| CfnSpotFleet.SpotFleetTagSpecificationProperty | |
| CfnSpotFleet.SpotPlacementProperty | |
| CfnSpotFleet.TargetGroupProperty | |
| CfnSpotFleet.TargetGroupsConfigProperty | |
| CfnSpotFleetProps | Properties for defining a |
| CfnSubnet | A CloudFormation |
| CfnSubnetCidrBlock | A CloudFormation |
| CfnSubnetCidrBlockProps | Properties for defining a |
| CfnSubnetNetworkAclAssociation | A CloudFormation |
| CfnSubnetNetworkAclAssociationProps | Properties for defining a |
| CfnSubnetProps | Properties for defining a |
| CfnSubnetRouteTableAssociation | A CloudFormation |
| CfnSubnetRouteTableAssociationProps | Properties for defining a |
| CfnTrafficMirrorFilter | A CloudFormation |
| CfnTrafficMirrorFilterProps | Properties for defining a |
| CfnTrafficMirrorFilterRule | A CloudFormation |
| CfnTrafficMirrorFilterRule.TrafficMirrorPortRangeProperty | |
| CfnTrafficMirrorFilterRuleProps | Properties for defining a |
| CfnTrafficMirrorSession | A CloudFormation |
| CfnTrafficMirrorSessionProps | Properties for defining a |
| CfnTrafficMirrorTarget | A CloudFormation |
| CfnTrafficMirrorTargetProps | Properties for defining a |
| CfnTransitGateway | A CloudFormation |
| CfnTransitGatewayAttachment | A CloudFormation |
| CfnTransitGatewayAttachmentProps | Properties for defining a |
| CfnTransitGatewayProps | Properties for defining a |
| CfnTransitGatewayRoute | A CloudFormation |
| CfnTransitGatewayRouteProps | Properties for defining a |
| CfnTransitGatewayRouteTable | A CloudFormation |
| CfnTransitGatewayRouteTableAssociation | A CloudFormation |
| CfnTransitGatewayRouteTableAssociationProps | Properties for defining a |
| CfnTransitGatewayRouteTablePropagation | A CloudFormation |
| CfnTransitGatewayRouteTablePropagationProps | Properties for defining a |
| CfnTransitGatewayRouteTableProps | Properties for defining a |
| CfnVolume | A CloudFormation |
| CfnVolumeAttachment | A CloudFormation |
| CfnVolumeAttachmentProps | Properties for defining a |
| CfnVolumeProps | Properties for defining a |
| CfnVPC | A CloudFormation |
| CfnVPCCidrBlock | A CloudFormation |
| CfnVPCCidrBlockProps | Properties for defining a |
| CfnVPCDHCPOptionsAssociation | A CloudFormation |
| CfnVPCDHCPOptionsAssociationProps | Properties for defining a |
| CfnVPCEndpoint | A CloudFormation |
| CfnVPCEndpointConnectionNotification | A CloudFormation |
| CfnVPCEndpointConnectionNotificationProps | Properties for defining a |
| CfnVPCEndpointProps | Properties for defining a |
| CfnVPCEndpointService | A CloudFormation |
| CfnVPCEndpointServicePermissions | A CloudFormation |
| CfnVPCEndpointServicePermissionsProps | Properties for defining a |
| CfnVPCEndpointServiceProps | Properties for defining a |
| CfnVPCGatewayAttachment | A CloudFormation |
| CfnVPCGatewayAttachmentProps | Properties for defining a |
| CfnVPCPeeringConnection | A CloudFormation |
| CfnVPCPeeringConnectionProps | Properties for defining a |
| CfnVPCProps | Properties for defining a |
| CfnVPNConnection | A CloudFormation |
| CfnVPNConnection.VpnTunnelOptionsSpecificationProperty | |
| CfnVPNConnectionProps | Properties for defining a |
| CfnVPNConnectionRoute | A CloudFormation |
| CfnVPNConnectionRouteProps | Properties for defining a |
| CfnVPNGateway | A CloudFormation |
| CfnVPNGatewayProps | Properties for defining a |
| CfnVPNGatewayRoutePropagation | A CloudFormation |
| CfnVPNGatewayRoutePropagationProps | Properties for defining a |
| CommonNetworkAclEntryOptions | Basic NetworkACL entry props. |
| ConfigureNatOptions | Options passed by the VPC when NAT needs to be configured. |
| ConnectionRule | |
| Connections_ | Manage the allowed network connections for constructs with Security Groups. |
| ConnectionsProps | Properties to intialize a new Connections object. |
| DefaultInstanceTenancy | The default tenancy of instances launched into the VPC. |
| EbsDeviceOptions | Block device options for an EBS volume. |
| EbsDeviceOptionsBase | Base block device options for an EBS volume. |
| EbsDeviceProps | Properties of an EBS block device. |
| EbsDeviceSnapshotOptions | Block device options for an EBS volume created from a snapshot. |
| EbsDeviceVolumeType | Supported EBS volume types for blockDevices. |
| ExecuteFileOptions | Options when executing a file. |
| FlowLog | A VPC flow log. |
| FlowLogDestination | The destination type for the flow log. |
| FlowLogDestinationConfig | Flow Log Destination configuration. |
| FlowLogDestinationType | The available destination types for Flow Logs. |
| FlowLogOptions | Options to add a flow log to a VPC. |
| FlowLogProps | Properties of a VPC Flow Log. |
| FlowLogResourceType | The type of resource to create the flow log for. |
| FlowLogTrafficType | The type of VPC traffic to log. |
| GatewayConfig | Pair represents a gateway created by NAT Provider. |
| GatewayVpcEndpoint | A gateway VPC endpoint. |
| GatewayVpcEndpointAwsService | An AWS service for a gateway VPC endpoint. |
| GatewayVpcEndpointOptions | Options to add a gateway endpoint to a VPC. |
| GatewayVpcEndpointProps | Construction properties for a GatewayVpcEndpoint. |
| GenericLinuxImage | Construct a Linux machine image from an AMI map. |
| GenericLinuxImageProps | Configuration options for GenericLinuxImage. |
| GenericWindowsImage | Construct a Windows machine image from an AMI map. |
| GenericWindowsImageProps | Configuration options for GenericWindowsImage. |
| Instance_ | This represents a single EC2 instance. |
| InstanceClass | What class and generation of instance to use. |
| InstanceProps | Properties of an EC2 Instance. |
| InstanceSize | What size of instance to use. |
| InstanceType | Instance type for EC2 instances. |
| InterfaceVpcEndpoint | A interface VPC endpoint. |
| InterfaceVpcEndpointAttributes | Construction properties for an ImportedInterfaceVpcEndpoint. |
| InterfaceVpcEndpointAwsService | An AWS service for an interface VPC endpoint. |
| InterfaceVpcEndpointOptions | Options to add an interface endpoint to a VPC. |
| InterfaceVpcEndpointProps | Construction properties for an InterfaceVpcEndpoint. |
| InterfaceVpcEndpointService | A custom-hosted service for an interface VPC endpoint. |
| LinuxUserDataOptions | Options when constructing UserData for Linux. |
| LookupMachineImage | A machine image whose AMI ID will be searched using DescribeImages. |
| LookupMachineImageProps | Properties for looking up an image. |
| MachineImage | Factory functions for standard Amazon Machine Image objects. |
| MachineImageConfig | Configuration for a machine image. |
| NatInstanceImage | Machine image representing the latest NAT instance image. |
| NatInstanceProps | Properties for a NAT instance. |
| NatProvider | NAT providers. |
| NetworkAcl | Define a new custom network ACL. |
| NetworkAclEntry | Define an entry in a Network ACL table. |
| NetworkAclEntryProps | Properties to create NetworkAclEntry. |
| NetworkAclProps | Properties to create NetworkAcl. |
| OperatingSystemType | The OS type of a particular image. |
| Peer | Peer object factories (to be used in Security Group management). |
| Port | Interface for classes that provide the connection-specification parts of a security group rule. |
| PortProps | Properties to create a port range. |
| PrivateSubnet | Represents a private VPC subnet resource. |
| PrivateSubnetAttributes | |
| PrivateSubnetProps | |
| Protocol | Protocol for use in Connection Rules. |
| PublicSubnet | Represents a public VPC subnet resource. |
| PublicSubnetAttributes | |
| PublicSubnetProps | |
| RouterType | Type of router used in route. |
| S3DownloadOptions | Options when downloading files from S3. |
| SecurityGroup | Creates an Amazon EC2 security group within a VPC. |
| SecurityGroupImportOptions | Additional options for imported security groups. |
| SecurityGroupProps | |
| SelectedSubnets | Result of selecting a subset of subnets from a VPC. |
| Subnet | Represents a new VPC subnet resource. |
| SubnetAttributes | |
| SubnetConfiguration | Specify configuration parameters for a single subnet group in a VPC. |
| SubnetNetworkAclAssociation | |
| SubnetNetworkAclAssociationProps | Properties to create a SubnetNetworkAclAssociation. |
| SubnetProps | Specify configuration parameters for a VPC subnet. |
| SubnetSelection | Customize subnets that are selected for placement of ENIs. |
| SubnetType | The type of Subnet. |
| TrafficDirection | Direction of traffic the AclEntry applies to. |
| UserData | Instance User Data. |
| Vpc | Define an AWS Virtual Private Cloud. |
| VpcAttributes | Properties that reference an external Vpc. |
| VpcEndpoint | |
| VpcEndpointService | A VPC endpoint service. |
| VpcEndpointServiceProps | Construction properties for a VpcEndpointService. |
| VpcEndpointType | The type of VPC endpoint. |
| VpcLookupOptions | Properties for looking up an existing VPC. |
| VpcProps | Configuration for Vpc. |
| VpnConnection | Define a VPN Connection. |
| VpnConnectionOptions | |
| VpnConnectionProps | |
| VpnConnectionType | The VPN connection type. |
| VpnTunnelOption | |
| WindowsImage | Select the latest version of the indicated Windows version. |
| WindowsImageProps | Configuration options for WindowsImage. |
| WindowsVersion | The Windows version to use for the WindowsImage. |