Show / Hide Table of Contents

Namespace Amazon.CDK.AWS.EC2

Amazon EC2 Construct Library

--- cfn-resources: Stable cdk-constructs: Stable

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
var vpc = new ec2.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. 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. 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:

    // Example automatically generated without compilation. See https://github.com/aws/jsii/issues/826
    class MyStack : Stack
    {get availabilityZones(): string[] {
            return ['us-west-2a', 'us-west-2b'];
          }
    
        public MyClass(Construct scope, string id, StackProps? props=null) : base(scope, id, props)
        {
        }
    }

    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:

    // Example automatically generated without compilation. See https://github.com/aws/jsii/issues/826
    new InterfaceVpcEndpoint(stack, "VPC Endpoint", new Struct {
        Vpc = vpc,
        Service = new InterfaceVpcEndpointService("com.amazonaws.vpce.us-east-1.vpce-svc-uuddlrlrbastrtsvc", 443),
        Subnets = new Struct {
            SubnetType = SubnetType.ISOLATED,
            AvailabilityZones = new [] { "us-east-1a", "us-east-1c" }
        }
    });

    You can also specify specific subnet objects for granular control:

    // Example automatically generated without compilation. See https://github.com/aws/jsii/issues/826
    new InterfaceVpcEndpoint(stack, "VPC Endpoint", new Struct {
        Vpc = vpc,
        Service = new InterfaceVpcEndpointService("com.amazonaws.vpce.us-east-1.vpce-svc-uuddlrlrbastrtsvc", 443),
        Subnets = new Struct {
            Subnets = new [] { subnet1, subnet2 }
        }
    });

    Which subnets are selected is evaluated as follows:

      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
      NatInstanceProvider 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.

      By default, the NAT instances will route all traffic. To control what traffic gets routed, pass allowAllTraffic: false and access the NatInstanceProvider.connections member after having passed it to the VPC:

      // Example automatically generated without compilation. See https://github.com/aws/jsii/issues/826
      var provider = NatProvider.Instance(new Struct {
          InstanceType = ,
          AllowAllTraffic = false
      });
      new Vpc(stack, "TheVPC", new Struct {
          NatGatewayProvider = provider
      });
      provider.Connections.AllowFrom(Peer.Ipv4("1.2.3.4/8"), Port.Tcp(80));

      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
      var vpc = new ec2.Vpc(this, "TheVPC", new Struct {
          // '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 Struct {
              // '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 = "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 Struct {
              CidrMask = 24,
              Name = "Application",
              SubnetType = ec2.SubnetType.PRIVATE
          }, new Struct {
              CidrMask = 28,
              Name = "Database",
              SubnetType = ec2.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

      Accessing the Internet Gateway

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

      // Example automatically generated without compilation. See https://github.com/aws/jsii/issues/826
      var 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.

      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:

      // Example automatically generated without compilation. See https://github.com/aws/jsii/issues/826
      var vpc = ec2.Vpc(this, "VPC", new Struct {
          SubnetConfiguration = new [] { new Struct {
              SubnetType = SubnetType.PUBLIC,
              Name = "Public"
          }, new Struct {
              SubnetType = SubnetType.ISOLATED,
              Name = "Isolated"
          } }
      })((Subnet)vpc.isolatedSubnets[0]).AddRoute("StaticRoute", new Struct {
          RouterId = vpc.InternetGatewayId,
          RouterType = RouterType.GATEWAY,
          DestinationCidrBlock = "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:

      // Example automatically generated. See https://github.com/aws/jsii/issues/826
      var vpc = new ec2.Vpc(this, "TheVPC", new Struct {
          NatGateways = 1,
          SubnetConfiguration = new [] { new Struct {
              CidrMask = 26,
              Name = "Public",
              SubnetType = ec2.SubnetType.PUBLIC
          }, new Struct {
              CidrMask = 26,
              Name = "Application1",
              SubnetType = ec2.SubnetType.PRIVATE
          }, new Struct {
              CidrMask = 26,
              Name = "Application2",
              SubnetType = ec2.SubnetType.PRIVATE,
              Reserved = true
          }, new Struct {
              CidrMask = 27,
              Name = "Database",
              SubnetType = ec2.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").

      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:

      // 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
      });

      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:

        Using Vpc.fromVpcAttributes() looks like this:

        // Example automatically generated without compilation. See https://github.com/aws/jsii/issues/826
        var vpc = ec2.Vpc.FromVpcAttributes(stack, "VPC", new Struct {
            VpcId = "vpc-1234",
            AvailabilityZones = new [] { "us-east-1a", "us-east-1b" },
        
            // Either pass literals for all IDs
            PublicSubnetIds = new [] { "s-12345", "s-67890" },
        
            // OR: import a list of known length
            PrivateSubnetIds = Fn.ImportListValue("PrivateSubnetIds", 2),
        
            // OR: split an imported string to a list of known length
            IsolatedSubnetIds = Fn.Split(",", ssm.StringParameter.ValueForStringParameter(stack, "MyParameter"), 2)
        });

        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
        ec2.Port.Tcp(80);
        ec2.Port.TcpRange(60000, 65535);
        ec2.Port.AllTcp();
        ec2.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");

        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.

        // Example automatically generated. See https://github.com/aws/jsii/issues/826
        SecurityGroup mySecurityGroupWithoutInlineRules = new SecurityGroup(this, "SecurityGroup", new SecurityGroupProps {
            Vpc = vpc,
            Description = "Allow ssh access to ec2 instances",
            AllowAllOutbound = true,
            DisableInlineRules = true
        });
        //This will add the rule as an external cloud formation construct
        mySecurityGroupWithoutInlineRules.AddIngressRule(Peer.AnyIpv4(), Port.Tcp(22), "allow ssh access from the world");

        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,
            CpuType = AmazonLinuxCpuType.X86_64
        });
        
        // Pick a Windows edition to use
        IMachineImage windows = MachineImage.LatestWindows(WindowsVersion.WINDOWS_SERVER_2019_ENGLISH_FULL_BASE);
        
        // Read AMI id from SSM parameter store
        IMachineImage ssm = MachineImage.FromSSMParameter("/my/ami", 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:
        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.

        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):

        // Example automatically generated. See https://github.com/aws/jsii/issues/826
        var vpc = new ec2.Vpc(this, "MyVpc", new Struct {
            VpnConnections = new Struct {
                Dynamic = new Struct { // Dynamic routing (BGP)
                    Ip = "1.2.3.4" },
                Static = new Struct { // 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
        var vpc = new ec2.Vpc(this, "MyVpc", new Struct {
            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 }
        });

        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:

        // Example automatically generated without compilation. See https://github.com/aws/jsii/issues/826
        new InterfaceVpcEndpoint(stack, "VPC Endpoint", new Struct {
            Vpc = vpc,
            Service = new InterfaceVpcEndpointService("com.amazonaws.vpce.us-east-1.vpce-svc-uuddlrlrbastrtsvc", 443),
            // Choose which availability zones to place the VPC endpoint in, based on
            // available AZs
            Subnets = new Struct {
                AvailabilityZones = new [] { "us-east-1a", "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.

        // Example automatically generated without compilation. See https://github.com/aws/jsii/issues/826
        new InterfaceVpcEndpoint(stack, "VPC Endpoint", new Struct {
            Vpc = vpc,
            Service = new InterfaceVpcEndpointService("com.amazonaws.vpce.us-east-1.vpce-svc-uuddlrlrbastrtsvc", 443),
            // Choose which availability zones to place the VPC endpoint in, based on
            // available AZs
            LookupSupportedAzs = true
        });

        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") }
        });

        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:

        // Example automatically generated without compilation. See https://github.com/aws/jsii/issues/826
        using Amazon.CDK.AWS.Route53;
        
        
        new VpcEndpointServiceDomainName(stack, "EndpointDomain", new VpcEndpointServiceDomainNameProps {
            EndpointService = vpces,
            DomainName = "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:

        // Example automatically generated without compilation. See https://github.com/aws/jsii/issues/826
        vpc.AddClientVpnEndpoint("Endpoint", new ClientVpnEndpointOptions {
            Cidr = "10.100.0.0/16",
            ServerCertificateArn = "arn:aws:acm:us-east-1:123456789012:certificate/server-certificate-id",
            // Mutual authentication
            ClientCertificateArn = "arn:aws:acm:us-east-1:123456789012:certificate/client-certificate-id",
            // User-based authentication
            UserBasedAuthentication = ClientVpnUserBasedAuthentication.Federated(samlProvider)
        });

        The endpoint must use at least one authentication method:

          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 addaddAuthorizationRule():

          // Example automatically generated without compilation. See https://github.com/aws/jsii/issues/826
          ClientVpnEndpoint endpoint = vpc.AddClientVpnEndpoint("Endpoint", new ClientVpnEndpointOptions {
              Cidr = "10.100.0.0/16",
              ServerCertificateArn = "arn:aws:acm:us-east-1:123456789012:certificate/server-certificate-id",
              UserBasedAuthentication = ClientVpnUserBasedAuthentication.Federated(samlProvider),
              AuthorizeAllUsersToVpcCidr = false
          });
          
          endpoint.AddAuthorizationRule("Rule", new ClientVpnAuthorizationRuleOptions {
              Cidr = "10.0.10.0/32",
              GroupId = "group-id"
          });

          Use addRoute() to configure network routes:

          // Example automatically generated without compilation. See https://github.com/aws/jsii/issues/826
          ClientVpnEndpoint endpoint = vpc.AddClientVpnEndpoint("Endpoint", new ClientVpnEndpointOptions {
              Cidr = "10.100.0.0/16",
              ServerCertificateArn = "arn:aws:acm:us-east-1:123456789012:certificate/server-certificate-id",
              UserBasedAuthentication = ClientVpnUserBasedAuthentication.Federated(samlProvider)
          });
          
          // Client-to-client access
          endpoint.AddRoute("Route", new ClientVpnRouteOptions {
              Cidr = "10.100.0.0/16",
              Target = 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.

          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:

          // Example automatically generated without compilation. See https://github.com/aws/jsii/issues/826
          new ec2.Instance(this, "Instance", new Struct {
              // Showing the most complex setup, if you have simpler requirements
              // you can use `CloudFormationInit.fromElements()`.
              Init = ec2.CloudFormationInit.FromConfigSets(new Struct {
                  ConfigSets = new Struct {
                      // Applies the configs below in this order
                      Default = new [] { "yumPreinstall", "config" }
                  },
                  Configs = new Struct {
                      YumPreinstall = new ec2.InitConfig(new [] { ec2.InitPackage.Yum("git") }),
                      Config = new ec2.InitConfig(new [] { ec2.InitFile.FromObject("/etc/stack.json", new Struct {
                          StackId = stack.StackId,
                          StackName = stack.StackName,
                          Region = stack.Region
                      }), ec2.InitGroup.FromName("my-group"), ec2.InitUser.FromName("my-user"), ec2.InitPackage.Rpm("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 = new Struct {
                  // Optional, which configsets to activate (['default'] by default)
                  ConfigSets = new [] { "default" },
          
                  // Optional, how long the installation is expected to take (5 minutes by default)
                  Timeout = Duration.Minutes(30)
              }
          });

          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:

          // Example automatically generated without compilation. See https://github.com/aws/jsii/issues/826
          var handle = new ec2.InitServiceRestartHandle();
          
          ec2.CloudFormationInit.FromElements(ec2.InitFile.FromString("/etc/nginx/nginx.conf", "...", new Struct { ServiceRestartHandles = new [] { handle } }), ec2.InitSource.FromBucket("/var/www/html", myBucket, "html.zip", new Struct { ServiceRestartHandles = new [] { handle } }), ec2.InitService.Enable("nginx", new Struct {
              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:

          // 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.

          EBS volume for the bastion host can be encrypted like:

          // Example automatically generated without compilation. See https://github.com/aws/jsii/issues/826
          var host = new ec2.BastionHostLinux(stack, "BastionHost", new Struct {
              Vpc = vpc,
              BlockDevices = new [] { new Struct {
                  DeviceName = "EBSBastionHost",
                  Volume = BlockDeviceVolume.Ebs(10, new Struct {
                      Encrypted = 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:

          // Example automatically generated without compilation. See https://github.com/aws/jsii/issues/826
          new ec2.Instance(this, "Instance", new Struct {
              // ...
              BlockDevices = new [] { new Struct {
                  DeviceName = "/dev/sda1",
                  Volume = ec2.BlockDeviceVolume.Ebs(50)
              }, new Struct {
                  DeviceName = "/dev/sdm",
                  Volume = ec2.BlockDeviceVolume.Ebs(100)
              } }
          });

          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:

          // Example automatically generated without compilation. See https://github.com/aws/jsii/issues/826
          var instance = new ec2.Instance(this, "Instance", new Struct { });
          Role role = new Role(stack, "SomeRole", new RoleProps {
              AssumedBy = new AccountRootPrincipal()
          });
          var volume = new ec2.Volume(this, "Volume", new Struct {
              AvailabilityZone = "us-west-2a",
              Size = cdk.Size.Gibibytes(500),
              Encrypted = true
          });
          
          volume.GrantAttachVolume(role, new [] { 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:

          // Example automatically generated without compilation. See https://github.com/aws/jsii/issues/826
          var instance = new ec2.Instance(this, "Instance", new Struct { });
          var volume = new ec2.Volume(this, "Volume", new Struct { });
          
          var attachGrant = volume.GrantAttachVolumeByResourceTag(instance.GrantPrincipal, new [] { instance });
          var detachGrant = volume.GrantDetachVolumeByResourceTag(instance.GrantPrincipal, new [] { 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:

          // Example automatically generated without compilation. See https://github.com/aws/jsii/issues/826
          var volume = new ec2.Volume(this, "Volume", new Struct { });
          var instance = new ec2.Instance(this, "Instance", new Struct { });
          volume.GrantAttachVolumeByResourceTag(instance.GrantPrincipal, new [] { instance });
          string targetDevice = "/dev/xvdz";
          instance.UserData.AddCommands($"aws --region {Stack.of(this).region} ec2 attach-volume --volume-id {volume.volumeId} --instance-id {instance.instanceId} --device {targetDevice}", $"while ! test -e {targetDevice}; do sleep 1; done");

          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 ec2.FlowLog(this, "FlowLog", new Struct {
              ResourceType = ec2.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
          var vpc = new ec2.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
          var vpc = new ec2.Vpc(this, "Vpc");
          
          vpc.AddFlowLog("FlowLogS3", new Struct {
              Destination = ec2.FlowLogDestination.ToS3()
          });
          
          vpc.AddFlowLog("FlowLogCloudWatch", new Struct {
              TrafficType = ec2.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 ec2.FlowLog(this, "FlowLog", new Struct {
              ResourceType = ec2.FlowLogResourceType.FromVpc(vpc),
              Destination = ec2.FlowLogDestination.ToCloudWatchLogs(logGroup, role)
          });

          S3

          // Example automatically generated without compilation. See https://github.com/aws/jsii/issues/826
          Bucket bucket = new Bucket(this, "MyCustomBucket");
          
          new ec2.FlowLog(this, "FlowLog", new Struct {
              ResourceType = ec2.FlowLogResourceType.FromVpc(vpc),
              Destination = ec2.FlowLogDestination.ToS3(bucket)
          });
          
          new ec2.FlowLog(this, "FlowLogWithKeyPrefix", new Struct {
              ResourceType = ec2.FlowLogResourceType.FromVpc(vpc),
              Destination = ec2.FlowLogDestination.ToS3(bucket, "prefix/")
          });

          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") });
          var instance = new ec2.Instance(this, "Instance", new Struct { });
          var localPath = instance.UserData.AddS3DownloadCommand(new Struct {
              Bucket = asset.Bucket,
              BucketKey = asset.S3ObjectKey
          });
          instance.UserData.AddExecuteFileCommand(new Struct {
              FilePath = localPath,
              Arguments = "--verbose -y"
          });
          asset.GrantRead(instance.Role);

          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) supports only MultipartUserData.

          The parts can be executed at different moment of instance start-up and can serve a different purposes. 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:

          // Example automatically generated without compilation. See https://github.com/aws/jsii/issues/826
          var bootHookConf = ec2.UserData.ForLinux();
          bootHookConf.AddCommands("cloud-init-per once docker_options echo 'OPTIONS=\"${OPTIONS} --storage-opt dm.basesize=40G\"' >> /etc/sysconfig/docker");
          
          var setupCommands = ec2.UserData.ForLinux();
          setupCommands.AddCommands("sudo yum install awscli && echo Packages installed らと > /var/tmp/setup");
          
          var multipartUserData = new ec2.MultipartUserData();
          // The docker has to be configured at early stage, so content type is overridden to boothook
          multipartUserData.AddPart(ec2.MultipartBody.FromUserData(bootHookConf, "text/cloud-boothook; charset=\"us-ascii\""));
          // Execute the rest of setup
          multipartUserData.AddPart(ec2.MultipartBody.FromUserData(setupCommands));
          
          new ec2.LaunchTemplate(stack, "", new Struct {
              UserData = multipartUserData,
              BlockDevices = new [] {  }
          });

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

          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");

          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, and security group.

          // Example automatically generated without compilation. See https://github.com/aws/jsii/issues/826
          var vpc = new ec2.Vpc(...);
          // ...
          var template = new ec2.LaunchTemplate(this, "LaunchTemplate", new Struct {
              MachineImage = new ec2.AmazonMachineImage(),
              SecurityGroup = new ec2.SecurityGroup(this, "LaunchTemplateSG", new Struct {
                  Vpc = vpc
              })
          });

          Classes

          AclCidr

          (experimental) Either an IPv4 or an IPv6 CIDR.

          AclCidrConfig

          (experimental) Acl Configuration for CIDR.

          AclIcmp

          (experimental) Properties to create Icmp.

          AclPortRange

          (experimental) Properties to create PortRange.

          AclTraffic

          (experimental) The traffic that is configured using a Network ACL entry.

          AclTrafficConfig

          (experimental) Acl Configuration for traffic.

          Action

          (experimental) What action to apply to traffic matching the ACL.

          AddRouteOptions

          Options for adding a new route to a subnet.

          AmazonLinuxCpuType

          CPU type.

          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.

          ApplyCloudFormationInitOptions

          Options for applying CloudFormation init to an instance or instance group.

          AttachInitOptions

          Options for attaching a CloudFormationInit to a resource.

          BastionHostLinux

          (experimental) This creates a linux bastion host you can use to connect to other instances or services in your VPC.

          BastionHostLinuxProps

          (experimental) 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 AWS::EC2::CapacityReservation.

          CfnCapacityReservation.TagSpecificationProperty
          CfnCapacityReservationProps

          Properties for defining a AWS::EC2::CapacityReservation.

          CfnCarrierGateway

          A CloudFormation AWS::EC2::CarrierGateway.

          CfnCarrierGatewayProps

          Properties for defining a AWS::EC2::CarrierGateway.

          CfnClientVpnAuthorizationRule

          A CloudFormation AWS::EC2::ClientVpnAuthorizationRule.

          CfnClientVpnAuthorizationRuleProps

          Properties for defining a AWS::EC2::ClientVpnAuthorizationRule.

          CfnClientVpnEndpoint

          A CloudFormation AWS::EC2::ClientVpnEndpoint.

          CfnClientVpnEndpoint.CertificateAuthenticationRequestProperty
          CfnClientVpnEndpoint.ClientAuthenticationRequestProperty
          CfnClientVpnEndpoint.ClientConnectOptionsProperty
          CfnClientVpnEndpoint.ConnectionLogOptionsProperty
          CfnClientVpnEndpoint.DirectoryServiceAuthenticationRequestProperty
          CfnClientVpnEndpoint.FederatedAuthenticationRequestProperty
          CfnClientVpnEndpoint.TagSpecificationProperty
          CfnClientVpnEndpointProps

          Properties for defining a AWS::EC2::ClientVpnEndpoint.

          CfnClientVpnRoute

          A CloudFormation AWS::EC2::ClientVpnRoute.

          CfnClientVpnRouteProps

          Properties for defining a AWS::EC2::ClientVpnRoute.

          CfnClientVpnTargetNetworkAssociation

          A CloudFormation AWS::EC2::ClientVpnTargetNetworkAssociation.

          CfnClientVpnTargetNetworkAssociationProps

          Properties for defining a AWS::EC2::ClientVpnTargetNetworkAssociation.

          CfnCustomerGateway

          A CloudFormation AWS::EC2::CustomerGateway.

          CfnCustomerGatewayProps

          Properties for defining a AWS::EC2::CustomerGateway.

          CfnDHCPOptions

          A CloudFormation AWS::EC2::DHCPOptions.

          CfnDHCPOptionsProps

          Properties for defining a AWS::EC2::DHCPOptions.

          CfnEC2Fleet

          A CloudFormation AWS::EC2::EC2Fleet.

          CfnEC2Fleet.CapacityReservationOptionsRequestProperty
          CfnEC2Fleet.FleetLaunchTemplateConfigRequestProperty
          CfnEC2Fleet.FleetLaunchTemplateOverridesRequestProperty
          CfnEC2Fleet.FleetLaunchTemplateSpecificationRequestProperty
          CfnEC2Fleet.OnDemandOptionsRequestProperty
          CfnEC2Fleet.PlacementProperty
          CfnEC2Fleet.SpotOptionsRequestProperty
          CfnEC2Fleet.TagSpecificationProperty
          CfnEC2Fleet.TargetCapacitySpecificationRequestProperty
          CfnEC2FleetProps

          Properties for defining a AWS::EC2::EC2Fleet.

          CfnEgressOnlyInternetGateway

          A CloudFormation AWS::EC2::EgressOnlyInternetGateway.

          CfnEgressOnlyInternetGatewayProps

          Properties for defining a AWS::EC2::EgressOnlyInternetGateway.

          CfnEIP

          A CloudFormation AWS::EC2::EIP.

          CfnEIPAssociation

          A CloudFormation AWS::EC2::EIPAssociation.

          CfnEIPAssociationProps

          Properties for defining a AWS::EC2::EIPAssociation.

          CfnEIPProps

          Properties for defining a AWS::EC2::EIP.

          CfnFlowLog

          A CloudFormation AWS::EC2::FlowLog.

          CfnFlowLogProps

          Properties for defining a AWS::EC2::FlowLog.

          CfnGatewayRouteTableAssociation

          A CloudFormation AWS::EC2::GatewayRouteTableAssociation.

          CfnGatewayRouteTableAssociationProps

          Properties for defining a AWS::EC2::GatewayRouteTableAssociation.

          CfnHost

          A CloudFormation AWS::EC2::Host.

          CfnHostProps

          Properties for defining a AWS::EC2::Host.

          CfnInstance

          A CloudFormation AWS::EC2::Instance.

          CfnInstance.AssociationParameterProperty
          CfnInstance.BlockDeviceMappingProperty
          CfnInstance.CpuOptionsProperty
          CfnInstance.CreditSpecificationProperty
          CfnInstance.EbsProperty
          CfnInstance.ElasticGpuSpecificationProperty
          CfnInstance.ElasticInferenceAcceleratorProperty
          CfnInstance.EnclaveOptionsProperty
          CfnInstance.HibernationOptionsProperty
          CfnInstance.InstanceIpv6AddressProperty
          CfnInstance.LaunchTemplateSpecificationProperty
          CfnInstance.LicenseSpecificationProperty
          CfnInstance.NetworkInterfaceProperty
          CfnInstance.NoDeviceProperty
          CfnInstance.PrivateIpAddressSpecificationProperty
          CfnInstance.SsmAssociationProperty
          CfnInstance.VolumeProperty
          CfnInstanceProps

          Properties for defining a AWS::EC2::Instance.

          CfnInternetGateway

          A CloudFormation AWS::EC2::InternetGateway.

          CfnInternetGatewayProps

          Properties for defining a AWS::EC2::InternetGateway.

          CfnLaunchTemplate

          A CloudFormation AWS::EC2::LaunchTemplate.

          CfnLaunchTemplate.BlockDeviceMappingProperty
          CfnLaunchTemplate.CapacityReservationSpecificationProperty
          CfnLaunchTemplate.CapacityReservationTargetProperty
          CfnLaunchTemplate.CpuOptionsProperty
          CfnLaunchTemplate.CreditSpecificationProperty
          CfnLaunchTemplate.EbsProperty
          CfnLaunchTemplate.ElasticGpuSpecificationProperty
          CfnLaunchTemplate.EnclaveOptionsProperty
          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 AWS::EC2::LaunchTemplate.

          CfnLocalGatewayRoute

          A CloudFormation AWS::EC2::LocalGatewayRoute.

          CfnLocalGatewayRouteProps

          Properties for defining a AWS::EC2::LocalGatewayRoute.

          CfnLocalGatewayRouteTableVPCAssociation

          A CloudFormation AWS::EC2::LocalGatewayRouteTableVPCAssociation.

          CfnLocalGatewayRouteTableVPCAssociationProps

          Properties for defining a AWS::EC2::LocalGatewayRouteTableVPCAssociation.

          CfnNatGateway

          A CloudFormation AWS::EC2::NatGateway.

          CfnNatGatewayProps

          Properties for defining a AWS::EC2::NatGateway.

          CfnNetworkAcl

          A CloudFormation AWS::EC2::NetworkAcl.

          CfnNetworkAclEntry

          A CloudFormation AWS::EC2::NetworkAclEntry.

          CfnNetworkAclEntry.IcmpProperty
          CfnNetworkAclEntry.PortRangeProperty
          CfnNetworkAclEntryProps

          Properties for defining a AWS::EC2::NetworkAclEntry.

          CfnNetworkAclProps

          Properties for defining a AWS::EC2::NetworkAcl.

          CfnNetworkInsightsAnalysis

          A CloudFormation AWS::EC2::NetworkInsightsAnalysis.

          CfnNetworkInsightsAnalysis.AlternatePathHintProperty
          CfnNetworkInsightsAnalysis.AnalysisAclRuleProperty
          CfnNetworkInsightsAnalysis.AnalysisComponentProperty
          CfnNetworkInsightsAnalysis.AnalysisLoadBalancerListenerProperty
          CfnNetworkInsightsAnalysis.AnalysisLoadBalancerTargetProperty
          CfnNetworkInsightsAnalysis.AnalysisPacketHeaderProperty
          CfnNetworkInsightsAnalysis.AnalysisRouteTableRouteProperty
          CfnNetworkInsightsAnalysis.AnalysisSecurityGroupRuleProperty
          CfnNetworkInsightsAnalysis.ExplanationProperty
          CfnNetworkInsightsAnalysis.PathComponentProperty
          CfnNetworkInsightsAnalysis.PortRangeProperty
          CfnNetworkInsightsAnalysisProps

          Properties for defining a AWS::EC2::NetworkInsightsAnalysis.

          CfnNetworkInsightsPath

          A CloudFormation AWS::EC2::NetworkInsightsPath.

          CfnNetworkInsightsPathProps

          Properties for defining a AWS::EC2::NetworkInsightsPath.

          CfnNetworkInterface

          A CloudFormation AWS::EC2::NetworkInterface.

          CfnNetworkInterface.InstanceIpv6AddressProperty
          CfnNetworkInterface.PrivateIpAddressSpecificationProperty
          CfnNetworkInterfaceAttachment

          A CloudFormation AWS::EC2::NetworkInterfaceAttachment.

          CfnNetworkInterfaceAttachmentProps

          Properties for defining a AWS::EC2::NetworkInterfaceAttachment.

          CfnNetworkInterfacePermission

          A CloudFormation AWS::EC2::NetworkInterfacePermission.

          CfnNetworkInterfacePermissionProps

          Properties for defining a AWS::EC2::NetworkInterfacePermission.

          CfnNetworkInterfaceProps

          Properties for defining a AWS::EC2::NetworkInterface.

          CfnPlacementGroup

          A CloudFormation AWS::EC2::PlacementGroup.

          CfnPlacementGroupProps

          Properties for defining a AWS::EC2::PlacementGroup.

          CfnPrefixList

          A CloudFormation AWS::EC2::PrefixList.

          CfnPrefixList.EntryProperty
          CfnPrefixListProps

          Properties for defining a AWS::EC2::PrefixList.

          CfnRoute

          A CloudFormation AWS::EC2::Route.

          CfnRouteProps

          Properties for defining a AWS::EC2::Route.

          CfnRouteTable

          A CloudFormation AWS::EC2::RouteTable.

          CfnRouteTableProps

          Properties for defining a AWS::EC2::RouteTable.

          CfnSecurityGroup

          A CloudFormation AWS::EC2::SecurityGroup.

          CfnSecurityGroup.EgressProperty
          CfnSecurityGroup.IngressProperty
          CfnSecurityGroupEgress

          A CloudFormation AWS::EC2::SecurityGroupEgress.

          CfnSecurityGroupEgressProps

          Properties for defining a AWS::EC2::SecurityGroupEgress.

          CfnSecurityGroupIngress

          A CloudFormation AWS::EC2::SecurityGroupIngress.

          CfnSecurityGroupIngressProps

          Properties for defining a AWS::EC2::SecurityGroupIngress.

          CfnSecurityGroupProps

          Properties for defining a AWS::EC2::SecurityGroup.

          CfnSpotFleet

          A CloudFormation AWS::EC2::SpotFleet.

          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.SpotCapacityRebalanceProperty
          CfnSpotFleet.SpotFleetLaunchSpecificationProperty
          CfnSpotFleet.SpotFleetMonitoringProperty
          CfnSpotFleet.SpotFleetRequestConfigDataProperty
          CfnSpotFleet.SpotFleetTagSpecificationProperty
          CfnSpotFleet.SpotMaintenanceStrategiesProperty
          CfnSpotFleet.SpotPlacementProperty
          CfnSpotFleet.TargetGroupProperty
          CfnSpotFleet.TargetGroupsConfigProperty
          CfnSpotFleetProps

          Properties for defining a AWS::EC2::SpotFleet.

          CfnSubnet

          A CloudFormation AWS::EC2::Subnet.

          CfnSubnetCidrBlock

          A CloudFormation AWS::EC2::SubnetCidrBlock.

          CfnSubnetCidrBlockProps

          Properties for defining a AWS::EC2::SubnetCidrBlock.

          CfnSubnetNetworkAclAssociation

          A CloudFormation AWS::EC2::SubnetNetworkAclAssociation.

          CfnSubnetNetworkAclAssociationProps

          Properties for defining a AWS::EC2::SubnetNetworkAclAssociation.

          CfnSubnetProps

          Properties for defining a AWS::EC2::Subnet.

          CfnSubnetRouteTableAssociation

          A CloudFormation AWS::EC2::SubnetRouteTableAssociation.

          CfnSubnetRouteTableAssociationProps

          Properties for defining a AWS::EC2::SubnetRouteTableAssociation.

          CfnTrafficMirrorFilter

          A CloudFormation AWS::EC2::TrafficMirrorFilter.

          CfnTrafficMirrorFilterProps

          Properties for defining a AWS::EC2::TrafficMirrorFilter.

          CfnTrafficMirrorFilterRule

          A CloudFormation AWS::EC2::TrafficMirrorFilterRule.

          CfnTrafficMirrorFilterRule.TrafficMirrorPortRangeProperty
          CfnTrafficMirrorFilterRuleProps

          Properties for defining a AWS::EC2::TrafficMirrorFilterRule.

          CfnTrafficMirrorSession

          A CloudFormation AWS::EC2::TrafficMirrorSession.

          CfnTrafficMirrorSessionProps

          Properties for defining a AWS::EC2::TrafficMirrorSession.

          CfnTrafficMirrorTarget

          A CloudFormation AWS::EC2::TrafficMirrorTarget.

          CfnTrafficMirrorTargetProps

          Properties for defining a AWS::EC2::TrafficMirrorTarget.

          CfnTransitGateway

          A CloudFormation AWS::EC2::TransitGateway.

          CfnTransitGatewayAttachment

          A CloudFormation AWS::EC2::TransitGatewayAttachment.

          CfnTransitGatewayAttachmentProps

          Properties for defining a AWS::EC2::TransitGatewayAttachment.

          CfnTransitGatewayConnect

          A CloudFormation AWS::EC2::TransitGatewayConnect.

          CfnTransitGatewayConnect.TransitGatewayConnectOptionsProperty
          CfnTransitGatewayConnectProps

          Properties for defining a AWS::EC2::TransitGatewayConnect.

          CfnTransitGatewayMulticastDomain

          A CloudFormation AWS::EC2::TransitGatewayMulticastDomain.

          CfnTransitGatewayMulticastDomainAssociation

          A CloudFormation AWS::EC2::TransitGatewayMulticastDomainAssociation.

          CfnTransitGatewayMulticastDomainAssociationProps

          Properties for defining a AWS::EC2::TransitGatewayMulticastDomainAssociation.

          CfnTransitGatewayMulticastDomainProps

          Properties for defining a AWS::EC2::TransitGatewayMulticastDomain.

          CfnTransitGatewayMulticastGroupMember

          A CloudFormation AWS::EC2::TransitGatewayMulticastGroupMember.

          CfnTransitGatewayMulticastGroupMemberProps

          Properties for defining a AWS::EC2::TransitGatewayMulticastGroupMember.

          CfnTransitGatewayMulticastGroupSource

          A CloudFormation AWS::EC2::TransitGatewayMulticastGroupSource.

          CfnTransitGatewayMulticastGroupSourceProps

          Properties for defining a AWS::EC2::TransitGatewayMulticastGroupSource.

          CfnTransitGatewayProps

          Properties for defining a AWS::EC2::TransitGateway.

          CfnTransitGatewayRoute

          A CloudFormation AWS::EC2::TransitGatewayRoute.

          CfnTransitGatewayRouteProps

          Properties for defining a AWS::EC2::TransitGatewayRoute.

          CfnTransitGatewayRouteTable

          A CloudFormation AWS::EC2::TransitGatewayRouteTable.

          CfnTransitGatewayRouteTableAssociation

          A CloudFormation AWS::EC2::TransitGatewayRouteTableAssociation.

          CfnTransitGatewayRouteTableAssociationProps

          Properties for defining a AWS::EC2::TransitGatewayRouteTableAssociation.

          CfnTransitGatewayRouteTablePropagation

          A CloudFormation AWS::EC2::TransitGatewayRouteTablePropagation.

          CfnTransitGatewayRouteTablePropagationProps

          Properties for defining a AWS::EC2::TransitGatewayRouteTablePropagation.

          CfnTransitGatewayRouteTableProps

          Properties for defining a AWS::EC2::TransitGatewayRouteTable.

          CfnVolume

          A CloudFormation AWS::EC2::Volume.

          CfnVolumeAttachment

          A CloudFormation AWS::EC2::VolumeAttachment.

          CfnVolumeAttachmentProps

          Properties for defining a AWS::EC2::VolumeAttachment.

          CfnVolumeProps

          Properties for defining a AWS::EC2::Volume.

          CfnVPC

          A CloudFormation AWS::EC2::VPC.

          CfnVPCCidrBlock

          A CloudFormation AWS::EC2::VPCCidrBlock.

          CfnVPCCidrBlockProps

          Properties for defining a AWS::EC2::VPCCidrBlock.

          CfnVPCDHCPOptionsAssociation

          A CloudFormation AWS::EC2::VPCDHCPOptionsAssociation.

          CfnVPCDHCPOptionsAssociationProps

          Properties for defining a AWS::EC2::VPCDHCPOptionsAssociation.

          CfnVPCEndpoint

          A CloudFormation AWS::EC2::VPCEndpoint.

          CfnVPCEndpointConnectionNotification

          A CloudFormation AWS::EC2::VPCEndpointConnectionNotification.

          CfnVPCEndpointConnectionNotificationProps

          Properties for defining a AWS::EC2::VPCEndpointConnectionNotification.

          CfnVPCEndpointProps

          Properties for defining a AWS::EC2::VPCEndpoint.

          CfnVPCEndpointService

          A CloudFormation AWS::EC2::VPCEndpointService.

          CfnVPCEndpointServicePermissions

          A CloudFormation AWS::EC2::VPCEndpointServicePermissions.

          CfnVPCEndpointServicePermissionsProps

          Properties for defining a AWS::EC2::VPCEndpointServicePermissions.

          CfnVPCEndpointServiceProps

          Properties for defining a AWS::EC2::VPCEndpointService.

          CfnVPCGatewayAttachment

          A CloudFormation AWS::EC2::VPCGatewayAttachment.

          CfnVPCGatewayAttachmentProps

          Properties for defining a AWS::EC2::VPCGatewayAttachment.

          CfnVPCPeeringConnection

          A CloudFormation AWS::EC2::VPCPeeringConnection.

          CfnVPCPeeringConnectionProps

          Properties for defining a AWS::EC2::VPCPeeringConnection.

          CfnVPCProps

          Properties for defining a AWS::EC2::VPC.

          CfnVPNConnection

          A CloudFormation AWS::EC2::VPNConnection.

          CfnVPNConnection.VpnTunnelOptionsSpecificationProperty
          CfnVPNConnectionProps

          Properties for defining a AWS::EC2::VPNConnection.

          CfnVPNConnectionRoute

          A CloudFormation AWS::EC2::VPNConnectionRoute.

          CfnVPNConnectionRouteProps

          Properties for defining a AWS::EC2::VPNConnectionRoute.

          CfnVPNGateway

          A CloudFormation AWS::EC2::VPNGateway.

          CfnVPNGatewayProps

          Properties for defining a AWS::EC2::VPNGateway.

          CfnVPNGatewayRoutePropagation

          A CloudFormation AWS::EC2::VPNGatewayRoutePropagation.

          CfnVPNGatewayRoutePropagationProps

          Properties for defining a AWS::EC2::VPNGatewayRoutePropagation.

          ClientVpnAuthorizationRule

          A client VPN authorization rule.

          ClientVpnAuthorizationRuleOptions

          Options for a ClientVpnAuthorizationRule.

          ClientVpnAuthorizationRuleProps

          Properties for a ClientVpnAuthorizationRule.

          ClientVpnEndpoint

          A client VPN connnection.

          ClientVpnEndpointAttributes

          Attributes when importing an existing client VPN endpoint.

          ClientVpnEndpointOptions

          Options for a client VPN endpoint.

          ClientVpnEndpointProps

          Properties for a client VPN endpoint.

          ClientVpnRoute

          A client VPN route.

          ClientVpnRouteOptions

          Options for a ClientVpnRoute.

          ClientVpnRouteProps

          Properties for a ClientVpnRoute.

          ClientVpnRouteTarget

          Target for a client VPN route.

          ClientVpnUserBasedAuthentication

          User-based authentication for a client VPN endpoint.

          CloudFormationInit

          A CloudFormation-init configuration.

          CommonNetworkAclEntryOptions

          (experimental) Basic NetworkACL entry props.

          ConfigSetProps

          Options for CloudFormationInit.withConfigSets.

          ConfigureNatOptions

          (experimental) 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.

          CpuCredits

          Provides the options for specifying the CPU credit type for burstable EC2 instance types (T2, T3, T3a, etc).

          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.

          EnableVpnGatewayOptions

          Options for the Vpc.enableVpnGateway() method.

          ExecuteFileOptions

          Options when executing a file.

          FlowLog

          (experimental) A VPC flow log.

          FlowLogDestination

          (experimental) The destination type for the flow log.

          FlowLogDestinationConfig

          (experimental) Flow Log Destination configuration.

          FlowLogDestinationType

          (experimental) The available destination types for Flow Logs.

          FlowLogOptions

          (experimental) Options to add a flow log to a VPC.

          FlowLogProps

          (experimental) Properties of a VPC Flow Log.

          FlowLogResourceType

          (experimental) The type of resource to create the flow log for.

          FlowLogTrafficType

          (experimental) 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.

          GenericSSMParameterImage

          Select the image based on a given SSM parameter.

          GenericWindowsImage

          Construct a Windows machine image from an AMI map.

          GenericWindowsImageProps

          Configuration options for GenericWindowsImage.

          InitCommand

          Command to execute on the instance.

          InitCommandOptions

          Options for InitCommand.

          InitCommandWaitDuration

          Represents a duration to wait after a command has finished, in case of a reboot (Windows only).

          InitConfig

          A collection of configuration elements.

          InitElement

          Base class for all CloudFormation Init elements.

          InitFile

          Create files on the EC2 instance.

          InitFileAssetOptions

          Additional options for creating an InitFile from an asset.

          InitFileOptions

          Options for InitFile.

          InitGroup

          Create Linux/UNIX groups and assign group IDs.

          InitPackage

          A package to be installed during cfn-init time.

          InitService

          A services that be enabled, disabled or restarted when the instance is launched.

          InitServiceOptions

          Options for an InitService.

          InitServiceRestartHandle

          An object that represents reasons to restart an InitService.

          InitSource

          Extract an archive into a directory.

          InitSourceAssetOptions

          Additional options for an InitSource that builds an asset from local files.

          InitSourceOptions

          Additional options for an InitSource.

          InitUser

          Create Linux/UNIX users and to assign user IDs.

          InitUserOptions

          Optional parameters used when creating a user.

          Instance_

          This represents a single EC2 instance.

          InstanceArchitecture

          Identifies an instance's CPU architecture.

          InstanceClass

          What class and generation of instance to use.

          InstanceInitiatedShutdownBehavior

          Provides the options for specifying the instance initiated shutdown behavior.

          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.

          LaunchTemplate

          This represents an EC2 LaunchTemplate.

          LaunchTemplateAttributes

          Attributes for an imported LaunchTemplate.

          LaunchTemplateProps

          Properties of a LaunchTemplate.

          LaunchTemplateSpecialVersions

          A class that provides convenient access to special version tokens for LaunchTemplate versions.

          LaunchTemplateSpotOptions

          Interface for the Spot market instance options provided in a LaunchTemplate.

          LinuxUserDataOptions

          Options when constructing UserData for Linux.

          LocationPackageOptions

          Options for InitPackage.rpm/InitPackage.msi.

          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.

          MultipartBody

          The base class for all classes which can be used as {@link MultipartUserData}.

          MultipartBodyOptions

          Options when creating MultipartBody.

          MultipartUserData

          Mime multipart user data.

          MultipartUserDataOptions

          Options for creating {@link MultipartUserData}.

          NamedPackageOptions

          Options for InitPackage.yum/apt/rubyGem/python.

          NatInstanceImage

          (experimental) Machine image representing the latest NAT instance image.

          NatInstanceProps

          (experimental) Properties for a NAT instance.

          NatInstanceProvider

          NAT provider which uses NAT Instances.

          NatProvider

          (experimental) NAT providers.

          NatTrafficDirection

          Direction of traffic to allow all by default.

          NetworkAcl

          (experimental) Define a new custom network ACL.

          NetworkAclEntry

          (experimental) Define an entry in a Network ACL table.

          NetworkAclEntryProps

          (experimental) Properties to create NetworkAclEntry.

          NetworkAclProps

          (experimental) 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.

          SpotInstanceInterruption

          Provides the options for the types of interruption for spot instances.

          SpotRequestType

          The Spot Instance request type.

          Subnet

          Represents a new VPC subnet resource.

          SubnetAttributes
          SubnetConfiguration

          Specify configuration parameters for a single subnet group in a VPC.

          SubnetFilter

          Contains logic which chooses a set of subnets from a larger list, in conjunction with SubnetSelection, to determine where to place AWS resources such as VPC endpoints, EC2 instances, etc.

          SubnetNetworkAclAssociation
          SubnetNetworkAclAssociationProps

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

          (experimental) Direction of traffic the AclEntry applies to.

          TransportProtocol

          Transport protocol for client VPN.

          UserData

          Instance User Data.

          Volume

          Creates a new EBS Volume in AWS EC2.

          VolumeAttributes

          Attributes required to import an existing EBS Volume into the Stack.

          VolumeProps

          Properties of an EBS Volume.

          Vpc

          Define an AWS Virtual Private Cloud.

          VpcAttributes

          Properties that reference an external Vpc.

          VpcEndpoint
          VpcEndpointService

          (experimental) A VPC endpoint service.

          VpcEndpointServiceProps

          (experimental) 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.

          VpnGateway

          The VPN Gateway that shall be added to the VPC.

          VpnGatewayProps

          The VpnGateway Properties.

          VpnPort

          Port for client VPN.

          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.

          Interfaces

          CfnCapacityReservation.ITagSpecificationProperty
          CfnClientVpnEndpoint.ICertificateAuthenticationRequestProperty
          CfnClientVpnEndpoint.IClientAuthenticationRequestProperty
          CfnClientVpnEndpoint.IClientConnectOptionsProperty
          CfnClientVpnEndpoint.IConnectionLogOptionsProperty
          CfnClientVpnEndpoint.IDirectoryServiceAuthenticationRequestProperty
          CfnClientVpnEndpoint.IFederatedAuthenticationRequestProperty
          CfnClientVpnEndpoint.ITagSpecificationProperty
          CfnEC2Fleet.ICapacityReservationOptionsRequestProperty
          CfnEC2Fleet.IFleetLaunchTemplateConfigRequestProperty
          CfnEC2Fleet.IFleetLaunchTemplateOverridesRequestProperty
          CfnEC2Fleet.IFleetLaunchTemplateSpecificationRequestProperty
          CfnEC2Fleet.IOnDemandOptionsRequestProperty
          CfnEC2Fleet.IPlacementProperty
          CfnEC2Fleet.ISpotOptionsRequestProperty
          CfnEC2Fleet.ITagSpecificationProperty
          CfnEC2Fleet.ITargetCapacitySpecificationRequestProperty
          CfnInstance.IAssociationParameterProperty
          CfnInstance.IBlockDeviceMappingProperty
          CfnInstance.ICpuOptionsProperty
          CfnInstance.ICreditSpecificationProperty
          CfnInstance.IEbsProperty
          CfnInstance.IElasticGpuSpecificationProperty
          CfnInstance.IElasticInferenceAcceleratorProperty
          CfnInstance.IEnclaveOptionsProperty
          CfnInstance.IHibernationOptionsProperty
          CfnInstance.IInstanceIpv6AddressProperty
          CfnInstance.ILaunchTemplateSpecificationProperty
          CfnInstance.ILicenseSpecificationProperty
          CfnInstance.INetworkInterfaceProperty
          CfnInstance.INoDeviceProperty
          CfnInstance.IPrivateIpAddressSpecificationProperty
          CfnInstance.ISsmAssociationProperty
          CfnInstance.IVolumeProperty
          CfnLaunchTemplate.IBlockDeviceMappingProperty
          CfnLaunchTemplate.ICapacityReservationSpecificationProperty
          CfnLaunchTemplate.ICapacityReservationTargetProperty
          CfnLaunchTemplate.ICpuOptionsProperty
          CfnLaunchTemplate.ICreditSpecificationProperty
          CfnLaunchTemplate.IEbsProperty
          CfnLaunchTemplate.IElasticGpuSpecificationProperty
          CfnLaunchTemplate.IEnclaveOptionsProperty
          CfnLaunchTemplate.IHibernationOptionsProperty
          CfnLaunchTemplate.IIamInstanceProfileProperty
          CfnLaunchTemplate.IInstanceMarketOptionsProperty
          CfnLaunchTemplate.IIpv6AddProperty
          CfnLaunchTemplate.ILaunchTemplateDataProperty
          CfnLaunchTemplate.ILaunchTemplateElasticInferenceAcceleratorProperty
          CfnLaunchTemplate.ILicenseSpecificationProperty
          CfnLaunchTemplate.IMetadataOptionsProperty
          CfnLaunchTemplate.IMonitoringProperty
          CfnLaunchTemplate.INetworkInterfaceProperty
          CfnLaunchTemplate.IPlacementProperty
          CfnLaunchTemplate.IPrivateIpAddProperty
          CfnLaunchTemplate.ISpotOptionsProperty
          CfnLaunchTemplate.ITagSpecificationProperty
          CfnNetworkAclEntry.IIcmpProperty
          CfnNetworkAclEntry.IPortRangeProperty
          CfnNetworkInsightsAnalysis.IAlternatePathHintProperty
          CfnNetworkInsightsAnalysis.IAnalysisAclRuleProperty
          CfnNetworkInsightsAnalysis.IAnalysisComponentProperty
          CfnNetworkInsightsAnalysis.IAnalysisLoadBalancerListenerProperty
          CfnNetworkInsightsAnalysis.IAnalysisLoadBalancerTargetProperty
          CfnNetworkInsightsAnalysis.IAnalysisPacketHeaderProperty
          CfnNetworkInsightsAnalysis.IAnalysisRouteTableRouteProperty
          CfnNetworkInsightsAnalysis.IAnalysisSecurityGroupRuleProperty
          CfnNetworkInsightsAnalysis.IExplanationProperty
          CfnNetworkInsightsAnalysis.IPathComponentProperty
          CfnNetworkInsightsAnalysis.IPortRangeProperty
          CfnNetworkInterface.IInstanceIpv6AddressProperty
          CfnNetworkInterface.IPrivateIpAddressSpecificationProperty
          CfnPrefixList.IEntryProperty
          CfnSecurityGroup.IEgressProperty
          CfnSecurityGroup.IIngressProperty
          CfnSpotFleet.IBlockDeviceMappingProperty
          CfnSpotFleet.IClassicLoadBalancerProperty
          CfnSpotFleet.IClassicLoadBalancersConfigProperty
          CfnSpotFleet.IEbsBlockDeviceProperty
          CfnSpotFleet.IFleetLaunchTemplateSpecificationProperty
          CfnSpotFleet.IGroupIdentifierProperty
          CfnSpotFleet.IIamInstanceProfileSpecificationProperty
          CfnSpotFleet.IInstanceIpv6AddressProperty
          CfnSpotFleet.IInstanceNetworkInterfaceSpecificationProperty
          CfnSpotFleet.ILaunchTemplateConfigProperty
          CfnSpotFleet.ILaunchTemplateOverridesProperty
          CfnSpotFleet.ILoadBalancersConfigProperty
          CfnSpotFleet.IPrivateIpAddressSpecificationProperty
          CfnSpotFleet.ISpotCapacityRebalanceProperty
          CfnSpotFleet.ISpotFleetLaunchSpecificationProperty
          CfnSpotFleet.ISpotFleetMonitoringProperty
          CfnSpotFleet.ISpotFleetRequestConfigDataProperty
          CfnSpotFleet.ISpotFleetTagSpecificationProperty
          CfnSpotFleet.ISpotMaintenanceStrategiesProperty
          CfnSpotFleet.ISpotPlacementProperty
          CfnSpotFleet.ITargetGroupProperty
          CfnSpotFleet.ITargetGroupsConfigProperty
          CfnTrafficMirrorFilterRule.ITrafficMirrorPortRangeProperty
          CfnTransitGatewayConnect.ITransitGatewayConnectOptionsProperty
          CfnVPNConnection.IVpnTunnelOptionsSpecificationProperty
          IAclCidrConfig

          (experimental) Acl Configuration for CIDR.

          IAclIcmp

          (experimental) Properties to create Icmp.

          IAclPortRange

          (experimental) Properties to create PortRange.

          IAclTrafficConfig

          (experimental) Acl Configuration for traffic.

          IAddRouteOptions

          Options for adding a new route to a subnet.

          IAmazonLinuxImageProps

          Amazon Linux image properties.

          IApplyCloudFormationInitOptions

          Options for applying CloudFormation init to an instance or instance group.

          IAttachInitOptions

          Options for attaching a CloudFormationInit to a resource.

          IBastionHostLinuxProps

          (experimental) Properties of the bastion host.

          IBlockDevice

          Block device.

          ICfnCapacityReservationProps

          Properties for defining a AWS::EC2::CapacityReservation.

          ICfnCarrierGatewayProps

          Properties for defining a AWS::EC2::CarrierGateway.

          ICfnClientVpnAuthorizationRuleProps

          Properties for defining a AWS::EC2::ClientVpnAuthorizationRule.

          ICfnClientVpnEndpointProps

          Properties for defining a AWS::EC2::ClientVpnEndpoint.

          ICfnClientVpnRouteProps

          Properties for defining a AWS::EC2::ClientVpnRoute.

          ICfnClientVpnTargetNetworkAssociationProps

          Properties for defining a AWS::EC2::ClientVpnTargetNetworkAssociation.

          ICfnCustomerGatewayProps

          Properties for defining a AWS::EC2::CustomerGateway.

          ICfnDHCPOptionsProps

          Properties for defining a AWS::EC2::DHCPOptions.

          ICfnEC2FleetProps

          Properties for defining a AWS::EC2::EC2Fleet.

          ICfnEgressOnlyInternetGatewayProps

          Properties for defining a AWS::EC2::EgressOnlyInternetGateway.

          ICfnEIPAssociationProps

          Properties for defining a AWS::EC2::EIPAssociation.

          ICfnEIPProps

          Properties for defining a AWS::EC2::EIP.

          ICfnFlowLogProps

          Properties for defining a AWS::EC2::FlowLog.

          ICfnGatewayRouteTableAssociationProps

          Properties for defining a AWS::EC2::GatewayRouteTableAssociation.

          ICfnHostProps

          Properties for defining a AWS::EC2::Host.

          ICfnInstanceProps

          Properties for defining a AWS::EC2::Instance.

          ICfnInternetGatewayProps

          Properties for defining a AWS::EC2::InternetGateway.

          ICfnLaunchTemplateProps

          Properties for defining a AWS::EC2::LaunchTemplate.

          ICfnLocalGatewayRouteProps

          Properties for defining a AWS::EC2::LocalGatewayRoute.

          ICfnLocalGatewayRouteTableVPCAssociationProps

          Properties for defining a AWS::EC2::LocalGatewayRouteTableVPCAssociation.

          ICfnNatGatewayProps

          Properties for defining a AWS::EC2::NatGateway.

          ICfnNetworkAclEntryProps

          Properties for defining a AWS::EC2::NetworkAclEntry.

          ICfnNetworkAclProps

          Properties for defining a AWS::EC2::NetworkAcl.

          ICfnNetworkInsightsAnalysisProps

          Properties for defining a AWS::EC2::NetworkInsightsAnalysis.

          ICfnNetworkInsightsPathProps

          Properties for defining a AWS::EC2::NetworkInsightsPath.

          ICfnNetworkInterfaceAttachmentProps

          Properties for defining a AWS::EC2::NetworkInterfaceAttachment.

          ICfnNetworkInterfacePermissionProps

          Properties for defining a AWS::EC2::NetworkInterfacePermission.

          ICfnNetworkInterfaceProps

          Properties for defining a AWS::EC2::NetworkInterface.

          ICfnPlacementGroupProps

          Properties for defining a AWS::EC2::PlacementGroup.

          ICfnPrefixListProps

          Properties for defining a AWS::EC2::PrefixList.

          ICfnRouteProps

          Properties for defining a AWS::EC2::Route.

          ICfnRouteTableProps

          Properties for defining a AWS::EC2::RouteTable.

          ICfnSecurityGroupEgressProps

          Properties for defining a AWS::EC2::SecurityGroupEgress.

          ICfnSecurityGroupIngressProps

          Properties for defining a AWS::EC2::SecurityGroupIngress.

          ICfnSecurityGroupProps

          Properties for defining a AWS::EC2::SecurityGroup.

          ICfnSpotFleetProps

          Properties for defining a AWS::EC2::SpotFleet.

          ICfnSubnetCidrBlockProps

          Properties for defining a AWS::EC2::SubnetCidrBlock.

          ICfnSubnetNetworkAclAssociationProps

          Properties for defining a AWS::EC2::SubnetNetworkAclAssociation.

          ICfnSubnetProps

          Properties for defining a AWS::EC2::Subnet.

          ICfnSubnetRouteTableAssociationProps

          Properties for defining a AWS::EC2::SubnetRouteTableAssociation.

          ICfnTrafficMirrorFilterProps

          Properties for defining a AWS::EC2::TrafficMirrorFilter.

          ICfnTrafficMirrorFilterRuleProps

          Properties for defining a AWS::EC2::TrafficMirrorFilterRule.

          ICfnTrafficMirrorSessionProps

          Properties for defining a AWS::EC2::TrafficMirrorSession.

          ICfnTrafficMirrorTargetProps

          Properties for defining a AWS::EC2::TrafficMirrorTarget.

          ICfnTransitGatewayAttachmentProps

          Properties for defining a AWS::EC2::TransitGatewayAttachment.

          ICfnTransitGatewayConnectProps

          Properties for defining a AWS::EC2::TransitGatewayConnect.

          ICfnTransitGatewayMulticastDomainAssociationProps

          Properties for defining a AWS::EC2::TransitGatewayMulticastDomainAssociation.

          ICfnTransitGatewayMulticastDomainProps

          Properties for defining a AWS::EC2::TransitGatewayMulticastDomain.

          ICfnTransitGatewayMulticastGroupMemberProps

          Properties for defining a AWS::EC2::TransitGatewayMulticastGroupMember.

          ICfnTransitGatewayMulticastGroupSourceProps

          Properties for defining a AWS::EC2::TransitGatewayMulticastGroupSource.

          ICfnTransitGatewayProps

          Properties for defining a AWS::EC2::TransitGateway.

          ICfnTransitGatewayRouteProps

          Properties for defining a AWS::EC2::TransitGatewayRoute.

          ICfnTransitGatewayRouteTableAssociationProps

          Properties for defining a AWS::EC2::TransitGatewayRouteTableAssociation.

          ICfnTransitGatewayRouteTablePropagationProps

          Properties for defining a AWS::EC2::TransitGatewayRouteTablePropagation.

          ICfnTransitGatewayRouteTableProps

          Properties for defining a AWS::EC2::TransitGatewayRouteTable.

          ICfnVolumeAttachmentProps

          Properties for defining a AWS::EC2::VolumeAttachment.

          ICfnVolumeProps

          Properties for defining a AWS::EC2::Volume.

          ICfnVPCCidrBlockProps

          Properties for defining a AWS::EC2::VPCCidrBlock.

          ICfnVPCDHCPOptionsAssociationProps

          Properties for defining a AWS::EC2::VPCDHCPOptionsAssociation.

          ICfnVPCEndpointConnectionNotificationProps

          Properties for defining a AWS::EC2::VPCEndpointConnectionNotification.

          ICfnVPCEndpointProps

          Properties for defining a AWS::EC2::VPCEndpoint.

          ICfnVPCEndpointServicePermissionsProps

          Properties for defining a AWS::EC2::VPCEndpointServicePermissions.

          ICfnVPCEndpointServiceProps

          Properties for defining a AWS::EC2::VPCEndpointService.

          ICfnVPCGatewayAttachmentProps

          Properties for defining a AWS::EC2::VPCGatewayAttachment.

          ICfnVPCPeeringConnectionProps

          Properties for defining a AWS::EC2::VPCPeeringConnection.

          ICfnVPCProps

          Properties for defining a AWS::EC2::VPC.

          ICfnVPNConnectionProps

          Properties for defining a AWS::EC2::VPNConnection.

          ICfnVPNConnectionRouteProps

          Properties for defining a AWS::EC2::VPNConnectionRoute.

          ICfnVPNGatewayProps

          Properties for defining a AWS::EC2::VPNGateway.

          ICfnVPNGatewayRoutePropagationProps

          Properties for defining a AWS::EC2::VPNGatewayRoutePropagation.

          IClientVpnAuthorizationRuleOptions

          Options for a ClientVpnAuthorizationRule.

          IClientVpnAuthorizationRuleProps

          Properties for a ClientVpnAuthorizationRule.

          IClientVpnConnectionHandler

          A connection handler for client VPN endpoints.

          IClientVpnEndpoint

          A client VPN endpoint.

          IClientVpnEndpointAttributes

          Attributes when importing an existing client VPN endpoint.

          IClientVpnEndpointOptions

          Options for a client VPN endpoint.

          IClientVpnEndpointProps

          Properties for a client VPN endpoint.

          IClientVpnRouteOptions

          Options for a ClientVpnRoute.

          IClientVpnRouteProps

          Properties for a ClientVpnRoute.

          ICommonNetworkAclEntryOptions

          (experimental) Basic NetworkACL entry props.

          IConfigSetProps

          Options for CloudFormationInit.withConfigSets.

          IConfigureNatOptions

          (experimental) Options passed by the VPC when NAT needs to be configured.

          IConnectable

          An object that has a Connections object.

          IConnectionRule
          IConnectionsProps

          Properties to intialize a new Connections object.

          IEbsDeviceOptions

          Block device options for an EBS volume.

          IEbsDeviceOptionsBase

          Base block device options for an EBS volume.

          IEbsDeviceProps

          Properties of an EBS block device.

          IEbsDeviceSnapshotOptions

          Block device options for an EBS volume created from a snapshot.

          IEnableVpnGatewayOptions

          Options for the Vpc.enableVpnGateway() method.

          IExecuteFileOptions

          Options when executing a file.

          IFlowLog

          (experimental) A FlowLog.

          IFlowLogDestinationConfig

          (experimental) Flow Log Destination configuration.

          IFlowLogOptions

          (experimental) Options to add a flow log to a VPC.

          IFlowLogProps

          (experimental) Properties of a VPC Flow Log.

          IGatewayConfig

          Pair represents a gateway created by NAT Provider.

          IGatewayVpcEndpoint

          A gateway VPC endpoint.

          IGatewayVpcEndpointOptions

          Options to add a gateway endpoint to a VPC.

          IGatewayVpcEndpointProps

          Construction properties for a GatewayVpcEndpoint.

          IGatewayVpcEndpointService

          A service for a gateway VPC endpoint.

          IGenericLinuxImageProps

          Configuration options for GenericLinuxImage.

          IGenericWindowsImageProps

          Configuration options for GenericWindowsImage.

          IInitCommandOptions

          Options for InitCommand.

          IInitFileAssetOptions

          Additional options for creating an InitFile from an asset.

          IInitFileOptions

          Options for InitFile.

          IInitServiceOptions

          Options for an InitService.

          IInitSourceAssetOptions

          Additional options for an InitSource that builds an asset from local files.

          IInitSourceOptions

          Additional options for an InitSource.

          IInitUserOptions

          Optional parameters used when creating a user.

          IInstance
          IInstanceProps

          Properties of an EC2 Instance.

          IInterfaceVpcEndpoint

          An interface VPC endpoint.

          IInterfaceVpcEndpointAttributes

          Construction properties for an ImportedInterfaceVpcEndpoint.

          IInterfaceVpcEndpointOptions

          Options to add an interface endpoint to a VPC.

          IInterfaceVpcEndpointProps

          Construction properties for an InterfaceVpcEndpoint.

          IInterfaceVpcEndpointService

          A service for an interface VPC endpoint.

          ILaunchTemplate

          Interface for LaunchTemplate-like objects.

          ILaunchTemplateAttributes

          Attributes for an imported LaunchTemplate.

          ILaunchTemplateProps

          Properties of a LaunchTemplate.

          ILaunchTemplateSpotOptions

          Interface for the Spot market instance options provided in a LaunchTemplate.

          ILinuxUserDataOptions

          Options when constructing UserData for Linux.

          ILocationPackageOptions

          Options for InitPackage.rpm/InitPackage.msi.

          ILookupMachineImageProps

          Properties for looking up an image.

          IMachineImage

          Interface for classes that can select an appropriate machine image to use.

          IMachineImageConfig

          Configuration for a machine image.

          IMultipartBodyOptions

          Options when creating MultipartBody.

          IMultipartUserDataOptions

          Options for creating {@link MultipartUserData}.

          INamedPackageOptions

          Options for InitPackage.yum/apt/rubyGem/python.

          INatInstanceProps

          (experimental) Properties for a NAT instance.

          INetworkAcl

          (experimental) A NetworkAcl.

          INetworkAclEntry

          (experimental) A NetworkAclEntry.

          INetworkAclEntryProps

          (experimental) Properties to create NetworkAclEntry.

          INetworkAclProps

          (experimental) Properties to create NetworkAcl.

          IPeer

          Interface for classes that provide the peer-specification parts of a security group rule.

          IPortProps

          Properties to create a port range.

          IPrivateSubnet
          IPrivateSubnetAttributes
          IPrivateSubnetProps
          IPublicSubnet
          IPublicSubnetAttributes
          IPublicSubnetProps
          IRouteTable

          An abstract route table.

          IS3DownloadOptions

          Options when downloading files from S3.

          ISecurityGroup

          Interface for security group-like objects.

          ISecurityGroupImportOptions

          Additional options for imported security groups.

          ISecurityGroupProps
          ISelectedSubnets

          Result of selecting a subset of subnets from a VPC.

          ISubnet
          ISubnetAttributes
          ISubnetConfiguration

          Specify configuration parameters for a single subnet group in a VPC.

          ISubnetNetworkAclAssociation

          (experimental) A SubnetNetworkAclAssociation.

          ISubnetNetworkAclAssociationProps

          (experimental) Properties to create a SubnetNetworkAclAssociation.

          ISubnetProps

          Specify configuration parameters for a VPC subnet.

          ISubnetSelection

          Customize subnets that are selected for placement of ENIs.

          IVolume

          An EBS Volume in AWS EC2.

          IVolumeAttributes

          Attributes required to import an existing EBS Volume into the Stack.

          IVolumeProps

          Properties of an EBS Volume.

          IVpc
          IVpcAttributes

          Properties that reference an external Vpc.

          IVpcEndpoint

          A VPC endpoint.

          IVpcEndpointService

          (experimental) A VPC endpoint service.

          IVpcEndpointServiceLoadBalancer

          A load balancer that can host a VPC Endpoint Service.

          IVpcEndpointServiceProps

          (experimental) Construction properties for a VpcEndpointService.

          IVpcLookupOptions

          Properties for looking up an existing VPC.

          IVpcProps

          Configuration for Vpc.

          IVpnConnection
          IVpnConnectionOptions
          IVpnConnectionProps
          IVpnGateway

          The virtual private gateway interface.

          IVpnGatewayProps

          The VpnGateway Properties.

          IVpnTunnelOption
          IWindowsImageProps

          Configuration options for WindowsImage.

          Back to top Generated by DocFX