Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.

# Buat VPC dengan subnet pribadi dan gateway NAT menggunakan AWS CLI
<a name="create-a-vpc-with-private-subnets-and-nat-gateways-using-aws-cli"></a>

Tutorial ini menunjukkan cara membuat VPC yang dapat Anda gunakan untuk server di lingkungan produksi menggunakan. AWS CLI Untuk meningkatkan ketahanan, Anda akan menerapkan server di dua Availability Zone, menggunakan grup Auto Scaling dan Application Load Balancer. Untuk keamanan tambahan, Anda akan menyebarkan server di subnet pribadi. Server akan menerima permintaan melalui penyeimbang beban dan dapat terhubung ke internet menggunakan gateway NAT. Untuk meningkatkan ketahanan, Anda akan menerapkan gateway NAT di setiap Availability Zone.

Diagram berikut memberikan gambaran umum tentang sumber daya yang termasuk dalam tutorial ini. VPC memiliki subnet publik dan subnet pribadi di dua Availability Zone. Setiap subnet publik berisi gateway NAT dan node penyeimbang beban. Server berjalan di subnet pribadi, diluncurkan dan dihentikan dengan menggunakan grup Auto Scaling, dan menerima lalu lintas dari penyeimbang beban. Server dapat terhubung ke internet dengan menggunakan gateway NAT. Server dapat terhubung ke Amazon S3 dengan menggunakan titik akhir VPC gateway.

![\[VPC dengan subnet di dua Availability Zone.\]](http://docs.aws.amazon.com/id_id/vpc/latest/userguide/images/vpc-example-private-subnets.png)


## Prasyarat
<a name="prerequisites"></a>

Sebelum Anda memulai tutorial ini, Anda perlu:
+  AWS CLI Diinstal dan dikonfigurasi dengan izin untuk membuat sumber daya VPC EC2 , instance, penyeimbang beban, dan grup Auto Scaling. Untuk informasi tentang menginstal AWS CLI, lihat [Menginstal atau memperbarui versi terbaru AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html).
+ Pengetahuan dasar tentang konsep VPC, termasuk subnet, tabel rute, dan gateway internet.
+ Prosesor JSON `jq` baris perintah diinstal. Ini digunakan untuk mengurai output AWS CLI perintah. Untuk informasi tentang menginstal jq, lihat [Download jq](https://stedolan.github.io/jq/download/).
+ Kuota layanan yang memadai untuk sumber daya yang akan Anda buat, termasuk:
+ Setidaknya 2 alamat IP Elastis yang tersedia
+ Setidaknya 2 gateway NAT
+ Setidaknya 1 VPC
+ Setidaknya 4 subnet
+ Setidaknya 1 Application Load Balancer

**Perkiraan biaya**: Sumber daya yang dibuat dalam tutorial ini akan dikenakan biaya di AWS akun Anda: *Gateway NAT: \$1 \$10,045 per jam, ditambah biaya pemrosesan data Alamat IP elastis: Gratis bila dikaitkan dengan instance yang sedang berjalan,* \$1 \$10,005 per jam bila tidak terkait instans: *Bervariasi berdasarkan jenis EC2 instans (t3.micro digunakan dalam tutorial ini) Application Load Balancer: \$1 \$10,0225 per* jam, ditambah biaya pemrosesan data

## Buat VPC dan subnet
<a name="create-the-vpc-and-subnets"></a>

Pertama, Anda akan membuat VPC dengan blok CIDR 10.0.0.0/16, yang menyediakan hingga 65.536 alamat IP pribadi.

```
# 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}]'
```

Perintah tersebut mengembalikan output serupa dengan berikut ini:

```
{
    "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"
            }
        ]
    }
}
```

Perhatikan ID VPC dari output (misalnya,`vpc-abcd1234`). Anda akan menggunakan ID ini dalam perintah berikutnya.

Selanjutnya, Anda akan mengidentifikasi dua Availability Zone di wilayah Anda untuk membuat arsitektur tangguh.

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

Perintah tersebut mengembalikan output serupa dengan berikut ini:

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

Sekarang, buat empat subnet: dua subnet publik untuk load balancer dan gateway NAT, dan dua subnet pribadi untuk server aplikasi Anda. Ganti `vpc-abcd1234` dengan ID VPC Anda yang sebenarnya, dan `us-east-1a` dan `us-east-1b` dengan Availability Zone Anda yang sebenarnya.

```
# 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}]'
```

Setiap perintah mengembalikan output yang berisi subnet ID. Perhatikan ini IDs untuk digunakan dalam perintah berikutnya:
+ Subnet Publik 1: `subnet-abcd1234`
+ Subnet Pribadi 1: `subnet-abcd5678`
+ Subnet Publik 2: `subnet-efgh1234`
+ Subnet Pribadi 2: `subnet-efgh5678`

## Buat dan konfigurasikan konektivitas internet
<a name="create-and-configure-internet-connectivity"></a>

Di bagian ini, Anda akan membuat gateway internet untuk memungkinkan komunikasi antara VPC dan internet, dan melampirkannya ke VPC Anda.

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

Perintah mengembalikan output yang berisi ID Internet Gateway. Perhatikan ID ini (misalnya,`igw-abcd1234`).

Lampirkan Internet Gateway ke VPC Anda. Ganti `igw-abcd1234` dengan ID Internet Gateway Anda yang sebenarnya dan `vpc-abcd1234` dengan ID VPC Anda yang sebenarnya.

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

Selanjutnya, buat tabel rute untuk subnet publik dan pribadi Anda. Ganti `vpc-abcd1234` dengan ID VPC Anda yang sebenarnya.

```
# 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}]'
```

Setiap perintah mengembalikan output yang berisi ID tabel rute. Perhatikan ini IDs:
+ Tabel Rute Umum: `rtb-abcd1234`
+ Tabel Rute Pribadi 1: `rtb-efgh1234`
+ Tabel Rute Pribadi 2: `rtb-ijkl1234`

Tambahkan rute ke Internet Gateway di tabel rute publik untuk mengaktifkan akses internet. Ganti `rtb-abcd1234` dengan ID tabel rute publik Anda yang sebenarnya dan `igw-abcd1234` dengan ID Internet Gateway Anda yang sebenarnya.

```
# 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
```

Kaitkan subnet dengan tabel rute masing-masing. Ganti tabel rute IDs dan subnet IDs dengan yang sebenarnya 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
```

## Buat gateway NAT
<a name="create-nat-gateways"></a>

Gateway NAT memungkinkan instance di subnet pribadi untuk terhubung ke internet atau AWS layanan lain, tetapi mencegah internet memulai koneksi dengan instans tersebut. Pertama, alokasikan alamat IP Elastis untuk gateway NAT Anda.

```
# 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}]'
```

Setiap perintah mengembalikan output yang berisi ID alokasi. Perhatikan ini IDs:
+ ID Alokasi EIP 1: `eipalloc-abcd1234`
+ ID Alokasi EIP 2: `eipalloc-efgh1234`

Buat Gateway NAT di setiap subnet publik. Ganti subnet IDs dan alokasi IDs dengan yang sebenarnya. 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}]'
```

Setiap perintah mengembalikan output yang berisi NAT Gateway ID. Perhatikan ini IDs:
+ Gerbang NAT 1: `nat-abcd1234`
+ Gerbang NAT 2: `nat-efgh1234`

NAT Gateways membutuhkan waktu beberapa menit untuk penyediaan. Tunggu sampai tersedia sebelum melanjutkan. Ganti NAT Gateway IDs dengan yang sebenarnya 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
```

Tambahkan rute ke Gateway NAT di tabel rute pribadi untuk mengaktifkan akses internet untuk instance di subnet pribadi. Ganti tabel rute IDs dan NAT Gateway IDs dengan yang sebenarnya 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
```

## Buat titik akhir VPC untuk Amazon S3
<a name="create-a-vpc-endpoint-for-amazon-s3"></a>

Titik akhir VPC untuk Amazon S3 memungkinkan instance di subnet pribadi Anda mengakses S3 tanpa melalui NAT Gateway, yang mengurangi biaya transfer data dan memberikan kinerja jaringan yang lebih baik. Ganti `vpc-abcd1234` dengan ID VPC Anda yang sebenarnya dan tabel rute IDs dengan yang sebenarnya. 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}]'
```

Perintah mengembalikan output yang berisi ID titik akhir VPC. Perhatikan ID ini (misalnya,`vpce-abcd1234`).

## Konfigurasikan grup keamanan
<a name="configure-security-groups"></a>

Grup keamanan bertindak sebagai firewall virtual untuk instans Anda untuk mengontrol lalu lintas masuk dan keluar. Buat grup keamanan untuk penyeimbang beban yang memungkinkan lalu lintas HTTP masuk dari mana saja. Ganti `vpc-abcd1234` dengan ID VPC Anda yang sebenarnya.

```
# 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}]'
```

Perintah mengembalikan output yang berisi ID grup keamanan. Perhatikan ID ini (misalnya,`sg-abcd1234`).

Izinkan lalu lintas HTTP masuk ke penyeimbang beban. Ganti `sg-abcd1234` dengan ID grup keamanan penyeimbang beban Anda yang sebenarnya.

```
# 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
```

Buat grup keamanan untuk server aplikasi yang memungkinkan lalu lintas masuk hanya dari penyeimbang beban. Ganti `vpc-abcd1234` dengan ID VPC Anda yang sebenarnya.

```
# 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}]'
```

Perintah mengembalikan output yang berisi ID grup keamanan. Perhatikan ID ini (misalnya,`sg-efgh1234`).

Izinkan lalu lintas HTTP masuk dari grup keamanan penyeimbang beban ke server aplikasi. Ganti `sg-efgh1234` dengan ID grup keamanan server aplikasi Anda yang sebenarnya dan `sg-abcd1234` dengan ID grup keamanan penyeimbang beban Anda yang sebenarnya.

```
# 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
```

## Buat template peluncuran untuk EC2 instance
<a name="create-a-launch-template-for-ec2-instances"></a>

Template peluncuran berisi informasi konfigurasi untuk meluncurkan instance, seperti ID AMI, tipe instans, dan grup keamanan. Pertama, buat skrip data pengguna yang akan dieksekusi saat instance diluncurkan.

```
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
```

Encode script data pengguna di base64.

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

Dapatkan ID AMI Amazon Linux 2 terbaru.

```
# 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
```

Buat template peluncuran dengan ID AMI, tipe instans, grup keamanan, dan data pengguna. Ganti `sg-efgh1234` dengan ID grup keamanan server aplikasi Anda yang sebenarnya `$AMI_ID` dan dan `$USER_DATA` dengan nilai yang diperoleh dari perintah sebelumnya.

```
# 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"
      }]
    }]
  }'
```

## Buat penyeimbang beban dan grup target
<a name="create-a-load-balancer-and-target-group"></a>

Grup target merutekan permintaan ke target terdaftar, seperti EC2 instance, menggunakan protokol dan port yang Anda tentukan. Buat grup target untuk server aplikasi Anda. Ganti `vpc-abcd1234` dengan ID VPC Anda yang sebenarnya.

```
# 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
```

Perintah mengembalikan output yang berisi kelompok target ARN. Perhatikan ARN ini (misalnya,`arn:aws:elasticloadbalancing:us-east-1:123456789012:targetgroup/AppTargetGroup/abcd1234`).

Buat Application Load Balancer di subnet publik. Ganti subnet IDs dan ID grup keamanan dengan ID Anda yang sebenarnya 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
```

Perintah mengembalikan output yang berisi ARN penyeimbang beban. Perhatikan ARN ini (misalnya,`arn:aws:elasticloadbalancing:us-east-1:123456789012:loadbalancer/app/AppLoadBalancer/abcd1234`).

Tunggu penyeimbang beban aktif sebelum melanjutkan. Ganti `arn:aws:elasticloadbalancing:us-east-1:123456789012:loadbalancer/app/AppLoadBalancer/abcd1234` dengan ARN penyeimbang beban Anda yang sebenarnya.

```
# 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
```

Buat pendengar untuk penyeimbang beban yang meneruskan lalu lintas HTTP ke grup target. Ganti ARN penyeimbang beban dan ARN grup target dengan ARN Anda yang sebenarnya. 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
```

## Membuat grup Auto Scaling
<a name="create-an-auto-scaling-group"></a>

Grup Auto Scaling berisi kumpulan EC2 instance yang diperlakukan sebagai pengelompokan logis untuk tujuan penskalaan dan manajemen otomatis. Buat grup Auto Scaling yang menggunakan template peluncuran dan menempatkan instance di subnet pribadi. Ganti subnet IDs dan kelompok sasaran ARN dengan ARN aktual IDs dan ARN Anda.

```
# 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
```

## Uji konfigurasi Anda
<a name="test-your-configuration"></a>

Setelah grup Auto Scaling meluncurkan instans dan mereka lulus pemeriksaan kesehatan, Anda dapat menguji penyeimbang beban Anda. Dapatkan nama DNS dari penyeimbang beban. Ganti ARN penyeimbang beban dengan ARN Anda yang sebenarnya.

```
# 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
```

Gunakan curl untuk menguji aplikasi dengan nama penyeimbang beban.

```
curl http://LoadBalancerName
```

Jika Anda me-refresh halaman beberapa kali, Anda akan melihat tanggapan dari berbagai instance di Availability Zone yang berbeda.

## Pembersihan sumber daya
<a name="clean-up-resources"></a>

Setelah selesai dengan tutorial ini, Anda harus menghapus semua sumber daya untuk menghindari biaya yang dikenakan. Ganti semua IDs dengan sumber daya Anda yang sebenarnya IDs.

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

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

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

# Wait for the load balancer to be deleted
sleep 30

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

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

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

# Wait for the NAT Gateways to be deleted
sleep 90

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

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

# Wait for security group dependencies to clear
sleep 30

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

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

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

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

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

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

## Langkah berikutnya
<a name="next-steps"></a>

Sekarang setelah Anda membuat VPC dengan subnet pribadi dan gateway NAT, Anda mungkin ingin menjelajahi topik terkait ini:
+ [Praktik terbaik keamanan untuk VPC Anda](vpc-security-best-practices.md)
+ [Mencatat lalu lintas IP menggunakan VPC Flow Logs](flow-logs.md)
+ [Kebijakan penskalaan grup Auto Scaling](https://docs.aws.amazon.com/autoscaling/ec2/userguide/as-scaling-simple-step.html)
+ [Pemeriksaan kesehatan kelompok sasaran penyeimbang beban](https://docs.aws.amazon.com/elasticloadbalancing/latest/application/target-group-health-checks.html)