# Criação de uma VPC que contém sub-redes privadas e gateways NAT usando a AWS CLI
Este tutorial demonstra como criar uma VPC que pode ser usada para servidores em um ambiente de produção, usando a AWS CLI. Para melhorar a resiliência, você implantará servidores em duas zonas de disponibilidade, com o uso de um grupo do Auto Scaling e de um Application Load Balancer. Para maior segurança, os servidores serão implantados em sub-redes privadas. Os servidores receberão solicitações por meio do balanceador de carga e poderão estabelecer conexões com a internet usando gateways NAT. Para melhorar a resiliência, você implantará um gateway NAT em cada zona de disponibilidade.
O diagrama apresentado a seguir fornece uma visão geral dos recursos incluídos neste tutorial. A VPC tem sub-redes públicas e sub-redes privadas em duas zonas de disponibilidade. Cada sub-rede pública contém um gateway NAT e um nó balanceador de carga. Os servidores executados nas sub-redes privadas são executados e encerrados usando um grupo do Auto Scaling e recebem tráfego do balanceador de carga. Os servidores podem se conectar à Internet usando o gateway NAT. Os servidores podem se conectar ao Amazon S3 usando um endpoint da VPC de gateway.
![\[Uma VPC com sub-redes em duas zonas de disponibilidade.\]](http://docs.aws.amazon.com/pt_br/vpc/latest/userguide/images/vpc-example-private-subnets.png)
## Pré-requisitos
Antes de iniciar este tutorial, será necessário:
+ Ter a AWS CLI instalada e configurada com permissões para criar recursos da VPC, instâncias do EC2, balanceadores de carga e grupos do Auto Scaling. Para obter informações sobre como instalar a AWS CLI, consulte [Instalar ou atualizar para a versão mais recente da AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html).
+ Ter conhecimento básico dos conceitos da VPC, incluindo sub-redes, tabelas de rotas e gateways da internet.
+ Ter o processador JSON para a linha de comando `jq` instalado. Esse processor é usado para analisar a saída dos comandos da AWS CLI. Para obter mais informações sobre a instalação do jq, consulte [Download jq](https://stedolan.github.io/jq/download/).
+ Ter cotas de serviço suficientes para os recursos que você criará, incluindo:
+ No mínimo, dois endereços IP elásticos disponíveis
+ No mínimo, dois gateways NAT
+ No mínimo, uma VPC
+ No mínimo, quatro sub-redes
+ No mínimo, um Application Load Balancer
**Custo estimado**: os recursos criados neste tutorial incorrerão em cobranças em sua conta da AWS: *Gateways NAT: custo de, aproximadamente, USD 0,045 por hora, acrescido de cobranças por processamento de dados* \$1 Endereços IP elásticos: gratuitos quando estão associados a instâncias em execução e com um custo de, aproximadamente, USD 0,005 por hora quando não associados \$1 *Instâncias do EC2: custo varia conforme o tipo de instância (o tipo t3.micro é usado neste tutorial)* \$1 Application Load Balancer: custo de, aproximadamente, USD 0,0225 por hora, acrescido de cobranças por processamento de dados.
## Criação da VPC e das sub-redes
Primeiro, você criará uma VPC com um bloco CIDR de 10.0.0.0/16, que possibilita a alocação de até 65.536 endereços IP privados.
```
# 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}]'
```
Esse comando retorna uma saída semelhante à seguinte:
```
{
"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"
}
]
}
}
```
Anote o ID da VPC apresentado na saída (por exemplo, `vpc-abcd1234`). Você usará esse ID nos próximos comandos.
Em seguida, você identificará duas zonas de disponibilidade em sua região para criar uma arquitetura resiliente.
```
# Get available Availability Zones
aws ec2 describe-availability-zones --query 'AvailabilityZones[0:2].ZoneName' --output text
```
Esse comando retorna uma saída semelhante à seguinte:
```
us-east-1a us-east-1b
```
Agora, crie quatro sub-redes: duas sub-redes públicas, destinadas ao balanceador de carga e aos gateways NAT, e duas sub-redes privadas, destinadas aos servidores de aplicações. Certifique-se de substituir `vpc-abcd1234` pelo ID correspondente à VPC, e `us-east-1a` e `us-east-1b` pelas zonas de disponibilidade correspondentes.
```
# 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 retorna uma saída que contém o ID da sub-rede. Anote esses IDs para uso nos próximos comandos:
+ Sub-rede pública 1: `subnet-abcd1234`
+ Sub-rede privada 1: `subnet-abcd5678`
+ Sub-rede pública 2: `subnet-efgh1234`
+ Sub-rede privada 2: `subnet-efgh5678`
## Criação e configuração da conectividade com a internet
Nesta seção, você criará um gateway da internet para permitir a comunicação entre a VPC e a internet, e o anexará à sua VPC.
```
# Create an Internet Gateway
aws ec2 create-internet-gateway --tag-specifications 'ResourceType=internet-gateway,Tags=[{Key=Name,Value=ProductionIGW}]'
```
O comando retorna uma saída que contém o ID do gateway da internet. Anote esse ID (por exemplo, `igw-abcd1234`).
Anexe o gateway da internet à VPC. Certifique-se de substituir `igw-abcd1234` pelo ID correspondente ao gateway da internet e `vpc-abcd1234` pelo ID correspondente à VPC.
```
# Attach the Internet Gateway to the VPC
aws ec2 attach-internet-gateway --internet-gateway-id igw-abcd1234 --vpc-id vpc-abcd1234
```
Em seguida, crie tabelas de rotas para as sub-redes públicas e privadas. Certifique-se de substituir `vpc-abcd1234` pelo ID correspondente à VPC.
```
# 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 retorna uma saída que contém o ID da tabela de rotas. Anote esses IDs:
+ Tabela de rotas pública: `rtb-abcd1234`
+ Tabela de rotas privada 1: `rtb-efgh1234`
+ Tabela de rotas privada 2: `rtb-ijkl1234`
Adicione uma rota para o gateway da internet na tabela de rotas pública com o objetivo de habilitar o acesso à internet. Certifique-se de substituir `rtb-abcd1234` pelo ID correspondente à tabela de rotas pública e `igw-abcd1234` pelo ID correspondente ao gateway da internet.
```
# 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
```
Associe as sub-redes às respectivas tabelas de rotas. Certifique-se de substituir os IDs da tabela de rotas e da sub-rede pelos valores correspondentes aos seus 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
```
## Criação de gateways NAT
Os gateways NAT permitem que instâncias localizadas em sub-redes privadas estabeleçam conexões com a internet ou com outros serviços da AWS, mas impedem tentativas de conexões iniciadas pela internet para essas instâncias. Primeiro, aloque endereços IP elásticos para os gateways 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 retorna uma saída que contém o ID da alocação. Anote esses IDs:
+ ID da alocação do EIP 1: `eipalloc-abcd1234`
+ ID da alocação do EIP 2: `eipalloc-efgh1234`
Crie gateways NAT em cada uma das sub-redes públicas. Certifique-se de substituir os IDs da sub-rede e da alocação pelos valores correspondentes aos seus 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}]'
```
Cada comando retorna uma saída que contém o ID do gateway NAT. Anote esses IDs:
+ Gateway NAT 1: `nat-abcd1234`
+ Gateway NAT 2: `nat-efgh1234`
Os gateways NAT demoram alguns minutos para serem provisionados. Antes de prosseguir, aguarde a confirmação de que os gateways estão disponíveis. Certifique-se de substituir os IDs do gateway NAT pelos valores correspondentes aos seus 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
```
Adicione rotas para os gateways NAT nas tabelas de rotas privadas com a finalidade de habilitar o acesso à internet para instâncias em sub-redes privadas. Certifique-se de substituir os IDs da tabela de rotas e do gateway NAT pelos valores correspondentes aos seus 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
```
## Criação de um endpoint da VPC para o Amazon S3
Um endpoint da VPC para o Amazon S3 permite que as instâncias localizadas em sub-redes privadas acessem o S3 diretamente, sem a necessidade de usar o gateway NAT, o que reduz os custos de transferência de dados e melhora a performance da rede. Certifique-se de substituir `vpc-abcd1234` pelo ID correspondente à VPC e os IDs da tabela de rotas pelos valores correspondentes aos seus 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}]'
```
O comando retorna uma saída que contém o ID do endpoint da VPC. Anote esse ID (por exemplo, `vpce-abcd1234`).
## Configurar grupos de segurança
Os grupos de segurança funcionam como firewalls virtuais para as instâncias com a finalidade de controlar o tráfego de entrada e de saída. Crie um grupo de segurança para o balanceador de carga que permita o tráfego HTTP de entrada proveniente de qualquer origem. Certifique-se de substituir `vpc-abcd1234` pelo ID correspondente à VPC.
```
# 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}]'
```
O comando retorna uma saída que contém o ID do grupo de segurança. Anote esse ID (por exemplo, `sg-abcd1234`).
Permita o tráfego HTTP de entrada para o balanceador de carga. Certifique-se de substituir `sg-abcd1234` pelo ID correspondente ao grupo de segurança do balanceador 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
```
Crie um grupo de segurança para os servidores de aplicações que permita tráfego de entrada proveniente somente do balanceador de carga. Certifique-se de substituir `vpc-abcd1234` pelo ID correspondente à VPC.
```
# 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}]'
```
O comando retorna uma saída que contém o ID do grupo de segurança. Anote esse ID (por exemplo, `sg-efgh1234`).
Permita o tráfego HTTP de entrada, proveniente do grupo de segurança do balanceador de carga, para os servidores de aplicações. Certifique-se de substituir `sg-efgh1234` pelo ID correspondente ao grupo de segurança do servidor de aplicações e `sg-abcd1234` pelo ID correspondente ao grupo de segurança do balanceador 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
```
## Criação de um modelo de inicialização para instâncias do EC2
Um modelo de inicialização contém as informações de configuração necessárias para iniciar uma instância, como o ID da AMI, o tipo de instância e os grupos de segurança. Primeiro, crie um script de dados do usuário que será executado no momento da inicialização da instância.
```
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
```
Realize a codificação do script de dados do usuário usando base64.
```
USER_DATA=$(base64 -w 0 user-data.sh)
```
Obtenha o ID da versão mais atual da AMI do Amazon Linux 2.
```
# 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
```
Crie um modelo de inicialização com o ID da AMI, o tipo de instância, o grupo de segurança e os dados do usuário. Certifique-se de substituir `sg-efgh1234` pelo ID correspondente ao grupo de segurança do servidor de aplicações, e `$AMI_ID` e `$USER_DATA` pelos valores obtidos dos 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"
}]
}]
}'
```
## Criação de um balanceador de carga e de um grupo de destino
Um grupo de destino encaminha as solicitações para os destinos registrados, como as instâncias do EC2, com base no protocolo e na porta especificados por você. Crie um grupo de destino para os servidores de aplicações. Certifique-se de substituir `vpc-abcd1234` pelo ID correspondente à VPC.
```
# 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
```
O comando retorna uma saída que contém o ARN do grupo de destino. Anote esse ARN (por exemplo, `arn:aws:elasticloadbalancing:us-east-1:123456789012:targetgroup/AppTargetGroup/abcd1234`).
Crie um Application Load Balancer nas sub-redes públicas. Certifique-se de substituir os IDs da sub-rede e do grupo de segurança pelos valores correspondentes aos seus 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
```
O comando retorna uma saída que contém o ARN do balanceador de carga. Anote esse ARN (por exemplo, `arn:aws:elasticloadbalancing:us-east-1:123456789012:loadbalancer/app/AppLoadBalancer/abcd1234`).
Antes de prosseguir, aguarde a confirmação de que o balanceador de carga está ativo. Certifique-se de substituir `arn:aws:elasticloadbalancing:us-east-1:123456789012:loadbalancer/app/AppLoadBalancer/abcd1234` pelo ARN correspondente ao balanceador de carga.
```
# 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
```
Crie um receptor para o balanceador de carga que tenha a função de redirecionar o tráfego HTTP ao grupo de destino. Certifique-se de substituir o ARN do balanceador de carga e do grupo de destino pelos valores correspondentes aos seus 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
```
## Criar um grupo do Auto Scaling
Um grupo do Auto Scaling contém um conjunto de instâncias do EC2 que são tratadas como um agrupamento lógico para fins de gerenciamento e escalabilidade automática. Crie um grupo do Auto Scaling que use o modelo de inicialização e aloque as instâncias nas sub-redes privadas. Certifique-se de substituir os IDs da sub-rede e o ARN do grupo de destino pelos valores correspondentes aos IDs e ao ARN.
```
# 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
```
## Testar a configuração
Assim que o grupo do Auto Scaling realizar a inicialização das instâncias e elas forem aprovadas nas verificações de integridade, você poderá executar testes no balanceador de carga. Obtenha o nome de DNS do balanceador de carga. Certifique-se de substituir o ARN do balanceador de carga pelo valor correspondente ao seu ARN.
```
# 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 o comando “curl” para realizar testes na aplicação usando o nome do balanceador de carga.
```
curl http://LoadBalancerName
```
Ao recarregar a página repetidamente, é esperado que você receba respostas provenientes de instâncias distintas localizadas em diferentes zonas de disponibilidade.
## Limpar recursos.
Após finalizar este tutorial, é importante excluir todos os recursos para não incorrer em cobranças. Certifique-se de substituir todos os IDs pelos valores correspondentes aos IDs de recursos.
```
# 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
```
## Próximas etapas
Agora que você criou uma VPC com sub-redes privadas e gateways NAT, pode desejar explorar os seguintes tópicos relacionados:
+ [Melhores práticas de segurança para a VPC](vpc-security-best-practices.md)
+ [Como registrar tráfego IP em log com logs de fluxo da VPC](flow-logs.md)
+ [Políticas de escalabilidade para o grupo do Auto Scaling](https://docs.aws.amazon.com/autoscaling/ec2/userguide/as-scaling-simple-step.html)
+ [Verificações de integridade do grupo de destino do balanceador de carga](https://docs.aws.amazon.com/elasticloadbalancing/latest/application/target-group-health-checks.html)