Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.
# Création d’un VPC avec des sous-réseaux privés et des passerelles NAT à l’aide de l’AWS CLI
Ce tutoriel vous explique comment créer un VPC que vous pouvez utiliser pour les serveurs d’un environnement de production à l’aide de l’AWS CLI. Pour améliorer la résilience, vous allez déployer les serveurs dans deux zones de disponibilité à l’aide d’un groupe Auto Scaling et d’un équilibreur de charge Application Load Balancer. Pour plus de sécurité, vous allez déployer les serveurs dans des sous-réseaux privés. Les serveurs recevront les demandes via l’équilibreur de charge et pourront se connecter à Internet à l’aide de passerelles NAT. Vous déploierez une passerelle NAT dans chaque zone de disponibilité pour assurer une meilleure résilience.
Le schéma suivant donne une vue d’ensemble des ressources comprises dans l’exemple. Le VPC contient des sous-réseaux privés et des sous-réseaux publics dans deux zones de disponibilité. Chaque sous-réseau public contient une passerelle NAT et un nœud d'équilibreur de charge. Les serveurs s'exécutent dans les sous-réseaux privés, sont lancés et arrêtés à l'aide d'un groupe Auto Scaling et reçoivent du trafic depuis l'équilibreur de charge. Les serveurs peuvent se connecter à Internet via la passerelle NAT. Les serveurs peuvent se connecter à Amazon S3 via un point de terminaison d'un VPC de passerelle.
![\[Un VPC avec des sous-réseaux dans deux zones de disponibilité.\]](http://docs.aws.amazon.com/fr_fr/vpc/latest/userguide/images/vpc-example-private-subnets.png)
## Prérequis
Avant de démarrer ce tutoriel, assurez-vous de disposer des éléments suivants :
+ L’AWS CLI installée et configurée avec les autorisations requises pour créer des ressources VPC, des instances EC2, des équilibreurs de charge et des groupes Auto Scaling. Pour plus d'informations sur l'installation d'AWS CLI, consultez la section [Installation ou mise à jour de la version la plus récente de AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html).
+ Des connaissances de base sur les concepts VPC, notamment les sous-réseaux, les tables de routage et les passerelles Internet.
+ Le processeur JSON en ligne de commande `jq` pour analyser la sortie des commandes AWS CLI. Pour plus d’informations sur l’installation de jq, consultez [Download jq](https://stedolan.github.io/jq/download/).
+ Des quotas de service suffisants pour les ressources que vous allez créer, notamment :
+ Au moins deux adresses IP Elastic disponibles
+ Au moins deux passerelles NAT
+ Au moins un VPC
+ Au moins quatre sous-réseaux
+ Au moins un équilibreur de charge Application Load Balancer
**Coût estimé** : les ressources créées lors de ce tutoriel seront facturées comme suit sur votre compte AWS : *passerelles NAT : environ 0,045 USD/h, plus des frais de traitement des données*, adresses IP Elastic : gratuites lorsqu’elles sont associées à des instances en cours d’exécution, 0,005 USD/h dans les autres cas, *instances EC2 : variable selon le type d’instance (t3.micro dans ce tutoriel), *Application Load Balancer : environ 0,0225 USD/h, plus des frais de traitement des données.
## Création du VPC et des sous-réseaux
Commencez par créer un VPC avec le bloc CIDR 10.0.0.0/16, qui fournit jusqu’à 65 536 adresses IP privées.
```
# 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}]'
```
La commande renvoie un résultat semblable à ce qui suit :
```
{
"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"
}
]
}
}
```
Notez l’ID de VPC indiqué dans la sortie (par exemple, `vpc-abcd1234`). Vous l’utiliserez dans les commandes suivantes.
Identifiez ensuite deux zones de disponibilité dans votre région pour créer une architecture résiliente.
```
# Get available Availability Zones
aws ec2 describe-availability-zones --query 'AvailabilityZones[0:2].ZoneName' --output text
```
La commande renvoie un résultat semblable à ce qui suit :
```
us-east-1a us-east-1b
```
Créez à présent quatre sous-réseaux : deux publics pour l’équilibreur de charge et les passerelles NAT et deux privés pour vos serveurs d’applications. Remplacez `vpc-abcd1234` par votre ID de VPC réel et `us-east-1a` et `us-east-1b` par vos zones de disponibilité réelles.
```
# 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}]'
```
Chaque commande renvoie une sortie contenant l’ID de sous-réseau. Notez ces ID, car vous les utiliserez dans les commandes suivantes :
+ Sous-réseau public 1 : `subnet-abcd1234`
+ Sous-réseau privé 1 : `subnet-abcd5678`
+ Sous-réseau public 2 : `subnet-efgh1234`
+ Sous-réseau privé 2 : `subnet-efgh5678`
## Création et configuration de la connectivité Internet
Dans cette section, vous allez créer une passerelle Internet permettant la communication entre votre VPC et Internet que vous attacherez à votre VPC.
```
# Create an Internet Gateway
aws ec2 create-internet-gateway --tag-specifications 'ResourceType=internet-gateway,Tags=[{Key=Name,Value=ProductionIGW}]'
```
La commande renvoie une sortie contenant l’ID de passerelle Internet. Notez cet ID (par exemple, `igw-abcd1234`).
Attachez la passerelle Internet à votre VPC. Remplacez `igw-abcd1234` par votre ID de passerelle Internet réel et `vpc-abcd1234` par votre ID de VPC réel.
```
# Attach the Internet Gateway to the VPC
aws ec2 attach-internet-gateway --internet-gateway-id igw-abcd1234 --vpc-id vpc-abcd1234
```
Créez ensuite des tables de routage pour vos sous-réseaux publics et privés. Remplacez `vpc-abcd1234` par votre ID de VPC réel.
```
# 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}]'
```
Chaque commande renvoie une sortie contenant l’ID de table de routage. Notez ces ID :
+ Table de routage publique : `rtb-abcd1234`
+ Table de routage privée 1 : `rtb-efgh1234`
+ Table de routage privée 2 : `rtb-ijkl1234`
Ajoutez à la table de routage publique une route vers la passerelle Internet pour permettre l’accès à Internet. Remplacez `rtb-abcd1234` par votre ID de table de routage publique réel et `igw-abcd1234` par votre ID de passerelle Internet réel.
```
# 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
```
Associez les sous-réseaux à leurs tables de routage respectives. Remplacez les ID de table de routage et de sous-réseau par vos ID réels.
```
# 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
```
## Création de passerelles NAT
Les passerelles NAT permettent aux instances des sous-réseaux privés de se connecter à Internet ou à d’autres services AWS tout en empêchant l’établissement de connexions avec ces instances depuis Internet. Commencez par allouer une adresse IP Elastic à vos passerelles 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}]'
```
Chaque commande renvoie une sortie contenant l’ID d’allocation. Notez ces ID :
+ ID d’allocation EIP 1 : `eipalloc-abcd1234`
+ ID d’allocation EIP 2 : `eipalloc-efgh1234`
Créez des passerelles NAT dans chaque sous-réseau public. Remplacez les ID de sous-réseau et d’allocation par vos ID réels.
```
# 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}]'
```
Chaque commande renvoie une sortie contenant l’ID de passerelle NAT. Notez ces ID :
+ Passerelle NAT 1 : `nat-abcd1234`
+ Passerelle NAT 2 : `nat-efgh1234`
Le provisionnement des passerelles NAT prend quelques minutes. Attendez qu’elles soient disponibles pour poursuivre. Remplacez les ID de passerelle NAT par vos ID réels.
```
# 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
```
Ajoutez aux tables de routage privées des routes vers les passerelles NAT pour permettre aux instances des sous-réseaux privés d’accéder à Internet. Remplacez les ID de table de routage et de passerelle NAT par vos ID réels.
```
# 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
```
## Création d’un point de terminaison de VPC pour Amazon S3
Un point de terminaison de VPC pour Amazon S3 permet aux instances de vos sous-réseaux privés d’accéder à S3 sans passer par la passerelle NAT, ce qui réduit les coûts de transfert de données et améliore les performances du réseau. Remplacez `vpc-abcd1234` par votre ID de VPC réel et les ID de table de routage par vos ID réels.
```
# 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}]'
```
La commande renvoie une sortie contenant l’ID de point de terminaison de VPC. Notez cet ID (par exemple, `vpce-abcd1234`).
## Configurer des groupes de sécurité
Les groupes de sécurité agissent comme des pare-feu virtuels pour vos instances afin de contrôler le trafic entrant et sortant. Créez pour l’équilibreur de charge un groupe de sécurité qui autorise le trafic HTTP entrant quelle que soit son origine. Remplacez `vpc-abcd1234` par votre ID de VPC réel.
```
# 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}]'
```
La commande renvoie une sortie contenant l’ID de groupe de sécurité. Notez cet ID (par exemple, `sg-abcd1234`).
Autorisez le trafic HTTP entrant vers l’équilibreur de charge. Remplacez `sg-abcd1234` par l’ID de groupe de sécurité réel de votre équilibreur de charge.
```
# 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
```
Créez pour les serveurs d’applications un groupe de sécurité qui autorise uniquement le trafic entrant en provenance de l’équilibreur de charge. Remplacez `vpc-abcd1234` par votre ID de VPC réel.
```
# 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}]'
```
La commande renvoie une sortie contenant l’ID de groupe de sécurité. Notez cet ID (par exemple, `sg-efgh1234`).
Autorisez le trafic HTTP entrant du groupe de sécurité de l’équilibreur de charge vers les serveurs d’applications. Remplacez `sg-efgh1234` par l’ID de groupe de sécurité réel de votre serveur d’applications et `sg-abcd1234` par l’ID de groupe de sécurité réel de votre équilibreur de charge.
```
# 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
```
## Création d’un modèle de lancement pour les instances EC2
Un modèle de lancement contient les informations de configuration pour le lancement d’une instance, notamment l’ID d’AMI, le type d’instance et les groupes de sécurité. Commencez par créer un script de données utilisateur qui sera exécuté au lancement de l’instance.
```
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
```
Codez le script de données utilisateur en base64.
```
USER_DATA=$(base64 -w 0 user-data.sh)
```
Recherchez l’ID de l’AMI Amazon Linux 2 la plus récente.
```
# 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
```
Créez un modèle de lancement avec l’ID d’AMI, le type d’instance, le groupe de sécurité et les données utilisateur. Remplacez `sg-efgh1234` par l’ID de groupe de sécurité réel de votre serveur d’applications, et `$AMI_ID` et `$USER_DATA` par les valeurs issues des commandes précédentes.
```
# 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"
}]
}]
}'
```
## Création d’un équilibreur de charge et d’un groupe cible
Un groupe cible achemine les demandes vers les cibles enregistrées (des instances EC2, par exemple) à l’aide du protocole et du numéro de port que vous spécifiez. Créez un groupe cible pour vos serveurs d’applications. Remplacez `vpc-abcd1234` par votre ID de VPC réel.
```
# 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
```
La commande renvoie une sortie contenant l’ARN du groupe cible. Notez cet ARN (par exemple, `arn:aws:elasticloadbalancing:us-east-1:123456789012:targetgroup/AppTargetGroup/abcd1234`).
Créez un équilibreur de charge Application Load Balancer dans les sous-réseaux publics. Remplacez les ID de sous-réseau et de groupe de sécurité par vos ID réels.
```
# 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
```
La commande renvoie une sortie contenant l’ARN de l’équilibreur de charge. Notez cet ARN (par exemple, `arn:aws:elasticloadbalancing:us-east-1:123456789012:loadbalancer/app/AppLoadBalancer/abcd1234`).
Attendez que l’équilibreur de charge soit actif pour poursuivre. Remplacez `arn:aws:elasticloadbalancing:us-east-1:123456789012:loadbalancer/app/AppLoadBalancer/abcd1234` par l’ARN réel de votre équilibreur de charge.
```
# 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
```
Créez un écouteur pour l’équilibreur de charge qui transfère le trafic HTTP au groupe cible. Remplacez les ARN de l’équilibreur de charge et du groupe cible par vos ARN réels.
```
# 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
```
## Créer un groupe Auto Scaling
Un groupe Auto Scaling contient un ensemble d'instances EC2 traitées comme un regroupement logique, aux fins de mise à l'échelle et de gestion automatique. Créez un groupe Auto Scaling qui utilise le modèle de lancement et place les instances dans les sous-réseaux privés. Remplacez les ID de sous-réseau et l’ARN du groupe cible par vos ID et ARN réels.
```
# 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
```
## Tester votre configuration
Une fois que le groupe Auto Scaling a lancé des instances et que le résultat de la surveillance de l’état de ces instances est positif, vous pouvez tester votre équilibreur de charge. Obtenez le nom DNS de l’équilibreur de charge. Remplacez l’ARN de l’équilibreur de charge par votre ARN réel.
```
# 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
```
Utilisez la commande curl pour tester l’application avec le nom de l’équilibreur de charge.
```
curl http://LoadBalancerName
```
En actualisant la page à plusieurs reprises, vous accéderez aux réponses provenant de différentes instances de différentes zones de disponibilité.
## Nettoyage des ressources
Une fois que vous avez terminé ce tutoriel, supprimez toutes les ressources pour éviter les coûts associés. Remplacez tous les ID par vos ID de ressource réels.
```
# 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
```
## Étapes suivantes
Maintenant que vous avez créé un VPC avec des sous-réseaux privés et des passerelles NAT, vous pouvez explorer les sujets connexes suivants :
+ [Bonnes pratiques de sécurité pour votre VPC](vpc-security-best-practices.md)
+ [Journalisation du trafic IP à l'aide des journaux de flux VPC](flow-logs.md)
+ [Politiques de mise à l’échelle des groupes Auto Scaling](https://docs.aws.amazon.com/autoscaling/ec2/userguide/as-scaling-simple-step.html)
+ [Surveillance de l’état des groupes cibles de l’équilibreur de charge](https://docs.aws.amazon.com/elasticloadbalancing/latest/application/target-group-health-checks.html)