La difficulté du Déploiement de VPC avec des sous-Réseaux avec CDK et Python

Question 1

Je suis en train de créer un VPC avec des sous-réseaux pour un projet, et pourtant je suis en cours d'exécution dans un problème où les CDK semble faire deux sous-réseaux avec le même bloc CIDR lors de la synthèse du code dans un modèle CloudFormation, même si je utilisez uniquement un bloc CIDR une fois par sous-réseau de la déclaration. Cela provoque l'échec du déploiement depuis blocs CIDR conflit les uns avec les autres lors de la création de la sous-réseaux. Voici le code pour la définition de la pile:

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)

Je ne sais pas comment résoudre ce problème, puisque de toute évidence, elle ne doit utiliser ces blocs CIDR une fois. Mais il ne le fait pas.

EDIT: je suis aujourd'hui, y compris un lien vers le modèle CloudFormation de sortie en réponse à un commentaire. J'ai remarqué que ce problème de conflit ne semble se produire avec public_subnetA et private_subnetA. Je ne comprends toujours pas pourquoi ce qui se passe.

EDIT 2: j'ai essayé de suivre maafk de la suggestion et réduit mon code à la suivante. Je veux garder les 2 publics et privés configuration de sous-réseau, mais maintenant je ne peux pas me connecter à mon instance EC2 peu importe ce que j'essaie. Pourquoi est quelque chose qui peut être facilement atteint dans Terraform donc inutilement difficiles à faire dans AWS CDK, a fortiori en 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

Vous êtes en train d'ajouter beaucoup plus de code que nécessaire.

La création d'un VPC avec CDK déjà prend soin de la plupart de ces pour vous

À partir de la docs

Un VPC par défaut de la configuration du public et privé sous-réseaux

Ici, c'est un plus "CDK natif de manière" d'écrire cela.

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

Beaucoup moins de code, et en utilisant les "valeurs par défaut raisonnables" qui viennent avec CDK

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

Vous êtes en train d'ajouter beaucoup plus de code que nécessaire.

La création d'un VPC avec CDK déjà prend soin de la plupart de ces pour vous

À partir de la docs

Un VPC par défaut de la configuration du public et privé sous-réseaux

Ici, c'est un plus "CDK natif de manière" d'écrire cela.

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

Beaucoup moins de code, et en utilisant les "valeurs par défaut raisonnables" qui viennent avec CDK

Comment puis-je faire choisir un sous-réseau public. Je pense que les sous-réseaux privés par défaut est me laissant incapable de se connecter à mon exemple via SSH.
La meilleure option pour le SSH est d'utiliser SSM gestionnaire de Session (installé par défaut sur Amazon Linux), ou d'utiliser un bastion de l'hôte dans un sous-réseau public. Si vous absolument devez créer votre instance dans un sous-réseau public, vous pouvez l'ajouter vpc_subnets=vpc.SubnetSelection(subnet_type=ec2.SubnetType.PUBLIC) à l' ec2.Instance paramètres

La difficulté du Déploiement de VPC avec des sous-Réseaux avec CDK et Python

La question

La meilleure réponse

Dans d'autres langues

Cette page est dans d'autres langues

Populaires dans cette catégorie

Questions populaires dans cette catégorie