Bereitstellen einer Container-Webanwendung auf Amazon ECS

HANDBUCH „ERSTE SCHRITTE“

Modul 2: Infrastruktur erstellen und Anwendung bereitstellen

In diesem Modul erstellen Sie einen ECS-Cluster und stellen Ihre App mit CDK bereit

Einführung

In diesem Modul erstellen Sie eine AWS-CDK-Anwendung, die die gesamte erforderliche Infrastruktur zum Einrichten eines ECS-Clusters erstellt und einen Beispielcontainer darin bereitstellt.

Lerninhalte

  • Erstellen einer einfachen CDK-Anwendung
  • Erstellen eines ECS-Clusters mit Fargate für die Kapazität
  • Erstellen einer Aufgabendefinition und eines Services, um unsere Anwendung bereitzustellen

 Veranschlagte Zeit

15 Minuten

 Voraussetzungen für das Modul

  • AWS-Konto mit Administratorzugriff**
  • Empfohlener Browser: aktuelle Version von Chrome oder Firefox

[**] Innerhalb der letzten 24 Stunden erstellte Konten haben möglicherweise noch keinen Zugriff auf alle für dieses Tutorial erforderlichen Services.

Implementierung

Erstellen der CDK-App

Stellen Sie zunächst sicher, dass CDK installiert ist. Falls dies nicht der Fall ist, folgen Sie bitte dem Leitfaden Erste Schritte mit AWS CDK:

cdk --version

Wir werden nun die CDK-Skelettanwendung mit TypeScript als Sprache unserer Wahl erstellen. Führen Sie den folgenden Befehl in Ihrem Terminal aus:

mkdir cdk-ecs-infra
cd cdk-ecs-infra
cdk init app --language typescript

Es wird Folgendes ausgegeben:

Applying project template app for typescript
# Welcome to your CDK TypeScript project!

This is a blank project for TypeScript development with CDK.

The `cdk.json` file tells the CDK Toolkit how to execute your app.

## Useful commands

 * `npm run build`   compile typescript to js
 * `npm run watch`   watch for changes and compile
 * `npm run test`    perform the jest unit tests
 * `cdk deploy`      deploy this stack to your default AWS account/region
 * `cdk diff`        compare deployed stack with current state
 * `cdk synth`       emits the synthesized CloudFormation template

Executing npm install...
✅ All done!

Erstellen des Codes für den Ressourcen-Stack

Gehen Sie zur Datei /lib/cdk-ecs-infra-stack.ts, in die Sie den Code für den zu erstellenden Ressourcen-Stack schreiben werden.

Ein Ressourcen-Stack ist ein Satz von Cloud-Infrastruktur-Ressourcen (in Ihrem speziellen Fall sind das alle AWS-Ressourcen), die für ein bestimmtes Konto bereitgestellt werden. Das Konto/die Region, in der diese Ressourcen bereitgestellt werden, kann im Stack konfiguriert werden (wie im Leitfaden Erste Schritte mit AWS CDK behandelt.

In diesem Ressourcen-Stack werden Sie die folgenden Ressourcen erstellen:

  • IAM-Rolle: Diese Rolle wird dem Container zugewiesen, damit sie andere AWS-Services aufrufen kann.
  • ECS-Aufgabendefinition: die spezifischen Parameter, die beim Starten des Containers verwendet werden sollen.
  • ECS-Muster für Fargate-Lastenverteilungs-Service: Dies abstrahiert die Komplexität aller Komponenten, die zum Erstellen des Clusters, des Load Balancers und des Service erforderlich sind und konfiguriert alles so, dass es zusammenarbeitet.

Erstellen des ECS-Clusters

Um mit dem Erstellen des ECS-Clusters zu beginnen, müssen Sie zunächst die richtigen Module importieren:

npm i @aws-cdk/aws-s3-assets

Fügen Sie dann in Ihrer Datei lib/cdk-eb-infra-stack.ts die Abhängigkeit oben in der Datei hinzu.

npm i @aws-cdk/aws-ec2 @aws-cdk/aws-ecs @aws-cdk/aws-ecs-patterns @aws-cdk/aws-iam 

Anschließend bearbeiten Sie die Datei lib/cdk-eb-infra-stack.ts, um die Abhängigkeit am Anfang der Datei hinzuzufügen.

import ecs = require('@aws-cdk/aws-ecs'); // Allows working with ECS resources
import ec2 = require('@aws-cdk/aws-ec2'); // Allows working with EC2 and VPC resources
import iam = require('@aws-cdk/aws-iam'); // Allows working with IAM resources
import ecsPatterns = require('@aws-cdk/aws-ecs-patterns') // Helper to create ECS services with loadbalancers, and configure them

Diese Module bieten Zugang zu allen Komponenten, die Sie für die Bereitstellung der Webanwendung benötigen. Der erste Schritt besteht darin, die vorhandene Standard-VPC in Ihrem Konto zu finden, indem Sie den folgenden Code eingeben:

// Look up the default VPC
const vpc = ec2.Vpc.fromLookup(this, "VPC", {
   isDefault: true
});

Als nächstes müssen Sie definieren, welcher Container verwendet werden soll und wie er konfiguriert werden soll. Dies geschieht durch Erstellen einer Aufgabendefinition, um den Container-Port, die benötigte CPU- und Arbeitsspeichermenge sowie das zu verwendende Container-Image bereitzustellen. Für diese Anleitung erstellen wir das mit der Beispielanwendung bereitgestellte Container-Image im Ordner SampleApp und lassen das Erstellen, den Upload und die Bereitstellung des Containers von CDK für uns verwalten. Wir werden auch eine leere IAM-Rolle erstellen, die an die Aufgabendefinition für zukünftige Leitfäden angehängt wird. 

Fügen Sie den folgenden Code hinzu, um die Aufgabendefinition und die IAM-Rolle zu erstellen:

const taskIamRole = new iam.Role(this, "AppRole", {
    roleName: "AppRole",
    assumedBy: new iam.ServicePrincipal('ecs-tasks.amazonaws.com'),
});

const taskDefinition = new ecs.FargateTaskDefinition(this, 'Task', {
    taskRole: taskIamRole,
});

taskDefinition.addContainer('MyContainer', {
    image: ecs.ContainerImage.fromAsset('../SampleApp'),
    portMappings: [{ containerPort: 80 }],
    memoryReservationMiB: 256,
     cpu : 256,
});

Im obigen Code sehen Sie, dass Sie mithilfe von FargateTaskDefintion und mithilfe von ContainerImage.fromAsset ein Aufgabendefinitionstyp für die Bereitstellung in Fargate angegeben haben. CDK erstellt das Container-Image mithilfe des Dockerfiles im SampleApp-Verzeichnis.

Als Nächstes müssen Sie den ECS-Cluster einrichten, einen Service definieren, einen Load Balancer erstellen, ihn für die Verbindung mit dem Service konfigurieren und die erforderlichen Sicherheitsgruppenregeln einrichten. Ein Service in ECS wird verwendet, um eine Aufgabendefinition zu starten, indem die gewünschte Anzahl von Kopien, Bereitstellungsstrategien und andere Konfigurationen angegeben werden. In diesem Beispiel starten wir nur 1 Kopie des Containers. Eine Sicherheitsgruppe fungiert als virtuelle Firewall für Ihre Instance, um den ein- und ausgehenden Datenverkehr zu kontrollieren, aber Sie müssen sie nicht konfigurieren, da das von Ihnen verwendete ECS-Muster dies für Sie erledigt. 

Fügen Sie Ihrem Projekt unter der Aufgabendefinition folgenden Code hinzu:

new ecsPatterns.ApplicationLoadBalancedFargateService(this, "MyApp", {
    vpc: vpc,
    taskDefinition: taskDefinition,
    desiredCount: 1,
    serviceName: 'MyWebApp',
    assignPublicIp: true,
    publicLoadBalancer: true,
})

Sie übergeben das vpc-Objekt, das Sie zuvor nachgeschlagen haben, um anzugeben, wo alle Ressourcen erstellt werden sollen, zusammen mit der Aufgabendefinition, die definiert, welches Container-Image bereitgestellt werden soll. Der desiredCount gibt an, wie viele Kopien Sie möchten, der serviceName wie Sie den Service nennen möchten, und publicLoadBalancer ist auf „wahr“ gesetzt, damit Sie über das Internet darauf zugreifen können. Die Zeile, die assignPublicIp auf „wahr“ setzt, ist in diesem Beispiel wichtig, da wir die Standard-VPC verwenden, die keine privaten Subnetze hat. Die bewährte Methode hier empfiehlt das Starten von Services in privaten Subnetzen, ist jedoch nicht Gegenstand dieses Leitfadens.

Jetzt können Sie die Webanwendung bereitstellen, aber zuerst müssen Sie CDK für das Konto einrichten, für das Sie die Anwendung bereitstellen möchten. 

Bearbeiten Sie die Datei bin/cdk-ecs-infra.ts und heben Sie den Kommentar zu Zeile 14 auf:

env: { account: process.env.CDK_DEFAULT_ACCOUNT, region: process.env.CDK_DEFAULT_REGION },

Dabei werden die in der AWS-CLI konfigurierte Konto-ID und Region verwendet. Bevor Sie CDK nutzen können, muss es gebootstrapped werden. Dadurch wird die erforderliche Infrastruktur für CDK erstellt, um die Infrastruktur in Ihrem Konto zu verwalten. Um CDK zu bootstrappen, führen Sie cdk bootstrap aus. Sie sollten eine Ausgabe ähnlich der folgenden sehen:

cdk bootstrap

#output
⏳  Bootstrapping environment aws://0123456789012/<region>...
✅  Environment aws://0123456789012/<region> bootstrapped

Dadurch wird die erforderliche Infrastruktur für CDK erstellt, um die Infrastruktur in Ihrem Konto zu verwalten. Wir empfehlen, das Handbuch Erste Schritte mit AWS CDK durchzuarbeiten, wenn Sie mit der Einrichtung einer CDK-Anwendung nicht vertraut sind.

Sobald das Bootstrapping abgeschlossen ist, führen Sie cdk deploy aus, um den Container, den Cluster und die gesamte andere erforderliche Infrastruktur bereitzustellen. Sie sollten eine Ausgabe ähnlich der folgenden sehen:

gsg-build-ecs-2

CDK wird Sie vor der Erstellung der Infrastruktur auffordern, da die Erstellung der Infrastruktur die Sicherheitskonfiguration ändert - in Ihrem Fall durch die Erstellung von IAM-Rollen und Sicherheitsgruppen. Drücken Sie y und dann „Enter“ zum Bereitstellen. CDK richtet nun die gesamte von Ihnen definierte Infrastruktur ein. Der Vorgang dauert einige Minuten. 

Während des Einrichtens werden Updates wie diese angezeigt:

gsg-build-ecs-3

Sobald dieser Vorgang abgeschlossen ist, sehen Sie eine Ausgabe mit dem Link zur öffentlichen URL, um wie folgt auf Ihren Service zuzugreifen:

gsg-build-ecs-4

Vollständiges Codebeispiel

import * as cdk from '@aws-cdk/core';
import ecs = require('@aws-cdk/aws-ecs');
import ec2 = require('@aws-cdk/aws-ec2');
import iam = require('@aws-cdk/aws-iam');
import ecsPatterns = require('@aws-cdk/aws-ecs-patterns')

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

      // Look up the default VPC
      const vpc = ec2.Vpc.fromLookup(this, "VPC", {
        isDefault: true
      });

      const taskIamRole = new iam.Role(this, "AppRole", {
        roleName: "AppRole",
        assumedBy: new iam.ServicePrincipal('ecs-tasks.amazonaws.com'),
      });

      const taskDefinition = new ecs.FargateTaskDefinition(this, 'Task', {
        taskRole: taskIamRole,
      });

      taskDefinition.addContainer('MyContainer', {
        image: ecs.ContainerImage.fromAsset('../SampleApp'),
        portMappings: [{ containerPort: 80 }],
        memoryReservationMiB: 256,
        cpu : 256,
      });

      new ecsPatterns.ApplicationLoadBalancedFargateService(this, "MyApp", {
        vpc: vpc,
        taskDefinition: taskDefinition,
        desiredCount: 1,
        serviceName: 'MyWebApp',
        assignPublicIp: true,
        publicLoadBalancer: true,
      })

  }
}

Zusammenfassung

In diesem Modul haben Sie gelernt, wie Sie mithilfe eines von CDK bereitgestellten ECS-Musters einen ECS-Cluster mit einem Load Balancer erstellen, um Datenverkehr für Ihren auf Fargate ausgeführten Container bereitzustellen. Im nächsten Modul bereinigen Sie alle in diesem Handbuch erstellten Ressourcen.

Nächstes Thema: Bereinigen von Ressourcen

Lassen Sie uns wissen, wie wir abgeschnitten haben.

Vielen Dank für Ihr Feedback
Wir freuen uns, dass diese Seite Ihnen geholfen hat. Würden Sie uns weitere Details mitteilen, damit wir uns weiter verbessern können?
Schließen
Vielen Dank für Ihr Feedback
Es tut uns leid, dass diese Seite Ihnen nicht weiterhelfen konnte. Würden Sie uns weitere Details mitteilen, damit wir uns weiter verbessern können?
Schließen