Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.

Per creare un VPC con sottoreti private e un gateway NAT, consulta AWS CLI

Questo tutorial spiega come creare un VPC da utilizzare per i server in un ambiente di produzione utilizzando la AWS CLI. Per migliorare la resilienza, implementerai 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 bilanciatore del carico e potranno connettersi a Internet utilizzando i gateway NAT. Per migliorare la resilienza, implementerai il gateway NAT in tutte le zone di disponibilità.

Nel diagramma seguente viene fornita 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, hai bisogno di:

Costo stimato: le risorse create in questo tutorial comporteranno addebiti sul tuo account AWS: NAT Gateways: ~0,045 $ all’ora, più i costi di elaborazione dei dati di indirizzi IP elastici: gratuiti se associati a istanze in esecuzione, ~0,005 $ all’ora se non sono associate istanze 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

Creazione di un VPC e delle sottoreti

Per prima cosa, creerai un VPC con un intervallo 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 del 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 bilanciatore del carico e i gateway NAT e due sottoreti private per i server delle applicazioni. Sostituisci vpc-abcd1234 con il tuo ID del VPC effettivo, e 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. Annota questi ID per utilizzarli nei comandi successivi:

Creazione e configurazione della connettività Internet

In questa sezione, creerai un gateway Internet per consentire la comunicazione tra il 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 del gateway Internet. Annota questo ID (ad esempio, igw-abcd1234).

Collega il gateway Internet al tuo VPC. Sostituisci igw-abcd1234 con il tuo ID effettivo del gateway Internet e vpc-abcd1234 con il tuo ID effettivo del VPC.

# 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. Sostituisci vpc-abcd1234 con il tuo ID effettivo del 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}]'

Ogni comando restituisce un output contenente l’ID della tabella di routing. Annota questi ID:

Aggiungi una route al gateway Internet nella tabella di routing pubblica per abilitare l’accesso a Internet. Sostituisci rtb-abcd1234 con il tuo ID effettivo della tabella di routing e igw-abcd1234 con il tuo ID effettivo del gateway 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

Associa le sottoreti alle rispettive tabelle di routing. Sostituisci gli ID delle tabelle di routing e gli ID delle sottoreti con i tuoi ID effettivi.

# 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

Creazione di gateway NAT

Utilizza i gateway NAT per consentire alle istanze in sottoreti private di connettersi a Internet o ad altri servizi AWS, ma impedisci a Internet di avviare una connessione 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 dell’allocazione. Annota questi ID:

Creazione di gateway NAT in ogni sottorete pubblica. Sostituisci gli ID delle sottoreti e gli ID di allocazione con i tuoi ID effettivi.

# 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. Annota questi ID:

Il provisioning dei gateway NAT richiede alcuni minuti. Attendi che siano disponibili prima di procedere. Sostituisci gli ID del gateway NAT con i tuoi ID effettivi.

# 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 delle route ai gateway NAT nelle tabelle di routing private per consentire l’accesso a Internet per le istanze nelle sottoreti private. Sostituisci gli ID delle tabelle di routing e gli ID del gateway NAT con i tuoi ID effettivi.

# 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

Creazione di 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 effettivo del VPC e gli ID della tabella di routing con i tuoi ID effettivi.

# 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. Annota questo ID (ad esempio, vpce-abcd1234).

Configurazione dei gruppi di sicurezza

I gruppi di sicurezza fungono da firewall virtuale per le istanze per controllare il traffico in entrata e quello in uscita. Crea un gruppo di sicurezza per il bilanciatore del carico che consenta il traffico HTTP in entrata da qualsiasi luogo. Sostituisci vpc-abcd1234 con il tuo ID effettivo del 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}]'

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

Consenti il traffico HTTP in entrata al bilanciatore del carico. Sostituisci sg-abcd1234 con l’ID effettivo del gruppo di sicurezza del sistema del bilanciatore 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 dell’applicazione che consenta il traffico in entrata solo dal bilanciatore del carico. Sostituisci vpc-abcd1234 con il tuo ID effettivo del 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}]'

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

Consenti il traffico HTTP in entrata dal gruppo di sicurezza del bilanciatore del carico ai server delle applicazioni. Sostituisci sg-efgh1234 con l’ID effettivo del gruppo di sicurezza del server dell’applicazione e sg-abcd1234 con l’ID effettivo del gruppo di sicurezza del bilanciatore del carico.

# 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

Creazione di un modello di avvio di un istanze EC2

Un modello di lancio contiene le informazioni di configurazione per avviare un’istanza, ad esempio 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 di 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. Sostituisci sg-efgh1234 con l’ID effettivo del gruppo di sicurezza del server dell’applicazione, e $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"
      }]
    }]
  }'

Creazione di un bilanciatore del carico e un gruppo di destinazione

Un gruppo di destinazione instrada le richieste verso destinazioni registrate, ad esempio istanze EC2, utilizzando il protocollo e il numero di porta che specifichi. Creazione di un gruppo di destinazioni per i server delle applicazioni. Sostituisci vpc-abcd1234 con il tuo ID effettivo del 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

Il comando restituisce l’output contenente l’ARN del gruppo di destinazione. Annota questo ARN (ad esempio, arn:aws:elasticloadbalancing:us-east-1:123456789012:targetgroup/AppTargetGroup/abcd1234).

Creazione di un Application Load Balancer nelle sottoreti pubbliche. Sostituisci gli ID sottorete e del gruppo di sicurezza con i tuoi ID effettivi.

# 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 il bilanciatore del carico dell’ARN. Annota questo ARN (ad esempio, arn:aws:elasticloadbalancing:us-east-1:123456789012:loadbalancer/app/AppLoadBalancer/abcd1234).

Attendi che il sistema del bilanciatore del carico sia attivo prima di procedere. Sostituisci arn:aws:elasticloadbalancing:us-east-1:123456789012:loadbalancer/app/AppLoadBalancer/abcd1234 con il tuo bilanciatore del carico effettivo dell’ARN.

# 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

Creazione di un listener per il bilanciatore del carico che inoltri il traffico HTTP al gruppo target. Sostituisci l’ARN del bilanciatore del carico e quello del gruppo di destinazione con i tuoi ARN effettivi.

# 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 con scalabilità automatica contiene una raccolta di istanze EC2, che vengono trattate come raggruppamento logico ai fini della scalabilità automatica e della gestione. Crea un gruppo Auto Scaling che utilizza il modello di avvio e colloca le istanze nelle sottoreti private. Sostituisci gli ID sottorete e gli ARN del gruppo di destinazione con i tuoi ID e ARN effettivi.

# 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 dell’integrità, puoi testare il tuo bilanciatore del carico. Ottieni il nome DNS pubblico del bilanciatore del carico. Sostituisci con il tuo ARN del bilanciatore del carico con il tuo ARN effettivo.

# 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 bilanciatore del carico.

curl http://LoadBalancerName

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

Eliminazione delle risorse

Una volta terminato questo tutorial, dovresti eliminare tutte le risorse per evitare l’addebito di costi aggiuntivi. Sostituisci tutti gli ID con gli ID effettivi delle risorse.

# 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

Dopo aver creato un VPC con sottoreti e gateway NAT, potresti voler approfondire questi argomenti correlati: