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 unter[Tutorial: Eine Pipeline mit einer Amazon ECR-Quelle und ECS-to-CodeDeploy Bereitstellung erstellen](tutorials-ecs-ecr-codedeploy.md).
**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 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**
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](https://docs.aws.amazon.com/codecommit/latest/userguide/how-to-create-repository.html) 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](https://docs.aws.amazon.com/AmazonECR/latest/userguide/repository-create.html) and [Push an Image](https://docs.aws.amazon.com/AmazonECR/latest/userguide/docker-push-ecr-image.html) 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](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 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](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/clusters.html) and [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
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 geschrieben[Voraussetzungen](#ecs-cd-prereqs), 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.
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 von **Willkommen** 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** bei. Pipeline-Typen unterscheiden sich in ihren Eigenschaften und im Preis. Weitere Informationen finden Sie unter [Arten von Pipelines](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 **AWS CodeBuild**Sie 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**.
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 **Image** 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. Wählen Sie **CloudWatch Protokolle** ab. 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 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.
1. 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**.
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 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/](https://console.aws.amazon.com/iam/) die IAM-Konsole.
1. Wählen Sie im linken Navigationsbereich **Roles** aus.
1. 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**.
1. Wählen Sie auf der Seite **Summary (Zusammenfassung)** die Option **Attach policy (Richtlinie anfügen)** aus.
1. 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.
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 aus Ihrer Codeänderung erstellt wurde.