Wählen Sie Ihre Cookie-Einstellungen aus

Wir verwenden essentielle Cookies und ähnliche Tools, die für die Bereitstellung unserer Website und Services erforderlich sind. Wir verwenden Performance-Cookies, um anonyme Statistiken zu sammeln, damit wir verstehen können, wie Kunden unsere Website nutzen, und Verbesserungen vornehmen können. Essentielle Cookies können nicht deaktiviert werden, aber Sie können auf „Anpassen“ oder „Ablehnen“ klicken, um Performance-Cookies abzulehnen.

Wenn Sie damit einverstanden sind, verwenden AWS und zugelassene Drittanbieter auch Cookies, um nützliche Features der Website bereitzustellen, Ihre Präferenzen zu speichern und relevante Inhalte, einschließlich relevanter Werbung, anzuzeigen. Um alle nicht notwendigen Cookies zu akzeptieren oder abzulehnen, klicken Sie auf „Akzeptieren“ oder „Ablehnen“. Um detailliertere Entscheidungen zu treffen, klicken Sie auf „Anpassen“.

Präferenzen
Kontakt
Feedback
AWS Documentation
AWS-Konto erstellen

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

RSS
Fokusmodus
Beispiel: Erstellen Sie einen AWS Fargate Dienst mit dem AWS CDK - AWS Cloud Development Kit (AWS CDK) v2
Erstellen eines CDK-ProjektsEinen Fargate-Dienst erstellenBereinigen

Dies ist der AWS CDK v2-Entwicklerhandbuch. Das ältere CDK v1 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.

Dies ist der AWS CDK v2-Entwicklerhandbuch. Das ältere CDK v1 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.

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

Amazon ECS ist ein hoch skalierbarer, schneller Container-Management-Service, der das Ausführen, Stoppen und Verwalten vereinfacht Docker Container in einem Cluster. Sie können Ihren Cluster auf einer serverlosen Infrastruktur hosten, die von Amazon ECS verwaltet wird, 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 (Amazon EC2) -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 Amazon ECS-Konstrukt hilft Ihnen bei der Nutzung von AWS Services, 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 (Amazon ECR) hinzu, wenn wir ein Image von Amazon ECR verwenden.

  • 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 in einem Schritt eine Quelle von unserem Computer für Amazon ECS 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 Bild.

Wichtig

Die ApplicationLoadBalancedFargateService Konstrukte, die wir verwenden werden, umfassen zahlreiche AWS Komponenten, von denen einige mit nicht unerheblichen Kosten verbunden sind, wenn sie in 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 eines CDK-Projekts

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 das Maven-Projekt jetzt in unsere IDE importieren.

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

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

anchoranchoranchoranchoranchor
mkdir MyEcsConstruct
cd MyEcsConstruct
cdk init --language typescript

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 ECS ausführen können:

  • Verwenden Sie den Fargate Starttyp, bei dem Amazon ECS die physischen Maschinen 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 Amazon ECS-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;
anchoranchoranchoranchoranchor

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

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

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 Amazon ECS-Service für den Betrieb eines Docker Bild.

Bereinigen

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

cdk destroy

Auf dieser Seite

DatenschutzNutzungsbedingungen für die WebsiteCookie-Einstellungen
© 2025, Amazon Web Services, Inc. oder Tochtergesellschaften. Alle Rechte vorbehalten.