Contoh: Buat layanan AWS Fargate menggunakan CDK AWS - AWS Cloud Development Kit (AWS CDK) v2
Buat proyek CDKBuat layanan FargateBersihkan

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:

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

ApplicationLoadBalancedFargateServiceKonstruksi 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.

TypeScript
mkdir MyEcsConstruct
cd MyEcsConstruct
cdk init --language typescript
JavaScript
mkdir MyEcsConstruct
cd MyEcsConstruct
cdk init --language javascript
Python
mkdir MyEcsConstruct
cd MyEcsConstruct
cdk init --language python
source .venv/bin/activate # On Windows, run '.\venv\Scripts\activate' instead
pip install -r requirements.txt
Java
mkdir MyEcsConstruct
cd MyEcsConstruct
cdk init --language java

Kami sekarang dapat mengimpor proyek Maven ke IDE kami.

C#
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:

TypeScript

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";
JavaScript

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");
Python

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)
Java

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.*;
C#

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:

TypeScript
    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
    });
JavaScript
    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
    });
Python
        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
Java
        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();
C#
            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