Tutorial: Amazon ECS Standard Deployment mit CodePipeline

Dieses Tutorial hilft Ihnen dabei, eine vollständige, end-to-end kontinuierliche Bereitstellungspipeline (CD) ECS mit Amazon zu erstellen CodePipeline.

Wichtig

Im Rahmen der Erstellung einer Pipeline in der Konsole wird ein S3-Artefakt-Bucket von CodePipeline for Artifacts verwendet. (Dies unterscheidet sich von dem Bucket, der für eine S3-Quellaktion verwendet wird.) Wenn sich der S3-Artefakt-Bucket in einem anderen Konto befindet als das Konto für Ihre Pipeline, stellen Sie sicher, dass der S3-Artefakt-Bucket denjenigen gehört AWS-Konten , die sicher und zuverlässig sind.

Anmerkung

Dieses Tutorial bezieht sich auf die ECS Amazon-Standardbereitstellungsaktion für CodePipeline. Ein Tutorial, das die Bereitstellungsaktion Amazon ECS to CodeDeploy Blue/Green in verwendet CodePipeline, finden Sie unterTutorial: Eine Pipeline mit einer ECR Amazon-Quelle und ECS -to-Deployment erstellen CodeDeploy .

Voraussetzungen

Es müssen bestimmte Ressourcen zur Verfügung stehen, damit Sie mithilfe dieses Tutorials eine CD-Pipeline erstellen können. Zum Einstieg benötigen Sie Folgendes:

Anmerkung

All diese Ressourcen sollten in derselben AWS Region erstellt werden.

• Ein Quellcodeverwaltungs-Repository (das in diesem Tutorial verwendet wird CodeCommit) mit Ihrem Dockerfile und Ihrer Anwendungsquelle. Weitere Informationen finden Sie im AWS CodeCommit Benutzerhandbuch unter Erstellen eines CodeCommit Repositorys.

• Ein Docker-Image-Repository (dieses Tutorial verwendet AmazonECR), das ein Image enthält, das Sie aus Ihrer Docker-Datei und Anwendungsquelle erstellt haben. Weitere Informationen finden Sie unter Creating a Repository and Push an Image im Amazon Elastic Container Registry User Guide.

• Eine ECS Amazon-Aufgabendefinition, die auf das in Ihrem Image-Repository gehostete Docker-Image verweist. Weitere Informationen finden Sie unter Erstellen einer Aufgabendefinition im Amazon Elastic Container Service Developer Guide.

  Wichtig

  Die ECS Amazon-Standardbereitstellungsaktion für CodePipeline erstellt eine eigene Version der Aufgabendefinition, die auf der vom ECS Amazon-Service verwendeten Version basiert. Wenn Sie neue Revisionen für die Aufgabendefinition erstellen, ohne den ECS Amazon-Service zu aktualisieren, ignoriert die Bereitstellungsaktion diese Revisionen.

  Im Folgenden finden Sie ein Beispiel für eine Aufgabendefinition, die für dieses Tutorial verwendet wurde. Der Wert, den Sie für Ihre Build-Spezifikationsdatei verwenden name und der im nächsten Schritt verwendet family wird.

  {
    "ipcMode": null,
    "executionRoleArn": "role_ARN",
    "containerDefinitions": [
      {
        "dnsSearchDomains": null,
        "environmentFiles": null,
        "logConfiguration": {
          "logDriver": "awslogs",
          "secretOptions": null,
          "options": {
            "awslogs-group": "/ecs/hello-world",
            "awslogs-region": "us-west-2",
            "awslogs-stream-prefix": "ecs"
          }
        },
        "entryPoint": null,
        "portMappings": [
          {
            "hostPort": 80,
            "protocol": "tcp",
            "containerPort": 80
          }
        ],
        "command": null,
        "linuxParameters": null,
        "cpu": 0,
        "environment": [],
        "resourceRequirements": null,
        "ulimits": null,
        "dnsServers": null,
        "mountPoints": [],
        "workingDirectory": null,
        "secrets": null,
        "dockerSecurityOptions": null,
        "memory": null,
        "memoryReservation": 128,
        "volumesFrom": [],
        "stopTimeout": null,
        "image": "image_name",
        "startTimeout": null,
        "firelensConfiguration": null,
        "dependsOn": null,
        "disableNetworking": null,
        "interactive": null,
        "healthCheck": null,
        "essential": true,
        "links": null,
        "hostname": null,
        "extraHosts": null,
        "pseudoTerminal": null,
        "user": null,
        "readonlyRootFilesystem": null,
        "dockerLabels": null,
        "systemControls": null,
        "privileged": null,
        "name": "hello-world"
      }
    ],
    "placementConstraints": [],
    "memory": "2048",
    "taskRoleArn": null,
    "compatibilities": [
      "EC2",
      "FARGATE"
    ],
    "taskDefinitionArn": "ARN",
    "family": "hello-world",
    "requiresAttributes": [],
    "pidMode": null,
    "requiresCompatibilities": [
      "FARGATE"
    ],
    "networkMode": "awsvpc",
    "cpu": "1024",
    "revision": 1,
    "status": "ACTIVE",
    "inferenceAccelerators": null,
    "proxyConfiguration": null,
    "volumes": []
  }

• Ein ECS Amazon-Cluster, der einen Service ausführt, der Ihre zuvor erwähnte Aufgabendefinition verwendet. Weitere Informationen finden Sie unter Creating a Cluster and Creating a Service im Amazon Elastic Container Service Developer Guide.

Nachdem Sie diese Voraussetzungen erfüllt haben, können Sie mit dem Tutorial fortfahren und Ihre CD-Pipeline erstellen.

Schritt 1: Hinzufügen einer Build-Spezifikationsdatei zu Ihrem Quell-Repository

In diesem Tutorial CodeBuild können Sie Ihr Docker-Image erstellen und das Image an Amazon ECR übertragen. Fügen Sie Ihrem Quellcode-Repository eine buildspec.yml Datei hinzu, um zu erfahren, CodeBuild wie das geht. Die nachfolgende Beispiel-Buildspezifikation bewirkt Folgendes:

• Phase vor dem Build:

  • Loggen Sie sich bei Amazon einECR.

  • Setze das Repository URI auf dein ECR Bild und füge ein Image-Tag mit den ersten sieben Zeichen der Git-Commit-ID der Quelle hinzu.

• Build-Phase:

  • Erstellen Sie das Docker-Image und taggen Sie das Image sowohl als latest als auch mit der Git-Commit-ID.

• Phase nach dem Build:

  • Push das Bild mit beiden Tags in dein ECR Repository.

  • Schreiben Sie eine Datei namens imagedefinitions.json Build-Root, die den Container-Namen Ihres ECS Amazon-Service sowie das Image und das Tag enthält. Die Bereitstellungsphase Ihrer CD-Pipeline erstellt anhand dieser Informationen eine neue Revision Ihrer Service-Aufgabendefinition und aktualisiert dann den Service für die Nutzung der neuen Aufgabendefinition. Die imagedefinitions.json Datei ist für den ECS Job Worker erforderlich.

Fügen Sie diesen Beispieltext ein, um Ihre buildspec.yml Datei zu erstellen, und ersetzen Sie die Werte für Ihr Bild und Ihre Aufgabendefinition. In diesem Text wird die Beispielkonto-ID 111122223333 verwendet.

version: 0.2

phases:
  pre_build:
    commands:
      - echo Logging in to Amazon ECR...
      - aws --version
      - aws ecr get-login-password --region $AWS_DEFAULT_REGION | docker login --username AWS --password-stdin 111122223333.dkr.ecr.us-west-2.amazonaws.com
      - REPOSITORY_URI=012345678910.dkr.ecr.us-west-2.amazonaws.com/hello-world
      - COMMIT_HASH=$(echo $CODEBUILD_RESOLVED_SOURCE_VERSION | cut -c 1-7)
      - IMAGE_TAG=${COMMIT_HASH:=latest}
  build:
    commands:
      - echo Build started on `date`
      - echo Building the Docker image...
      - docker build -t $REPOSITORY_URI:latest .
      - docker tag $REPOSITORY_URI:latest $REPOSITORY_URI:$IMAGE_TAG
  post_build:
    commands:
      - echo Build completed on `date`
      - echo Pushing the Docker images...
      - docker push $REPOSITORY_URI:latest
      - docker push $REPOSITORY_URI:$IMAGE_TAG
      - echo Writing image definitions file...
      - printf '[{"name":"hello-world","imageUri":"%s"}]' $REPOSITORY_URI:$IMAGE_TAG > imagedefinitions.json
artifacts:
    files: imagedefinitions.json

Die Build-Spezifikation wurde für die Beispielaufgabendefinition geschriebenVoraussetzungen, die in bereitgestellt wurde und vom ECS Amazon-Service für dieses Tutorial verwendet wurde. Der REPOSITORY_URI-Wert entspricht dem image-Repository (ohne Image-Tag), und der hello-world-Wert am Ende der Datei entspricht dem Container-Namen in der Aufgabendefinition des Service.

So fügen Sie eine buildspec.yml-Datei zu Ihrem Quell-Repository hinzu

1. Öffnen Sie einen Text-Editor und kopieren Sie die Build-Spezifikation in eine neue Datei.

2. Ersetzen Sie den REPOSITORY_URI Wert (012345678910.dkr.ecr.us-west-2.amazonaws.com/hello-world) durch Ihr ECR Amazon-Repository URI (ohne Image-Tag) für Ihr Docker-Image. Ersetzen Sie hello-world durch den Container-Namen in der Aufgabendefinition Ihres Service, die auf das Docker-Image verweist.

3. Führen Sie einen Commit und eine Push-Übertragung Ihrer buildspec.yml-Datei zu Ihrem Quell-Repository durch.

   1. Fügen Sie die Datei hinzu.

      git add .

   2. Führen Sie einen Commit der Änderung durch.

      git commit -m "Adding build specification."

   3. Führen Sie eine Push-Übertragung für das Commit durch.

      git push

Schritt 2: Erstellen einer durchgängigen Bereitstellungs-Pipeline

Verwenden Sie den CodePipeline Assistenten, um Ihre Pipeline-Phasen zu erstellen und Ihr Quell-Repository mit Ihrem ECS Service zu verbinden.

So erstellen Sie Ihre Pipeline

1. Öffnen Sie die CodePipeline Konsole unter https://console.aws.amazon.com/codepipeline/.

2. Klicken Sie auf der Seite Welcome auf Create pipeline.

   Wenn Sie dies zum ersten Mal verwenden CodePipeline, wird anstelle von Willkommen eine Einführungsseite angezeigt. Wählen Sie Get Started Now.

3. Geben Sie auf der Seite Schritt 1: Name in das Feld Pipeline-Name den Namen für Ihre Pipeline ein. Bei diesem Tutorial lautet der Pipeline-Name hello-world.

4. Wählen Sie unter Pipeline-Typ die Option V2 aus. Weitere Informationen finden Sie unter Arten von Pipelines. Wählen Sie Weiter.

5. Wählen Sie auf der Seite Schritt 2: Quellstufe hinzufügen für Quellanbieter die Option AWS CodeCommit.

   1. Wählen Sie unter Repository-Name den Namen des CodeCommit Repositorys aus, das als Quellpfad für Ihre Pipeline verwendet werden soll.

   2. Wählen Sie für Branch name (Zweigname) den zu verwendenden Zweig und dann Next (Weiter) aus.

6. Wählen Sie auf der Seite Schritt 3: Build-Phase hinzufügen die Option AWS CodeBuildBuild Provider und dann Create project aus.

   1. Wählen Sie für Project name einen eindeutigen Namen für Ihr Build-Projekt aus. Bei diesem Tutorial lautet der Projektname hello-world.

   2. Wählen Sie für Environment image (Umgebungs-Abbild) die Option Managed image (Verwaltetes Abbild) aus.

   3. Wählen Sie für Operating system (Betriebssystem) die Option Amazon Linux 2 aus.

   4. Wählen Sie unter Runtime (Laufzeit) die Option Standard aus.

   5. Wählen Sie für Image die Option aws/codebuild/amazonlinux2-x86_64-standard:3.0.

   6. Verwenden Sie für Image version (Abbildversion) und Environment type (Umgebungstyp) die Standardwerte.

   7. Wählen Sie Enable this flag if you want to build Docker images or want your builds to get elevated privileges (Dieses Flag aktivieren, wenn Docker-Abbilder erstellt oder die Builds erweiterte Berechtigungen erhalten sollen) aus.

   8. Wählen Sie CloudWatch Protokolle ab. Möglicherweise müssen Sie Erweitert erweitern.

   9. Wählen Sie Weiter zu CodePipeline.

   10. Wählen Sie Weiter.

       Anmerkung

       Der Assistent erstellt eine CodeBuild Servicerolle mit dem Namen codebuild- für Ihr Build-Projektbuild-project-name-Dienstrolle. Notieren Sie sich diesen Rollennamen, wenn Sie ihm später ECR Amazon-Berechtigungen hinzufügen.

7. Wählen Sie auf der Seite Schritt 4: Bereitstellungsphase hinzufügen als Bereitstellungsanbieter Amazon ausECS.

   1. Wählen Sie als Clustername den ECS Amazon-Cluster aus, in dem Ihr Service ausgeführt wird. Für dieses Tutorial lautet der Cluster default.

   2. Wählen Sie für Service name (Service-Name) den zu aktualisierenden Service und dann Next (Weiter) aus. Bei diesem Tutorial lautet der Servicename hello-world.

8. Überprüfen Sie auf der Seite Step 5: Review (Schritt 5: Überprüfen) die Pipeline-Konfiguration und wählen Sie Create pipeline (Pipeline erstellen), um die Pipeline zu erstellen.

   Anmerkung

   Nachdem die Pipeline erstellt wurde, versucht sie, die verschiedenen Pipeline-Phasen zu durchlaufen. Die vom Assistenten erstellte CodeBuild Standardrolle ist jedoch nicht berechtigt, alle in der buildspec.yml Datei enthaltenen Befehle auszuführen, sodass die Erstellungsphase fehlschlägt. Der nächste Abschnitt fügt die Berechtigungen für die Build-Phase hinzu.

Schritt 3: ECR Amazon-Berechtigungen zur CodeBuild Rolle hinzufügen

Der CodePipeline Assistent hat eine IAM Rolle für das CodeBuild Build-Projekt mit dem Namen codebuild- erstelltbuild-project-name-Dienstrolle. Für dieses Tutorial lautet codebuild-hello-world-service der Name -role. Da die buildspec.yml Datei Aufrufe an ECR API Amazon-Operationen sendet, muss die Rolle über eine Richtlinie verfügen, die Berechtigungen für diese ECR Amazon-Aufrufe zulässt. Das folgende Verfahren hilft Ihnen, die richtigen Berechtigungen an die Rolle anzufügen.

So fügen Sie ECR Amazon-Berechtigungen zur CodeBuild Rolle hinzu

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

2. Wählen Sie im linken Navigationsbereich Roles aus.

3. Geben Sie im Suchfeld codebuild- ein und wählen Sie die Rolle aus, die vom CodePipeline Assistenten erstellt wurde. Für dieses Tutorial lautet der Rollenname codebuild-hello-world-service-role.

4. Wählen Sie auf der Seite Summary (Zusammenfassung) die Option Attach policy (Richtlinie anfügen) aus.

5. Markieren Sie das Kästchen links neben der EC2ContainerRegistryPowerUserAmazon-Richtlinie und wählen Sie Richtlinie anhängen aus.

Schritt 4: Testen Ihrer Pipeline

Ihre Pipeline sollte über alles verfügen, was für die Ausführung einer end-to-end systemeigenen AWS kontinuierlichen Bereitstellung erforderlich ist. Testen Sie nun ihre Funktionalität, indem Sie eine Code-Änderung mithilfe von Push zu Ihrem Quell-Repository übertragen.

So testen Sie Ihre Pipeline

1. Nehmen Sie eine Code-Änderung an Ihrem konfigurierten Quell-Repository vor und führen Sie den Commit-Vorgang und die Push-Übertragung der Änderung durch.

2. Öffnen Sie die CodePipeline Konsole unter https://console.aws.amazon.com/codepipeline/.

3. Wählen Sie Ihre Pipeline in der Liste aus.

4. Sehen Sie sich an, wie die Pipeline ihre Phasen durchläuft. Ihre Pipeline sollte abgeschlossen sein und Ihr ECS Amazon-Service führt das Docker-Image aus, das aufgrund Ihrer Codeänderung erstellt wurde.