Crea un VPC con sottoreti private e gateway NAT utilizzando AWS CLI

Questo tutorial dimostra come creare un VPC da utilizzare per i server in un ambiente di produzione utilizzando il. AWS CLI Per migliorare la resilienza, distribuirai i server in due zone di disponibilità, utilizzando un gruppo Auto Scaling e un Application Load Balancer. Per una maggiore sicurezza, implementerai i server in sottoreti private. I server riceveranno le richieste tramite il sistema di bilanciamento del carico e potranno connettersi a Internet utilizzando i gateway NAT. Per migliorare la resilienza, implementerai un gateway NAT in ogni zona di disponibilità.

Il diagramma seguente fornisce una panoramica delle risorse incluse in questo tutorial. Il VPC dispone di sottoreti pubbliche e private in due zone di disponibilità. Ogni sottorete pubblica contiene un gateway NAT e un nodo del sistema di bilanciamento del carico. I server vengono eseguiti nelle sottoreti private, vengono avviati e terminati utilizzando un gruppo con scalabilità automatica e ricevono traffico dal sistema di bilanciamento del carico. I server possono connettersi a Internet utilizzando il gateway NAT. I server possono connettersi ad Amazon S3 utilizzando un endpoint VPC gateway.

Prerequisiti

Prima di iniziare questo tutorial, è necessario:

• AWS CLI Installato e configurato con le autorizzazioni per creare risorse VPC EC2 , istanze, sistemi di bilanciamento del carico e gruppi di Auto Scaling. Per informazioni sull'installazione di AWS CLI, vedere Installazione o aggiornamento della versione più recente di. AWS CLI

• Conoscenza di base dei concetti VPC, tra cui sottoreti, tabelle di routing e gateway Internet.

• Il processore JSON da jq riga di comando installato. Viene utilizzato per analizzare l'output dei comandi. AWS CLI Per informazioni sull'installazione di jq, vedi Download jq.

• Quote di servizio sufficienti per le risorse che creerai, tra cui:

• Almeno 2 indirizzi IP elastici disponibili

• Almeno 2 gateway NAT

• Almeno 1 VPC

• Almeno 4 sottoreti

• Almeno 1 Application Load Balancer

Costo stimato: Le risorse create in questo tutorial comporteranno addebiti AWS sul tuo account: NAT Gateways: ~$0,045 all'ora, più i costi di elaborazione dei dati Indirizzi IP elastici: gratuiti se associati a istanze in esecuzione, ~$0,005 all'ora se non associate EC2 : varia in base al tipo di istanza (t3.micro utilizzato in questo tutorial) Application Load Balancer: ~$0,0225 all'ora, più i costi di elaborazione dei dati

Crea il VPC e le sottoreti

Innanzitutto, creerai un VPC con un blocco CIDR di 10.0.0.0/16, che fornisce fino a 65.536 indirizzi IP privati.

# Create a VPC with CIDR block 10.0.0.0/16
aws ec2 create-vpc --cidr-block 10.0.0.0/16 --tag-specifications 'ResourceType=vpc,Tags=[{Key=Name,Value=ProductionVPC}]'

Il comando restituisce un output simile al seguente:

{
    "Vpc": {
        "CidrBlock": "10.0.0.0/16",
        "DhcpOptionsId": "dopt-abcd1234",
        "State": "pending",
        "VpcId": "vpc-abcd1234",
        "OwnerId": "123456789012",
        "InstanceTenancy": "default",
        "Ipv6CidrBlockAssociationSet": [],
        "CidrBlockAssociationSet": [
            {
                "AssociationId": "vpc-cidr-assoc-abcd1234",
                "CidrBlock": "10.0.0.0/16",
                "CidrBlockState": {
                    "State": "associated"
                }
            }
        ],
        "IsDefault": false,
        "Tags": [
            {
                "Key": "Name",
                "Value": "ProductionVPC"
            }
        ]
    }
}

Annota l'ID VPC dall'output (ad esempio,vpc-abcd1234). Utilizzerai questo ID nei comandi successivi.

Successivamente, identificherai due zone di disponibilità nella tua regione per creare un'architettura resiliente.

# Get available Availability Zones
aws ec2 describe-availability-zones --query 'AvailabilityZones[0:2].ZoneName' --output text

Il comando restituisce un output simile al seguente:

us-east-1a us-east-1b

Ora, crea quattro sottoreti: due sottoreti pubbliche per il bilanciamento del carico e i gateway NAT e due sottoreti private per i server delle applicazioni. Sostituisci vpc-abcd1234 con il tuo ID VPC effettivo us-east-1a e us-east-1b con le tue zone di disponibilità effettive.

# Create public subnet in first AZ
aws ec2 create-subnet \
  --vpc-id vpc-abcd1234 \
  --cidr-block 10.0.0.0/24 \
  --availability-zone us-east-1a \
  --tag-specifications 'ResourceType=subnet,Tags=[{Key=Name,Value=PublicSubnet1}]'

# Create private subnet in first AZ
aws ec2 create-subnet \
  --vpc-id vpc-abcd1234 \
  --cidr-block 10.0.1.0/24 \
  --availability-zone us-east-1a \
  --tag-specifications 'ResourceType=subnet,Tags=[{Key=Name,Value=PrivateSubnet1}]'

# Create public subnet in second AZ
aws ec2 create-subnet \
  --vpc-id vpc-abcd1234 \
  --cidr-block 10.0.2.0/24 \
  --availability-zone us-east-1b \
  --tag-specifications 'ResourceType=subnet,Tags=[{Key=Name,Value=PublicSubnet2}]'

# Create private subnet in second AZ
aws ec2 create-subnet \
  --vpc-id vpc-abcd1234 \
  --cidr-block 10.0.3.0/24 \
  --availability-zone us-east-1b \
  --tag-specifications 'ResourceType=subnet,Tags=[{Key=Name,Value=PrivateSubnet2}]'

Ogni comando restituisce un output contenente l'ID della sottorete. Nota questi IDs per utilizzarli nei comandi successivi:

• Sottorete pubblica 1: subnet-abcd1234

• Sottorete privata 1: subnet-abcd5678

• Sottorete pubblica 2: subnet-efgh1234

• Sottorete privata 2: subnet-efgh5678

Crea e configura la connettività Internet

In questa sezione, creerai un gateway Internet per consentire la comunicazione tra il tuo VPC e Internet e collegarlo al tuo VPC.

# Create an Internet Gateway
aws ec2 create-internet-gateway --tag-specifications 'ResourceType=internet-gateway,Tags=[{Key=Name,Value=ProductionIGW}]'

Il comando restituisce un output contenente l'ID Internet Gateway. Annotate questo ID (ad esempio,igw-abcd1234).

Collega l'Internet Gateway al tuo VPC. Sostituiscilo igw-abcd1234 con il tuo ID Internet Gateway effettivo e vpc-abcd1234 con il tuo ID VPC effettivo.

# Attach the Internet Gateway to the VPC
aws ec2 attach-internet-gateway --internet-gateway-id igw-abcd1234 --vpc-id vpc-abcd1234

Successivamente, crea tabelle di routing per le tue sottoreti pubbliche e private. vpc-abcd1234Sostituiscilo con il tuo ID VPC effettivo.

# Create a route table for public subnets
aws ec2 create-route-table --vpc-id vpc-abcd1234 --tag-specifications 'ResourceType=route-table,Tags=[{Key=Name,Value=PublicRouteTable}]'

# Create route table for private subnet in first AZ
aws ec2 create-route-table --vpc-id vpc-abcd1234 --tag-specifications 'ResourceType=route-table,Tags=[{Key=Name,Value=PrivateRouteTable1}]'

# Create route table for private subnet in second AZ
aws ec2 create-route-table --vpc-id vpc-abcd1234 --tag-specifications 'ResourceType=route-table,Tags=[{Key=Name,Value=PrivateRouteTable2}]'

Ogni comando restituisce un output contenente l'ID della tabella delle rotte. Nota questi IDs:

• Tabella dei percorsi pubblici: rtb-abcd1234

• Tabella dei percorsi privati 1: rtb-efgh1234

• Tabella 2 del percorso privato: rtb-ijkl1234

Aggiungi un percorso all'Internet Gateway nella tabella delle rotte pubbliche per abilitare l'accesso a Internet. Sostituisci rtb-abcd1234 con l'effettivo ID della tabella di routing pubblica e igw-abcd1234 con l'ID effettivo dell'Internet Gateway.

# Add a route to the Internet Gateway
aws ec2 create-route --route-table-id rtb-abcd1234 --destination-cidr-block 0.0.0.0/0 --gateway-id igw-abcd1234

Associate le sottoreti alle rispettive tabelle di routing. Sostituisci la tabella di routing IDs e la subnet IDs con le tue attuali. IDs

# Associate public subnets with the public route table
aws ec2 associate-route-table --route-table-id rtb-abcd1234 --subnet-id subnet-abcd1234
aws ec2 associate-route-table --route-table-id rtb-abcd1234 --subnet-id subnet-efgh1234

# Associate private subnets with their respective route tables
aws ec2 associate-route-table --route-table-id rtb-efgh1234 --subnet-id subnet-abcd5678
aws ec2 associate-route-table --route-table-id rtb-ijkl1234 --subnet-id subnet-efgh5678

Crea gateway NAT

I gateway NAT consentono alle istanze in sottoreti private di connettersi a Internet o ad altri AWS servizi, ma impediscono a Internet di avviare connessioni con tali istanze. Innanzitutto, alloca gli indirizzi IP elastici per i tuoi gateway NAT.

# Allocate Elastic IP for NAT Gateway in first AZ
aws ec2 allocate-address --domain vpc --tag-specifications 'ResourceType=elastic-ip,Tags=[{Key=Name,Value=NAT1-EIP}]'

# Allocate Elastic IP for NAT Gateway in second AZ
aws ec2 allocate-address --domain vpc --tag-specifications 'ResourceType=elastic-ip,Tags=[{Key=Name,Value=NAT2-EIP}]'

Ogni comando restituisce un output contenente l'ID di allocazione. Nota questi IDs:

• ID di allocazione EIP 1: eipalloc-abcd1234

• ID di allocazione EIP 2: eipalloc-efgh1234

Crea gateway NAT in ogni sottorete pubblica. Sostituisci la sottorete IDs e l'allocazione IDs con quelle effettive. IDs

# Create NAT Gateway in public subnet of first AZ
aws ec2 create-nat-gateway \
  --subnet-id subnet-abcd1234 \
  --allocation-id eipalloc-abcd1234 \
  --tag-specifications 'ResourceType=natgateway,Tags=[{Key=Name,Value=NAT-Gateway1}]'

# Create NAT Gateway in public subnet of second AZ
aws ec2 create-nat-gateway \
  --subnet-id subnet-efgh1234 \
  --allocation-id eipalloc-efgh1234 \
  --tag-specifications 'ResourceType=natgateway,Tags=[{Key=Name,Value=NAT-Gateway2}]'

Ogni comando restituisce un output contenente l'ID del gateway NAT. Nota questi IDs:

• Gateway NAT 1: nat-abcd1234

• Gateway NAT 2: nat-efgh1234

Il provisioning dei gateway NAT richiede alcuni minuti. Attendi che siano disponibili prima di procedere. Sostituisci il NAT Gateway IDs con il tuo attuale. IDs

# Wait for NAT Gateways to be available
aws ec2 wait nat-gateway-available --nat-gateway-ids nat-abcd1234
aws ec2 wait nat-gateway-available --nat-gateway-ids nat-efgh1234

Aggiungi percorsi ai gateway NAT nelle tabelle delle rotte private per consentire l'accesso a Internet per le istanze nelle sottoreti private. Sostituisci la tabella di routing IDs e il gateway NAT con quelli attuali. IDs IDs

# Add route to NAT Gateway 1 in private route table 1
aws ec2 create-route \
  --route-table-id rtb-efgh1234 \
  --destination-cidr-block 0.0.0.0/0 \
  --nat-gateway-id nat-abcd1234

# Add route to NAT Gateway 2 in private route table 2
aws ec2 create-route \
  --route-table-id rtb-ijkl1234 \
  --destination-cidr-block 0.0.0.0/0 \
  --nat-gateway-id nat-efgh1234

Crea un endpoint VPC per Amazon S3

Un endpoint VPC per Amazon S3 consente alle istanze nelle sottoreti private di accedere a S3 senza passare dal gateway NAT, il che riduce i costi di trasferimento dei dati e offre migliori prestazioni di rete. Sostituisci vpc-abcd1234 con il tuo ID VPC effettivo e la tabella delle rotte IDs con il tuo attuale. IDs

# Get the prefix list ID for S3 in your region
S3_PREFIX_LIST_ID=$(aws ec2 describe-prefix-lists --filters "Name=prefix-list-name,Values=com.amazonaws.$(aws configure get region).s3" --query 'PrefixLists[0].PrefixListId' --output text)

# Create the VPC endpoint for S3
aws ec2 create-vpc-endpoint \
  --vpc-id vpc-abcd1234 \
  --service-name com.amazonaws.$(aws configure get region).s3 \
  --route-table-ids rtb-efgh1234 rtb-ijkl1234 \
  --tag-specifications 'ResourceType=vpc-endpoint,Tags=[{Key=Name,Value=S3-Endpoint}]'

Il comando restituisce un output contenente l'ID dell'endpoint VPC. Nota questo ID (ad esempio,vpce-abcd1234).

Configurazione dei gruppi di sicurezza

I gruppi di sicurezza fungono da firewall virtuali per consentire alle istanze di controllare il traffico in entrata e in uscita. Crea un gruppo di sicurezza per il sistema di bilanciamento del carico che consenta il traffico HTTP in entrata da qualsiasi luogo. vpc-abcd1234Sostituiscilo con il tuo ID VPC effettivo.

# Create security group for the load balancer
aws ec2 create-security-group \
  --group-name LoadBalancerSG \
  --description "Security group for the load balancer" \
  --vpc-id vpc-abcd1234 \
  --tag-specifications 'ResourceType=security-group,Tags=[{Key=Name,Value=LoadBalancerSG}]'

Il comando restituisce un output contenente l'ID del gruppo di sicurezza. Annotate questo ID (ad esempio,sg-abcd1234).

Consenti il traffico HTTP in entrata verso il sistema di bilanciamento del carico. sg-abcd1234Sostituiscilo con l'ID effettivo del gruppo di sicurezza del sistema di bilanciamento del carico.

# Allow inbound HTTP traffic from anywhere
aws ec2 authorize-security-group-ingress \
  --group-id sg-abcd1234 \
  --protocol tcp \
  --port 80 \
  --cidr 0.0.0.0/0

Crea un gruppo di sicurezza per i server delle applicazioni che consenta il traffico in entrata solo dal load balancer. vpc-abcd1234Sostituiscilo con il tuo ID VPC effettivo.

# Create security group for the application servers
aws ec2 create-security-group \
  --group-name AppServerSG \
  --description "Security group for the application servers" \
  --vpc-id vpc-abcd1234 \
  --tag-specifications 'ResourceType=security-group,Tags=[{Key=Name,Value=AppServerSG}]'

Il comando restituisce un output contenente l'ID del gruppo di sicurezza. Annotate questo ID (ad esempio,sg-efgh1234).

Consenti il traffico HTTP in entrata dal gruppo di sicurezza del bilanciamento del carico ai server delle applicazioni. sg-efgh1234Sostituiscilo con l'ID effettivo del gruppo di sicurezza dell'Application Server e sg-abcd1234 con l'ID effettivo del gruppo di sicurezza del Load Balancer.

# Allow inbound HTTP traffic from the load balancer security group
aws ec2 authorize-security-group-ingress \
  --group-id sg-efgh1234 \
  --protocol tcp \
  --port 80 \
  --source-group sg-abcd1234

Crea un modello di avvio per le istanze EC2

Un modello di avvio contiene le informazioni di configurazione per avviare un'istanza, come l'ID AMI, il tipo di istanza e i gruppi di sicurezza. Innanzitutto, crea uno script di dati utente che verrà eseguito all'avvio dell'istanza.

cat > user-data.sh << 'EOF'
#!/bin/bash
yum update -y
yum install -y httpd
systemctl start httpd
systemctl enable httpd
echo "<h1>Hello from $(hostname -f) in $(curl -s http://169.254.169.254/latest/meta-data/placement/availability-zone)</h1>" > /var/www/html/index.html
EOF

Codifica lo script dei dati utente in base64.

USER_DATA=$(base64 -w 0 user-data.sh)

Ottieni l'ID AMI Amazon Linux 2 più recente.

# Get the latest Amazon Linux 2 AMI ID
aws ec2 describe-images --owners amazon --filters "Name=name,Values=amzn2-ami-hvm-*-x86_64-gp2" "Name=state,Values=available" --query 'sort_by(Images, &CreationDate)[-1].ImageId' --output text

Crea un modello di avvio con l'ID AMI, il tipo di istanza, il gruppo di sicurezza e i dati utente. sg-efgh1234Sostituitelo con l'ID effettivo del gruppo di sicurezza dell'Application Server $AMI_ID e $USER_DATA con i valori ottenuti dai comandi precedenti.

# Create a launch template
aws ec2 create-launch-template \
  --launch-template-name AppServerTemplate \
  --version-description "Initial version" \
  --tag-specifications 'ResourceType=launch-template,Tags=[{Key=Name,Value=AppServerTemplate}]' \
  --launch-template-data '{
    "NetworkInterfaces": [{
      "DeviceIndex": 0,
      "Groups": ["sg-efgh1234"],
      "DeleteOnTermination": true
    }],
    "ImageId": "ami-abcd1234",
    "InstanceType": "t3.micro",
    "UserData": "IyEvYmluL2Jhc2gKeXVtIHVwZGF0ZSAteQp5dW0gaW5zdGFsbCAteSBodHRwZApzeXN0ZW1jdGwgc3RhcnQgaHR0cGQKc3lzdGVtY3RsIGVuYWJsZSBodHRwZAplY2hvICI8aDE+SGVsbG8gZnJvbSAkKGhvc3RuYW1lIC1mKSBpbiAkKGN1cmwgLXMgaHR0cDovLzE2OS4yNTQuMTY5LjI1NC9sYXRlc3QvbWV0YS1kYXRhL3BsYWNlbWVudC9hdmFpbGFiaWxpdHktem9uZSk8L2gxPiIgPiAvdmFyL3d3dy9odG1sL2luZGV4Lmh0bWw=",
    "TagSpecifications": [{
      "ResourceType": "instance",
      "Tags": [{
        "Key": "Name",
        "Value": "AppServer"
      }]
    }]
  }'

Crea un sistema di bilanciamento del carico e un gruppo target

Un gruppo target indirizza le richieste verso destinazioni registrate, come EC2 le istanze, utilizzando il protocollo e la porta specificati. Crea un gruppo target per i tuoi server delle applicazioni. vpc-abcd1234Sostituiscilo con il tuo ID VPC effettivo.

# Create a target group
aws elbv2 create-target-group \
  --name AppTargetGroup \
  --protocol HTTP \
  --port 80 \
  --vpc-id vpc-abcd1234 \
  --target-type instance \
  --health-check-protocol HTTP \
  --health-check-path / \
  --health-check-port traffic-port

Il comando restituisce un output contenente l'ARN del gruppo target. Nota questo ARN (ad esempio,arn:aws:elasticloadbalancing:us-east-1:123456789012:targetgroup/AppTargetGroup/abcd1234).

Crea un Application Load Balancer nelle sottoreti pubbliche. Sostituisci l'ID della sottorete IDs e del gruppo di sicurezza con quello attuale. IDs

# Create a load balancer
aws elbv2 create-load-balancer \
  --name AppLoadBalancer \
  --subnets subnet-abcd1234 subnet-efgh1234 \
  --security-groups sg-abcd1234 \
  --tags Key=Name,Value=AppLoadBalancer

Il comando restituisce l'output contenente l'ARN del bilanciamento del carico. Nota questo ARN (ad esempio,arn:aws:elasticloadbalancing:us-east-1:123456789012:loadbalancer/app/AppLoadBalancer/abcd1234).

Attendi che il load balancer sia attivo prima di procedere. arn:aws:elasticloadbalancing:us-east-1:123456789012:loadbalancer/app/AppLoadBalancer/abcd1234Sostituiscilo con l'ARN del tuo attuale sistema di bilanciamento del carico.

# Wait for load balancer to be active
aws elbv2 wait load-balancer-available \
  --load-balancer-arns arn:aws:elasticloadbalancing:us-east-1:123456789012:loadbalancer/app/AppLoadBalancer/abcd1234

Crea un listener per il load balancer che inoltri il traffico HTTP al gruppo target. Sostituisci l'ARN del sistema di bilanciamento del carico e l'ARN del gruppo target con quelli effettivi. ARNs

# Create a listener
aws elbv2 create-listener \
  --load-balancer-arn arn:aws:elasticloadbalancing:us-east-1:123456789012:loadbalancer/app/AppLoadBalancer/abcd1234 \
  --protocol HTTP \
  --port 80 \
  --default-actions Type=forward,TargetGroupArn=arn:aws:elasticloadbalancing:us-east-1:123456789012:targetgroup/AppTargetGroup/abcd1234

Creazione di un gruppo con dimensionamento automatico

Un gruppo Auto Scaling contiene una raccolta di EC2 istanze che vengono trattate come un raggruppamento logico ai fini del ridimensionamento e della gestione automatici. Crea un gruppo Auto Scaling che utilizza il modello di avvio e colloca le istanze nelle sottoreti private. Sostituisci l'ARN della sottorete IDs e del gruppo target con il tuo IDs ARN effettivo.

# Create an Auto Scaling group
aws autoscaling create-auto-scaling-group \
  --auto-scaling-group-name AppAutoScalingGroup \
  --launch-template LaunchTemplateName=AppServerTemplate,Version='$Latest' \
  --min-size 2 \
  --max-size 4 \
  --desired-capacity 2 \
  --vpc-zone-identifier "subnet-abcd5678,subnet-efgh5678" \
  --target-group-arns arn:aws:elasticloadbalancing:us-east-1:123456789012:targetgroup/AppTargetGroup/abcd1234 \
  --health-check-type ELB \
  --health-check-grace-period 300 \
  --tags Key=Name,Value=AppServer,PropagateAtLaunch=true

Test della configurazione

Dopo che il gruppo Auto Scaling ha avviato le istanze e queste hanno superato i controlli di integrità, puoi testare il tuo sistema di bilanciamento del carico. Ottieni il nome DNS del load balancer. Sostituisci l'ARN del bilanciamento del carico con il tuo ARN attuale.

# Get the DNS name of the load balancer
aws elbv2 describe-load-balancers \
  --load-balancer-arns arn:aws:elasticloadbalancing:us-east-1:123456789012:loadbalancer/app/AppLoadBalancer/abcd1234 \
  --query 'LoadBalancers[0].DNSName' \
  --output text)

Usa curl per testare l'applicazione con il nome del load balancer.

curl http://LoadBalancerName

Se aggiorni la pagina più volte, dovresti vedere le risposte provenienti da diverse istanze in diverse zone di disponibilità.

Pulizia delle risorse

Al termine di questo tutorial, dovresti eliminare tutte le risorse per evitare di incorrere in addebiti. Sostituisci tutto IDs con la tua risorsa effettiva. IDs

# Delete the Auto Scaling group
aws autoscaling delete-auto-scaling-group \
  --auto-scaling-group-name AppAutoScalingGroup \
  --force-delete

# Wait for the Auto Scaling group to be deleted
sleep 60

# Delete the load balancer
aws elbv2 delete-load-balancer \
  --load-balancer-arn arn:aws:elasticloadbalancing:us-east-1:123456789012:loadbalancer/app/AppLoadBalancer/abcd1234

# Wait for the load balancer to be deleted
sleep 30

# Delete the target group
aws elbv2 delete-target-group \
  --target-group-arn arn:aws:elasticloadbalancing:us-east-1:123456789012:targetgroup/AppTargetGroup/abcd1234

# Delete the launch template
aws ec2 delete-launch-template \
  --launch-template-name AppServerTemplate

# Delete the NAT Gateways
aws ec2 delete-nat-gateway --nat-gateway-id nat-abcd1234
aws ec2 delete-nat-gateway --nat-gateway-id nat-efgh1234

# Wait for the NAT Gateways to be deleted
sleep 90

# Release the Elastic IPs
aws ec2 release-address --allocation-id eipalloc-abcd1234
aws ec2 release-address --allocation-id eipalloc-efgh1234

# Delete the VPC endpoint
aws ec2 delete-vpc-endpoints --vpc-endpoint-ids vpce-abcd1234

# Wait for security group dependencies to clear
sleep 30

# Delete the security groups
aws ec2 delete-security-group --group-id sg-efgh1234
aws ec2 delete-security-group --group-id sg-abcd1234

# Detach the Internet Gateway
aws ec2 detach-internet-gateway --internet-gateway-id igw-abcd1234 --vpc-id vpc-abcd1234

# Delete the Internet Gateway
aws ec2 delete-internet-gateway --internet-gateway-id igw-abcd1234

# Delete the route tables
aws ec2 delete-route-table --route-table-id rtb-efgh1234
aws ec2 delete-route-table --route-table-id rtb-ijkl1234
aws ec2 delete-route-table --route-table-id rtb-abcd1234

# Delete the subnets
aws ec2 delete-subnet --subnet-id subnet-abcd1234
aws ec2 delete-subnet --subnet-id subnet-efgh1234
aws ec2 delete-subnet --subnet-id subnet-abcd5678
aws ec2 delete-subnet --subnet-id subnet-efgh5678

# Delete the VPC
aws ec2 delete-vpc --vpc-id vpc-abcd1234

Passaggi successivi

Ora che hai creato un VPC con sottoreti private e gateway NAT, potresti voler esplorare questi argomenti correlati:

• Security best practices for your VPC

• Registrazione del traffico IP utilizzando log di flusso VPC

• Auto Scaling: politiche di scalabilità di gruppo

• Controlli di integrità del gruppo target di Load Balancer