Tutorial: Amazon ECS-Standardbereitstellung mit CodePipeline - AWS CodePipeline
VoraussetzungenSchritt 1: Hinzufügen einer Build-Spezifikationsdatei zu Ihrem Quell-RepositorySchritt 2: Erstellen einer durchgängigen Bereitstellungs-PipelineSchritt 3: Amazon ECR-Berechtigungen zur CodeBuild Rolle hinzufügenSchritt 4: Testen Ihrer Pipeline

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: Amazon ECS-Standardbereitstellung mit CodePipeline

Dieses Tutorial hilft Ihnen dabei, eine vollständige, end-to-end kontinuierliche Bereitstellungspipeline (CD) mit Amazon ECS mit 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 Amazon ECS-Standardbereitstellungsaktion für CodePipeline. Ein Tutorial, das die Aktion Amazon ECS to CodeDeploy Blue/Green Deployment in verwendet CodePipeline, finden Sie unterTutorial: Eine Pipeline mit einer Amazon ECR-Quelle und ECS-to-CodeDeploy Bereitstellung erstellen.

Anmerkung

Dieses Tutorial bezieht sich auf die Amazon ECS-Standardbereitstellungsaktion für CodePipeline mit einer Quellaktion. Ein Tutorial, das die ECSstandard Amazon-Bereitstellungsaktion zusammen mit der ECRBuild AndPublish Build-Aktion verwendet, um Ihr Image CodePipeline zu pushen, finden Sie unterTutorial: Erstellen Sie ein Docker-Image und übertragen Sie es auf Amazon ECR mit CodePipeline.

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 unter Erstellen eines CodeCommit Repositorys im AWS CodeCommit Benutzerhandbuch.

  • Ein Docker-Image-Repository (dieses Tutorial verwendet Amazon ECR), 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 Amazon ECS-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 Amazon ECS-Standardbereitstellungsaktion für CodePipeline erstellt eine eigene Revision der Aufgabendefinition, die auf der vom Amazon ECS-Service verwendeten Version basiert. Wenn Sie neue Revisionen für die Aufgabendefinition erstellen, ohne den Amazon ECS-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 Amazon ECS-Cluster, auf dem ein Service ausgeführt wird, 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 eine buildspec.yml-Datei zu Ihrem Quellcode-Repository hinzu, um CodeBuild mitzuteilen, wie zu verfahren ist. Die nachfolgende Beispiel-Buildspezifikation bewirkt Folgendes:

  • Phase vor dem Build:

    • Melden Sie sich bei Amazon ECR an.

    • Stellen Sie die Repository-URI auf Ihr ECR-Image ein und fügen Sie 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:

    • Führen Sie die Push-Übertragung des Image zu Ihrem ECR-Repository mit beiden Tags durch.

    • Schreiben Sie eine Datei namens imagedefinitions.json Build-Root, die den Container-Namen Ihres Amazon ECS-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 Datei imagedefinitions.json wird für den ECS-Auftragsworker benötigt.

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 Amazon ECS-Service für dieses Tutorial verwendet wird. 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 Ihre Amazon ECR-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-Stufen 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. Wählen Sie auf der Seite Schritt 1: Erstellungsoption auswählen unter Erstellungsoptionen die Option Benutzerdefinierte Pipeline erstellen aus. Wählen Sie Weiter.

  4. Geben Sie in Schritt 2: Pipeline-Einstellungen auswählen im Feld Pipeline-Name den Namen für Ihre Pipeline ein. Bei diesem Tutorial lautet der Pipeline-Name hello-world.

  5. Behalten Sie unter Pipeline-Typ die Standardauswahl bei V2 bei. Pipeline-Typen unterscheiden sich in ihren Eigenschaften und im Preis. Weitere Informationen finden Sie unter Arten von Pipelines. Wählen Sie Weiter.

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

    1. Wählen Sie für Repository name (Repository-Name) den Namen des CodeCommit-Repositorys aus, das als Quellspeicherort 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.

  7. Wählen AWS CodeBuildSie auf der Seite Schritt 4: Buildphase hinzufügen für Build-Anbieter die Option 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- build-project-name -service-role für Ihr Build-Projekt. Notieren Sie sich diesen Rollennamen, wenn Sie ihm später Amazon ECR-Berechtigungen hinzufügen.

  8. Wählen Sie auf der Seite Schritt 5: Bereitstellungsphase hinzufügen als Bereitstellungsanbieter Amazon ECS aus.

    1. Wählen Sie als Clustername den Amazon ECS-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.

  9. Überprüfen Sie auf der Seite Step 6: Review Ihre Pipeline-Konfiguration und wählen Sie Create pipeline, 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: Amazon ECR-Berechtigungen zur CodeBuild Rolle hinzufügen

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

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

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

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

  3. Geben Sie im Suchfeld codebuild- ein und wählen Sie die Rolle aus, die CodePipeline vom 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 Amazon ECS-Service führt das Docker-Image aus, das aus Ihrer Codeänderung erstellt wurde.