1366 lines
42 KiB
TypeScript
1366 lines
42 KiB
TypeScript
import type { IConstruct, IDependable } from 'constructs';
|
|
import { Construct } from 'constructs';
|
|
import type { ClientVpnEndpointOptions } from './client-vpn-endpoint';
|
|
import { ClientVpnEndpoint } from './client-vpn-endpoint';
|
|
import type { ISubnetRef, IVPCRef, SubnetReference, VPCReference } from './ec2.generated';
|
|
import { CfnNatGateway } from './ec2.generated';
|
|
import type { IIpAddresses, IIpv6Addresses } from './ip-addresses';
|
|
import { NatProvider } from './nat';
|
|
import type { INetworkAcl } from './network-acl';
|
|
import { SubnetFilter } from './subnet';
|
|
import type { GatewayVpcEndpointOptions, InterfaceVpcEndpointOptions } from './vpc-endpoint';
|
|
import { GatewayVpcEndpoint, InterfaceVpcEndpoint } from './vpc-endpoint';
|
|
import type { FlowLogOptions } from './vpc-flow-logs';
|
|
import { FlowLog } from './vpc-flow-logs';
|
|
import type { VpcLookupOptions } from './vpc-lookup';
|
|
import type { EnableVpnGatewayOptions, VpnConnectionOptions } from './vpn';
|
|
import { VpnConnection } from './vpn';
|
|
import type { IResource } from '../../core';
|
|
import { Resource } from '../../core';
|
|
export interface ISubnet extends IResource, ISubnetRef {
|
|
/**
|
|
* The Availability Zone the subnet is located in
|
|
*/
|
|
readonly availabilityZone: string;
|
|
/**
|
|
* The subnetId for this particular subnet
|
|
* @attribute
|
|
*/
|
|
readonly subnetId: string;
|
|
/**
|
|
* Dependable that can be depended upon to force internet connectivity established on the VPC
|
|
*/
|
|
readonly internetConnectivityEstablished: IDependable;
|
|
/**
|
|
* The IPv4 CIDR block for this subnet
|
|
*/
|
|
readonly ipv4CidrBlock: string;
|
|
/**
|
|
* The route table for this subnet
|
|
*/
|
|
readonly routeTable: IRouteTable;
|
|
/**
|
|
* Associate a Network ACL with this subnet
|
|
*
|
|
* @param acl The Network ACL to associate
|
|
*/
|
|
associateNetworkAcl(id: string, acl: INetworkAcl): void;
|
|
}
|
|
/**
|
|
* An abstract route table
|
|
*/
|
|
export interface IRouteTable {
|
|
/**
|
|
* Route table ID
|
|
*/
|
|
readonly routeTableId: string;
|
|
}
|
|
export interface IVpc extends IResource, IVPCRef {
|
|
/**
|
|
* Identifier for this VPC
|
|
* @attribute
|
|
*/
|
|
readonly vpcId: string;
|
|
/**
|
|
* ARN for this VPC
|
|
* @attribute
|
|
*/
|
|
readonly vpcArn: string;
|
|
/**
|
|
* CIDR range for this VPC
|
|
*
|
|
* @attribute
|
|
*/
|
|
readonly vpcCidrBlock: string;
|
|
/**
|
|
* List of public subnets in this VPC
|
|
*/
|
|
readonly publicSubnets: ISubnet[];
|
|
/**
|
|
* List of private subnets in this VPC
|
|
*/
|
|
readonly privateSubnets: ISubnet[];
|
|
/**
|
|
* List of isolated subnets in this VPC
|
|
*/
|
|
readonly isolatedSubnets: ISubnet[];
|
|
/**
|
|
* AZs for this VPC
|
|
*/
|
|
readonly availabilityZones: string[];
|
|
/**
|
|
* Identifier for the VPN gateway
|
|
*/
|
|
readonly vpnGatewayId?: string;
|
|
/**
|
|
* Dependable that can be depended upon to force internet connectivity established on the VPC
|
|
*/
|
|
readonly internetConnectivityEstablished: IDependable;
|
|
/**
|
|
* Return information on the subnets appropriate for the given selection strategy
|
|
*
|
|
* Requires that at least one subnet is matched, throws a descriptive
|
|
* error message otherwise.
|
|
*/
|
|
selectSubnets(selection?: SubnetSelection): SelectedSubnets;
|
|
/**
|
|
* Adds a VPN Gateway to this VPC
|
|
*/
|
|
enableVpnGateway(options: EnableVpnGatewayOptions): void;
|
|
/**
|
|
* Adds a new VPN connection to this VPC
|
|
*/
|
|
addVpnConnection(id: string, options: VpnConnectionOptions): VpnConnection;
|
|
/**
|
|
* Adds a new client VPN endpoint to this VPC
|
|
*/
|
|
addClientVpnEndpoint(id: string, options: ClientVpnEndpointOptions): ClientVpnEndpoint;
|
|
/**
|
|
* Adds a new gateway endpoint to this VPC
|
|
*/
|
|
addGatewayEndpoint(id: string, options: GatewayVpcEndpointOptions): GatewayVpcEndpoint;
|
|
/**
|
|
* Adds a new interface endpoint to this VPC
|
|
*/
|
|
addInterfaceEndpoint(id: string, options: InterfaceVpcEndpointOptions): InterfaceVpcEndpoint;
|
|
/**
|
|
* Adds a new Flow Log to this VPC
|
|
*/
|
|
addFlowLog(id: string, options?: FlowLogOptions): FlowLog;
|
|
}
|
|
/**
|
|
* The types of IP addresses provisioned in the VPC.
|
|
*/
|
|
export declare enum IpProtocol {
|
|
/**
|
|
* The vpc will be configured with only IPv4 addresses.
|
|
*
|
|
* This is the default protocol if unset.
|
|
*/
|
|
IPV4_ONLY = "Ipv4_Only",
|
|
/**
|
|
* The vpc will have both IPv4 and IPv6 addresses.
|
|
*
|
|
* Unless specified, public IPv4 addresses will not be auto assigned,
|
|
* an egress only internet gateway (EIGW) will be created and configured,
|
|
* and NATs and internet gateways (IGW) will be configured with IPv6 addresses.
|
|
*/
|
|
DUAL_STACK = "Dual_Stack"
|
|
}
|
|
/**
|
|
* The type of Subnet
|
|
*/
|
|
export declare enum SubnetType {
|
|
/**
|
|
* Isolated Subnets do not route traffic to the Internet (in this VPC),
|
|
* and as such, do not require NAT gateways.
|
|
*
|
|
* Isolated subnets can only connect to or be connected to from other
|
|
* instances in the same VPC. A default VPC configuration will not include
|
|
* isolated subnets.
|
|
*
|
|
* This can be good for subnets with RDS or Elasticache instances,
|
|
* or which route Internet traffic through a peer VPC.
|
|
*/
|
|
PRIVATE_ISOLATED = "Isolated",
|
|
/**
|
|
* Subnet that routes to the internet, but not vice versa.
|
|
*
|
|
* Instances in a private subnet can connect to the Internet, but will not
|
|
* allow connections to be initiated from the Internet. Egress to the internet will
|
|
* need to be provided.
|
|
* NAT Gateway(s) are the default solution to providing this subnet type the ability to route Internet traffic.
|
|
* If a NAT Gateway is not required or desired, set `natGateways:0` or use
|
|
* `SubnetType.PRIVATE_ISOLATED` instead.
|
|
*
|
|
* By default, a NAT gateway is created in every public subnet for maximum availability.
|
|
* Be aware that you will be charged for NAT gateways.
|
|
*
|
|
* Normally a Private subnet will use a NAT gateway in the same AZ, but
|
|
* if `natGateways` is used to reduce the number of NAT gateways, a NAT
|
|
* gateway from another AZ will be used instead.
|
|
*/
|
|
PRIVATE_WITH_EGRESS = "Private",
|
|
/**
|
|
* Subnet that routes to the internet (via a NAT gateway), but not vice versa.
|
|
*
|
|
* Instances in a private subnet can connect to the Internet, but will not
|
|
* allow connections to be initiated from the Internet. NAT Gateway(s) are
|
|
* required with this subnet type to route the Internet traffic through.
|
|
* If a NAT Gateway is not required or desired, use `SubnetType.PRIVATE_ISOLATED` instead.
|
|
*
|
|
* By default, a NAT gateway is created in every public subnet for maximum availability.
|
|
* Be aware that you will be charged for NAT gateways.
|
|
*
|
|
* Normally a Private subnet will use a NAT gateway in the same AZ, but
|
|
* if `natGateways` is used to reduce the number of NAT gateways, a NAT
|
|
* gateway from another AZ will be used instead.
|
|
* @deprecated use `PRIVATE_WITH_EGRESS`
|
|
*/
|
|
PRIVATE_WITH_NAT = "Deprecated_Private_NAT",
|
|
/**
|
|
* Subnet connected to the Internet
|
|
*
|
|
* Instances in a Public subnet can connect to the Internet and can be
|
|
* connected to from the Internet as long as they are launched with public
|
|
* IPs (controlled on the AutoScalingGroup or other constructs that launch
|
|
* instances).
|
|
*
|
|
* Public subnets route outbound traffic via an Internet Gateway.
|
|
*/
|
|
PUBLIC = "Public"
|
|
}
|
|
/**
|
|
* Customize subnets that are selected for placement of ENIs
|
|
*
|
|
* Constructs that allow customization of VPC placement use parameters of this
|
|
* type to provide placement settings.
|
|
*
|
|
* By default, the instances are placed in the private subnets.
|
|
*/
|
|
export interface SubnetSelection {
|
|
/**
|
|
* Select all subnets of the given type
|
|
*
|
|
* At most one of `subnetType` and `subnetGroupName` can be supplied.
|
|
*
|
|
* @default SubnetType.PRIVATE_WITH_EGRESS (or ISOLATED or PUBLIC if there are no PRIVATE_WITH_EGRESS subnets)
|
|
*/
|
|
readonly subnetType?: SubnetType;
|
|
/**
|
|
* Select subnets only in the given AZs.
|
|
*
|
|
* @default no filtering on AZs is done
|
|
*/
|
|
readonly availabilityZones?: string[];
|
|
/**
|
|
* Select the subnet group with the given name
|
|
*
|
|
* Select the subnet group with the given name. This only needs
|
|
* to be used if you have multiple subnet groups of the same type
|
|
* and you need to distinguish between them. Otherwise, prefer
|
|
* `subnetType`.
|
|
*
|
|
* This field does not select individual subnets, it selects all subnets that
|
|
* share the given subnet group name. This is the name supplied in
|
|
* `subnetConfiguration`.
|
|
*
|
|
* At most one of `subnetType` and `subnetGroupName` can be supplied.
|
|
*
|
|
* @default - Selection by type instead of by name
|
|
*/
|
|
readonly subnetGroupName?: string;
|
|
/**
|
|
* If true, return at most one subnet per AZ
|
|
*
|
|
* @default false
|
|
*/
|
|
readonly onePerAz?: boolean;
|
|
/**
|
|
* List of provided subnet filters.
|
|
*
|
|
* @default - none
|
|
*/
|
|
readonly subnetFilters?: SubnetFilter[];
|
|
/**
|
|
* Explicitly select individual subnets
|
|
*
|
|
* Use this if you don't want to automatically use all subnets in
|
|
* a group, but have a need to control selection down to
|
|
* individual subnets.
|
|
*
|
|
* Cannot be specified together with `subnetType` or `subnetGroupName`.
|
|
*
|
|
* @default - Use all subnets in a selected group (all private subnets by default)
|
|
*/
|
|
readonly subnets?: ISubnet[];
|
|
}
|
|
/**
|
|
* Result of selecting a subset of subnets from a VPC
|
|
*/
|
|
export interface SelectedSubnets {
|
|
/**
|
|
* The subnet IDs
|
|
*/
|
|
readonly subnetIds: string[];
|
|
/**
|
|
* The respective AZs of each subnet
|
|
*/
|
|
readonly availabilityZones: string[];
|
|
/**
|
|
* Dependency representing internet connectivity for these subnets
|
|
*/
|
|
readonly internetConnectivityEstablished: IDependable;
|
|
/**
|
|
* Selected subnet objects
|
|
*/
|
|
readonly subnets: ISubnet[];
|
|
/**
|
|
* Whether any of the given subnets are from the VPC's public subnets.
|
|
*/
|
|
readonly hasPublic: boolean;
|
|
/**
|
|
* The subnet selection is not actually real yet
|
|
*
|
|
* If this value is true, don't validate anything about the subnets. The count
|
|
* or identities are not known yet, and the validation will most likely fail
|
|
* which will prevent a successful lookup.
|
|
*
|
|
* @default false
|
|
*/
|
|
readonly isPendingLookup?: boolean;
|
|
}
|
|
/**
|
|
* A new or imported VPC
|
|
*/
|
|
declare abstract class VpcBase extends Resource implements IVpc {
|
|
/**
|
|
* Identifier for this VPC
|
|
*/
|
|
abstract readonly vpcId: string;
|
|
/**
|
|
* Arn of this VPC
|
|
*/
|
|
abstract readonly vpcArn: string;
|
|
/**
|
|
* CIDR range for this VPC
|
|
*/
|
|
abstract readonly vpcCidrBlock: string;
|
|
/**
|
|
* List of public subnets in this VPC
|
|
*/
|
|
abstract readonly publicSubnets: ISubnet[];
|
|
/**
|
|
* List of private subnets in this VPC
|
|
*/
|
|
abstract readonly privateSubnets: ISubnet[];
|
|
/**
|
|
* List of isolated subnets in this VPC
|
|
*/
|
|
abstract readonly isolatedSubnets: ISubnet[];
|
|
/**
|
|
* AZs for this VPC
|
|
*/
|
|
abstract readonly availabilityZones: string[];
|
|
/**
|
|
* Dependencies for internet connectivity
|
|
*/
|
|
abstract readonly internetConnectivityEstablished: IDependable;
|
|
/**
|
|
* If this is set to true, don't error out on trying to select subnets
|
|
*/
|
|
protected incompleteSubnetDefinition: boolean;
|
|
/**
|
|
* Mutable private field for the vpnGatewayId
|
|
*
|
|
* @internal
|
|
*/
|
|
protected _vpnGatewayId?: string;
|
|
get vpcRef(): VPCReference;
|
|
/**
|
|
* Returns IDs of selected subnets
|
|
*/
|
|
selectSubnets(selection?: SubnetSelection): SelectedSubnets;
|
|
/**
|
|
* Adds a VPN Gateway to this VPC
|
|
*/
|
|
enableVpnGateway(options: EnableVpnGatewayOptions): void;
|
|
/**
|
|
* Adds a new VPN connection to this VPC
|
|
*/
|
|
addVpnConnection(id: string, options: VpnConnectionOptions): VpnConnection;
|
|
/**
|
|
* Adds a new client VPN endpoint to this VPC
|
|
*/
|
|
addClientVpnEndpoint(id: string, options: ClientVpnEndpointOptions): ClientVpnEndpoint;
|
|
/**
|
|
* Adds a new interface endpoint to this VPC
|
|
*/
|
|
addInterfaceEndpoint(id: string, options: InterfaceVpcEndpointOptions): InterfaceVpcEndpoint;
|
|
/**
|
|
* Adds a new gateway endpoint to this VPC
|
|
*/
|
|
addGatewayEndpoint(id: string, options: GatewayVpcEndpointOptions): GatewayVpcEndpoint;
|
|
/**
|
|
* Adds a new flow log to this VPC
|
|
*/
|
|
addFlowLog(id: string, options?: FlowLogOptions): FlowLog;
|
|
/**
|
|
* Returns the id of the VPN Gateway (if enabled)
|
|
*/
|
|
get vpnGatewayId(): string | undefined;
|
|
/**
|
|
* Return the subnets appropriate for the placement strategy
|
|
*/
|
|
protected selectSubnetObjects(selection?: SubnetSelection): ISubnet[];
|
|
private applySubnetFilters;
|
|
private selectSubnetObjectsByName;
|
|
private selectSubnetObjectsByType;
|
|
/**
|
|
* Validate the fields in a SubnetSelection object, and reify defaults if necessary
|
|
*
|
|
* In case of default selection, select the first type of PRIVATE, ISOLATED,
|
|
* PUBLIC (in that order) that has any subnets.
|
|
*/
|
|
private reifySelectionDefaults;
|
|
}
|
|
/**
|
|
* Properties that reference an external Vpc
|
|
*/
|
|
export interface VpcAttributes {
|
|
/**
|
|
* VPC's identifier
|
|
*/
|
|
readonly vpcId: string;
|
|
/**
|
|
* VPC's CIDR range
|
|
*
|
|
* @default - Retrieving the CIDR from the VPC will fail
|
|
*/
|
|
readonly vpcCidrBlock?: string;
|
|
/**
|
|
* List of availability zones for the subnets in this VPC.
|
|
*/
|
|
readonly availabilityZones: string[];
|
|
/**
|
|
* List of public subnet IDs
|
|
*
|
|
* Must be undefined or match the availability zones in length and order.
|
|
*
|
|
* @default - The VPC does not have any public subnets
|
|
*/
|
|
readonly publicSubnetIds?: string[];
|
|
/**
|
|
* List of names for the public subnets
|
|
*
|
|
* Must be undefined or have a name for every public subnet group.
|
|
*
|
|
* @default - All public subnets will have the name `Public`
|
|
*/
|
|
readonly publicSubnetNames?: string[];
|
|
/**
|
|
* List of IDs of route tables for the public subnets.
|
|
*
|
|
* Must be undefined or have a name for every public subnet group.
|
|
*
|
|
* @default - Retrieving the route table ID of any public subnet will fail
|
|
*/
|
|
readonly publicSubnetRouteTableIds?: string[];
|
|
/**
|
|
* List of IPv4 CIDR blocks for the public subnets.
|
|
*
|
|
* Must be undefined or have an entry for every public subnet group.
|
|
*
|
|
* @default - Retrieving the IPv4 CIDR block of any public subnet will fail
|
|
*/
|
|
readonly publicSubnetIpv4CidrBlocks?: string[];
|
|
/**
|
|
* List of private subnet IDs
|
|
*
|
|
* Must be undefined or match the availability zones in length and order.
|
|
*
|
|
* @default - The VPC does not have any private subnets
|
|
*/
|
|
readonly privateSubnetIds?: string[];
|
|
/**
|
|
* List of names for the private subnets
|
|
*
|
|
* Must be undefined or have a name for every private subnet group.
|
|
*
|
|
* @default - All private subnets will have the name `Private`
|
|
*/
|
|
readonly privateSubnetNames?: string[];
|
|
/**
|
|
* List of IDs of route tables for the private subnets.
|
|
*
|
|
* Must be undefined or have a name for every private subnet group.
|
|
*
|
|
* @default - Retrieving the route table ID of any private subnet will fail
|
|
*/
|
|
readonly privateSubnetRouteTableIds?: string[];
|
|
/**
|
|
* List of IPv4 CIDR blocks for the private subnets.
|
|
*
|
|
* Must be undefined or have an entry for every private subnet group.
|
|
*
|
|
* @default - Retrieving the IPv4 CIDR block of any private subnet will fail
|
|
*/
|
|
readonly privateSubnetIpv4CidrBlocks?: string[];
|
|
/**
|
|
* List of isolated subnet IDs
|
|
*
|
|
* Must be undefined or match the availability zones in length and order.
|
|
*
|
|
* @default - The VPC does not have any isolated subnets
|
|
*/
|
|
readonly isolatedSubnetIds?: string[];
|
|
/**
|
|
* List of names for the isolated subnets
|
|
*
|
|
* Must be undefined or have a name for every isolated subnet group.
|
|
*
|
|
* @default - All isolated subnets will have the name `Isolated`
|
|
*/
|
|
readonly isolatedSubnetNames?: string[];
|
|
/**
|
|
* List of IDs of route tables for the isolated subnets.
|
|
*
|
|
* Must be undefined or have a name for every isolated subnet group.
|
|
*
|
|
* @default - Retrieving the route table ID of any isolated subnet will fail
|
|
*/
|
|
readonly isolatedSubnetRouteTableIds?: string[];
|
|
/**
|
|
* List of IPv4 CIDR blocks for the isolated subnets.
|
|
*
|
|
* Must be undefined or have an entry for every isolated subnet group.
|
|
*
|
|
* @default - Retrieving the IPv4 CIDR block of any isolated subnet will fail
|
|
*/
|
|
readonly isolatedSubnetIpv4CidrBlocks?: string[];
|
|
/**
|
|
* VPN gateway's identifier
|
|
*/
|
|
readonly vpnGatewayId?: string;
|
|
/**
|
|
* The region the VPC is in
|
|
*
|
|
* @default - The region of the stack where the VPC belongs to
|
|
*/
|
|
readonly region?: string;
|
|
}
|
|
export interface SubnetAttributes {
|
|
/**
|
|
* The Availability Zone the subnet is located in
|
|
*
|
|
* @default - No AZ information, cannot use AZ selection features
|
|
*/
|
|
readonly availabilityZone?: string;
|
|
/**
|
|
* The IPv4 CIDR block associated with the subnet
|
|
*
|
|
* @default - No CIDR information, cannot use CIDR filter features
|
|
*/
|
|
readonly ipv4CidrBlock?: string;
|
|
/**
|
|
* The ID of the route table for this particular subnet
|
|
*
|
|
* @default - No route table information, cannot create VPC endpoints
|
|
*/
|
|
readonly routeTableId?: string;
|
|
/**
|
|
* The subnetId for this particular subnet
|
|
*/
|
|
readonly subnetId: string;
|
|
}
|
|
/**
|
|
* Configuration for Vpc
|
|
*/
|
|
export interface VpcProps {
|
|
/**
|
|
* The protocol of the vpc.
|
|
*
|
|
* Options are IPv4 only or dual stack.
|
|
*
|
|
* @default IpProtocol.IPV4_ONLY
|
|
*/
|
|
readonly ipProtocol?: IpProtocol;
|
|
/**
|
|
* The Provider to use to allocate IPv4 Space to your VPC.
|
|
*
|
|
* Options include static allocation or from a pool.
|
|
*
|
|
* Note this is specific to IPv4 addresses.
|
|
*
|
|
* @default ec2.IpAddresses.cidr
|
|
*/
|
|
readonly ipAddresses?: IIpAddresses;
|
|
/**
|
|
* The CIDR range to use for the VPC, e.g. '10.0.0.0/16'.
|
|
*
|
|
* Should be a minimum of /28 and maximum size of /16. The range will be
|
|
* split across all subnets per Availability Zone.
|
|
*
|
|
* @default Vpc.DEFAULT_CIDR_RANGE
|
|
*
|
|
* @deprecated Use ipAddresses instead
|
|
*/
|
|
readonly cidr?: string;
|
|
/**
|
|
* Indicates whether the instances launched in the VPC get public DNS hostnames.
|
|
*
|
|
* If this attribute is true, instances in the VPC get public DNS hostnames,
|
|
* but only if the enableDnsSupport attribute is also set to true.
|
|
*
|
|
* @default true
|
|
*/
|
|
readonly enableDnsHostnames?: boolean;
|
|
/**
|
|
* Indicates whether the DNS resolution is supported for the VPC.
|
|
*
|
|
* If this attribute is false, the Amazon-provided DNS server in the VPC that
|
|
* resolves public DNS hostnames to IP addresses is not enabled. If this
|
|
* attribute is true, queries to the Amazon provided DNS server at the
|
|
* 169.254.169.253 IP address, or the reserved IP address at the base of the
|
|
* VPC IPv4 network range plus two will succeed.
|
|
*
|
|
* @default true
|
|
*/
|
|
readonly enableDnsSupport?: boolean;
|
|
/**
|
|
* The default tenancy of instances launched into the VPC.
|
|
*
|
|
* By setting this to dedicated tenancy, instances will be launched on
|
|
* hardware dedicated to a single AWS customer, unless specifically specified
|
|
* at instance launch time. Please note, not all instance types are usable
|
|
* with Dedicated tenancy.
|
|
*
|
|
* @default DefaultInstanceTenancy.Default (shared) tenancy
|
|
*/
|
|
readonly defaultInstanceTenancy?: DefaultInstanceTenancy;
|
|
/**
|
|
* Define the maximum number of AZs to use in this region
|
|
*
|
|
* If the region has more AZs than you want to use (for example, because of
|
|
* EIP limits), pick a lower number here. The AZs will be sorted and picked
|
|
* from the start of the list.
|
|
*
|
|
* If you pick a higher number than the number of AZs in the region, all AZs
|
|
* in the region will be selected. To use "all AZs" available to your
|
|
* account, use a high number (such as 99).
|
|
*
|
|
* Be aware that environment-agnostic stacks will be created with access to
|
|
* only 2 AZs, so to use more than 2 AZs, be sure to specify the account and
|
|
* region on your stack.
|
|
*
|
|
* Specify this option only if you do not specify `availabilityZones`.
|
|
*
|
|
* @default 3
|
|
*/
|
|
readonly maxAzs?: number;
|
|
/**
|
|
* Define the number of AZs to reserve.
|
|
*
|
|
* When specified, the IP space is reserved for the azs but no actual
|
|
* resources are provisioned.
|
|
*
|
|
* @default 0
|
|
*/
|
|
readonly reservedAzs?: number;
|
|
/**
|
|
* Availability zones this VPC spans.
|
|
*
|
|
* Specify this option only if you do not specify `maxAzs`.
|
|
*
|
|
* @default - a subset of AZs of the stack
|
|
*/
|
|
readonly availabilityZones?: string[];
|
|
/**
|
|
* The number of NAT Gateways/Instances to create.
|
|
*
|
|
* The type of NAT gateway or instance will be determined by the
|
|
* `natGatewayProvider` parameter.
|
|
*
|
|
* You can set this number lower than the number of Availability Zones in your
|
|
* VPC in order to save on NAT cost. Be aware you may be charged for
|
|
* cross-AZ data traffic instead.
|
|
*
|
|
* @default - One NAT gateway/instance per Availability Zone
|
|
*/
|
|
readonly natGateways?: number;
|
|
/**
|
|
* Configures the subnets which will have NAT Gateways/Instances
|
|
*
|
|
* You can pick a specific group of subnets by specifying the group name;
|
|
* the picked subnets must be public subnets.
|
|
*
|
|
* Only necessary if you have more than one public subnet group.
|
|
*
|
|
* @default - All public subnets.
|
|
*/
|
|
readonly natGatewaySubnets?: SubnetSelection;
|
|
/**
|
|
* What type of NAT provider to use
|
|
*
|
|
* Select between NAT gateways or NAT instances. NAT gateways
|
|
* may not be available in all AWS regions.
|
|
*
|
|
* @default NatProvider.gateway()
|
|
*
|
|
*/
|
|
readonly natGatewayProvider?: NatProvider;
|
|
/**
|
|
* Configure the subnets to build for each AZ
|
|
*
|
|
* Each entry in this list configures a Subnet Group; each group will contain a
|
|
* subnet for each Availability Zone.
|
|
*
|
|
* For example, if you want 1 public subnet, 1 private subnet, and 1 isolated
|
|
* subnet in each AZ provide the following:
|
|
*
|
|
* ```ts
|
|
* new ec2.Vpc(this, 'VPC', {
|
|
* subnetConfiguration: [
|
|
* {
|
|
* cidrMask: 24,
|
|
* name: 'ingress',
|
|
* subnetType: ec2.SubnetType.PUBLIC,
|
|
* },
|
|
* {
|
|
* cidrMask: 24,
|
|
* name: 'application',
|
|
* subnetType: ec2.SubnetType.PRIVATE_WITH_EGRESS,
|
|
* },
|
|
* {
|
|
* cidrMask: 28,
|
|
* name: 'rds',
|
|
* subnetType: ec2.SubnetType.PRIVATE_ISOLATED,
|
|
* }
|
|
* ]
|
|
* });
|
|
* ```
|
|
*
|
|
* @default - The VPC CIDR will be evenly divided between 1 public and 1
|
|
* private subnet per AZ.
|
|
*/
|
|
readonly subnetConfiguration?: SubnetConfiguration[];
|
|
/**
|
|
* Indicates whether a VPN gateway should be created and attached to this VPC.
|
|
*
|
|
* @default - true when vpnGatewayAsn or vpnConnections is specified
|
|
*/
|
|
readonly vpnGateway?: boolean;
|
|
/**
|
|
* The private Autonomous System Number (ASN) for the VPN gateway.
|
|
*
|
|
* @default - Amazon default ASN.
|
|
*/
|
|
readonly vpnGatewayAsn?: number;
|
|
/**
|
|
* VPN connections to this VPC.
|
|
*
|
|
* @default - No connections.
|
|
*/
|
|
readonly vpnConnections?: {
|
|
[id: string]: VpnConnectionOptions;
|
|
};
|
|
/**
|
|
* Where to propagate VPN routes.
|
|
*
|
|
* @default - On the route tables associated with private subnets. If no
|
|
* private subnets exists, isolated subnets are used. If no isolated subnets
|
|
* exists, public subnets are used.
|
|
*/
|
|
readonly vpnRoutePropagation?: SubnetSelection[];
|
|
/**
|
|
* Gateway endpoints to add to this VPC.
|
|
*
|
|
* @default - None.
|
|
*/
|
|
readonly gatewayEndpoints?: {
|
|
[id: string]: GatewayVpcEndpointOptions;
|
|
};
|
|
/**
|
|
* Flow logs to add to this VPC.
|
|
*
|
|
* @default - No flow logs.
|
|
*/
|
|
readonly flowLogs?: {
|
|
[id: string]: FlowLogOptions;
|
|
};
|
|
/**
|
|
* The VPC name.
|
|
*
|
|
* Since the VPC resource doesn't support providing a physical name, the value provided here will be recorded in the `Name` tag
|
|
*
|
|
* @default this.node.path
|
|
*/
|
|
readonly vpcName?: string;
|
|
/**
|
|
* If set to true then the default inbound & outbound rules will be removed
|
|
* from the default security group
|
|
*
|
|
* @default true if '@aws-cdk/aws-ec2:restrictDefaultSecurityGroup' is enabled, false otherwise
|
|
*/
|
|
readonly restrictDefaultSecurityGroup?: boolean;
|
|
/**
|
|
* If set to false then disable the creation of the default internet gateway
|
|
*
|
|
* @default true
|
|
*/
|
|
readonly createInternetGateway?: boolean;
|
|
/**
|
|
* The Provider to use to allocate IPv6 Space to your VPC.
|
|
*
|
|
* Options include amazon provided CIDR block.
|
|
*
|
|
* Note this is specific to IPv6 addresses.
|
|
*
|
|
* @default Ipv6Addresses.amazonProvided
|
|
*/
|
|
readonly ipv6Addresses?: IIpv6Addresses;
|
|
}
|
|
/**
|
|
* The default tenancy of instances launched into the VPC.
|
|
*/
|
|
export declare enum DefaultInstanceTenancy {
|
|
/**
|
|
* Instances can be launched with any tenancy.
|
|
*/
|
|
DEFAULT = "default",
|
|
/**
|
|
* Any instance launched into the VPC automatically has dedicated tenancy, unless you launch it with the default tenancy.
|
|
*/
|
|
DEDICATED = "dedicated",
|
|
/**
|
|
* Instances must be launched on dedicated hosts. This provides additional visibility
|
|
* and control over instance placement at the physical host level.
|
|
*/
|
|
HOST = "host"
|
|
}
|
|
/**
|
|
* Specify configuration parameters for a single subnet group in a VPC.
|
|
*/
|
|
export interface SubnetConfiguration {
|
|
/**
|
|
* The number of leading 1 bits in the routing mask.
|
|
*
|
|
* The number of available IP addresses in each subnet of this group
|
|
* will be equal to `2^(32 - cidrMask) - 2`.
|
|
*
|
|
* Valid values are `16--28`.
|
|
*
|
|
* Note this is specific to IPv4 addresses.
|
|
*
|
|
* @default - Available IP space is evenly divided across subnets.
|
|
*/
|
|
readonly cidrMask?: number;
|
|
/**
|
|
* The type of Subnet to configure.
|
|
*
|
|
* The Subnet type will control the ability to route and connect to the
|
|
* Internet.
|
|
*/
|
|
readonly subnetType: SubnetType;
|
|
/**
|
|
* Logical name for the subnet group.
|
|
*
|
|
* This name can be used when selecting VPC subnets to distinguish
|
|
* between different subnet groups of the same type.
|
|
*/
|
|
readonly name: string;
|
|
/**
|
|
* Controls if subnet IP space needs to be reserved.
|
|
*
|
|
* When true, the IP space for the subnet is reserved but no actual
|
|
* resources are provisioned. This space is only dependent on the
|
|
* number of availability zones and on `cidrMask` - all other subnet
|
|
* properties are ignored.
|
|
*
|
|
* @default false
|
|
*/
|
|
readonly reserved?: boolean;
|
|
/**
|
|
* Controls if a public IPv4 address is associated to an instance at launch
|
|
*
|
|
* Note this is specific to IPv4 addresses.
|
|
*
|
|
* @default true in Subnet.Public of IPV4_ONLY VPCs, false otherwise
|
|
*/
|
|
readonly mapPublicIpOnLaunch?: boolean;
|
|
/**
|
|
* This property is specific to dual stack VPCs.
|
|
*
|
|
* If set to false, then an IPv6 address will not be automatically assigned.
|
|
*
|
|
* Note this is specific to IPv6 addresses.
|
|
*
|
|
* @default true
|
|
*/
|
|
readonly ipv6AssignAddressOnCreation?: boolean;
|
|
}
|
|
/**
|
|
* Define an AWS Virtual Private Cloud
|
|
*
|
|
* See the package-level documentation of this package for an overview
|
|
* of the various dimensions in which you can configure your VPC.
|
|
*
|
|
* For example:
|
|
*
|
|
* ```ts
|
|
* const vpc = new ec2.Vpc(this, 'TheVPC', {
|
|
* ipAddresses: ec2.IpAddresses.cidr('10.0.0.0/16'),
|
|
* })
|
|
*
|
|
* // Iterate the private subnets
|
|
* const selection = vpc.selectSubnets({
|
|
* subnetType: ec2.SubnetType.PRIVATE_WITH_EGRESS
|
|
* });
|
|
*
|
|
* for (const subnet of selection.subnets) {
|
|
* // ...
|
|
* }
|
|
* ```
|
|
*
|
|
* @resource AWS::EC2::VPC
|
|
*/
|
|
export declare class Vpc extends VpcBase {
|
|
/**
|
|
* Uniquely identifies this class.
|
|
*/
|
|
static readonly PROPERTY_INJECTION_ID: string;
|
|
/**
|
|
* The default CIDR range used when creating VPCs.
|
|
* This can be overridden using VpcProps when creating a VPCNetwork resource.
|
|
* e.g. new VpcResource(this, { cidr: '192.168.0.0./16' })
|
|
*
|
|
* Note this is specific to the IPv4 CIDR.
|
|
*/
|
|
static readonly DEFAULT_CIDR_RANGE: string;
|
|
/**
|
|
* The default subnet configuration
|
|
*
|
|
* 1 Public and 1 Private subnet per AZ evenly split
|
|
*/
|
|
static readonly DEFAULT_SUBNETS: SubnetConfiguration[];
|
|
/**
|
|
* The default subnet configuration if natGateways specified to be 0
|
|
*
|
|
* 1 Public and 1 Isolated Subnet per AZ evenly split
|
|
*/
|
|
static readonly DEFAULT_SUBNETS_NO_NAT: SubnetConfiguration[];
|
|
/**
|
|
* Import a VPC by supplying all attributes directly
|
|
*
|
|
* NOTE: using `fromVpcAttributes()` with deploy-time parameters (like a `Fn.importValue()` or
|
|
* `CfnParameter` to represent a list of subnet IDs) sometimes accidentally works. It happens
|
|
* to work for constructs that need a list of subnets (like `AutoScalingGroup` and `eks.Cluster`)
|
|
* but it does not work for constructs that need individual subnets (like
|
|
* `Instance`). See https://github.com/aws/aws-cdk/issues/4118 for more
|
|
* information.
|
|
*
|
|
* Prefer to use `Vpc.fromLookup()` instead.
|
|
*/
|
|
static fromVpcAttributes(scope: Construct, id: string, attrs: VpcAttributes): IVpc;
|
|
/**
|
|
* Import an existing VPC by querying the AWS environment this stack is deployed to.
|
|
*
|
|
* This function only needs to be used to use VPCs not defined in your CDK
|
|
* application. If you are looking to share a VPC between stacks, you can
|
|
* pass the `Vpc` object between stacks and use it as normal.
|
|
*
|
|
* Calling this method will lead to a lookup when the CDK CLI is executed.
|
|
* You can therefore not use any values that will only be available at
|
|
* CloudFormation execution time (i.e., Tokens).
|
|
*
|
|
* The VPC information will be cached in `cdk.context.json` and the same VPC
|
|
* will be used on future runs. To refresh the lookup, you will have to
|
|
* evict the value from the cache using the `cdk context` command. See
|
|
* https://docs.aws.amazon.com/cdk/latest/guide/context.html for more information.
|
|
*/
|
|
static fromLookup(scope: Construct, id: string, options: VpcLookupOptions): IVpc;
|
|
/**
|
|
* Identifier for this VPC
|
|
*/
|
|
readonly vpcId: string;
|
|
/**
|
|
* @attribute
|
|
*/
|
|
readonly vpcArn: string;
|
|
/**
|
|
* @attribute
|
|
*/
|
|
readonly vpcCidrBlock: string;
|
|
/**
|
|
* @attribute
|
|
*/
|
|
readonly vpcDefaultNetworkAcl: string;
|
|
/**
|
|
* @attribute
|
|
*/
|
|
readonly vpcCidrBlockAssociations: string[];
|
|
/**
|
|
* @attribute
|
|
*/
|
|
readonly vpcDefaultSecurityGroup: string;
|
|
/**
|
|
* @attribute
|
|
*/
|
|
readonly vpcIpv6CidrBlocks: string[];
|
|
/**
|
|
* List of public subnets in this VPC
|
|
*/
|
|
readonly publicSubnets: ISubnet[];
|
|
/**
|
|
* List of private subnets in this VPC
|
|
*/
|
|
readonly privateSubnets: ISubnet[];
|
|
/**
|
|
* List of isolated subnets in this VPC
|
|
*/
|
|
readonly isolatedSubnets: ISubnet[];
|
|
/**
|
|
* AZs for this VPC
|
|
*/
|
|
readonly availabilityZones: string[];
|
|
/**
|
|
* Internet Gateway for the VPC. Note that in case the VPC is configured only
|
|
* with ISOLATED subnets, this attribute will be `undefined`.
|
|
*/
|
|
readonly internetGatewayId?: string;
|
|
readonly internetConnectivityEstablished: IDependable;
|
|
/**
|
|
* Indicates if instances launched in this VPC will have public DNS hostnames.
|
|
*/
|
|
readonly dnsHostnamesEnabled: boolean;
|
|
/**
|
|
* Indicates if DNS support is enabled for this VPC.
|
|
*/
|
|
readonly dnsSupportEnabled: boolean;
|
|
/**
|
|
* The VPC resource
|
|
*/
|
|
private readonly resource;
|
|
/**
|
|
* Indicates if IPv4 addresses will be used in the VPC.
|
|
*
|
|
* True for IPV4_ONLY and DUAL_STACK VPCs.
|
|
*/
|
|
private readonly useIpv4;
|
|
/**
|
|
* Indicates if IPv6 addresses will be used in the VPC.
|
|
*
|
|
* True for DUAL_STACK VPCs. False for IPV4_ONLY VPCs.
|
|
*/
|
|
private readonly useIpv6;
|
|
/**
|
|
* The provider of ipv4 addresses
|
|
*/
|
|
private readonly ipAddresses;
|
|
/**
|
|
* The provider of IPv6 addresses.
|
|
*/
|
|
private readonly ipv6Addresses?;
|
|
/**
|
|
* The IPv6 CIDR block CFN resource.
|
|
*
|
|
* Needed to create a dependency for the subnets.
|
|
*/
|
|
private readonly ipv6CidrBlock?;
|
|
/**
|
|
* The IPv6 CIDR block string representation.
|
|
*/
|
|
private readonly ipv6SelectedCidr?;
|
|
/**
|
|
* Subnet configurations for this VPC
|
|
*/
|
|
private subnetConfiguration;
|
|
private readonly _internetConnectivityEstablished;
|
|
/**
|
|
* Vpc creates a VPC that spans a whole region.
|
|
* It will automatically divide the provided VPC CIDR range, and create public and private subnets per Availability Zone.
|
|
* Network routing for the public subnets will be configured to allow outbound access directly via an Internet Gateway.
|
|
* Network routing for the private subnets will be configured to allow outbound access via a set of resilient NAT Gateways (one per AZ).
|
|
*/
|
|
constructor(scope: Construct, id: string, props?: VpcProps);
|
|
private createNatGateways;
|
|
/**
|
|
* createSubnets creates the subnets specified by the subnet configuration
|
|
* array or creates the `DEFAULT_SUBNETS` configuration
|
|
*/
|
|
private createSubnets;
|
|
/**
|
|
* Defaults to true in Subnet.Public for IPV4_ONLY VPCs.
|
|
*
|
|
* Defaults to false in Subnet.Public for DUAL_STACK VPCs.
|
|
*
|
|
* Always defaults to false in non-public subnets and will error if set.
|
|
*/
|
|
private calculateMapPublicIpOnLaunch;
|
|
private createSubnetResources;
|
|
private restrictDefaultSecurityGroup;
|
|
/**
|
|
* Returns the list of resolved availability zones found in the provided stack availability
|
|
* zones.
|
|
*
|
|
* Note: A resolved availability zone refers to an availability zone that is not a token
|
|
* and is also not a dummy value.
|
|
*/
|
|
private resolveStackAvailabilityZones;
|
|
}
|
|
/**
|
|
* Specify configuration parameters for a VPC subnet
|
|
*/
|
|
export interface SubnetProps {
|
|
/**
|
|
* The availability zone for the subnet
|
|
*/
|
|
readonly availabilityZone: string;
|
|
/**
|
|
* The VPC which this subnet is part of
|
|
*/
|
|
readonly vpcId: string;
|
|
/**
|
|
* The CIDR notation for this subnet
|
|
*/
|
|
readonly cidrBlock: string;
|
|
/**
|
|
* Controls if a public IP is associated to an instance at launch
|
|
*
|
|
* @default true in Subnet.Public, false in Subnet.Private or Subnet.Isolated.
|
|
*/
|
|
readonly mapPublicIpOnLaunch?: boolean;
|
|
/**
|
|
* The IPv6 CIDR block.
|
|
*
|
|
* If you specify AssignIpv6AddressOnCreation, you must also specify Ipv6CidrBlock.
|
|
*
|
|
* @default - no IPv6 CIDR block.
|
|
*/
|
|
readonly ipv6CidrBlock?: string;
|
|
/**
|
|
* Indicates whether a network interface created in this subnet receives an IPv6 address.
|
|
*
|
|
* If you specify AssignIpv6AddressOnCreation, you must also specify Ipv6CidrBlock.
|
|
*
|
|
* @default false
|
|
*/
|
|
readonly assignIpv6AddressOnCreation?: boolean;
|
|
}
|
|
/**
|
|
* Represents a new VPC subnet resource
|
|
*
|
|
* @resource AWS::EC2::Subnet
|
|
*/
|
|
export declare class Subnet extends Resource implements ISubnet {
|
|
/**
|
|
* Uniquely identifies this class.
|
|
*/
|
|
static readonly PROPERTY_INJECTION_ID: string;
|
|
static isVpcSubnet(x: any): x is Subnet;
|
|
static fromSubnetAttributes(scope: Construct, id: string, attrs: SubnetAttributes): ISubnet;
|
|
/**
|
|
* Import existing subnet from id.
|
|
*/
|
|
static fromSubnetId(scope: Construct, id: string, subnetId: string): ISubnet;
|
|
/**
|
|
* The Availability Zone the subnet is located in
|
|
*/
|
|
readonly availabilityZone: string;
|
|
/**
|
|
* @attribute
|
|
*/
|
|
readonly ipv4CidrBlock: string;
|
|
/**
|
|
* The subnetId for this particular subnet
|
|
*/
|
|
readonly subnetId: string;
|
|
/**
|
|
* @attribute
|
|
*/
|
|
readonly subnetVpcId: string;
|
|
/**
|
|
* @attribute
|
|
*/
|
|
readonly subnetAvailabilityZone: string;
|
|
/**
|
|
* @attribute
|
|
*/
|
|
readonly subnetIpv6CidrBlocks: string[];
|
|
/**
|
|
* The Amazon Resource Name (ARN) of the Outpost for this subnet (if one exists).
|
|
* @attribute
|
|
*/
|
|
readonly subnetOutpostArn: string;
|
|
/**
|
|
* @attribute
|
|
*/
|
|
readonly subnetNetworkAclAssociationId: string;
|
|
/**
|
|
* Parts of this VPC subnet
|
|
*/
|
|
readonly dependencyElements: IDependable[];
|
|
/**
|
|
* The routeTableId attached to this subnet.
|
|
*/
|
|
readonly routeTable: IRouteTable;
|
|
readonly subnetRef: SubnetReference;
|
|
readonly internetConnectivityEstablished: IDependable;
|
|
private readonly _internetConnectivityEstablished;
|
|
private _networkAcl;
|
|
constructor(scope: Construct, id: string, props: SubnetProps);
|
|
/**
|
|
* Create a default route that points to a passed IGW, with a dependency
|
|
* on the IGW's attachment to the VPC.
|
|
*
|
|
* @param gatewayId the logical ID (ref) of the gateway attached to your VPC
|
|
* @param gatewayAttachment the gateway attachment construct to be added as a dependency
|
|
*/
|
|
addDefaultInternetRoute(gatewayId: string, gatewayAttachment: IDependable): void;
|
|
/**
|
|
* Create a default IPv6 route that points to a passed IGW.
|
|
*
|
|
* @param gatewayId the logical ID (ref) of the gateway attached to your VPC
|
|
*/
|
|
addIpv6DefaultInternetRoute(gatewayId: string): void;
|
|
/**
|
|
* Create a default IPv6 route that points to a passed EIGW.
|
|
*
|
|
* @param gatewayId the logical ID (ref) of the gateway attached to your VPC
|
|
*/
|
|
addIpv6DefaultEgressOnlyInternetRoute(gatewayId: string): void;
|
|
/**
|
|
* Network ACL associated with this Subnet
|
|
*
|
|
* Upon creation, this is the default ACL which allows all traffic, except
|
|
* explicit DENY entries that you add.
|
|
*
|
|
* You can replace it with a custom ACL which denies all traffic except
|
|
* the explicit ALLOW entries that you add by creating a `NetworkAcl`
|
|
* object and calling `associateNetworkAcl()`.
|
|
*/
|
|
get networkAcl(): INetworkAcl;
|
|
/**
|
|
* Adds an entry to this subnets route table that points to the passed NATGatewayId
|
|
* @param natGatewayId The ID of the NAT gateway
|
|
*/
|
|
addDefaultNatRoute(natGatewayId: string): void;
|
|
/**
|
|
* Adds an entry to this subnets route table that points to the passed NATGatewayId.
|
|
* Uses the known 64:ff9b::/96 prefix.
|
|
* @param natGatewayId The ID of the NAT gateway
|
|
*/
|
|
addIpv6Nat64Route(natGatewayId: string): void;
|
|
/**
|
|
* Adds an entry to this subnets route table
|
|
*/
|
|
addRoute(id: string, options: AddRouteOptions): void;
|
|
associateNetworkAcl(id: string, networkAcl: INetworkAcl): void;
|
|
}
|
|
/**
|
|
* Options for adding a new route to a subnet
|
|
*/
|
|
export interface AddRouteOptions {
|
|
/**
|
|
* IPv4 range this route applies to
|
|
*
|
|
* @default '0.0.0.0/0'
|
|
*/
|
|
readonly destinationCidrBlock?: string;
|
|
/**
|
|
* IPv6 range this route applies to
|
|
*
|
|
* @default - Uses IPv6
|
|
*/
|
|
readonly destinationIpv6CidrBlock?: string;
|
|
/**
|
|
* What type of router to route this traffic to
|
|
*/
|
|
readonly routerType: RouterType;
|
|
/**
|
|
* The ID of the router
|
|
*
|
|
* Can be an instance ID, gateway ID, etc, depending on the router type.
|
|
*/
|
|
readonly routerId: string;
|
|
/**
|
|
* Whether this route will enable internet connectivity
|
|
*
|
|
* If true, this route will be added before any AWS resources that depend
|
|
* on internet connectivity in the VPC will be created.
|
|
*
|
|
* @default false
|
|
*/
|
|
readonly enablesInternetConnectivity?: boolean;
|
|
}
|
|
/**
|
|
* Type of router used in route
|
|
*/
|
|
export declare enum RouterType {
|
|
/**
|
|
* Carrier gateway
|
|
*/
|
|
CARRIER_GATEWAY = "CarrierGateway",
|
|
/**
|
|
* Egress-only Internet Gateway
|
|
*/
|
|
EGRESS_ONLY_INTERNET_GATEWAY = "EgressOnlyInternetGateway",
|
|
/**
|
|
* Internet Gateway
|
|
*/
|
|
GATEWAY = "Gateway",
|
|
/**
|
|
* Instance
|
|
*/
|
|
INSTANCE = "Instance",
|
|
/**
|
|
* Local Gateway
|
|
*/
|
|
LOCAL_GATEWAY = "LocalGateway",
|
|
/**
|
|
* NAT Gateway
|
|
*/
|
|
NAT_GATEWAY = "NatGateway",
|
|
/**
|
|
* Network Interface
|
|
*/
|
|
NETWORK_INTERFACE = "NetworkInterface",
|
|
/**
|
|
* Transit Gateway
|
|
*/
|
|
TRANSIT_GATEWAY = "TransitGateway",
|
|
/**
|
|
* VPC peering connection
|
|
*/
|
|
VPC_PEERING_CONNECTION = "VpcPeeringConnection",
|
|
/**
|
|
* VPC Endpoint for gateway load balancers
|
|
*/
|
|
VPC_ENDPOINT = "VpcEndpoint",
|
|
/**
|
|
* AWS Network Manager Core Network
|
|
*/
|
|
CORE_NETWORK = "CoreNetwork"
|
|
}
|
|
export interface PublicSubnetProps extends SubnetProps {
|
|
}
|
|
export interface IPublicSubnet extends ISubnet {
|
|
}
|
|
export interface PublicSubnetAttributes extends SubnetAttributes {
|
|
}
|
|
/**
|
|
* Represents a public VPC subnet resource
|
|
*/
|
|
export declare class PublicSubnet extends Subnet implements IPublicSubnet {
|
|
/**
|
|
* Uniquely identifies this class.
|
|
*/
|
|
static readonly PROPERTY_INJECTION_ID: string;
|
|
static fromPublicSubnetAttributes(scope: Construct, id: string, attrs: PublicSubnetAttributes): IPublicSubnet;
|
|
constructor(scope: Construct, id: string, props: PublicSubnetProps);
|
|
/**
|
|
* Creates a new managed NAT gateway attached to this public subnet.
|
|
* Also adds the EIP for the managed NAT.
|
|
* @returns A ref to the NAT Gateway ID
|
|
*/
|
|
addNatGateway(eipAllocationId?: string): CfnNatGateway;
|
|
}
|
|
export interface PrivateSubnetProps extends SubnetProps {
|
|
}
|
|
export interface IPrivateSubnet extends ISubnet {
|
|
}
|
|
export interface PrivateSubnetAttributes extends SubnetAttributes {
|
|
}
|
|
/**
|
|
* Represents a private VPC subnet resource
|
|
*/
|
|
export declare class PrivateSubnet extends Subnet implements IPrivateSubnet {
|
|
/**
|
|
* Uniquely identifies this class.
|
|
*/
|
|
static readonly PROPERTY_INJECTION_ID: string;
|
|
static fromPrivateSubnetAttributes(scope: Construct, id: string, attrs: PrivateSubnetAttributes): IPrivateSubnet;
|
|
constructor(scope: Construct, id: string, props: PrivateSubnetProps);
|
|
}
|
|
export {};
|