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.
# Migrieren Sie Abfrage-Pipelines, um die ereignisbasierte Änderungserkennung zu nutzen
AWS CodePipeline unterstützt die vollständige, end-to-end kontinuierliche Bereitstellung, was das Starten Ihrer Pipeline bei jeder Codeänderung einschließt. Es gibt zwei unterstützte Methoden, um Ihre Pipeline nach einer Codeänderung zu starten: ereignisbasierte Änderungserkennung und Abfrage. Wir empfehlen, die ereignisbasierte Änderungserkennung für Pipelines zu verwenden.
Verwenden Sie die hier aufgeführten Verfahren, um Ihre Abfrage-Pipelines auf die ereignisbasierte Methode zur Änderungserkennung für Ihre Pipeline zu migrieren (zu aktualisieren).
Die empfohlene Methode zur ereignisbasierten Änderungserkennung für Pipelines wird durch die Pipeline-Quelle bestimmt, z. B. CodeCommit In diesem Fall müsste die Polling-Pipeline beispielsweise auf die ereignisbasierte Änderungserkennung mit migrieren. EventBridge
## Wie migriert man Polling-Pipelines
Um Abfrage-Pipelines zu migrieren, ermitteln Sie Ihre Abfrage-Pipelines und legen Sie dann die empfohlene Methode zur ereignisbasierten Änderungserkennung fest:
+ Verwenden Sie die unter beschriebenen Schritte, um Ihre Abfrage-Pipelines [Polling-Pipelines in Ihrem Konto anzeigen](#update-change-detection-view-polling) zu ermitteln.
+ Suchen Sie in der Tabelle nach Ihrem Pipeline-Quelltyp und wählen Sie dann das Verfahren mit der Implementierung aus, die Sie für die Migration Ihrer Polling-Pipeline verwenden möchten. Jeder Abschnitt enthält mehrere Methoden für die Migration, z. B. die Verwendung der CLI oder CloudFormation.
| Migrieren von Pipelines zur empfohlenen Methode zur Änderungserkennung | Pipeline-Quelle | Empfohlene ereignisbasierte Erkennungsmethode | Migrationsverfahren |
| --- | --- | --- | --- |
| AWS CodeCommit | EventBridge (empfohlen). | Siehe [Migrieren Sie Abfrage-Pipelines mit einer Quelle CodeCommit](#update-change-detection-codecommit). |
| Amazon S3 | EventBridge und Bucket für Ereignisbenachrichtigungen aktiviert (empfohlen). | Siehe [Migrieren Sie Abfrage-Pipelines mit einer für Ereignisse aktivierten S3-Quelle](#update-change-detection-S3-event). |
| Amazon S3 | EventBridge und eine AWS CloudTrail Spur. | Siehe [Migrieren Sie Polling-Pipelines mit einer S3-Quelle und einem S3-Trail CloudTrail](#update-change-detection-S3). |
| GitHub (per GitHub App) | Verbindungen (empfohlen) | Siehe [Migrieren Sie Abfrage-Pipelines für eine Quellaktion GitHub (per OAuth App) zu Verbindungen](#update-change-detection-github-connection). |
| GitHub (per OAuth App) | Webhooks | Siehe [Migrieren Sie Abfrage-Pipelines für eine Quellaktion GitHub (per OAuth App) zu Webhooks](#update-change-detection-github-webhooks). |
**Wichtig**
Für entsprechende Aktualisierungen der Konfiguration von Pipeline-Aktionen, wie z. B. Pipelines mit einer Aktion GitHub (per OAuth App), müssen Sie den `PollForSourceChanges` Parameter in der Konfiguration Ihrer Quellaktion explizit auf *false* setzen, um zu verhindern, dass eine Pipeline Abfragen durchführt. Daher ist es möglich, eine Pipeline fälschlicherweise sowohl mit ereignisbasierter Änderungserkennung als auch mit Abfrage zu konfigurieren, indem Sie beispielsweise eine EventBridge Regel konfigurieren *und* gleichzeitig den Parameter weglassen. `PollForSourceChanges` Dies führt zu duplizierten Pipelineausführungen, wobei die Pipeline bei der maximalen Gesamtzahl von Abfrage-Pipelines berücksichtigt wird. Standardmäßig handelt es sich hierbei um einen sehr viel niedrigeren Wert als für ereignisbasierte Pipelines. Weitere Informationen finden Sie unter [Kontingente in AWS CodePipeline](limits.md).
## Polling-Pipelines in Ihrem Konto anzeigen
Verwenden Sie als ersten Schritt eines der folgenden Skripts, um zu ermitteln, welche Pipelines in Ihrem Konto für Abfragen konfiguriert sind. Dies sind die Pipelines für die Migration zur ereignisbasierten Änderungserkennung.
### Abfrage-Pipelines in Ihrem Konto anzeigen (Skript)
Gehen Sie wie folgt vor, um mithilfe eines Skripts die Pipelines in Ihrem Konto zu ermitteln, die Polling verwenden.
1. Öffnen Sie ein Terminalfenster und führen Sie dann einen der folgenden Schritte aus:
+ Führen Sie den folgenden Befehl aus, um ein neues Skript mit dem Namen **PollingPipelinesExtractor.sh** zu erstellen.
```
vi PollingPipelinesExtractor.sh
```
+ Um ein Python-Skript zu verwenden, führen Sie den folgenden Befehl aus, um ein neues Python-Skript namens **PollingPipelinesExtractor.py** zu erstellen.
```
vi PollingPipelinesExtractor.py
```
1. Kopieren Sie den folgenden Code und fügen Sie ihn in das **PollingPipelinesExtractor**Skript ein. Führen Sie eine der folgenden Aktionen aus:
+ Kopieren Sie den folgenden Code und fügen Sie ihn in das **PollingPipelinesExtractor.sh-Skript** ein.
```
#!/bin/bash
set +x
POLLING_PIPELINES=()
LAST_EXECUTED_DATES=()
NEXT_TOKEN=null
HAS_NEXT_TOKEN=true
if [[ $# -eq 0 ]] ; then
echo 'Please provide region name'
exit 0
fi
REGION=$1
while [ "$HAS_NEXT_TOKEN" != "false" ]; do
if [ "$NEXT_TOKEN" != "null" ];
then
LIST_PIPELINES_RESPONSE=$(aws codepipeline list-pipelines --region $REGION --next-token $NEXT_TOKEN)
else
LIST_PIPELINES_RESPONSE=$(aws codepipeline list-pipelines --region $REGION)
fi
LIST_PIPELINES=$(jq -r '.pipelines[].name' <<< "$LIST_PIPELINES_RESPONSE")
NEXT_TOKEN=$(jq -r '.nextToken' <<< "$LIST_PIPELINES_RESPONSE")
if [ "$NEXT_TOKEN" == "null" ];
then
HAS_NEXT_TOKEN=false
fi
for pipline_name in $LIST_PIPELINES
do
PIPELINE=$(aws codepipeline get-pipeline --name $pipline_name --region $REGION)
HAS_POLLABLE_ACTIONS=$(jq '.pipeline.stages[].actions[] | select(.actionTypeId.category == "Source") | select(.actionTypeId.owner == ("ThirdParty","AWS")) | select(.actionTypeId.provider == ("GitHub","S3","CodeCommit")) | select(.configuration.PollForSourceChanges == ("true",null))' <<< "$PIPELINE")
if [ ! -z "$HAS_POLLABLE_ACTIONS" ];
then
POLLING_PIPELINES+=("$pipline_name")
PIPELINE_EXECUTIONS=$(aws codepipeline list-pipeline-executions --pipeline-name $pipline_name --region $REGION)
LAST_EXECUTION=$(jq -r '.pipelineExecutionSummaries[0]' <<< "$PIPELINE_EXECUTIONS")
if [ "$LAST_EXECUTION" != "null" ];
then
LAST_EXECUTED_TIMESTAMP=$(jq -r '.startTime' <<< "$LAST_EXECUTION")
LAST_EXECUTED_DATE="$(date -r ${LAST_EXECUTED_TIMESTAMP%.*})"
else
LAST_EXECUTED_DATE="Not executed in last year"
fi
LAST_EXECUTED_DATES+=("$LAST_EXECUTED_DATE")
fi
done
done
fileName=$REGION-$(date +%s)
printf "| %-30s | %-30s |\n" "Polling Pipeline Name" "Last Executed Time"
printf "| %-30s | %-30s |\n" "_____________________" "__________________"
for i in "${!POLLING_PIPELINES[@]}"; do
printf "| %-30s | %-30s |\n" "${POLLING_PIPELINES[i]}" "${LAST_EXECUTED_DATES[i]}"
printf "${POLLING_PIPELINES[i]}," >> $fileName.csv
done
printf "\nSaving Polling Pipeline Names to file $fileName.csv."
```
+ Kopieren Sie den folgenden Code und fügen Sie ihn in das **PollingPipelinesExtractor.py-Skript** ein.
```
import boto3
import sys
import time
import math
hasNextToken = True
nextToken = ""
pollablePipelines = []
lastExecutedTimes = []
if len(sys.argv) == 1:
raise Exception("Please provide region name.")
session = boto3.Session(profile_name='default', region_name=sys.argv[1])
codepipeline = session.client('codepipeline')
def is_pollable_action(action):
actionTypeId = action['actionTypeId']
configuration = action['configuration']
return actionTypeId['owner'] in {"AWS", "ThirdParty"} and actionTypeId['provider'] in {"GitHub", "CodeCommit", "S3"} and ('PollForSourceChanges' not in configuration or configuration['PollForSourceChanges'] == 'true')
def has_pollable_actions(pipeline):
hasPollableAction = False
pipelineDefinition = codepipeline.get_pipeline(name=pipeline['name'])['pipeline']
for action in pipelineDefinition['stages'][0]['actions']:
hasPollableAction = is_pollable_action(action)
if hasPollableAction:
break
return hasPollableAction
def get_last_executed_time(pipelineName):
pipelineExecutions=codepipeline.list_pipeline_executions(pipelineName=pipelineName)['pipelineExecutionSummaries']
if pipelineExecutions:
return pipelineExecutions[0]['startTime'].strftime("%A %m/%d/%Y, %H:%M:%S")
else:
return "Not executed in last year"
while hasNextToken:
if nextToken=="":
list_pipelines_response = codepipeline.list_pipelines()
else:
list_pipelines_response = codepipeline.list_pipelines(nextToken=nextToken)
if 'nextToken' in list_pipelines_response:
nextToken = list_pipelines_response['nextToken']
else:
hasNextToken= False
for pipeline in list_pipelines_response['pipelines']:
if has_pollable_actions(pipeline):
pollablePipelines.append(pipeline['name'])
lastExecutedTimes.append(get_last_executed_time(pipeline['name']))
fileName="{region}-{timeNow}.csv".format(region=sys.argv[1],timeNow=math.trunc(time.time()))
file = open(fileName, 'w')
print ("{:<30} {:<30} {:<30}".format('Polling Pipeline Name', '|','Last Executed Time'))
print ("{:<30} {:<30} {:<30}".format('_____________________', '|','__________________'))
for i in range(len(pollablePipelines)):
print("{:<30} {:<30} {:<30}".format(pollablePipelines[i], '|', lastExecutedTimes[i]))
file.write("{pipeline},".format(pipeline=pollablePipelines[i]))
file.close()
print("\nSaving Polling Pipeline Names to file {fileName}".format(fileName=fileName))
```
1. Für jede Region, in der Sie Pipelines haben, müssen Sie das Skript für diese Region ausführen. Gehen Sie wie folgt vor, um das Skript auszuführen:
+ Führen Sie den folgenden Befehl aus, um das Skript mit dem Namen „**PollingPipelinesExtractor.sh**“ auszuführen. In diesem Beispiel ist die Region us-west-2.
```
./PollingPipelinesExtractor.sh us-west-2
```
+ **Führen Sie für das Python-Skript den folgenden Befehl aus, um das Python-Skript mit dem Namen PollingPipelinesExtractor .py auszuführen.** In diesem Beispiel ist die Region us-west-2.
```
python3 PollingPipelinesExtractor.py us-west-2
```
In der folgenden Beispielausgabe des Skripts gab die Region us-west-2 eine Liste von Polling-Pipelines zurück und zeigt die letzte Ausführungszeit für jede Pipeline an.
```
% ./pollingPipelineExtractor.sh us-west-2
| Polling Pipeline Name | Last Executed Time |
| _____________________ | __________________ |
| myCodeBuildPipeline | Wed Mar 8 09:35:49 PST 2023 |
| myCodeCommitPipeline | Mon Apr 24 22:32:32 PDT 2023 |
| TestPipeline | Not executed in last year |
Saving list of polling pipeline names to us-west-2-1682496174.csv...%
```
Analysieren Sie die Skriptausgabe und aktualisieren Sie für jede Pipeline in der Liste die Abfragequelle auf die empfohlene ereignisbasierte Methode zur Erkennung von Änderungen.
**Anmerkung**
Ihre Abfrage-Pipelines werden durch die Aktionskonfiguration der Pipeline für den Parameter bestimmt. `PollForSourceChanges` Wenn in der Konfiguration der Pipeline-Quelle der `PollForSourceChanges` Parameter weggelassen wurde, wird CodePipeline standardmäßig Ihr Repository nach Quelländerungen abgefragt. Dieses Verhalten ist dasselbe, als ob `PollForSourceChanges` es enthalten und auf true gesetzt wäre. Weitere Informationen finden Sie in den Konfigurationsparametern für die Quellaktion Ihrer Pipeline, z. B. in den Konfigurationsparametern der Amazon S3 S3-Quellaktion unter[Referenz zur Amazon S3 S3-Quellaktion](action-reference-S3.md).
Beachten Sie, dass dieses Skript auch eine .csv-Datei generiert, die die Liste der Abfrage-Pipelines in Ihrem Konto enthält, und die CSV-Datei im aktuellen Arbeitsordner speichert.
## Migrieren Sie Abfrage-Pipelines mit einer Quelle CodeCommit
Sie können Ihre Polling-Pipeline migrieren, um sie EventBridge zur Erkennung von Änderungen in Ihrem CodeCommit Quell-Repository oder Ihrem Amazon S3 S3-Quell-Bucket zu verwenden.
**CodeCommit**-- Bei einer Pipeline mit einer CodeCommit Quelle ändern Sie die Pipeline so, dass die Änderungserkennung automatisiert wird. EventBridge Wählen Sie aus den folgenden Methoden, um die Migration zu implementieren:
+ **Konsole:** [Migrieren von Abfrage-Pipelines (CodeCommit oder Amazon S3 S3-Quelle) (Konsole)](#update-change-detection-console-codecommit-S3)
+ **CLI:** [Migrieren von Abfrage-Pipelines (CodeCommit Quelle) (CLI)](#update-change-detection-cli-codecommit)
+ **CloudFormation: ** [Migrieren Sie Abfrage-Pipelines (CodeCommit Quelle) (CloudFormation Vorlage)](#update-change-detection-cfn-codecommit)
### Migrieren von Abfrage-Pipelines (CodeCommit oder Amazon S3 S3-Quelle) (Konsole)
Sie können die CodePipeline Konsole verwenden, um Ihre Pipeline zu aktualisieren, um Änderungen in Ihrem CodeCommit Quell-Repository oder Ihrem Amazon S3 S3-Quell-Bucket zu erkennen. EventBridge
**Anmerkung**
Wenn Sie die Konsole verwenden, um eine Pipeline zu bearbeiten, die über ein CodeCommit Quell-Repository oder einen Amazon S3 S3-Quell-Bucket verfügt, werden die Regel und die IAM-Rolle für Sie erstellt. Wenn Sie die AWS CLI Pipeline bearbeiten, müssen Sie die EventBridge Regel und die IAM-Rolle selbst erstellen. Weitere Informationen finden Sie unter [CodeCommit Quellaktionen und EventBridge](triggering.md).
Führen Sie die folgenden Schritte aus, um eine Pipeline zu bearbeiten, die periodische Prüfungen verwendet. Wenn Sie eine Pipeline erstellen möchten, informieren Sie sich unter [Eine Pipeline, Phasen und Aktionen erstellen](pipelines-create.md).
**So bearbeiten Sie die Quellphase einer Pipeline**
1. Melden Sie sich bei der an AWS-Managementkonsole und öffnen Sie die CodePipeline Konsole unter [http://console.aws.amazon. com/codesuite/codepipeline/home](https://console.aws.amazon.com/codesuite/codepipeline/home).
Die Namen aller mit Ihrem AWS Konto verknüpften Pipelines werden angezeigt.
1. Wählen Sie im Feld **Name** den Namen der Pipeline aus, die Sie bearbeiten möchten. Auf diese Weise wird eine detaillierte Ansicht der Pipeline geöffnet (einschließlich des Status der Aktionen in den einzelnen Stufen der Pipeline).
1. Wählen Sie auf der Pipelinedetails-Seite **Edit** aus.
1. Wählen Sie in der Stufe **Edit stage (Stufe bearbeiten)** das Bearbeitungssymbol für die Quellaktion aus.
1. Erweitern Sie die **Optionen zur Änderungserkennung** und wählen Sie ** CloudWatch Ereignisse verwenden, um meine Pipeline automatisch zu starten, wenn eine Änderung eintritt (empfohlen)**.
Es wird eine Meldung mit der EventBridge Regel angezeigt, die für diese Pipeline erstellt werden soll. Wählen Sie **Aktualisieren** aus.
Wenn Sie eine Pipeline aktualisieren, die über eine Amazon S3 S3-Quelle verfügt, wird die folgende Meldung angezeigt. Wählen Sie **Aktualisieren** aus.
1. Wenn Sie die Bearbeitung der Pipeline abgeschlossen haben, wählen Sie **Save pipeline changes** aus, um zur Übersichtsseite zurückzukehren.
In einer Meldung wird der Name der EventBridge Regel angezeigt, die für Ihre Pipeline erstellt werden soll. Wählen Sie **Save and continue** aus.
1. Um Ihre Aktion zu testen, geben Sie eine Änderung frei, indem Sie mit dem AWS CLI eine Änderung an der Quelle festschreiben, die in der Quellphase der Pipeline angegeben wurde.
### Migrieren von Abfrage-Pipelines (CodeCommit Quelle) (CLI)
Gehen Sie wie folgt vor, um eine Pipeline zu bearbeiten, die Abfragen (regelmäßige Prüfungen) verwendet, um eine EventBridge Regel zum Starten der Pipeline zu verwenden. Wenn Sie eine Pipeline erstellen möchten, informieren Sie sich unter [Eine Pipeline, Phasen und Aktionen erstellen](pipelines-create.md).
Um eine ereignisgesteuerte Pipeline mit zu erstellen CodeCommit, bearbeiten Sie den `PollForSourceChanges` Parameter Ihrer Pipeline und erstellen dann die folgenden Ressourcen:
+ EventBridge Ereignis
+ IAM-Rolle, damit dieses Ereignis Ihre Pipeline starten kann
**Um den PollForSourceChanges Parameter Ihrer Pipeline zu bearbeiten**
**Wichtig**
Wenn Sie eine Pipeline mit dieser Methode erstellen, ist der Parameter `PollForSourceChanges` standardmäßig „true“, wenn er nicht ausdrücklich auf „false“ gesetzt wird. Wenn Sie ereignisbasierte Erkennung hinzufügen, müssen Sie den Parameter Ihrer Ausgabe hinzufügen und Ihn auf „false“ setzen, um die Abfrage zu deaktivieren. Andernfalls wird Ihre Pipeline bei einer einzigen Quelländerung zweimal gestartet. Details hierzu finden Sie unter [Gültige Einstellungen für den `PollForSourceChanges` Parameter](PollForSourceChanges-defaults.md).
1. Führen Sie den Befehl **get-pipeline** zum Kopieren der Pipeline-Struktur in eine JSON-Datei aus. Geben Sie für eine Pipeline mit dem Namen `MyFirstPipeline` den folgenden Befehl ein:
```
aws codepipeline get-pipeline --name MyFirstPipeline >pipeline.json
```
Dieser Befehl gibt nichts zurück. Die erstellte Datei sollte jedoch in dem Verzeichnis auftauchen, in dem Sie den Befehl ausgeführt haben.
1. Öffnen Sie die JSON-Datei in einem beliebigen Texteditor und bearbeiten Sie die Quellstufe, indem Sie den Parameter `PollForSourceChanges` in `false` ändern, wie in diesem Beispiel gezeigt.
**Warum nehme ich diese Änderung vor?** Durch Ändern dieses Parameters in `false` werden periodische Prüfungen deaktiviert. Sie können daher nur die ereignisbasierte Erkennung von Änderungen verwenden.
```
"configuration": {
"PollForSourceChanges": "false",
"BranchName": "main",
"RepositoryName": "MyTestRepo"
},
```
1. Wenn Sie mit einer Pipeline-Struktur arbeiten, die Sie mit dem Befehl **get-pipeline** abgerufen haben, müssen Sie die `metadata`-Zeilen aus der JSON-Datei entfernen. Andernfalls kann der **update-pipeline**-Befehl sie nicht nutzen. Entfernen Sie die `"metadata": { }`-Zeilen und die Felder `"created"`, `"pipelineARN"` und `"updated"`.
Entfernen Sie z. B. die folgenden Zeilen aus der Struktur:
```
"metadata": {
"pipelineArn": "arn:aws:codepipeline:region:account-ID:pipeline-name",
"created": "date",
"updated": "date"
},
```
Speichern Sie die Datei.
1. Um Ihre Änderungen zu übernehmen, führen Sie den Befehl **update-pipeline** aus und geben Sie die Pipeline-JSON-Datei an:
**Wichtig**
Achten Sie darauf, dass `file://` vor dem Dateinamen steht. Dies ist bei diesem Befehl erforderlich.
```
aws codepipeline update-pipeline --cli-input-json file://pipeline.json
```
Dieser Befehl gibt die gesamte Struktur der bearbeiteten Pipeline zurück.
**Anmerkung**
Der Befehl **update-pipeline** stoppt die Pipeline. Wenn eine Revision über die Pipeline ausgeführt wird, wenn Sie den Befehl **update-pipeline** ausführen, wird diese Ausführung gestoppt. Sie müssen die Ausführung der Pipeline manuell starten, um die Revision über die aktualisierte Pipeline auszuführen. Verwenden Sie den **`start-pipeline-execution`**-Befehl, um Ihre Pipeline manuell zu starten.
**Um eine EventBridge Regel mit CodeCommit als Ereignisquelle und CodePipeline als Ziel zu erstellen**
1. Fügen Sie Berechtigungen hinzu EventBridge , die CodePipeline zum Aufrufen der Regel verwendet werden sollen. Weitere Informationen finden Sie unter [Verwenden ressourcenbasierter Richtlinien für Amazon](https://docs.aws.amazon.com/eventbridge/latest/userguide/eb-use-resource-based.html). EventBridge
1. Verwenden Sie das folgende Beispiel, um die Vertrauensrichtlinie zu erstellen, die es ermöglicht, die Servicerolle EventBridge zu übernehmen. Geben Sie der Vertrauensrichtlinie den Namen `trustpolicyforEB.json`.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": "events.amazonaws.com"
},
"Action": "sts:AssumeRole"
}
]
}
```
------
1. Verwenden Sie den folgenden Befehl, um die `Role-for-MyRule`-Rolle zu erstellen und die Vertrauensrichtlinie anzufügen.
```
aws iam create-role --role-name Role-for-MyRule --assume-role-policy-document file://trustpolicyforEB.json
```
1. Erstellen Sie die JSON-Datei der Berechtigungsrichtlinie wie in diesem Beispiel für die Pipeline mit dem Namen `MyFirstPipeline` gezeigt. Geben Sie der Berechtigungsrichtlinie den Namen `permissionspolicyforEB.json`.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"codepipeline:StartPipelineExecution"
],
"Resource": [
"arn:aws:codepipeline:us-west-2:111122223333:MyFirstPipeline"
]
}
]
}
```
------
1. Verwenden Sie den folgenden Befehl, um die Berechtigungsrichtlinie `CodePipeline-Permissions-Policy-for-EB` der Rolle `Role-for-MyRule` anzufügen.
**Warum nehme ich diese Änderung vor?** Durch das Hinzufügen dieser Richtlinie zur Rolle werden Berechtigungen für erstellt EventBridge.
```
aws iam put-role-policy --role-name Role-for-MyRule --policy-name CodePipeline-Permissions-Policy-For-EB --policy-document file://permissionspolicyforEB.json
```
1. Rufen Sie den Befehl „**put-rule**“ auf und beziehen Sie die Parameter „`--name`“, „`--event-pattern`“ und „`--role-arn`“ ein.
**Warum nehme ich diese Änderung vor?** Dieser Befehl aktiviert CloudFormation , um das Ereignis zu erstellen.
Mit dem folgenden Beispielbefehl wird eine Regel mit dem Namen „`MyCodeCommitRepoRule`“ erstellt.
```
aws events put-rule --name "MyCodeCommitRepoRule" --event-pattern "{\"source\":[\"aws.codecommit\"],\"detail-type\":[\"CodeCommit Repository State Change\"],\"resources\":[\"repository-ARN\"],\"detail\":{\"referenceType\":[\"branch\"],\"referenceName\":[\"main\"]}}" --role-arn "arn:aws:iam::ACCOUNT_ID:role/Role-for-MyRule"
```
1. Um es CodePipeline als Ziel hinzuzufügen, rufen Sie den **put-targets** Befehl auf und geben Sie die folgenden Parameter an:
+ Der Parameter `--rule` wird für den `rule_name` verwendet, den Sie mit **put-rule** erstellt haben.
+ Der Parameter `--targets` wird für die Listen-`Id` des Ziels in der Zielliste und den `ARN` der Ziel-Pipeline verwendet.
Der folgende Beispielbefehl legt fest, dass für die Regel mit dem Namen `MyCodeCommitRepoRule` die Ziel-`Id` aus der Nummer 1 besteht. Dies bedeutet, dass in einer Liste mit Zielen für die Regel dieses Ziel 1 ist. Der Beispielbefehl gibt zudem ein Beispiel `ARN` für die Pipeline an. Die Pipeline startet, wenn Änderungen im Repository auftreten.
```
aws events put-targets --rule MyCodeCommitRepoRule --targets Id=1,Arn=arn:aws:codepipeline:us-west-2:80398EXAMPLE:TestPipeline
```
1. (Optional) Um einen Eingangstransformator mit Quellüberschreibungen für eine bestimmte Bild-ID zu konfigurieren, verwenden Sie den folgenden JSON-Code in Ihrem CLI-Befehl. Im folgenden Beispiel wird eine Überschreibung konfiguriert, wobei:
+ `Source`In diesem Beispiel handelt es sich um den dynamischen Wert, der bei der Pipelineerstellung definiert wurde und nicht aus dem Quellereignis abgeleitet wurde. `actionName`
+ `COMMIT_ID`In diesem Beispiel handelt es sich um den dynamischen Wert, der bei der Pipelineerstellung definiert wurde und nicht aus dem Quellereignis abgeleitet wurde. `revisionType`
+ In diesem Beispiel wird < *revisionValue* > von der Quellereignisvariablen abgeleitet. `revisionValue`
```
{
"Rule": "my-rule",
"Targets": [
{
"Id": "MyTargetId",
"Arn": "pipeline-ARN",
"InputTransformer": {
"sourceRevisions": {
"actionName": "Source",
"revisionType": "COMMIT_ID",
"revisionValue": ""
},
"variables": [
{
"name": "Branch_Name",
"value": "value"
}
]
}
}
]
}
```
### Migrieren Sie Abfrage-Pipelines (CodeCommit Quelle) (CloudFormation Vorlage)
Um eine ereignisgesteuerte Pipeline mit zu erstellen AWS CodeCommit, bearbeiten Sie den `PollForSourceChanges` Parameter Ihrer Pipeline und fügen dann Ihrer Vorlage die folgenden Ressourcen hinzu:
+ Eine Regel EventBridge
+ Eine IAM-Rolle für Ihre Regel EventBridge
Wenn Sie CloudFormation Ihre Pipelines erstellen und verwalten, enthält Ihre Vorlage Inhalte wie die folgenden.
**Anmerkung**
Die `Configuration`-Eigenschaft in der Quellstufe mit dem Namen `PollForSourceChanges`. Wenn diese Eigenschaft in Ihrer Vorlage nicht enthalten ist, dann wird `PollForSourceChanges` standardmäßig auf `true` festgelegt.
------
#### [ YAML ]
```
Resources:
AppPipeline:
Type: AWS::CodePipeline::Pipeline
Properties:
Name: codecommit-polling-pipeline
RoleArn:
!GetAtt CodePipelineServiceRole.Arn
Stages:
-
Name: Source
Actions:
-
Name: SourceAction
ActionTypeId:
Category: Source
Owner: AWS
Version: 1
Provider: CodeCommit
OutputArtifacts:
- Name: SourceOutput
Configuration:
BranchName: !Ref BranchName
RepositoryName: !Ref RepositoryName
PollForSourceChanges: true
RunOrder: 1
```
------
#### [ JSON ]
```
"Stages": [
{
"Name": "Source",
"Actions": [{
"Name": "SourceAction",
"ActionTypeId": {
"Category": "Source",
"Owner": "AWS",
"Version": 1,
"Provider": "CodeCommit"
},
"OutputArtifacts": [{
"Name": "SourceOutput"
}],
"Configuration": {
"BranchName": {
"Ref": "BranchName"
},
"RepositoryName": {
"Ref": "RepositoryName"
},
"PollForSourceChanges": true
},
"RunOrder": 1
}]
},
```
------
**Um Ihre CloudFormation Pipeline-Vorlage zu aktualisieren und eine Regel zu erstellen EventBridge**
1. Verwenden Sie in der Vorlage unter die `AWS::IAM::Role` CloudFormation Ressource`Resources`, um die IAM-Rolle zu konfigurieren, mit der Ihre Veranstaltung Ihre Pipeline starten kann. Dieser Eintrag erstellt eine Rolle mit zwei Richtlinien:
+ Die erste Richtlinie ermöglicht die Übernahme der Rolle.
+ Die zweite Richtlinie stellt Berechtigungen zum Starten der Pipeline bereit.
**Warum nehme ich diese Änderung vor?** Durch das Hinzufügen der `AWS::IAM::Role` Ressource können CloudFormation Sie Berechtigungen für EventBridge erstellen. Diese Ressource wird Ihrem CloudFormation Stack hinzugefügt.
------
#### [ YAML ]
```
EventRole:
Type: AWS::IAM::Role
Properties:
AssumeRolePolicyDocument:
Version: 2012-10-17
Statement:
-
Effect: Allow
Principal:
Service:
- events.amazonaws.com
Action: sts:AssumeRole
Path: /
Policies:
-
PolicyName: eb-pipeline-execution
PolicyDocument:
Version: 2012-10-17
Statement:
-
Effect: Allow
Action: codepipeline:StartPipelineExecution
Resource: !Join [ '', [ 'arn:aws:codepipeline:', !Ref 'AWS::Region', ':', !Ref 'AWS::AccountId', ':', !Ref AppPipeline ] ]
```
------
#### [ JSON ]
```
"EventRole": {
"Type": "AWS::IAM::Role",
"Properties": {
"AssumeRolePolicyDocument": {
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": [
"events.amazonaws.com"
]
},
"Action": "sts:AssumeRole"
}
]
},
"Path": "/",
"Policies": [
{
"PolicyName": "eb-pipeline-execution",
"PolicyDocument": {
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": "codepipeline:StartPipelineExecution",
"Resource": {
"Fn::Join": [
"",
[
"arn:aws:codepipeline:",
{
"Ref": "AWS::Region"
},
":",
{
"Ref": "AWS::AccountId"
},
":",
{
"Ref": "AppPipeline"
}
]
...
```
------
1. Verwenden Sie in der Vorlage unter die `AWS::Events::Rule` CloudFormation Ressource`Resources`, um eine EventBridge Regel hinzuzufügen. Dieses Ereignismuster erzeugt ein Ereignis, das Push-Änderungen an Ihrem Repository überwacht. Wenn eine Änderung des Repository-Status EventBridge erkannt wird, wird die Regel in `StartPipelineExecution` Ihrer Zielpipeline aufgerufen.
**Warum nehme ich diese Änderung vor?** Durch Hinzufügen der `AWS::Events::Rule` Ressource kann CloudFormation das Ereignis erstellt werden. Diese Ressource wird Ihrem CloudFormation Stack hinzugefügt.
------
#### [ YAML ]
```
EventRule:
Type: AWS::Events::Rule
Properties:
EventPattern:
source:
- aws.codecommit
detail-type:
- 'CodeCommit Repository State Change'
resources:
- !Join [ '', [ 'arn:aws:codecommit:', !Ref 'AWS::Region', ':', !Ref 'AWS::AccountId', ':', !Ref RepositoryName ] ]
detail:
event:
- referenceCreated
- referenceUpdated
referenceType:
- branch
referenceName:
- main
Targets:
-
Arn:
!Join [ '', [ 'arn:aws:codepipeline:', !Ref 'AWS::Region', ':', !Ref 'AWS::AccountId', ':', !Ref AppPipeline ] ]
RoleArn: !GetAtt EventRole.Arn
Id: codepipeline-AppPipeline
```
------
#### [ JSON ]
```
"EventRule": {
"Type": "AWS::Events::Rule",
"Properties": {
"EventPattern": {
"source": [
"aws.codecommit"
],
"detail-type": [
"CodeCommit Repository State Change"
],
"resources": [
{
"Fn::Join": [
"",
[
"arn:aws:codecommit:",
{
"Ref": "AWS::Region"
},
":",
{
"Ref": "AWS::AccountId"
},
":",
{
"Ref": "RepositoryName"
}
]
]
}
],
"detail": {
"event": [
"referenceCreated",
"referenceUpdated"
],
"referenceType": [
"branch"
],
"referenceName": [
"main"
]
}
},
"Targets": [
{
"Arn": {
"Fn::Join": [
"",
[
"arn:aws:codepipeline:",
{
"Ref": "AWS::Region"
},
":",
{
"Ref": "AWS::AccountId"
},
":",
{
"Ref": "AppPipeline"
}
]
]
},
"RoleArn": {
"Fn::GetAtt": [
"EventRole",
"Arn"
]
},
"Id": "codepipeline-AppPipeline"
}
]
}
},
```
------
1. (Optional) Verwenden Sie den folgenden YAML-Snippet, um einen Eingangstransformator mit Quellüberschreibungen für eine bestimmte Bild-ID zu konfigurieren. Im folgenden Beispiel wird eine Überschreibung konfiguriert, wobei:
+ `Source`In diesem Beispiel handelt es sich um den dynamischen Wert, der bei der Pipelineerstellung definiert wurde und nicht aus dem Quellereignis abgeleitet wurde. `actionName`
+ `COMMIT_ID`In diesem Beispiel handelt es sich um den dynamischen Wert, der bei der Pipelineerstellung definiert wurde und nicht aus dem Quellereignis abgeleitet wurde. `revisionType`
+ In diesem Beispiel wird < *revisionValue* > von der Quellereignisvariablen abgeleitet. `revisionValue`
+ Die Ausgabevariablen für `BranchName` und `Value` sind angegeben.
```
Rule: my-rule
Targets:
- Id: MyTargetId
Arn: pipeline-ARN
InputTransformer:
sourceRevisions:
actionName: Source
revisionType: COMMIT_ID
revisionValue:
variables:
- name: BranchName
value: value
```
1. Speichern Sie die aktualisierte Vorlage auf Ihrem lokalen Computer, und öffnen Sie dann die CloudFormation Konsole.
1. Wählen Sie Ihren Stack aus und klicken Sie auf **Create Change Set for Current Stack (Änderungssatz für laufenden Stack erstellen)**.
1. Laden Sie die Vorlage hoch und zeigen Sie dann die in CloudFormation aufgeführten Änderungen an. Dies sind die Änderungen, die am Stack vorgenommen werden sollen. Ihre neuen Ressourcen sollten in der Liste angezeigt werden.
1. Wählen Sie **Ausführen**.
**Um den PollForSourceChanges Parameter Ihrer Pipeline zu bearbeiten**
**Wichtig**
In vielen Fällen ist der Parameter `PollForSourceChanges` „true“, wenn Sie eine Pipeline erstellen. Wenn Sie ereignisbasierte Erkennung hinzufügen, müssen Sie den Parameter Ihrer Ausgabe hinzufügen und Ihn auf „false“ setzen, um die Abfrage zu deaktivieren. Andernfalls wird Ihre Pipeline bei einer einzigen Quelländerung zweimal gestartet. Details hierzu finden Sie unter [Gültige Einstellungen für den `PollForSourceChanges` Parameter](PollForSourceChanges-defaults.md).
+ Ändern Sie in der Vorlage `PollForSourceChanges` in `false`. Wenn Sie `PollForSourceChanges` nicht in Ihre Pipeline-Definition einbezogen haben, fügen Sie das Objekt hinzu und legen es auf `false` fest.
**Warum nehme ich diese Änderung vor?** Durch Ändern dieses Parameters in `false` werden periodische Prüfungen deaktiviert. Sie können daher nur die ereignisbasierte Erkennung von Änderungen verwenden.
------
#### [ YAML ]
```
Name: Source
Actions:
-
Name: SourceAction
ActionTypeId:
Category: Source
Owner: AWS
Version: 1
Provider: CodeCommit
OutputArtifacts:
- Name: SourceOutput
Configuration:
BranchName: !Ref BranchName
RepositoryName: !Ref RepositoryName
PollForSourceChanges: false
RunOrder: 1
```
------
#### [ JSON ]
```
{
"Name": "Source",
"Actions": [
{
"Name": "SourceAction",
"ActionTypeId": {
"Category": "Source",
"Owner": "AWS",
"Version": 1,
"Provider": "CodeCommit"
},
"OutputArtifacts": [
{
"Name": "SourceOutput"
}
],
"Configuration": {
"BranchName": {
"Ref": "BranchName"
},
"RepositoryName": {
"Ref": "RepositoryName"
},
"PollForSourceChanges": false
},
"RunOrder": 1
}
]
},
```
------
**Example**
Wenn Sie diese Ressourcen mit erstellen CloudFormation, wird Ihre Pipeline ausgelöst, wenn Dateien in Ihrem Repository erstellt oder aktualisiert werden. Im Folgenden finden Sie den endgültigen Vorlagenausschnitt:
```
Resources:
EventRole:
Type: AWS::IAM::Role
Properties:
AssumeRolePolicyDocument:
Version: 2012-10-17
Statement:
-
Effect: Allow
Principal:
Service:
- events.amazonaws.com
Action: sts:AssumeRole
Path: /
Policies:
-
PolicyName: eb-pipeline-execution
PolicyDocument:
Version: 2012-10-17
Statement:
-
Effect: Allow
Action: codepipeline:StartPipelineExecution
Resource: !Join [ '', [ 'arn:aws:codepipeline:', !Ref 'AWS::Region', ':', !Ref 'AWS::AccountId', ':', !Ref AppPipeline ] ]
EventRule:
Type: AWS::Events::Rule
Properties:
EventPattern:
source:
- aws.codecommit
detail-type:
- 'CodeCommit Repository State Change'
resources:
- !Join [ '', [ 'arn:aws:codecommit:', !Ref 'AWS::Region', ':', !Ref 'AWS::AccountId', ':', !Ref RepositoryName ] ]
detail:
event:
- referenceCreated
- referenceUpdated
referenceType:
- branch
referenceName:
- main
Targets:
-
Arn:
!Join [ '', [ 'arn:aws:codepipeline:', !Ref 'AWS::Region', ':', !Ref 'AWS::AccountId', ':', !Ref AppPipeline ] ]
RoleArn: !GetAtt EventRole.Arn
Id: codepipeline-AppPipeline
AppPipeline:
Type: AWS::CodePipeline::Pipeline
Properties:
Name: codecommit-events-pipeline
RoleArn:
!GetAtt CodePipelineServiceRole.Arn
Stages:
-
Name: Source
Actions:
-
Name: SourceAction
ActionTypeId:
Category: Source
Owner: AWS
Version: 1
Provider: CodeCommit
OutputArtifacts:
- Name: SourceOutput
Configuration:
BranchName: !Ref BranchName
RepositoryName: !Ref RepositoryName
PollForSourceChanges: false
RunOrder: 1
...
```
```
"Resources": {
...
"EventRole": {
"Type": "AWS::IAM::Role",
"Properties": {
"AssumeRolePolicyDocument": {
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": [
"events.amazonaws.com"
]
},
"Action": "sts:AssumeRole"
}
]
},
"Path": "/",
"Policies": [
{
"PolicyName": "eb-pipeline-execution",
"PolicyDocument": {
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": "codepipeline:StartPipelineExecution",
"Resource": {
"Fn::Join": [
"",
[
"arn:aws:codepipeline:",
{
"Ref": "AWS::Region"
},
":",
{
"Ref": "AWS::AccountId"
},
":",
{
"Ref": "AppPipeline"
}
]
]
}
}
]
}
}
]
}
},
"EventRule": {
"Type": "AWS::Events::Rule",
"Properties": {
"EventPattern": {
"source": [
"aws.codecommit"
],
"detail-type": [
"CodeCommit Repository State Change"
],
"resources": [
{
"Fn::Join": [
"",
[
"arn:aws:codecommit:",
{
"Ref": "AWS::Region"
},
":",
{
"Ref": "AWS::AccountId"
},
":",
{
"Ref": "RepositoryName"
}
]
]
}
],
"detail": {
"event": [
"referenceCreated",
"referenceUpdated"
],
"referenceType": [
"branch"
],
"referenceName": [
"main"
]
}
},
"Targets": [
{
"Arn": {
"Fn::Join": [
"",
[
"arn:aws:codepipeline:",
{
"Ref": "AWS::Region"
},
":",
{
"Ref": "AWS::AccountId"
},
":",
{
"Ref": "AppPipeline"
}
]
]
},
"RoleArn": {
"Fn::GetAtt": [
"EventRole",
"Arn"
]
},
"Id": "codepipeline-AppPipeline"
}
]
}
},
"AppPipeline": {
"Type": "AWS::CodePipeline::Pipeline",
"Properties": {
"Name": "codecommit-events-pipeline",
"RoleArn": {
"Fn::GetAtt": [
"CodePipelineServiceRole",
"Arn"
]
},
"Stages": [
{
"Name": "Source",
"Actions": [
{
"Name": "SourceAction",
"ActionTypeId": {
"Category": "Source",
"Owner": "AWS",
"Version": 1,
"Provider": "CodeCommit"
},
"OutputArtifacts": [
{
"Name": "SourceOutput"
}
],
"Configuration": {
"BranchName": {
"Ref": "BranchName"
},
"RepositoryName": {
"Ref": "RepositoryName"
},
"PollForSourceChanges": false
},
"RunOrder": 1
}
]
},
...
```
## Migrieren Sie Abfrage-Pipelines mit einer für Ereignisse aktivierten S3-Quelle
Bei einer Pipeline mit einer Amazon S3 S3-Quelle ändern Sie die Pipeline so, dass die Änderungserkennung über EventBridge und mit einem Quell-Bucket, der für Ereignisbenachrichtigungen aktiviert ist, automatisiert wird. Dies ist die empfohlene Methode, wenn Sie die CLI verwenden oder Ihre Pipeline migrieren CloudFormation möchten.
**Anmerkung**
Dazu gehört die Verwendung eines Buckets, der für Ereignisbenachrichtigungen aktiviert ist, sodass Sie keinen separaten CloudTrail Trail erstellen müssen. Wenn Sie die Konsole verwenden, werden eine Ereignisregel und ein CloudTrail Trail für Sie eingerichtet. Informationen zu diesen Schritten finden Sie unter[Migrieren Sie Polling-Pipelines mit einer S3-Quelle und einem S3-Trail CloudTrail](#update-change-detection-S3).
+ **CLI:** [Migrieren Sie Polling-Pipelines mit einer S3-Quelle und einem CloudTrail S3-Trail (CLI)](#update-change-detection-cli-S3)
+ **CloudFormation: **[Migrieren Sie Polling-Pipelines mit einer S3-Quelle und einem CloudTrail S3-Trail (Vorlage)CloudFormation](#update-change-detection-cfn-s3)
### Migrieren Sie Abfrage-Pipelines mit einer für Ereignisse aktivierten S3-Quelle (CLI)
Gehen Sie wie folgt vor, um eine Pipeline zu bearbeiten, die Polling (regelmäßige Prüfungen) verwendet, um stattdessen ein Ereignis in zu verwenden. EventBridge Wenn Sie eine Pipeline erstellen möchten, informieren Sie sich unter [Eine Pipeline, Phasen und Aktionen erstellen](pipelines-create.md).
Um eine ereignisgesteuerte Pipeline mit Amazon S3 zu erstellen, bearbeiten Sie den `PollForSourceChanges` Parameter Ihrer Pipeline und erstellen dann die folgenden Ressourcen:
+ EventBridge Ereignisregel
+ IAM-Rolle, damit das EventBridge Ereignis Ihre Pipeline starten kann
**Um eine EventBridge Regel mit Amazon S3 als Ereignisquelle und CodePipeline als Ziel zu erstellen und die Berechtigungsrichtlinie anzuwenden**
1. Erteilen Sie Berechtigungen EventBridge , die CodePipeline zum Aufrufen der Regel verwendet werden können. Weitere Informationen finden Sie unter [Verwenden ressourcenbasierter Richtlinien für Amazon](https://docs.aws.amazon.com/eventbridge/latest/userguide/eb-use-resource-based.html). EventBridge
1. Verwenden Sie das folgende Beispiel zum Erstellen der Vertrauensrichtlinie, mit der EventBridge die Servicerolle übernehmen kann. Geben Sie ihr den Namen `trustpolicyforEB.json`.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": "events.amazonaws.com"
},
"Action": "sts:AssumeRole"
}
]
}
```
------
1. Verwenden Sie den folgenden Befehl, um die `Role-for-MyRule`-Rolle zu erstellen und die Vertrauensrichtlinie anzufügen.
**Warum nehme ich diese Änderung vor?** Durch das Hinzufügen dieser Vertrauensrichtlinie zur Rolle werden Berechtigungen für EventBridge erstellt.
```
aws iam create-role --role-name Role-for-MyRule --assume-role-policy-document file://trustpolicyforEB.json
```
1. Erstellen Sie die JSON-Datei der Berechtigungsrichtlinie wie hier für die Pipeline mit dem Namen `MyFirstPipeline` gezeigt. Geben Sie der Berechtigungsrichtlinie den Namen `permissionspolicyforEB.json`.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"codepipeline:StartPipelineExecution"
],
"Resource": [
"arn:aws:codepipeline:us-west-2:111122223333:MyFirstPipeline"
]
}
]
}
```
------
1. Führen Sie den folgenden Befehl aus, um der erstellten `Role-for-MyRule`-Rolle die neue `CodePipeline-Permissions-Policy-for-EB`-Berechtigungsrichtlinie anzufügen.
```
aws iam put-role-policy --role-name Role-for-MyRule --policy-name CodePipeline-Permissions-Policy-For-EB --policy-document file://permissionspolicyforEB.json
```
1. Rufen Sie den Befehl „**put-rule**“ auf und beziehen Sie die Parameter „`--name`“, „`--event-pattern`“ und „`--role-arn`“ ein.
Mit dem folgenden Beispielbefehl wird eine Regel mit dem Namen „`EnabledS3SourceRule`“ erstellt.
```
aws events put-rule --name "EnabledS3SourceRule" --event-pattern "{\"source\":[\"aws.s3\"],\"detail-type\":[\"Object Created\"],\"detail\":{\"bucket\":{\"name\":[\"amzn-s3-demo-source-bucket\"]}}}" --role-arn "arn:aws:iam::ACCOUNT_ID:role/Role-for-MyRule"
```
1. Um es CodePipeline als Ziel hinzuzufügen, rufen Sie den **put-targets** Befehl auf und geben Sie die Parameter `--rule` und `--targets` an.
Der folgende Befehl legt fest, dass für die Regel mit dem Namen `EnabledS3SourceRule` die Ziel-`Id` aus der Nummer 1 besteht. Dies bedeutet, dass in einer Liste mit Zielen für die Regel dies Ziel 1 ist. Der Befehl gibt zudem ein Beispiel `ARN` für die Pipeline an. Die Pipeline startet, wenn Änderungen im Repository auftreten.
```
aws events put-targets --rule EnabledS3SourceRule --targets Id=codepipeline-AppPipeline,Arn=arn:aws:codepipeline:us-west-2:80398EXAMPLE:TestPipeline
```
**Um den PollForSourceChanges Parameter Ihrer Pipeline zu bearbeiten**
**Wichtig**
Wenn Sie eine Pipeline mit dieser Methode erstellen, ist der Parameter `PollForSourceChanges` standardmäßig „true“, wenn er nicht ausdrücklich auf „false“ gesetzt wird. Wenn Sie ereignisbasierte Erkennung hinzufügen, müssen Sie den Parameter Ihrer Ausgabe hinzufügen und Ihn auf „false“ setzen, um die Abfrage zu deaktivieren. Andernfalls wird Ihre Pipeline bei einer einzigen Quelländerung zweimal gestartet. Details hierzu finden Sie unter [Gültige Einstellungen für den `PollForSourceChanges` Parameter](PollForSourceChanges-defaults.md).
1. Führen Sie den Befehl **get-pipeline** zum Kopieren der Pipeline-Struktur in eine JSON-Datei aus. Geben Sie für eine Pipeline mit dem Namen `MyFirstPipeline` den folgenden Befehl ein:
```
aws codepipeline get-pipeline --name MyFirstPipeline >pipeline.json
```
Dieser Befehl gibt nichts zurück. Die erstellte Datei sollte jedoch in dem Verzeichnis auftauchen, in dem Sie den Befehl ausgeführt haben.
1. Öffnen Sie die JSON-Datei in einem Texteditor und bearbeiten Sie die Quellphase, indem Sie den Parameter `PollForSourceChanges` für einen Bucket mit dem Namen `amzn-s3-demo-source-bucket`in `false` ändern wie in diesem Beispiel gezeigt.
**Warum nehme ich diese Änderung vor?** Durch Festlegen dieses Parameters in `false` werden periodische Prüfungen deaktiviert. Sie können daher nur die ereignisbasierte Erkennung von Änderungen verwenden.
```
"configuration": {
"S3Bucket": "amzn-s3-demo-source-bucket",
"PollForSourceChanges": "false",
"S3ObjectKey": "index.zip"
},
```
1. Wenn Sie mit einer Pipeline-Struktur arbeiten, die Sie mit dem Befehl **get-pipeline** abgerufen haben, müssen Sie die `metadata`-Zeilen aus der JSON-Datei entfernen. Andernfalls kann der **update-pipeline**-Befehl sie nicht nutzen. Entfernen Sie die `"metadata": { }`-Zeilen und die Felder `"created"`, `"pipelineARN"` und `"updated"`.
Entfernen Sie z. B. die folgenden Zeilen aus der Struktur:
```
"metadata": {
"pipelineArn": "arn:aws:codepipeline:region:account-ID:pipeline-name",
"created": "date",
"updated": "date"
},
```
Speichern Sie die Datei.
1. Um Ihre Änderungen zu übernehmen, führen Sie den Befehl **update-pipeline** aus und geben Sie die Pipeline-JSON-Datei an:
**Wichtig**
Achten Sie darauf, dass `file://` vor dem Dateinamen steht. Dies ist bei diesem Befehl erforderlich.
```
aws codepipeline update-pipeline --cli-input-json file://pipeline.json
```
Dieser Befehl gibt die gesamte Struktur der bearbeiteten Pipeline zurück.
**Anmerkung**
Der Befehl **update-pipeline** stoppt die Pipeline. Wenn eine Revision über die Pipeline ausgeführt wird, wenn Sie den Befehl **update-pipeline** ausführen, wird diese Ausführung gestoppt. Sie müssen die Ausführung der Pipeline manuell starten, um die Revision über die aktualisierte Pipeline auszuführen. Verwenden Sie den **start-pipeline-execution**-Befehl, um Ihre Pipeline manuell zu starten.
### Migrieren Sie Abfrage-Pipelines mit einer für Ereignisse aktivierten S3-Quelle (Vorlage)CloudFormation
Dieses Verfahren gilt für eine Pipeline, bei der im Quell-Bucket Ereignisse aktiviert sind.
Gehen Sie wie folgt vor, um Ihre Pipeline mit einer Amazon S3 S3-Quelle von der Abfrage bis zur ereignisbasierten Änderungserkennung zu bearbeiten.
Um eine ereignisgesteuerte Pipeline mit Amazon S3 zu erstellen, bearbeiten Sie den `PollForSourceChanges` Parameter Ihrer Pipeline und fügen dann die folgenden Ressourcen zu Ihrer Vorlage hinzu:
+ EventBridge Regel und IAM-Rolle, damit dieses Ereignis Ihre Pipeline starten kann.
Wenn Sie CloudFormation Ihre Pipelines erstellen und verwalten, enthält Ihre Vorlage Inhalte wie den folgenden.
**Anmerkung**
Die `Configuration`-Eigenschaft in der Quellstufe mit dem Namen `PollForSourceChanges`. Wenn diese Eigenschaft in Ihrer Vorlage nicht enthalten ist, dann wird `PollForSourceChanges` standardmäßig auf `true` festgelegt.
------
#### [ YAML ]
```
AppPipeline:
Type: AWS::CodePipeline::Pipeline
Properties:
RoleArn: !GetAtt CodePipelineServiceRole.Arn
Stages:
-
Name: Source
Actions:
-
Name: SourceAction
ActionTypeId:
Category: Source
Owner: AWS
Version: 1
Provider: S3
OutputArtifacts:
-
Name: SourceOutput
Configuration:
S3Bucket: !Ref SourceBucket
S3ObjectKey: !Ref S3SourceObjectKey
PollForSourceChanges: true
RunOrder: 1
...
```
------
#### [ JSON ]
```
"AppPipeline": {
"Type": "AWS::CodePipeline::Pipeline",
"Properties": {
"RoleArn": {
"Fn::GetAtt": ["CodePipelineServiceRole", "Arn"]
},
"Stages": [
{
"Name": "Source",
"Actions": [
{
"Name": "SourceAction",
"ActionTypeId": {
"Category": "Source",
"Owner": "AWS",
"Version": 1,
"Provider": "S3"
},
"OutputArtifacts": [
{
"Name": "SourceOutput"
}
],
"Configuration": {
"S3Bucket": {
"Ref": "SourceBucket"
},
"S3ObjectKey": {
"Ref": "SourceObjectKey"
},
"PollForSourceChanges": true
},
"RunOrder": 1
}
]
},
...
```
------
**Um eine EventBridge Regel mit Amazon S3 als Ereignisquelle und CodePipeline als Ziel zu erstellen und die Berechtigungsrichtlinie anzuwenden**
1. Verwenden Sie in der Vorlage unter die `AWS::IAM::Role` CloudFormation Ressource`Resources`, um die IAM-Rolle zu konfigurieren, mit der Ihr Ereignis Ihre Pipeline starten kann. Dieser Eintrag erstellt eine Rolle mit zwei Richtlinien:
+ Die erste Richtlinie ermöglicht die Übernahme der Rolle.
+ Die zweite Richtlinie stellt Berechtigungen zum Starten der Pipeline bereit.
**Warum nehme ich diese Änderung vor?** Durch das Hinzufügen einer `AWS::IAM::Role` Ressource können CloudFormation Sie Berechtigungen für EventBridge erstellen. Diese Ressource wird Ihrem CloudFormation Stack hinzugefügt.
------
#### [ YAML ]
```
EventRole:
Type: AWS::IAM::Role
Properties:
AssumeRolePolicyDocument:
Version: 2012-10-17
Statement:
-
Effect: Allow
Principal:
Service:
- events.amazonaws.com
Action: sts:AssumeRole
Path: /
Policies:
-
PolicyName: eb-pipeline-execution
PolicyDocument:
Version: 2012-10-17
Statement:
-
Effect: Allow
Action: codepipeline:StartPipelineExecution
Resource: !Join [ '', [ 'arn:aws:codepipeline:', !Ref 'AWS::Region', ':', !Ref 'AWS::AccountId', ':', !Ref AppPipeline ] ]
...
```
------
#### [ JSON ]
```
"EventRole": {
"Type": "AWS::IAM::Role",
"Properties": {
"AssumeRolePolicyDocument": {
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": [
"events.amazonaws.com"
]
},
"Action": "sts:AssumeRole"
}
]
},
"Path": "/",
"Policies": [
{
"PolicyName": "eb-pipeline-execution",
"PolicyDocument": {
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": "codepipeline:StartPipelineExecution",
"Resource": {
"Fn::Join": [
"",
[
"arn:aws:codepipeline:",
{
"Ref": "AWS::Region"
},
":",
{
"Ref": "AWS::AccountId"
},
":",
{
"Ref": "AppPipeline"
}
]
]
...
```
------
1. Verwenden Sie die `AWS::Events::Rule` CloudFormation Ressource, um eine EventBridge Regel hinzuzufügen. Dieses Ereignismuster erzeugt ein Ereignis, das die Erstellung oder Löschung von Objekten in Ihrem Amazon S3 S3-Quell-Bucket überwacht. Fügen Sie darüber hinaus ein Ziel für Ihre Pipeline ein. Wenn ein Objekt erstellt wird, wird diese Regel in `StartPipelineExecution` Ihrer Zielpipeline aufgerufen.
**Warum nehme ich diese Änderung vor?** Durch das Hinzufügen der `AWS::Events::Rule` Ressource kann CloudFormation das Ereignis erstellt werden. Diese Ressource wird Ihrem CloudFormation Stack hinzugefügt.
------
#### [ YAML ]
```
EventRule:
Type: AWS::Events::Rule
Properties:
EventBusName: default
EventPattern:
source:
- aws.s3
detail-type:
- Object Created
detail:
bucket:
name:
- !Ref SourceBucket
Name: EnabledS3SourceRule
State: ENABLED
Targets:
-
Arn:
!Join [ '', [ 'arn:aws:codepipeline:', !Ref 'AWS::Region', ':', !Ref 'AWS::AccountId', ':', !Ref AppPipeline ] ]
RoleArn: !GetAtt EventRole.Arn
Id: codepipeline-AppPipeline
...
```
------
#### [ JSON ]
```
"EventRule": {
"Type": "AWS::Events::Rule",
"Properties": {
"EventBusName": "default",
"EventPattern": {
"source": [
"aws.s3"
],
"detail-type": [
"Object Created"
],
"detail": {
"bucket": {
"name": [
"s3-pipeline-source-fra-bucket"
]
}
}
},
"Name": "EnabledS3SourceRule",
"State": "ENABLED",
"Targets": [
{
"Arn": {
"Fn::Join": [
"",
[
"arn:aws:codepipeline:",
{
"Ref": "AWS::Region"
},
":",
{
"Ref": "AWS::AccountId"
},
":",
{
"Ref": "AppPipeline"
}
]
]
},
"RoleArn": {
"Fn::GetAtt": [
"EventRole",
"Arn"
]
},
"Id": "codepipeline-AppPipeline"
}
]
}
}
},
...
```
------
1. Speichern Sie Ihre aktualisierte Vorlage auf Ihrem lokalen Computer und öffnen Sie die CloudFormation -Konsole.
1. Wählen Sie Ihren Stack aus und klicken Sie auf **Create Change Set for Current Stack (Änderungssatz für laufenden Stack erstellen)**.
1. Laden Sie Ihre aktualisierte Vorlage hoch und zeigen Sie dann die in CloudFormation aufgeführten Änderungen an. Dies sind die Änderungen, die am Stack vorgenommen werden. Ihre neuen Ressourcen sollten in der Liste angezeigt werden.
1. Wählen Sie **Ausführen**.
**Um den PollForSourceChanges Parameter Ihrer Pipeline zu bearbeiten**
**Wichtig**
Wenn Sie eine Pipeline mit dieser Methode erstellen, ist der Parameter `PollForSourceChanges` standardmäßig „true“, wenn er nicht ausdrücklich auf „false“ gesetzt wird. Wenn Sie ereignisbasierte Erkennung hinzufügen, müssen Sie den Parameter Ihrer Ausgabe hinzufügen und Ihn auf „false“ setzen, um die Abfrage zu deaktivieren. Andernfalls wird Ihre Pipeline bei einer einzigen Quelländerung zweimal gestartet. Details hierzu finden Sie unter [Gültige Einstellungen für den `PollForSourceChanges` Parameter](PollForSourceChanges-defaults.md).
+ Ändern Sie in der Vorlage `PollForSourceChanges` in `false`. Wenn Sie `PollForSourceChanges` nicht in Ihre Pipeline-Definition einbezogen haben, fügen Sie das Objekt hinzu und legen es auf `false` fest.
**Warum nehme ich diese Änderung vor?** Durch Ändern von `PollForSourceChanges` in `false` werden periodische Prüfungen deaktiviert. Sie können daher nur die ereignisbasierte Erkennung von Änderungen verwenden.
------
#### [ YAML ]
```
Name: Source
Actions:
-
Name: SourceAction
ActionTypeId:
Category: Source
Owner: AWS
Version: 1
Provider: S3
OutputArtifacts:
- Name: SourceOutput
Configuration:
S3Bucket: !Ref SourceBucket
S3ObjectKey: !Ref SourceObjectKey
PollForSourceChanges: false
RunOrder: 1
```
------
#### [ JSON ]
```
{
"Name": "SourceAction",
"ActionTypeId": {
"Category": "Source",
"Owner": "AWS",
"Version": 1,
"Provider": "S3"
},
"OutputArtifacts": [
{
"Name": "SourceOutput"
}
],
"Configuration": {
"S3Bucket": {
"Ref": "SourceBucket"
},
"S3ObjectKey": {
"Ref": "SourceObjectKey"
},
"PollForSourceChanges": false
},
"RunOrder": 1
}
```
------
**Example**
Wenn Sie diese Ressourcen erstellen, wird Ihre Pipeline ausgelöst, wenn Dateien in Ihrem Repository erstellt oder aktualisiert werden. CloudFormation
Hören Sie hier nicht auf. Obwohl Ihre Pipeline erstellt wurde, müssen Sie eine zweite CloudFormation Vorlage für Ihre Amazon S3 S3-Pipeline erstellen. Wenn Sie die zweite Vorlage nicht erstellen, enthält Ihre Pipeline keine Funktionalität für die Änderungserkennung.
```
Parameters:
SourceObjectKey:
Description: 'S3 source artifact'
Type: String
Default: SampleApp_Linux.zip
ApplicationName:
Description: 'CodeDeploy application name'
Type: String
Default: DemoApplication
BetaFleet:
Description: 'Fleet configured in CodeDeploy'
Type: String
Default: DemoFleet
Resources:
SourceBucket:
Type: AWS::S3::Bucket
Properties:
NotificationConfiguration:
EventBridgeConfiguration:
EventBridgeEnabled: true
VersioningConfiguration:
Status: Enabled
CodePipelineArtifactStoreBucket:
Type: AWS::S3::Bucket
CodePipelineArtifactStoreBucketPolicy:
Type: AWS::S3::BucketPolicy
Properties:
Bucket: !Ref CodePipelineArtifactStoreBucket
PolicyDocument:
Version: 2012-10-17
Statement:
-
Sid: DenyUnEncryptedObjectUploads
Effect: Deny
Principal: '*'
Action: s3:PutObject
Resource: !Join [ '', [ !GetAtt CodePipelineArtifactStoreBucket.Arn, '/*' ] ]
Condition:
StringNotEquals:
s3:x-amz-server-side-encryption: aws:kms
-
Sid: DenyInsecureConnections
Effect: Deny
Principal: '*'
Action: s3:*
Resource: !Sub ${CodePipelineArtifactStoreBucket.Arn}/*
Condition:
Bool:
aws:SecureTransport: false
CodePipelineServiceRole:
Type: AWS::IAM::Role
Properties:
AssumeRolePolicyDocument:
Version: 2012-10-17
Statement:
-
Effect: Allow
Principal:
Service:
- codepipeline.amazonaws.com
Action: sts:AssumeRole
Path: /
Policies:
-
PolicyName: AWS-CodePipeline-Service-3
PolicyDocument:
Version: 2012-10-17
Statement:
-
Effect: Allow
Action:
- codecommit:CancelUploadArchive
- codecommit:GetBranch
- codecommit:GetCommit
- codecommit:GetUploadArchiveStatus
- codecommit:UploadArchive
Resource: 'resource_ARN'
-
Effect: Allow
Action:
- codedeploy:CreateDeployment
- codedeploy:GetApplicationRevision
- codedeploy:GetDeployment
- codedeploy:GetDeploymentConfig
- codedeploy:RegisterApplicationRevision
Resource: 'resource_ARN'
-
Effect: Allow
Action:
- codebuild:BatchGetBuilds
- codebuild:StartBuild
Resource: 'resource_ARN'
-
Effect: Allow
Action:
- devicefarm:ListProjects
- devicefarm:ListDevicePools
- devicefarm:GetRun
- devicefarm:GetUpload
- devicefarm:CreateUpload
- devicefarm:ScheduleRun
Resource: 'resource_ARN'
-
Effect: Allow
Action:
- lambda:InvokeFunction
- lambda:ListFunctions
Resource: 'resource_ARN'
-
Effect: Allow
Action:
- iam:PassRole
Resource: 'resource_ARN'
-
Effect: Allow
Action:
- elasticbeanstalk:*
- ec2:*
- elasticloadbalancing:*
- autoscaling:*
- cloudwatch:*
- s3:*
- sns:*
- cloudformation:*
- rds:*
- sqs:*
- ecs:*
Resource: 'resource_ARN'
AppPipeline:
Type: AWS::CodePipeline::Pipeline
Properties:
Name: s3-events-pipeline
RoleArn:
!GetAtt CodePipelineServiceRole.Arn
Stages:
-
Name: Source
Actions:
-
Name: SourceAction
ActionTypeId:
Category: Source
Owner: AWS
Version: 1
Provider: S3
OutputArtifacts:
- Name: SourceOutput
Configuration:
S3Bucket: !Ref SourceBucket
S3ObjectKey: !Ref SourceObjectKey
PollForSourceChanges: false
RunOrder: 1
-
Name: Beta
Actions:
-
Name: BetaAction
InputArtifacts:
- Name: SourceOutput
ActionTypeId:
Category: Deploy
Owner: AWS
Version: 1
Provider: CodeDeploy
Configuration:
ApplicationName: !Ref ApplicationName
DeploymentGroupName: !Ref BetaFleet
RunOrder: 1
ArtifactStore:
Type: S3
Location: !Ref CodePipelineArtifactStoreBucket
EventRole:
Type: AWS::IAM::Role
Properties:
AssumeRolePolicyDocument:
Version: 2012-10-17
Statement:
-
Effect: Allow
Principal:
Service:
- events.amazonaws.com
Action: sts:AssumeRole
Path: /
Policies:
-
PolicyName: eb-pipeline-execution
PolicyDocument:
Version: 2012-10-17
Statement:
-
Effect: Allow
Action: codepipeline:StartPipelineExecution
Resource: !Join [ '', [ 'arn:aws:codepipeline:', !Ref 'AWS::Region', ':', !Ref 'AWS::AccountId', ':', !Ref AppPipeline ] ]
EventRule:
Type: AWS::Events::Rule
Properties:
EventBusName: default
EventPattern:
source:
- aws.s3
detail-type:
- Object Created
detail:
bucket:
name:
- !Ref SourceBucket
Name: EnabledS3SourceRule
State: ENABLED
Targets:
-
Arn:
!Join [ '', [ 'arn:aws:codepipeline:', !Ref 'AWS::Region', ':', !Ref 'AWS::AccountId', ':', !Ref AppPipeline ] ]
RoleArn: !GetAtt EventRole.Arn
Id: codepipeline-AppPipeline
```
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Action": [
"appconfig:StartDeployment",
"appconfig:StopDeployment",
"appconfig:GetDeployment"
],
"Resource": [
"arn:aws:appconfig:*:111122223333:application/[[Application]]",
"arn:aws:appconfig:*:111122223333:application/[[Application]]/*",
"arn:aws:appconfig:*:111122223333:deploymentstrategy/*"
],
"Effect": "Allow"
}
]
}
```
## Migrieren Sie Polling-Pipelines mit einer S3-Quelle und einem S3-Trail CloudTrail
Bei einer Pipeline mit einer Amazon S3 S3-Quelle ändern Sie die Pipeline so, dass die Änderungserkennung automatisiert wird EventBridge. Wählen Sie aus den folgenden Methoden, um die Migration zu implementieren:
+ **Konsole:** [Migrieren von Abfrage-Pipelines (CodeCommit oder Amazon S3 S3-Quelle) (Konsole)](#update-change-detection-console-codecommit-S3)
+ **CLI:** [Migrieren Sie Polling-Pipelines mit einer S3-Quelle und einem CloudTrail S3-Trail (CLI)](#update-change-detection-cli-S3)
+ **CloudFormation: **[Migrieren Sie Polling-Pipelines mit einer S3-Quelle und einem CloudTrail S3-Trail (Vorlage)CloudFormation](#update-change-detection-cfn-s3)
### Migrieren Sie Polling-Pipelines mit einer S3-Quelle und einem CloudTrail S3-Trail (CLI)
Gehen Sie wie folgt vor, um eine Pipeline zu bearbeiten, die Polling (regelmäßige Prüfungen) verwendet, um stattdessen ein Ereignis in zu verwenden. EventBridge Wenn Sie eine Pipeline erstellen möchten, informieren Sie sich unter [Eine Pipeline, Phasen und Aktionen erstellen](pipelines-create.md).
Um eine ereignisgesteuerte Pipeline mit Amazon S3 zu erstellen, bearbeiten Sie den `PollForSourceChanges` Parameter Ihrer Pipeline und erstellen dann die folgenden Ressourcen:
+ AWS CloudTrail Trail-, Bucket- und Bucket-Richtlinie, die Amazon S3 zur Protokollierung der Ereignisse verwenden kann.
+ EventBridge Ereignis
+ IAM-Rolle, damit das EventBridge Ereignis Ihre Pipeline starten kann
**Um einen AWS CloudTrail Trail zu erstellen und die Protokollierung zu aktivieren**
Um mit dem einen Trail AWS CLI zu erstellen, rufen Sie den **create-trail** Befehl auf und geben Sie Folgendes an:
+ Den Trail-Namen.
+ Der Bucket, auf den Sie bereits die Bucket-Richtlinie für AWS CloudTrail angewendet haben.
Weitere Informationen finden Sie unter [Erstellen eines Pfads mit der AWS Befehlszeilenschnittstelle](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/cloudtrail-create-and-update-a-trail-by-using-the-aws-cli.html).
1. Rufen Sie den Befehl **create-trail** auf und beziehen Sie die Parameter `--name` und `--s3-bucket-name` ein.
**Warum nehme ich diese Änderung vor?** Dadurch wird der für Ihren S3-Quell-Bucket erforderliche CloudTrail-Trail erstellt.
Der folgende Befehl verwendet `--name` und `--s3-bucket-name` zum Erstellen eines Trails mit dem Namen `my-trail` und eines Buckets mit dem Namen `amzn-s3-demo-source-bucket`.
```
aws cloudtrail create-trail --name my-trail --s3-bucket-name amzn-s3-demo-source-bucket
```
1. Rufen Sie den Befehl **start-logging** auf und beziehen Sie den `--name`-Parameter ein.
**Warum nehme ich diese Änderung vor?** Dieser Befehl startet die CloudTrail Protokollierung für Ihren Quell-Bucket und sendet Ereignisse an EventBridge.
Beispiel:
Im folgenden Befehl wird `--name` verwendet, um die Protokollierung auf einem Trail mit der Bezeichnung `my-trail` zu starten.
```
aws cloudtrail start-logging --name my-trail
```
1. Rufen Sie den Befehl **put-event-selectors** auf und beziehen Sie die Parameter `--trail-name` und `--event-selectors` ein. Verwenden Sie Event-Selektoren, um anzugeben, dass Ihr Trail Datenereignisse für Ihren Quell-Bucket protokollieren und die Ereignisse an die EventBridge Regel senden soll.
**Warum nehme ich diese Änderung vor?** Dieser Befehl filtert Ereignisse.
Beispiel:
Im folgenden Beispielbefehl werden `--trail-name` und `--event-selectors` verwendet, um die Verwaltung von Datenereignissen für einen Quell-Bucket und einen Präfix namens `amzn-s3-demo-source-bucket/myFolder` anzugeben.
```
aws cloudtrail put-event-selectors --trail-name my-trail --event-selectors '[{ "ReadWriteType": "WriteOnly", "IncludeManagementEvents":false, "DataResources": [{ "Type": "AWS::S3::Object", "Values": ["arn:aws:s3:::amzn-s3-demo-source-bucket/myFolder/file.zip"] }] }]'
```
**Um eine EventBridge Regel mit Amazon S3 als Ereignisquelle und CodePipeline als Ziel zu erstellen und die Berechtigungsrichtlinie anzuwenden**
1. Erteilen Sie Berechtigungen EventBridge , die CodePipeline zum Aufrufen der Regel verwendet werden können. Weitere Informationen finden Sie unter [Verwenden ressourcenbasierter Richtlinien für Amazon](https://docs.aws.amazon.com/eventbridge/latest/userguide/eb-use-resource-based.html). EventBridge
1. Verwenden Sie das folgende Beispiel, um die Vertrauensrichtlinie zu erstellen, damit EventBridge Sie die Servicerolle übernehmen können. Geben Sie ihr den Namen `trustpolicyforEB.json`.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": "events.amazonaws.com"
},
"Action": "sts:AssumeRole"
}
]
}
```
------
1. Verwenden Sie den folgenden Befehl, um die `Role-for-MyRule`-Rolle zu erstellen und die Vertrauensrichtlinie anzufügen.
**Warum nehme ich diese Änderung vor?** Durch das Hinzufügen dieser Vertrauensrichtlinie zur Rolle werden Berechtigungen für erstellt EventBridge.
```
aws iam create-role --role-name Role-for-MyRule --assume-role-policy-document file://trustpolicyforEB.json
```
1. Erstellen Sie die JSON-Datei der Berechtigungsrichtlinie wie hier für die Pipeline mit dem Namen `MyFirstPipeline` gezeigt. Geben Sie der Berechtigungsrichtlinie den Namen `permissionspolicyforEB.json`.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"codepipeline:StartPipelineExecution"
],
"Resource": [
"arn:aws:codepipeline:us-west-2:111122223333:MyFirstPipeline"
]
}
]
}
```
------
1. Führen Sie den folgenden Befehl aus, um der erstellten `Role-for-MyRule`-Rolle die neue `CodePipeline-Permissions-Policy-for-EB`-Berechtigungsrichtlinie anzufügen.
```
aws iam put-role-policy --role-name Role-for-MyRule --policy-name CodePipeline-Permissions-Policy-For-EB --policy-document file://permissionspolicyforEB.json
```
1. Rufen Sie den Befehl „**put-rule**“ auf und beziehen Sie die Parameter „`--name`“, „`--event-pattern`“ und „`--role-arn`“ ein.
Mit dem folgenden Beispielbefehl wird eine Regel mit dem Namen „`MyS3SourceRule`“ erstellt.
```
aws events put-rule --name "MyS3SourceRule" --event-pattern "{\"source\":[\"aws.s3\"],\"detail-type\":[\"AWS API Call via CloudTrail\"],\"detail\":{\"eventSource\":[\"s3.amazonaws.com\"],\"eventName\":[\"CopyObject\",\"PutObject\",\"CompleteMultipartUpload\"],\"requestParameters\":{\"bucketName\":[\"amzn-s3-demo-source-bucket\"],\"key\":[\"my-key\"]}}}
--role-arn "arn:aws:iam::ACCOUNT_ID:role/Role-for-MyRule"
```
1. Um das Objekt CodePipeline als Ziel hinzuzufügen, rufen Sie den **put-targets** Befehl auf und geben Sie die `--targets` Parameter `--rule` und an.
Der folgende Befehl legt fest, dass für die Regel mit dem Namen `MyS3SourceRule` die Ziel-`Id` aus der Nummer 1 besteht. Dies bedeutet, dass in einer Liste mit Zielen für die Regel dies Ziel 1 ist. Der Befehl gibt zudem ein Beispiel `ARN` für die Pipeline an. Die Pipeline startet, wenn Änderungen im Repository auftreten.
```
aws events put-targets --rule MyS3SourceRule --targets Id=1,Arn=arn:aws:codepipeline:us-west-2:80398EXAMPLE:TestPipeline
```
1. (Optional) Um einen Eingangstransformator mit Quellüberschreibungen für eine bestimmte Bild-ID zu konfigurieren, verwenden Sie den folgenden JSON-Code in Ihrem CLI-Befehl. Im folgenden Beispiel wird eine Überschreibung konfiguriert, wobei:
+ `Source`In diesem Beispiel handelt es sich um den dynamischen Wert, der bei der Pipelineerstellung definiert wurde und nicht aus dem Quellereignis abgeleitet wurde. `actionName`
+ `S3_OBJECT_VERSION_ID`In diesem Beispiel handelt es sich um den dynamischen Wert, der bei der Pipelineerstellung definiert wurde und nicht aus dem Quellereignis abgeleitet wurde. `revisionType`
+ In diesem Beispiel wird < *revisionValue* > von der Quellereignisvariablen abgeleitet. `revisionValue`
```
{
"Rule": "my-rule",
"Targets": [
{
"Id": "MyTargetId",
"Arn": "ARN",
"InputTransformer": {
"InputPathsMap": {
"revisionValue": "$.detail.object.version-id"
},
"InputTemplate": {
"sourceRevisions": {
"actionName": "Source",
"revisionType": "S3_OBJECT_VERSION_ID",
"revisionValue": ""
}
}
}
}
]
}
```
**Um den PollForSourceChanges Parameter Ihrer Pipeline zu bearbeiten**
**Wichtig**
Wenn Sie eine Pipeline mit dieser Methode erstellen, ist der Parameter `PollForSourceChanges` standardmäßig „true“, wenn er nicht ausdrücklich auf „false“ gesetzt wird. Wenn Sie ereignisbasierte Erkennung hinzufügen, müssen Sie den Parameter Ihrer Ausgabe hinzufügen und Ihn auf „false“ setzen, um die Abfrage zu deaktivieren. Andernfalls wird Ihre Pipeline bei einer einzigen Quelländerung zweimal gestartet. Details hierzu finden Sie unter [Gültige Einstellungen für den `PollForSourceChanges` Parameter](PollForSourceChanges-defaults.md).
1. Führen Sie den Befehl **get-pipeline** zum Kopieren der Pipeline-Struktur in eine JSON-Datei aus. Geben Sie für eine Pipeline mit dem Namen `MyFirstPipeline` den folgenden Befehl ein:
```
aws codepipeline get-pipeline --name MyFirstPipeline >pipeline.json
```
Dieser Befehl gibt nichts zurück. Die erstellte Datei sollte jedoch in dem Verzeichnis auftauchen, in dem Sie den Befehl ausgeführt haben.
1. Öffnen Sie die JSON-Datei in einem Texteditor und bearbeiten Sie die Quellphase, indem Sie den Parameter `PollForSourceChanges` für einen Bucket mit dem Namen `amzn-s3-demo-source-bucket`in `false` ändern wie in diesem Beispiel gezeigt.
**Warum nehme ich diese Änderung vor?** Durch Festlegen dieses Parameters in `false` werden periodische Prüfungen deaktiviert. Sie können daher nur die ereignisbasierte Erkennung von Änderungen verwenden.
```
"configuration": {
"S3Bucket": "amzn-s3-demo-source-bucket",
"PollForSourceChanges": "false",
"S3ObjectKey": "index.zip"
},
```
1. Wenn Sie mit einer Pipeline-Struktur arbeiten, die Sie mit dem Befehl **get-pipeline** abgerufen haben, müssen Sie die `metadata`-Zeilen aus der JSON-Datei entfernen. Andernfalls kann der **update-pipeline**-Befehl sie nicht nutzen. Entfernen Sie die `"metadata": { }`-Zeilen und die Felder `"created"`, `"pipelineARN"` und `"updated"`.
Entfernen Sie z. B. die folgenden Zeilen aus der Struktur:
```
"metadata": {
"pipelineArn": "arn:aws:codepipeline:region:account-ID:pipeline-name",
"created": "date",
"updated": "date"
},
```
Speichern Sie die Datei.
1. Um Ihre Änderungen zu übernehmen, führen Sie den Befehl **update-pipeline** aus und geben Sie die Pipeline-JSON-Datei an:
**Wichtig**
Achten Sie darauf, dass `file://` vor dem Dateinamen steht. Dies ist bei diesem Befehl erforderlich.
```
aws codepipeline update-pipeline --cli-input-json file://pipeline.json
```
Dieser Befehl gibt die gesamte Struktur der bearbeiteten Pipeline zurück.
**Anmerkung**
Der Befehl **update-pipeline** stoppt die Pipeline. Wenn eine Revision über die Pipeline ausgeführt wird, wenn Sie den Befehl **update-pipeline** ausführen, wird diese Ausführung gestoppt. Sie müssen die Ausführung der Pipeline manuell starten, um die Revision über die aktualisierte Pipeline auszuführen. Verwenden Sie den **start-pipeline-execution**-Befehl, um Ihre Pipeline manuell zu starten.
### Migrieren Sie Polling-Pipelines mit einer S3-Quelle und einem CloudTrail S3-Trail (Vorlage)CloudFormation
Gehen Sie wie folgt vor, um Ihre Pipeline mit einer Amazon S3 S3-Quelle von der Abfrage bis zur ereignisbasierten Änderungserkennung zu bearbeiten.
Um eine ereignisgesteuerte Pipeline mit Amazon S3 zu erstellen, bearbeiten Sie den `PollForSourceChanges` Parameter Ihrer Pipeline und fügen dann die folgenden Ressourcen zu Ihrer Vorlage hinzu:
+ EventBridge erfordert, dass alle Amazon S3 S3-Ereignisse protokolliert werden müssen. Sie müssen eine AWS CloudTrail Trail-, Bucket- und Bucket-Richtlinie erstellen, die Amazon S3 verwenden kann, um die auftretenden Ereignisse zu protokollieren. Weitere Informationen finden Sie unter [Datenereignisse für Trails protokollieren](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/logging-data-events-with-cloudtrail.html) [und Verwaltungsereignisse für Trails](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/logging-management-events-with-cloudtrail.html) protokollieren.
+ EventBridge Regel und IAM-Rolle, damit dieses Ereignis unsere Pipeline starten kann.
Wenn Sie CloudFormation Ihre Pipelines erstellen und verwalten, enthält Ihre Vorlage Inhalte wie den folgenden.
**Anmerkung**
Die `Configuration`-Eigenschaft in der Quellstufe mit dem Namen `PollForSourceChanges`. Wenn diese Eigenschaft in Ihrer Vorlage nicht enthalten ist, dann wird `PollForSourceChanges` standardmäßig auf `true` festgelegt.
------
#### [ YAML ]
```
AppPipeline:
Type: AWS::CodePipeline::Pipeline
Properties:
RoleArn: !GetAtt CodePipelineServiceRole.Arn
Stages:
-
Name: Source
Actions:
-
Name: SourceAction
ActionTypeId:
Category: Source
Owner: AWS
Version: 1
Provider: S3
OutputArtifacts:
-
Name: SourceOutput
Configuration:
S3Bucket: !Ref SourceBucket
S3ObjectKey: !Ref S3SourceObjectKey
PollForSourceChanges: true
RunOrder: 1
...
```
------
#### [ JSON ]
```
"AppPipeline": {
"Type": "AWS::CodePipeline::Pipeline",
"Properties": {
"RoleArn": {
"Fn::GetAtt": ["CodePipelineServiceRole", "Arn"]
},
"Stages": [
{
"Name": "Source",
"Actions": [
{
"Name": "SourceAction",
"ActionTypeId": {
"Category": "Source",
"Owner": "AWS",
"Version": 1,
"Provider": "S3"
},
"OutputArtifacts": [
{
"Name": "SourceOutput"
}
],
"Configuration": {
"S3Bucket": {
"Ref": "SourceBucket"
},
"S3ObjectKey": {
"Ref": "SourceObjectKey"
},
"PollForSourceChanges": true
},
"RunOrder": 1
}
]
},
...
```
------
**Um eine EventBridge Regel mit Amazon S3 als Ereignisquelle und CodePipeline als Ziel zu erstellen und die Berechtigungsrichtlinie anzuwenden**
1. Verwenden Sie in der Vorlage unter die `AWS::IAM::Role` CloudFormation Ressource`Resources`, um die IAM-Rolle zu konfigurieren, mit der Ihr Ereignis Ihre Pipeline starten kann. Dieser Eintrag erstellt eine Rolle mit zwei Richtlinien:
+ Die erste Richtlinie ermöglicht die Übernahme der Rolle.
+ Die zweite Richtlinie stellt Berechtigungen zum Starten der Pipeline bereit.
**Warum nehme ich diese Änderung vor?** Durch das Hinzufügen einer `AWS::IAM::Role` Ressource können CloudFormation Sie Berechtigungen für EventBridge erstellen. Diese Ressource wird Ihrem CloudFormation Stack hinzugefügt.
------
#### [ YAML ]
```
EventRole:
Type: AWS::IAM::Role
Properties:
AssumeRolePolicyDocument:
Version: 2012-10-17
Statement:
-
Effect: Allow
Principal:
Service:
- events.amazonaws.com
Action: sts:AssumeRole
Path: /
Policies:
-
PolicyName: eb-pipeline-execution
PolicyDocument:
Version: 2012-10-17
Statement:
-
Effect: Allow
Action: codepipeline:StartPipelineExecution
Resource: !Join [ '', [ 'arn:aws:codepipeline:', !Ref 'AWS::Region', ':', !Ref 'AWS::AccountId', ':', !Ref AppPipeline ] ]
...
```
------
#### [ JSON ]
```
"EventRole": {
"Type": "AWS::IAM::Role",
"Properties": {
"AssumeRolePolicyDocument": {
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": [
"events.amazonaws.com"
]
},
"Action": "sts:AssumeRole"
}
]
},
"Path": "/",
"Policies": [
{
"PolicyName": "eb-pipeline-execution",
"PolicyDocument": {
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": "codepipeline:StartPipelineExecution",
"Resource": {
"Fn::Join": [
"",
[
"arn:aws:codepipeline:",
{
"Ref": "AWS::Region"
},
":",
{
"Ref": "AWS::AccountId"
},
":",
{
"Ref": "AppPipeline"
}
]
]
...
```
------
1. Verwenden Sie die `AWS::Events::Rule` CloudFormation Ressource, um eine EventBridge Regel hinzuzufügen. Dieses Ereignismuster erzeugt ein Ereignis`CopyObject`, `PutObject` das Ihren `CompleteMultipartUpload` Amazon S3 S3-Quell-Bucket überwacht. Fügen Sie darüber hinaus ein Ziel für Ihre Pipeline ein. Wenn `CopyObject`, `PutObject` oder `CompleteMultipartUpload` auftritt, ruft diese Rolle `StartPipelineExecution` in Ihrer Ziel-Pipeline auf.
**Warum nehme ich diese Änderung vor?** Durch das Hinzufügen der `AWS::Events::Rule` Ressource kann CloudFormation das Ereignis erstellt werden. Diese Ressource wird Ihrem CloudFormation Stack hinzugefügt.
------
#### [ YAML ]
```
EventRule:
Type: AWS::Events::Rule
Properties:
EventPattern:
source:
- aws.s3
detail-type:
- 'AWS API Call via CloudTrail'
detail:
eventSource:
- s3.amazonaws.com
eventName:
- CopyObject
- PutObject
- CompleteMultipartUpload
requestParameters:
bucketName:
- !Ref SourceBucket
key:
- !Ref SourceObjectKey
Targets:
-
Arn:
!Join [ '', [ 'arn:aws:codepipeline:', !Ref 'AWS::Region', ':', !Ref 'AWS::AccountId', ':', !Ref AppPipeline ] ]
RoleArn: !GetAtt EventRole.Arn
Id: codepipeline-AppPipeline
...
```
------
#### [ JSON ]
```
"EventRule": {
"Type": "AWS::Events::Rule",
"Properties": {
"EventPattern": {
"source": [
"aws.s3"
],
"detail-type": [
"AWS API Call via CloudTrail"
],
"detail": {
"eventSource": [
"s3.amazonaws.com"
],
"eventName": [
"CopyObject",
"PutObject",
"CompleteMultipartUpload"
],
"requestParameters": {
"bucketName": [
{
"Ref": "SourceBucket"
}
],
"key": [
{
"Ref": "SourceObjectKey"
}
]
}
}
},
"Targets": [
{
"Arn": {
"Fn::Join": [
"",
[
"arn:aws:codepipeline:",
{
"Ref": "AWS::Region"
},
":",
{
"Ref": "AWS::AccountId"
},
":",
{
"Ref": "AppPipeline"
}
]
]
},
"RoleArn": {
"Fn::GetAtt": [
"EventRole",
"Arn"
]
},
"Id": "codepipeline-AppPipeline"
}
]
}
}
},
...
```
------
1. Fügen Sie diesen Ausschnitt zu Ihrer ersten Vorlage hinzu, um Stack-übergreifende Funktionalität zu ermöglichen:
------
#### [ YAML ]
```
Outputs:
SourceBucketARN:
Description: "S3 bucket ARN that Cloudtrail will use"
Value: !GetAtt SourceBucket.Arn
Export:
Name: SourceBucketARN
```
------
#### [ JSON ]
```
"Outputs" : {
"SourceBucketARN" : {
"Description" : "S3 bucket ARN that Cloudtrail will use",
"Value" : { "Fn::GetAtt": ["SourceBucket", "Arn"] },
"Export" : {
"Name" : "SourceBucketARN"
}
}
...
```
------
1. (Optional) Verwenden Sie den folgenden YAML-Snippet, um einen Eingangstransformator mit Quellüberschreibungen für eine bestimmte Bild-ID zu konfigurieren. Im folgenden Beispiel wird eine Überschreibung konfiguriert, wobei:
+ `Source`In diesem Beispiel handelt es sich um den dynamischen Wert, der bei der Pipelineerstellung definiert wurde und nicht aus dem Quellereignis abgeleitet wurde. `actionName`
+ `S3_OBJECT_VERSION_ID`In diesem Beispiel handelt es sich um den dynamischen Wert, der bei der Pipelineerstellung definiert wurde und nicht aus dem Quellereignis abgeleitet wurde. `revisionType`
+ In diesem Beispiel wird < *revisionValue* > von der Quellereignisvariablen abgeleitet. `revisionValue`
```
---
Rule: my-rule
Targets:
- Id: MyTargetId
Arn: pipeline-ARN
InputTransformer:
InputPathsMap:
revisionValue: "$.detail.object.version-id"
InputTemplate:
sourceRevisions:
actionName: Source
revisionType: S3_OBJECT_VERSION_ID
revisionValue: ''
```
1. Speichern Sie Ihre aktualisierte Vorlage auf Ihrem lokalen Computer und öffnen Sie die CloudFormation Konsole.
1. Wählen Sie Ihren Stack aus und klicken Sie auf **Create Change Set for Current Stack (Änderungssatz für laufenden Stack erstellen)**.
1. Laden Sie Ihre aktualisierte Vorlage hoch und zeigen Sie dann die in CloudFormation aufgeführten Änderungen an. Dies sind die Änderungen, die am Stack vorgenommen werden. Ihre neuen Ressourcen sollten in der Liste angezeigt werden.
1. Wählen Sie **Ausführen**.
**Um den PollForSourceChanges Parameter Ihrer Pipeline zu bearbeiten**
**Wichtig**
Wenn Sie eine Pipeline mit dieser Methode erstellen, ist der Parameter `PollForSourceChanges` standardmäßig „true“, wenn er nicht ausdrücklich auf „false“ gesetzt wird. Wenn Sie ereignisbasierte Erkennung hinzufügen, müssen Sie den Parameter Ihrer Ausgabe hinzufügen und Ihn auf „false“ setzen, um die Abfrage zu deaktivieren. Andernfalls wird Ihre Pipeline bei einer einzigen Quelländerung zweimal gestartet. Details hierzu finden Sie unter [Gültige Einstellungen für den `PollForSourceChanges` Parameter](PollForSourceChanges-defaults.md).
+ Ändern Sie in der Vorlage `PollForSourceChanges` in `false`. Wenn Sie `PollForSourceChanges` nicht in Ihre Pipeline-Definition einbezogen haben, fügen Sie das Objekt hinzu und legen es auf `false` fest.
**Warum nehme ich diese Änderung vor?** Durch Ändern von `PollForSourceChanges` in `false` werden periodische Prüfungen deaktiviert. Sie können daher nur die ereignisbasierte Erkennung von Änderungen verwenden.
------
#### [ YAML ]
```
Name: Source
Actions:
-
Name: SourceAction
ActionTypeId:
Category: Source
Owner: AWS
Version: 1
Provider: S3
OutputArtifacts:
- Name: SourceOutput
Configuration:
S3Bucket: !Ref SourceBucket
S3ObjectKey: !Ref SourceObjectKey
PollForSourceChanges: false
RunOrder: 1
```
------
#### [ JSON ]
```
{
"Name": "SourceAction",
"ActionTypeId": {
"Category": "Source",
"Owner": "AWS",
"Version": 1,
"Provider": "S3"
},
"OutputArtifacts": [
{
"Name": "SourceOutput"
}
],
"Configuration": {
"S3Bucket": {
"Ref": "SourceBucket"
},
"S3ObjectKey": {
"Ref": "SourceObjectKey"
},
"PollForSourceChanges": false
},
"RunOrder": 1
}
```
------
**Um eine zweite Vorlage für die CloudTrail Ressourcen Ihrer Amazon S3 S3-Pipeline zu erstellen**
+ Verwenden Sie in einer separaten Vorlage unter`Resources`, die `AWS::CloudTrail::Trail` CloudFormation Ressourcen `AWS::S3::Bucket``AWS::S3::BucketPolicy`, und, um eine einfache Bucket-Definition und einen Trail für bereitzustellen CloudTrail.
**Warum nehme ich diese Änderung vor?** Angesichts des aktuellen Limits von fünf Trails pro Konto muss der CloudTrail Trail separat erstellt und verwaltet werden. (Siehe [Grenzwerte unter AWS CloudTrail](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/WhatIsCloudTrail-Limits.html).) Sie können jedoch viele Amazon S3 S3-Buckets in einen einzigen Trail aufnehmen, sodass Sie den Trail einmal erstellen und dann bei Bedarf Amazon S3 S3-Buckets für andere Pipelines hinzufügen können. Fügen Sie den folgenden Code in Ihre zweite Beispielvorlagendatei ein.
------
#### [ YAML ]
```
###################################################################################
# Prerequisites:
# - S3 SourceBucket and SourceObjectKey must exist
###################################################################################
Parameters:
SourceObjectKey:
Description: 'S3 source artifact'
Type: String
Default: SampleApp_Linux.zip
Resources:
AWSCloudTrailBucketPolicy:
Type: AWS::S3::BucketPolicy
Properties:
Bucket: !Ref AWSCloudTrailBucket
PolicyDocument:
Version: 2012-10-17
Statement:
-
Sid: AWSCloudTrailAclCheck
Effect: Allow
Principal:
Service:
- cloudtrail.amazonaws.com
Action: s3:GetBucketAcl
Resource: !GetAtt AWSCloudTrailBucket.Arn
-
Sid: AWSCloudTrailWrite
Effect: Allow
Principal:
Service:
- cloudtrail.amazonaws.com
Action: s3:PutObject
Resource: !Join [ '', [ !GetAtt AWSCloudTrailBucket.Arn, '/AWSLogs/', !Ref 'AWS::AccountId', '/*' ] ]
Condition:
StringEquals:
s3:x-amz-acl: bucket-owner-full-control
AWSCloudTrailBucket:
Type: AWS::S3::Bucket
DeletionPolicy: Retain
AwsCloudTrail:
DependsOn:
- AWSCloudTrailBucketPolicy
Type: AWS::CloudTrail::Trail
Properties:
S3BucketName: !Ref AWSCloudTrailBucket
EventSelectors:
-
DataResources:
-
Type: AWS::S3::Object
Values:
- !Join [ '', [ !ImportValue SourceBucketARN, '/', !Ref SourceObjectKey ] ]
ReadWriteType: WriteOnly
IncludeManagementEvents: false
IncludeGlobalServiceEvents: true
IsLogging: true
IsMultiRegionTrail: true
...
```
------
#### [ JSON ]
```
{
"Parameters": {
"SourceObjectKey": {
"Description": "S3 source artifact",
"Type": "String",
"Default": "SampleApp_Linux.zip"
}
},
"Resources": {
"AWSCloudTrailBucket": {
"Type": "AWS::S3::Bucket",
"DeletionPolicy": "Retain"
},
"AWSCloudTrailBucketPolicy": {
"Type": "AWS::S3::BucketPolicy",
"Properties": {
"Bucket": {
"Ref": "AWSCloudTrailBucket"
},
"PolicyDocument": {
"Version": "2012-10-17",
"Statement": [
{
"Sid": "AWSCloudTrailAclCheck",
"Effect": "Allow",
"Principal": {
"Service": [
"cloudtrail.amazonaws.com"
]
},
"Action": "s3:GetBucketAcl",
"Resource": {
"Fn::GetAtt": [
"AWSCloudTrailBucket",
"Arn"
]
}
},
{
"Sid": "AWSCloudTrailWrite",
"Effect": "Allow",
"Principal": {
"Service": [
"cloudtrail.amazonaws.com"
]
},
"Action": "s3:PutObject",
"Resource": {
"Fn::Join": [
"",
[
{
"Fn::GetAtt": [
"AWSCloudTrailBucket",
"Arn"
]
},
"/AWSLogs/",
{
"Ref": "AWS::AccountId"
},
"/*"
]
]
},
"Condition": {
"StringEquals": {
"s3:x-amz-acl": "bucket-owner-full-control"
}
}
}
]
}
}
},
"AwsCloudTrail": {
"DependsOn": [
"AWSCloudTrailBucketPolicy"
],
"Type": "AWS::CloudTrail::Trail",
"Properties": {
"S3BucketName": {
"Ref": "AWSCloudTrailBucket"
},
"EventSelectors": [
{
"DataResources": [
{
"Type": "AWS::S3::Object",
"Values": [
{
"Fn::Join": [
"",
[
{
"Fn::ImportValue": "SourceBucketARN"
},
"/",
{
"Ref": "SourceObjectKey"
}
]
]
}
]
}
],
"ReadWriteType": "WriteOnly",
"IncludeManagementEvents": false
}
],
"IncludeGlobalServiceEvents": true,
"IsLogging": true,
"IsMultiRegionTrail": true
}
}
}
}
...
```
------
**Example**
Wenn Sie diese Ressourcen erstellen, wird Ihre Pipeline ausgelöst, wenn Dateien in Ihrem Repository erstellt oder aktualisiert werden. CloudFormation
Hören Sie hier nicht auf. Obwohl Ihre Pipeline erstellt wurde, müssen Sie eine zweite CloudFormation Vorlage für Ihre Amazon S3 S3-Pipeline erstellen. Wenn Sie die zweite Vorlage nicht erstellen, enthält Ihre Pipeline keine Funktionalität für die Änderungserkennung.
```
Resources:
SourceBucket:
Type: AWS::S3::Bucket
Properties:
VersioningConfiguration:
Status: Enabled
CodePipelineArtifactStoreBucket:
Type: AWS::S3::Bucket
CodePipelineArtifactStoreBucketPolicy:
Type: AWS::S3::BucketPolicy
Properties:
Bucket: !Ref CodePipelineArtifactStoreBucket
PolicyDocument:
Version: 2012-10-17
Statement:
-
Sid: DenyUnEncryptedObjectUploads
Effect: Deny
Principal: '*'
Action: s3:PutObject
Resource: !Join [ '', [ !GetAtt CodePipelineArtifactStoreBucket.Arn, '/*' ] ]
Condition:
StringNotEquals:
s3:x-amz-server-side-encryption: aws:kms
-
Sid: DenyInsecureConnections
Effect: Deny
Principal: '*'
Action: s3:*
Resource: !Join [ '', [ !GetAtt CodePipelineArtifactStoreBucket.Arn, '/*' ] ]
Condition:
Bool:
aws:SecureTransport: false
CodePipelineServiceRole:
Type: AWS::IAM::Role
Properties:
AssumeRolePolicyDocument:
Version: 2012-10-17
Statement:
-
Effect: Allow
Principal:
Service:
- codepipeline.amazonaws.com
Action: sts:AssumeRole
Path: /
Policies:
-
PolicyName: AWS-CodePipeline-Service-3
PolicyDocument:
Version: 2012-10-17
Statement:
-
Effect: Allow
Action:
- codecommit:CancelUploadArchive
- codecommit:GetBranch
- codecommit:GetCommit
- codecommit:GetUploadArchiveStatus
- codecommit:UploadArchive
Resource: 'resource_ARN'
-
Effect: Allow
Action:
- codedeploy:CreateDeployment
- codedeploy:GetApplicationRevision
- codedeploy:GetDeployment
- codedeploy:GetDeploymentConfig
- codedeploy:RegisterApplicationRevision
Resource: 'resource_ARN'
-
Effect: Allow
Action:
- codebuild:BatchGetBuilds
- codebuild:StartBuild
Resource: 'resource_ARN'
-
Effect: Allow
Action:
- devicefarm:ListProjects
- devicefarm:ListDevicePools
- devicefarm:GetRun
- devicefarm:GetUpload
- devicefarm:CreateUpload
- devicefarm:ScheduleRun
Resource: 'resource_ARN'
-
Effect: Allow
Action:
- lambda:InvokeFunction
- lambda:ListFunctions
Resource: 'resource_ARN'
-
Effect: Allow
Action:
- iam:PassRole
Resource: 'resource_ARN'
-
Effect: Allow
Action:
- elasticbeanstalk:*
- ec2:*
- elasticloadbalancing:*
- autoscaling:*
- cloudwatch:*
- s3:*
- sns:*
- cloudformation:*
- rds:*
- sqs:*
- ecs:*
Resource: 'resource_ARN'
AppPipeline:
Type: AWS::CodePipeline::Pipeline
Properties:
Name: s3-events-pipeline
RoleArn:
!GetAtt CodePipelineServiceRole.Arn
Stages:
-
Name: Source
Actions:
-
Name: SourceAction
ActionTypeId:
Category: Source
Owner: AWS
Version: 1
Provider: S3
OutputArtifacts:
- Name: SourceOutput
Configuration:
S3Bucket: !Ref SourceBucket
S3ObjectKey: !Ref SourceObjectKey
PollForSourceChanges: false
RunOrder: 1
-
Name: Beta
Actions:
-
Name: BetaAction
InputArtifacts:
- Name: SourceOutput
ActionTypeId:
Category: Deploy
Owner: AWS
Version: 1
Provider: CodeDeploy
Configuration:
ApplicationName: !Ref ApplicationName
DeploymentGroupName: !Ref BetaFleet
RunOrder: 1
ArtifactStore:
Type: S3
Location: !Ref CodePipelineArtifactStoreBucket
EventRole:
Type: AWS::IAM::Role
Properties:
AssumeRolePolicyDocument:
Version: 2012-10-17
Statement:
-
Effect: Allow
Principal:
Service:
- events.amazonaws.com
Action: sts:AssumeRole
Path: /
Policies:
-
PolicyName: eb-pipeline-execution
PolicyDocument:
Version: 2012-10-17
Statement:
-
Effect: Allow
Action: codepipeline:StartPipelineExecution
Resource: !Join [ '', [ 'arn:aws:codepipeline:', !Ref 'AWS::Region', ':', !Ref 'AWS::AccountId', ':', !Ref AppPipeline ] ]
EventRule:
Type: AWS::Events::Rule
Properties:
EventPattern:
source:
- aws.s3
detail-type:
- 'AWS API Call via CloudTrail'
detail:
eventSource:
- s3.amazonaws.com
eventName:
- PutObject
- CompleteMultipartUpload
resources:
ARN:
- !Join [ '', [ !GetAtt SourceBucket.Arn, '/', !Ref SourceObjectKey ] ]
Targets:
-
Arn:
!Join [ '', [ 'arn:aws:codepipeline:', !Ref 'AWS::Region', ':', !Ref 'AWS::AccountId', ':', !Ref AppPipeline ] ]
RoleArn: !GetAtt EventRole.Arn
Id: codepipeline-AppPipeline
Outputs:
SourceBucketARN:
Description: "S3 bucket ARN that Cloudtrail will use"
Value: !GetAtt SourceBucket.Arn
Export:
Name: SourceBucketARN
```
```
"Resources": {
"SourceBucket": {
"Type": "AWS::S3::Bucket",
"Properties": {
"VersioningConfiguration": {
"Status": "Enabled"
}
}
},
"CodePipelineArtifactStoreBucket": {
"Type": "AWS::S3::Bucket"
},
"CodePipelineArtifactStoreBucketPolicy": {
"Type": "AWS::S3::BucketPolicy",
"Properties": {
"Bucket": {
"Ref": "CodePipelineArtifactStoreBucket"
},
"PolicyDocument": {
"Version": "2012-10-17",
"Statement": [
{
"Sid": "DenyUnEncryptedObjectUploads",
"Effect": "Deny",
"Principal": "*",
"Action": "s3:PutObject",
"Resource": {
"Fn::Join": [
"",
[
{
"Fn::GetAtt": [
"CodePipelineArtifactStoreBucket",
"Arn"
]
},
"/*"
]
]
},
"Condition": {
"StringNotEquals": {
"s3:x-amz-server-side-encryption": "aws:kms"
}
}
},
{
"Sid": "DenyInsecureConnections",
"Effect": "Deny",
"Principal": "*",
"Action": "s3:*",
"Resource": {
"Fn::Join": [
"",
[
{
"Fn::GetAtt": [
"CodePipelineArtifactStoreBucket",
"Arn"
]
},
"/*"
]
]
},
"Condition": {
"Bool": {
"aws:SecureTransport": false
}
}
}
]
}
}
},
"CodePipelineServiceRole": {
"Type": "AWS::IAM::Role",
"Properties": {
"AssumeRolePolicyDocument": {
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": [
"codepipeline.amazonaws.com"
]
},
"Action": "sts:AssumeRole"
}
]
},
"Path": "/",
"Policies": [
{
"PolicyName": "AWS-CodePipeline-Service-3",
"PolicyDocument": {
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"codecommit:CancelUploadArchive",
"codecommit:GetBranch",
"codecommit:GetCommit",
"codecommit:GetUploadArchiveStatus",
"codecommit:UploadArchive"
],
"Resource": "resource_ARN"
},
{
"Effect": "Allow",
"Action": [
"codedeploy:CreateDeployment",
"codedeploy:GetApplicationRevision",
"codedeploy:GetDeployment",
"codedeploy:GetDeploymentConfig",
"codedeploy:RegisterApplicationRevision"
],
"Resource": "resource_ARN"
},
{
"Effect": "Allow",
"Action": [
"codebuild:BatchGetBuilds",
"codebuild:StartBuild"
],
"Resource": "resource_ARN"
},
{
"Effect": "Allow",
"Action": [
"devicefarm:ListProjects",
"devicefarm:ListDevicePools",
"devicefarm:GetRun",
"devicefarm:GetUpload",
"devicefarm:CreateUpload",
"devicefarm:ScheduleRun"
],
"Resource": "resource_ARN"
},
{
"Effect": "Allow",
"Action": [
"lambda:InvokeFunction",
"lambda:ListFunctions"
],
"Resource": "resource_ARN"
},
{
"Effect": "Allow",
"Action": [
"iam:PassRole"
],
"Resource": "resource_ARN"
},
{
"Effect": "Allow",
"Action": [
"elasticbeanstalk:*",
"ec2:*",
"elasticloadbalancing:*",
"autoscaling:*",
"cloudwatch:*",
"s3:*",
"sns:*",
"cloudformation:*",
"rds:*",
"sqs:*",
"ecs:*"
],
"Resource": "resource_ARN"
}
]
}
}
]
}
},
"AppPipeline": {
"Type": "AWS::CodePipeline::Pipeline",
"Properties": {
"Name": "s3-events-pipeline",
"RoleArn": {
"Fn::GetAtt": [
"CodePipelineServiceRole",
"Arn"
]
},
"Stages": [
{
"Name": "Source",
"Actions": [
{
"Name": "SourceAction",
"ActionTypeId": {
"Category": "Source",
"Owner": "AWS",
"Version": 1,
"Provider": "S3"
},
"OutputArtifacts": [
{
"Name": "SourceOutput"
}
],
"Configuration": {
"S3Bucket": {
"Ref": "SourceBucket"
},
"S3ObjectKey": {
"Ref": "SourceObjectKey"
},
"PollForSourceChanges": false
},
"RunOrder": 1
}
]
},
{
"Name": "Beta",
"Actions": [
{
"Name": "BetaAction",
"InputArtifacts": [
{
"Name": "SourceOutput"
}
],
"ActionTypeId": {
"Category": "Deploy",
"Owner": "AWS",
"Version": 1,
"Provider": "CodeDeploy"
},
"Configuration": {
"ApplicationName": {
"Ref": "ApplicationName"
},
"DeploymentGroupName": {
"Ref": "BetaFleet"
}
},
"RunOrder": 1
}
]
}
],
"ArtifactStore": {
"Type": "S3",
"Location": {
"Ref": "CodePipelineArtifactStoreBucket"
}
}
}
},
"EventRole": {
"Type": "AWS::IAM::Role",
"Properties": {
"AssumeRolePolicyDocument": {
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": [
"events.amazonaws.com"
]
},
"Action": "sts:AssumeRole"
}
]
},
"Path": "/",
"Policies": [
{
"PolicyName": "eb-pipeline-execution",
"PolicyDocument": {
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": "codepipeline:StartPipelineExecution",
"Resource": {
"Fn::Join": [
"",
[
"arn:aws:codepipeline:",
{
"Ref": "AWS::Region"
},
":",
{
"Ref": "AWS::AccountId"
},
":",
{
"Ref": "AppPipeline"
}
]
]
}
}
]
}
}
]
}
},
"EventRule": {
"Type": "AWS::Events::Rule",
"Properties": {
"EventPattern": {
"source": [
"aws.s3"
],
"detail-type": [
"AWS API Call via CloudTrail"
],
"detail": {
"eventSource": [
"s3.amazonaws.com"
],
"eventName": [
"PutObject",
"CompleteMultipartUpload"
],
"resources": {
"ARN": [
{
"Fn::Join": [
"",
[
{
"Fn::GetAtt": [
"SourceBucket",
"Arn"
]
},
"/",
{
"Ref": "SourceObjectKey"
}
]
]
}
]
}
}
},
"Targets": [
{
"Arn": {
"Fn::Join": [
"",
[
"arn:aws:codepipeline:",
{
"Ref": "AWS::Region"
},
":",
{
"Ref": "AWS::AccountId"
},
":",
{
"Ref": "AppPipeline"
}
]
]
},
"RoleArn": {
"Fn::GetAtt": [
"EventRole",
"Arn"
]
},
"Id": "codepipeline-AppPipeline"
}
]
}
}
},
"Outputs" : {
"SourceBucketARN" : {
"Description" : "S3 bucket ARN that Cloudtrail will use",
"Value" : { "Fn::GetAtt": ["SourceBucket", "Arn"] },
"Export" : {
"Name" : "SourceBucketARN"
}
}
}
}
...
```
## Migrieren Sie Abfrage-Pipelines für eine Quellaktion GitHub (per OAuth App) zu Verbindungen
Sie können eine Quellaktion GitHub (per OAuth App) migrieren, um Verbindungen für Ihr externes Repository zu verwenden. Dies ist die empfohlene Methode zur Erkennung von Änderungen für Pipelines mit einer Quellaktion GitHub (per OAuth App).
Für eine Pipeline mit einer Quellaktion GitHub (per OAuth App) empfehlen wir, die Pipeline so zu ändern, dass eine Aktion GitHub (per GitHub App) verwendet wird, sodass die Änderungserkennung automatisiert wird. AWS CodeConnections Weitere Informationen zum Arbeiten mit Verbindungen finden Sie unter[GitHub Verbindungen](connections-github.md).
### Stellen Sie eine Verbindung zu GitHub (Konsole) her
Sie können die Konsole verwenden, um eine Verbindung zu herzustellen GitHub.
#### Schritt 1: Ersetzen Sie Ihre Aktion GitHub (per OAuth App)
Verwenden Sie die Pipeline-Bearbeitungsseite, um Ihre Aktion GitHub (per OAuth App) durch eine Aktion GitHub (per GitHub App) zu ersetzen.
**Um deine Aktion GitHub (per OAuth App) zu ersetzen**
1. Melden Sie sich bei der CodePipeline Konsole an.
1. Wählen Sie Ihre Pipeline und dann **Bearbeiten** aus. Wählen Sie in Ihrer **Quellstufe die Option Phase bearbeiten** aus. Es wird eine Meldung angezeigt, in der empfohlen wird, Ihre Aktion zu aktualisieren.
1. Wählen Sie **unter Aktionsanbieter** die Option **GitHub (über GitHub App)** aus.
1. Führen Sie eine der folgenden Aktionen aus:
+ Wenn Sie noch keine **Verbindung** zu Ihrem Anbieter hergestellt haben, wählen Sie unter Verbindung die Option **Connect** aus GitHub. Fahren Sie mit Schritt 2 fort: Verbindung herstellen zu GitHub.
+ Wenn Sie bereits eine **Verbindung** zu Ihrem Anbieter hergestellt haben, wählen Sie unter Verbindung die Verbindung aus. Fahren Sie mit Schritt 3 fort: Speichern Sie die Quellaktion für Ihre Verbindung.
#### Schritt 2: Stellen Sie eine Verbindung her zu GitHub
Nachdem Sie sich entschieden haben, die Verbindung herzustellen, wird **die GitHub Seite Connect** angezeigt.
**Um eine Verbindung herzustellen zu GitHub**
1. Unter **GitHub Verbindungseinstellungen** wird Ihr Verbindungsname unter **Verbindungsname** angezeigt.
Wählen Sie unter **GitHub Apps** eine App-Installation aus oder wählen Sie **Neue App installieren**, um eine zu erstellen.
**Anmerkung**
Sie installieren eine App für alle Verbindungen mit einem bestimmten Anbieter. Wenn Sie die GitHub App bereits installiert haben, wählen Sie sie aus und überspringen Sie diesen Schritt.
1. Wenn die Autorisierungsseite für GitHub angezeigt wird, melden Sie sich mit Ihren Anmeldeinformationen an und wählen Sie dann, ob Sie fortfahren möchten.
1. Auf der App-Installationsseite wird eine Meldung angezeigt, dass die AWS CodeStar App versucht, eine Verbindung zu Ihrem GitHub Konto herzustellen.
**Anmerkung**
Sie installieren die App nur einmal für jedes GitHub Konto. Wenn Sie die App schon einmal installiert haben, können Sie **Configure (Konfiguration)** wählen und mit einer Änderungsseite für die App-Installation fortfahren. Alternativ kommen Sie über die Schaltfläche „Back“ (Zurück) zur Konsole zurück.
1. Wählen Sie auf der AWS CodeStar Seite „**Installieren**“ die Option „**Installieren**“.
1. Auf der GitHub Seite **Connect** wird die Verbindungs-ID für Ihre neue Installation angezeigt. Wählen Sie **Connect** aus.
#### Schritt 3: Speichern Sie Ihre GitHub Quellaktion
Vervollständigen Sie Ihre Aktualisierungen auf der Seite **Aktion bearbeiten**, um Ihre neue Quellaktion zu speichern.
**Um Ihre GitHub Quellaktion zu speichern**
1. Geben Sie **unter Repository** den Namen Ihres Drittanbieter-Repositorys ein. Geben Sie im Feld **Branch** den Branch ein, in dem Ihre Pipeline Quelländerungen erkennen soll.
**Anmerkung**
Geben Sie im Feld **Repository** `owner-name/repository-name` wie in diesem Beispiel gezeigt ein:
```
my-account/my-repository
```
1. Wählen Sie unter **Ausgabeartefaktformat** das Format für Ihre Artefakte aus.
+ Um die Ausgabeartefakte der GitHub Aktion mit der Standardmethode zu speichern, wählen Sie **CodePipelineStandard**. Die Aktion greift auf die Dateien aus dem GitHub Repository zu und speichert die Artefakte in einer ZIP-Datei im Pipeline-Artefaktspeicher.
+ Um eine JSON-Datei zu speichern, die einen URL-Verweis auf das Repository enthält, damit Downstream-Aktionen Git-Befehle direkt ausführen können, wählen Sie **Full clone (Vollständiger Klon)**. Diese Option kann nur von CodeBuild nachgelagerten Aktionen verwendet werden.
Wenn Sie diese Option wählen, müssen Sie die Berechtigungen für Ihre CodeBuild Projektservice-Rolle aktualisieren, wie unter beschrieben[Fügen Sie CodeBuild GitClone Berechtigungen für Verbindungen zu Bitbucket, Enterprise Server oder .com GitHub hinzu GitHub GitLab](troubleshooting.md#codebuild-role-connections). Ein Tutorial, das Ihnen zeigt, wie Sie die Option **Vollständiges Klonen** verwenden, finden Sie unter[Tutorial: Vollständigen Klon mit einer GitHub Pipeline-Quelle verwenden](tutorials-github-gitclone.md).
1. Unter **Ausgabeartefakte** können Sie den Namen des Ausgabeartefakts für diese Aktion beibehalten, z. B. `SourceArtifact` Wählen Sie **Fertig**, um die **Aktionsseite Bearbeiten** zu schließen.
1. Wählen Sie „**Fertig**“, um die Seite zur Bearbeitung der Phase zu schließen. Wählen Sie **Speichern**, um die Seite zur Bearbeitung der Pipeline zu schließen.
### Verbindung herstellen zu GitHub (CLI)
Sie können das AWS Command Line Interface (AWS CLI) verwenden, um eine Verbindung zu herzustellen GitHub.
Verwenden Sie dazu den Befehl **create-connection**.
**Wichtig**
Eine Verbindung, die über AWS CLI oder AWS CloudFormation erstellt wurde, hat standardmäßig `PENDING` den Status. Nachdem Sie eine Verbindung mit der CLI hergestellt haben oder verwenden Sie die Konsole CloudFormation, um die Verbindung so zu bearbeiten, dass sie ihren Status festlegt`AVAILABLE`.
**Um eine Verbindung herzustellen zu GitHub**
1. Öffnen Sie die Eingabeaufforderung (Windows) oder das Terminal (Linux, macOS oder Unix). Verwenden Sie den AWS CLI , um den **create-connection** Befehl auszuführen, und geben Sie dabei `--provider-type` und `--connection-name` für Ihre Verbindung an. In diesem Beispiel lautet der Name des Drittanbieters `GitHub` und der angegebene Verbindungsname `MyConnection`.
```
aws codeconnections create-connection --provider-type GitHub --connection-name MyConnection
```
Wenn der Befehl erfolgreich ausgeführt wurde, gibt er die ARN-Informationen der Verbindung ähnlich der folgenden zurück.
```
{
"ConnectionArn": "arn:aws:codeconnections:us-west-2:account_id:connection/aEXAMPLE-8aad-4d5d-8878-dfcab0bc441f"
}
```
1. Verwenden Sie die Konsole, um die Verbindung fertigzustellen.
## Migrieren Sie Abfrage-Pipelines für eine Quellaktion GitHub (per OAuth App) zu Webhooks
Sie können Ihre Pipeline migrieren, um Webhooks zu verwenden, um Änderungen in Ihrem Quell-Repository zu erkennen. GitHub Diese Migration zu Webhooks ist nur für die Aktion GitHub (per OAuth App) vorgesehen.
+ **Konsole:** [Migrieren Sie Polling-Pipelines zu Webhooks GitHub (über OAuth App), Quellaktionen) (Konsole)](#update-change-detection-console-github)
+ **CLI:** [Migrieren Sie Abfrage-Pipelines zu Webhooks GitHub (über OAuth App), Quellaktionen) (CLI)](#update-change-detection-cli-github)
+ **CloudFormation: ** [Aktualisiere Pipelines für Push-Ereignisse GitHub (über OAuth App), Quellaktionen) (CloudFormation Vorlage)](#update-change-detection-cfn-github)
**Wichtig**
Verwenden Sie beim Erstellen von CodePipeline Webhooks nicht Ihre eigenen Anmeldeinformationen und verwenden Sie nicht dasselbe geheime Token für mehrere Webhooks. Generieren Sie für optimale Sicherheit für jeden Webhook, den Sie erstellen, ein eindeutiges geheimes Token. Das geheime Token ist eine willkürliche Zeichenfolge, die Sie angeben und die zur Berechnung und Signierung der gesendeten Webhook-Payloads GitHub verwendet wird CodePipeline, um die Integrität und Authentizität der Webhook-Payloads zu schützen. Die Verwendung Ihrer eigenen Anmeldeinformationen oder die Wiederverwendung desselben Tokens in mehreren Webhooks kann zu Sicherheitslücken führen.
### Migrieren Sie Polling-Pipelines zu Webhooks GitHub (über OAuth App), Quellaktionen) (Konsole)
Für die Quellaktion GitHub (per OAuth App) können Sie die CodePipeline Konsole verwenden, um Ihre Pipeline so zu aktualisieren, dass Webhooks verwendet werden, um Änderungen in Ihrem Quell-Repository zu erkennen. GitHub
Gehen Sie wie folgt vor, um eine Pipeline zu bearbeiten, die stattdessen Polling (regelmäßige Prüfungen) verwendet EventBridge . Wenn Sie eine Pipeline erstellen möchten, informieren Sie sich unter [Eine Pipeline, Phasen und Aktionen erstellen](pipelines-create.md).
Wenn Sie die Konsole verwenden, wird der Parameter `PollForSourceChanges` für Ihre Pipeline für Sie geändert. Der GitHub Webhook wird für Sie erstellt und registriert.
**So bearbeiten Sie die Quellphase einer Pipeline**
1. Melden Sie sich bei der an AWS-Managementkonsole und öffnen Sie die CodePipeline Konsole unter [http://console.aws.amazon. com/codesuite/codepipeline/home](https://console.aws.amazon.com/codesuite/codepipeline/home).
Die Namen aller mit Ihrem AWS Konto verknüpften Pipelines werden angezeigt.
1. Wählen Sie im Feld **Name** den Namen der Pipeline aus, die Sie bearbeiten möchten. Auf diese Weise wird eine detaillierte Ansicht der Pipeline geöffnet (einschließlich des Status der Aktionen in den einzelnen Stufen der Pipeline).
1. Wählen Sie auf der Pipelinedetails-Seite **Edit** aus.
1. Wählen Sie in der Stufe **Edit stage (Stufe bearbeiten)** das Bearbeitungssymbol für die Quellaktion aus.
1. Erweitern Sie die **Optionen zur Änderungserkennung** und wählen Sie **Amazon CloudWatch Events verwenden, um meine Pipeline automatisch zu starten, wenn eine Änderung eintritt (empfohlen)**.
Es wird eine Meldung mit dem Hinweis angezeigt, dass ein Webhook CodePipeline erstellt AWS CodePipeline wird GitHub , um Quellenänderungen zu erkennen: erstellt einen Webhook für Sie. Sie können sich in den folgenden Optionen abmelden. Wählen Sie **Aktualisieren** aus. CodePipeline Erzeugt zusätzlich zum Webhook Folgendes:
+ Ein Geheimnis, das nach dem Zufallsprinzip generiert wurde und zur Autorisierung der Verbindung verwendet wird. GitHub
+ Die Webhook-URL wird generiert, wobei der öffentliche Endpunkt für die Region verwendet wird.
CodePipeline registriert den Webhook bei. GitHub Damit wird die URL für den Empfang von Repository-Ereignissen abonniert.
1. Wenn Sie die Bearbeitung der Pipeline abgeschlossen haben, wählen Sie **Save pipeline changes** aus, um zur Übersichtsseite zurückzukehren.
Es wird eine Meldung mit dem Namen des für Ihre Pipeline zu erstellenden Webhooks angezeigt. Wählen Sie **Save and continue** aus.
1. Um Ihre Aktion zu testen, geben Sie eine Änderung frei, indem Sie mit dem eine Änderung AWS CLI an der Quelle festschreiben, die in der Quellphase der Pipeline angegeben wurde.
### Migrieren Sie Abfrage-Pipelines zu Webhooks GitHub (über OAuth App), Quellaktionen) (CLI)
Führen Sie die folgenden Schritte aus, um eine Pipeline, die Abfragen (periodische Prüfungen) verwendet, zu bearbeiten, damit sie stattdessen einen Webhook verwendet. Wenn Sie eine Pipeline erstellen möchten, informieren Sie sich unter [Eine Pipeline, Phasen und Aktionen erstellen](pipelines-create.md).
Um eine ereignisgesteuerte Pipeline zu erstellen, bearbeiten Sie den Parameter `PollForSourceChanges` Ihrer Pipeline und erstellen anschließend die folgenden Ressourcen manuell:
+ GitHub Webhook und Autorisierungsparameter
**So erstellen und registrieren Sie Ihren Webhook**
**Anmerkung**
Wenn Sie die CLI verwenden oder CloudFormation eine Pipeline erstellen und einen Webhook hinzufügen, müssen Sie regelmäßige Prüfungen deaktivieren. Um die periodischen Prüfungen zu deaktivieren, müssen Sie explizit den `PollForSourceChanges`-Parameter hinzufügen und auf „false“ setzen, wie in der abschließenden Prozedur unten. Andernfalls ist die Standardeinstellung für eine CLI oder CloudFormation Pipeline der `PollForSourceChanges` Standardwert true und wird nicht in der Ausgabe der Pipeline-Struktur angezeigt. Weitere Hinweise zu PollForSourceChanges Standardwerten finden Sie unter. [Gültige Einstellungen für den `PollForSourceChanges` Parameter](PollForSourceChanges-defaults.md)
1. Erstellen Sie in einem Texteditor eine JSON-Datei für den Webhook, den Sie erstellen möchten, und speichern Sie sie. Verwenden Sie diese Beispieldatei für einen Webhook mit dem Namen `my-webhook`:
```
{
"webhook": {
"name": "my-webhook",
"targetPipeline": "pipeline_name",
"targetAction": "source_action_name",
"filters": [{
"jsonPath": "$.ref",
"matchEquals": "refs/heads/{Branch}"
}],
"authentication": "GITHUB_HMAC",
"authenticationConfiguration": {
"SecretToken": "secret"
}
}
}
```
1. Rufen Sie den Befehl **put-webhook** auf und beziehen Sie die Parameter `--cli-input` und `--region` ein.
Der folgende Beispielbefehl erstellt einen Webhook mit der JSON-Datei `webhook_json`.
```
aws codepipeline put-webhook --cli-input-json file://webhook_json.json --region "eu-central-1"
```
1. In der in diesem Beispiel gezeigten Ausgabe für einen Webhook mit dem Namen `my-webhook` werden die URL und der ARN zurückgegeben.
```
{
"webhook": {
"url": "https://webhooks.domain.com/trigger111111111EXAMPLE11111111111111111",
"definition": {
"authenticationConfiguration": {
"SecretToken": "secret"
},
"name": "my-webhook",
"authentication": "GITHUB_HMAC",
"targetPipeline": "pipeline_name",
"targetAction": "Source",
"filters": [
{
"jsonPath": "$.ref",
"matchEquals": "refs/heads/{Branch}"
}
]
},
"arn": "arn:aws:codepipeline:eu-central-1:ACCOUNT_ID:webhook:my-webhook"
},
"tags": [{
"key": "Project",
"value": "ProjectA"
}]
}
```
In diesem Beispiel wird dem Webhook Tagging hinzugefügt, indem dem Webhook der Tag-Schlüssel `Project` und der Wert `ProjectA` hinzugefügt werden. Weitere Informationen zum Markieren von Ressourcen in finden Sie CodePipeline unter. [Taggen von -Ressourcen](tag-resources.md)
1. Rufen Sie den Befehl **register-webhook-with-third-party** auf und beziehen Sie den `--webhook-name`-Parameter ein.
Der folgende Beispielbefehl registriert einen Webhook mit dem Namen `my-webhook`.
```
aws codepipeline register-webhook-with-third-party --webhook-name my-webhook
```
**So bearbeiten Sie den Parameter Ihrer Pipeline PollForSourceChanges**
**Wichtig**
Wenn Sie eine Pipeline mit dieser Methode erstellen, ist der Parameter `PollForSourceChanges` standardmäßig „true“, wenn er nicht ausdrücklich auf „false“ gesetzt wird. Wenn Sie ereignisbasierte Erkennung hinzufügen, müssen Sie den Parameter Ihrer Ausgabe hinzufügen und Ihn auf „false“ setzen, um die Abfrage zu deaktivieren. Andernfalls wird Ihre Pipeline bei einer einzigen Quelländerung zweimal gestartet. Details hierzu finden Sie unter [Gültige Einstellungen für den `PollForSourceChanges` Parameter](PollForSourceChanges-defaults.md).
1. Führen Sie den Befehl **get-pipeline** zum Kopieren der Pipeline-Struktur in eine JSON-Datei aus. Für eine Pipeline mit dem Namen `MyFirstPipeline` würden Sie beispielsweise den folgenden Befehl verwenden:
```
aws codepipeline get-pipeline --name MyFirstPipeline >pipeline.json
```
Dieser Befehl gibt nichts zurück. Die erstellte Datei sollte jedoch in dem Verzeichnis auftauchen, in dem Sie den Befehl ausgeführt haben.
1. Öffnen Sie die JSON-Datei in einem beliebigen Texteditor und bearbeiten Sie die Quellstufe, indem Sie den Parameter `PollForSourceChanges` ändern oder hinzufügen. In diesem Beispiel für ein Repository mit dem Namen `UserGitHubRepo` ist der Parameter auf `false` festgelegt.
**Warum nehme ich diese Änderung vor?** Wenn Sie diesen Parameter ändern, werden regelmäßige Überprüfungen deaktiviert, sodass Sie nur die ereignisbasierte Änderungserkennung verwenden können.
```
"configuration": {
"Owner": "name",
"Repo": "UserGitHubRepo",
"PollForSourceChanges": "false",
"Branch": "main",
"OAuthToken": "****"
},
```
1. Falls Sie mit der Pipeline-Struktur arbeiten, die mithilfe des **get-pipeline**-Befehls abgerufen wurde, müssen Sie die Struktur in der JSON-Datei bearbeiten, indem Sie die `metadata`-Zeilen aus der Datei entfernen. Andernfalls kann der **update-pipeline**-Befehl sie nicht nutzen. Entfernen Sie den Abschnitt `"metadata"` aus der Pipeline-Struktur in der JSON-Datei, einschließlich `{ }` und der Felder `"created"`, `"pipelineARN"` und `"updated"`.
Entfernen Sie z. B. die folgenden Zeilen aus der Struktur:
```
"metadata": {
"pipelineArn": "arn:aws:codepipeline:region:account-ID:pipeline-name",
"created": "date",
"updated": "date"
},
```
Speichern Sie die Datei.
1. Führen Sie den Befehl **update-pipeline** aus, um die Änderungen zu übernehmen. Geben Sie die Pipeline-JSON-Datei dabei folgendermaßen an:
**Wichtig**
Achten Sie darauf, dass `file://` vor dem Dateinamen steht. Dies ist bei diesem Befehl erforderlich.
```
aws codepipeline update-pipeline --cli-input-json file://pipeline.json
```
Dieser Befehl gibt die gesamte Struktur der bearbeiteten Pipeline zurück.
**Anmerkung**
Der Befehl **update-pipeline** stoppt die Pipeline. Wenn eine Revision über die Pipeline ausgeführt wird, wenn Sie den Befehl **update-pipeline** ausführen, wird diese Ausführung gestoppt. Sie müssen die Ausführung der Pipeline manuell starten, um die Revision über die aktualisierte Pipeline auszuführen. Verwenden Sie den **start-pipeline-execution**-Befehl, um Ihre Pipeline manuell zu starten.
### Aktualisiere Pipelines für Push-Ereignisse GitHub (über OAuth App), Quellaktionen) (CloudFormation Vorlage)
Gehen Sie wie folgt vor, um Ihre Pipeline (mit einer GitHub Quelle) von regelmäßigen Überprüfungen (Polling) bis hin zur ereignisbasierten Änderungserkennung mithilfe von Webhooks zu aktualisieren.
Um eine ereignisgesteuerte Pipeline mit zu erstellen AWS CodeCommit, bearbeiten Sie den `PollForSourceChanges` Parameter Ihrer Pipeline und fügen dann eine GitHub Webhook-Ressource zu Ihrer Vorlage hinzu.
Wenn Sie CloudFormation Ihre Pipelines erstellen und verwalten, hat Ihre Vorlage Inhalte wie den folgenden.
**Anmerkung**
Beachten Sie die `PollForSourceChanges`-Konfigurationseigenschaft in der Quellstufe. Wenn diese Eigenschaft in Ihrer Vorlage nicht enthalten ist, dann wird `PollForSourceChanges` standardmäßig auf `true` festgelegt.
------
#### [ YAML ]
```
Resources:
AppPipeline:
Type: AWS::CodePipeline::Pipeline
Properties:
Name: github-polling-pipeline
RoleArn:
!GetAtt CodePipelineServiceRole.Arn
Stages:
-
Name: Source
Actions:
-
Name: SourceAction
ActionTypeId:
Category: Source
Owner: ThirdParty
Version: 1
Provider: GitHub
OutputArtifacts:
- Name: SourceOutput
Configuration:
Owner: !Ref GitHubOwner
Repo: !Ref RepositoryName
Branch: !Ref BranchName
OAuthToken: {{resolve:secretsmanager:MyGitHubSecret:SecretString:token}} PollForSourceChanges: true
RunOrder: 1
...
```
------
#### [ JSON ]
```
"AppPipeline": {
"Type": "AWS::CodePipeline::Pipeline",
"Properties": {
"Name": "github-polling-pipeline",
"RoleArn": {
"Fn::GetAtt": [
"CodePipelineServiceRole",
"Arn"
]
},
"Stages": [
{
"Name": "Source",
"Actions": [
{
"Name": "SourceAction",
"ActionTypeId": {
"Category": "Source",
"Owner": "ThirdParty",
"Version": 1,
"Provider": "GitHub"
},
"OutputArtifacts": [
{
"Name": "SourceOutput"
}
],
"Configuration": {
"Owner": {
"Ref": "GitHubOwner"
},
"Repo": {
"Ref": "RepositoryName"
},
"Branch": {
"Ref": "BranchName"
},
"OAuthToken": "{{resolve:secretsmanager:MyGitHubSecret:SecretString:token}}",
"PollForSourceChanges": true
},
"RunOrder": 1
}
]
},
...
```
------
**So fügen Sie Parameter hinzu und erstellen einen Webhook in Ihrer Vorlage**
Wir empfehlen dringend, dass Sie diese AWS Secrets Manager zum Speichern Ihrer Anmeldeinformationen verwenden. Wenn Sie Secrets Manager verwenden, müssen Sie Ihre geheimen Parameter bereits in Secrets Manager konfiguriert und gespeichert haben. In diesem Beispiel werden dynamische Verweise auf Secrets Manager für die GitHub Anmeldeinformationen für Ihren Webhook verwendet. Weitere Informationen finden Sie unter [ Verwenden von dynamischen Referenzen zum Angeben von Vorlagenwerten](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/dynamic-references.html#dynamic-references-secretsmanager).
**Wichtig**
Geben Sie bei der Übergabe von Secret-Parametern den Wert nicht direkt in die Vorlage ein. Der Wert wird als Klartext gerendert und ist daher lesbar. Verwenden Sie aus Sicherheitsgründen keinen Klartext in Ihrer CloudFormation Vorlage, um Ihre Anmeldeinformationen zu speichern.
Wenn Sie die CLI verwenden oder CloudFormation eine Pipeline erstellen und einen Webhook hinzufügen, müssen Sie regelmäßige Prüfungen deaktivieren.
**Anmerkung**
Um die periodischen Prüfungen zu deaktivieren, müssen Sie explizit den `PollForSourceChanges`-Parameter hinzufügen und auf „false“ setzen, wie in der abschließenden Prozedur unten. Andernfalls ist die Standardeinstellung für eine CLI oder CloudFormation Pipeline der `PollForSourceChanges` Standardwert true und wird nicht in der Ausgabe der Pipeline-Struktur angezeigt. Weitere Hinweise zu PollForSourceChanges Standardwerten finden Sie unter. [Gültige Einstellungen für den `PollForSourceChanges` Parameter](PollForSourceChanges-defaults.md)
1. Fügen Sie in der Vorlage unter `Resources` Ihre Parameter hinzu:
------
#### [ YAML ]
```
Parameters:
GitHubOwner:
Type: String
...
```
------
#### [ JSON ]
```
{
"Parameters": {
"BranchName": {
"Description": "GitHub branch name",
"Type": "String",
"Default": "main"
},
"GitHubOwner": {
"Type": "String"
},
...
```
------
1. Verwenden Sie die `AWS::CodePipeline::Webhook` CloudFormation Ressource, um einen Webhook hinzuzufügen.
**Anmerkung**
Die angegebene `TargetAction` muss mit der in der Pipeline definierten `Name`-Eigenschaft Ihrer Quellaktion übereinstimmen.
Wenn auf gesetzt `RegisterWithThirdParty` ist`true`, stellen Sie sicher, dass der mit dem verknüpfte Benutzer die erforderlichen Bereiche festlegen `OAuthToken` kann. GitHub Das Token und der Webhook erfordern die folgenden Bereiche: GitHub
+ `repo`: Wird für die vollständige Kontrolle in Bezug auf das Lesen und Einfügen von Artefakten aus öffentlichen und privaten Repositorys in eine Pipeline verwendet.
+ `admin:repo_hook`: Wird für die vollständige Kontrolle in Bezug auf Repository-Hooks verwendet.
Andernfalls wird ein GitHub 404-Fehler zurückgegeben. Weitere Informationen zum zurückgegebenen Fehler 404 erhalten Sie unter [https://help.github.com/articles/about-webhooks](https://help.github.com/articles/about-webhooks).
------
#### [ YAML ]
```
AppPipelineWebhook:
Type: AWS::CodePipeline::Webhook
Properties:
Authentication: GITHUB_HMAC
AuthenticationConfiguration:
SecretToken: {{resolve:secretsmanager:MyGitHubSecret:SecretString:token}}
Filters:
-
JsonPath: "$.ref"
MatchEquals: refs/heads/{Branch}
TargetPipeline: !Ref AppPipeline
TargetAction: SourceAction
Name: AppPipelineWebhook
TargetPipelineVersion: !GetAtt AppPipeline.Version
RegisterWithThirdParty: true
...
```
------
#### [ JSON ]
```
"AppPipelineWebhook": {
"Type": "AWS::CodePipeline::Webhook",
"Properties": {
"Authentication": "GITHUB_HMAC",
"AuthenticationConfiguration": {
"SecretToken": "{{resolve:secretsmanager:MyGitHubSecret:SecretString:token}}"
},
"Filters": [{
"JsonPath": "$.ref",
"MatchEquals": "refs/heads/{Branch}"
}],
"TargetPipeline": {
"Ref": "AppPipeline"
},
"TargetAction": "SourceAction",
"Name": "AppPipelineWebhook",
"TargetPipelineVersion": {
"Fn::GetAtt": [
"AppPipeline",
"Version"
]
},
"RegisterWithThirdParty": true
}
},
...
```
------
1. Speichern Sie die aktualisierte Vorlage auf Ihrem lokalen Computer und öffnen Sie dann die CloudFormation Konsole.
1. Wählen Sie Ihren Stack aus und klicken Sie auf **Create Change Set for Current Stack (Änderungssatz für laufenden Stack erstellen)**.
1. Laden Sie die Vorlage hoch und zeigen Sie dann die in CloudFormation aufgeführten Änderungen an. Dies sind die Änderungen, die am Stack vorgenommen werden sollen. Ihre neuen Ressourcen sollten in der Liste angezeigt werden.
1. Wählen Sie **Ausführen**.
**Um den PollForSourceChanges Parameter Ihrer Pipeline zu bearbeiten**
**Wichtig**
Wenn Sie eine Pipeline mit dieser Methode erstellen, ist der Parameter `PollForSourceChanges` standardmäßig „true“, wenn er nicht ausdrücklich auf „false“ gesetzt wird. Wenn Sie ereignisbasierte Erkennung hinzufügen, müssen Sie den Parameter Ihrer Ausgabe hinzufügen und Ihn auf „false“ setzen, um die Abfrage zu deaktivieren. Andernfalls wird Ihre Pipeline bei einer einzigen Quelländerung zweimal gestartet. Details hierzu finden Sie unter [Gültige Einstellungen für den `PollForSourceChanges` Parameter](PollForSourceChanges-defaults.md).
+ Ändern Sie in der Vorlage `PollForSourceChanges` in `false`. Wenn Sie `PollForSourceChanges` nicht in Ihre Pipeline-Definition einbezogen haben, fügen Sie das Objekt hinzu und legen es auf "false" fest.
**Warum nehme ich diese Änderung vor?** Durch Ändern dieses Parameters in `false` werden periodische Prüfungen deaktiviert. Sie können daher nur die ereignisbasierte Erkennung von Änderungen verwenden.
------
#### [ YAML ]
```
Name: Source
Actions:
-
Name: SourceAction
ActionTypeId:
Category: Source
Owner: ThirdParty
Version: 1
Provider: GitHub
OutputArtifacts:
- Name: SourceOutput
Configuration:
Owner: !Ref GitHubOwner
Repo: !Ref RepositoryName
Branch: !Ref BranchName
OAuthToken: {{resolve:secretsmanager:MyGitHubSecret:SecretString:token}}
PollForSourceChanges: false
RunOrder: 1
```
------
#### [ JSON ]
```
{
"Name": "Source",
"Actions": [{
"Name": "SourceAction",
"ActionTypeId": {
"Category": "Source",
"Owner": "ThirdParty",
"Version": 1,
"Provider": "GitHub"
},
"OutputArtifacts": [{
"Name": "SourceOutput"
}],
"Configuration": {
"Owner": {
"Ref": "GitHubOwner"
},
"Repo": {
"Ref": "RepositoryName"
},
"Branch": {
"Ref": "BranchName"
},
"OAuthToken": "{{resolve:secretsmanager:MyGitHubSecret:SecretString:token}}",
PollForSourceChanges: false
},
"RunOrder": 1
}]
```
------
**Example**
Wenn Sie diese Ressourcen mit erstellen CloudFormation, wird der definierte Webhook im angegebenen GitHub Repository erstellt. Ihre Pipeline wird bei einem Commit ausgelöst.
```
Parameters:
GitHubOwner:
Type: String
Resources:
AppPipelineWebhook:
Type: AWS::CodePipeline::Webhook
Properties:
Authentication: GITHUB_HMAC
AuthenticationConfiguration:
SecretToken: {{resolve:secretsmanager:MyGitHubSecret:SecretString:token}}
Filters:
-
JsonPath: "$.ref"
MatchEquals: refs/heads/{Branch}
TargetPipeline: !Ref AppPipeline
TargetAction: SourceAction
Name: AppPipelineWebhook
TargetPipelineVersion: !GetAtt AppPipeline.Version
RegisterWithThirdParty: true
AppPipeline:
Type: AWS::CodePipeline::Pipeline
Properties:
Name: github-events-pipeline
RoleArn:
!GetAtt CodePipelineServiceRole.Arn
Stages:
-
Name: Source
Actions:
-
Name: SourceAction
ActionTypeId:
Category: Source
Owner: ThirdParty
Version: 1
Provider: GitHub
OutputArtifacts:
- Name: SourceOutput
Configuration:
Owner: !Ref GitHubOwner
Repo: !Ref RepositoryName
Branch: !Ref BranchName
OAuthToken: {{resolve:secretsmanager:MyGitHubSecret:SecretString:token}}
PollForSourceChanges: false
RunOrder: 1
...
```
```
{
"Parameters": {
"BranchName": {
"Description": "GitHub branch name",
"Type": "String",
"Default": "main"
},
"RepositoryName": {
"Description": "GitHub repository name",
"Type": "String",
"Default": "test"
},
"GitHubOwner": {
"Type": "String"
},
"ApplicationName": {
"Description": "CodeDeploy application name",
"Type": "String",
"Default": "DemoApplication"
},
"BetaFleet": {
"Description": "Fleet configured in CodeDeploy",
"Type": "String",
"Default": "DemoFleet"
}
},
"Resources": {
...
},
"AppPipelineWebhook": {
"Type": "AWS::CodePipeline::Webhook",
"Properties": {
"Authentication": "GITHUB_HMAC",
"AuthenticationConfiguration": {
"SecretToken": {
"{{resolve:secretsmanager:MyGitHubSecret:SecretString:token}}"
}
},
"Filters": [
{
"JsonPath": "$.ref",
"MatchEquals": "refs/heads/{Branch}"
}
],
"TargetPipeline": {
"Ref": "AppPipeline"
},
"TargetAction": "SourceAction",
"Name": "AppPipelineWebhook",
"TargetPipelineVersion": {
"Fn::GetAtt": [
"AppPipeline",
"Version"
]
},
"RegisterWithThirdParty": true
}
},
"AppPipeline": {
"Type": "AWS::CodePipeline::Pipeline",
"Properties": {
"Name": "github-events-pipeline",
"RoleArn": {
"Fn::GetAtt": [
"CodePipelineServiceRole",
"Arn"
]
},
"Stages": [
{
"Name": "Source",
"Actions": [
{
"Name": "SourceAction",
"ActionTypeId": {
"Category": "Source",
"Owner": "ThirdParty",
"Version": 1,
"Provider": "GitHub"
},
"OutputArtifacts": [
{
"Name": "SourceOutput"
}
],
"Configuration": {
"Owner": {
"Ref": "GitHubOwner"
},
"Repo": {
"Ref": "RepositoryName"
},
"Branch": {
"Ref": "BranchName"
},
"OAuthToken": "{{resolve:secretsmanager:MyGitHubSecret:SecretString:token}}",
"PollForSourceChanges": false
},
"RunOrder": 1
...
```