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, durchgängige CD-Pipeline (Continuous Deployment) mit Amazon ECS mit zu erstellen CodePipeline.
**Wichtig**
Im Rahmen der Erstellung einer Pipeline in der Konsole wird ein S3-Artefakt-Bucket von CodePipeline für Artefakte 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 als dem Konto für Ihre Pipeline befindet, stellen Sie sicher, dass der S3-Artefakt-Bucket dem Konto gehört AWS-Konten , das sicher und zuverlässig ist.
**Anmerkung**
Dieses Tutorial bezieht sich auf die Amazon ECS-Standardbereitstellungsaktion für. CodePipeline Ein Tutorial, in dem Amazon ECS für CodeDeploy blue/green Bereitstellungsaktionen verwendet wird CodePipeline, finden Sie unter[Tutorial: Erstellen Sie eine Pipeline mit einer Amazon ECR-Quelle und Bereitstellung ECS-to-CodeDeploy](tutorials-ecs-ecr-codedeploy.md).
**Anmerkung**
Dieses Tutorial bezieht sich auf die Amazon ECS-Standardbereitstellungsaktion CodePipeline mit einer Quellaktion. Ein Tutorial, das die Amazon ECS-Standardbereitstellungsaktion zusammen mit der ECRBuildAndPublish Build-Aktion verwendet, CodePipeline um Ihr Image zu übertragen, finden Sie unter[Tutorial: Erstellen Sie ein Docker-Image und übertragen Sie es auf Amazon ECR mit CodePipeline (Typ V2)](tutorials-ecr-build-publish.md).
## 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**
Alle diese Ressourcen sollten in derselben AWS Region erstellt werden.
+ Ein Quellcodeverwaltungs-Repository (dieses Tutorial verwendet CodeCommit) mit Ihrem Dockerfile und Ihrer Anwendungsquelle. Weitere Informationen finden Sie [ im *AWS CodeCommit Benutzerhandbuch unter*](https://docs.aws.amazon.com/codecommit/latest/userguide/how-to-create-repository.html) Erstellen eines CodeCommit Repositorys.
+ Ein Docker-Image-Repository (dieses Tutorial verwendet Amazon ECR), das ein Image enthält, das Sie aus Ihrer Dockerfile- und Anwendungsquelle erstellt haben. Weitere Informationen finden Sie unter [ Erstellen eines Repositorys ](https://docs.aws.amazon.com/AmazonECR/latest/userguide/repository-create.html) und Übertragen [ eines Images ](https://docs.aws.amazon.com/AmazonECR/latest/userguide/docker-push-ecr-image.html) im * Amazon Elastic Container Registry Benutzerhandbuch. *
+ Eine Amazon ECS-Aufgabendefinition, die auf das in Ihrem Image-Repository gehostete Docker-Image verweist. Weitere Informationen finden Sie unter [ Erstellen einer Aufgabendefinition ](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/create-task-definition.html) im * Amazon Elastic Container Service Developer Guide*.
**Wichtig**
Die Amazon ECS-Standardbereitstellungsaktion für CodePipeline erstellt eine eigene Version 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 Überarbeitungen.
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 ](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/clusters.html) und [ Creating a Service ](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/create-service-console-v2.html) 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
Dieses Tutorial dient CodeBuild dazu, Ihr Docker-Image zu erstellen und das Image an Amazon ECR zu ü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:
+ Pre-build Stufe:
+ 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.
+ Post-build Stufe:
+ Führen Sie die Push-Übertragung des Image zu Ihrem ECR-Repository mit beiden Tags durch.
+ Schreiben Sie eine Datei mit dem Namen `imagedefinitions.json` im Build-Stammverzeichnis, 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 Image 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 Beispiel-Aufgabendefinition geschrieben, die in [Voraussetzungen](#ecs-cd-prereqs) bereitgestellt wurde und vom Amazon ECS-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.
**Um einen hinzuzufügen `buildspec.yml` Datei zu deinem Quell-Repository**
1. Öffnen Sie einen Text-Editor und kopieren Sie die Build-Spezifikation in eine neue Datei.
1. 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.
1. 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 .
```
1. Führen Sie einen Commit der Änderung durch.
```
git commit -m "Adding build specification."
```
1. 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/](https://console.aws.amazon.com/codepipeline/).
1. Klicken Sie auf der Seite **Welcome** auf **Create pipeline**.
Wenn Sie dies zum ersten Mal verwenden CodePipeline, wird anstelle der ** ** Willkommensseite eine Einführungsseite angezeigt. Wählen Sie **Get Started Now**.
1. Wählen Sie auf der ** Seite ** Schritt 1: Erstellungsoption auswählen unter ** Erstellungsoptionen ** die ** Option Benutzerdefinierte Pipeline ** erstellen aus. Wählen Sie **Weiter** aus.
1. 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**.
1. Behalten Sie unter ** Pipeline-Typ ** die Standardauswahl bei ** V2**. Die Pipeline-Typen unterscheiden sich in ihren Eigenschaften und ihrem Preis. Weitere Informationen finden Sie unter [Pipeline-Typen](pipeline-types.md). Wählen Sie **Weiter** aus.
1. 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.
1. Wählen Sie für **Branch name (Zweigname)** den zu verwendenden Zweig und dann **Next (Weiter)** aus.
1. Wählen Sie auf der ** Seite ** Schritt 4: Build-Phase hinzufügen für ** Build-Anbieter die ** Option **AWS CodeBuild** 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**.
1. Wählen Sie für **Environment image (Umgebungs-Abbild)** die Option **Managed image (Verwaltetes Abbild)** aus.
1. Wählen Sie für **Operating system (Betriebssystem)** die Option **Amazon Linux 2** aus.
1. Wählen Sie unter **Runtime (Laufzeit)** die Option **Standard** aus.
1. Wählen Sie für ** Bild ** die Option ** `aws/codebuild/amazonlinux2-x86_64-standard:3.0`**.
1. Verwenden Sie für **Image version (Abbildversion)** und **Environment type (Umgebungstyp)** die Standardwerte.
1. 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.
1. Deaktivieren Sie ** CloudWatch Protokolle**. Möglicherweise müssen Sie „**Erweitert**“ erweitern.
1. Wählen Sie ** Weiter zu CodePipeline**.
1. Wählen Sie **Weiter** aus.
**Anmerkung**
Der Assistent erstellt eine CodeBuild Servicerolle für Ihr Build-Projekt mit dem Namen ** codebuild- {{build-project-name}} ** -service-role. Notieren Sie sich diesen Rollennamen, wenn Sie ihm später Amazon ECR-Berechtigungen hinzufügen.
1. Wählen Sie auf der ** Seite ** Schritt 5: Bereitstellungsphase hinzufügen für ** 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**.
1. 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**.
1. Ü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 Build-Phase 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 erstellte eine IAM-Rolle für das CodeBuild Build-Projekt mit dem Namen ** codebuild- -service-role. {{build-project-name}} ** Für dieses Tutorial lautet der Name codebuild-hello-world-service-role. ** ** 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.
**Um Amazon ECR-Berechtigungen zur Rolle hinzuzufügen CodeBuild**
1. Öffnen Sie unter [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/) die IAM-Konsole.
1. Wählen Sie im linken Navigationsbereich **Roles** aus.
1. Geben Sie in das Suchfeld ** codebuild- ein ** und wählen Sie die Rolle aus, die CodePipeline vom Assistenten erstellt wurde. In diesem Tutorial lautet der Name der Rolle **code-build-hello-world-service-role**.
1. Wählen Sie auf der Seite **Summary (Zusammenfassung)** die Option **Attach policy (Richtlinie anfügen)** aus.
1. Wählen Sie das Feld links neben der ** AmazonEC2ContainerRegistryPowerUser ** Richtlinie aus und wählen Sie Richtlinie ** ** anhängen aus.
## Schritt 4: Testen Ihrer Pipeline
Ihre Pipeline sollte alles enthalten, was Sie für eine durchgängige native AWS kontinuierliche Bereitstellung benötigen. 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.
1. Öffnen Sie die CodePipeline Konsole unter [ https://console.aws.amazon.com/codepipeline/](https://console.aws.amazon.com/codepipeline/).
1. Wählen Sie Ihre Pipeline in der Liste aus.
1. 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 anhand Ihrer Codeänderung erstellt wurde.