Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.
# Esegui la migrazione delle pipeline di sondaggi per utilizzare il rilevamento delle modifiche basato sugli eventi
AWS CodePipeline supporta la distribuzione completa e end-to-end continua, che include l'avvio della pipeline ogni volta che viene apportata una modifica al codice. Esistono due modi supportati per avviare la pipeline in caso di modifica del codice: rilevamento delle modifiche basato sugli eventi e polling. Consigliamo di utilizzare il rilevamento delle modifiche basato sugli eventi per le pipeline.
Utilizza le procedure qui incluse per migrare (aggiornare) le tue pipeline di polling al metodo di rilevamento delle modifiche basato sugli eventi per la tua pipeline.
Il metodo di rilevamento delle modifiche basato sugli eventi consigliato per le pipeline è determinato dall'origine della pipeline, ad esempio. CodeCommit In tal caso, ad esempio, la pipeline di sondaggio dovrebbe migrare al rilevamento delle modifiche basato sugli eventi con. EventBridge
## Come migrare le pipeline elettorali
Per migrare le pipeline di sondaggi, determina le tue pipeline di sondaggio e quindi determina il metodo di rilevamento delle modifiche consigliato basato sugli eventi:
+ Utilizza la procedura descritta di seguito per determinare le tue pipeline di [Visualizzazione delle pipeline di sondaggio nel proprio account](#update-change-detection-view-polling) sondaggi.
+ Nella tabella, individuate il tipo di sorgente della vostra pipeline, quindi scegliete la procedura con l'implementazione che desiderate utilizzare per migrare la pipeline di polling. Ogni sezione contiene diversi metodi per la migrazione, ad esempio l'utilizzo della CLI o. CloudFormation
| Come migrare le pipeline nel metodo di rilevamento delle modifiche consigliato | Fonte della pipeline | Metodo di rilevamento consigliato basato sugli eventi | Procedure di migrazione |
| --- | --- | --- | --- |
| AWS CodeCommit | EventBridge (consigliato). | Per informazioni, consulta [Migra le pipeline di polling con una fonte CodeCommit](#update-change-detection-codecommit). |
| Simple Storage Service (Amazon S3) | EventBridge e bucket abilitato per le notifiche degli eventi (consigliato). | Per informazioni, consulta [Esegui la migrazione delle pipeline di polling con una fonte S3 abilitata per gli eventi](#update-change-detection-S3-event). |
| Simple Storage Service (Amazon S3) | EventBridge e una AWS CloudTrail pista. | Per informazioni, consulta [Migra le pipeline di polling con un sorgente e un trail S3 CloudTrail](#update-change-detection-S3). |
| GitHub (tramite GitHub App) | Connessioni (consigliate) | Per informazioni, consulta [Migra le pipeline di polling per un'azione sorgente GitHub (tramite OAuth app) verso le connessioni](#update-change-detection-github-connection). |
| GitHub (tramite OAuth app) | Webhook | Per informazioni, consulta [Migra le pipeline di polling per un'azione sorgente GitHub (tramite OAuth app) sui webhook](#update-change-detection-github-webhooks). |
**Importante**
Per gli aggiornamenti della configurazione delle azioni della pipeline applicabili, ad esempio le pipeline con un'azione GitHub (tramite OAuth app), devi impostare esplicitamente il `PollForSourceChanges` parametro su *false* all'interno della configurazione dell'azione Source per impedire il polling di una pipeline. Di conseguenza, è possibile configurare erroneamente una pipeline sia con il rilevamento delle modifiche basato sugli eventi che con il polling, ad esempio configurando una *regola e* omettendo anche il parametro. EventBridge `PollForSourceChanges` Questa operazione si traduce in esecuzioni di pipeline duplicate e la pipeline viene conteggiata rispetto al limite sul numero totale di pipeline di polling che per impostazione predefinita è molto più basso delle pipeline basate su eventi. Per ulteriori informazioni, consulta [Quote in AWS CodePipeline](limits.md).
## Visualizzazione delle pipeline di sondaggio nel proprio account
Come primo passaggio, utilizza uno dei seguenti script per determinare quali pipeline del tuo account sono configurate per il polling. Queste sono le pipeline da migrare al rilevamento delle modifiche basato sugli eventi.
### Visualizzazione delle pipeline di sondaggio nel tuo account (script)
Segui questi passaggi per utilizzare uno script per determinare le pipeline del tuo account che utilizzano il polling.
1. Apri una finestra di terminale, quindi esegui una delle seguenti operazioni:
+ Eseguite il comando seguente per creare un nuovo script denominato **PollingPipelinesExtractor.sh.**
```
vi PollingPipelinesExtractor.sh
```
+ **Per usare uno script python, esegui il comando seguente per creare un nuovo script python chiamato .py. PollingPipelinesExtractor**
```
vi PollingPipelinesExtractor.py
```
1. Copia e incolla il seguente codice nello script. **PollingPipelinesExtractor** Esegui una delle seguenti operazioni:
+ Copia e incolla il codice seguente nello **PollingPipelinesExtractorscript.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."
```
+ Copia e incolla il codice seguente nello **PollingPipelinesExtractorscript.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. Per ogni regione in cui sono presenti pipeline, è necessario eseguire lo script per quella regione. Per eseguire lo script, effettuate una delle seguenti operazioni:
+ Eseguite il comando seguente per eseguire lo script denominato **PollingPipelinesExtractor.sh.** In questo esempio, la regione è us-west-2.
```
./PollingPipelinesExtractor.sh us-west-2
```
+ **Per lo script python, esegui il comando seguente per eseguire lo script python denominato .py. PollingPipelinesExtractor** In questo esempio, la regione è us-west-2.
```
python3 PollingPipelinesExtractor.py us-west-2
```
Nel seguente esempio di output dello script, la regione us-west-2 ha restituito un elenco di pipeline di polling e mostra l'ora dell'ultima esecuzione per ciascuna 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...%
```
Analizza l'output dello script e, per ogni pipeline nell'elenco, aggiorna la fonte di polling con il metodo di rilevamento delle modifiche basato sugli eventi consigliato.
**Nota**
Le pipeline di polling sono determinate dalla configurazione delle azioni della pipeline per il parametro. `PollForSourceChanges` Se nella configurazione di origine della pipeline il `PollForSourceChanges` parametro è omesso, per impostazione CodePipeline predefinita esegue il polling del repository per verificare la presenza di modifiche all'origine. Questo comportamento è lo stesso che se fosse `PollForSourceChanges` incluso e impostato su true. Per ulteriori informazioni, consulta i parametri di configurazione per l'azione di origine della pipeline, ad esempio i parametri di configurazione dell'azione sorgente di Amazon S3 in. [Riferimento all'azione del codice sorgente di Amazon S3](action-reference-S3.md)
Tieni presente che questo script genera anche un file.csv contenente l'elenco delle pipeline di polling presenti nel tuo account e salva il file.csv nella cartella di lavoro corrente.
## Migra le pipeline di polling con una fonte CodeCommit
Puoi migrare la tua pipeline di polling per utilizzarla per EventBridge rilevare le modifiche nel tuo repository di CodeCommit origine o nel tuo bucket di origine Amazon S3.
**CodeCommit**-- Per una pipeline con una CodeCommit fonte, modifica la pipeline in modo da automatizzare il rilevamento delle modifiche. EventBridge Scegliete uno dei seguenti metodi per implementare la migrazione:
+ **Console:** [Migrazione delle pipeline di polling (o sorgente Amazon CodeCommit S3) (console)](#update-change-detection-console-codecommit-S3)
+ **CLI:** [Migrazione delle pipeline di polling (CodeCommit origine) (CLI)](#update-change-detection-cli-codecommit)
+ **CloudFormation: ** [Migra le pipeline di polling (CodeCommit source) (modello)CloudFormation](#update-change-detection-cfn-codecommit)
### Migrazione delle pipeline di polling (o sorgente Amazon CodeCommit S3) (console)
Puoi utilizzare la CodePipeline console per aggiornare la pipeline da utilizzare per EventBridge rilevare le modifiche nel tuo repository di CodeCommit origine o nel tuo bucket di origine Amazon S3.
**Nota**
Quando usi la console per modificare una pipeline con un repository di CodeCommit origine o un bucket di origine Amazon S3, la regola e il ruolo IAM vengono creati automaticamente. Se utilizzi il AWS CLI per modificare la pipeline, devi creare tu stesso la EventBridge regola e il ruolo IAM. Per ulteriori informazioni, consulta [CodeCommit azioni di origine e EventBridge](triggering.md).
Utilizza queste fasi per modificare una pipeline che utilizza controlli periodici. Se vuoi creare una pipeline, consulta [Crea una pipeline, fasi e azioni](pipelines-create.md).
**Per modificare la fase di origine della pipeline**
1. Accedi Console di gestione AWS e apri la CodePipeline console all'[indirizzo http://console.aws.amazon. com/codesuite/codepipeline/home](https://console.aws.amazon.com/codesuite/codepipeline/home).
Vengono visualizzati i nomi di tutte le pipeline associate al tuo AWS account.
1. In **Name (Nome)**, scegliere il nome della pipeline da modificare. Questa operazione apre una visualizzazione dettagliata della pipeline. compreso lo stato di ciascuna delle operazioni in ciascuna fase della pipeline.
1. Nella pagina dei dettagli della pipeline, scegliere **Edit (Modifica)**.
1. In **Edit stage (Modifica fase)**, scegli l'icona di modifica sull'operazione di origine.
1. Espandi **le opzioni di rilevamento delle modifiche** e scegli **Usa CloudWatch eventi per avviare automaticamente la mia pipeline quando si verifica una modifica (scelta consigliata)**.
Viene visualizzato un messaggio che mostra la EventBridge regola da creare per questa pipeline. Scegliere **Aggiorna**.
Se stai aggiornando una pipeline che ha una fonte Amazon S3, viene visualizzato il seguente messaggio. Scegliere **Aggiorna**.
1. Al termine della modifica della pipeline, scegliere **Save pipeline changes (Salva modifiche pipeline)** per tornare alla pagina di riepilogo.
Un messaggio mostra il nome della EventBridge regola da creare per la pipeline. Seleziona **Salva e continua**.
1. Per testare la tua azione, rilascia una modifica utilizzando il AWS CLI comando per confermare una modifica alla fonte specificata nella fase di origine della pipeline.
### Migrazione delle pipeline di polling (CodeCommit origine) (CLI)
Segui questi passaggi per modificare una pipeline che utilizza il polling (controlli periodici) per utilizzare una regola per avviare la pipeline. EventBridge Se vuoi creare una pipeline, consulta [Crea una pipeline, fasi e azioni](pipelines-create.md).
Per creare una pipeline basata sugli eventi con CodeCommit, devi modificare il `PollForSourceChanges` parametro della pipeline e quindi creare le seguenti risorse:
+ EventBridge evento
+ Ruolo IAM per consentire all'evento di avviare la pipeline
**Per modificare i parametri della PollForSourceChanges pipeline**
**Importante**
Quando crei una pipeline con questo metodo, il parametro `PollForSourceChanges` è preimpostato su "true" se non viene impostato esplicitamente su "false". Quando aggiungi il rilevamento delle modifiche basato su eventi, devi aggiungere il parametro all'output e impostarlo su "false" per disabilitare il polling. In caso contrario, la pipeline si avvia due volte per una singola modifica dell'origine. Per informazioni dettagliate, vedi [Impostazioni valide per il `PollForSourceChanges` parametro](PollForSourceChanges-defaults.md).
1. Esegui il comando **get-pipeline** per copiare la struttura della pipeline in un file JSON. Ad esempio, per una pipeline denominata `MyFirstPipeline`, esegui il seguente comando:
```
aws codepipeline get-pipeline --name MyFirstPipeline >pipeline.json
```
Questo comando non restituisce alcun valore, ma nella directory in cui è stato eseguito dovrebbe comparire il file creato.
1. Apri il file JSON in qualsiasi editor di testo normale e modifica la fase di origine modificando il parametro `PollForSourceChanges` su `false`, come illustrato in questo esempio.
**Perché occorre apportare questa modifica?** La modifica di questo parametro in `false` disattiva i controlli periodici, in modo che sia possibile utilizzare solo il rilevamento delle modifiche basato su eventi.
```
"configuration": {
"PollForSourceChanges": "false",
"BranchName": "main",
"RepositoryName": "MyTestRepo"
},
```
1. Se stai utilizzando la struttura della pipeline recuperata tramite il comando **get-pipeline**, rimuovi le righe `metadata` dal file JSON. In caso contrario, il comando **update-pipeline** non è in grado di utilizzarlo. Rimuovi le righe `"metadata": { }` e i campi `"created"`, `"pipelineARN"` e `"updated"`.
Ad esempio, rimuovere dalla struttura le seguenti righe:
```
"metadata": {
"pipelineArn": "arn:aws:codepipeline:region:account-ID:pipeline-name",
"created": "date",
"updated": "date"
},
```
Salvare il file.
1. Per applicare le modifiche, eseguire il comando **update-pipeline**, specificando il file JSON della pipeline:
**Importante**
Assicurarsi di includere `file://` prima del nome del file. Questo è obbligatorio in questo comando.
```
aws codepipeline update-pipeline --cli-input-json file://pipeline.json
```
Questo comando restituisce l'intera struttura della pipeline modificata.
**Nota**
Il comando **update-pipeline** arresta la pipeline. Se è in corso di elaborazione una versione durante l'esecuzione del comando **update-pipeline**, tale elaborazione viene arrestata. Per elaborare tale versione utilizzando la pipeline aggiornata, devi avviare manualmente la pipeline. Utilizza il comando **`start-pipeline-execution`** per avviare manualmente la pipeline.
**Per creare una EventBridge regola con CodeCommit come origine dell'evento e CodePipeline come destinazione**
1. Aggiungi le autorizzazioni EventBridge da utilizzare per CodePipeline richiamare la regola. Per ulteriori informazioni, consulta [Utilizzo delle politiche basate sulle risorse per Amazon](https://docs.aws.amazon.com/eventbridge/latest/userguide/eb-use-resource-based.html). EventBridge
1. Usa l'esempio seguente per creare la politica di fiducia che consente di EventBridge assumere il ruolo di servizio. Denomina la policy di attendibilità `trustpolicyforEB.json`.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": "events.amazonaws.com"
},
"Action": "sts:AssumeRole"
}
]
}
```
------
1. Utilizza il seguente comando per creare il ruolo `Role-for-MyRule` e collegare la policy di attendibilità.
```
aws iam create-role --role-name Role-for-MyRule --assume-role-policy-document file://trustpolicyforEB.json
```
1. Crea il JSON della policy delle autorizzazioni, come mostrato in questo esempio, per la pipeline denominata `MyFirstPipeline`. Denomina la policy delle autorizzazioni `permissionspolicyforEB.json`.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"codepipeline:StartPipelineExecution"
],
"Resource": [
"arn:aws:codepipeline:us-west-2:111122223333:MyFirstPipeline"
]
}
]
}
```
------
1. Utilizza il comando seguente per collegare la policy delle autorizzazioni `CodePipeline-Permissions-Policy-for-EB` al ruolo `Role-for-MyRule`.
**Perché occorre apportare questa modifica?** L'aggiunta di questa politica al ruolo crea le autorizzazioni per EventBridge.
```
aws iam put-role-policy --role-name Role-for-MyRule --policy-name CodePipeline-Permissions-Policy-For-EB --policy-document file://permissionspolicyforEB.json
```
1. Richiama il comando **put-rule** e includi i parametri `--name`, `--event-pattern` e `--role-arn`.
**Perché occorre apportare questa modifica?** Questo comando consente a CloudFormation di creare l'evento.
Il seguente comando di esempio crea una regola denominata `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. Per aggiungerlo CodePipeline come destinazione, chiamate il **put-targets** comando e includete i seguenti parametri:
+ Il parametro `--rule` viene utilizzato con il `rule_name` che hai creato utilizzando **put-rule**.
+ Il parametro `--targets` viene utilizzato con l'`Id` elenco della destinazione nell'elenco delle destinazioni e l'`ARN` della pipeline di destinazione.
Il comando di esempio seguente specifica che per la regola denominata `MyCodeCommitRepoRule`, la destinazione `Id` è composta dal numero uno, per indicare che in un elenco di destinazioni per la regola questa è la destinazione 1. Il comando di esempio specifica anche un esempio di `ARN` per la pipeline. La pipeline si avvia quando si verifica una modifica nel repository.
```
aws events put-targets --rule MyCodeCommitRepoRule --targets Id=1,Arn=arn:aws:codepipeline:us-west-2:80398EXAMPLE:TestPipeline
```
1. (Facoltativo) Per configurare un trasformatore di ingresso con sostituzioni di origine per un ID immagine specifico, utilizzate il seguente codice JSON nel comando CLI. L'esempio seguente configura un override in cui:
+ `Source`In questo esempio`actionName`, è il valore dinamico, definito al momento della creazione della pipeline, non derivato dall'evento di origine.
+ `COMMIT_ID`In questo esempio`revisionType`, è il valore dinamico, definito al momento della creazione della pipeline, non derivato dall'evento di origine.
+ Il`revisionValue`, < *revisionValue* > in questo esempio, è derivato dalla variabile dell'evento source.
```
{
"Rule": "my-rule",
"Targets": [
{
"Id": "MyTargetId",
"Arn": "pipeline-ARN",
"InputTransformer": {
"sourceRevisions": {
"actionName": "Source",
"revisionType": "COMMIT_ID",
"revisionValue": ""
},
"variables": [
{
"name": "Branch_Name",
"value": "value"
}
]
}
}
]
}
```
### Migra le pipeline di polling (CodeCommit source) (modello)CloudFormation
Per creare una pipeline basata sugli eventi con AWS CodeCommit, modificate il `PollForSourceChanges` parametro della pipeline e quindi aggiungete le seguenti risorse al modello:
+ EventBridge Una regola
+ Un ruolo IAM per la tua EventBridge regola
Se lo utilizzi CloudFormation per creare e gestire le tue pipeline, il tuo modello include contenuti come i seguenti.
**Nota**
La proprietà `Configuration` nella fase di origine chiamata `PollForSourceChanges`. Se questa proprietà non è inclusa nel modello, allora `PollForSourceChanges` è impostato su `true` per impostazione predefinita.
------
#### [ 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
}]
},
```
------
**Per aggiornare il CloudFormation modello di pipeline e creare una regola EventBridge**
1. Nel modello, sotto`Resources`, utilizza la `AWS::IAM::Role` CloudFormation risorsa per configurare il ruolo IAM che consente all'evento di avviare la pipeline. Questa voce crea un ruolo che utilizza due policy:
+ La prima policy consente di assumere quel ruolo.
+ La seconda policy fornisce le autorizzazioni per avviare la pipeline.
**Perché occorre apportare questa modifica?** L'aggiunta della `AWS::IAM::Role` risorsa consente di CloudFormation creare autorizzazioni per. EventBridge Questa risorsa viene aggiunta al tuo CloudFormation stack.
------
#### [ 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. Nel modello, sotto`Resources`, usa la `AWS::Events::Rule` CloudFormation risorsa per aggiungere una EventBridge regola. Questo modello di eventi crea un evento che monitora le modifiche push al tuo repository. Quando EventBridge rileva una modifica dello stato del repository, la regola viene `StartPipelineExecution` richiamata sulla pipeline di destinazione.
**Perché sto apportando questa modifica?** L'aggiunta della `AWS::Events::Rule` risorsa CloudFormation consente di creare l'evento. Questa risorsa viene aggiunta al tuo CloudFormation stack.
------
#### [ 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. (Facoltativo) Per configurare un trasformatore di ingresso con sostituzioni di sorgente per un ID di immagine specifico, utilizzate il seguente frammento di codice YAML. L'esempio seguente configura un override in cui:
+ `Source`In questo esempio`actionName`, è il valore dinamico, definito al momento della creazione della pipeline, non derivato dall'evento di origine.
+ `COMMIT_ID`In questo esempio`revisionType`, è il valore dinamico, definito al momento della creazione della pipeline, non derivato dall'evento di origine.
+ Il`revisionValue`, < *revisionValue* > in questo esempio, è derivato dalla variabile dell'evento source.
+ Le variabili di output per `BranchName` e `Value` sono specificate.
```
Rule: my-rule
Targets:
- Id: MyTargetId
Arn: pipeline-ARN
InputTransformer:
sourceRevisions:
actionName: Source
revisionType: COMMIT_ID
revisionValue:
variables:
- name: BranchName
value: value
```
1. Salva il modello aggiornato sul computer locale, quindi apri la CloudFormation console.
1. Seleziona lo stack e scegli **Create Change Set for Current Stack (Crea set di modifiche per lo stack corrente)**.
1. Carica il modello e quindi visualizza le modifiche elencate in CloudFormation. Queste sono le modifiche da apportare allo stack. Le nuove risorse dovrebbero essere visibili nell'elenco.
1. Scegli **Esegui**.
**Per modificare i parametri della PollForSourceChanges pipeline**
**Importante**
In molti casi, il parametro `PollForSourceChanges` è preimpostato su "true" al momento della creazione di una pipeline. Quando aggiungi il rilevamento delle modifiche basato su eventi, devi aggiungere il parametro all'output e impostarlo su "false" per disabilitare il polling. In caso contrario, la pipeline si avvia due volte per una singola modifica dell'origine. Per informazioni dettagliate, vedi [Impostazioni valide per il `PollForSourceChanges` parametro](PollForSourceChanges-defaults.md).
+ Nel modello, modifica `PollForSourceChanges` in `false`. Se non hai incluso `PollForSourceChanges` nella definizione della pipeline, aggiungilo e impostalo su `false`.
**Perché occorre apportare questa modifica?** La modifica di questo parametro in `false` disattiva i controlli periodici, in modo che sia possibile utilizzare solo il rilevamento delle modifiche basato su eventi.
------
#### [ 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**
Quando crei queste risorse con CloudFormation, la pipeline viene attivata quando i file nel tuo repository vengono creati o aggiornati. Qui è riportato il frammento di modello finale:
```
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
}
]
},
...
```
## Esegui la migrazione delle pipeline di polling con una fonte S3 abilitata per gli eventi
Per una pipeline con un'origine Amazon S3, modifica la pipeline in modo che il rilevamento delle modifiche sia automatizzato EventBridge tramite e con un bucket di origine abilitato per le notifiche degli eventi. Questo è il metodo consigliato se utilizzi la CLI o CloudFormation per migrare la tua pipeline.
**Nota**
Ciò include l'utilizzo di un bucket abilitato per le notifiche degli eventi, in cui non è necessario creare un percorso separato. CloudTrail Se utilizzi la console, vengono impostate automaticamente una regola e un CloudTrail percorso per gli eventi. Per questi passaggi, vedi[Migra le pipeline di polling con un sorgente e un trail S3 CloudTrail](#update-change-detection-S3).
+ **CLI:** [Migra le pipeline di polling con un codice sorgente e trail CloudTrail (CLI) S3](#update-change-detection-cli-S3)
+ **CloudFormation: **[Migra le pipeline di polling con una sorgente e un trail S3 (modello) CloudTrail CloudFormation](#update-change-detection-cfn-s3)
### Esegui la migrazione delle pipeline di polling con un'origine S3 abilitata per gli eventi (CLI)
Segui questi passaggi per modificare una pipeline che utilizza il polling (controlli periodici) in cui utilizzare invece un evento. EventBridge Se vuoi creare una pipeline, consulta [Crea una pipeline, fasi e azioni](pipelines-create.md).
Per creare una pipeline basata sugli eventi con Amazon S3, devi modificare il `PollForSourceChanges` parametro della pipeline e quindi creare le seguenti risorse:
+ EventBridge regola dell'evento
+ ruolo IAM per consentire all' EventBridge evento di avviare la pipeline
**Per creare una EventBridge regola con Amazon S3 come origine dell'evento e CodePipeline come destinazione e applicare la politica delle autorizzazioni**
1. Concedi le autorizzazioni EventBridge da utilizzare per CodePipeline richiamare la regola. Per ulteriori informazioni, consulta [Utilizzo delle politiche basate sulle risorse per Amazon](https://docs.aws.amazon.com/eventbridge/latest/userguide/eb-use-resource-based.html). EventBridge
1. Utilizzare l'esempio seguente per creare la policy di trust per consentire a EventBridge di assumere il ruolo del servizio. Denominalo `trustpolicyforEB.json`.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": "events.amazonaws.com"
},
"Action": "sts:AssumeRole"
}
]
}
```
------
1. Utilizza il seguente comando per creare il ruolo `Role-for-MyRule` e collegare la policy di attendibilità.
**Perché occorre apportare questa modifica?** L'aggiunta al ruolo di questa policy di affidabilità crea le autorizzazioni per EventBridge.
```
aws iam create-role --role-name Role-for-MyRule --assume-role-policy-document file://trustpolicyforEB.json
```
1. Crea il JSON della policy delle autorizzazioni, come mostrato qui per la pipeline denominata `MyFirstPipeline`. Denomina la policy delle autorizzazioni `permissionspolicyforEB.json`.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"codepipeline:StartPipelineExecution"
],
"Resource": [
"arn:aws:codepipeline:us-west-2:111122223333:MyFirstPipeline"
]
}
]
}
```
------
1. Utilizza il comando seguente per collegare la nuova policy delle autorizzazioni `CodePipeline-Permissions-Policy-for-EB` al ruolo `Role-for-MyRule` che hai creato.
```
aws iam put-role-policy --role-name Role-for-MyRule --policy-name CodePipeline-Permissions-Policy-For-EB --policy-document file://permissionspolicyforEB.json
```
1. Richiama il comando **put-rule** e includi i parametri `--name`, `--event-pattern` e `--role-arn`.
Il seguente comando di esempio crea una regola denominata `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. Per aggiungere CodePipeline come destinazione, chiama il **put-targets** comando e includi i parametri and. `--rule` `--targets`
Il comando seguente specifica che per la regola denominata `EnabledS3SourceRule`, la destinazione `Id` è composta dal numero uno, per indicare che in un elenco di destinazioni per la regola questa è la destinazione 1. Il comando specifica anche un esempio di `ARN` per la pipeline. La pipeline si avvia quando si verifica una modifica nel repository.
```
aws events put-targets --rule EnabledS3SourceRule --targets Id=codepipeline-AppPipeline,Arn=arn:aws:codepipeline:us-west-2:80398EXAMPLE:TestPipeline
```
**Per modificare il parametro della PollForSourceChanges pipeline**
**Importante**
Quando crei una pipeline con questo metodo, il parametro `PollForSourceChanges` è preimpostato su "true" se non viene impostato esplicitamente su "false". Quando aggiungi il rilevamento delle modifiche basato su eventi, devi aggiungere il parametro all'output e impostarlo su "false" per disabilitare il polling. In caso contrario, la pipeline si avvia due volte per una singola modifica dell'origine. Per informazioni dettagliate, vedi [Impostazioni valide per il `PollForSourceChanges` parametro](PollForSourceChanges-defaults.md).
1. Esegui il comando **get-pipeline** per copiare la struttura della pipeline in un file JSON. Ad esempio, per una pipeline denominata `MyFirstPipeline`, esegui il seguente comando:
```
aws codepipeline get-pipeline --name MyFirstPipeline >pipeline.json
```
Questo comando non restituisce alcun valore, ma nella directory in cui è stato eseguito dovrebbe comparire il file creato.
1. Apri il file JSON in qualsiasi editor di testo normale e modifica la fase di origine modificando il parametro `PollForSourceChanges` per un bucket denominato `amzn-s3-demo-source-bucket``false` come mostrato nell'esempio seguente.
**Perché occorre apportare questa modifica?** L'impostazione del parametro su `false` disattiva i controlli periodici, in modo che sia possibile utilizzare solo il rilevamento delle modifiche basato su eventi.
```
"configuration": {
"S3Bucket": "amzn-s3-demo-source-bucket",
"PollForSourceChanges": "false",
"S3ObjectKey": "index.zip"
},
```
1. Se stai utilizzando la struttura della pipeline recuperata tramite il comando **get-pipeline**, devi rimuovere le righe `metadata` dal file JSON. In caso contrario, il comando **update-pipeline** non è in grado di utilizzarlo. Rimuovi le righe `"metadata": { }` e i campi `"created"`, `"pipelineARN"` e `"updated"`.
Ad esempio, rimuovere dalla struttura le seguenti righe:
```
"metadata": {
"pipelineArn": "arn:aws:codepipeline:region:account-ID:pipeline-name",
"created": "date",
"updated": "date"
},
```
Salvare il file.
1. Per applicare le modifiche, eseguire il comando **update-pipeline**, specificando il file JSON della pipeline:
**Importante**
Assicurarsi di includere `file://` prima del nome del file. Questo è obbligatorio in questo comando.
```
aws codepipeline update-pipeline --cli-input-json file://pipeline.json
```
Questo comando restituisce l'intera struttura della pipeline modificata.
**Nota**
Il comando **update-pipeline** arresta la pipeline. Se è in corso di elaborazione una versione durante l'esecuzione del comando **update-pipeline**, tale elaborazione viene arrestata. Per elaborare tale versione utilizzando la pipeline aggiornata, devi avviare manualmente la pipeline. Utilizza il comando **start-pipeline-execution** per avviare manualmente la pipeline.
### Migra le pipeline di polling con una fonte S3 abilitata per gli eventi (modello)CloudFormation
Questa procedura è per una pipeline in cui gli eventi sono abilitati nel bucket di origine.
Utilizza questi passaggi per modificare la tua pipeline con una fonte Amazon S3, dal polling al rilevamento delle modifiche basato sugli eventi.
Per creare una pipeline basata sugli eventi con Amazon S3, devi modificare il `PollForSourceChanges` parametro della pipeline e quindi aggiungere le seguenti risorse al modello:
+ EventBridge regola e ruolo IAM per consentire a questo evento di avviare la pipeline.
Se lo utilizzi CloudFormation per creare e gestire le tue pipeline, il tuo modello include contenuti come i seguenti.
**Nota**
La proprietà `Configuration` nella fase di origine chiamata `PollForSourceChanges`. Se il modello non include questa proprietà, allora `PollForSourceChanges` è impostato su `true` per impostazione predefinita.
------
#### [ 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
}
]
},
...
```
------
**Per creare una EventBridge regola con Amazon S3 come origine dell'evento e CodePipeline come destinazione e applicare la politica delle autorizzazioni**
1. Nel modello, sotto`Resources`, utilizza la `AWS::IAM::Role` CloudFormation risorsa per configurare il ruolo IAM che consente all'evento di avviare la pipeline. Questa voce crea un ruolo che utilizza due policy:
+ La prima policy consente di assumere quel ruolo.
+ La seconda policy fornisce le autorizzazioni per avviare la pipeline.
**Perché occorre apportare questa modifica?** L'aggiunta di `AWS::IAM::Role` risorse consente CloudFormation di creare autorizzazioni per. EventBridge Questa risorsa viene aggiunta al tuo CloudFormation stack.
------
#### [ 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. Usa la `AWS::Events::Rule` CloudFormation risorsa per aggiungere una EventBridge regola. Questo modello di eventi crea un evento che monitora la creazione o l'eliminazione di oggetti nel bucket di origine Amazon S3. Inoltre, include una destinazione della pipeline. Quando viene creato un oggetto, questa regola invoca `StartPipelineExecution` la pipeline di destinazione.
**Perché occorre apportare questa modifica?** L'aggiunta della `AWS::Events::Rule` risorsa consente di CloudFormation creare l'evento. Questa risorsa viene aggiunta al tuo CloudFormation stack.
------
#### [ 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. Salvare il modello aggiornato sul computer locale e aprire la console CloudFormation .
1. Seleziona lo stack e scegli **Create Change Set for Current Stack (Crea set di modifiche per lo stack corrente)**.
1. Caricare il modello aggiornato e quindi visualizzare le modifiche elencate in CloudFormation. Queste sono le modifiche che verranno apportate allo stack. Le nuove risorse dovrebbero essere visibili nell'elenco.
1. Scegli **Esegui**.
**Per modificare i parametri della pipeline PollForSourceChanges**
**Importante**
Quando crei una pipeline con questo metodo, il parametro `PollForSourceChanges` è preimpostato su "true" se non viene impostato esplicitamente su "false". Quando aggiungi il rilevamento delle modifiche basato su eventi, devi aggiungere il parametro all'output e impostarlo su "false" per disabilitare il polling. In caso contrario, la pipeline si avvia due volte per una singola modifica dell'origine. Per informazioni dettagliate, vedi [Impostazioni valide per il `PollForSourceChanges` parametro](PollForSourceChanges-defaults.md).
+ Nel modello, modifica `PollForSourceChanges` in `false`. Se non hai incluso `PollForSourceChanges` nella definizione della pipeline, aggiungilo e impostalo su `false`.
**Perché occorre apportare questa modifica?** La modifica di `PollForSourceChanges` in `false` disattiva i controlli periodici, in modo che sia possibile utilizzare solo il rilevamento delle modifiche basato su eventi.
------
#### [ 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**
Quando si utilizzano CloudFormation per creare queste risorse, la pipeline viene attivata quando i file nel repository vengono creati o aggiornati.
Non è finita qui. Sebbene la pipeline sia stata creata, è necessario creare un secondo CloudFormation modello per la pipeline Amazon S3. Se non crei il secondo modello, la pipeline non avrà la funzionalità di rilevamento delle modifiche.
```
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"
}
]
}
```
## Migra le pipeline di polling con un sorgente e un trail S3 CloudTrail
Per una pipeline con una fonte Amazon S3, modifica la pipeline in modo da automatizzare il rilevamento delle modifiche. EventBridge Scegli tra i seguenti metodi per implementare la migrazione:
+ **Console:** [Migrazione delle pipeline di polling (o sorgente Amazon CodeCommit S3) (console)](#update-change-detection-console-codecommit-S3)
+ **CLI:** [Migra le pipeline di polling con un codice sorgente e trail CloudTrail (CLI) S3](#update-change-detection-cli-S3)
+ **CloudFormation: **[Migra le pipeline di polling con una sorgente e un trail S3 (modello) CloudTrail CloudFormation](#update-change-detection-cfn-s3)
### Migra le pipeline di polling con un codice sorgente e trail CloudTrail (CLI) S3
Segui questi passaggi per modificare una pipeline che utilizza il polling (controlli periodici) per utilizzare invece un evento. EventBridge Se vuoi creare una pipeline, consulta [Crea una pipeline, fasi e azioni](pipelines-create.md).
Per creare una pipeline basata sugli eventi con Amazon S3, devi modificare il `PollForSourceChanges` parametro della pipeline e quindi creare le seguenti risorse:
+ AWS CloudTrail policy trail, bucket e bucket che Amazon S3 può utilizzare per registrare gli eventi.
+ EventBridge evento
+ Ruolo IAM per consentire all' EventBridge evento di avviare la tua pipeline
**Per creare un AWS CloudTrail percorso e abilitare la registrazione**
Per utilizzare il AWS CLI per creare una traccia, chiamate il **create-trail** comando, specificando:
+ Il nome del trail.
+ Il bucket nel quale hai già applicato le policy del bucket per AWS CloudTrail.
Per ulteriori informazioni, vedere [Creazione di un percorso con l'interfaccia a riga di AWS comando](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/cloudtrail-create-and-update-a-trail-by-using-the-aws-cli.html).
1. Chiama il comando **create-trail** e includi i parametri `--name` e `--s3-bucket-name`.
**Perché occorre apportare questa modifica?** Questo crea il trail CloudTrail richiesto per il bucket di origine S3.
Il comando seguente utilizza `--name` e `--s3-bucket-name` per creare un trail denominato `my-trail` e un bucket denominato `amzn-s3-demo-source-bucket`.
```
aws cloudtrail create-trail --name my-trail --s3-bucket-name amzn-s3-demo-source-bucket
```
1. Chiama il comando **start-logging** e includi il parametro `--name`.
**Perché sto apportando questa modifica?** Questo comando avvia la CloudTrail registrazione per il bucket di origine e invia gli eventi a. EventBridge
Esempio:
Il comando seguente utilizza `--name` per avviare la registrazione su un trail denominato `my-trail`.
```
aws cloudtrail start-logging --name my-trail
```
1. Chiama il comando **put-event-selectors** e includi i parametri `--trail-name` e `--event-selectors`. Usa i selettori di eventi per specificare che desideri che il tuo trail registri gli eventi di dati per il tuo bucket di origine e invii gli eventi alla regola. EventBridge
**Perché sto apportando questa modifica?** Questo comando filtra gli eventi.
Esempio:
Il comando seguente utilizza `--trail-name` e `--event-selectors` per specificare gli eventi dati per un bucket e un prefisso di origine denominati `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"] }] }]'
```
**Per creare una EventBridge regola con Amazon S3 come origine dell'evento e CodePipeline come destinazione e applicare la politica delle autorizzazioni**
1. Concedi le autorizzazioni EventBridge da utilizzare per CodePipeline richiamare la regola. Per ulteriori informazioni, consulta [Utilizzo delle politiche basate sulle risorse per Amazon](https://docs.aws.amazon.com/eventbridge/latest/userguide/eb-use-resource-based.html). EventBridge
1. Usa l'esempio seguente per creare la politica di fiducia che EventBridge consenta di assumere il ruolo di servizio. Denominalo `trustpolicyforEB.json`.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": "events.amazonaws.com"
},
"Action": "sts:AssumeRole"
}
]
}
```
------
1. Utilizza il seguente comando per creare il ruolo `Role-for-MyRule` e collegare la policy di attendibilità.
**Perché occorre apportare questa modifica?** L'aggiunta di questa politica di fiducia al ruolo crea le autorizzazioni per EventBridge.
```
aws iam create-role --role-name Role-for-MyRule --assume-role-policy-document file://trustpolicyforEB.json
```
1. Crea il JSON della policy delle autorizzazioni, come mostrato qui per la pipeline denominata `MyFirstPipeline`. Denomina la policy delle autorizzazioni `permissionspolicyforEB.json`.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"codepipeline:StartPipelineExecution"
],
"Resource": [
"arn:aws:codepipeline:us-west-2:111122223333:MyFirstPipeline"
]
}
]
}
```
------
1. Utilizza il comando seguente per collegare la nuova policy delle autorizzazioni `CodePipeline-Permissions-Policy-for-EB` al ruolo `Role-for-MyRule` che hai creato.
```
aws iam put-role-policy --role-name Role-for-MyRule --policy-name CodePipeline-Permissions-Policy-For-EB --policy-document file://permissionspolicyforEB.json
```
1. Richiama il comando **put-rule** e includi i parametri `--name`, `--event-pattern` e `--role-arn`.
Il seguente comando di esempio crea una regola denominata `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. Per aggiungere CodePipeline come destinazione, chiamate il **put-targets** comando e includete i `--targets` parametri `--rule` and.
Il comando seguente specifica che per la regola denominata `MyS3SourceRule`, la destinazione `Id` è composta dal numero uno, per indicare che in un elenco di destinazioni per la regola questa è la destinazione 1. Il comando specifica anche un esempio di `ARN` per la pipeline. La pipeline si avvia quando si verifica una modifica nel repository.
```
aws events put-targets --rule MyS3SourceRule --targets Id=1,Arn=arn:aws:codepipeline:us-west-2:80398EXAMPLE:TestPipeline
```
1. (Facoltativo) Per configurare un trasformatore di ingresso con sostituzioni di origine per un ID immagine specifico, utilizzate il seguente codice JSON nel comando CLI. L'esempio seguente configura un override in cui:
+ `Source`In questo esempio`actionName`, è il valore dinamico, definito al momento della creazione della pipeline, non derivato dall'evento di origine.
+ `S3_OBJECT_VERSION_ID`In questo esempio`revisionType`, è il valore dinamico, definito al momento della creazione della pipeline, non derivato dall'evento di origine.
+ Il`revisionValue`, < *revisionValue* > in questo esempio, è derivato dalla variabile dell'evento 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": ""
}
}
}
}
]
}
```
**Per modificare il parametro della PollForSourceChanges pipeline**
**Importante**
Quando crei una pipeline con questo metodo, il parametro `PollForSourceChanges` è preimpostato su "true" se non viene impostato esplicitamente su "false". Quando aggiungi il rilevamento delle modifiche basato su eventi, devi aggiungere il parametro all'output e impostarlo su "false" per disabilitare il polling. In caso contrario, la pipeline si avvia due volte per una singola modifica dell'origine. Per informazioni dettagliate, vedi [Impostazioni valide per il `PollForSourceChanges` parametro](PollForSourceChanges-defaults.md).
1. Esegui il comando **get-pipeline** per copiare la struttura della pipeline in un file JSON. Ad esempio, per una pipeline denominata `MyFirstPipeline`, esegui il seguente comando:
```
aws codepipeline get-pipeline --name MyFirstPipeline >pipeline.json
```
Questo comando non restituisce alcun valore, ma nella directory in cui è stato eseguito dovrebbe comparire il file creato.
1. Apri il file JSON in qualsiasi editor di testo normale e modifica la fase di origine modificando il parametro `PollForSourceChanges` per un bucket denominato `amzn-s3-demo-source-bucket``false` come mostrato nell'esempio seguente.
**Perché occorre apportare questa modifica?** L'impostazione del parametro su `false` disattiva i controlli periodici, in modo che sia possibile utilizzare solo il rilevamento delle modifiche basato su eventi.
```
"configuration": {
"S3Bucket": "amzn-s3-demo-source-bucket",
"PollForSourceChanges": "false",
"S3ObjectKey": "index.zip"
},
```
1. Se stai utilizzando la struttura della pipeline recuperata tramite il comando **get-pipeline**, devi rimuovere le righe `metadata` dal file JSON. In caso contrario, il comando **update-pipeline** non è in grado di utilizzarlo. Rimuovi le righe `"metadata": { }` e i campi `"created"`, `"pipelineARN"` e `"updated"`.
Ad esempio, rimuovere dalla struttura le seguenti righe:
```
"metadata": {
"pipelineArn": "arn:aws:codepipeline:region:account-ID:pipeline-name",
"created": "date",
"updated": "date"
},
```
Salvare il file.
1. Per applicare le modifiche, eseguire il comando **update-pipeline**, specificando il file JSON della pipeline:
**Importante**
Assicurarsi di includere `file://` prima del nome del file. Questo è obbligatorio in questo comando.
```
aws codepipeline update-pipeline --cli-input-json file://pipeline.json
```
Questo comando restituisce l'intera struttura della pipeline modificata.
**Nota**
Il comando **update-pipeline** arresta la pipeline. Se è in corso di elaborazione una versione durante l'esecuzione del comando **update-pipeline**, tale elaborazione viene arrestata. Per elaborare tale versione utilizzando la pipeline aggiornata, devi avviare manualmente la pipeline. Utilizza il comando **start-pipeline-execution** per avviare manualmente la pipeline.
### Migra le pipeline di polling con una sorgente e un trail S3 (modello) CloudTrail CloudFormation
Utilizza questi passaggi per modificare la tua pipeline con una fonte Amazon S3, dal polling al rilevamento delle modifiche basato sugli eventi.
Per creare una pipeline basata sugli eventi con Amazon S3, devi modificare il `PollForSourceChanges` parametro della pipeline e quindi aggiungere le seguenti risorse al modello:
+ EventBridge richiede la registrazione di tutti gli eventi di Amazon S3. È necessario creare una policy AWS CloudTrail trail, bucket e bucket che Amazon S3 possa utilizzare per registrare gli eventi che si verificano. Per ulteriori informazioni, consulta [Registrazione degli eventi relativi ai dati per i sentieri e [Registrazione](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/logging-management-events-with-cloudtrail.html) degli eventi](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/logging-data-events-with-cloudtrail.html) di gestione dei percorsi.
+ EventBridge regola e ruolo IAM per consentire a questo evento di avviare la nostra pipeline.
Se lo utilizzi CloudFormation per creare e gestire le tue pipeline, il tuo modello include contenuti come i seguenti.
**Nota**
La proprietà `Configuration` nella fase di origine chiamata `PollForSourceChanges`. Se il modello non include questa proprietà, allora `PollForSourceChanges` è impostato su `true` per impostazione predefinita.
------
#### [ 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
}
]
},
...
```
------
**Per creare una EventBridge regola con Amazon S3 come origine dell'evento e CodePipeline come destinazione e applicare la politica delle autorizzazioni**
1. Nel modello, sotto`Resources`, utilizza la `AWS::IAM::Role` CloudFormation risorsa per configurare il ruolo IAM che consente all'evento di avviare la pipeline. Questa voce crea un ruolo che utilizza due policy:
+ La prima policy consente di assumere quel ruolo.
+ La seconda policy fornisce le autorizzazioni per avviare la pipeline.
**Perché occorre apportare questa modifica?** L'aggiunta di `AWS::IAM::Role` risorse consente CloudFormation di creare autorizzazioni per. EventBridge Questa risorsa viene aggiunta al tuo CloudFormation stack.
------
#### [ 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. Usa la `AWS::Events::Rule` CloudFormation risorsa per aggiungere una EventBridge regola. Questo modello di eventi crea un evento che monitora `CopyObject` `PutObject` e `CompleteMultipartUpload` sul tuo bucket di origine Amazon S3. Inoltre, include una destinazione della pipeline. Quando si verifica `CopyObject`, `PutObject` o `CompleteMultipartUpload`, questa regola richiama `StartPipelineExecution` sulla pipeline di destinazione.
**Perché occorre apportare questa modifica?** L'aggiunta della `AWS::Events::Rule` risorsa consente di CloudFormation creare l'evento. Questa risorsa viene aggiunta al tuo CloudFormation stack.
------
#### [ 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. Aggiungere questo snippet di codice al primo modello per consentire la funzionalità tra stack:
------
#### [ 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. (Facoltativo) Per configurare un trasformatore di ingresso con sostituzioni di sorgente per un ID di immagine specifico, utilizzate il seguente frammento di codice YAML. L'esempio seguente configura un override in cui:
+ `Source`In questo esempio`actionName`, è il valore dinamico, definito al momento della creazione della pipeline, non derivato dall'evento di origine.
+ `S3_OBJECT_VERSION_ID`In questo esempio`revisionType`, è il valore dinamico, definito al momento della creazione della pipeline, non derivato dall'evento di origine.
+ Il`revisionValue`, < *revisionValue* > in questo esempio, è derivato dalla variabile dell'evento 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: ''
```
1. Salva il modello aggiornato sul computer locale e apri la CloudFormation console.
1. Seleziona lo stack e scegli **Create Change Set for Current Stack (Crea set di modifiche per lo stack corrente)**.
1. Caricare il modello aggiornato e quindi visualizzare le modifiche elencate in CloudFormation. Queste sono le modifiche che verranno apportate allo stack. Le nuove risorse dovrebbero essere visibili nell'elenco.
1. Scegli **Esegui**.
**Per modificare i parametri della PollForSourceChanges pipeline**
**Importante**
Quando crei una pipeline con questo metodo, il parametro `PollForSourceChanges` è preimpostato su "true" se non viene impostato esplicitamente su "false". Quando aggiungi il rilevamento delle modifiche basato su eventi, devi aggiungere il parametro all'output e impostarlo su "false" per disabilitare il polling. In caso contrario, la pipeline si avvia due volte per una singola modifica dell'origine. Per informazioni dettagliate, vedi [Impostazioni valide per il `PollForSourceChanges` parametro](PollForSourceChanges-defaults.md).
+ Nel modello, modifica `PollForSourceChanges` in `false`. Se non hai incluso `PollForSourceChanges` nella definizione della pipeline, aggiungilo e impostalo su `false`.
**Perché occorre apportare questa modifica?** La modifica di `PollForSourceChanges` in `false` disattiva i controlli periodici, in modo che sia possibile utilizzare solo il rilevamento delle modifiche basato su eventi.
------
#### [ 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
}
```
------
**Per creare un secondo modello per le risorse della tua pipeline Amazon S3 CloudTrail**
+ In un modello separato, sotto`Resources`, utilizza le `AWS::CloudTrail::Trail` CloudFormation risorse `AWS::S3::Bucket``AWS::S3::BucketPolicy`, e per fornire una definizione e un percorso semplici per il bucket. CloudTrail
**Perché sto apportando questa modifica?** Dato l'attuale limite di cinque percorsi per account, il CloudTrail percorso deve essere creato e gestito separatamente. (Vedi [Limiti in AWS CloudTrail](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/WhatIsCloudTrail-Limits.html).) Tuttavia, puoi includere molti bucket Amazon S3 in un singolo trail, in modo da poter creare il trail una sola volta e poi aggiungere bucket Amazon S3 per altre pipeline, se necessario. Incolla quanto segue nel secondo file di modello di esempio.
------
#### [ 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**
Quando utilizzi CloudFormation per creare queste risorse, la tua pipeline viene attivata quando i file nel tuo repository vengono creati o aggiornati.
Non è finita qui. Sebbene la pipeline sia stata creata, è necessario creare un secondo CloudFormation modello per la pipeline Amazon S3. Se non crei il secondo modello, la pipeline non avrà la funzionalità di rilevamento delle modifiche.
```
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"
}
}
}
}
...
```
## Migra le pipeline di polling per un'azione sorgente GitHub (tramite OAuth app) verso le connessioni
Puoi migrare un'azione sorgente GitHub (tramite OAuth app) per utilizzare le connessioni per il tuo repository esterno. Questo è il metodo di rilevamento delle modifiche consigliato per le pipeline con un'azione sorgente GitHub (tramite OAuth app).
Per una pipeline con un'azione di origine GitHub (tramite OAuth app), consigliamo di modificare la pipeline per utilizzare un'azione GitHub (tramite GitHub app) in modo da automatizzare il rilevamento delle modifiche. AWS CodeConnections Per ulteriori informazioni sull'utilizzo delle connessioni, consulta. [GitHub connessioni](connections-github.md)
### Creare una connessione a GitHub (console)
È possibile utilizzare la console per creare una connessione a GitHub.
#### Passaggio 1: sostituisci la tua azione GitHub (tramite OAuth app)
Utilizza la pagina di modifica della pipeline per sostituire l'azione GitHub (tramite OAuth app) con un'azione GitHub (tramite GitHub app).
**Per sostituire la tua azione GitHub (tramite OAuth app)**
1. Accedi alla CodePipeline console.
1. Scegli la tua pipeline e scegli **Modifica**. Scegli **Modifica fase nella fase** di origine. Viene visualizzato un messaggio che consiglia di aggiornare l'azione.
1. In **Action provider**, scegli **GitHub (tramite GitHub app)**.
1. Esegui una delle seguenti operazioni:
+ In **Connessione**, se non hai già creato una connessione al tuo provider, scegli **Connetti a GitHub**. Procedi al Passaggio 2: Crea una connessione a GitHub.
+ In **Connessione**, se hai già creato una connessione al tuo provider, scegli la connessione. Procedi al passaggio 3: Salva l'azione di origine per la tua connessione.
#### Passaggio 2: Creare una connessione a GitHub
Dopo aver scelto di creare la connessione, viene GitHub visualizzata la pagina **Connetti a**.
**Per creare una connessione a GitHub**
1. **Nelle impostazioni di GitHub connessione**, il nome della connessione viene visualizzato in **Nome connessione**.
In **GitHub App**, scegli l'installazione di un'app o scegli **Installa una nuova app** per crearne una.
**Nota**
È sufficiente installare una sola app per tutte le connessioni a un provider specifico. Se hai già installato l' GitHub app, sceglila e salta questo passaggio.
1. Se GitHub viene visualizzata la pagina di autorizzazione, accedi con le tue credenziali e scegli di continuare.
1. Nella pagina di installazione dell'app, un messaggio indica che l' AWS CodeStar app sta tentando di connettersi al tuo GitHub account.
**Nota**
L'app viene installata una sola volta per ogni GitHub account. Se hai già installato l'app, puoi scegliere **Configure (Configura)** per passare a una pagina di modifica per l'installazione dell'app oppure è possibile utilizzare il pulsante Indietro per tornare alla console.
1. Nella AWS CodeStar pagina di **installazione**, scegli **Installa**.
1. Nella GitHub pagina **Connect to**, viene visualizzato l'ID di connessione per la nuova installazione. Scegli **Connetti**.
#### Passaggio 3: Salva l'azione GitHub sorgente
Completa gli aggiornamenti nella pagina **Modifica azione** per salvare la nuova azione sorgente.
**Per salvare l'azione GitHub sorgente**
1. In **Repository**, inserisci il nome del tuo repository di terze parti. In **Branch**, inserisci il ramo in cui desideri che la pipeline rilevi le modifiche all'origine.
**Nota**
In **Repository**, digita `owner-name/repository-name` come mostrato in questo esempio:
```
my-account/my-repository
```
1. In Formato **di output degli artefatti, scegliete il formato** per gli artefatti.
+ **Per memorizzare gli artefatti di output derivanti dall' GitHub azione utilizzando il metodo predefinito, scegliete predefinito. CodePipeline** L'azione accede ai file dal GitHub repository e archivia gli artefatti in un file ZIP nel Pipeline Artifact Store.
+ Per archiviare un file JSON contenente un riferimento URL al repository in modo che le operazioni downstream possano eseguire direttamente comandi Git, scegliere **Full clone (Clone completo)**. Questa opzione può essere utilizzata solo dalle azioni a valle. CodeBuild
Se scegli questa opzione, dovrai aggiornare le autorizzazioni per il tuo ruolo di CodeBuild Project Service come mostrato in. [Aggiungi le autorizzazioni per le connessioni a Bitbucket, Enterprise Server o.com CodeBuild GitClone GitHub GitHub GitLab](troubleshooting.md#codebuild-role-connections) Per un tutorial che mostra come usare l'opzione **Full clone**, consulta. [Tutorial: usa il clone completo con una sorgente di GitHub pipeline](tutorials-github-gitclone.md)
1. In **Output Artifacts**, puoi mantenere il nome dell'artefatto di output per questa azione, ad esempio. `SourceArtifact` **Scegli **Fine per** chiudere la pagina Modifica azione.**
1. **Scegliete Fine** per chiudere la pagina di modifica dello stage. Scegliete **Salva** per chiudere la pagina di modifica della pipeline.
### Creare una connessione a GitHub (CLI)
È possibile utilizzare AWS Command Line Interface (AWS CLI) per creare una connessione a GitHub.
Per farlo, utilizzare il comando **create-connection**.
**Importante**
Per impostazione predefinita, una connessione creata tramite AWS CLI o AWS CloudFormation è in `PENDING` stato. Dopo aver creato una connessione con la CLI o CloudFormation, utilizza la console per modificare la connessione e definirne lo stato. `AVAILABLE`
**Per creare una connessione a GitHub**
1. Apri un terminale (Linux, macOS o Unix) o prompt dei comandi (Windows). Utilizzate il AWS CLI per eseguire il **create-connection** comando, specificando `--provider-type` e `--connection-name` per la connessione. In questo esempio, il nome del provider di terze parti è `GitHub` e il nome della connessione specificato è `MyConnection`.
```
aws codeconnections create-connection --provider-type GitHub --connection-name MyConnection
```
In caso di esito positivo, questo comando restituisce informazioni dell'ARN della connessione simili alle seguenti.
```
{
"ConnectionArn": "arn:aws:codeconnections:us-west-2:account_id:connection/aEXAMPLE-8aad-4d5d-8878-dfcab0bc441f"
}
```
1. Utilizzare la console per completare la connessione.
## Migra le pipeline di polling per un'azione sorgente GitHub (tramite OAuth app) sui webhook
Puoi migrare la tua pipeline per utilizzare i webhook per rilevare le modifiche nel tuo repository di origine. GitHub Questa migrazione ai webhook riguarda solo l'azione (tramite app). GitHub OAuth
+ **Console:** [Migra le pipeline di polling ai webhook (tramite app) (azioni di origine) (console) GitHub OAuth](#update-change-detection-console-github)
+ **CLI:** [Migrazione delle pipeline di polling ai webhook ((tramite OAuth app) GitHub (azioni di origine) (CLI)](#update-change-detection-cli-github)
+ **CloudFormation: ** [Aggiorna le pipeline per gli eventi push GitHub (tramite OAuth app) (azioni di origine) (modello)CloudFormation](#update-change-detection-cfn-github)
**Importante**
Durante la creazione di CodePipeline webhook, non utilizzate le vostre credenziali né riutilizzate lo stesso token segreto su più webhook. Per una sicurezza ottimale, genera un token segreto unico per ogni webhook creato. Il token segreto è una stringa arbitraria fornita dall'utente, che viene GitHub utilizzata per calcolare e firmare i payload del webhook a cui vengono inviati CodePipeline, per proteggere l'integrità e l'autenticità dei payload del webhook. L'utilizzo delle proprie credenziali o il riutilizzo dello stesso token su più webhook può portare a vulnerabilità di sicurezza.
### Migra le pipeline di polling ai webhook (tramite app) (azioni di origine) (console) GitHub OAuth
Per l'azione di origine GitHub (tramite OAuth app), puoi utilizzare la CodePipeline console per aggiornare la pipeline e utilizzare i webhook per rilevare le modifiche nel tuo repository di origine. GitHub
Segui questi passaggi per modificare una pipeline che utilizza invece il polling (controlli periodici). EventBridge Se vuoi creare una pipeline, consulta [Crea una pipeline, fasi e azioni](pipelines-create.md).
Quando utilizzi la console, il parametro `PollForSourceChanges` per la pipeline viene modificato per te. Il GitHub webhook viene creato e registrato automaticamente.
**Per modificare la fase di origine della pipeline**
1. Accedi Console di gestione AWS e apri la CodePipeline console all'[indirizzo http://console.aws.amazon. com/codesuite/codepipeline/home](https://console.aws.amazon.com/codesuite/codepipeline/home).
Vengono visualizzati i nomi di tutte le pipeline associate al tuo AWS account.
1. In **Name (Nome)**, scegliere il nome della pipeline da modificare. Questa operazione apre una visualizzazione dettagliata della pipeline. compreso lo stato di ciascuna delle operazioni in ciascuna fase della pipeline.
1. Nella pagina dei dettagli della pipeline, scegliere **Edit (Modifica)**.
1. In **Edit stage (Modifica fase)**, scegli l'icona di modifica sull'operazione di origine.
1. Espandi **le opzioni di rilevamento delle modifiche** e scegli **Usa Amazon CloudWatch Events per avviare automaticamente la mia pipeline quando si verifica una modifica (consigliato)**.
Viene visualizzato un messaggio che avvisa che CodePipeline crea un webhook GitHub per rilevare le modifiche all'origine: AWS CodePipeline creerà un webhook per te. È possibile effettuare l'opt-out nelle opzioni riportate di seguito. Scegliere **Aggiorna**. Oltre al webhook, CodePipeline crea quanto segue:
+ Un segreto, generato casualmente e utilizzato per autorizzare la connessione a. GitHub
+ L'URL del webhook, generato utilizzando l'endpoint pubblico della regione.
CodePipeline registra il webhook con. GitHub Questo consente di effettuare la sottoscrizione dell'URL per ricevere eventi del repository.
1. Al termine della modifica della pipeline, scegliere **Save pipeline changes (Salva modifiche pipeline)** per tornare alla pagina di riepilogo.
Viene visualizzato un messaggio con il nome del webhook da creare per la pipeline. Seleziona **Salva e continua**.
1. Per testare la tua azione, rilascia una modifica utilizzando il AWS CLI comando per confermare una modifica alla fonte specificata nella fase di origine della pipeline.
### Migrazione delle pipeline di polling ai webhook ((tramite OAuth app) GitHub (azioni di origine) (CLI)
Segui queste fasi per modificare una pipeline che utilizza polling (controlli periodici) in modo da usare invece un webhook. Se vuoi creare una pipeline, consulta [Crea una pipeline, fasi e azioni](pipelines-create.md).
Per creare una pipeline basata su eventi, dovrai modificare il parametro `PollForSourceChanges` della pipeline e quindi creare le seguenti risorse manualmente:
+ GitHub webhook e parametri di autorizzazione
**Per creare e registrare il webhook**
**Nota**
Quando si utilizza la CLI o CloudFormation si crea una pipeline e si aggiunge un webhook, è necessario disabilitare i controlli periodici. Per disabilitare i controlli periodici, devi aggiungere esplicitamente il parametro `PollForSourceChanges` e impostarlo su "false", come descritto nella procedura finale di seguito. Altrimenti, l'impostazione predefinita per una CLI o una CloudFormation pipeline è che il `PollForSourceChanges` valore predefinito è true e non viene visualizzato nell'output della struttura della pipeline. Per ulteriori informazioni sui valori predefiniti, vedere. PollForSourceChanges [Impostazioni valide per il `PollForSourceChanges` parametro](PollForSourceChanges-defaults.md)
1. In un editor di testo, creare e salvare un file JSON per il webhook da creare. Utilizza questo file di esempio per un webhook denominato `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. Chiama il comando **put-webhook** e includi i parametri `--cli-input` e `--region`.
Il comando di esempio seguente crea un webhook con il file JSON `webhook_json`.
```
aws codepipeline put-webhook --cli-input-json file://webhook_json.json --region "eu-central-1"
```
1. Nell'output mostrato in questo esempio, vengono restituiti l'URL e l'ARN per un webhook denominato `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"
}]
}
```
In questo esempio vengono aggiunte tag al webhook, inclusa la chiave di tag `Project` e il valore `ProjectA` al webhook. Per ulteriori informazioni sull'etichettatura delle risorse, vedere. CodePipeline [Applicazione di tag alle risorse](tag-resources.md)
1. Chiama il comando **register-webhook-with-third-party** e includi il parametro `--webhook-name`.
Il comando di esempio seguente registra un webhook denominato `my-webhook`.
```
aws codepipeline register-webhook-with-third-party --webhook-name my-webhook
```
**Per modificare il parametro della pipeline PollForSourceChanges**
**Importante**
Quando crei una pipeline con questo metodo, il parametro `PollForSourceChanges` è preimpostato su "true" se non viene impostato esplicitamente su "false". Quando aggiungi il rilevamento delle modifiche basato su eventi, devi aggiungere il parametro all'output e impostarlo su "false" per disabilitare il polling. In caso contrario, la pipeline si avvia due volte per una singola modifica dell'origine. Per informazioni dettagliate, vedi [Impostazioni valide per il `PollForSourceChanges` parametro](PollForSourceChanges-defaults.md).
1. Esegui il comando **get-pipeline** per copiare la struttura della pipeline in un file JSON. Ad esempio, per una pipeline denominata `MyFirstPipeline`, digitare il comando seguente:
```
aws codepipeline get-pipeline --name MyFirstPipeline >pipeline.json
```
Questo comando non restituisce alcun valore, ma nella directory in cui è stato eseguito dovrebbe comparire il file creato.
1. Apri il file JSON in qualsiasi editor di testo normale e modifica la fase di origine modificando o aggiungendo il parametro `PollForSourceChanges`. In questo esempio, per un repository denominato `UserGitHubRepo`, il parametro è impostato su `false`.
**Perché sto apportando questa modifica?** La modifica di questo parametro disattiva i controlli periodici, quindi è possibile utilizzare solo il rilevamento delle modifiche basato sugli eventi.
```
"configuration": {
"Owner": "name",
"Repo": "UserGitHubRepo",
"PollForSourceChanges": "false",
"Branch": "main",
"OAuthToken": "****"
},
```
1. Se utilizzi la struttura della pipeline recuperata utilizzando il comando **get-pipeline**, devi modificare la struttura del file JSON rimuovendo le righe `metadata` dal file. In caso contrario, il comando **update-pipeline** non è in grado di utilizzarlo. Rimuovi la sezione `"metadata"` dalla struttura della pipeline nel file JSON, inclusi `{ }` e i campi `"created"`, `"pipelineARN"` e `"updated"`.
Ad esempio, rimuovere dalla struttura le seguenti righe:
```
"metadata": {
"pipelineArn": "arn:aws:codepipeline:region:account-ID:pipeline-name",
"created": "date",
"updated": "date"
},
```
Salvare il file.
1. Per applicare le modifiche, eseguire il comando **update-pipeline**, specificando il file JSON della pipeline, in modo analogo al seguente:
**Importante**
Assicurarsi di includere `file://` prima del nome del file. Questo è obbligatorio in questo comando.
```
aws codepipeline update-pipeline --cli-input-json file://pipeline.json
```
Questo comando restituisce l'intera struttura della pipeline modificata.
**Nota**
Il comando **update-pipeline** arresta la pipeline. Se è in corso di elaborazione una versione durante l'esecuzione del comando **update-pipeline**, tale elaborazione viene arrestata. Per elaborare tale versione utilizzando la pipeline aggiornata, devi avviare manualmente la pipeline. Utilizza il comando **start-pipeline-execution** per avviare manualmente la pipeline.
### Aggiorna le pipeline per gli eventi push GitHub (tramite OAuth app) (azioni di origine) (modello)CloudFormation
Segui questi passaggi per aggiornare la pipeline (con una GitHub fonte) dai controlli periodici (polling) al rilevamento delle modifiche basato sugli eventi tramite webhook.
Per creare una pipeline basata sugli eventi con AWS CodeCommit, devi modificare il `PollForSourceChanges` parametro della pipeline e quindi aggiungere una risorsa webhook al tuo modello. GitHub
Se lo utilizzi CloudFormation per creare e gestire le tue pipeline, il tuo modello ha contenuti come i seguenti.
**Nota**
Nota la proprietà di configurazione `PollForSourceChanges` nella fase di origine. Se il modello non include questa proprietà, allora `PollForSourceChanges` è impostato su `true` per impostazione predefinita.
------
#### [ 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
}
]
},
...
```
------
**Per aggiungere parametri e creare un webhook nel modello**
Ti consigliamo vivamente di Gestione dei segreti AWS utilizzarlo per archiviare le tue credenziali. Se si utilizza Secrets Manager, è necessario avere già configurato e archiviato i parametri segreti in Secrets Manager. Questo esempio utilizza riferimenti dinamici a Secrets Manager per GitHub le credenziali del webhook. Per ulteriori informazioni, consulta [Utilizzo di riferimenti dinamici per specificare valori di modello](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/dynamic-references.html#dynamic-references-secretsmanager).
**Importante**
Quando si passano parametri segreti, non immettere il valore direttamente nel modello. Il valore viene reso come testo in chiaro ed è quindi leggibile. Per motivi di sicurezza, non utilizzate testo semplice nel CloudFormation modello per memorizzare le credenziali.
Quando si utilizza la CLI o CloudFormation si crea una pipeline e si aggiunge un webhook, è necessario disabilitare i controlli periodici.
**Nota**
Per disabilitare i controlli periodici, devi aggiungere esplicitamente il parametro `PollForSourceChanges` e impostarlo su "false", come descritto nella procedura finale di seguito. Altrimenti, l'impostazione predefinita per una CLI o una CloudFormation pipeline è che il `PollForSourceChanges` valore predefinito è true e non viene visualizzato nell'output della struttura della pipeline. Per ulteriori informazioni sui valori predefiniti, vedere. PollForSourceChanges [Impostazioni valide per il `PollForSourceChanges` parametro](PollForSourceChanges-defaults.md)
1. Nel modello, in `Resources`, aggiungi i parametri:
------
#### [ YAML ]
```
Parameters:
GitHubOwner:
Type: String
...
```
------
#### [ JSON ]
```
{
"Parameters": {
"BranchName": {
"Description": "GitHub branch name",
"Type": "String",
"Default": "main"
},
"GitHubOwner": {
"Type": "String"
},
...
```
------
1. Usa la `AWS::CodePipeline::Webhook` CloudFormation risorsa per aggiungere un webhook.
**Nota**
Il `TargetAction` specificato deve corrispondere alla proprietà `Name` dell'operazione di origine definita nella pipeline.
Se `RegisterWithThirdParty` è impostato su`true`, assicurati che l'utente associato a `OAuthToken` possa impostare gli ambiti richiesti. GitHub Il token e il webhook richiedono i seguenti ambiti: GitHub
+ `repo` - utilizzato per il controllo completo per leggere ed estrarre artefatti da repository pubblici e privati in una pipeline.
+ `admin:repo_hook` - utilizzato per il controllo completo di hook di repository.
Altrimenti, GitHub restituisce un 404. Per ulteriori informazioni sulla restituzione di un 404, consulta [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. Salva il modello aggiornato sul computer locale, quindi apri la CloudFormation console.
1. Seleziona lo stack e scegli **Create Change Set for Current Stack (Crea set di modifiche per lo stack corrente)**.
1. Carica il modello e quindi visualizza le modifiche elencate in CloudFormation. Queste sono le modifiche da apportare allo stack. Le nuove risorse dovrebbero essere visibili nell'elenco.
1. Scegli **Esegui**.
**Per modificare i parametri della PollForSourceChanges pipeline**
**Importante**
Quando crei una pipeline con questo metodo, il parametro `PollForSourceChanges` è preimpostato su "true" se non viene impostato esplicitamente su "false". Quando aggiungi il rilevamento delle modifiche basato su eventi, devi aggiungere il parametro all'output e impostarlo su "false" per disabilitare il polling. In caso contrario, la pipeline si avvia due volte per una singola modifica dell'origine. Per informazioni dettagliate, vedi [Impostazioni valide per il `PollForSourceChanges` parametro](PollForSourceChanges-defaults.md).
+ Nel modello, modifica `PollForSourceChanges` in `false`. Se non hai incluso `PollForSourceChanges` nella definizione della pipeline, aggiungilo e impostalo su "false".
**Perché sto apportando questa modifica?** La modifica di questo parametro in `false` disattiva i controlli periodici, in modo che sia possibile utilizzare solo il rilevamento delle modifiche basato su eventi.
------
#### [ 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**
Quando si creano queste risorse con CloudFormation, il webhook definito viene creato nel GitHub repository specificato. La pipeline si attiva alla conferma.
```
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
...
```