Tutorial: Bereitstellen einer Anwendung in Amazon ECS - Amazon CodeCatalyst
VoraussetzungenSchritt 1: Richten Sie einen AWS Benutzer ein und AWS CloudShellSchritt 2: Stellen Sie eine Platzhalteranwendung in Amazon ECS bereitSchritt 3: Erstellen Sie ein Amazon ECR-Image-RepositorySchritt 4: Rollen erstellen, erstellen und bereitstellenSchritt 5: AWS Rollen hinzufügen zu CodeCatalystSchritt 6: Erstellen Sie ein Quell-RepositorySchritt 7: Quelldateien hinzufügenSchritt 8: Einen Workflow erstellen und ausführenSchritt 9: Nehmen Sie eine Änderung an Ihren Quelldateien vorBereinigen

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.

Tutorial: Bereitstellen einer Anwendung in Amazon ECS

In diesem Tutorial erfahren Sie, wie Sie mithilfe eines Workflows, Amazon ECS und einiger anderer AWS Services eine serverlose Anwendung in Amazon Elastic Container Service (Amazon ECS) bereitstellen. Bei der bereitgestellten Anwendung handelt es sich um eine einfache Hello World-Website, die auf einem Docker-Image des Apache-Webservers basiert. Das Tutorial führt Sie durch die erforderlichen Vorbereitungsarbeiten, z. B. die Einrichtung eines Clusters, und beschreibt anschließend, wie Sie einen Workflow für die Erstellung und Bereitstellung der Anwendung erstellen.

Tipp

Anstatt sich durch dieses Tutorial zu arbeiten, können Sie einen Blueprint verwenden, der ein vollständiges Amazon ECS-Setup für Sie durchführt. Sie müssen entweder die Node.js API mit AWS Fargate oder die Java API mit AWS Fargate Blueprint verwenden. Weitere Informationen finden Sie unter Ein Projekt mit einem Blueprint erstellen.

Voraussetzungen

Bevor Sie beginnen:

  • Sie benötigen einen CodeCatalyst Bereich mit einem verbundenen AWS Konto. Weitere Informationen finden Sie unter Einen Raum schaffen.

  • In deinem Space benötigst du ein leeres CodeCatalyst Projekt mit dem Namen:

    codecatalyst-ecs-project

    Weitere Informationen finden Sie unter Ein leeres Projekt in Amazon erstellen CodeCatalyst.

  • In Ihrem Projekt benötigen Sie eine CodeCatalyst Umgebung namens:

    codecatalyst-ecs-environment

    Konfigurieren Sie diese Umgebung wie folgt:

    • Wählen Sie einen beliebigen Typ aus, z. B. „Keine Produktion“.

    • Connect dein AWS Konto damit.

    • Wählen Sie für die Standard-IAM-Rolle eine beliebige Rolle aus. Sie werden später eine andere Rolle angeben.

    Weitere Informationen finden Sie unter Bereitstellung in AWS-Konten und VPCs mit Umgebungen CodeCatalyst.

Schritt 1: Richten Sie einen AWS Benutzer ein und AWS CloudShell

Der erste Schritt in diesem Tutorial besteht darin AWS IAM Identity Center, einen Benutzer zu erstellen und eine AWS CloudShell Instanz als dieser Benutzer zu starten. Für die Dauer dieses Tutorials CloudShell ist dies Ihr Entwicklungscomputer, auf dem Sie AWS Ressourcen und Dienste konfigurieren. Löschen Sie diesen Benutzer, nachdem Sie das Tutorial abgeschlossen haben.

Anmerkung

Verwenden Sie für dieses Tutorial nicht Ihren Root-Benutzer. Sie müssen einen separaten Benutzer erstellen, da sonst später Probleme bei der Ausführung von Aktionen in der AWS Command Line Interface (CLI) auftreten können.

Weitere Informationen zu IAM Identity Center-Benutzern finden Sie im AWS IAM Identity Center Benutzerhandbuch und im AWS CloudShell Benutzerhandbuch. CloudShell

So erstellen Sie einen IAM Identity Center-Benutzer

  1. Melden Sie sich bei der an AWS Management Console und öffnen Sie die AWS IAM Identity Center Konsole unter https://console.aws.amazon.com/singlesignon/.

    Anmerkung

    Stellen Sie sicher, dass Sie sich mit dem anmelden AWS-Konto , der mit Ihrem CodeCatalyst Bereich verbunden ist. Sie können überprüfen, welches Konto verbunden ist, indem Sie zu Ihrem Bereich navigieren und den Tab AWS-Konten auswählen. Weitere Informationen finden Sie unter Einen Raum schaffen.

  2. Wählen Sie im Navigationsbereich Users (Benutzer) und dann Add User (Benutzer hinzufügen) aus.

  3. Geben Sie im Feld Nutzername Folgendes ein:

    CodeCatalystECSUser

  4. Wählen Sie unter Passwort die Option Einmalpasswort generieren aus, das Sie mit diesem Benutzer teilen können.

  5. Geben Sie in den Feldern E-Mail-Adresse und E-Mail-Adresse bestätigen eine E-Mail-Adresse ein, die noch nicht in IAM Identity Center existiert.

  6. Geben Sie in die Felder Vorname und Nachname Folgendes ein:

    CodeCatalystECSUser

  7. Behalten Sie im Feld Anzeigename den automatisch generierten Namen bei:

    CodeCatalystECSUser CodeCatalystECSUser

  8. Wählen Sie Weiter aus.

  9. Wählen Sie auf der Seite Benutzer zu Gruppen hinzufügen die Option Weiter aus.

  10. Überprüfen Sie auf der Seite Benutzer überprüfen und hinzufügen die Informationen und wählen Sie Benutzer hinzufügen aus.

    Ein Dialogfeld mit einem Einmalkennwort wird angezeigt.

  11. Wählen Sie Kopieren und fügen Sie dann die Anmeldeinformationen ein, einschließlich der URL des AWS Zugriffsportals und des Einmalkennworts.

  12. Klicken Sie auf Schließen.

So erstellen Sie einen Berechtigungssatz

Sie weisen diesen Berechtigungssatz einem CodeCatalystECSUser späteren Zeitpunkt zu.

  1. Wählen Sie im Navigationsbereich die Option Berechtigungssätze und dann Berechtigungssatz erstellen aus.

  2. Wählen Sie Vordefinierter Berechtigungssatz und dann aus AdministratorAccess. Diese Richtlinie gewährt allen volle Berechtigungen AWS-Services.

  3. Wählen Sie Weiter aus.

  4. Geben Sie im Feld Name des Berechtigungssatzes Folgendes ein:

    CodeCatalystECSPermissionSet

  5. Wählen Sie Weiter aus.

  6. Überprüfen Sie auf der Seite Überprüfen und erstellen die Informationen und wählen Sie Erstellen aus.

Um den Berechtigungssatz CodeCatalyst ecsUser zuzuweisen

  1. Wählen Sie im Navigationsbereich das Kontrollkästchen neben dem aus AWS-Konten, bei dem Sie derzeit angemeldet sind AWS-Konto , und aktivieren Sie es anschließend.

  2. Wählen Sie Benutzer oder Gruppen zuweisen aus.

  3. Wählen Sie die Registerkarte Users.

  4. Aktivieren Sie das Kontrollkästchen nebenCodeCatalystECSUser.

  5. Wählen Sie Weiter aus.

  6. Aktivieren Sie das Kontrollkästchen nebenCodeCatalystECSPermissionSet.

  7. Wählen Sie Weiter aus.

  8. Überprüfen Sie die Informationen und wählen Sie Senden aus.

    Sie haben sie nun CodeCatalystECSPermissionSet zugewiesen CodeCatalystECSUser und an Sie AWS-Konto gebunden.

Um sich ab- und wieder als CodeCatalyst ecsUser anzumelden

  1. Bevor Sie sich abmelden, stellen Sie sicher, dass Sie die URL des AWS Zugriffsportals sowie den Benutzernamen und das Einmalpasswort für haben. CodeCatalystECSUser Sie hätten diese Informationen früher in einen Texteditor kopieren sollen.

    Anmerkung

    Wenn Ihnen diese Informationen nicht vorliegen, rufen Sie die CodeCatalystECSUser Detailseite im IAM Identity Center auf und wählen Sie Passwort zurücksetzen, Einmalpasswort generieren [...] , und klicken Sie erneut auf Passwort zurücksetzen, um die Informationen auf dem Bildschirm anzuzeigen.

  2. Melden Sie sich ab AWS.

  3. Fügen Sie die URL des AWS Zugangsportals in die Adressleiste Ihres Browsers ein.

  4. Melden Sie sich mit dem Benutzernamen und dem Einmalpasswort für anCodeCatalystECSUser.

  5. Geben Sie unter Neues Passwort ein Passwort ein und wählen Sie Neues Passwort festlegen aus.

    Auf dem Bildschirm erscheint ein AWS-KontoFeld.

  6. Wählen Sie AWS-Kontound wählen Sie dann den Namen des Benutzers und des AWS-Konto Berechtigungssatzes aus, dem Sie den CodeCatalystECSUser Benutzer zugewiesen haben.

  7. Wählen Sie neben dem CodeCatalystECSPermissionSet die Option Verwaltungskonsole aus.

    Das AWS Management Console erscheint. Sie sind jetzt CodeCatalystECSUser mit den entsprechenden Berechtigungen angemeldet.

Um eine AWS CloudShell Instance zu starten

  1. Wählen Sie wie CodeCatalystECSUser in der oberen Navigationsleiste das AWS Symbol ( AWS icon ).

    Die Hauptseite von wird AWS Management Console angezeigt.

  2. Wählen Sie in der oberen Navigationsleiste das AWS CloudShell Symbol ( CloudShell icon ).

    CloudShell öffnet. Warten Sie, bis die CloudShell Umgebung erstellt ist.

    Anmerkung

    Wenn Sie das CloudShell Symbol nicht sehen, vergewissern Sie sich, dass Sie sich in einer Region befinden, die von unterstützt wird CloudShell. In diesem Tutorial wird davon ausgegangen, dass Sie sich in der Region USA West (Oregon) befinden.

Um zu überprüfen, ob der installiert AWS CLI ist

  1. Geben Sie im CloudShell Terminal Folgendes ein:

    aws --version

  2. Vergewissern Sie sich, dass eine Version angezeigt wird.

    Der AWS CLI ist bereits für den aktuellen Benutzer konfiguriertCodeCatalystECSUser, sodass keine AWS CLI Schlüssel und Anmeldeinformationen konfiguriert werden müssen, wie dies normalerweise der Fall ist.

Schritt 2: Stellen Sie eine Platzhalteranwendung in Amazon ECS bereit

In diesem Abschnitt stellen Sie manuell eine Platzhalteranwendung in Amazon ECS bereit. Diese Platzhalteranwendung wird durch die Hello World-Anwendung ersetzt, die in Ihrem Workflow bereitgestellt wird. Die Platzhalteranwendung ist Apache Web Server.

Weitere Informationen zu Amazon ECS finden Sie im Amazon Elastic Container Service Developer Guide.

Führen Sie die folgenden Schritte durch, um die Platzhalteranwendung bereitzustellen.

Um die Rolle zur Aufgabenausführung zu erstellen

Diese Rolle gewährt Amazon ECS die AWS Fargate (Fargate) Erlaubnis, API-Aufrufe in Ihrem Namen durchzuführen.

  1. Erstellen Sie eine Vertrauensrichtlinie:

    1. Geben Sie in AWS CloudShell den folgenden Befehl ein:

      cat > codecatalyst-ecs-trust-policy.json

      Im CloudShell Terminal erscheint eine blinkende Aufforderung.

    2. Geben Sie an der Eingabeaufforderung den folgenden Code ein:

      {
  "Version": "2012-10-17",
  "Statement": [
    {
      "Sid": "",
      "Effect": "Allow",
      "Principal": {
        "Service": "ecs-tasks.amazonaws.com"
      },
      "Action": "sts:AssumeRole"
    }
  ]
}

    3. Platzieren Sie den Cursor hinter der letzten geschweiften Klammer (}).

    4. Drücken Sie dann Enter undCtrl+d, um die Datei zu speichern und cat zu beenden.

  2. Erstellen Sie eine Rolle zur Aufgabenausführung:

    aws iam create-role \
      --role-name codecatalyst-ecs-task-execution-role \
      --assume-role-policy-document file://codecatalyst-ecs-trust-policy.json

  3. Hängen Sie die AWS verwaltete AmazonECSTaskExecutionRolePolicy Richtlinie an die Rolle an:

    aws iam attach-role-policy \
      --role-name codecatalyst-ecs-task-execution-role \
      --policy-arn arn:aws:iam::aws:policy/service-role/AmazonECSTaskExecutionRolePolicy

  4. Die Details der Rolle anzeigen:

    aws iam get-role \
      --role-name codecatalyst-ecs-task-execution-role

  5. Notieren Sie sich den "Arn": Wert der Rolle, zum Beispielarn:aws:iam::111122223333:role/codecatalyst-ecs-task-execution-role. Sie benötigen diesen Amazon-Ressourcennamen (ARN) später.

Erstellen eines Amazon ECS-Clusters

Dieser Cluster wird die Apache-Platzhalteranwendung und später die Hello World-Anwendung enthalten.

  1. Wie in CodeCatalystECSUser AWS CloudShell, erstellen Sie einen leeren Cluster:

    aws ecs create-cluster --cluster-name codecatalyst-ecs-cluster

  2. (Optional) Stellen Sie sicher, dass der Cluster erfolgreich erstellt wurde:

    aws ecs list-clusters

    Der ARN des codecatalyst-ecs-cluster Clusters sollte in der Liste erscheinen, was auf eine erfolgreiche Erstellung hinweist.

Um eine Aufgabendefinitionsdatei zu erstellen

Die Aufgabendefinitionsdatei gibt an, dass das Docker-Image (httpd:2.4) des Apache 2.4-Webservers ausgeführt werden soll, von DockerHub dem abgerufen wird.

  1. Wie in CodeCatalystECSUser AWS CloudShell, erstellen Sie eine Aufgabendefinitionsdatei:

    cat > taskdef.json

  2. Fügen Sie den folgenden Code an der Eingabeaufforderung ein:

    {
    "executionRoleArn": "arn:aws:iam::111122223333:role/codecatalyst-ecs-task-execution-role",
    "containerDefinitions": [
        {
            "name": "codecatalyst-ecs-container",
            "image": "httpd:2.4",
            "essential": true,
            "portMappings": [
                {
                    "hostPort": 80,
                    "protocol": "tcp",
                    "containerPort": 80
                }
            ]
        }
    ],
    "requiresCompatibilities": [
        "FARGATE"
    ],
    "cpu": "256",
    "family": "codecatalyst-ecs-task-def",
    "memory": "512",
    "networkMode": "awsvpc"
}

    Ersetzen Sie im vorherigen Code arn:aws:iam: :111122223333:role/ -role codecatalyst-ecs-task-execution

    mit dem ARN der Aufgabenausführungsrolle, die Sie notiert habenUm die Rolle zur Aufgabenausführung zu erstellen.

  3. Platzieren Sie den Cursor hinter der letzten geschweiften Klammer (}).

  4. Drücken Sie dann Enter undCtrl+d, um die Datei zu speichern und cat zu beenden.

Um die Aufgabendefinitionsdatei bei Amazon ECS zu registrieren

  1. Wie in CodeCatalystECSUser AWS CloudShell, registrieren Sie die Aufgabendefinition:

    aws ecs register-task-definition \
    --cli-input-json file://taskdef.json

  2. (Optional) Stellen Sie sicher, dass die Aufgabendefinition registriert wurde:

    aws ecs list-task-definitions

    Die codecatalyst-ecs-task-def Aufgabendefinition sollte in der Liste erscheinen.

Um den Amazon ECS-Service zu erstellen

Der Amazon ECS-Service führt die Aufgaben (und die zugehörigen Docker-Container) der Apache-Platzhalteranwendung und später der Hello World-Anwendung aus.

  1. Wechseln Sie außerdem zur Amazon Elastic Container Service-Konsole, falls Sie dies noch nicht getan haben. CodeCatalystECSUser

  2. Wählen Sie den Cluster aus, den Sie zuvor erstellt haben,codecatalyst-ecs-cluster.

  3. Wählen Sie auf der Registerkarte Dienste die Option Erstellen aus.

  4. Gehen Sie auf der Seite Erstellen wie folgt vor:

    1. Behalten Sie alle Standardeinstellungen mit Ausnahme der im Folgenden aufgeführten bei.

    2. Wählen Sie unter Launch type (Starttyp) FARGATE aus.

    3. Wählen Sie unter Aufgabendefinition in der Dropdownliste Familie die folgenden Optionen aus:

      codecatalyst-ecs-task-def

    4. Geben Sie als Dienstname Folgendes ein:

      codecatalyst-ecs-service

    5. Geben Sie für Gewünschte Aufgaben Folgendes ein:

      3

      In diesem Tutorial startet jede Aufgabe einen einzelnen Docker-Container.

    6. Erweitern Sie den Bereich Netzwerk.

    7. Wählen Sie für VPC eine beliebige VPC aus.

    8. Wählen Sie für Subnetze ein beliebiges Subnetz aus.

      Anmerkung

      Geben Sie nur ein Subnetz an. Das ist alles, was für dieses Tutorial benötigt wird.

      Anmerkung

      Wenn Sie keine VPC und kein Subnetz haben, erstellen Sie sie. Weitere Informationen finden Sie unter Erstellen einer VPC und Erstellen eines Subnetzes in Ihrer VPC im Amazon VPC-Benutzerhandbuch.

    9. Wählen Sie für Sicherheitsgruppe die Option Create a new security group aus und gehen Sie dann wie folgt vor:

      1. Geben Sie als Namen der Sicherheitsgruppe Folgendes ein:

        codecatalyst-ecs-security-group

      2. Geben Sie als Beschreibung der Sicherheitsgruppe Folgendes ein:

        CodeCatalyst ECS security group

      3. Wählen Sie Regel hinzufügen aus. Wählen Sie für Typ die Option HTTP und für Quelle die Option Anywhere aus.

    10. Wählen Sie unten Create aus.

    11. Warten Sie, bis der Dienst erstellt wurde. Dies kann einige Minuten dauern.

  5. Wählen Sie die Registerkarte Aufgaben und dann die Schaltfläche „Aktualisieren“. Vergewissern Sie sich, dass die Spalte Letzter Status für alle drei Aufgaben auf Wird ausgeführt gesetzt ist.

(Optional) Um zu überprüfen, ob Ihre Apache-Platzhalteranwendung ausgeführt wird

  1. Wählen Sie auf der Registerkarte Aufgaben eine der drei Aufgaben aus.

  2. Wählen Sie im Feld Öffentliche IP die Option Open Address aus.

    Eine It Works! Seite wird angezeigt. Dies weist darauf hin, dass der Amazon ECS-Service erfolgreich eine Aufgabe gestartet hat, die einen Docker-Container mit dem Apache-Image gestartet hat.

    An dieser Stelle des Tutorials haben Sie manuell einen Amazon ECS-Cluster, eine Service- und Aufgabendefinition sowie eine Apache-Platzhalteranwendung bereitgestellt. Nachdem Sie all diese Elemente eingerichtet haben, sind Sie nun bereit, einen Workflow zu erstellen, der die Apache-Platzhalteranwendung durch die Hello World-Anwendung des Tutorials ersetzt.

Schritt 3: Erstellen Sie ein Amazon ECR-Image-Repository

In diesem Abschnitt erstellen Sie ein privates Image-Repository in Amazon Elastic Container Registry (Amazon ECR). In diesem Repository wird das Docker-Image des Tutorials gespeichert, das das zuvor bereitgestellte Apache-Platzhalter-Image ersetzt.

Weitere Informationen zu Amazon ECR finden Sie im Amazon Elastic Container Registry User Guide.

Um ein Bild-Repository in Amazon ECR zu erstellen

  1. Wie in CodeCatalystECSUser AWS CloudShell, ein leeres Repository in Amazon ECR erstellen:

    aws ecr create-repository --repository-name codecatalyst-ecs-image-repo

  2. Zeigen Sie die Details des Amazon ECR-Repositorys an:

    aws ecr describe-repositories \
      --repository-names codecatalyst-ecs-image-repo

  3. Notieren Sie sich den “repositoryUri”: Wert, zum Beispiel. 111122223333.dkr.ecr.us-west-2.amazonaws.com/codecatalyst-ecs-image-repo

    Sie benötigen ihn später, wenn Sie das Repository zu Ihrem Workflow hinzufügen.

Schritt 4: AWS Rollen erstellen

In diesem Abschnitt erstellen Sie AWS IAM-Rollen, die Ihr CodeCatalyst Workflow benötigt, um zu funktionieren. Diese Rollen sind:

  • Build-Rolle — Erteilt der CodeCatalyst Build-Aktion (im Workflow) die Berechtigung, auf Ihr AWS Konto zuzugreifen und in Amazon ECR und Amazon EC2 zu schreiben.

  • Rolle bereitstellen — Erteilt der Aktion CodeCatalyst Deploy to ECS (im Workflow) die Berechtigung, auf Ihr AWS Konto, Amazon ECS und einige andere AWS Services zuzugreifen.

Weitere Informationen zu IAM-Rollen finden Sie unter IAM-Rollen im AWS Identity and Access Management Benutzerhandbuch.

Anmerkung

Um Zeit zu sparen, können Sie anstelle der beiden zuvor aufgeführten Rollen eine einzelne CodeCatalystWorkflowDevelopmentRole-spaceName Rolle, die so genannte Rolle, erstellen. Weitere Informationen finden Sie unter Die CodeCatalystWorkflowDevelopmentRole-spaceNameRolle für Ihr Konto und Ihren Bereich erstellen. Beachten Sie, dass die CodeCatalystWorkflowDevelopmentRole-spaceName Rolle über sehr umfangreiche Berechtigungen verfügt, was ein Sicherheitsrisiko darstellen kann. Wir empfehlen, diese Rolle nur in Tutorials und Szenarien zu verwenden, in denen die Sicherheit weniger wichtig ist. In diesem Tutorial wird davon ausgegangen, dass Sie die beiden zuvor aufgeführten Rollen erstellen.

Um die Build- und Deploy-Rollen zu erstellen, können Sie entweder die AWS Management Console oder die verwenden AWS CLI.

AWS Management Console

Gehen Sie wie folgt vor, um die Build- und Deploy-Rollen zu erstellen.

Um eine Build-Rolle zu erstellen

  1. Erstellen Sie wie folgt eine Richtlinie für die Rolle:

    1. Melden Sie sich an bei AWS.

    2. Öffnen Sie die IAM-Konsole unter https://console.aws.amazon.com/iam/.

    3. Wählen Sie im Navigationsbereich Policies aus.

    4. Wählen Sie Richtlinie erstellen aus.

    5. Wählen Sie den Tab JSON.

    6. Löschen Sie den vorhandenen Code.

    7. Fügen Sie folgenden Code ein:

      {
    "Version": "2012-10-17",
    "Statement": [
        {
            "Effect": "Allow",
            "Action": [
                "ecr:*",
                "ec2:*"
            ],
            "Resource": "*"
        }
    ]
}
      Anmerkung

      Wenn die Rolle zum ersten Mal zum Ausführen von Workflow-Aktionen verwendet wird, verwenden Sie den Platzhalter in der Ressourcenrichtlinien-Anweisung und grenzen Sie dann die Richtlinie mit dem Ressourcennamen ab, sobald sie verfügbar ist.

      "Resource": "*"

    8. Wählen Sie Next: Tags (Weiter: Tags) aus.

    9. Klicken Sie auf Weiter: Prüfen.

    10. Geben Sie im Feld Name Folgendes ein:

      codecatalyst-ecs-build-policy

    11. Wählen Sie Richtlinie erstellen aus.

      Sie haben jetzt eine Berechtigungsrichtlinie erstellt.

  2. Erstellen Sie die Build-Rolle wie folgt:

    1. Wählen Sie im Navigationsbereich Roles (Rollen) und dann Create role (Rolle erstellen).

    2. Wählen Sie Benutzerdefinierte Vertrauensrichtlinie.

    3. Löschen Sie die bestehende benutzerdefinierte Vertrauensrichtlinie.

    4. Fügen Sie die folgende benutzerdefinierte Vertrauensrichtlinie hinzu:

      {
    "Version": "2012-10-17",
    "Statement": [
        {
            "Sid": "",
            "Effect": "Allow",
            "Principal": {
                "Service":  [
                   "codecatalyst-runner.amazonaws.com",
                   "codecatalyst.amazonaws.com"
                 ]
            },
            "Action": "sts:AssumeRole"
        }
    ]
}

    5. Wählen Sie Weiter aus.

    6. Suchen Sie unter Berechtigungsrichtlinien nach codecatalyst-ecs-build-policy und aktivieren Sie das entsprechende Kontrollkästchen.

    7. Wählen Sie Weiter aus.

    8. Geben Sie als Rollenname Folgendes ein:

      codecatalyst-ecs-build-role

    9. Geben Sie als Rollenbeschreibung Folgendes ein:

      CodeCatalyst ECS build role

    10. Wählen Sie Rolle erstellen aus.

    Sie haben jetzt eine Build-Rolle mit einer Berechtigungsrichtlinie und einer Vertrauensrichtlinie erstellt.

  3. Besorgen Sie sich den ARN für die Build-Rolle wie folgt:

    1. Wählen Sie im Navigationsbereich Rollen aus.

    2. Geben Sie im Suchfeld den Namen der Rolle ein, die Sie gerade erstellt haben (codecatalyst-ecs-build-role).

    3. Wählen Sie die Rolle aus der Liste aus.

      Die Übersichtsseite der Rolle wird angezeigt.

    4. Kopieren Sie oben den ARN-Wert. Sie benötigen sie später.

Um eine Bereitstellungsrolle zu erstellen

  1. Erstellen Sie wie folgt eine Richtlinie für die Rolle:

    1. Melden Sie sich an bei AWS.

    2. Öffnen Sie die IAM-Konsole unter https://console.aws.amazon.com/iam/.

    3. Wählen Sie im Navigationsbereich Policies aus.

    4. Wählen Sie Richtlinie erstellen aus.

    5. Wählen Sie den Tab JSON.

    6. Löschen Sie den vorhandenen Code.

    7. Fügen Sie folgenden Code ein:

      {
    "Version": "2012-10-17",
    "Statement": [{
    "Action":[
      "ecs:DescribeServices",
      "ecs:CreateTaskSet",
      "ecs:DeleteTaskSet",
      "ecs:ListClusters",
      "ecs:RegisterTaskDefinition",
      "ecs:UpdateServicePrimaryTaskSet",
      "ecs:UpdateService",
      "elasticloadbalancing:DescribeTargetGroups",
      "elasticloadbalancing:DescribeListeners",
      "elasticloadbalancing:ModifyListener",
      "elasticloadbalancing:DescribeRules",
      "elasticloadbalancing:ModifyRule",
      "lambda:InvokeFunction",
      "lambda:ListFunctions",
      "cloudwatch:DescribeAlarms",
      "sns:Publish",
      "sns:ListTopics", 
      "s3:GetObject",
      "s3:GetObjectVersion",
      "codedeploy:CreateApplication", 
      "codedeploy:CreateDeployment", 
      "codedeploy:CreateDeploymentGroup", 
      "codedeploy:GetApplication", 
      "codedeploy:GetDeployment", 
      "codedeploy:GetDeploymentGroup", 
      "codedeploy:ListApplications", 
      "codedeploy:ListDeploymentGroups", 
      "codedeploy:ListDeployments", 
      "codedeploy:StopDeployment", 
      "codedeploy:GetDeploymentTarget", 
      "codedeploy:ListDeploymentTargets", 
      "codedeploy:GetDeploymentConfig", 
      "codedeploy:GetApplicationRevision", 
      "codedeploy:RegisterApplicationRevision", 
      "codedeploy:BatchGetApplicationRevisions", 
      "codedeploy:BatchGetDeploymentGroups", 
      "codedeploy:BatchGetDeployments", 
      "codedeploy:BatchGetApplications", 
      "codedeploy:ListApplicationRevisions", 
      "codedeploy:ListDeploymentConfigs", 
      "codedeploy:ContinueDeployment"           
   ],
   "Resource":"*",
   "Effect":"Allow"
},{"Action":[
      "iam:PassRole"
   ],
   "Effect":"Allow",
   "Resource":"*",
   "Condition":{"StringLike":{"iam:PassedToService":[
            "ecs-tasks.amazonaws.com",
            "codedeploy.amazonaws.com"
         ]
      }
   }
}]
}
      Anmerkung

      Wenn die Rolle zum ersten Mal zum Ausführen von Workflow-Aktionen verwendet wird, verwenden Sie den Platzhalter in der Ressourcenrichtlinien-Anweisung. Sie können die Richtlinie dann anhand des Ressourcennamens einschränken, sobald sie verfügbar ist.

      "Resource": "*"

    8. Wählen Sie Next: Tags (Weiter: Tags) aus.

    9. Klicken Sie auf Weiter: Prüfen.

    10. Geben Sie im Feld Name Folgendes ein:

      codecatalyst-ecs-deploy-policy

    11. Wählen Sie Richtlinie erstellen aus.

      Sie haben jetzt eine Berechtigungsrichtlinie erstellt.

  2. Erstellen Sie die Bereitstellungsrolle wie folgt:

    1. Wählen Sie im Navigationsbereich Roles (Rollen) und dann Create role (Rolle erstellen).

    2. Wählen Sie Benutzerdefinierte Vertrauensrichtlinie.

    3. Löschen Sie die bestehende benutzerdefinierte Vertrauensrichtlinie.

    4. Fügen Sie die folgende benutzerdefinierte Vertrauensrichtlinie hinzu:

      {
    "Version": "2012-10-17",
    "Statement": [
        {
            "Sid": "",
            "Effect": "Allow",
            "Principal": {
                "Service":  [
                   "codecatalyst-runner.amazonaws.com",
                   "codecatalyst.amazonaws.com"
                 ]
            },
            "Action": "sts:AssumeRole"
        }
    ]
}

    5. Wählen Sie Weiter aus.

    6. Suchen Sie unter Berechtigungsrichtlinien nach codecatalyst-ecs-deploy-policy und aktivieren Sie das entsprechende Kontrollkästchen.

    7. Wählen Sie Weiter aus.

    8. Geben Sie als Rollenname Folgendes ein:

      codecatalyst-ecs-deploy-role

    9. Geben Sie als Rollenbeschreibung Folgendes ein:

      CodeCatalyst ECS deploy role

    10. Wählen Sie Rolle erstellen aus.

    Sie haben jetzt eine Bereitstellungsrolle mit einer Vertrauensrichtlinie erstellt.

  3. Rufen Sie den ARN für die Bereitstellungsrolle wie folgt ab:

    1. Wählen Sie im Navigationsbereich Rollen aus.

    2. Geben Sie im Suchfeld den Namen der Rolle ein, die Sie gerade erstellt haben (codecatalyst-ecs-deploy-role).

    3. Wählen Sie die Rolle aus der Liste aus.

      Die Übersichtsseite der Rolle wird angezeigt.

    4. Kopieren Sie oben den ARN-Wert. Sie benötigen sie später.

AWS CLI

Gehen Sie wie folgt vor, um die Build- und Deploy-Rollen zu erstellen.

Um eine Vertrauensrichtlinie für beide Rollen zu erstellen

Wie in CodeCatalystECSUser AWS CloudShell, erstellen Sie eine Vertrauensrichtliniendatei:

  1. Erstellen Sie die Datei:

    cat > codecatalyst-ecs-trust-policy.json

  2. Fügen Sie an der Terminal-Eingabeaufforderung den folgenden Code ein:

    {
    "Version": "2012-10-17",
    "Statement": [
        {
            "Sid": "",
            "Effect": "Allow",
            "Principal": {
                "Service":  [
                   "codecatalyst-runner.amazonaws.com",
                   "codecatalyst.amazonaws.com"
                 ]
            },
            "Action": "sts:AssumeRole"
        }
    ]
}

  3. Platzieren Sie den Cursor hinter der letzten geschweiften Klammer (}).

  4. Drücken Sie dann Enter undCtrl+d, um die Datei zu speichern und cat zu beenden.

Um die Build-Richtlinie und die Build-Rolle zu erstellen

  1. Erstellen Sie die Build-Richtlinie:

    1. Wie in CodeCatalystECSUser AWS CloudShell, erstellen Sie eine Build-Richtliniendatei:

      cat > codecatalyst-ecs-build-policy.json

    2. Geben Sie an der Eingabeaufforderung den folgenden Code ein:

      {
    "Version": "2012-10-17",
    "Statement": [
        {
            "Effect": "Allow",
            "Action": [
                "ecr:*",
                "ec2:*"
            ],
            "Resource": "*"
        }
    ]
}

    3. Platzieren Sie den Cursor hinter der letzten geschweiften Klammer (}).

    4. Drücken Sie dann Enter undCtrl+d, um die Datei zu speichern und cat zu beenden.

  2. Fügen Sie die Build-Richtlinie hinzu zu AWS:

    aws iam create-policy \
    --policy-name codecatalyst-ecs-build-policy \
    --policy-document file://codecatalyst-ecs-build-policy.json

  3. Notieren Sie sich in der Befehlsausgabe den "arn": Wert, zum Beispielarn:aws:iam::111122223333:policy/codecatalyst-ecs-build-policy. Sie benötigen diesen ARN später.

  4. Erstellen Sie die Build-Rolle und fügen Sie ihr die Vertrauensrichtlinie hinzu:

    aws iam create-role \
      --role-name codecatalyst-ecs-build-role \
      --assume-role-policy-document file://codecatalyst-ecs-trust-policy.json

  5. Hängen Sie die Build-Richtlinie an die Build-Rolle an:

    aws iam attach-role-policy \
      --role-name codecatalyst-ecs-build-role \
      --policy-arn arn:aws:iam::111122223333:policy/codecatalyst-ecs-build-policy

    Wobei arn:aws:iam: :111122223333:policy/ codecatalyst-ecs-build-policy durch den ARN der Build-Richtlinie ersetzt wird, die Sie zuvor notiert haben.

  6. Zeigt die Details der Build-Rolle an:

    aws iam get-role \
      --role-name codecatalyst-ecs-build-role

  7. Notieren Sie sich den "Arn": Wert der Rolle, zum Beispielarn:aws:iam::111122223333:role/codecatalyst-ecs-build-role. Sie benötigen diesen ARN später.

Um die Bereitstellungsrichtlinie und die Bereitstellungsrolle zu erstellen

  1. Erstellen Sie eine Bereitstellungsrichtlinie:

    1. Erstellen Sie AWS CloudShell unter eine Bereitstellungsrichtliniendatei:

      cat > codecatalyst-ecs-deploy-policy.json

    2. Geben Sie an der Eingabeaufforderung den folgenden Code ein:

      {
    "Version": "2012-10-17",
    "Statement": [{
    "Action":[
      "ecs:DescribeServices",
      "ecs:CreateTaskSet",
      "ecs:DeleteTaskSet",
      "ecs:ListClusters",
      "ecs:RegisterTaskDefinition",
      "ecs:UpdateServicePrimaryTaskSet",
      "ecs:UpdateService",
      "elasticloadbalancing:DescribeTargetGroups",
      "elasticloadbalancing:DescribeListeners",
      "elasticloadbalancing:ModifyListener",
      "elasticloadbalancing:DescribeRules",
      "elasticloadbalancing:ModifyRule",
      "lambda:InvokeFunction",
      "lambda:ListFunctions",
      "cloudwatch:DescribeAlarms",
      "sns:Publish",
      "sns:ListTopics", 
      "s3:GetObject",
      "s3:GetObjectVersion",
      "codedeploy:CreateApplication", 
      "codedeploy:CreateDeployment", 
      "codedeploy:CreateDeploymentGroup", 
      "codedeploy:GetApplication", 
      "codedeploy:GetDeployment", 
      "codedeploy:GetDeploymentGroup", 
      "codedeploy:ListApplications", 
      "codedeploy:ListDeploymentGroups", 
      "codedeploy:ListDeployments", 
      "codedeploy:StopDeployment", 
      "codedeploy:GetDeploymentTarget", 
      "codedeploy:ListDeploymentTargets", 
      "codedeploy:GetDeploymentConfig", 
      "codedeploy:GetApplicationRevision", 
      "codedeploy:RegisterApplicationRevision", 
      "codedeploy:BatchGetApplicationRevisions", 
      "codedeploy:BatchGetDeploymentGroups", 
      "codedeploy:BatchGetDeployments", 
      "codedeploy:BatchGetApplications", 
      "codedeploy:ListApplicationRevisions", 
      "codedeploy:ListDeploymentConfigs", 
      "codedeploy:ContinueDeployment"           
   ],
   "Resource":"*",
   "Effect":"Allow"
},{"Action":[
      "iam:PassRole"
   ],
   "Effect":"Allow",
   "Resource":"*",
   "Condition":{"StringLike":{"iam:PassedToService":[
            "ecs-tasks.amazonaws.com",
            "codedeploy.amazonaws.com"
         ]
      }
   }
}]
}
      Anmerkung

      Wenn die Rolle zum ersten Mal zum Ausführen von Workflow-Aktionen verwendet wird, verwenden Sie den Platzhalter in der Ressourcenrichtlinien-Anweisung und grenzen Sie dann die Richtlinie mit dem Ressourcennamen ab, sobald sie verfügbar ist.

      "Resource": "*"

    3. Platzieren Sie den Cursor hinter der letzten geschweiften Klammer ()}.

    4. Drücken Sie dann Enter undCtrl+d, um die Datei zu speichern und cat zu beenden.

  2. Fügen Sie die Bereitstellungsrichtlinie hinzu zu AWS:

    aws iam create-policy \
    --policy-name codecatalyst-ecs-deploy-policy \
    --policy-document file://codecatalyst-ecs-deploy-policy.json

  3. Notieren Sie sich in der Befehlsausgabe den "arn": Wert der Bereitstellungsrichtlinie, arn:aws:iam::111122223333:policy/codecatalyst-ecs-deploy-policy z. B. Sie benötigen diesen ARN später.

  4. Erstellen Sie die Bereitstellungsrolle und fügen Sie ihr die Vertrauensrichtlinie hinzu:

    aws iam create-role \
      --role-name codecatalyst-ecs-deploy-role \
      --assume-role-policy-document file://codecatalyst-ecs-trust-policy.json

  5. Hängen Sie die Bereitstellungsrichtlinie an die Bereitstellungsrolle an, wobei arn:aws:iam: :111122223333:policy/ codecatalyst-ecs-deploy-policy durch den ARN der Bereitstellungsrichtlinie ersetzt wird, die Sie zuvor notiert haben.

    aws iam attach-role-policy \
      --role-name codecatalyst-ecs-deploy-role \
      --policy-arn arn:aws:iam::111122223333:policy/codecatalyst-ecs-deploy-policy

  6. Zeigen Sie die Details der Bereitstellungsrolle an:

    aws iam get-role \
      --role-name codecatalyst-ecs-deploy-role

  7. Notieren Sie sich den "Arn": Wert der Rolle, zum Beispielarn:aws:iam::111122223333:role/codecatalyst-ecs-deploy-role. Sie benötigen diesen ARN später.

Schritt 5: AWS Rollen hinzufügen CodeCatalyst

In diesem Schritt fügen Sie der CodeCatalyst Kontoverbindung in Ihrem Bereich die Build-Rolle (codecatalyst-ecs-build-rolecodecatalyst-ecs-deploy-role) und die Bereitstellungsrolle () hinzu.

Um deiner Kontoverbindung Rollen zum Erstellen und Bereitstellen hinzuzufügen

  1. Navigieren CodeCatalyst Sie darin zu Ihrem Bereich.

  2. Wählen Sie AWS accounts (-Konten). Eine Liste der Kontoverbindungen wird angezeigt.

  3. Wählen Sie die Kontoverbindung aus, die dem AWS Konto entspricht, in dem Sie Ihre Build- und Deploy-Rollen erstellt haben.

  4. Wählen Sie in der AWS Managementkonsole die Option Rollen verwalten aus.

    Die Seite „IAM-Rolle zu Amazon CodeCatalyst Space hinzufügen“ wird angezeigt. Möglicherweise müssen Sie sich anmelden, um auf die Seite zuzugreifen.

  5. Wählen Sie Eine bestehende Rolle hinzufügen, die Sie in IAM erstellt haben.

    Eine Dropdownliste wird angezeigt. In der Liste werden alle IAM-Rollen mit einer Vertrauensrichtlinie angezeigt, die die Dienstprinzipale codecatalyst-runner.amazonaws.com und die codecatalyst.amazonaws.com Dienstprinzipale umfasst.

  6. Wählen Sie in der Dropdownliste die Option und codecatalyst-ecs-build-role anschließend Rolle hinzufügen aus.

    Anmerkung

    Wenn Sie das sehenThe security token included in the request is invalid, liegt es möglicherweise daran, dass Sie nicht über die richtigen Berechtigungen verfügen. Um dieses Problem zu beheben, melden Sie sich ab und melden Sie sich mit dem AWS Konto wieder an, das Sie bei der Erstellung Ihres CodeCatalyst Bereichs verwendet haben. AWS

  7. Wählen Sie „IAM-Rolle hinzufügen“, wählen Sie „Eine bestehende Rolle hinzufügen, die Sie in IAM erstellt haben“ und wählen Sie in der Drop-down-Liste die Option aus. codecatalyst-ecs-deploy-role Wählen Sie Rolle hinzufügen aus.

    Sie haben jetzt die Build- und Deploy-Rollen zu Ihrem Bereich hinzugefügt.

  8. Kopieren Sie den Wert des CodeCatalyst Amazon-Anzeigenamens. Sie benötigen diesen Wert später, wenn Sie Ihren Workflow erstellen.

Schritt 6: Erstellen Sie ein Quell-Repository

In diesem Schritt erstellen Sie ein Quell-Repository in CodeCatalyst. In diesem Repository werden die Quelldateien des Tutorials gespeichert, z. B. die Aufgabendefinitionsdatei.

Weitere Informationen zu Quell-Repositorys finden Sie unterErstellen eines Quell-Repositorys.

Um ein Quell-Repository zu erstellen

  1. Öffnen Sie die CodeCatalyst Konsole unter https://codecatalyst.aws/.

  2. Navigieren Sie zu Ihrem Projekt,codecatalyst-ecs-project.

  3. Wählen Sie im Navigationsbereich Code und dann Source Repositories aus.

  4. Wählen Sie Repository hinzufügen und anschließend Repository erstellen aus.

  5. Geben Sie im Feld Repository-Name Folgendes ein:

    codecatalyst-ecs-source-repository

  6. Wählen Sie Erstellen.

Schritt 7: Quelldateien hinzufügen

In diesem Abschnitt fügen Sie die Hello World-Quelldateien zu Ihrem CodeCatalyst Repository hinzu. codecatalyst-ecs-source-repository Sie bestehen aus:

  • Eine index.html Datei — Zeigt eine Hello World-Nachricht im Browser an.

  • Ein Dockerfile — Beschreibt das Basis-Image, das für Ihr Docker-Image verwendet werden soll, und die Docker-Befehle, die darauf angewendet werden sollen.

  • Eine taskdef.json Datei — Definiert das Docker-Image, das beim Starten von Aufgaben in Ihrem Cluster verwendet werden soll.

Die Ordnerstruktur sieht wie folgt aus:

.
|— public-html
|  |— index.html
|— Dockerfile
|— taskdef.json
Anmerkung

Die folgenden Anweisungen zeigen Ihnen, wie Sie die Dateien mithilfe der CodeCatalyst Konsole hinzufügen. Sie können jedoch auch Git verwenden, wenn Sie dies bevorzugen. Details hierzu finden Sie unter Klonen eines Quell-Repositorys.

index.html

Die index.html Datei zeigt im Browser eine Hello World-Nachricht an.

Um die Datei index.html hinzuzufügen

  1. Gehen Sie in der CodeCatalyst Konsole zu Ihrem Quell-Repository,codecatalyst-ecs-source-repository.

  2. Wählen Sie unter Dateien die Option Datei erstellen aus.

  3. Geben Sie als Dateiname Folgendes ein:

    public-html/index.html
    Wichtig

    Stellen Sie sicher, dass Sie das public-html/ Präfix angeben, um einen Ordner mit demselben Namen zu erstellen. Das index.html wird sich voraussichtlich in diesem Ordner befinden.

  4. Geben Sie in das Textfeld den folgenden Code ein:

    <html>
  <head>
    <title>Hello World</title>
    <style>
      body {
      background-color: black;
      text-align: center;
      color: white;
      font-family: Arial, Helvetica, sans-serif;
      }  
    </style>
  </head>
  <body>
    <h1>Hello World</h1>
  </body>
</html>

  5. Wählen Sie Commit und anschließend erneut Commit aus.

    Das index.html wird Ihrem Repository in einem public-html Ordner hinzugefügt.

Dockerfile

Das Dockerfile beschreibt das zu verwendende Basis-Decker-Image und die darauf anzuwendenden Docker-Befehle. Weitere Informationen zum Dockerfile finden Sie in der Dockerfile-Referenz.

Das hier angegebene Dockerfile gibt an, dass das Apache 2.4-Basisimage () verwendet werden soll. httpd Es enthält auch Anweisungen zum Kopieren einer index.html aufgerufenen Quelldatei in einen Ordner auf dem Apache-Server, der Webseiten bereitstellt. Die EXPOSE Anweisung in der Dockerfile teilt Docker mit, dass der Container auf Port 80 lauscht.

Um das Dockerfile hinzuzufügen

  1. Wählen Sie in Ihrem Quell-Repository die Option Datei erstellen aus.

  2. Geben Sie als Dateiname Folgendes ein:

    Dockerfile

    Geben Sie keine Dateierweiterung an.

    Wichtig

    Das Dockerfile muss sich im Stammordner Ihres Repositorys befinden. Der Docker build Befehl des Workflows erwartet, dass es dort vorhanden ist.

  3. Geben Sie in das Textfeld den folgenden Code ein:

    FROM httpd:2.4
COPY ./public-html/index.html /usr/local/apache2/htdocs/index.html
EXPOSE 80

  4. Wählen Sie Commit und anschließend erneut Commit aus.

    Das Dockerfile wird Ihrem Repository hinzugefügt.

taskdef.json

Die taskdef.json Datei, die Sie in diesem Schritt hinzufügen, ist dieselbe wie die, in der Sie bereits angegeben haben, Schritt 2: Stellen Sie eine Platzhalteranwendung in Amazon ECS bereit mit dem folgenden Unterschied:

Anstatt einen fest codierten Docker-Imagenamen im image: Feld (httpd:2.4) anzugeben, verwendet die Aufgabendefinition hier einige Variablen, um das Bild zu bezeichnen: und. $REPOSITORY_URI $IMAGE_TAG Diese Variablen werden durch echte Werte ersetzt, die durch die Build-Aktion des Workflows generiert wurden, wenn Sie den Workflow in einem späteren Schritt ausführen.

Einzelheiten zu den Aufgabendefinitionsparametern finden Sie unter Aufgabendefinitionsparameter im Amazon Elastic Container Service Developer Guide.

Um die Datei taskdef.json hinzuzufügen

  1. Wählen Sie in Ihrem Quell-Repository die Option Datei erstellen aus.

  2. Geben Sie als Dateiname Folgendes ein:

    taskdef.json

  3. Geben Sie in das Textfeld den folgenden Code ein:

    {
    "executionRoleArn": "arn:aws:iam::account_ID:role/codecatalyst-ecs-task-execution-role",
    "containerDefinitions": [
        {
            "name": "codecatalyst-ecs-container",
            # The $REPOSITORY_URI and $IMAGE_TAG variables will be replaced 
            # by the workflow at build time (see the build action in the 
            # workflow)
            "image": $REPOSITORY_URI:$IMAGE_TAG,
            "essential": true,
            "portMappings": [
                {
                    "hostPort": 80,
                    "protocol": "tcp",
                    "containerPort": 80
                }
            ]
        }
    ],
    "requiresCompatibilities": [
        "FARGATE"
    ],
    "networkMode": "awsvpc",
    "cpu": "256",
    "memory": "512",
    "family": "codecatalyst-ecs-task-def"
}

    Ersetzen Sie im vorherigen Code

    arn:aws:iam: :account_id:role/ -role codecatalyst-ecs-task-execution

    mit dem ARN der Aufgabenausführungsrolle, die Sie notiert habenUm die Rolle zur Aufgabenausführung zu erstellen.

  4. Wählen Sie Commit und anschließend erneut Commit aus.

    Die taskdef.json Datei wird Ihrem Repository hinzugefügt.

Schritt 8: Einen Workflow erstellen und ausführen

In diesem Schritt erstellen Sie einen Workflow, der Ihre Quelldateien zu einem Docker-Image zusammenbaut und das Image dann in Ihrem Amazon ECS-Cluster bereitstellt. Diese Bereitstellung ersetzt die bestehende Apache-Platzhalteranwendung.

Der Workflow besteht aus den folgenden Bausteinen, die nacheinander ausgeführt werden:

  • Ein Trigger — Dieser Trigger startet die Workflow-Ausführung automatisch, wenn Sie eine Änderung an Ihr Quell-Repository übertragen. Weitere Informationen zu Auslösern finden Sie unter Automatisches Starten einer Workflow-Ausführung mit Triggern.

  • Eine Build-Aktion (BuildBackend) — Beim Auslösen erstellt die Aktion das Docker-Image mithilfe der Dockerfile und überträgt das Image an Amazon ECR. Die Build-Aktion aktualisiert auch das taskdef.json mit dem richtigen image Feldwert und erstellt dann ein Ausgabeartefakt dieser Datei. Dieses Artefakt wird als Eingabe für die Bereitstellungsaktion verwendet, die als Nächstes folgt.

    Weitere Informationen zur Build-Aktion finden Sie unterBauen mit Workflows.

  • Eine Bereitstellungsaktion (DeployToECS) — Nach Abschluss der Build-Aktion sucht die Bereitstellungsaktion nach dem von der Build-Aktion (TaskDefArtifact) generierten Ausgabeartefakt, findet dessen Inhalt und registriert es bei Ihrem Amazon ECS-Service. taskdef.json Der Service folgt dann den Anweisungen in der taskdef.json Datei, um drei Amazon ECS-Aufgaben — und zugehörige Hello World Docker-Container — in Ihrem Amazon ECS-Cluster auszuführen.

So erstellen Sie ein Workflow

  1. Wählen Sie in der CodeCatalyst Konsole im Navigationsbereich CI/CD und dann Workflows aus.

  2. Wählen Sie Workflow erstellen aus.

  3. Wählen Sie für Quell-Repository die Optioncodecatalyst-ecs-source-repository.

  4. Wählen Sie für Branch die Optionmain.

  5. Wählen Sie Erstellen.

  6. Löschen Sie den YAML-Beispielcode.

  7. Fügen Sie den folgenden YAML-Code hinzu:

    Anmerkung

    Im folgenden YAML-Code können Sie die Connections: Abschnitte weglassen, wenn Sie möchten. Wenn Sie diese Abschnitte weglassen, müssen Sie sicherstellen, dass die im Feld Standard-IAM-Rolle angegebene Rolle in Ihrer Umgebung die Berechtigungen und Vertrauensrichtlinien beider Rollen enthält, die unter beschrieben sind. Schritt 5: AWS Rollen hinzufügen CodeCatalyst Weitere Informationen zum Einrichten einer Umgebung mit einer Standard-IAM-Rolle finden Sie unter. Erstellen einer Umgebung

    Name: codecatalyst-ecs-workflow
SchemaVersion: 1.0

Triggers:
  - Type: PUSH
    Branches:
      - main
Actions:
  BuildBackend:
    Identifier: aws/build@v1
    Environment:
      Name: codecatalyst-ecs-environment
      Connections:
        - Name: codecatalyst-account-connection
          Role: codecatalyst-ecs-build-role
    Inputs:
      Sources:
        - WorkflowSource
      Variables:
        - Name: REPOSITORY_URI
          Value: 111122223333.dkr.ecr.us-west-2.amazonaws.com/codecatalyst-ecs-image-repo
        - Name: IMAGE_TAG
          Value: ${WorkflowSource.CommitId}
    Configuration:
      Steps:
        #pre_build:
        - Run: echo Logging in to Amazon ECR...
        - Run: aws --version
        - Run: aws ecr get-login-password --region us-west-2 | docker login --username AWS --password-stdin 111122223333.dkr.ecr.us-west-2.amazonaws.com
        #build:
        - Run: echo Build started on `date`
        - Run: echo Building the Docker image...
        - Run: docker build -t $REPOSITORY_URI:latest .
        - Run: docker tag $REPOSITORY_URI:latest $REPOSITORY_URI:$IMAGE_TAG
        #post_build:
        - Run: echo Build completed on `date`
        - Run: echo Pushing the Docker images...
        - Run: docker push $REPOSITORY_URI:latest
        - Run: docker push $REPOSITORY_URI:$IMAGE_TAG
        # Replace the variables in taskdef.json
        - Run: find taskdef.json -type f | xargs sed -i "s|\$REPOSITORY_URI|$REPOSITORY_URI|g"
        - Run: find taskdef.json -type f | xargs sed -i "s|\$IMAGE_TAG|$IMAGE_TAG|g"
        - Run: cat taskdef.json
        # The output artifact will be a zip file that contains a task definition file.
    Outputs:
      Artifacts:
        - Name: TaskDefArtifact
          Files: 
            - taskdef.json
  DeployToECS:
    DependsOn: 
      - BuildBackend
    Identifier: aws/ecs-deploy@v1
    Environment:
      Name: codecatalyst-ecs-environment
      Connections:
        - Name: codecatalyst-account-connection
          Role: codecatalyst-ecs-deploy-role
    Inputs:
      Sources: []
      Artifacts:
        - TaskDefArtifact
    Configuration:
      region: us-west-2
      cluster: codecatalyst-ecs-cluster
      service: codecatalyst-ecs-service
      task-definition: taskdef.json

    Ersetzen Sie im vorherigen Code:

    • Beide Instanzen von codecatalyst-ecs-environmentmit dem Namen der Umgebung, in der Sie erstellt habenVoraussetzungen.

    • Beide Instanzen von codecatalyst-account-connectionmit dem Anzeigenamen Ihrer Kontoverbindung. Der Anzeigename kann eine Zahl sein. Weitere Informationen finden Sie unter Schritt 5: AWS Rollen hinzufügen CodeCatalyst.

    • codecatalyst-ecs-build-rolemit dem Namen der Build-Rolle, in der Sie sie erstellt habenSchritt 4: AWS Rollen erstellen.

    • 111122223333.dkr. ecr.us-west-2.amazonaws.com/codecatalyst-ecs-image-repo(in der Value: Eigenschaft) mit der URI des Amazon ECR-Repositorys, in dem Sie es erstellt haben. Schritt 3: Erstellen Sie ein Amazon ECR-Image-Repository

    • 111122223333.dkr. ecr.us-west-2.amazonaws.com (im Run: aws ecr Befehl) mit der URI des Amazon ECR-Repositorys ohne das Bildsuffix (). /codecatalyst-ecs-image-repo

    • codecatalyst-ecs-deploy-rolemit dem Namen der Bereitstellungsrolle, in der Sie sie erstellt haben. Schritt 4: AWS Rollen erstellen

    • Beide Instanzen von us-west-2 mit Ihrem AWS Regionalcode. Eine Liste der Regionalcodes finden Sie unter Regionale Endpunkte in der. Allgemeine AWS-Referenz

    Anmerkung

    Wenn Sie sich entschieden haben, keine Build- und Deploy-Rollen zu erstellen, ersetzen Sie codecatalyst-ecs-build-roleund codecatalyst-ecs-deploy-roledurch den Namen der CodeCatalystWorkflowDevelopmentRole-spaceName Rolle. Weitere Informationen über diese Rolle finden Sie unter Schritt 4: AWS Rollen erstellen.

    Tipp

    Anstatt die sed Befehle find und und zu verwenden, die im vorherigen Workflow-Code gezeigt wurden, um das Repository und den Namen des Images zu aktualisieren, können Sie zu diesem Zweck die Amazon ECS-Aufgabendefinitionsaktion rendern verwenden. Weitere Informationen finden Sie unter Ändern einer Amazon ECS-Aufgabendefinitionsdatei mithilfe eines Workflows.

  8. (Optional) Wählen Sie „Validieren“, um sicherzustellen, dass der YAML-Code gültig ist, bevor Sie ihn festschreiben.

  9. Wählen Sie Commit (Übergeben).

  10. Geben Sie im Dialogfeld „Workflow bestätigen“ Folgendes ein:

    1. Entfernen Sie bei Nachricht bestätigen den Text und geben Sie Folgendes ein:

      Add first workflow

    2. Wählen Sie für Repositorycodecatalyst-ecs-source-repository.

    3. Wählen Sie als Branch-Name die Option main aus.

    4. Wählen Sie Commit (Übergeben).

    Sie haben jetzt einen Workflow erstellt. Eine Workflow-Ausführung wird aufgrund des oben im Workflow definierten Triggers automatisch gestartet. Insbesondere, als Sie die workflow.yaml Datei in Ihr Quell-Repository übernommen (und per Push übertragen) haben, hat der Trigger die Workflow-Ausführung gestartet.

Um den Fortschritt der Workflow-Ausführung zu sehen

  1. Wählen Sie im Navigationsbereich der CodeCatalyst Konsole CI/CD und dann Workflows aus.

  2. Wählen Sie den Workflow aus, den Sie gerade erstellt haben,. codecatalyst-ecs-workflow

  3. Wählen Sie BuildBackend, ob Sie den Baufortschritt sehen möchten.

  4. Wählen Sie DeployToECS, um den Fortschritt der Bereitstellung zu sehen.

    Weitere Informationen zum Anzeigen von Ausführungsdetails finden Sie unterStatus und Details der Workflow-Ausführung anzeigen.

Um die Bereitstellung zu überprüfen

  1. Öffnen Sie die klassische Amazon-ECS-Konsole unter https://console.aws.amazon.com/ecs/.

  2. Wählen Sie Ihren Cluster,codecatalyst-ecs-cluster.

  3. Wählen Sie die Registerkarte Tasks aus.

  4. Wählen Sie eine der drei Aufgaben.

  5. Wählen Sie im Feld Öffentliche IP die Option Open Address aus.

    Im Browser wird eine Seite „Hello World“ angezeigt, die darauf hinweist, dass der Amazon ECS-Service Ihre Anwendung erfolgreich bereitgestellt hat.

Schritt 9: Nehmen Sie eine Änderung an Ihren Quelldateien vor

In diesem Abschnitt nehmen Sie eine Änderung an der index.html Datei in Ihrem Quell-Repository vor. Diese Änderung veranlasst den Workflow, ein neues Docker-Image zu erstellen, es mit einer Commit-ID zu kennzeichnen, es an Amazon ECR weiterzuleiten und es in Amazon ECS bereitzustellen.

Um die Datei index.html zu ändern

  1. Wählen Sie in der CodeCatalyst Konsole im Navigationsbereich Code, dann Quell-Repositories und anschließend Ihr Repository aus. codecatalyst-ecs-source-repository

  2. Klicken Sie auf public-html und danach auf index.html.

    Der Inhalt von index.html wird angezeigt.

  3. Wählen Sie Bearbeiten aus.

  4. Ändern Sie in Zeile 14 den Hello World Text inTutorial complete!.

  5. Wählen Sie Commit und anschließend erneut Commit aus.

    Durch den Commit wird ein neuer Workflow-Lauf gestartet.

  6. (Optional) Gehen Sie zur Hauptseite Ihres Quell-Repositorys, wählen Sie Commits anzeigen und notieren Sie sich die Commit-ID für die index.html Änderung.

  7. Beobachten Sie den Fortschritt der Bereitstellung:

    1. Wählen Sie im Navigationsbereich CI/CD und dann Workflows aus.

    2. Wählen Siecodecatalyst-ecs-workflow, ob Sie die letzte Ausführung anzeigen möchten.

    3. Wählen Sie und DeployToECS BuildBackend, um den Fortschritt der Workflow-Ausführung zu sehen.

  8. Stellen Sie wie folgt sicher, dass Ihre Anwendung aktualisiert wurde:

    1. Öffnen Sie die klassische Amazon-ECS-Konsole unter https://console.aws.amazon.com/ecs/.

    2. Wählen Sie Ihren Cluster,codecatalyst-ecs-cluster.

    3. Wählen Sie die Registerkarte Tasks aus.

    4. Wählen Sie eine der drei Aufgaben.

    5. Wählen Sie im Feld Öffentliche IP die Option Open Address aus.

      Eine Tutorial complete! Seite wird angezeigt.

  9. (Optional) Wechseln Sie in AWS zur Amazon ECR-Konsole und überprüfen Sie, ob das neue Docker-Image mit der Commit-ID aus Schritt 6 gekennzeichnet wurde.

Bereinigen

Bereinigen Sie die in diesem Tutorial verwendeten Dateien und Dienste, um zu vermeiden, dass dafür Gebühren anfallen.

Im AWS Management Console, bereinigen Sie in dieser Reihenfolge:

  1. Gehen Sie in Amazon ECS wie folgt vor:

    1. Löschencodecatalyst-ecs-service.

    2. Löschencodecatalyst-ecs-cluster.

    3. Abmeldencodecatalyst-ecs-task-definition.

  2. Löschen codecatalyst-ecs-image-repo Sie in Amazon ECR.

  3. Löschen codecatalyst-ecs-security-group Sie in Amazon EC2.

  4. Löschen Sie im IAM Identity Center:

    1. CodeCatalystECSUser

    2. CodeCatalystECSPermissionSet

Bereinigen Sie in der CodeCatalyst Konsole wie folgt:

  1. Löschencodecatalyst-ecs-workflow.

  2. Löschencodecatalyst-ecs-environment.

  3. Löschencodecatalyst-ecs-source-repository.

  4. Löschencodecatalyst-ecs-project.

In diesem Tutorial haben Sie gelernt, wie Sie mithilfe eines CodeCatalyst Workflows und einer Aktion „In Amazon ECS bereitstellen“ eine Anwendung für einen Amazon ECS-Service bereitstellen.