Ini adalah Panduan Pengembang AWS CDK v2. CDK v1 yang lebih lama memasuki pemeliharaan pada 1 Juni 2022 dan mengakhiri dukungan pada 1 Juni 2023.
Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.
# Contoh: Buat layanan AWS Fargate menggunakan CDK AWS
Dalam contoh ini, kami menunjukkan cara membuat layanan AWS Fargate yang berjalan di kluster Amazon Elastic Container Service (Amazon ECS) Container Service (Amazon ECS) yang diawali oleh Application Load Balancer yang menghadap ke internet dari gambar di Amazon ECR.
Amazon ECS adalah layanan manajemen kontainer yang sangat skalabel, cepat, yang memudahkan untuk menjalankan, menghentikan, dan mengelola kontainer Docker di cluster. Anda dapat meng-host klaster Anda di infrastruktur tanpa server yang dikelola oleh Amazon ECS dengan meluncurkan layanan atau tugas Anda menggunakan jenis peluncuran Fargate. Untuk kontrol lebih lanjut, Anda dapat meng-host tugas Anda di klaster instans Amazon Elastic Compute Cloud (Amazon EC2) yang Anda kelola dengan menggunakan jenis EC2 peluncuran Amazon.
Dalam contoh ini, kami meluncurkan beberapa layanan menggunakan tipe peluncuran Fargate. Jika Anda telah menggunakan Konsol AWS Manajemen untuk membuat layanan Fargate, Anda tahu bahwa ada banyak langkah yang harus diikuti untuk menyelesaikan tugas itu. AWS memiliki beberapa tutorial dan topik dokumentasi yang memandu Anda melalui pembuatan layanan Fargate, termasuk:
+ [Cara Menerapkan Kontainer Docker - AWS](https://aws.amazon.com/getting-started/tutorials/deploy-docker-containers)
+ [Menyiapkan dengan Amazon ECS](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/get-set-up-for-amazon-ecs.html)
+ [Memulai Amazon ECS Menggunakan Fargate](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ECS_GetStarted.html)
Contoh ini membuat layanan Fargate serupa menggunakan CDK AWS .
Konstruksi Amazon ECS yang digunakan dalam contoh ini membantu Anda menggunakan AWS layanan dengan memberikan manfaat berikut:
+ Secara otomatis mengkonfigurasi penyeimbang beban.
+ Secara otomatis membuka grup keamanan untuk penyeimbang beban. Hal ini memungkinkan penyeimbang beban untuk berkomunikasi dengan instance tanpa harus secara eksplisit membuat grup keamanan.
+ Secara otomatis memesan ketergantungan antara layanan dan penyeimbang beban yang dilampirkan ke grup target, di mana AWS CDK memberlakukan urutan pembuatan listener yang benar sebelum instance dibuat.
+ Secara otomatis mengonfigurasi data pengguna pada grup penskalaan otomatis. Ini menciptakan konfigurasi yang benar untuk mengaitkan cluster ke AMIs.
+ Memvalidasi kombinasi parameter lebih awal. Ini memperlihatkan AWS CloudFormation masalah sebelumnya, sehingga menghemat waktu penerapan. Misalnya, tergantung pada tugasnya, mudah untuk mengkonfigurasi pengaturan memori secara tidak benar. Sebelumnya, kami tidak akan menemukan kesalahan sampai kami menerapkan aplikasi kami. Tetapi sekarang AWS CDK dapat mendeteksi kesalahan konfigurasi dan memancarkan kesalahan saat kami mensintesis aplikasi kami.
+ Secara otomatis menambahkan izin untuk Amazon Elastic Container Registry (Amazon ECR) Registry ECR) jika kami menggunakan gambar dari Amazon ECR.
+ Secara otomatis skala. AWS CDK menyediakan metode sehingga kami dapat menskalakan instance secara otomatis saat kami menggunakan kluster Amazon EC2 . Ini terjadi secara otomatis ketika kita menggunakan instance di cluster Fargate.
Selain itu, AWS CDK mencegah instance dihapus saat penskalaan otomatis mencoba menghentikan instance, tetapi tugas sedang berjalan atau dijadwalkan pada instance itu.
Sebelumnya, kami harus membuat fungsi Lambda untuk memiliki fungsi ini.
+ Menyediakan dukungan aset, sehingga kami dapat menyebarkan sumber dari mesin kami ke Amazon ECS dalam satu langkah. Sebelumnya, untuk menggunakan sumber aplikasi, kami harus melakukan beberapa langkah manual, seperti mengunggah ke Amazon ECR dan membuat gambar Docker.
**penting**
`ApplicationLoadBalancedFargateService`Konstruksi yang akan kita gunakan mencakup banyak AWS komponen, beberapa di antaranya memiliki biaya non-sepele jika dibiarkan disediakan di AWS akun kita, bahkan jika kita tidak menggunakannya. Pastikan untuk membersihkan (`cdk destroy`) jika Anda mengikuti contoh ini.
## Buat proyek CDK
Kami mulai dengan membuat proyek CDK. Ini adalah direktori yang menyimpan kode AWS CDK kami, termasuk aplikasi CDK kami.
**Example**
```
mkdir MyEcsConstruct
cd MyEcsConstruct
cdk init --language typescript
```
```
mkdir MyEcsConstruct
cd MyEcsConstruct
cdk init --language javascript
```
```
mkdir MyEcsConstruct
cd MyEcsConstruct
cdk init --language python
source .venv/bin/activate # On Windows, run '.\venv\Scripts\activate' instead
pip install -r requirements.txt
```
```
mkdir MyEcsConstruct
cd MyEcsConstruct
cdk init --language java
```
Kami sekarang dapat mengimpor proyek Maven ke IDE kami.
```
mkdir MyEcsConstruct
cd MyEcsConstruct
cdk init --language csharp
```
Kami sekarang dapat membuka `src/MyEcsConstruct.sln` di Visual Studio.
Selanjutnya, kami menjalankan aplikasi dan mengonfirmasi bahwa itu membuat tumpukan kosong.
```
cdk synth
```
## Buat layanan Fargate
Ada dua cara berbeda agar kita dapat menjalankan tugas penampung kita dengan Amazon ECS:
+ Gunakan jenis `Fargate` peluncuran, di mana Amazon ECS mengelola mesin fisik tempat kontainer berjalan untuk kami.
+ Gunakan tipe `EC2` peluncuran, tempat kami melakukan pengelolaan, seperti menentukan penskalaan otomatis.
Untuk contoh ini, kita akan membuat layanan Fargate yang berjalan di cluster Amazon ECS, di depan oleh Application Load Balancer yang menghadap ke internet.
Kami menambahkan impor modul AWS Construct Library berikut ke file *stack* kami:
**Example**
Berkas: `lib/my_ecs_construct-stack.ts`
```
import * as ec2 from "aws-cdk-lib/aws-ec2";
import * as ecs from "aws-cdk-lib/aws-ecs";
import * as ecs_patterns from "aws-cdk-lib/aws-ecs-patterns";
```
Berkas: `lib/my_ecs_construct-stack.js`
```
const ec2 = require("aws-cdk-lib/aws-ec2");
const ecs = require("aws-cdk-lib/aws-ecs");
const ecs_patterns = require("aws-cdk-lib/aws-ecs-patterns");
```
Berkas: `my_ecs_construct/my_ecs_construct_stack.py`
```
from aws_cdk import (aws_ec2 as ec2, aws_ecs as ecs,
aws_ecs_patterns as ecs_patterns)
```
Berkas: `src/main/java/com/myorg/MyEcsConstructStack.java`
```
import software.amazon.awscdk.services.ec2.*;
import software.amazon.awscdk.services.ecs.*;
import software.amazon.awscdk.services.ecs.patterns.*;
```
Berkas: `src/MyEcsConstruct/MyEcsConstructStack.cs`
```
using Amazon.CDK.AWS.EC2;
using Amazon.CDK.AWS.ECS;
using Amazon.CDK.AWS.ECS.Patterns;
```
Dalam tumpukan kami, kami menambahkan kode berikut:
**Example**
```
const vpc = new ec2.Vpc(this, "MyVpc", {
maxAzs: 3 // Default is all AZs in region
});
const cluster = new ecs.Cluster(this, "MyCluster", {
vpc: vpc
});
// Create a load-balanced Fargate service and make it public
new ecs_patterns.ApplicationLoadBalancedFargateService(this, "MyFargateService", {
cluster: cluster, // Required
cpu: 512, // Default is 256
desiredCount: 6, // Default is 1
taskImageOptions: { image: ecs.ContainerImage.fromRegistry("amazon/amazon-ecs-sample") },
memoryLimitMiB: 2048, // Default is 512
publicLoadBalancer: true // Default is true
});
```
```
const vpc = new ec2.Vpc(this, "MyVpc", {
maxAzs: 3 // Default is all AZs in region
});
const cluster = new ecs.Cluster(this, "MyCluster", {
vpc: vpc
});
// Create a load-balanced Fargate service and make it public
new ecs_patterns.ApplicationLoadBalancedFargateService(this, "MyFargateService", {
cluster: cluster, // Required
cpu: 512, // Default is 256
desiredCount: 6, // Default is 1
taskImageOptions: { image: ecs.ContainerImage.fromRegistry("amazon/amazon-ecs-sample") },
memoryLimitMiB: 2048, // Default is 512
publicLoadBalancer: true // Default is true
});
```
```
vpc = ec2.Vpc(self, "MyVpc", max_azs=3) # default is all AZs in region
cluster = ecs.Cluster(self, "MyCluster", vpc=vpc)
ecs_patterns.ApplicationLoadBalancedFargateService(self, "MyFargateService",
cluster=cluster, # Required
cpu=512, # Default is 256
desired_count=6, # Default is 1
task_image_options=ecs_patterns.ApplicationLoadBalancedTaskImageOptions(
image=ecs.ContainerImage.from_registry("amazon/amazon-ecs-sample")),
memory_limit_mib=2048, # Default is 512
public_load_balancer=True) # Default is True
```
```
Vpc vpc = Vpc.Builder.create(this, "MyVpc")
.maxAzs(3) // Default is all AZs in region
.build();
Cluster cluster = Cluster.Builder.create(this, "MyCluster")
.vpc(vpc).build();
// Create a load-balanced Fargate service and make it public
ApplicationLoadBalancedFargateService.Builder.create(this, "MyFargateService")
.cluster(cluster) // Required
.cpu(512) // Default is 256
.desiredCount(6) // Default is 1
.taskImageOptions(
ApplicationLoadBalancedTaskImageOptions.builder()
.image(ContainerImage.fromRegistry("amazon/amazon-ecs-sample"))
.build())
.memoryLimitMiB(2048) // Default is 512
.publicLoadBalancer(true) // Default is true
.build();
```
```
var vpc = new Vpc(this, "MyVpc", new VpcProps
{
MaxAzs = 3 // Default is all AZs in region
});
var cluster = new Cluster(this, "MyCluster", new ClusterProps
{
Vpc = vpc
});
// Create a load-balanced Fargate service and make it public
new ApplicationLoadBalancedFargateService(this, "MyFargateService",
new ApplicationLoadBalancedFargateServiceProps
{
Cluster = cluster, // Required
DesiredCount = 6, // Default is 1
TaskImageOptions = new ApplicationLoadBalancedTaskImageOptions
{
Image = ContainerImage.FromRegistry("amazon/amazon-ecs-sample")
},
MemoryLimitMiB = 2048, // Default is 256
PublicLoadBalancer = true // Default is true
}
);
```
Selanjutnya, kami memvalidasi kode kami dengan menjalankan yang berikut ini untuk mensintesis tumpukan kami:
```
cdk synth
```
Tumpukan ratusan baris, jadi kami tidak akan menunjukkannya di sini. Tumpukan harus berisi satu instance default, subnet pribadi dan subnet publik untuk tiga Availability Zones, dan grup keamanan.
Untuk menyebarkan tumpukan, kami menjalankan yang berikut:
```
cdk deploy
```
AWS CloudFormation menampilkan informasi tentang lusinan langkah yang diperlukan saat menyebarkan aplikasi kami.
Setelah penerapan selesai, kami telah berhasil membuat layanan Amazon ECS yang didukung Fargate untuk menjalankan image Docker.
## Bersihkan
Sebagai praktik terbaik pemeliharaan umum, dan untuk meminimalkan biaya yang tidak perlu, kami menghapus tumpukan kami saat selesai:
```
cdk destroy
```