Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.
# Migrez les pipelines de sondage pour utiliser la détection des modifications basée sur les événements
AWS CodePipeline prend en charge la livraison complète et end-to-end continue, ce qui inclut le démarrage de votre pipeline chaque fois qu'un changement de code est effectué. Deux méthodes sont prises en charge pour démarrer votre pipeline lors d'une modification de code : la détection des modifications basée sur les événements et le sondage. Nous recommandons d'utiliser la détection des modifications basée sur les événements pour les pipelines.
Utilisez les procédures incluses ici pour migrer (mettre à jour) vos pipelines de sondage vers la méthode de détection des modifications basée sur les événements pour votre pipeline.
La méthode de détection des modifications basée sur les événements recommandée pour les pipelines est déterminée par la source du pipeline, telle que. CodeCommit Dans ce cas, par exemple, le pipeline de sondage devra migrer vers la détection des modifications basée sur les événements avec. EventBridge
## Comment migrer les pipelines de sondage
Pour migrer des pipelines de sondage, déterminez vos pipelines de sondage, puis déterminez la méthode recommandée de détection des modifications basée sur les événements :
+ Suivez les étapes ci-dessous [Afficher les pipelines de sondage dans votre compte](#update-change-detection-view-polling) pour déterminer vos pipelines de vote.
+ Dans le tableau, recherchez le type de source de votre pipeline, puis choisissez la procédure avec l'implémentation que vous souhaitez utiliser pour migrer votre pipeline de sondage. Chaque section contient plusieurs méthodes de migration, telles que l'utilisation de la CLI ou CloudFormation.
[See the AWS documentation website for more details](http://docs.aws.amazon.com/fr_fr/codepipeline/latest/userguide/update-change-detection.html)
**Important**
Pour les mises à jour de configuration des actions de pipeline applicables, telles que les pipelines comportant une action GitHub (via une OAuth application), vous devez définir explicitement le `PollForSourceChanges` paramètre sur *false* dans la configuration de votre action Source pour empêcher le sondage d'un pipeline. Par conséquent, il est possible de configurer par erreur un pipeline avec une détection des modifications basée sur des événements *et* une interrogation, par exemple en configurant une EventBridge règle et en omettant le paramètre. `PollForSourceChanges` Cela génère des exécutions de pipeline en double ; le pipeline est compté dans le nombre total de pipelines d'interrogation, qui, par défaut, est beaucoup plus faible que celui des pipelines basés sur les événements. Pour de plus amples informations, veuillez consulter [Quotas dans AWS CodePipeline](limits.md).
## Afficher les pipelines de sondage dans votre compte
Dans un premier temps, utilisez l'un des scripts suivants pour déterminer quels pipelines de votre compte sont configurés pour le sondage. Il s'agit des pipelines permettant de migrer vers la détection des modifications basée sur les événements.
### Afficher les pipelines de sondage dans votre compte (script)
Suivez ces étapes pour utiliser un script afin de déterminer les pipelines de votre compte qui utilisent le sondage.
1. Ouvrez une fenêtre de terminal, puis effectuez l'une des opérations suivantes :
+ Exécutez la commande suivante pour créer un nouveau script nommé **PollingPipelinesExtractor.sh.**
```
vi PollingPipelinesExtractor.sh
```
+ Pour utiliser un script python, exécutez la commande suivante pour créer un nouveau script python nommé **PollingPipelinesExtractor.py.**
```
vi PollingPipelinesExtractor.py
```
1. Copiez et collez le code suivant dans le **PollingPipelinesExtractor**script. Effectuez l’une des actions suivantes :
+ Copiez et collez le code suivant dans le script **PollingPipelinesExtractor.sh.**
```
#!/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."
```
+ Copiez et collez le code suivant dans le script **PollingPipelinesExtractor.py.**
```
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. Pour chaque région où vous avez des pipelines, vous devez exécuter le script correspondant à cette région. Pour exécuter le script, effectuez l'une des opérations suivantes :
+ Exécutez la commande suivante pour exécuter le script nommé **PollingPipelinesExtractor.sh.** Dans cet exemple, la région est us-west-2.
```
./PollingPipelinesExtractor.sh us-west-2
```
+ Pour le script python, exécutez la commande suivante pour exécuter le script python nommé **PollingPipelinesExtractor.py.** Dans cet exemple, la région est us-west-2.
```
python3 PollingPipelinesExtractor.py us-west-2
```
Dans l'exemple de sortie du script suivant, la région us-west-2 a renvoyé une liste de pipelines de sondage et indique l'heure de la dernière exécution de chaque pipeline.
```
% ./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...%
```
Analysez le résultat du script et, pour chaque pipeline de la liste, mettez à jour la source d'interrogation selon la méthode de détection des modifications basée sur les événements recommandée.
**Note**
Vos pipelines de sondage sont déterminés par la configuration d'action du pipeline pour le `PollForSourceChanges` paramètre. Si le `PollForSourceChanges` paramètre est omis dans la configuration de la source du pipeline, le système interroge CodePipeline par défaut votre référentiel pour vérifier les modifications de source. Ce comportement est le même que s'`PollForSourceChanges`il était inclus et défini sur true. Pour plus d'informations, consultez les paramètres de configuration de l'action source de votre pipeline, tels que les paramètres de configuration de l'action source Amazon S3 dans[Référence d'action source Amazon S3](action-reference-S3.md).
Notez que ce script génère également un fichier .csv contenant la liste des pipelines de sondage de votre compte et enregistre le fichier .csv dans le dossier de travail actuel.
## Migrer les pipelines de sondage avec une CodeCommit source
Vous pouvez migrer votre pipeline de sondage EventBridge afin de détecter les modifications apportées à votre référentiel CodeCommit source ou à votre compartiment source Amazon S3.
**CodeCommit**-- Pour un pipeline avec une CodeCommit source, modifiez le pipeline afin que la détection des modifications soit automatisée EventBridge. Choisissez l'une des méthodes suivantes pour implémenter la migration :
+ **Console :** [Migrer les pipelines de sondage (CodeCommit ou la source Amazon S3) (console)](#update-change-detection-console-codecommit-S3)
+ **CLI :** [Migrer les pipelines de sondage (CodeCommit source) (CLI)](#update-change-detection-cli-codecommit)
+ **CloudFormation: ** [Migrer les pipelines de sondage (CodeCommit source) (CloudFormation modèle)](#update-change-detection-cfn-codecommit)
### Migrer les pipelines de sondage (CodeCommit ou la source Amazon S3) (console)
Vous pouvez utiliser la CodePipeline console pour mettre à jour votre pipeline afin de détecter les modifications apportées à votre référentiel CodeCommit source ou à votre compartiment source Amazon S3. EventBridge
**Note**
Lorsque vous utilisez la console pour modifier un pipeline contenant un référentiel CodeCommit source ou un compartiment source Amazon S3, la règle et le rôle IAM sont créés pour vous. Si vous utilisez le AWS CLI pour modifier le pipeline, vous devez créer vous-même la EventBridge règle et le rôle IAM. Pour de plus amples informations, veuillez consulter [CodeCommit actions à la source et EventBridge](triggering.md).
Utilisez ces étapes pour modifier un pipeline qui utilise les vérifications périodiques. Si vous voulez créer un pipeline, consultez [Création d'un pipeline, d'étapes et d'actions](pipelines-create.md).
**Pour modifier l'étape source du pipeline**
1. Connectez-vous à la CodePipeline console AWS Management Console et ouvrez-la à l'[adresse http://console.aws.amazon. com/codesuite/codepipeline/home](https://console.aws.amazon.com/codesuite/codepipeline/home).
Les noms de tous les pipelines associés à votre AWS compte sont affichés.
1. Dans **Name**, choisissez le nom du pipeline que vous souhaitez modifier. Une vue détaillée du pipeline s'affiche alors, laquelle indique notamment l'état de chaque action, dans chaque étape du pipeline.
1. Sur la page des détails du pipeline, choisissez **Edit**.
1. À l'étape **Modifier**, choisissez l'icône de modification sur l'action source.
1. Développez **les options de détection des modifications** et choisissez **Utiliser les CloudWatch événements pour démarrer automatiquement mon pipeline en cas de modification (recommandé)**.
Un message s'affiche indiquant la EventBridge règle à créer pour ce pipeline. Choisissez **Mettre à jour**.
Si vous mettez à jour un pipeline qui possède une source Amazon S3, le message suivant s'affiche. Choisissez **Mettre à jour**.
1. Lorsque vous avez terminé de modifier votre pipeline, cliquez sur **Save pipeline changes** pour revenir à la page récapitulative.
Un message affiche le nom de la EventBridge règle à créer pour votre pipeline. Choisissez **Save and continue (Enregistrer et continuer)**.
1. Pour tester votre action, publiez une modification en utilisant le AWS CLI pour valider une modification de la source spécifiée dans l'étape source du pipeline.
### Migrer les pipelines de sondage (CodeCommit source) (CLI)
Procédez comme suit pour modifier un pipeline qui utilise des interrogations (vérifications périodiques) afin d'utiliser une EventBridge règle pour démarrer le pipeline. Si vous voulez créer un pipeline, consultez [Création d'un pipeline, d'étapes et d'actions](pipelines-create.md).
Pour créer un pipeline piloté par des événements avec CodeCommit, vous modifiez le `PollForSourceChanges` paramètre de votre pipeline, puis vous créez les ressources suivantes :
+ EventBridge événement
+ Rôle IAM pour autoriser cet événement à lancer votre pipeline
**Pour modifier le PollForSourceChanges paramètre de votre pipeline**
**Important**
Lorsque vous créez un pipeline avec cette méthode, le paramètre `PollForSourceChanges` prend la valeur Vrai par défaut s'il n'est pas explicitement défini sur Faux. Lorsque vous ajoutez la détection des modifications basée sur les événements, vous devez ajouter le paramètre à votre sortie et le configurer sur Faux pour désactiver l'interrogation. Sinon, votre pipeline démarre deux fois pour une seule modification de source. Pour en savoir plus, consultez [Réglages valides pour le `PollForSourceChanges` paramètre](PollForSourceChanges-defaults.md).
1. Exécutez la commande **get-pipeline** pour copier la structure de pipeline dans un fichier JSON. Par exemple, pour un pipeline nommé `MyFirstPipeline`, exécutez la commande suivante :
```
aws codepipeline get-pipeline --name {{MyFirstPipeline}} >{{pipeline.json}}
```
Cette commande ne renvoie rien, mais le fichier que vous avez créé doit apparaître dans le répertoire où vous avez exécuté la commande.
1. Ouvrez le fichier JSON dans un éditeur de texte brut et modifiez l'étape source en remplaçant la valeur du paramètre `PollForSourceChanges` par `false`, comme illustré dans cet exemple.
**Pourquoi est-ce que j'effectue cette modification ?** Le remplacement de la valeur de ce paramètre par `false` désactive les vérifications périodiques, ce qui vous permet d'utiliser la détection des modifications basée sur les événements uniquement.
```
"configuration": {
{{"PollForSourceChanges": "false",}}
"BranchName": "main",
"RepositoryName": "MyTestRepo"
},
```
1. Si vous utilisez la structure de pipeline extraite à l'aide de la commande **get-pipeline**, supprimez les lignes `metadata` du fichier JSON. Sinon, la commande **update-pipeline** ne peut pas l'utiliser. Supprimez les lignes `"metadata": { }` et les champs `"updated"`, `"created"` et `"pipelineARN"`.
Par exemple, supprimez les lignes suivantes de la structure :
```
"metadata": {
"pipelineArn": "arn:aws:codepipeline:{{region}}:{{account-ID}}:{{pipeline-name}}",
"created": "{{date}}",
"updated": "{{date}}"
},
```
Enregistrez le fichier.
1. Pour appliquer les modifications, exécutez la commande **update-pipeline** en spécifiant le fichier JSON du pipeline :
**Important**
N'oubliez pas d'inclure `file://` devant le nom du fichier. Il est nécessaire dans cette commande.
```
aws codepipeline update-pipeline --cli-input-json file://{{pipeline.json}}
```
Cette commande affiche toute la structure du pipeline mise à jour.
**Note**
La commande **update-pipeline** interrompt le pipeline. Si une révision est exécutée dans le pipeline lorsque vous exécutez la commande **update-pipeline** celle-ci est interrompue. Vous devez lancer manuellement le pipeline pour exécuter cette révision dans le pipeline mis à jour. Utilisez la commande **`start-pipeline-execution`** pour démarrer manuellement votre pipeline.
**Pour créer une EventBridge règle avec CodeCommit comme source d'événement et CodePipeline comme cible**
1. Ajoutez des autorisations EventBridge à utiliser CodePipeline pour invoquer la règle. Pour plus d'informations, consultez [Utiliser des politiques basées sur les ressources pour Amazon](https://docs.aws.amazon.com/eventbridge/latest/userguide/eb-use-resource-based.html). EventBridge
1. Utilisez l'exemple suivant pour créer la politique de confiance qui permet EventBridge d'assumer le rôle de service. Nommez la stratégie d'approbation `trustpolicyforEB.json`.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": "events.amazonaws.com"
},
"Action": "sts:AssumeRole"
}
]
}
```
------
1. Utilisez la commande suivante pour créer le rôle `Role-for-MyRule` et attachez la stratégie d'approbation.
```
aws iam create-role --role-name Role-for-MyRule --assume-role-policy-document file://trustpolicyforEB.json
```
1. Créez le JSON de stratégie d'autorisations comme indiqué dans cet exemple pour le pipeline nommé `MyFirstPipeline`. Nommez la stratégie d'autorisations `permissionspolicyforEB.json`.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"codepipeline:StartPipelineExecution"
],
"Resource": [
"arn:aws:codepipeline:us-west-2:{{111122223333}}:MyFirstPipeline"
]
}
]
}
```
------
1. Utilisez la commande suivante pour attacher au rôle `Role-for-MyRule` la stratégie d'autorisations `CodePipeline-Permissions-Policy-for-EB`.
**Pourquoi est-ce que j'effectue cette modification ?** L'ajout de cette politique au rôle crée des autorisations pour EventBridge.
```
aws iam put-role-policy --role-name Role-for-MyRule --policy-name CodePipeline-Permissions-Policy-For-EB --policy-document file://permissionspolicyforEB.json
```
1. Appelez la commande **put-rule** et incluez les paramètres `--name`, `--event-pattern` et `--role-arn`.
**Pourquoi est-ce que j'effectue cette modification ?** Cette commande permet à CloudFormation de créer l'événement.
L'exemple de commande suivant crée une règle nommée `MyCodeCommitRepoRule`.
```
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. Pour l'ajouter CodePipeline en tant que cible, appelez la **put-targets** commande et incluez les paramètres suivants :
+ Le paramètre `--rule` s'utilise avec le la règle `rule_name` que vous avez créée à l'aide de la commande **put-rule**.
+ Le paramètre `--targets` s'utilise avec l'ID de liste `Id` de la cible figurant dans la liste des cibles et l'`ARN` du pipeline cible.
L'exemple de commande suivant spécifie que pour la règle appelée `MyCodeCommitRepoRule`, l'`Id` cible est composé du numéro un, ce qui indique qu'il s'agit de la règle 1 dans une liste de cibles pour la règle. L'exemple de commande spécifie également un exemple d'`ARN` pour le pipeline. Le pipeline démarre lorsque des modifications sont effectuées dans le référentiel.
```
aws events put-targets --rule MyCodeCommitRepoRule --targets Id=1,Arn=arn:aws:codepipeline:us-west-2:80398EXAMPLE:TestPipeline
```
1. (Facultatif) Pour configurer un transformateur d'entrée avec des remplacements de source pour un ID d'image spécifique, utilisez le code JSON suivant dans votre commande CLI. L'exemple suivant configure une dérogation dans laquelle :
+ `Source`Dans cet exemple`actionName`, il s'agit de la valeur dynamique, définie lors de la création du pipeline, qui n'est pas dérivée de l'événement source.
+ `COMMIT_ID`Dans cet exemple`revisionType`, il s'agit de la valeur dynamique, définie lors de la création du pipeline, qui n'est pas dérivée de l'événement source.
+ Dans cet exemple`revisionValue`, le, < {{revisionValue}} > est dérivé de la variable d'événement source.
```
{
"Rule": "my-rule",
"Targets": [
{
"Id": "MyTargetId",
"Arn": "{{pipeline-ARN}}",
"InputTransformer": {
"sourceRevisions": {
"actionName": "Source",
"revisionType": "COMMIT_ID",
"revisionValue": "<{{revisionValue}}>"
},
"variables": [
{
"name": "{{Branch_Name}}",
"value": "value"
}
]
}
}
]
}
```
### Migrer les pipelines de sondage (CodeCommit source) (CloudFormation modèle)
Pour créer un pipeline piloté par des événements avec AWS CodeCommit, vous devez modifier le `PollForSourceChanges` paramètre de votre pipeline, puis ajouter les ressources suivantes à votre modèle :
+ Une EventBridge règle
+ Un rôle IAM pour votre règle EventBridge
Si vous l'utilisez CloudFormation pour créer et gérer vos pipelines, votre modèle inclut du contenu tel que celui-ci.
**Note**
La propriété `Configuration` de l'étape source appelée `PollForSourceChanges`. Si cette propriété n'est pas incluse dans votre modèle, `PollForSourceChanges` est défini sur `true` par défaut.
------
#### [ 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
}]
},
```
------
**Pour mettre à jour votre CloudFormation modèle de pipeline et créer une EventBridge règle**
1. Dans le modèle ci-dessous`Resources`, utilisez la `AWS::IAM::Role` CloudFormation ressource pour configurer le rôle IAM qui permet à votre événement de démarrer votre pipeline. Cette entrée crée un rôle qui utilise deux stratégies :
+ La première stratégie autorise le rôle à être endossé.
+ La deuxième stratégie fournit des autorisations pour démarrer le pipeline.
**Pourquoi est-ce que j'effectue cette modification ?** L'ajout de la `AWS::IAM::Role` ressource permet CloudFormation de créer des autorisations pour EventBridge. Cette ressource est ajoutée à votre CloudFormation pile.
------
#### [ 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. Dans le modèle, sous`Resources`, utilisez la `AWS::Events::Rule` CloudFormation ressource pour ajouter une EventBridge règle. Ce modèle d'événement crée un événement qui surveille les modifications push apportées à votre référentiel. Lorsqu'un changement d'état du référentiel est EventBridge détecté, la règle est invoquée `StartPipelineExecution` sur votre pipeline cible.
**Pourquoi est-ce que je fais ce changement ?** L'ajout de la `AWS::Events::Rule` ressource CloudFormation permet de créer l'événement. Cette ressource est ajoutée à votre CloudFormation pile.
------
#### [ 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. (Facultatif) Pour configurer un transformateur d'entrée avec des remplacements de source pour un ID d'image spécifique, utilisez l'extrait de code YAML suivant. L'exemple suivant configure une dérogation dans laquelle :
+ `Source`Dans cet exemple`actionName`, il s'agit de la valeur dynamique, définie lors de la création du pipeline, qui n'est pas dérivée de l'événement source.
+ `COMMIT_ID`Dans cet exemple`revisionType`, il s'agit de la valeur dynamique, définie lors de la création du pipeline, qui n'est pas dérivée de l'événement source.
+ Dans cet exemple`revisionValue`, le, < {{revisionValue}} > est dérivé de la variable d'événement source.
+ Les variables de sortie pour `BranchName` et `Value` sont spécifiées.
```
Rule: my-rule
Targets:
- Id: MyTargetId
Arn: pipeline-ARN
InputTransformer:
sourceRevisions:
actionName: Source
revisionType: COMMIT_ID
revisionValue: <{{revisionValue}}>
variables:
- name: {{BranchName}}
value: value
```
1. Enregistrez le modèle mis à jour sur votre ordinateur local, puis ouvrez la CloudFormation console.
1. Choisissez votre pile, puis **Créer un jeu de modifications pour la pile actuelle**.
1. Chargez le modèle mis à jour, puis affichez les modifications répertoriées dans CloudFormation. Il s'agit des modifications apportées à la pile. Vos nouvelles ressources doivent figurer dans la liste.
1. Sélectionnez **Execute (Exécuter)**.
**Pour modifier le PollForSourceChanges paramètre de votre pipeline**
**Important**
Dans de nombreux cas, le paramètre `PollForSourceChanges` prend la valeur Vrai par défaut lorsque vous créez un pipeline. Lorsque vous ajoutez la détection des modifications basée sur les événements, vous devez ajouter le paramètre à votre sortie et le configurer sur Faux pour désactiver l'interrogation. Sinon, votre pipeline démarre deux fois pour une seule modification de source. Pour en savoir plus, consultez [Réglages valides pour le `PollForSourceChanges` paramètre](PollForSourceChanges-defaults.md).
+ Dans le modèle, remplacez la valeur du paramètre `PollForSourceChanges` par `false`. Si vous n'avez pas inclus `PollForSourceChanges` dans votre définition de pipeline, ajoutez ce paramètre et définissez-le sur `false`.
**Pourquoi est-ce que j'effectue cette modification ?** Le remplacement de la valeur de ce paramètre par `false` désactive les vérifications périodiques, ce qui vous permet d'utiliser la détection des modifications basée sur les événements uniquement.
------
#### [ 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**
Lorsque vous créez ces ressources avec CloudFormation, votre pipeline est déclenché lorsque des fichiers de votre référentiel sont créés ou mis à jour. Voici un extrait du modèle final :
```
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
}
]
},
...
```
## Migrer les pipelines de sondage avec une source S3 activée pour les événements
Pour un pipeline avec une source Amazon S3, modifiez-le afin que la détection des modifications soit automatisée via EventBridge et avec un compartiment source activé pour les notifications d'événements. Il s'agit de la méthode recommandée si vous utilisez la CLI ou CloudFormation pour migrer votre pipeline.
**Note**
Cela inclut l'utilisation d'un bucket activé pour les notifications d'événements, dans lequel vous n'avez pas besoin de créer un journal CloudTrail distinct. Si vous utilisez la console, une règle d'événement et CloudTrail un suivi sont configurés pour vous. Pour ces étapes, voir[Migrer les pipelines de sondage avec une source et CloudTrail un suivi S3](#update-change-detection-S3).
+ **CLI :** [Migrer les pipelines de sondage avec une source et un suivi CloudTrail S3 (CLI)](#update-change-detection-cli-S3)
+ **CloudFormation: **[Migrer les pipelines de sondage avec une source et un CloudTrail suivi S3 (CloudFormation modèle)](#update-change-detection-cfn-s3)
### Migrer les pipelines de sondage avec une source S3 activée pour les événements (CLI)
Suivez ces étapes pour modifier un pipeline qui utilise des sondages (contrôles périodiques) afin d'utiliser un événement à la EventBridge place. Si vous voulez créer un pipeline, consultez [Création d'un pipeline, d'étapes et d'actions](pipelines-create.md).
Pour créer un pipeline piloté par des événements avec Amazon S3, vous modifiez le `PollForSourceChanges` paramètre de votre pipeline, puis vous créez les ressources suivantes :
+ EventBridge règle de l'événement
+ Rôle IAM pour permettre à l' EventBridge événement de démarrer votre pipeline
**Pour créer une EventBridge règle avec Amazon S3 comme source d'événement et CodePipeline comme cible et appliquer la politique d'autorisations**
1. Accordez EventBridge des autorisations permettant CodePipeline d'invoquer la règle. Pour plus d'informations, consultez [Utiliser des politiques basées sur les ressources pour Amazon](https://docs.aws.amazon.com/eventbridge/latest/userguide/eb-use-resource-based.html). EventBridge
1. Utilisez l'exemple suivant pour créer la stratégie d'approbation qui permet à EventBridge d'assumer le rôle de service. Nommez-la `trustpolicyforEB.json`.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": "events.amazonaws.com"
},
"Action": "sts:AssumeRole"
}
]
}
```
------
1. Utilisez la commande suivante pour créer le rôle `Role-for-MyRule` et attachez la stratégie d'approbation.
**Pourquoi est-ce que j'effectue cette modification ?** L'ajout de cette stratégie d'approbation au rôle crée des autorisations pour EventBridge.
```
aws iam create-role --role-name Role-for-MyRule --assume-role-policy-document file://trustpolicyforEB.json
```
1. Créez le JSON de stratégie d'autorisations, comme décrit ici, pour le pipeline nommé `MyFirstPipeline`. Nommez la stratégie d'autorisations `permissionspolicyforEB.json`.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"codepipeline:StartPipelineExecution"
],
"Resource": [
"arn:aws:codepipeline:us-west-2:{{111122223333}}:MyFirstPipeline"
]
}
]
}
```
------
1. Utilisez la commande suivante pour attacher la nouvelle stratégie d'autorisations `CodePipeline-Permissions-Policy-for-EB` au rôle `Role-for-MyRule` que vous avez créé.
```
aws iam put-role-policy --role-name Role-for-MyRule --policy-name CodePipeline-Permissions-Policy-For-EB --policy-document file://permissionspolicyforEB.json
```
1. Appelez la commande **put-rule** et incluez les paramètres `--name`, `--event-pattern` et `--role-arn`.
L'exemple de commande suivant crée une règle nommée `EnabledS3SourceRule`.
```
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. Pour ajouter CodePipeline en tant que cible, appelez la **put-targets** commande et incluez les `--targets` paramètres `--rule` et.
La commande suivante spécifie que pour la règle nommée `EnabledS3SourceRule`, l'`Id` cible est composé du numéro un, ce qui indique qu'il s'agit de la règle 1 dans une liste de cibles pour la règle. La commande spécifie également un exemple d'`ARN` pour le pipeline. Le pipeline démarre lorsque des modifications sont effectuées dans le référentiel.
```
aws events put-targets --rule EnabledS3SourceRule --targets Id=codepipeline-AppPipeline,Arn=arn:aws:codepipeline:us-west-2:80398EXAMPLE:TestPipeline
```
**Pour modifier le PollForSourceChanges paramètre de votre pipeline**
**Important**
Lorsque vous créez un pipeline avec cette méthode, le paramètre `PollForSourceChanges` prend la valeur Vrai par défaut s'il n'est pas explicitement défini sur Faux. Lorsque vous ajoutez la détection des modifications basée sur les événements, vous devez ajouter le paramètre à votre sortie et le configurer sur Faux pour désactiver l'interrogation. Sinon, votre pipeline démarre deux fois pour une seule modification de source. Pour en savoir plus, consultez [Réglages valides pour le `PollForSourceChanges` paramètre](PollForSourceChanges-defaults.md).
1. Exécutez la commande **get-pipeline** pour copier la structure de pipeline dans un fichier JSON. Par exemple, pour un pipeline nommé `MyFirstPipeline`, exécutez la commande suivante :
```
aws codepipeline get-pipeline --name {{MyFirstPipeline}} >{{pipeline.json}}
```
Cette commande ne renvoie rien, mais le fichier que vous avez créé doit apparaître dans le répertoire où vous avez exécuté la commande.
1. Ouvrez le fichier JSON dans un éditeur de texte brut et modifiez l'étape source en remplaçant la valeur du paramètre `PollForSourceChanges` pour un compartiment nommé `amzn-s3-demo-source-bucket` par `false`, comme illustré dans cet exemple.
**Pourquoi est-ce que j'effectue cette modification ?** La définition de ce paramètre sur `false` désactive les vérifications périodiques, ce qui vous permet d'utiliser la détection des modifications basée sur les événements uniquement.
```
"configuration": {
"S3Bucket": "amzn-s3-demo-source-bucket",
{{"PollForSourceChanges": "false",}}
"S3ObjectKey": "index.zip"
},
```
1. Si vous utilisez la structure de pipeline extraite à l'aide de la commande **get-pipeline**, vous devez supprimer les lignes `metadata` du fichier JSON. Sinon, la commande **update-pipeline** ne peut pas l'utiliser. Supprimez les lignes `"metadata": { }` et les champs `"updated"`, `"created"` et `"pipelineARN"`.
Par exemple, supprimez les lignes suivantes de la structure :
```
"metadata": {
"pipelineArn": "arn:aws:codepipeline:{{region}}:{{account-ID}}:{{pipeline-name}}",
"created": "{{date}}",
"updated": "{{date}}"
},
```
Enregistrez le fichier.
1. Pour appliquer les modifications, exécutez la commande **update-pipeline** en spécifiant le fichier JSON du pipeline :
**Important**
N'oubliez pas d'inclure `file://` devant le nom du fichier. Il est nécessaire dans cette commande.
```
aws codepipeline update-pipeline --cli-input-json file://{{pipeline.json}}
```
Cette commande affiche toute la structure du pipeline mise à jour.
**Note**
La commande **update-pipeline** interrompt le pipeline. Si une révision est exécutée dans le pipeline lorsque vous exécutez la commande **update-pipeline** celle-ci est interrompue. Vous devez lancer manuellement le pipeline pour exécuter cette révision dans le pipeline mis à jour. Utilisez la commande **start-pipeline-execution** pour démarrer manuellement votre pipeline.
### Migrer les pipelines de sondage avec une source S3 activée pour les événements (CloudFormation modèle)
Cette procédure concerne un pipeline dans lequel les événements sont activés dans le compartiment source.
Suivez ces étapes pour modifier votre pipeline avec une source Amazon S3, qu'il s'agisse d'un sondage ou d'une détection des modifications basée sur des événements.
Pour créer un pipeline piloté par des événements avec Amazon S3, vous modifiez le `PollForSourceChanges` paramètre de votre pipeline, puis vous ajoutez les ressources suivantes à votre modèle :
+ EventBridge règle et rôle IAM pour permettre à cet événement de démarrer votre pipeline.
Si vous l'utilisez CloudFormation pour créer et gérer vos pipelines, votre modèle inclut du contenu tel que celui-ci.
**Note**
La propriété `Configuration` de l'étape source appelée `PollForSourceChanges`. Si votre modèle ne comprend pas cette propriété, `PollForSourceChanges` est défini sur `true` par défaut.
------
#### [ 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
}
]
},
...
```
------
**Pour créer une EventBridge règle avec Amazon S3 comme source d'événement et CodePipeline comme cible et appliquer la politique d'autorisations**
1. Dans le modèle ci-dessous`Resources`, utilisez la `AWS::IAM::Role` CloudFormation ressource pour configurer le rôle IAM qui permet à votre événement de démarrer votre pipeline. Cette entrée crée un rôle qui utilise deux stratégies :
+ La première stratégie autorise le rôle à être endossé.
+ La deuxième stratégie fournit des autorisations pour démarrer le pipeline.
**Pourquoi est-ce que j'effectue cette modification ?** L'ajout `AWS::IAM::Role` de ressources CloudFormation permet de créer des autorisations pour EventBridge. Cette ressource est ajoutée à votre CloudFormation pile.
------
#### [ 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. Utilisez la `AWS::Events::Rule` CloudFormation ressource pour ajouter une EventBridge règle. Ce modèle d'événement crée un événement qui surveille la création ou la suppression d'objets dans votre compartiment source Amazon S3. En outre, incluez une cible de votre pipeline. Lorsqu'un objet est créé, cette règle est invoquée `StartPipelineExecution` sur votre pipeline cible.
**Pourquoi est-ce que j'effectue cette modification ?** L'ajout de la `AWS::Events::Rule` ressource CloudFormation permet de créer l'événement. Cette ressource est ajoutée à votre CloudFormation pile.
------
#### [ 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. Enregistrez le modèle mis à jour sur votre ordinateur local, puis ouvrez la console CloudFormation .
1. Choisissez votre pile, puis **Créer un jeu de modifications pour la pile actuelle**.
1. Chargez votre modèle mis à jour, puis affichez les modifications répertoriées dans CloudFormation. Il s'agit des modifications qui seront apportées à la pile. Vos nouvelles ressources doivent figurer dans la liste.
1. Sélectionnez **Execute (Exécuter)**.
**Pour modifier le PollForSourceChanges paramètre de votre pipeline**
**Important**
Lorsque vous créez un pipeline avec cette méthode, le paramètre `PollForSourceChanges` prend la valeur Vrai par défaut s'il n'est pas explicitement défini sur Faux. Lorsque vous ajoutez la détection des modifications basée sur les événements, vous devez ajouter le paramètre à votre sortie et le configurer sur Faux pour désactiver l'interrogation. Sinon, votre pipeline démarre deux fois pour une seule modification de source. Pour en savoir plus, consultez [Réglages valides pour le `PollForSourceChanges` paramètre](PollForSourceChanges-defaults.md).
+ Dans le modèle, remplacez la valeur du paramètre `PollForSourceChanges` par `false`. Si vous n'avez pas inclus `PollForSourceChanges` dans votre définition de pipeline, ajoutez ce paramètre et définissez-le sur `false`.
**Pourquoi est-ce que j'effectue cette modification ?** Le remplacement de la valeur du paramètre `PollForSourceChanges` par `false` désactive les vérifications périodiques, ce qui vous permet d'utiliser la détection des modifications basée sur les événements uniquement.
------
#### [ 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**
Lorsque vous créez CloudFormation ces ressources, votre pipeline est déclenché lorsque les fichiers de votre référentiel sont créés ou mis à jour.
Ne vous arrêtez pas là. Bien que votre pipeline soit créé, vous devez créer un deuxième CloudFormation modèle pour votre pipeline Amazon S3. Si vous ne créez pas le second modèle, votre pipeline ne dispose d'aucune fonctionnalité de détection des modifications.
```
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"
}
]
}
```
## Migrer les pipelines de sondage avec une source et CloudTrail un suivi S3
Pour un pipeline avec une source Amazon S3, modifiez le pipeline afin que la détection des modifications soit automatisée EventBridge. Choisissez l'une des méthodes suivantes pour implémenter la migration :
+ **Console :** [Migrer les pipelines de sondage (CodeCommit ou la source Amazon S3) (console)](#update-change-detection-console-codecommit-S3)
+ **CLI :** [Migrer les pipelines de sondage avec une source et un suivi CloudTrail S3 (CLI)](#update-change-detection-cli-S3)
+ **CloudFormation: **[Migrer les pipelines de sondage avec une source et un CloudTrail suivi S3 (CloudFormation modèle)](#update-change-detection-cfn-s3)
### Migrer les pipelines de sondage avec une source et un suivi CloudTrail S3 (CLI)
Suivez ces étapes pour modifier un pipeline qui utilise des sondages (contrôles périodiques) afin d'utiliser un événement à la EventBridge place. Si vous voulez créer un pipeline, consultez [Création d'un pipeline, d'étapes et d'actions](pipelines-create.md).
Pour créer un pipeline piloté par des événements avec Amazon S3, vous modifiez le `PollForSourceChanges` paramètre de votre pipeline, puis vous créez les ressources suivantes :
+ AWS CloudTrail politique de suivi, de compartiment et de compartiment qu'Amazon S3 peut utiliser pour consigner les événements.
+ EventBridge événement
+ Rôle IAM pour permettre à l' EventBridge événement de démarrer votre pipeline
**Pour créer un AWS CloudTrail parcours et activer la journalisation**
Pour utiliser le AWS CLI pour créer un parcours, appelez la **create-trail** commande en spécifiant :
+ Le nom du journal de suivi.
+ Le compartiment auquel vous avez déjà appliqué la stratégie de compartiment pour AWS CloudTrail.
Pour plus d'informations, consultez la section [Création d'un parcours à l'aide de l'interface de ligne de AWS commande](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/cloudtrail-create-and-update-a-trail-by-using-the-aws-cli.html).
1. Appelez la commande **create-trail** et incluez les paramètres `--name` et `--s3-bucket-name`.
**Pourquoi est-ce que j'effectue cette modification ?** Cela crée le journal de suivi CloudTrail requis pour votre compartiment source S3.
La commande suivante utilise `--name` et `--s3-bucket-name` pour créer un journal de suivi nommé `my-trail` et un compartiment nommé `amzn-s3-demo-source-bucket`.
```
aws cloudtrail create-trail --name my-trail --s3-bucket-name amzn-s3-demo-source-bucket
```
1. Appelez la commande **start-logging** et incluez le paramètre `--name`.
**Pourquoi est-ce que je fais ce changement ?** Cette commande lance la CloudTrail journalisation de votre compartiment source et envoie les événements à EventBridge.
Exemple :
La commande suivante utilise `--name` pour démarrer la journalisation dans un journal de suivi nommé `my-trail`.
```
aws cloudtrail start-logging --name my-trail
```
1. Appelez la commande **put-event-selectors** et incluez les paramètres `--trail-name` et `--event-selectors`. Utilisez les sélecteurs d'événements pour spécifier que vous souhaitez que votre journal enregistre les événements de données pour votre compartiment source et envoie les événements à la EventBridge règle.
**Pourquoi est-ce que je fais ce changement ?** Cette commande filtre les événements.
Exemple :
Dans l'exemple suivant, la commande utilise `--trail-name` et `--event-selectors` pour spécifier des événements de données pour un compartiment source et un préfixe nommés `amzn-s3-demo-source-bucket/myFolder`.
```
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"] }] }]'
```
**Pour créer une EventBridge règle avec Amazon S3 comme source d'événement et CodePipeline comme cible et appliquer la politique d'autorisations**
1. Accordez EventBridge des autorisations permettant CodePipeline d'invoquer la règle. Pour plus d'informations, consultez [Utiliser des politiques basées sur les ressources pour Amazon](https://docs.aws.amazon.com/eventbridge/latest/userguide/eb-use-resource-based.html). EventBridge
1. Utilisez l'exemple suivant pour créer la politique de confiance permettant EventBridge d'assumer le rôle de service. Nommez-la `trustpolicyforEB.json`.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": "events.amazonaws.com"
},
"Action": "sts:AssumeRole"
}
]
}
```
------
1. Utilisez la commande suivante pour créer le rôle `Role-for-MyRule` et attachez la stratégie d'approbation.
**Pourquoi est-ce que j'effectue cette modification ?** L'ajout de cette politique de confiance au rôle crée des autorisations pour EventBridge.
```
aws iam create-role --role-name Role-for-MyRule --assume-role-policy-document file://trustpolicyforEB.json
```
1. Créez le JSON de stratégie d'autorisations, comme décrit ici, pour le pipeline nommé `MyFirstPipeline`. Nommez la stratégie d'autorisations `permissionspolicyforEB.json`.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"codepipeline:StartPipelineExecution"
],
"Resource": [
"arn:aws:codepipeline:us-west-2:{{111122223333}}:MyFirstPipeline"
]
}
]
}
```
------
1. Utilisez la commande suivante pour attacher la nouvelle stratégie d'autorisations `CodePipeline-Permissions-Policy-for-EB` au rôle `Role-for-MyRule` que vous avez créé.
```
aws iam put-role-policy --role-name Role-for-MyRule --policy-name CodePipeline-Permissions-Policy-For-EB --policy-document file://permissionspolicyforEB.json
```
1. Appelez la commande **put-rule** et incluez les paramètres `--name`, `--event-pattern` et `--role-arn`.
L'exemple de commande suivant crée une règle nommée `MyS3SourceRule`.
```
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. Pour ajouter CodePipeline en tant que cible, appelez la **put-targets** commande et incluez les `--targets` paramètres `--rule` et.
La commande suivante spécifie que pour la règle nommée `MyS3SourceRule`, l'`Id` cible est composé du numéro un, ce qui indique qu'il s'agit de la règle 1 dans une liste de cibles pour la règle. La commande spécifie également un exemple d'`ARN` pour le pipeline. Le pipeline démarre lorsque des modifications sont effectuées dans le référentiel.
```
aws events put-targets --rule MyS3SourceRule --targets Id=1,Arn=arn:aws:codepipeline:us-west-2:80398EXAMPLE:TestPipeline
```
1. (Facultatif) Pour configurer un transformateur d'entrée avec des remplacements de source pour un ID d'image spécifique, utilisez le code JSON suivant dans votre commande CLI. L'exemple suivant configure une dérogation dans laquelle :
+ `Source`Dans cet exemple`actionName`, il s'agit de la valeur dynamique, définie lors de la création du pipeline, qui n'est pas dérivée de l'événement source.
+ `S3_OBJECT_VERSION_ID`Dans cet exemple`revisionType`, il s'agit de la valeur dynamique, définie lors de la création du pipeline, qui n'est pas dérivée de l'événement source.
+ Dans cet exemple`revisionValue`, le, < {{revisionValue}} > est dérivé de la variable d'événement source.
```
{
"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": "<{{revisionValue}}>"
}
}
}
}
]
}
```
**Pour modifier le PollForSourceChanges paramètre de votre pipeline**
**Important**
Lorsque vous créez un pipeline avec cette méthode, le paramètre `PollForSourceChanges` prend la valeur Vrai par défaut s'il n'est pas explicitement défini sur Faux. Lorsque vous ajoutez la détection des modifications basée sur les événements, vous devez ajouter le paramètre à votre sortie et le configurer sur Faux pour désactiver l'interrogation. Sinon, votre pipeline démarre deux fois pour une seule modification de source. Pour en savoir plus, consultez [Réglages valides pour le `PollForSourceChanges` paramètre](PollForSourceChanges-defaults.md).
1. Exécutez la commande **get-pipeline** pour copier la structure de pipeline dans un fichier JSON. Par exemple, pour un pipeline nommé `MyFirstPipeline`, exécutez la commande suivante :
```
aws codepipeline get-pipeline --name {{MyFirstPipeline}} >{{pipeline.json}}
```
Cette commande ne renvoie rien, mais le fichier que vous avez créé doit apparaître dans le répertoire où vous avez exécuté la commande.
1. Ouvrez le fichier JSON dans un éditeur de texte brut et modifiez l'étape source en remplaçant la valeur du paramètre `PollForSourceChanges` pour un compartiment nommé `amzn-s3-demo-source-bucket` par `false`, comme illustré dans cet exemple.
**Pourquoi est-ce que j'effectue cette modification ?** La définition de ce paramètre sur `false` désactive les vérifications périodiques, ce qui vous permet d'utiliser la détection des modifications basée sur les événements uniquement.
```
"configuration": {
"S3Bucket": "amzn-s3-demo-source-bucket",
{{"PollForSourceChanges": "false",}}
"S3ObjectKey": "index.zip"
},
```
1. Si vous utilisez la structure de pipeline extraite à l'aide de la commande **get-pipeline**, vous devez supprimer les lignes `metadata` du fichier JSON. Sinon, la commande **update-pipeline** ne peut pas l'utiliser. Supprimez les lignes `"metadata": { }` et les champs `"updated"`, `"created"` et `"pipelineARN"`.
Par exemple, supprimez les lignes suivantes de la structure :
```
"metadata": {
"pipelineArn": "arn:aws:codepipeline:{{region}}:{{account-ID}}:{{pipeline-name}}",
"created": "{{date}}",
"updated": "{{date}}"
},
```
Enregistrez le fichier.
1. Pour appliquer les modifications, exécutez la commande **update-pipeline** en spécifiant le fichier JSON du pipeline :
**Important**
N'oubliez pas d'inclure `file://` devant le nom du fichier. Il est nécessaire dans cette commande.
```
aws codepipeline update-pipeline --cli-input-json file://{{pipeline.json}}
```
Cette commande affiche toute la structure du pipeline mise à jour.
**Note**
La commande **update-pipeline** interrompt le pipeline. Si une révision est exécutée dans le pipeline lorsque vous exécutez la commande **update-pipeline** celle-ci est interrompue. Vous devez lancer manuellement le pipeline pour exécuter cette révision dans le pipeline mis à jour. Utilisez la commande **start-pipeline-execution** pour démarrer manuellement votre pipeline.
### Migrer les pipelines de sondage avec une source et un CloudTrail suivi S3 (CloudFormation modèle)
Suivez ces étapes pour modifier votre pipeline avec une source Amazon S3, qu'il s'agisse d'un sondage ou d'une détection des modifications basée sur des événements.
Pour créer un pipeline piloté par des événements avec Amazon S3, vous modifiez le `PollForSourceChanges` paramètre de votre pipeline, puis vous ajoutez les ressources suivantes à votre modèle :
+ EventBridge exige que tous les événements Amazon S3 soient enregistrés. Vous devez créer une politique AWS CloudTrail de suivi, de compartiment et de compartiment qu'Amazon S3 peut utiliser pour consigner les événements qui se produisent. Pour plus d'informations, voir [Enregistrement des événements liés aux données pour les sentiers](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/logging-data-events-with-cloudtrail.html) et [Événements de gestion de la journalisation pour les sentiers](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/logging-management-events-with-cloudtrail.html).
+ EventBridge règle et rôle IAM pour permettre à cet événement de démarrer notre pipeline.
Si vous l'utilisez CloudFormation pour créer et gérer vos pipelines, votre modèle inclut du contenu tel que celui-ci.
**Note**
La propriété `Configuration` de l'étape source appelée `PollForSourceChanges`. Si votre modèle ne comprend pas cette propriété, `PollForSourceChanges` est défini sur `true` par défaut.
------
#### [ 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
}
]
},
...
```
------
**Pour créer une EventBridge règle avec Amazon S3 comme source d'événement et CodePipeline comme cible et appliquer la politique d'autorisations**
1. Dans le modèle ci-dessous`Resources`, utilisez la `AWS::IAM::Role` CloudFormation ressource pour configurer le rôle IAM qui permet à votre événement de démarrer votre pipeline. Cette entrée crée un rôle qui utilise deux stratégies :
+ La première stratégie autorise le rôle à être endossé.
+ La deuxième stratégie fournit des autorisations pour démarrer le pipeline.
**Pourquoi est-ce que j'effectue cette modification ?** L'ajout `AWS::IAM::Role` de ressources CloudFormation permet de créer des autorisations pour EventBridge. Cette ressource est ajoutée à votre CloudFormation pile.
------
#### [ 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. Utilisez la `AWS::Events::Rule` CloudFormation ressource pour ajouter une EventBridge règle. Ce modèle d'événement crée un événement qui surveille `CopyObject` `PutObject` et `CompleteMultipartUpload` sur votre compartiment source Amazon S3. En outre, incluez une cible de votre pipeline. Lorsque `CopyObject`, `PutObject` ou `CompleteMultipartUpload` se produit, cette règle appelle `StartPipelineExecution` sur votre pipeline cible.
**Pourquoi est-ce que j'effectue cette modification ?** L'ajout de la `AWS::Events::Rule` ressource CloudFormation permet de créer l'événement. Cette ressource est ajoutée à votre CloudFormation pile.
------
#### [ 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. Ajoutez cet extrait à votre premier modèle pour autoriser les fonctionnalités entre piles :
------
#### [ 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. (Facultatif) Pour configurer un transformateur d'entrée avec des remplacements de source pour un ID d'image spécifique, utilisez l'extrait de code YAML suivant. L'exemple suivant configure une dérogation dans laquelle :
+ `Source`Dans cet exemple`actionName`, il s'agit de la valeur dynamique, définie lors de la création du pipeline, qui n'est pas dérivée de l'événement source.
+ `S3_OBJECT_VERSION_ID`Dans cet exemple`revisionType`, il s'agit de la valeur dynamique, définie lors de la création du pipeline, qui n'est pas dérivée de l'événement source.
+ Dans cet exemple`revisionValue`, le, < {{revisionValue}} > est dérivé de la variable d'événement source.
```
---
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: '<{{revisionValue}}>'
```
1. Enregistrez le modèle mis à jour sur votre ordinateur local et ouvrez la CloudFormation console.
1. Choisissez votre pile, puis **Créer un jeu de modifications pour la pile actuelle**.
1. Chargez votre modèle mis à jour, puis affichez les modifications répertoriées dans CloudFormation. Il s'agit des modifications qui seront apportées à la pile. Vos nouvelles ressources doivent figurer dans la liste.
1. Sélectionnez **Execute (Exécuter)**.
**Pour modifier le PollForSourceChanges paramètre de votre pipeline**
**Important**
Lorsque vous créez un pipeline avec cette méthode, le paramètre `PollForSourceChanges` prend la valeur Vrai par défaut s'il n'est pas explicitement défini sur Faux. Lorsque vous ajoutez la détection des modifications basée sur les événements, vous devez ajouter le paramètre à votre sortie et le configurer sur Faux pour désactiver l'interrogation. Sinon, votre pipeline démarre deux fois pour une seule modification de source. Pour en savoir plus, consultez [Réglages valides pour le `PollForSourceChanges` paramètre](PollForSourceChanges-defaults.md).
+ Dans le modèle, remplacez la valeur du paramètre `PollForSourceChanges` par `false`. Si vous n'avez pas inclus `PollForSourceChanges` dans votre définition de pipeline, ajoutez ce paramètre et définissez-le sur `false`.
**Pourquoi est-ce que j'effectue cette modification ?** Le remplacement de la valeur du paramètre `PollForSourceChanges` par `false` désactive les vérifications périodiques, ce qui vous permet d'utiliser la détection des modifications basée sur les événements uniquement.
------
#### [ 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
}
```
------
**Pour créer un deuxième modèle pour les CloudTrail ressources de votre pipeline Amazon S3**
+ Dans un modèle distinct, sous`Resources`, utilisez les `AWS::CloudTrail::Trail` CloudFormation ressources `AWS::S3::Bucket``AWS::S3::BucketPolicy`, et pour fournir une définition de compartiment et un suivi simples pour CloudTrail.
**Pourquoi est-ce que je fais ce changement ?** Compte tenu de la limite actuelle de cinq sentiers par compte, le CloudTrail sentier doit être créé et géré séparément. (Voir [Limites dans AWS CloudTrail](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/WhatIsCloudTrail-Limits.html).) Cependant, vous pouvez inclure de nombreux compartiments Amazon S3 sur un seul parcours, de sorte que vous pouvez créer le suivi une seule fois, puis ajouter des compartiments Amazon S3 pour d'autres pipelines si nécessaire. Collez ce qui suit dans votre deuxième exemple de fichier de modèle.
------
#### [ 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**
Lorsque vous créez CloudFormation ces ressources, votre pipeline est déclenché lorsque les fichiers de votre référentiel sont créés ou mis à jour.
Ne vous arrêtez pas là. Bien que votre pipeline soit créé, vous devez créer un deuxième CloudFormation modèle pour votre pipeline Amazon S3. Si vous ne créez pas le second modèle, votre pipeline ne dispose d'aucune fonctionnalité de détection des modifications.
```
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"
}
}
}
}
...
```
## Migrer les pipelines de sondage pour une action source GitHub (via une OAuth application) vers des connexions
Vous pouvez migrer une action source GitHub (via une OAuth application) afin d'utiliser des connexions pour votre référentiel externe. Il s'agit de la méthode de détection des modifications recommandée pour les pipelines dotés d'une action source GitHub (via une OAuth application).
Pour un pipeline avec une action source GitHub (via une OAuth application), nous vous recommandons de modifier le pipeline pour utiliser une action GitHub (via une GitHub application) afin que la détection des modifications soit automatisée AWS CodeConnections. Pour plus d'informations sur l'utilisation des connexions, consultez[GitHub connexions](connections-github.md).
### Création d'une connexion à GitHub (console)
Vous pouvez utiliser la console pour créer une connexion à GitHub.
#### Étape 1 : remplacez votre action GitHub (via OAuth l'application)
Utilisez la page d'édition du pipeline pour remplacer votre action GitHub (via OAuth l'application) par une action GitHub (via GitHub l'application).
**Pour remplacer votre action GitHub (via OAuth l'application)**
1. Connectez-vous à la CodePipeline console.
1. Choisissez votre pipeline, puis cliquez sur **Modifier**. Choisissez l'**étape Modifier** sur votre scène source. Un message s'affiche pour vous recommander de mettre à jour votre action.
1. Dans **Action provider**, choisissez **GitHub (via GitHub App)**.
1. Effectuez l’une des actions suivantes :
+ Sous **Connexion**, si vous n'avez pas encore créé de connexion avec votre fournisseur, choisissez **Se connecter à GitHub**. Passez à l'étape 2 : créer une connexion à GitHub.
+ Sous **Connexion**, si vous avez déjà créé une connexion avec votre fournisseur, choisissez-la. Passez à l'étape 3 : Enregistrer l'action source pour votre connexion.
#### Étape 2 : créer une connexion avec GitHub
Une fois que vous avez choisi de créer la connexion, la GitHub page **Connect to** s'affiche.
**Pour créer une connexion avec GitHub**
1. Dans **les paramètres de GitHub connexion**, le nom de votre connexion apparaît dans **Nom de la connexion**.
Sous **GitHub Applications**, choisissez une installation d'application ou choisissez **Installer une nouvelle application** pour en créer une.
**Note**
Installez une application pour toutes vos connexions à un fournisseur particulier. Si vous avez déjà installé l' GitHub application, choisissez-la et ignorez cette étape.
1. Si la page d'autorisation GitHub s'affiche, connectez-vous avec vos informations d'identification, puis choisissez de continuer.
1. Sur la page d'installation de l'application, un message indique que l' AWS CodeStar application essaie de se connecter à votre GitHub compte.
**Note**
Vous n'installez l'application qu'une seule fois pour chaque GitHub compte. Si vous avez déjà installé l'application, vous pouvez choisir **Configure (Configurer)** pour passer à une page de modification pour l'installation de votre application, ou vous pouvez utiliser le bouton Précédent pour revenir à la console.
1. Sur la AWS CodeStar page **Installer**, choisissez **Installer**.
1. Sur la GitHub page **Connect to**, l'ID de connexion de votre nouvelle installation s'affiche. Choisissez **Se connecter**.
#### Étape 3 : Enregistrez votre action GitHub source
Effectuez vos mises à jour sur la page **Modifier l'action** pour enregistrer votre nouvelle action source.
**Pour enregistrer votre action GitHub source**
1. Dans **Référentiel**, entrez le nom de votre référentiel tiers. Dans **Branche**, entrez la branche dans laquelle vous souhaitez que votre pipeline détecte les modifications de source.
**Note**
Dans **Repository**, tapez `owner-name/repository-name` comme indiqué dans cet exemple :
```
my-account/my-repository
```
1. Dans **Format d'artefact de sortie**, choisissez le format de vos artefacts.
+ Pour stocker les artefacts de sortie de l' GitHub action à l'aide de la méthode par défaut, choisissez **CodePipelinepar défaut**. L'action accède aux fichiers depuis le GitHub référentiel et stocke les artefacts dans un fichier ZIP dans le magasin d'artefacts du pipeline.
+ Pour stocker un fichier JSON contenant une référence d'URL au référentiel afin que les actions en aval puissent exécuter directement les commandes Git, choisissez **Full clone (Clone complet)**. Cette option ne peut être utilisée que par des actions CodeBuild en aval.
Si vous choisissez cette option, vous devrez mettre à jour les autorisations associées à votre rôle de service de CodeBuild projet, comme indiqué dans[Ajoutez CodeBuild GitClone des autorisations pour les connexions à Bitbucket GitHub, GitHub Enterprise Server ou .com GitLab](troubleshooting.md#codebuild-role-connections). Pour consulter un didacticiel expliquant comment utiliser l'option de **clonage complet**, voir[Tutoriel : Utiliser un clone complet avec une source de GitHub pipeline](tutorials-github-gitclone.md).
1. Dans **Artefacts de sortie**, vous pouvez conserver le nom de l'artefact de sortie pour cette action, par exemple`SourceArtifact`. Choisissez **OK** pour fermer la page **d'action Modifier**.
1. Choisissez **OK** pour fermer la page d'édition de l'étape. Choisissez **Enregistrer** pour fermer la page d'édition du pipeline.
### Création d'une connexion à GitHub (CLI)
Vous pouvez utiliser le AWS Command Line Interface (AWS CLI) pour créer une connexion à GitHub.
Pour ce faire, utilisez la commande **create-connection**.
**Important**
Une connexion créée via le AWS CLI ou AWS CloudFormation est en `PENDING` état par défaut. Après avoir créé une connexion avec la CLI CloudFormation, utilisez la console pour modifier la connexion afin de définir son état`AVAILABLE`.
**Pour créer une connexion avec GitHub**
1. Ouvrez une invite de terminal (Linux, macOS ou Unix) ou de commande (Windows). Utilisez le AWS CLI pour exécuter la **create-connection** commande, en spécifiant le `--provider-type` et `--connection-name` pour votre connexion. Dans cet exemple, le nom du fournisseur tiers est `GitHub` et le nom de connexion spécifié est `MyConnection`.
```
aws codeconnections create-connection --provider-type GitHub --connection-name MyConnection
```
En cas de succès, cette commande renvoie les informations ARN de connexion semblables à ce qui suit.
```
{
"ConnectionArn": "arn:aws:codeconnections:us-west-2:{{account_id}}:connection/aEXAMPLE-8aad-4d5d-8878-dfcab0bc441f"
}
```
1. Utilisez la console pour terminer la connexion.
## Migrer les pipelines de sondage pour une action source GitHub (via une OAuth application) vers des webhooks
Vous pouvez migrer votre pipeline pour utiliser des webhooks afin de détecter les modifications apportées à votre référentiel GitHub source. Cette migration vers les webhooks est réservée à l'action GitHub (via OAuth l'application).
+ **Console :** [Migrer les pipelines de sondage vers les webhooks GitHub (via OAuth l'application) (actions source) (console)](#update-change-detection-console-github)
+ **CLI :** [Migrer les pipelines de sondage vers les webhooks GitHub (via OAuth l'application) (actions source) (CLI)](#update-change-detection-cli-github)
+ **CloudFormation: ** [Mettre à jour les pipelines pour les événements push GitHub (via OAuth l'application) (actions source) (CloudFormation modèle)](#update-change-detection-cfn-github)
**Important**
Lorsque vous créez des CodePipeline webhooks, n'utilisez pas vos propres informations d'identification et ne réutilisez pas le même jeton secret sur plusieurs webhooks. Pour une sécurité optimale, générez un jeton secret unique pour chaque webhook que vous créez. Le jeton secret est une chaîne arbitraire que vous fournissez, qui GitHub sert à calculer et à signer les charges utiles du webhook envoyées CodePipeline, afin de protéger l'intégrité et l'authenticité des charges utiles du webhook. L'utilisation de vos propres informations d'identification ou la réutilisation du même jeton sur plusieurs webhooks peut entraîner des failles de sécurité.
### Migrer les pipelines de sondage vers les webhooks GitHub (via OAuth l'application) (actions source) (console)
Pour l'action source GitHub (via OAuth l'application), vous pouvez utiliser la CodePipeline console pour mettre à jour votre pipeline afin d'utiliser des webhooks pour détecter les modifications dans votre référentiel GitHub source.
Suivez ces étapes pour modifier un pipeline qui utilise des sondages (contrôles périodiques) pour l'utiliser à la EventBridge place. Si vous voulez créer un pipeline, consultez [Création d'un pipeline, d'étapes et d'actions](pipelines-create.md).
Lorsque vous utilisez la console, le paramètre `PollForSourceChanges` de votre pipeline est modifié pour vous. Le GitHub webhook est créé et enregistré pour vous.
**Pour modifier l'étape source du pipeline**
1. Connectez-vous à la CodePipeline console AWS Management Console et ouvrez-la à l'[adresse http://console.aws.amazon. com/codesuite/codepipeline/home](https://console.aws.amazon.com/codesuite/codepipeline/home).
Les noms de tous les pipelines associés à votre AWS compte sont affichés.
1. Dans **Name**, choisissez le nom du pipeline que vous souhaitez modifier. Une vue détaillée du pipeline s'affiche alors, laquelle indique notamment l'état de chaque action, dans chaque étape du pipeline.
1. Sur la page des détails du pipeline, choisissez **Edit**.
1. À l'étape **Modifier**, choisissez l'icône de modification sur l'action source.
1. Développez **les options de détection des modifications** et choisissez **Utiliser Amazon CloudWatch Events pour démarrer automatiquement mon pipeline en cas de modification (recommandé)**.
Un message s'affiche pour vous informer qu'un webhook est CodePipeline créé GitHub pour détecter les modifications de source : un webhook AWS CodePipeline sera créé pour vous. Vous pouvez vous désinscrire dans les options ci-dessous. Choisissez **Mettre à jour**. En plus du webhook, CodePipeline crée ce qui suit :
+ Un secret, généré aléatoirement et utilisé pour autoriser la connexion à GitHub.
+ L'URL du webhook, générée à l'aide du point de terminaison public pour la région.
CodePipeline enregistre le webhook avec GitHub. Cette action abonne l'URL à la réception des événements du référentiel.
1. Lorsque vous avez terminé de modifier votre pipeline, cliquez sur **Save pipeline changes** pour revenir à la page récapitulative.
Un message affiche le nom du webhook à créer pour votre pipeline. Choisissez **Save and continue (Enregistrer et continuer)**.
1. Pour tester votre action, publiez une modification en utilisant le AWS CLI pour valider une modification de la source spécifiée dans l'étape source du pipeline.
### Migrer les pipelines de sondage vers les webhooks GitHub (via OAuth l'application) (actions source) (CLI)
Suivez ces étapes pour modifier un pipeline qui utilise les vérifications périodiques afin d'utiliser plutôt un webhook. Si vous voulez créer un pipeline, consultez [Création d'un pipeline, d'étapes et d'actions](pipelines-create.md).
Pour créer un pipeline basé sur les événements, vous devez modifier le paramètre `PollForSourceChanges` de votre pipeline, puis créer manuellement les ressources suivantes :
+ GitHub webhook et paramètres d'autorisation
**Pour créer et enregistrer votre webhook**
**Note**
Lorsque vous utilisez la CLI ou CloudFormation pour créer un pipeline et ajouter un webhook, vous devez désactiver les vérifications périodiques. Pour désactiver les vérifications périodiques, vous devez ajouter explicitement le paramètre `PollForSourceChanges` et lui affectez la valeur Faux, comme indiqué dans la procédure finale ci-dessous. Sinon, la valeur par défaut d'une CLI ou d'un CloudFormation pipeline est true et ne s'affiche pas dans la sortie de la structure du pipeline. `PollForSourceChanges` Pour plus d'informations sur les PollForSourceChanges valeurs par défaut, consultez[Réglages valides pour le `PollForSourceChanges` paramètre](PollForSourceChanges-defaults.md).
1. Dans un éditeur de texte, créez et enregistrez un fichier JSON pour le webhook que vous souhaitez créer. Utilisez cet exemple de fichier pour un webhook nommé `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. Appelez la commande **put-webhook** et incluez les paramètres `--cli-input` et `--region`.
L'exemple de commande suivant crée un webhook avec le fichier JSON `webhook_json`.
```
aws codepipeline put-webhook --cli-input-json file://webhook_json.json --region "eu-central-1"
```
1. Dans la sortie illustrée dans cet exemple, l'URL et l'ARN sont renvoyés pour un webhook nommé `my-webhook`.
```
{
"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"
}]
}
```
Cet exemple ajoute le balisage du webhook en incluant la clé de balise `Project` et la valeur `ProjectA` sur le webhook. Pour plus d'informations sur le balisage des ressources CodePipeline, consultez[Balisage des ressources](tag-resources.md).
1. Appelez la commande **register-webhook-with-third-party** et incluez le paramètre `--webhook-name`.
L'exemple de commande suivant enregistre un webhook nommé `my-webhook`.
```
aws codepipeline register-webhook-with-third-party --webhook-name my-webhook
```
**Pour modifier le PollForSourceChanges paramètre de votre pipeline**
**Important**
Lorsque vous créez un pipeline avec cette méthode, le paramètre `PollForSourceChanges` prend la valeur Vrai par défaut s'il n'est pas explicitement défini sur Faux. Lorsque vous ajoutez la détection des modifications basée sur les événements, vous devez ajouter le paramètre à votre sortie et le configurer sur Faux pour désactiver l'interrogation. Sinon, votre pipeline démarre deux fois pour une seule modification de source. Pour en savoir plus, consultez [Réglages valides pour le `PollForSourceChanges` paramètre](PollForSourceChanges-defaults.md).
1. Exécutez la commande **get-pipeline** pour copier la structure de pipeline dans un fichier JSON. Par exemple, pour un pipeline nommé `MyFirstPipeline`, saisissez la commande suivante :
```
aws codepipeline get-pipeline --name {{MyFirstPipeline}} >{{pipeline.json}}
```
Cette commande ne renvoie rien, mais le fichier que vous avez créé doit apparaître dans le répertoire où vous avez exécuté la commande.
1. Ouvrez le fichier JSON dans un éditeur de texte brut et modifiez l'étape source en modifiant ou en ajoutant le paramètre `PollForSourceChanges`. Dans cet exemple, pour un référentiel nommé `UserGitHubRepo`, le paramètre est défini sur `false`.
**Pourquoi est-ce que je fais ce changement ?** La modification de ce paramètre désactive les contrôles périodiques afin que vous puissiez utiliser uniquement la détection des modifications basée sur les événements.
```
"configuration": {
"Owner": "{{name}}",
"Repo": "UserGitHubRepo",
{{"PollForSourceChanges": "false",}}
"Branch": "main",
"OAuthToken": "****"
},
```
1. Si vous utilisez la structure de pipeline récupérée à l'aide de la commande **get-pipeline**, vous devez modifier cette structure dans le fichier JSON en supprimant les lignes `metadata` du fichier. Sinon, la commande **update-pipeline** ne peut pas l'utiliser. Supprimez la section `"metadata"` de la structure de pipeline dans le fichier JSON, y compris les champs `{ }`, `"created"`, `"pipelineARN"` et `"updated"`.
Par exemple, supprimez les lignes suivantes de la structure :
```
"metadata": {
"pipelineArn": "arn:aws:codepipeline:{{region}}:{{account-ID}}:{{pipeline-name}}",
"created": "{{date}}",
"updated": "{{date}}"
},
```
Enregistrez le fichier.
1. Pour appliquer les modifications, exécutez la commande **update-pipeline** en spécifiant le fichier JSON du pipeline d'une manière similaire à l'exemple suivant :
**Important**
N'oubliez pas d'inclure `file://` devant le nom du fichier. Il est nécessaire dans cette commande.
```
aws codepipeline update-pipeline --cli-input-json file://{{pipeline.json}}
```
Cette commande affiche toute la structure du pipeline mise à jour.
**Note**
La commande **update-pipeline** interrompt le pipeline. Si une révision est exécutée dans le pipeline lorsque vous exécutez la commande **update-pipeline** celle-ci est interrompue. Vous devez lancer manuellement le pipeline pour exécuter cette révision dans le pipeline mis à jour. Utilisez la commande **start-pipeline-execution** pour démarrer manuellement votre pipeline.
### Mettre à jour les pipelines pour les événements push GitHub (via OAuth l'application) (actions source) (CloudFormation modèle)
Suivez ces étapes pour mettre à jour votre pipeline (avec une GitHub source) en passant des contrôles périodiques (sondages) à la détection des modifications basée sur des événements à l'aide de webhooks.
Pour créer un pipeline piloté par des événements avec AWS CodeCommit, vous modifiez le `PollForSourceChanges` paramètre de votre pipeline, puis vous ajoutez une ressource GitHub webhook à votre modèle.
Si vous avez l' CloudFormation habitude de créer et de gérer vos pipelines, le contenu de votre modèle est le suivant.
**Note**
Notez la propriété de configuration `PollForSourceChanges` de l'étape source. Si votre modèle ne comprend pas cette propriété, `PollForSourceChanges` est défini sur `true` par défaut.
------
#### [ 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
}
]
},
...
```
------
**Pour ajouter des paramètres et créer un webhook dans votre modèle**
Nous vous recommandons vivement de l'utiliser AWS Secrets Manager pour stocker vos informations d'identification. Si vous utilisez Secrets Manager, vous devez avoir déjà configuré et stocké vos paramètres secrets dans Secrets Manager. Cet exemple utilise des références dynamiques à Secrets Manager pour les GitHub informations d'identification de votre webhook. Pour de plus amples informations, veuillez consulter [Utilisation de références dynamiques pour spécifier des valeurs de modèle](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/dynamic-references.html#dynamic-references-secretsmanager).
**Important**
Lorsque vous transmettez des paramètres de secret, n'entrez pas la valeur directement dans le modèle. La valeur est rendue en texte brut ; elle est donc lisible. Pour des raisons de sécurité, n'utilisez pas de texte brut dans votre CloudFormation modèle pour stocker vos informations d'identification.
Lorsque vous utilisez la CLI ou CloudFormation pour créer un pipeline et ajouter un webhook, vous devez désactiver les vérifications périodiques.
**Note**
Pour désactiver les vérifications périodiques, vous devez ajouter explicitement le paramètre `PollForSourceChanges` et lui affectez la valeur Faux, comme indiqué dans la procédure finale ci-dessous. Sinon, la valeur par défaut d'une CLI ou d'un CloudFormation pipeline est true et ne s'affiche pas dans la sortie de la structure du pipeline. `PollForSourceChanges` Pour plus d'informations sur les PollForSourceChanges valeurs par défaut, consultez[Réglages valides pour le `PollForSourceChanges` paramètre](PollForSourceChanges-defaults.md).
1. Dans le modèle, sous `Resources`, ajoutez vos paramètres :
------
#### [ YAML ]
```
Parameters:
GitHubOwner:
Type: String
...
```
------
#### [ JSON ]
```
{
"Parameters": {
"BranchName": {
"Description": "GitHub branch name",
"Type": "String",
"Default": "main"
},
"GitHubOwner": {
"Type": "String"
},
...
```
------
1. Utilisez la `AWS::CodePipeline::Webhook` CloudFormation ressource pour ajouter un webhook.
**Note**
La valeur de `TargetAction` que vous spécifiez doit correspondre à la propriété `Name` de l'action source définie dans le pipeline.
S'`RegisterWithThirdParty`il est défini sur`true`, assurez-vous que l'utilisateur associé au `OAuthToken` peut définir les étendues requises. GitHub Le jeton et le webhook nécessitent les champs d' GitHub application suivants :
+ `repo` - utilisée pour contrôler entièrement la lecture et l'extraction des artefacts dans un pipeline à partir de référentiels publics et privés.
+ `admin:repo_hook` - utilisée pour contrôler entièrement les hooks de référentiel.
Dans le cas contraire, GitHub renvoie un 404. Pour plus d'informations sur l'erreur 404 renvoyée, consultez [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. Enregistrez le modèle mis à jour sur votre ordinateur local, puis ouvrez la CloudFormation console.
1. Choisissez votre pile, puis **Créer un jeu de modifications pour la pile actuelle**.
1. Chargez le modèle mis à jour, puis affichez les modifications répertoriées dans CloudFormation. Il s'agit des modifications apportées à la pile. Vos nouvelles ressources doivent figurer dans la liste.
1. Sélectionnez **Execute (Exécuter)**.
**Pour modifier le PollForSourceChanges paramètre de votre pipeline**
**Important**
Lorsque vous créez un pipeline avec cette méthode, le paramètre `PollForSourceChanges` prend la valeur Vrai par défaut s'il n'est pas explicitement défini sur Faux. Lorsque vous ajoutez la détection des modifications basée sur les événements, vous devez ajouter le paramètre à votre sortie et le configurer sur Faux pour désactiver l'interrogation. Sinon, votre pipeline démarre deux fois pour une seule modification de source. Pour en savoir plus, consultez [Réglages valides pour le `PollForSourceChanges` paramètre](PollForSourceChanges-defaults.md).
+ Dans le modèle, remplacez la valeur du paramètre `PollForSourceChanges` par `false`. Si vous n'avez pas inclus `PollForSourceChanges` dans votre définition de pipeline, ajoutez ce paramètre et définissez-le sur false.
**Pourquoi est-ce que je fais ce changement ?** Le remplacement de la valeur de ce paramètre par `false` désactive les vérifications périodiques, ce qui vous permet d'utiliser la détection des modifications basée sur les événements uniquement.
------
#### [ 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**
Lorsque vous créez ces ressources avec CloudFormation, le webhook défini est créé dans le GitHub référentiel spécifié. Votre pipeline est déclenché à la validation.
```
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
...
```