Erste Schritte mit Amazon ECS mit AWS CDK - Amazon ECS
Schritt 1: Einrichten des Projekts AWS CDKSchritt 2: Verwenden von AWS CDK, um einen containerisierten Webserver auf Fargate zu definierenSchritt 3: Testen des WebserversSchritt 4: BereinigenNächste Schritte

Erste Schritte mit Amazon ECS mit AWS CDK

In diesem Thema erfahren Sie, wie Sie einen containerisierten Webserver mit Amazon Elastic Container Service und dem AWS Cloud Development Kit (AWS CDK) auf Fargate bereitstellen. AWS CDK ist ein Infrastructure as Code (IAC)-Framework, mit dem Sie AWS-Infrastruktur mit einer vollwertigen Programmiersprache definieren können. Sie schreiben eine App in einer der unterstützten Sprachen des CDK, die einen oder mehrere Stacks enthält, und synthetisieren sie dann in einer AWS CloudFormation-Vorlage und stellen Sie die Ressourcen auf Ihrem AWS-Konto bereit.

Die AWS-Construct Library, die im CDK enthalten ist, stellt APIs bereit, mit denen die Ressourcen modelliert werden, die von jedem AWS-Service angeboten werden. Für die gängigsten Dienste stellt die Bibliothek kuratierte Konstrukte bereit, die intelligente Standardwerte bereitstellen und Best Practices mit weniger erforderlichen Parametern implementieren. Eines dieser Module, aws-ecs-patterns, bietet Abstraktionen auf hoher Ebene, mit denen Sie Ihren containerisierten Service und alle notwendigen unterstützenden Ressourcen in nur wenigen Codezeilen definieren können.

Das Konstrukt, das wir in diesem Thema verwenden werden, ist ApplicationLoadBalancedFargateService. Wie Sie wahrscheinlich aus dem Namen erkennen können, stellt dieses Konstrukt einen Amazon ECS-Dienst auf Fargate hinter einem Application Load Balancer bereit. Das aws-ecs-patterns-Modul enthält auch Konstrukte, die ein Network Load Balancer verwenden und/oder auf Amazon EC2 ausgeführt werden, wenn Sie diese Optionen bevorzugen.

Bevor Sie mit diesem Thema beginnen, richten Sie Ihre AWS CDK-Entwicklungsumgebung ein wie in Erste Schritte mit den AWS CDK-Voraussetzungen beschrieben und installieren Sie dann das AWS CDK durch Ausstellen von:

npm install -g aws-cdk
Anmerkung

Bei dieser Anleitung wird davon ausgegangen, dass Sie das AWS CDK v2 verwenden.

Schritt 1: Einrichten des Projekts AWS CDK

Erstellen Sie ein Verzeichnis für Ihre neue AWS CDK-App und initialisieren Sie das Projekt.

TypeScript
mkdir hello-ecs
cd hello-ecs
cdk init --language typescript
JavaScript
mkdir hello-ecs
cd hello-ecs
cdk init --language javascript
Python
mkdir hello-ecs
cd hello-ecs
cdk init --language python

Nachdem das Projekt initialisiert wurde, aktivieren Sie die virtuelle Umgebung des Projekts und installieren Sie die Baseline-Abhängigkeiten von AWS CDK.

source .venv/bin/activate
python -m pip install -r requirements.txt
Java
mkdir hello-ecs
cd hello-ecs
cdk init --language java

Importieren Sie dieses Maven-Projekt in Ihre Java-IDE (verwenden Sie z. B. in Eclipse Datei > Import > Maven > Vorhandene Maven-Projekte).

C#
mkdir hello-ecs
cd hello-ecs
cdk init --language csharp
Anmerkung

Vergewissern Sie sich, dass Sie das Verzeichnis hello-ecs wie angezeigt benennen. Die AWS CDK-Anwendungsvorlage verwendet den Namen des Projektverzeichnisses, um Namen für Quelldateien und -klassen zu generieren. Wenn Sie einen anderen Namen verwenden, stimmt Ihre App nicht mit diesen Anweisungen überein.

AWS CDK v2 enthält stabile Konstrukte für alle AWS-Services in einem einzigen Paket, genannt aws-cdk-lib. Dieses Paket wird als Abhängigkeit installiert, wenn Sie das Projekt initialisieren (oder in einigen Sprachen beim ersten Entwickeln). In diesem Thema verwenden wir ein Konstrukt von Amazon ECS Patterns, das hochrangige Abstraktionen für die Arbeit mit Amazon ECS bietet. Dieses Modul wiederum stützt sich auf Amazon-ECS-Konstrukte und andere, um die für Ihre Amazon-ECS-Anwendung erforderlichen Ressourcen bereitzustellen.

Die Namen, die Sie zum Importieren dieser Bibliotheken in Ihre CDK-Anwendung verwenden, unterscheiden sich geringfügig, je nachdem, welche Programmiersprache Sie verwenden. Als Referenz finden Sie hier die Namen, die in jeder unterstützten CDK-Programmiersprache verwendet werden.

TypeScript
@aws-cdk-lib/aws-ecs
@aws-cdk-lib/aws-ecs-patterns
JavaScript
@aws-cdk-/aws-ecs
@aws-cdk-lib/aws-ecs-patterns
Python
aws_cdk.aws_ecs
aws_cdk.aws_ecs_patterns
Java
software.amazon.awscdk.services.ecs
software.amazon.awscdk.services.ecs.patterns
C#
Amazon.CDK.AWS.ECS
Amazon.CDK.AWS.ECS.Patterns

Schritt 2: Verwenden von AWS CDK, um einen containerisierten Webserver auf Fargate zu definieren

Wir werden das amazon-ecs-sample-Container-Image aus Docker Hub verwenden. Dieses Bild enthält eine PHP Web App, die unter Amazon Linux 2 läuft.

In dem von Ihnen erstellten AWS CDK-Projekt bearbeiten Sie die Datei, die die Definition des Stapels enthält, so dass sie wie im folgenden Code aussieht. Sie erkennen die Instanziierung des ApplicationLoadBalancedFargateService-Konstrukts oder zumindest seinen Namen.

Anmerkung

Was ist ein Stack? Der Stack ist die Bereitstellungseinheit: Alle Ressourcen müssen sich in einem Stack befinden, und alle Ressourcen in einem Stack werden zusammen bereitgestellt. Wenn eine Ressource nicht bereitgestellt werden kann, werden alle anderen bereits bereitgestellten Ressourcen zurückgesetzt. Eine AWS CDK-App kann mehrere Stacks enthalten und Ressourcen in einem Stack können sich auf Ressourcen in einem anderen beziehen.

TypeScript

Aktualisieren Sie lib/hello-ecs-stack.ts damit darauf folgendes steht.

import * as cdk from '@aws-cdk-lib';
import { Construct } from 'constructs';

import * as ecs from '@aws-cdk-lib/aws-ecs';
import * as ecsp from '@aws-cdk-lib/aws-ecs-patterns';

export class HelloEcsStack extends cdk.Stack {
  constructor(scope: Construct, id: string, props?: cdk.StackProps) {
    super(scope, id, props);

    new ecsp.ApplicationLoadBalancedFargateService(this, 'MyWebServer', {
      taskImageOptions: {
        image: ecs.ContainerImage.fromRegistry('amazon/amazon-ecs-sample'),
      },
      publicLoadBalancer: true
    });
  }
}
JavaScript

Aktualisieren Sie lib/hello-ecs-stack.js damit darauf folgendes steht.

const cdk = require('@aws-cdk-lib');
const { Construct } = require('constructs');

const ecs = require('@aws-cdk-lib/aws-ecs');
const ecsp = require('@aws-cdk-lib/aws-ecs-patterns');

class HelloEcsStack extends cdk.Stack {
  constructor(scope: Construct, id: string, props?: cdk.StackProps) {
    super(scope, id, props);

    new ecsp.ApplicationLoadBalancedFargateService(this, 'MyWebServer', {
      taskImageOptions: {
        image: ecs.ContainerImage.fromRegistry('amazon/amazon-ecs-sample'),
      },
      publicLoadBalancer: true
    });
  }
}

module.exports = { HelloEcsStack }
Python

Aktualisieren Sie hello-ecs/hello_ecs_stack.py damit darauf folgendes steht.

import aws_cdk as cdk
from constructs import Construct

import aws_cdk.aws_ecs as ecs
import aws_cdk.aws_ecs_patterns as ecsp

class HelloEcsStack(cdk.Stack):

    def __init__(self, scope: Construct, construct_id: str, **kwargs) -> None:
        super().__init__(scope, construct_id, **kwargs)

        ecsp.ApplicationLoadBalancedFargateService(self, "MyWebServer",
            task_image_options=ecsp.ApplicationLoadBalancedTaskImageOptions(
                image=ecs.ContainerImage.from_registry("amazon/amazon-ecs-sample")),
            public_load_balancer=True
        )
Java

Aktualisieren Sie src/main/java/com.myorg/HelloEcsStack.java damit darauf folgendes steht.

package com.myorg;

import software.constructs.Construct;
import software.amazon.awscdk.Stack;
import software.amazon.awscdk.StackProps;

import software.amazon.awscdk.services.ecs.ContainerImage;
import software.amazon.awscdk.services.ecs.patterns.ApplicationLoadBalancedFargateService;
import software.amazon.awscdk.services.ecs.patterns.ApplicationLoadBalancedTaskImageOptions;

public class HelloEcsStack extends Stack {
    public HelloEcsStack(final Construct scope, final String id) {
        this(scope, id, null);
    }

    public HelloEcsStack(final Construct scope, final String id, final StackProps props) {
        super(scope, id, props);

        ApplicationLoadBalancedFargateService.Builder.create(this, "MyWebServer")
        	.taskImageOptions(ApplicationLoadBalancedTaskImageOptions.builder()
        			.image(ContainerImage.fromRegistry("amazon/amazon-ecs-sample"))
        			.build())
        	.publicLoadBalancer(true)
        	.build();        
    }
}
C#

Aktualisieren Sie src/HelloEcs/HelloEcsStack.cs damit darauf folgendes steht.

using Amazon.CDK;
using Constructs;

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

namespace HelloEcs
{
    public class HelloEcsStack : Stack
    {
        internal HelloEcsStack(Construct scope, string id, IStackProps props = null) : base(scope, id, props)
        {
            new ApplicationLoadBalancedFargateService(this, "MyWebServer",
                new ApplicationLoadBalancedFargateServiceProps
                {
                    TaskImageOptions = new ApplicationLoadBalancedTaskImageOptions
                    {
                        Image = ContainerImage.FromRegistry("amazon/amazon-ecs-sample")
                    },
                    PublicLoadBalancer = true
                });
        }
    }
}

Sie können in diesem kurzen Snippet sehen:

  • Der logische Name des Dienstes, MyWebServer.

  • Das Container-Image, erhalten von DockerHub, amazon/amazon-ecs-sample..

  • Die Tatsache, dass der Load Balancer eine öffentliche Adresse hat und somit über das Internet zugänglich sein wird.

Wenn Sie, wie wir hier getan haben, den Amazon ECS-Cluster, die zugrunde liegenden Amazon Virtual Private Cloud- und Amazon-EC2-Instances, eine Auto-Scaling-Gruppe, den Application Load Balancer, die erforderlichen IAM-Rollen und -Richtlinien und andere AWS-Ressourcen auslassen, die für die Bereitstellung des Webservers erforderlich sind, wird AWS CDK auch diese Ressourcen erstellen. Einige automatisch bereitgestellte Ressourcen werden von allen Amazon ECS-Diensten freigegeben, die im Stack definiert sind.

Speichern Sie die Quelldatei, und geben Sie cdk synth im Hauptverzeichnis der App heraus. AWS CDK führt die App aus und synthetisiert eine AWS CloudFormation-Vorlage aus ihr und zeigt dann die Vorlage an. Die Vorlage ist etwa 600 Zeilen YAML, daher wird hier nur der Anfang angezeigt. (Ihre Vorlage kann Unterschiede zu unserer haben.)


Resources:
  MyWebServerLB3B5FD3AB:
    Type: AWS::ElasticLoadBalancingV2::LoadBalancer
    Properties:
      LoadBalancerAttributes:
        - Key: deletion_protection.enabled
          Value: "false"
      Scheme: internet-facing
      SecurityGroups:
        - Fn::GetAtt:
            - MyWebServerLBSecurityGroup01B285AA
            - GroupId
      Subnets:
        - Ref: EcsDefaultClusterMnL3mNNYNVpcPublicSubnet1Subnet3C273B99
        - Ref: EcsDefaultClusterMnL3mNNYNVpcPublicSubnet2Subnet95FF715A
      Type: application
    DependsOn:
      - EcsDefaultClusterMnL3mNNYNVpcPublicSubnet1DefaultRouteFF4E2178
      - EcsDefaultClusterMnL3mNNYNVpcPublicSubnet2DefaultRouteB1375520
    Metadata:
      aws:cdk:path: HelloEcsStack/MyWebServer/LB/Resource
  MyWebServerLBSecurityGroup01B285AA:
    Type: AWS::EC2::SecurityGroup
    Properties:
      GroupDescription: Automatically created Security Group for ELB HelloEcsStackMyWebServerLB06757F57
      SecurityGroupIngress:
        - CidrIp: 0.0.0.0/0
          Description: Allow from anyone on port 80
          FromPort: 80
          IpProtocol: tcp
          ToPort: 80
      VpcId:
        Ref: EcsDefaultClusterMnL3mNNYNVpc7788A521
    Metadata:
      aws:cdk:path: HelloEcsStack/MyWebServer/LB/SecurityGroup/Resource
# and so on for another few hundred lines

Um den Dienst tatsächlich in Ihrem AWS-Konto bereitzustellen, geben Sie cdk deploy heraus. Sie werden aufgefordert, die IAM-Richtlinien zu genehmigen, die AWS CDK generiert hat.

Die Bereitstellung wird einige Minuten dauern. Sie werden sehen, dass AWS CDK eine ganze Reihe von Ressourcen erstellt. Die letzten Zeilen der Ausgabe der Bereitstellung enthalten den öffentlichen Hostnamen des Load Balancers und eine HTTP-URL für den neuen Webserver.

Outputs:
HelloEcsStack.MyWebServerLoadBalancerDNSXXXXXXX = Hello-MyWeb-ZZZZZZZZZZZZZ-ZZZZZZZZZZ.us-west-2.elb.amazonaws.com
HelloEcsStack.MyWebServerServiceURLYYYYYYYY = http://Hello-MyWeb-ZZZZZZZZZZZZZ-ZZZZZZZZZZ.us-west-2.elb.amazonaws.com

Schritt 3: Testen des Webservers

Kopieren Sie die URL aus der Bereitstellungsausgabe und fügen Sie sie in Ihren Webbrowser ein. Sie sollten eine Begrüßungsnachricht vom Webserver sehen.

Schritt 4: Bereinigen

Jetzt, da Sie mit dem Webserver fertig sind (er macht nichts außer der Anzeige der Glückwunschmeldung), können Sie den Service mit dem CDK abreißen. Geben Sie cdk destroy im Hauptverzeichnis Ihrer App heraus. Dies verhindert unbeabsichtigte AWS-Gebühren.

Nächste Schritte

Weitere Informationen über die Entwicklung der AWS-Infrastruktur unter Verwendung von AWS CDK finden Sie im AWS CDK-Entwicklerhandbuch.

Informationen zum Schreiben von AWS CDK-Apps in der Sprache Ihrer Wahl finden Sie unter:

TypeScript

Arbeiten mit AWS CDK in TypeScript

JavaScript

Arbeiten mit AWS CDK in JavaScript

Python

Arbeiten mit AWS CDK in Python

Java

Arbeiten mit AWS CDK in Java

C#

Arbeiten mit AWS CDK in C#

Weitere Informationen über die Module der AWS Construct Library, die in diesem Thema verwendet werden, finden Sie im den Übersichten aus der AWS CDK-API-Referenz unten.