# Creación de una VPC con subredes privadas y puertas de enlace NAT mediante la AWS CLI
En este tutorial, se muestra cómo crear una VPC que se puede utilizar para los servidores de un entorno de producción mediante la AWS CLI. Para mejorar la resiliencia, implementará servidores en dos zonas de disponibilidad, mediante un grupo de escalado automático y un equilibrador de carga de aplicación. Para obtener mayor seguridad, implementará los servidores en subredes privadas. Los servidores recibirán las solicitudes a través del equilibrador de carga y podrán conectarse a Internet mediante puertas de enlace NAT. Para mejorar la resiliencia, implementará una puerta de enlace NAT en cada zona de disponibilidad.
En el diagrama siguiente, se proporciona información general sobre los recursos que se incluyen en este tutorial. La VPC tiene subredes privadas y públicas en dos zonas de disponibilidad. Cada subred pública contiene una puerta de enlace NAT y un nodo equilibrador de carga. Los servidores se ejecutan en las subredes privadas, se lanzan y terminan mediante un grupo de escalado automático y reciben tráfico desde el equilibrador de carga. Los servidores pueden conectarse a Internet mediante la puerta de enlace NAT. Los servidores pueden conectarse a Amazon S3 mediante un punto de conexión de VPC de puerta de enlace.
![\[Una VPC con subredes en dos zonas de disponibilidad.\]](http://docs.aws.amazon.com/es_es/vpc/latest/userguide/images/vpc-example-private-subnets.png)
## Requisitos previos
Antes de comenzar este tutorial, necesita lo siguiente:
+ La AWS CLI debe estar instalada y configurada con permisos para crear recursos de VPC, instancias de EC2, equilibradores de carga y grupos de escalado automático. Para obtener información sobre cómo instalar AWS CLI, consulte [Instalar o actualizar la versión más reciente de AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html).
+ Conocimientos básicos de los conceptos sobre las VPC, incluidas subredes, tablas de enrutamiento y puertas de enlace de Internet.
+ Debe estar instalado el procesador de línea de comandos JSON `jq`. Se utiliza para analizar el resultado de los comandos de la AWS CLI. Para obtener información sobre la instalación de jq, consulte [Download jq (Descarga de jq)](https://stedolan.github.io/jq/download/).
+ Contar con cuotas de servicio suficientes para los recursos que creará, que incluyen lo siguiente:
+ Al menos 2 direcciones IP elásticas disponibles
+ Al menos 2 puertas de enlace NAT
+ Al menos 1 VPC
+ Al menos 4 subredes
+ Al menos 1 equilibrador de carga de aplicación
**Costo estimado**: los recursos creados en este tutorial incurrirán en cargos en su cuenta de AWS: *Puertas de enlace NAT: \$10,045 USD por hora, más cargos por procesamiento de datos* Direcciones IP elásticas: gratuitas cuando se asocian a instancias en ejecución, \$10,005 USD por hora cuando no están asociadas * Instancias de EC2: varía según el tipo de instancia (en este tutorial, se utiliza t3.micro)* Equilibrador de carga de aplicación: \$10,0225 USD por hora, más cargos por procesamiento de datos
## Creación de las VPC y las subredes
En primer lugar, creará una VPC con un bloque CIDR de 10.0.0.0/16, que proporciona hasta 65 536 direcciones IP privadas.
```
# 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}]'
```
El comando devuelve un resultado similar al siguiente:
```
{
"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"
}
]
}
}
```
Cuando vea la salida, anote el ID de la VPC (por ejemplo, `vpc-abcd1234`). Utilizará este ID en comandos posteriores.
A continuación, identificará dos zonas de disponibilidad en su región para crear una arquitectura resiliente.
```
# Get available Availability Zones
aws ec2 describe-availability-zones --query 'AvailabilityZones[0:2].ZoneName' --output text
```
El comando devuelve un resultado similar al siguiente:
```
us-east-1a us-east-1b
```
Ahora, cree cuatro subredes: dos públicas para el equilibrador de carga y las puertas de enlace NAT, y dos privadas para los servidores de su aplicación. Reemplace `vpc-abcd1234` con su ID de la VPC real, y `us-east-1a` y `us-east-1b` con sus zonas de disponibilidad reales.
```
# 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}]'
```
Cada comando devuelve un resultado que contiene el ID de la subred. Anote estos ID para usarlos en comandos posteriores:
+ Subred pública 1: `subnet-abcd1234`
+ Subred privada 1: `subnet-abcd5678`
+ Subred pública 2: `subnet-efgh1234`
+ Subred privada 2: `subnet-efgh5678`
## Creación y configuración de la conectividad a Internet
En esta sección, creará una puerta de enlace de Internet para permitir la comunicación entre la VPC e Internet, y la adjuntará a la VPC.
```
# Create an Internet Gateway
aws ec2 create-internet-gateway --tag-specifications 'ResourceType=internet-gateway,Tags=[{Key=Name,Value=ProductionIGW}]'
```
El comando devuelve una salida que contiene el ID de la puerta de enlace de Internet. Anote este ID (por ejemplo, `igw-abcd1234`).
Adjunte la puerta de enlace de Internet a su VPC. Reemplace `igw-abcd1234` con su ID de la puerta de enlace de Internet real y `vpc-abcd1234` con su ID de la VPC real.
```
# Attach the Internet Gateway to the VPC
aws ec2 attach-internet-gateway --internet-gateway-id igw-abcd1234 --vpc-id vpc-abcd1234
```
Luego, cree tablas de enrutamiento para sus subredes públicas y privadas. Reemplace `vpc-abcd1234` por su ID de la VPC real.
```
# 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}]'
```
Cada comando devuelve una salida que contiene el ID de la tabla de enrutamiento. Anote estos ID:
+ Tabla de enrutamiento pública: `rtb-abcd1234`
+ Tabla de enrutamiento privada 1: `rtb-efgh1234`
+ Tabla de enrutamiento privada 2: `rtb-ijkl1234`
Agregue una ruta a la puerta de enlace de Internet en la tabla de enrutamiento pública para habilitar el acceso a Internet. Reemplace `rtb-abcd1234` con su ID de la tabla de enrutamiento pública real y `igw-abcd1234` con su ID de la puerta de enlace de Internet real.
```
# 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
```
Asocie las subredes con sus tablas de enrutamiento respectivas. Reemplace los ID de la tabla de enrutamiento y los ID de la subred con sus ID reales.
```
# 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
```
## Creación de puertas de enlace NAT
La puerta de enlace NAT permite que las instancias de las subredes privadas se conecten a Internet o a otros servicios de AWS, pero impede que Internet inicie conexiones con dichas instancias. En primer lugar, asigne direcciones IP elásticas a las puertas de enlace 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}]'
```
Cada comando devuelve una salida que contiene el ID de la asignación. Anote estos ID:
+ ID de la asignación de EIP 1: `eipalloc-abcd1234`
+ ID de la asignación de EIP 2: `eipalloc-efgh1234`
Cree puertas de enlace NAT en cada subred pública. Reemplace los ID de la subred y los ID de la asignación con sus ID reales.
```
# 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}]'
```
Cada comando devuelve una salida que contiene el ID de la puerta de enlace NAT. Anote estos ID:
+ Puerta de enlace NAT 1: `nat-abcd1234`
+ Puerta de enlace NAT 2: `nat-efgh1234`
Las puertas de enlace NAT tardan unos minutos en aprovisionarse. Espere a que estén disponibles antes de continuar. Reemplace los ID de la puerta de enlace NAT con sus ID reales.
```
# 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
```
Agregue rutas a las puertas de enlace NAT en las tablas de enrutamiento privadas para permitir el acceso a Internet a las instancias en subredes privadas. Reemplace los ID de la tabla de enrutamiento y los ID de la puerta de enlace NAT con sus ID reales.
```
# 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
```
## Creación de un punto de conexión de VPC para Amazon S3
Un punto de conexión de VPC para Amazon S3 permite que las instancias en sus subredes privadas accedan a S3 sin pasar por la puerta de enlace NAT, lo que reduce los costos de transferencia de datos y proporciona un mejor rendimiento de la red. Reemplace `vpc-abcd1234` con su ID de la VPC real y los ID de la tabla de enrutamiento con sus ID reales.
```
# 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}]'
```
El comando devuelve una salida que contiene el ID del punto de conexión de VPC. Anote este ID (por ejemplo, `vpce-abcd1234`).
## Configuración de grupos de seguridad
Los grupos de seguridad funcionan como firewalls virtuales para que las instancias controlen el tráfico entrante y saliente. Cree un grupo de seguridad para el equilibrador de carga que permita el tráfico HTTP entrante desde cualquier lugar. Reemplace `vpc-abcd1234` por su ID de la VPC real.
```
# 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}]'
```
El comando devuelve una salida que contiene el ID del grupo de seguridad. Anote este ID (por ejemplo, `sg-abcd1234`).
Permita que el tráfico entrante HTTP llegue al equilibrador de carga. Reemplace `sg-abcd1234` con el ID real del grupo de seguridad del equilibrador de carga.
```
# 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
```
Cree un grupo de seguridad para los servidores de la aplicación que permita que solo entre tráfico desde el equilibrador de carga. Reemplace `vpc-abcd1234` por su ID de la VPC real.
```
# 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}]'
```
El comando devuelve una salida que contiene el ID del grupo de seguridad. Anote este ID (por ejemplo, `sg-efgh1234`).
Permita que el tráfico HTTP entrante llegue del grupo de seguridad del equilibrador de carga a los servidores de la aplicación. Reemplace `sg-efgh1234` con el ID real del grupo de seguridad del servidor de la aplicación y `sg-abcd1234` con el ID real del grupo de seguridad del equilibrador de carga.
```
# 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
```
## Creación de una plantilla de lanzamiento para instancias de EC2
Una plantilla de lanzamiento contiene la información de configuración para iniciar una instancia, como el ID de la AMI, el tipo de instancia y los grupos de seguridad. En primer lugar, cree un script de datos de usuario que se ejecutará cuando se lance la instancia.
```
cat > user-data.sh << 'EOF'
#!/bin/bash
yum update -y
yum install -y httpd
systemctl start httpd
systemctl enable httpd
echo "Hello from $(hostname -f) in $(curl -s http://169.254.169.254/latest/meta-data/placement/availability-zone)
" > /var/www/html/index.html
EOF
```
Codifique el script de datos de usuario en base64.
```
USER_DATA=$(base64 -w 0 user-data.sh)
```
Obtenga el ID de la AMI de Amazon Linux 2 más reciente.
```
# 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
```
Cree una plantilla de lanzamiento con el ID de la AMI, el tipo de instancia, el grupo de seguridad y los datos de usuario. Reemplace `sg-efgh1234` con su ID real del grupo de seguridad del servidor de la aplicación, y `$AMI_ID` y `$USER_DATA` con los valores obtenidos de los comandos anteriores.
```
# 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"
}]
}]
}'
```
## Creación de un equilibrador de carga y un grupo de destino
Un grupo de destino direcciona las solicitudes a destinos registrados, como instancias de EC2, mediante el protocolo y el puerto especificado. Cree un grupo de destino para los servidores de su aplicación. Reemplace `vpc-abcd1234` por su ID de la VPC real.
```
# 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
```
El comando devuelve una salida que contiene el ARN del grupo de destino. Anote este ARN (por ejemplo, `arn:aws:elasticloadbalancing:us-east-1:123456789012:targetgroup/AppTargetGroup/abcd1234`).
Cree un equilibrador de carga de aplicación en las subredes públicas. Reemplace los ID de la subred y del grupo de seguridad por sus valores reales.
```
# 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
```
El comando devuelve una salida que contiene el ARN del equilibrador de carga. Anote este ARN (por ejemplo, `arn:aws:elasticloadbalancing:us-east-1:123456789012:loadbalancer/app/AppLoadBalancer/abcd1234`).
Espere a que el equilibrador de carga esté activo antes de continuar. Reemplace `arn:aws:elasticloadbalancing:us-east-1:123456789012:loadbalancer/app/AppLoadBalancer/abcd1234` por el ARN de su equilibrador de carga real.
```
# 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
```
Cree un oyente para el equilibrador de carga que reenvíe el tráfico HTTP al grupo de destino. Reemplace el ARN del equilibrador de carga y el ARN del grupo de destino por sus ARN reales.
```
# 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
```
## Creación de un grupo de escalado automático
Un Auto Scaling group (grupo de escalado automático) contiene una colección de instancias de Amazon EC2 que se tratan como una agrupación lógica a efectos de escalado automático y administración. Cree un grupo de escalado automático que utilice la plantilla de lanzamiento y coloque las instancias en las subredes privadas. Reemplace los ID de la subred y el ARN del grupo de destino con sus ID y ARN reales.
```
# 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
```
## Pruebe la configuración
Una vez que el grupo de escalado automático lance las instancias y estas pasen las comprobaciones de estado, puede probar su equilibrador de carga. Obtenga el nombre del DNS del equilibrador de carga. Reemplace el ARN del equilibrador de carga por su ARN real.
```
# 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
```
Use curl para probar la aplicación con el nombre del equilibrador de carga.
```
curl http://LoadBalancerName
```
Si actualiza la página varias veces, debería ver las respuestas de distintas instancias en diferentes zonas de disponibilidad.
## Eliminar recursos
Cuando haya terminado con este tutorial, elimine todos los recursos para evitar de incurrir en costos adicionales. Reemplace todos los ID con los ID de sus recursos reales.
```
# 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
```
## Pasos a seguir a continuación
Ahora que ha creado una VPC con subredes privadas y puertas de enlace NAT, es posible que desee explorar estos temas relacionados:
+ [Prácticas recomendadas de seguridad de la VPC](vpc-security-best-practices.md)
+ [Registro del tráfico de IP con registros de flujo de la VPC](flow-logs.md)
+ [Políticas de escalado por grupo de escalado automático](https://docs.aws.amazon.com/autoscaling/ec2/userguide/as-scaling-simple-step.html)
+ [Comprobaciones de estado para los grupos de destino del equilibrador de carga](https://docs.aws.amazon.com/elasticloadbalancing/latest/application/target-group-health-checks.html)