Problemi di Distribuzione VPC con Subnet con CDK e Python

Question 1

Sto cercando di creare un VPC con subnet per un progetto, ma sono in esecuzione in una questione dove CDK sembra fare due sottoreti con lo stesso blocco CIDR quando sintetizzare il codice in un CloudFormation modello, anche se io uso solo un blocco CIDR una volta per dichiarazione di sottorete. Questo provoca la distribuzione di un errore poiché CIDR blocchi in conflitto con l'altro durante la creazione di sottoreti. Ecco il codice per la definizione dello stack:

from aws_cdk import core as cdk
from aws_cdk import aws_ec2 as ec2

class CdkWorkshop3Stack(cdk.Stack):

    def __init__(self, scope: cdk.Construct, construct_id: str, **kwargs) -> None:
        super().__init__(scope, construct_id, **kwargs)

        # The code that defines your stack goes here

        # instantiate VPC with dns support and hostname enabled and cidr block at 10.0.0.0/24
        vpc = ec2.Vpc(self, "vpc-cf",
                      cidr="10.0.0.0/24",
                      enable_dns_support=True,
                      enable_dns_hostnames=True
                      )

        # instantiate internet gateway and attach VPC with internet gateway
        igw = ec2.CfnInternetGateway(self, "igw")
        igw_attach = ec2.CfnVPCGatewayAttachment(
            self, "igw_attach", vpc_id=vpc.vpc_id, internet_gateway_id=igw.attr_internet_gateway_id)

        # instantiate elastic IP with VPC domin
        eip = ec2.CfnEIP(self, "eip", domain="VPC")

        # instantiate public and private subnets and use first availability zone
        pub_subnetA = ec2.Subnet(
            self, "public-subnetA", availability_zone=super().availability_zones[0], cidr_block="10.0.0.0/26", vpc_id=vpc.vpc_id, map_public_ip_on_launch=True)
        pub_subnetB = ec2.Subnet(
            self, "public-subnetB", availability_zone=super().availability_zones[0], cidr_block="10.0.0.64/26", vpc_id=vpc.vpc_id, map_public_ip_on_launch=True)
        pri_subnetA = ec2.Subnet(
            self, "private-subnetA", availability_zone=super().availability_zones[0], cidr_block="10.0.0.128/26", vpc_id=vpc.vpc_id, map_public_ip_on_launch=False)
        pri_subnetB = ec2.Subnet(
            self, "private-subnetB", availability_zone=super().availability_zones[0], cidr_block="10.0.0.192/26", vpc_id=vpc.vpc_id, map_public_ip_on_launch=False)

        # instantiate NAT gateway
        nat_gateway = ec2.CfnNatGateway(
            self, "nat_gateway", allocation_id=eip.attr_allocation_id, subnet_id=pub_subnetA.subnet_vpc_id)

        # instantiate routing tables
        pub_route_table = ec2.CfnRouteTable(
            self, "pub_route_table", vpc_id=vpc.vpc_id)
        pri_route_table = ec2.CfnRouteTable(
            self, "pri_route_table", vpc_id=vpc.vpc_id)

        # instantiate public and private routes
        pub_route = ec2.CfnRoute(self, "pub_route", route_table_id=pub_route_table.attr_route_table_id,
                                 destination_cidr_block="0.0.0.0/0", gateway_id=igw.attr_internet_gateway_id)
        pri_route = ec2.CfnRoute(self, "pri_route", route_table_id=pri_route_table.attr_route_table_id,
                                 destination_cidr_block="0.0.0.0/0", nat_gateway_id=nat_gateway.ref)

        # instantiate subnet route table associations
        pub_subnetA_route_table_association = ec2.CfnSubnetRouteTableAssociation(
            self, "pub_subnetA_route_table_association", route_table_id=pub_route_table.attr_route_table_id, subnet_id=pub_subnetA.subnet_vpc_id)
        pub_subnetB_route_table_association = ec2.CfnSubnetRouteTableAssociation(
            self, "pub_subnetB_route_table_association", route_table_id=pub_route_table.attr_route_table_id, subnet_id=pub_subnetB.subnet_vpc_id)
        pri_subnetA_route_table_association = ec2.CfnSubnetRouteTableAssociation(
            self, "pri_subnetA_route_table_association", route_table_id=pri_route_table.attr_route_table_id, subnet_id=pri_subnetA.subnet_vpc_id)
        pri_subnetB_route_table_association = ec2.CfnSubnetRouteTableAssociation(
            self, "pri_subnetB_route_table_association", route_table_id=pri_route_table.attr_route_table_id, subnet_id=pri_subnetB.subnet_vpc_id)

        security_group = ec2.SecurityGroup(self, "security_group", vpc=vpc)
        security_group.add_ingress_rule(
            ec2.Peer.ipv4("0.0.0.0/0"), ec2.Port.tcp(22))

        ec2_instance = ec2.Instance(self, "EC2", instance_type=ec2.InstanceType.of(ec2.InstanceClass.BURSTABLE2, ec2.InstanceSize.MICRO), machine_image=ec2.MachineImage.latest_amazon_linux(),
                                    key_name="RandomKeyName", security_group=security_group, vpc=vpc, vpc_subnets=pri_subnetA)

Non so come risolvere questo problema, dato che chiaramente si deve utilizzare solo quelli CIDR blocchi di una volta. Ma non è così.

EDIT: ora sto includendo un link al CloudFormation modello di output in risposta a un commento. Ho notato che questo problema di conflitto di solo sembra verificarsi con public_subnetA e private_subnetA. Non riesco ancora a capire perché questo sta accadendo.

EDIT 2: ho provato a seguire maafk suggerimento e ridotto il mio codice nel modo seguente. Voglio mantenere il 2 pubblico e privato configurazione della subnet, ma ora non riesco a collegarmi alla mia istanza EC2 non importa quello che cerco. Perché è qualcosa che può essere facilmente raggiunto in Terraforma così inutilmente difficile da fare in AWS CDK, figuriamoci in Python?

from aws_cdk import core as cdk
from aws_cdk import aws_ec2 as ec2

class HelloCdkStack(cdk.Stack):

    def __init__(self, scope: cdk.Construct, construct_id: str, **kwargs) -> None:
        super().__init__(scope, construct_id, **kwargs)
        vpc = ec2.Vpc(self, "vpc-cf",
                      cidr="10.0.0.0/24",
                      enable_dns_support=True,
                      enable_dns_hostnames=True,
                      nat_gateways=1,
                      max_azs=1,
                      subnet_configuration=[ec2.SubnetConfiguration(
                          name="public-subnetA",
                          cidr_mask=26,
                          subnet_type=ec2.SubnetType.PUBLIC
                      ), ec2.SubnetConfiguration(
                          name="public-subnetB",
                          cidr_mask=26,
                          subnet_type=ec2.SubnetType.PUBLIC
                      ), ec2.SubnetConfiguration(
                          name="private-subnetA",
                          cidr_mask=26,
                          subnet_type=ec2.SubnetType.PRIVATE
                      ), ec2.SubnetConfiguration(
                          name="private-subnetB",
                          cidr_mask=26,
                          subnet_type=ec2.SubnetType.PRIVATE)]
                      )

        ec2_instance = ec2.Instance(self, "EC2", instance_type=ec2.InstanceType.of(ec2.InstanceClass.BURSTABLE2, ec2.InstanceSize.MICRO), machine_image=ec2.MachineImage.latest_amazon_linux(
        ), key_name="KeyPairRandom", vpc=vpc, vpc_subnets=vpc.select_subnets(subnet_type=ec2.SubnetType.PUBLIC).subnets[0])

        ec2_instance.connections.allow_from_any_ipv4(
            ec2.Port.tcp(22), 'Allow inbound SSH from anywhere')

Question 2

Si sta aggiungendo un sacco di codice che è necessario.

La creazione di un VPC con CDK già si prende cura di questo per voi

Dal docs

Il valore predefinito VPC configurazione è in grado di creare pubbliche e private subnet

Qui è un di più "CDK modo nativo" per scrivere questo.

from aws_cdk import core as cdk
from aws_cdk import aws_ec2 as ec2

class CdkWorkshop3Stack(cdk.Stack):

    def __init__(self, scope: cdk.Construct, construct_id: str, **kwargs) -> None:
        super().__init__(scope, construct_id, **kwargs)

        vpc = ec2.Vpc(self, "vpc-cf",
            cidr="10.0.0.0/24",
            # dns hostnames and support enabled by default
        )

        ec2_instance = ec2.Instance(self, "EC2", 
            instance_type=ec2.InstanceType.of(ec2.InstanceClass.BURSTABLE2, ec2.InstanceSize.MICRO), machine_image=ec2.MachineImage.latest_amazon_linux(),
            key_name="RandomKeyName", 
            vpc=vpc,
            # PRIVATE subnets are chosen by default
        )
        # Not a great security practice to open ssh to the world, but can do it this way
        ec2_instance.connections.allow_from_any_ipv4(ec2.Port.tcp(22), 'Allow inbound SSH from anywhere')

Molto meno codice, e utilizzando "impostazioni predefinite" che vengono con CDK

maafk · Answer 1 · 2021-11-20T12:31:11

Si sta aggiungendo un sacco di codice che è necessario.

La creazione di un VPC con CDK già si prende cura di questo per voi

Dal docs

Il valore predefinito VPC configurazione è in grado di creare pubbliche e private subnet

Qui è un di più "CDK modo nativo" per scrivere questo.

from aws_cdk import core as cdk
from aws_cdk import aws_ec2 as ec2

class CdkWorkshop3Stack(cdk.Stack):

    def __init__(self, scope: cdk.Construct, construct_id: str, **kwargs) -> None:
        super().__init__(scope, construct_id, **kwargs)

        vpc = ec2.Vpc(self, "vpc-cf",
            cidr="10.0.0.0/24",
            # dns hostnames and support enabled by default
        )

        ec2_instance = ec2.Instance(self, "EC2", 
            instance_type=ec2.InstanceType.of(ec2.InstanceClass.BURSTABLE2, ec2.InstanceSize.MICRO), machine_image=ec2.MachineImage.latest_amazon_linux(),
            key_name="RandomKeyName", 
            vpc=vpc,
            # PRIVATE subnets are chosen by default
        )
        # Not a great security practice to open ssh to the world, but can do it this way
        ec2_instance.connections.allow_from_any_ipv4(ec2.Port.tcp(22), 'Allow inbound SSH from anywhere')

Molto meno codice, e utilizzando "impostazioni predefinite" che vengono con CDK

Come faccio a scegliere una public subnet. Penso che il privato subnet di default è di lasciare me in grado di connettersi alla mia istanza tramite SSH.
Migliore opzione per SSH è quello di utilizzare SSM gestore di Sessione (installato di default su Amazon Linux), o per l'utilizzo di un bastion host in una public subnet. Se è assolutamente necessario creare l'istanza in un pubblico subnet, è possibile aggiungere vpc_subnets=vpc.SubnetSelection(subnet_type=ec2.SubnetType.PUBLIC) per il ec2.Instance parametri

Problemi di Distribuzione VPC con Subnet con CDK e Python

Domanda

Migliore risposta

In altre lingue

Questa pagina è in altre lingue

Popolare in questa categoria

Domande popolari in questa categoria