Beispiel: Erstellen Sie einen AWS Fargate Dienst mit dem AWS CDK - AWS Cloud Development Kit (AWS CDK) v2
Erstellen Sie ein CDK ProjektEinen Fargate-Dienst erstellenBereinigen

Dies ist der AWS CDK v2-Entwicklerhandbuch. Die ältere CDK Version 1 wurde am 1. Juni 2022 in die Wartung aufgenommen und der Support wurde am 1. Juni 2023 eingestellt.

Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.

Beispiel: Erstellen Sie einen AWS Fargate Dienst mit dem AWS CDK

In diesem Beispiel zeigen wir Ihnen, wie Sie aus einem Image auf Amazon einen AWS Fargate Service erstellen, der auf einem Amazon Elastic Container Service (AmazonECS) -Cluster ausgeführt wird, dem ein mit dem Internet verbundener Application Load Balancer vorangestellt ist. ECR

Amazon ECS ist ein hoch skalierbarer, schneller Container-Management-Service, der es einfach macht, Docker Container in einem Cluster auszuführen, zu stoppen und zu verwalten. Sie können Ihren Cluster auf einer serverlosen Infrastruktur hosten, die von Amazon verwaltet wird, ECS indem Sie Ihre Dienste oder Aufgaben mit dem Fargate-Starttyp starten. Für mehr Kontrolle können Sie Ihre Aufgaben auf einem Cluster von Amazon Elastic Compute Cloud (AmazonEC2) -Instances hosten, die Sie mithilfe des EC2 Amazon-Starttyps verwalten.

In diesem Beispiel starten wir einige Dienste mit dem Starttyp Fargate. Wenn Sie den verwendet haben, AWS Management Console um einen Fargate-Dienst zu erstellen, wissen Sie, dass Sie viele Schritte ausführen müssen, um diese Aufgabe zu erledigen. AWS enthält mehrere Tutorials und Dokumentationsthemen, die Sie durch die Erstellung eines Fargate-Dienstes führen, darunter:

In diesem Beispiel wird ein ähnlicher Fargate-Dienst mit dem AWS CDK erstellt.

Das in diesem Beispiel verwendete ECS Amazon-Konstrukt hilft Ihnen bei der Nutzung von AWS Diensten, indem es die folgenden Vorteile bietet:

  • Konfiguriert automatisch einen Load Balancer.

  • Öffnet automatisch eine Sicherheitsgruppe für Load Balancer. Dadurch können Load Balancer mit Instances kommunizieren, ohne explizit eine Sicherheitsgruppe erstellen zu müssen.

  • Ordnet automatisch die Abhängigkeit zwischen dem Service und dem Load Balancer an, der einer Zielgruppe zugeordnet ist. Dabei wird die richtige Reihenfolge bei der Erstellung des Listeners AWS CDK erzwungen, bevor eine Instanz erstellt wird.

  • Konfiguriert automatisch Benutzerdaten für automatisch skalierende Gruppen. Dadurch wird die richtige Konfiguration erstellt, der ein Cluster zugeordnet AMIs werden kann.

  • Validiert Parameterkombinationen frühzeitig. Dadurch werden AWS CloudFormation Probleme früher aufgedeckt, wodurch Bereitstellungszeit gespart wird. Je nach Aufgabe ist es beispielsweise leicht, die Speichereinstellungen falsch zu konfigurieren. Bisher trat kein Fehler auf, bis wir unsere App bereitgestellt hatten. Aber jetzt AWS CDK können sie eine Fehlkonfiguration erkennen und einen Fehler ausgeben, wenn wir unsere App synthetisieren.

  • Fügt automatisch Berechtigungen für Amazon Elastic Container Registry (AmazonECR) hinzu, wenn wir ein Image von Amazon verwendenECR.

  • Skaliert automatisch. Das AWS CDK bietet eine Methode, mit der wir Instances auto skalieren können, wenn wir einen EC2 Amazon-Cluster verwenden. Dies geschieht automatisch, wenn wir eine Instanz in einem Fargate-Cluster verwenden.

    Darüber hinaus AWS CDK verhindert dies, dass eine Instanz gelöscht wird, wenn die automatische Skalierung versucht, eine Instanz zu stoppen, aber entweder eine Aufgabe auf dieser Instanz läuft oder geplant ist.

    Bisher mussten wir eine Lambda-Funktion erstellen, um diese Funktionalität zu haben.

  • Bietet Asset-Support, sodass wir ECS in einem Schritt eine Quelle von unserem Computer für Amazon bereitstellen können. Bisher mussten wir zur Verwendung einer Anwendungsquelle mehrere manuelle Schritte ausführen, z. B. das Hochladen auf Amazon ECR und das Erstellen eines Docker Images.

Wichtig

Die ApplicationLoadBalancedFargateService Konstrukte, die wir verwenden werden, umfassen zahlreiche AWS Komponenten, von denen einige mit nicht unerheblichen Kosten verbunden sind, wenn sie auf unserem AWS Konto bereitgestellt werden, auch wenn wir sie nicht verwenden. Achten Sie darauf, clean up (cdk destroy) zu verwenden, wenn Sie diesem Beispiel folgen.

Erstellen Sie ein CDK Projekt

Wir beginnen mit der Erstellung eines CDK Projekts. Dies ist ein Verzeichnis, in dem unser AWS CDK Code gespeichert ist, einschließlich unserer CDK App.

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

Wir können jetzt das Maven-Projekt in unser IDE importieren.

C#
mkdir MyEcsConstruct
cd MyEcsConstruct
cdk init --language csharp

Wir können jetzt src/MyEcsConstruct.sln in Visual Studio öffnen.

Als Nächstes führen wir die App aus und bestätigen, dass sie einen leeren Stapel erstellt.

cdk synth

Einen Fargate-Dienst erstellen

Es gibt zwei verschiedene Möglichkeiten, wie wir unsere Container-Aufgaben mit Amazon ausführen könnenECS:

  • Verwenden Sie den Fargate Starttyp, bei dem Amazon die physischen Maschinen ECS verwaltet, auf denen unsere Container für uns laufen.

  • Verwenden Sie den EC2 Starttyp, bei dem wir die Verwaltung übernehmen, z. B. die Angabe der automatischen Skalierung.

In diesem Beispiel erstellen wir einen Fargate-Service, der auf einem ECS Amazon-Cluster ausgeführt wird und von einem mit dem Internet verbundenen Application Load Balancer unterstützt wird.

Wir fügen unserer Stack-Datei die folgenden Modulimporte der AWS Construct Library hinzu:

TypeScript

Datei: 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

Datei: 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

Datei: 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

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

Datei: src/MyEcsConstruct/MyEcsConstructStack.cs

using Amazon.CDK.AWS.EC2;
using Amazon.CDK.AWS.ECS;
using Amazon.CDK.AWS.ECS.Patterns;

In unserem Stack fügen wir den folgenden Code hinzu:

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
                }
            );

Als Nächstes validieren wir unseren Code, indem wir Folgendes ausführen, um unseren Stack zu synthetisieren:

cdk synth

Der Stapel besteht aus Hunderten von Zeilen, daher werden wir ihn hier nicht zeigen. Der Stack sollte eine Standardinstanz, ein privates Subnetz und ein öffentliches Subnetz für die drei Availability Zones sowie eine Sicherheitsgruppe enthalten.

Um den Stack bereitzustellen, führen wir Folgendes aus:

cdk deploy

AWS CloudFormation zeigt Informationen zu den Dutzenden von Schritten an, die bei der Bereitstellung unserer App erforderlich sind.

Nach Abschluss der Bereitstellung haben wir erfolgreich einen von Fargate betriebenen ECS Amazon-Service zum Ausführen eines Docker Images erstellt.

Bereinigen

Als allgemeine bewährte Methode zur Wartung und zur Minimierung unnötiger Kosten löschen wir unseren Stack, wenn er abgeschlossen ist:

cdk destroy