Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés.
# Migrar los canales de sondeo para utilizar la detección de cambios basada en eventos
AWS CodePipeline admite una entrega completa y end-to-end continua, lo que incluye iniciar tu canalización siempre que se produzca un cambio de código. Hay dos formas de iniciar la canalización tras un cambio de código: detección de cambios basada en eventos y sondeo. Recomendamos utilizar la detección de cambios basada en eventos para las canalizaciones.
Utilice los procedimientos que se incluyen aquí para migrar (actualizar) sus canalizaciones de sondeo al método de detección de cambios basada en eventos para su canalización.
El método de detección de cambios basado en eventos recomendado para las canalizaciones viene determinado por la fuente de la canalización, por ejemplo. CodeCommit En ese caso, por ejemplo, el proceso de sondeo tendría que migrar a la detección de cambios basada en eventos con. EventBridge
## Cómo migrar canalizaciones de sondeo
Para migrar canalizaciones de sondeo, determine sus canalizaciones de sondeo y, a continuación, determine el método recomendado de detección de cambios basada en eventos:
+ Siga los pasos que se indican en [Cómo ver las canalizaciones de sondeo de su cuenta](#update-change-detection-view-polling) para determinar sus canalizaciones de sondeo.
+ En la tabla, busque el tipo de origen de su canalización y, a continuación, elija el procedimiento con la implementación que desee usar para migrar su canalización de sondeo. Cada sección contiene varios métodos de migración, como el uso de la CLI o CloudFormation.
| Cómo migrar canalizaciones al método de detección de cambios recomendado | Origen de la canalización | Método recomendado de detección basada en eventos | Procedimientos de migración |
| --- | --- | --- | --- |
| AWS CodeCommit | EventBridge (recomendado). | Consulte [Migre los canales de sondeo con una fuente CodeCommit](#update-change-detection-codecommit). |
| Amazon S3 | EventBridge y el bucket está habilitado para las notificaciones de eventos (recomendado). | Consulte [Migración de canalizaciones de sondeo con un origen de S3 habilitado para los eventos](#update-change-detection-S3-event). |
| Amazon S3 | EventBridge y un AWS CloudTrail sendero. | Consulte [Migre las canalizaciones de sondeo con una fuente y CloudTrail un seguimiento de S3](#update-change-detection-S3). |
| GitHub (a través de GitHub la aplicación) | Conexiones (recomendado) | Consulte [Migre los canales de sondeo de una acción fuente GitHub (mediante una OAuth aplicación) a las conexiones](#update-change-detection-github-connection). |
| GitHub (a través de OAuth la aplicación) | Webhooks | Consulte [Migre los canales de sondeo de una acción fuente GitHub (mediante una OAuth aplicación) a webhooks](#update-change-detection-github-webhooks). |
**importante**
En el caso de las actualizaciones de configuración de las acciones de canalización aplicables, como las canalizaciones con una acción GitHub (a través de una OAuth aplicación), debes establecer explícitamente el `PollForSourceChanges` parámetro en *false* en la configuración de la acción de origen para evitar que una canalización sea sondeada. Como resultado, es posible configurar erróneamente una canalización mediante la detección de cambios basada en eventos *y* el sondeo, por ejemplo, configurando una EventBridge regla y omitiendo también el parámetro. `PollForSourceChanges` Esto se traduce en ejecuciones de canalizaciones duplicadas y la canalización se computa para los límites del número total de canalizaciones que realicen sondeos, lo que de forma predeterminada es mucho menor que las canalizaciones basadas en eventos. Para obtener más información, consulte [Cuotas en AWS CodePipeline](limits.md).
## Cómo ver las canalizaciones de sondeo de su cuenta
Como primer paso, utilice uno de los siguientes scripts para determinar qué canalizaciones de su cuenta están configuradas para el sondeo. Estas son las canalizaciones para migrar a la detección de cambios basada en eventos.
### Ver las canalizaciones de sondeo de la cuenta (script)
Siga estos pasos para determinar con un script las canalizaciones de su cuenta que utilizan el sondeo.
1. Abra una ventana de terminal y, a continuación, realice una de las operaciones siguientes:
+ **Ejecute el siguiente comando para crear un nuevo script denominado .sh. PollingPipelinesExtractor**
```
vi PollingPipelinesExtractor.sh
```
+ Para usar una secuencia de comandos de Python, ejecute el siguiente comando para crear una nueva secuencia de comandos de Python denominada **PollingPipelinesExtractor.py.**
```
vi PollingPipelinesExtractor.py
```
1. Copie y pegue el siguiente código en el **PollingPipelinesExtractor**script. Realice una de las siguientes acciones:
+ Copie y pegue el siguiente código en el script **PollingPipelinesExtractor.sh.**
```
#!/bin/bash
set +x
POLLING_PIPELINES=()
LAST_EXECUTED_DATES=()
NEXT_TOKEN=null
HAS_NEXT_TOKEN=true
if [[ $# -eq 0 ]] ; then
echo 'Please provide region name'
exit 0
fi
REGION=$1
while [ "$HAS_NEXT_TOKEN" != "false" ]; do
if [ "$NEXT_TOKEN" != "null" ];
then
LIST_PIPELINES_RESPONSE=$(aws codepipeline list-pipelines --region $REGION --next-token $NEXT_TOKEN)
else
LIST_PIPELINES_RESPONSE=$(aws codepipeline list-pipelines --region $REGION)
fi
LIST_PIPELINES=$(jq -r '.pipelines[].name' <<< "$LIST_PIPELINES_RESPONSE")
NEXT_TOKEN=$(jq -r '.nextToken' <<< "$LIST_PIPELINES_RESPONSE")
if [ "$NEXT_TOKEN" == "null" ];
then
HAS_NEXT_TOKEN=false
fi
for pipline_name in $LIST_PIPELINES
do
PIPELINE=$(aws codepipeline get-pipeline --name $pipline_name --region $REGION)
HAS_POLLABLE_ACTIONS=$(jq '.pipeline.stages[].actions[] | select(.actionTypeId.category == "Source") | select(.actionTypeId.owner == ("ThirdParty","AWS")) | select(.actionTypeId.provider == ("GitHub","S3","CodeCommit")) | select(.configuration.PollForSourceChanges == ("true",null))' <<< "$PIPELINE")
if [ ! -z "$HAS_POLLABLE_ACTIONS" ];
then
POLLING_PIPELINES+=("$pipline_name")
PIPELINE_EXECUTIONS=$(aws codepipeline list-pipeline-executions --pipeline-name $pipline_name --region $REGION)
LAST_EXECUTION=$(jq -r '.pipelineExecutionSummaries[0]' <<< "$PIPELINE_EXECUTIONS")
if [ "$LAST_EXECUTION" != "null" ];
then
LAST_EXECUTED_TIMESTAMP=$(jq -r '.startTime' <<< "$LAST_EXECUTION")
LAST_EXECUTED_DATE="$(date -r ${LAST_EXECUTED_TIMESTAMP%.*})"
else
LAST_EXECUTED_DATE="Not executed in last year"
fi
LAST_EXECUTED_DATES+=("$LAST_EXECUTED_DATE")
fi
done
done
fileName=$REGION-$(date +%s)
printf "| %-30s | %-30s |\n" "Polling Pipeline Name" "Last Executed Time"
printf "| %-30s | %-30s |\n" "_____________________" "__________________"
for i in "${!POLLING_PIPELINES[@]}"; do
printf "| %-30s | %-30s |\n" "${POLLING_PIPELINES[i]}" "${LAST_EXECUTED_DATES[i]}"
printf "${POLLING_PIPELINES[i]}," >> $fileName.csv
done
printf "\nSaving Polling Pipeline Names to file $fileName.csv."
```
+ Copie y pegue el siguiente código en el script **PollingPipelinesExtractor.py.**
```
import boto3
import sys
import time
import math
hasNextToken = True
nextToken = ""
pollablePipelines = []
lastExecutedTimes = []
if len(sys.argv) == 1:
raise Exception("Please provide region name.")
session = boto3.Session(profile_name='default', region_name=sys.argv[1])
codepipeline = session.client('codepipeline')
def is_pollable_action(action):
actionTypeId = action['actionTypeId']
configuration = action['configuration']
return actionTypeId['owner'] in {"AWS", "ThirdParty"} and actionTypeId['provider'] in {"GitHub", "CodeCommit", "S3"} and ('PollForSourceChanges' not in configuration or configuration['PollForSourceChanges'] == 'true')
def has_pollable_actions(pipeline):
hasPollableAction = False
pipelineDefinition = codepipeline.get_pipeline(name=pipeline['name'])['pipeline']
for action in pipelineDefinition['stages'][0]['actions']:
hasPollableAction = is_pollable_action(action)
if hasPollableAction:
break
return hasPollableAction
def get_last_executed_time(pipelineName):
pipelineExecutions=codepipeline.list_pipeline_executions(pipelineName=pipelineName)['pipelineExecutionSummaries']
if pipelineExecutions:
return pipelineExecutions[0]['startTime'].strftime("%A %m/%d/%Y, %H:%M:%S")
else:
return "Not executed in last year"
while hasNextToken:
if nextToken=="":
list_pipelines_response = codepipeline.list_pipelines()
else:
list_pipelines_response = codepipeline.list_pipelines(nextToken=nextToken)
if 'nextToken' in list_pipelines_response:
nextToken = list_pipelines_response['nextToken']
else:
hasNextToken= False
for pipeline in list_pipelines_response['pipelines']:
if has_pollable_actions(pipeline):
pollablePipelines.append(pipeline['name'])
lastExecutedTimes.append(get_last_executed_time(pipeline['name']))
fileName="{region}-{timeNow}.csv".format(region=sys.argv[1],timeNow=math.trunc(time.time()))
file = open(fileName, 'w')
print ("{:<30} {:<30} {:<30}".format('Polling Pipeline Name', '|','Last Executed Time'))
print ("{:<30} {:<30} {:<30}".format('_____________________', '|','__________________'))
for i in range(len(pollablePipelines)):
print("{:<30} {:<30} {:<30}".format(pollablePipelines[i], '|', lastExecutedTimes[i]))
file.write("{pipeline},".format(pipeline=pollablePipelines[i]))
file.close()
print("\nSaving Polling Pipeline Names to file {fileName}".format(fileName=fileName))
```
1. Deberá ejecutar el script para cada región en la que tenga canalizaciones. Para ejecutar el script, realice una de las siguientes operaciones:
+ Ejecute el siguiente comando para ejecutar el script denominado **PollingPipelinesExtractor.sh.** En este ejemplo, la región es us-west-2.
```
./PollingPipelinesExtractor.sh us-west-2
```
+ Para el script de Python, ejecute el siguiente comando para ejecutar el script de Python denominado **PollingPipelinesExtractor.py.** En este ejemplo, la región es us-west-2.
```
python3 PollingPipelinesExtractor.py us-west-2
```
En el siguiente ejemplo de salida del script, la región us-west-2 devolvió una lista de canalizaciones de sondeo y muestra la hora de la última ejecución de cada canalización.
```
% ./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...%
```
Analice la salida del script y, para cada canalización de la lista, actualice el origen de sondeo al método recomendado de detección de cambios basada en eventos.
**nota**
Sus canalizaciones de sondeo vienen determinadas por la configuración de acción de la canalización para el parámetro `PollForSourceChanges`. Si la configuración de la fuente de la canalización tiene el `PollForSourceChanges` parámetro omitido, el CodePipeline valor predeterminado es sondear tu repositorio para ver si hay cambios en la fuente. Este comportamiento es el mismo que si se incluye `PollForSourceChanges` y se establece en true. Para obtener más información, consulte los parámetros de configuración de la acción de origen de su canalización, como los parámetros de configuración de la acción de origen de Amazon S3, en [Referencia sobre la acción de origen de Amazon S3](action-reference-S3.md).
Tenga en cuenta que este script también genera un archivo.csv que contiene la lista de canalizaciones de sondeo de su cuenta y guarda el archivo.csv en la carpeta de trabajo actual.
## Migre los canales de sondeo con una fuente CodeCommit
Puede migrar su canal de sondeo para usarlo EventBridge para detectar cambios en su repositorio de CodeCommit origen o en su bucket de código fuente de Amazon S3.
**CodeCommit**-- En el caso de una canalización con una CodeCommit fuente, modifique la canalización para que la detección de cambios se automatice EventBridge. Elija uno de los siguientes métodos para implementar la migración:
+ **Consola: **[Migrar canales de sondeo (CodeCommit o fuente de Amazon S3) (consola)](#update-change-detection-console-codecommit-S3)
+ **CLI: **[Migrar los canales de sondeo (CodeCommit fuente) (CLI)](#update-change-detection-cli-codecommit)
+ **CloudFormation: ** [Migre los canales de sondeo (CodeCommit fuente) (CloudFormation plantilla)](#update-change-detection-cfn-codecommit)
### Migrar canales de sondeo (CodeCommit o fuente de Amazon S3) (consola)
Puede usar la CodePipeline consola para actualizar su canalización y EventBridge detectar cambios en su repositorio de CodeCommit origen o en su bucket de código fuente de Amazon S3.
**nota**
Cuando utilizas la consola para editar una canalización que tiene un repositorio de CodeCommit origen o un bucket de código fuente de Amazon S3, la regla y el rol de IAM se crean automáticamente. Si utilizas el AWS CLI para editar la canalización, debes crear tú mismo la EventBridge regla y el rol de IAM. Para obtener más información, consulte [CodeCommit acciones de origen y EventBridge](triggering.md).
Utilice estos pasos para editar una canalización que utiliza las comprobaciones periódicas. Si desea crear una canalización, consulte [Creación de una canalización, etapas y acciones](pipelines-create.md).
**Para editar la etapa de código fuente de la canalización**
1. Inicie sesión en la CodePipeline consola Consola de administración de AWS y ábrala en [http://console.aws.amazon. com/codesuite/codepipeline/home](https://console.aws.amazon.com/codesuite/codepipeline/home).
Se muestran los nombres de todas las canalizaciones asociadas a tu AWS cuenta.
1. En **Nombre**, elija el nombre de la canalización que desea editar. Esto abre una vista detallada de la canalización, que incluye el estado de cada una de las acciones en cada etapa de la canalización.
1. En la página de detalles de la canalización, elija **Edit**.
1. En la etapa **Edit (Editar)**, elija el icono de edición en la acción de código fuente.
1. Amplía **las opciones de detección de cambios** y selecciona **Usar CloudWatch eventos para iniciar automáticamente mi canalización cuando se produzca un cambio (recomendado).**
Aparece un mensaje que muestra la EventBridge regla que se va a crear para esta canalización. Elija **Actualizar**.
Si está actualizando una canalización que tiene origen en Amazon S3, aparecerá el mensaje siguiente. Elija **Actualizar**.
1. Cuando haya terminado de editar la canalización, elija **Save pipeline changes** para volver a la página de resumen.
Aparece un mensaje con el nombre de la EventBridge regla que se va a crear para tu canalización. Elija **Guardar y continuar**.
1. Para probar tu acción, publica un cambio utilizando la opción AWS CLI para confirmar un cambio en la fuente especificada en la etapa de origen de la canalización.
### Migrar los canales de sondeo (CodeCommit fuente) (CLI)
Siga estos pasos para editar una canalización que utiliza sondeos (comprobaciones periódicas) y usar una EventBridge regla para iniciar la canalización. Si desea crear una canalización, consulte [Creación de una canalización, etapas y acciones](pipelines-create.md).
Para crear una canalización basada en eventos CodeCommit, edita el `PollForSourceChanges` parámetro de la canalización y, a continuación, crea los siguientes recursos:
+ EventBridge evento
+ Rol de IAM para permitir que este evento inicie la canalización
**Para editar el PollForSourceChanges parámetro de tu canalización**
**importante**
Al crear una canalización con este método, el parámetro `PollForSourceChanges` se establece en true de forma predeterminada si no se establece explícitamente en false. Al añadir la detección de cambios basada en eventos, debe añadir el parámetro a la salida y establecerlo en false para deshabilitar el sondeo. De lo contrario, la canalización comienza dos veces para un único cambio en el código fuente. Para obtener más información, consulte [Configuración válida para el parámetro `PollForSourceChanges`](PollForSourceChanges-defaults.md).
1. Ejecute el comando **get-pipeline** para copiar la estructura de canalización en un archivo JSON. Por ejemplo, para una canalización denominada `MyFirstPipeline`, escriba el siguiente comando:
```
aws codepipeline get-pipeline --name MyFirstPipeline >pipeline.json
```
Este comando no devuelve nada, pero el archivo creado debería aparecer en el directorio en el que se ejecutó el comando.
1. Abra el archivo JSON en cualquier editor de texto sin formato y edite la etapa de origen cambiando el parámetro `PollForSourceChanges` por `false`, tal y como se muestra en este ejemplo.
**¿Por qué voy a hacer este cambio?** Al cambiar este parámetro a `false`, se desactivan las comprobaciones periódicas, por lo que únicamente puede utilizar la detección de cambios basada en eventos.
```
"configuration": {
"PollForSourceChanges": "false",
"BranchName": "main",
"RepositoryName": "MyTestRepo"
},
```
1. Si está trabajando con la estructura de la canalización recuperada mediante el comando **get-pipeline**, elimine las líneas `metadata` del archivo JSON. De lo contrario, el comando **update-pipeline** no puede utilizarlo. Elimine las líneas `"metadata": { }` y los campos `"updated"`, `"created"` y `"pipelineARN"`.
Por ejemplo, quite las siguientes líneas de la estructura:
```
"metadata": {
"pipelineArn": "arn:aws:codepipeline:region:account-ID:pipeline-name",
"created": "date",
"updated": "date"
},
```
Guarde el archivo.
1. Para aplicar los cambios, ejecute el comando **update-pipeline** especificando el archivo JSON:
**importante**
Asegúrese de incluir `file://` antes del nombre de archivo. Es obligatorio en este comando.
```
aws codepipeline update-pipeline --cli-input-json file://pipeline.json
```
Este comando devuelve la estructura completa de la canalización editada.
**nota**
El comando **update-pipeline** detiene la canalización. Si se está ejecutando una revisión en la canalización al ejecutar el comando **update-pipeline**, dicha ejecución se detiene. Debe iniciar manualmente la canalización para ejecutar dicha revisión en la canalización actualizada. Utilice el comando **`start-pipeline-execution`** para iniciar manualmente la canalización.
**Para crear una EventBridge CodeCommit regla con el origen y CodePipeline el destino del evento**
1. Agregue los permisos EventBridge para utilizarlos CodePipeline para invocar la regla. Para obtener más información, consulta [Uso de políticas basadas en recursos para Amazon](https://docs.aws.amazon.com/eventbridge/latest/userguide/eb-use-resource-based.html). EventBridge
1. Utilice el siguiente ejemplo para crear la política de confianza que permita EventBridge asumir la función de servicio. Ponga un nombre a la política de confianza `trustpolicyforEB.json`.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": "events.amazonaws.com"
},
"Action": "sts:AssumeRole"
}
]
}
```
------
1. Utilice el comando para crear el rol `Role-for-MyRule` y asocie la política de confianza.
```
aws iam create-role --role-name Role-for-MyRule --assume-role-policy-document file://trustpolicyforEB.json
```
1. Cree el JSON de la política de permisos, tal y como se muestra en este ejemplo para la canalización denominada `MyFirstPipeline`. Ponga un nombre a la política de permisos `permissionspolicyforEB.json`.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"codepipeline:StartPipelineExecution"
],
"Resource": [
"arn:aws:codepipeline:us-west-2:111122223333:MyFirstPipeline"
]
}
]
}
```
------
1. Utilice el siguiente comando para asociar la política de permisos `CodePipeline-Permissions-Policy-for-EB` al rol `Role-for-MyRule`.
**¿Por qué voy a hacer este cambio?** Al agregar esta política al rol, se crean permisos para EventBridge.
```
aws iam put-role-policy --role-name Role-for-MyRule --policy-name CodePipeline-Permissions-Policy-For-EB --policy-document file://permissionspolicyforEB.json
```
1. Llame al comando **put-rule** e incluya los parámetros `--name`, `--event-pattern` y `--role-arn`.
**¿Por qué voy a hacer este cambio?** Este comando permite que CloudFormation cree el evento.
El siguiente comando de ejemplo crea una regla llamada `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. Para añadirlo CodePipeline como destino, ejecuta el **put-targets** comando e incluye los siguientes parámetros:
+ El parámetro `--rule` se usa con el `rule_name` que creó con el comando **put-rule**.
+ El parámetro `--targets` se usa con el `Id` del destino de la lista de destinos y el `ARN` de la canalización de destino.
El siguiente comando de muestra especifica que, para la regla denominada `MyCodeCommitRepoRule`, el destino `Id` se compone del número uno, lo que indica que, en lo que puede ser una lista de destinos de la regla, se trata del destino 1. El comando de muestra también especifica un `ARN` de ejemplo para la canalización. La canalización se inicia cuando se produce algún cambio en el repositorio.
```
aws events put-targets --rule MyCodeCommitRepoRule --targets Id=1,Arn=arn:aws:codepipeline:us-west-2:80398EXAMPLE:TestPipeline
```
1. (Opcional) Para configurar un transformador de entrada con anulaciones de origen para un ID de imagen específico, utilice el siguiente fragmento de código JSON en el comando de la CLI. En el siguiente ejemplo, se configura una anulación donde:
+ `actionName` (`Source` en este ejemplo) es el valor dinámico, que se define en la creación de la canalización, no se deriva del evento de origen.
+ `revisionType` (`COMMIT_ID` en este ejemplo) es el valor dinámico, que se define en la creación de la canalización, no se deriva del evento de origen.
+ En este ejemplo`revisionValue`, < *revisionValue* > se deriva de la variable de evento de origen.
```
{
"Rule": "my-rule",
"Targets": [
{
"Id": "MyTargetId",
"Arn": "pipeline-ARN",
"InputTransformer": {
"sourceRevisions": {
"actionName": "Source",
"revisionType": "COMMIT_ID",
"revisionValue": ""
},
"variables": [
{
"name": "Branch_Name",
"value": "value"
}
]
}
}
]
}
```
### Migre los canales de sondeo (CodeCommit fuente) (CloudFormation plantilla)
Para crear una canalización basada en eventos AWS CodeCommit, edita el `PollForSourceChanges` parámetro de la canalización y, a continuación, agrega los siguientes recursos a la plantilla:
+ Una regla EventBridge
+ ¿Una función de IAM para su regla EventBridge
Si lo utilizas CloudFormation para crear y gestionar tus canalizaciones, la plantilla incluye contenido como el siguiente.
**nota**
La propiedad `Configuration` en la etapa de código fuente denominada `PollForSourceChanges`. Si dicha propiedad no está incluida en la plantilla, `PollForSourceChanges` se establece en `true` de forma predeterminada.
------
#### [ 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
}]
},
```
------
**Para actualizar tu CloudFormation plantilla de canalización y crear una regla EventBridge**
1. En la plantilla, en la sección`Resources`, usa el `AWS::IAM::Role` CloudFormation recurso para configurar la función de IAM que permite que tu evento inicie tu canalización. Esta entrada crea un rol que utiliza dos políticas:
+ La primera política permite asumir el rol.
+ La segunda política concede permisos para iniciar la canalización.
**¿Por qué voy a hacer este cambio?** Añadir el `AWS::IAM::Role` recurso permite CloudFormation crear permisos para EventBridge. Este recurso se añade a tu CloudFormation pila.
------
#### [ 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. En la plantilla, en`Resources`, usa el `AWS::Events::Rule` CloudFormation recurso para agregar una EventBridge regla. Este patrón de eventos crea un evento que monitoriza la introducción de cambios en su repositorio. Cuando EventBridge detecta un cambio en el estado del repositorio, la regla se invoca `StartPipelineExecution` en la canalización de destino.
**¿Por qué voy a hacer este cambio?** Añadir el `AWS::Events::Rule` recurso permite CloudFormation crear el evento. Este recurso se añade a tu CloudFormation pila.
------
#### [ 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. (Opcional) Para configurar un transformador de entrada con anulaciones de origen para un ID de imagen específico, utilice el siguiente fragmento de código YAML. En el siguiente ejemplo, se configura una anulación donde:
+ `actionName` (`Source` en este ejemplo) es el valor dinámico, que se define en la creación de la canalización, no se deriva del evento de origen.
+ `revisionType` (`COMMIT_ID` en este ejemplo) es el valor dinámico, que se define en la creación de la canalización, no se deriva del evento de origen.
+ En este ejemplo`revisionValue`, < *revisionValue* > se deriva de la variable de evento de origen.
+ Se especifican las variables de salida para `BranchName` y `Value`.
```
Rule: my-rule
Targets:
- Id: MyTargetId
Arn: pipeline-ARN
InputTransformer:
sourceRevisions:
actionName: Source
revisionType: COMMIT_ID
revisionValue:
variables:
- name: BranchName
value: value
```
1. Guarde la plantilla actualizada en el equipo local y, a continuación, abra la CloudFormation consola.
1. Seleccione la pila y luego elija **Create Change Set for Current Stack (Crear conjuntos de cambios para la pila actual)**.
1. Cargue la plantilla y, a continuación, consulte los cambios indicados en CloudFormation. Estos son los cambios que se realizan en la pila. Debería ver los nuevos recursos en la lista.
1. Elija **Ejecutar**.
**Para editar el PollForSourceChanges parámetro de tu canalización**
**importante**
En muchos casos, el parámetro `PollForSourceChanges` es true de forma predeterminada al crear una canalización. Al añadir la detección de cambios basada en eventos, debe añadir el parámetro a la salida y establecerlo en false para deshabilitar el sondeo. De lo contrario, la canalización comienza dos veces para un único cambio en el código fuente. Para obtener más información, consulte [Configuración válida para el parámetro `PollForSourceChanges`](PollForSourceChanges-defaults.md).
+ En la plantilla, cambie `PollForSourceChanges` por `false`. Si no ha incluido `PollForSourceChanges` en la definición de la canalización, añádalo y establézcalo en `false`.
**¿Por qué voy a hacer este cambio?** Al cambiar este parámetro a `false`, se desactivan las comprobaciones periódicas, por lo que únicamente puede utilizar la detección de cambios basada en eventos.
------
#### [ 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**
Cuando creas estos recursos con CloudFormation, tu canalización se activa cuando se crean o actualizan los archivos de tu repositorio. Este es el fragmento final de la plantilla:
```
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
}
]
},
...
```
## Migración de canalizaciones de sondeo con un origen de S3 habilitado para los eventos
En el caso de una canalización con una fuente de Amazon S3, modifique la canalización para que la detección de cambios se EventBridge automatice mediante y con un bucket de origen que esté habilitado para las notificaciones de eventos. Este es el método recomendado si utilizas la CLI o si quieres CloudFormation migrar tu canalización.
**nota**
Esto incluye el uso de un depósito que esté habilitado para las notificaciones de eventos, de modo que no sea necesario crear un CloudTrail registro independiente. Si utilizas la consola, se configurarán automáticamente una regla de evento y una CloudTrail ruta. Para los siguientes pasos, consulte [Migre las canalizaciones de sondeo con una fuente y CloudTrail un seguimiento de S3](#update-change-detection-S3).
+ **CLI: **[Migre los canales de sondeo con una fuente y un CloudTrail seguimiento (CLI) de S3](#update-change-detection-cli-S3)
+ **CloudFormation: **[Migre los canales de sondeo con una fuente y un seguimiento de CloudTrail S3 (CloudFormation plantilla)](#update-change-detection-cfn-s3)
### Migrar los canales de sondeo con origen de S3 habilitado para los eventos (CLI)
Sigue estos pasos para editar una canalización que utiliza sondeos (comprobaciones periódicas) y utilizar un evento en EventBridge su lugar. Si desea crear una canalización, consulte [Creación de una canalización, etapas y acciones](pipelines-create.md).
Para crear una canalización basada en eventos con Amazon S3, debe editar el parámetro `PollForSourceChanges` de la canalización y, a continuación, crear los siguientes recursos manualmente:
+ EventBridge regla de eventos
+ Función de IAM para permitir que el EventBridge evento inicie tu canalización
**Para crear una EventBridge regla con Amazon S3 como origen y CodePipeline destino del evento y aplicar la política de permisos**
1. Otorgue permisos EventBridge para utilizarlos CodePipeline para invocar la regla. Para obtener más información, consulta [Uso de políticas basadas en recursos para Amazon](https://docs.aws.amazon.com/eventbridge/latest/userguide/eb-use-resource-based.html). EventBridge
1. Utilice el siguiente ejemplo para crear la política de confianza que permite que EventBridge asuma el rol de servicio. Denomínelo `trustpolicyforEB.json`.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": "events.amazonaws.com"
},
"Action": "sts:AssumeRole"
}
]
}
```
------
1. Utilice el comando para crear el rol `Role-for-MyRule` y asocie la política de confianza.
**¿Por qué voy a hacer este cambio?** Al añadir esta política de confianza al rol, se crean permisos para EventBridge.
```
aws iam create-role --role-name Role-for-MyRule --assume-role-policy-document file://trustpolicyforEB.json
```
1. Cree el JSON de la política de permisos tal y como se muestra aquí para la canalización denominada `MyFirstPipeline`. Ponga un nombre a la política de permisos `permissionspolicyforEB.json`.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"codepipeline:StartPipelineExecution"
],
"Resource": [
"arn:aws:codepipeline:us-west-2:111122223333:MyFirstPipeline"
]
}
]
}
```
------
1. Utilice el siguiente comando para asociar la nueva política de permisos `CodePipeline-Permissions-Policy-for-EB` al rol `Role-for-MyRule` que ha creado.
```
aws iam put-role-policy --role-name Role-for-MyRule --policy-name CodePipeline-Permissions-Policy-For-EB --policy-document file://permissionspolicyforEB.json
```
1. Llame al comando **put-rule** e incluya los parámetros `--name`, `--event-pattern` y `--role-arn`.
El siguiente comando de ejemplo crea una regla denominada `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. Para añadirlo CodePipeline como objetivo, ejecuta el **put-targets** comando e incluye los parámetros `--rule` y`--targets`.
El siguiente comando especifica que, para la regla denominada `EnabledS3SourceRule`, el destino `Id` se compone del número uno, lo que indica que, en lo que puede ser una lista de destinos de la regla, se trata del destino 1. El comando también especifica un `ARN` de ejemplo para la canalización. La canalización se inicia cuando se produce algún cambio en el repositorio.
```
aws events put-targets --rule EnabledS3SourceRule --targets Id=codepipeline-AppPipeline,Arn=arn:aws:codepipeline:us-west-2:80398EXAMPLE:TestPipeline
```
**Para editar el PollForSourceChanges parámetro de tu canalización**
**importante**
Al crear una canalización con este método, el parámetro `PollForSourceChanges` se establece en true de forma predeterminada si no se establece explícitamente en false. Al añadir la detección de cambios basada en eventos, debe añadir el parámetro a la salida y establecerlo en false para deshabilitar el sondeo. De lo contrario, la canalización comienza dos veces para un único cambio en el código fuente. Para obtener más información, consulte [Configuración válida para el parámetro `PollForSourceChanges`](PollForSourceChanges-defaults.md).
1. Ejecute el comando **get-pipeline** para copiar la estructura de canalización en un archivo JSON. Por ejemplo, para una canalización denominada `MyFirstPipeline`, escriba el siguiente comando:
```
aws codepipeline get-pipeline --name MyFirstPipeline >pipeline.json
```
Este comando no devuelve nada, pero el archivo creado debería aparecer en el directorio en el que se ejecutó el comando.
1. Abra el archivo JSON en cualquier editor de texto sin formato y edite la etapa de código fuente cambiando el parámetro `PollForSourceChanges` del bucket denominado `amzn-s3-demo-source-bucket` a `false`, tal y como se muestra en este ejemplo.
**¿Por qué voy a hacer este cambio?** Al establecer este parámetro en `false`, se desactivan las comprobaciones periódicas, por lo que únicamente puede utilizar la detección de cambios basada en eventos.
```
"configuration": {
"S3Bucket": "amzn-s3-demo-source-bucket",
"PollForSourceChanges": "false",
"S3ObjectKey": "index.zip"
},
```
1. Si está trabajando con la estructura de la canalización recuperada mediante el comando **get-pipeline**, debe eliminar las líneas `metadata` del archivo JSON. De lo contrario, el comando **update-pipeline** no puede utilizarlo. Elimine las líneas `"metadata": { }` y los campos `"updated"`, `"created"` y `"pipelineARN"`.
Por ejemplo, quite las siguientes líneas de la estructura:
```
"metadata": {
"pipelineArn": "arn:aws:codepipeline:region:account-ID:pipeline-name",
"created": "date",
"updated": "date"
},
```
Guarde el archivo.
1. Para aplicar los cambios, ejecute el comando **update-pipeline** especificando el archivo JSON:
**importante**
Asegúrese de incluir `file://` antes del nombre de archivo. Es obligatorio en este comando.
```
aws codepipeline update-pipeline --cli-input-json file://pipeline.json
```
Este comando devuelve la estructura completa de la canalización editada.
**nota**
El comando **update-pipeline** detiene la canalización. Si se está ejecutando una revisión en la canalización al ejecutar el comando **update-pipeline**, dicha ejecución se detiene. Debe iniciar manualmente la canalización para ejecutar dicha revisión en la canalización actualizada. Utilice el comando **start-pipeline-execution** para iniciar manualmente la canalización.
### Migre los canales de sondeo con una fuente S3 habilitada para eventos (CloudFormation plantilla)
Este procedimiento es para una canalización en la que el bucket de origen tiene los eventos habilitados.
Utilice estos pasos para editar una canalización con origen en Amazon S3 que usa sondeos para que use la detección de cambios basada en eventos.
Para crear una canalización basada en eventos con Amazon S3, deberá editar el parámetro `PollForSourceChanges` de la canalización y, a continuación, añadir los siguientes recursos a su plantilla:
+ EventBridge regla y función de IAM para permitir que este evento inicie su canalización.
Si la utilizas CloudFormation para crear y gestionar tus canalizaciones, la plantilla incluye contenido como el siguiente.
**nota**
La propiedad `Configuration` en la etapa de código fuente denominada `PollForSourceChanges`. Si la plantilla no incluye esa propiedad, `PollForSourceChanges` se establece en `true` de forma predeterminada.
------
#### [ 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
}
]
},
...
```
------
**Para crear una EventBridge regla con Amazon S3 como origen y CodePipeline destino del evento y aplicar la política de permisos**
1. En la plantilla, en`Resources`, utilice el `AWS::IAM::Role` CloudFormation recurso para configurar la función de IAM que le permitirá a su evento iniciar su canalización. Esta entrada crea un rol que utiliza dos políticas:
+ La primera política permite asumir el rol.
+ La segunda política concede permisos para iniciar la canalización.
**¿Por qué voy a hacer este cambio?** Añadir `AWS::IAM::Role` un recurso permite CloudFormation crear permisos para EventBridge. Este recurso se añade a tu CloudFormation pila.
------
#### [ 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 el `AWS::Events::Rule` CloudFormation recurso para añadir una EventBridge regla. Este patrón de eventos crea un evento que monitoriza la creación o eliminación de objetos en el bucket de origen de Amazon S3. Además, incluya un objetivo de la canalización. Cuando se crea un objeto, esta regla invoca `StartPipelineExecution` en la canalización de destino.
**¿Por qué voy a hacer este cambio?** Añadir el `AWS::Events::Rule` recurso CloudFormation permite crear el evento. Este recurso se añade a tu CloudFormation pila.
------
#### [ 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. Guarde la plantilla actualizada en el equipo local y abra la consola de CloudFormation .
1. Seleccione la pila y luego elija **Create Change Set for Current Stack (Crear conjuntos de cambios para la pila actual)**.
1. Cargue su plantilla actualizada y, a continuación, consulte los cambios indicados en CloudFormation. Estos son los cambios que se realizarán en la pila. Debería ver los nuevos recursos en la lista.
1. Elija **Ejecutar**.
**Para editar el PollForSourceChanges parámetro de tu canalización**
**importante**
Al crear una canalización con este método, el parámetro `PollForSourceChanges` se establece en true de forma predeterminada si no se establece explícitamente en false. Al añadir la detección de cambios basada en eventos, debe añadir el parámetro a la salida y establecerlo en false para deshabilitar el sondeo. De lo contrario, la canalización comienza dos veces para un único cambio en el código fuente. Para obtener más información, consulte [Configuración válida para el parámetro `PollForSourceChanges`](PollForSourceChanges-defaults.md).
+ En la plantilla, cambie `PollForSourceChanges` por `false`. Si no ha incluido `PollForSourceChanges` en la definición de la canalización, añádalo y establézcalo en `false`.
**¿Por qué voy a hacer este cambio?** Al cambiar `PollForSourceChanges` a `false`, se desactivan las comprobaciones periódicas, por lo que únicamente puede utilizar la detección de cambios basada en eventos.
------
#### [ 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**
Al CloudFormation crear estos recursos, tu canalización se activa cuando se crean o actualizan los archivos de tu repositorio.
No se detenga aquí. Aunque se haya creado la canalización, debe crear una segunda CloudFormation plantilla para la canalización de Amazon S3. Si no crea la segunda plantilla, la canalización no tendrá ninguna funcionalidad de detección de cambios.
```
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"
}
]
}
```
## Migre las canalizaciones de sondeo con una fuente y CloudTrail un seguimiento de S3
En el caso de una canalización con una fuente de Amazon S3, modifique la canalización para que la detección de cambios se automatice EventBridge. Elija uno de los siguientes métodos para implementar la migración:
+ **Consola: **[Migrar canales de sondeo (CodeCommit o fuente de Amazon S3) (consola)](#update-change-detection-console-codecommit-S3)
+ **CLI: **[Migre los canales de sondeo con una fuente y un CloudTrail seguimiento (CLI) de S3](#update-change-detection-cli-S3)
+ **CloudFormation: **[Migre los canales de sondeo con una fuente y un seguimiento de CloudTrail S3 (CloudFormation plantilla)](#update-change-detection-cfn-s3)
### Migre los canales de sondeo con una fuente y un CloudTrail seguimiento (CLI) de S3
Siga estos pasos para editar una canalización que utiliza sondeos (comprobaciones periódicas) y, en EventBridge su lugar, utilizar un evento. Si desea crear una canalización, consulte [Creación de una canalización, etapas y acciones](pipelines-create.md).
Para crear una canalización basada en eventos con Amazon S3, debe editar el parámetro `PollForSourceChanges` de la canalización y, a continuación, crear los siguientes recursos manualmente:
+ AWS CloudTrail política de seguimiento, bucket y bucket que Amazon S3 puede utilizar para registrar los eventos.
+ EventBridge evento
+ Función de IAM para permitir que el EventBridge evento inicie tu canalización
**Para crear una AWS CloudTrail ruta y habilitar el registro**
Para usar el AWS CLI para crear un rastro, ejecute el **create-trail** comando y especifique:
+ El nombre del registro de seguimiento.
+ El bucket al que ya haya aplicado la política de bucket para AWS CloudTrail.
Para obtener más información, consulte [Crear una ruta con la interfaz de línea de AWS comandos](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/cloudtrail-create-and-update-a-trail-by-using-the-aws-cli.html).
1. Llame al comando **create-trail** e incluya los parámetros `--name` y `--s3-bucket-name`.
**¿Por qué voy a hacer este cambio?** Esto crea el registro de seguimiento de CloudTrail necesario para su bucket de origen de S3.
El comando siguiente utiliza `--name` y `--s3-bucket-name` para crear un registro de seguimiento llamado `my-trail` y un bucket llamado `amzn-s3-demo-source-bucket`.
```
aws cloudtrail create-trail --name my-trail --s3-bucket-name amzn-s3-demo-source-bucket
```
1. Use el comando **start-logging** e incluya el parámetro `--name`.
**¿Por qué voy a hacer este cambio?** Este comando inicia el CloudTrail registro del bucket de origen y envía los eventos a EventBridge.
Ejemplo:
El siguiente comando utiliza `--name` para iniciar el registro en un registro de seguimiento llamado `my-trail`.
```
aws cloudtrail start-logging --name my-trail
```
1. Llame al comando **put-event-selectors** e incluya los parámetros `--trail-name` y `--event-selectors`. Utilice los selectores de eventos para especificar que desea que su ruta registre los eventos de datos del bucket de origen y los envíe a la EventBridge regla.
**¿Por qué voy a hacer este cambio?** Este comando filtra eventos.
Ejemplo:
El siguiente comando utiliza `--trail-name` y `--event-selectors` para especificar eventos de datos para un bucket de origen y un prefijo llamados `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"] }] }]'
```
**Para crear una EventBridge regla con Amazon S3 como origen y CodePipeline destino del evento y aplicar la política de permisos**
1. Otorgue permisos EventBridge para utilizarlos CodePipeline para invocar la regla. Para obtener más información, consulta [Uso de políticas basadas en recursos para Amazon](https://docs.aws.amazon.com/eventbridge/latest/userguide/eb-use-resource-based.html). EventBridge
1. Utilice el siguiente ejemplo para crear la política de confianza que permita EventBridge asumir la función de servicio. Denomínelo `trustpolicyforEB.json`.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": "events.amazonaws.com"
},
"Action": "sts:AssumeRole"
}
]
}
```
------
1. Utilice el comando para crear el rol `Role-for-MyRule` y asocie la política de confianza.
**¿Por qué voy a hacer este cambio?** Al agregar esta política de confianza al rol, se crean permisos para EventBridge.
```
aws iam create-role --role-name Role-for-MyRule --assume-role-policy-document file://trustpolicyforEB.json
```
1. Cree el JSON de la política de permisos tal y como se muestra aquí para la canalización denominada `MyFirstPipeline`. Ponga un nombre a la política de permisos `permissionspolicyforEB.json`.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"codepipeline:StartPipelineExecution"
],
"Resource": [
"arn:aws:codepipeline:us-west-2:111122223333:MyFirstPipeline"
]
}
]
}
```
------
1. Utilice el siguiente comando para asociar la nueva política de permisos `CodePipeline-Permissions-Policy-for-EB` al rol `Role-for-MyRule` que ha creado.
```
aws iam put-role-policy --role-name Role-for-MyRule --policy-name CodePipeline-Permissions-Policy-For-EB --policy-document file://permissionspolicyforEB.json
```
1. Llame al comando **put-rule** e incluya los parámetros `--name`, `--event-pattern` y `--role-arn`.
El siguiente comando de ejemplo crea una regla denominada `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. Para añadirlo CodePipeline como destino, ejecuta el **put-targets** comando e incluye los `--targets` parámetros `--rule` y.
El siguiente comando especifica que, para la regla denominada `MyS3SourceRule`, el destino `Id` se compone del número uno, lo que indica que, en lo que puede ser una lista de destinos de la regla, se trata del destino 1. El comando también especifica un `ARN` de ejemplo para la canalización. La canalización se inicia cuando se produce algún cambio en el repositorio.
```
aws events put-targets --rule MyS3SourceRule --targets Id=1,Arn=arn:aws:codepipeline:us-west-2:80398EXAMPLE:TestPipeline
```
1. (Opcional) Para configurar un transformador de entrada con anulaciones de origen para un ID de imagen específico, utilice el siguiente fragmento de código JSON en el comando de la CLI. En el siguiente ejemplo, se configura una anulación donde:
+ `actionName` (`Source` en este ejemplo) es el valor dinámico, que se define en la creación de la canalización, no se deriva del evento de origen.
+ `revisionType` (`S3_OBJECT_VERSION_ID` en este ejemplo) es el valor dinámico, que se define en la creación de la canalización, no se deriva del evento de origen.
+ En este ejemplo`revisionValue`, < *revisionValue* > se deriva de la variable de evento de origen.
```
{
"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": ""
}
}
}
}
]
}
```
**Para editar el PollForSourceChanges parámetro de tu canalización**
**importante**
Al crear una canalización con este método, el parámetro `PollForSourceChanges` se establece en true de forma predeterminada si no se establece explícitamente en false. Al añadir la detección de cambios basada en eventos, debe añadir el parámetro a la salida y establecerlo en false para deshabilitar el sondeo. De lo contrario, la canalización comienza dos veces para un único cambio en el código fuente. Para obtener más información, consulte [Configuración válida para el parámetro `PollForSourceChanges`](PollForSourceChanges-defaults.md).
1. Ejecute el comando **get-pipeline** para copiar la estructura de canalización en un archivo JSON. Por ejemplo, para una canalización denominada `MyFirstPipeline`, escriba el siguiente comando:
```
aws codepipeline get-pipeline --name MyFirstPipeline >pipeline.json
```
Este comando no devuelve nada, pero el archivo creado debería aparecer en el directorio en el que se ejecutó el comando.
1. Abra el archivo JSON en cualquier editor de texto sin formato y edite la etapa de código fuente cambiando el parámetro `PollForSourceChanges` del bucket denominado `amzn-s3-demo-source-bucket` a `false`, tal y como se muestra en este ejemplo.
**¿Por qué voy a hacer este cambio?** Al establecer este parámetro en `false`, se desactivan las comprobaciones periódicas, por lo que únicamente puede utilizar la detección de cambios basada en eventos.
```
"configuration": {
"S3Bucket": "amzn-s3-demo-source-bucket",
"PollForSourceChanges": "false",
"S3ObjectKey": "index.zip"
},
```
1. Si está trabajando con la estructura de la canalización recuperada mediante el comando **get-pipeline**, debe eliminar las líneas `metadata` del archivo JSON. De lo contrario, el comando **update-pipeline** no puede utilizarlo. Elimine las líneas `"metadata": { }` y los campos `"updated"`, `"created"` y `"pipelineARN"`.
Por ejemplo, quite las siguientes líneas de la estructura:
```
"metadata": {
"pipelineArn": "arn:aws:codepipeline:region:account-ID:pipeline-name",
"created": "date",
"updated": "date"
},
```
Guarde el archivo.
1. Para aplicar los cambios, ejecute el comando **update-pipeline** especificando el archivo JSON:
**importante**
Asegúrese de incluir `file://` antes del nombre de archivo. Es obligatorio en este comando.
```
aws codepipeline update-pipeline --cli-input-json file://pipeline.json
```
Este comando devuelve la estructura completa de la canalización editada.
**nota**
El comando **update-pipeline** detiene la canalización. Si se está ejecutando una revisión en la canalización al ejecutar el comando **update-pipeline**, dicha ejecución se detiene. Debe iniciar manualmente la canalización para ejecutar dicha revisión en la canalización actualizada. Utilice el comando **start-pipeline-execution** para iniciar manualmente la canalización.
### Migre los canales de sondeo con una fuente y un seguimiento de CloudTrail S3 (CloudFormation plantilla)
Utilice estos pasos para editar una canalización con origen en Amazon S3 que usa sondeos para que use la detección de cambios basada en eventos.
Para crear una canalización basada en eventos con Amazon S3, deberá editar el parámetro `PollForSourceChanges` de la canalización y, a continuación, añadir los siguientes recursos a su plantilla:
+ EventBridge requiere que se registren todos los eventos de Amazon S3. Debe crear un registro de seguimiento de AWS CloudTrail , un bucket y una política de bucket que Amazon S3 pueda usar para registrar los eventos que se produzcan. Para obtener más información, consulte [Registro de eventos de datos](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/logging-data-events-with-cloudtrail.html) y [Registro de eventos de gestión para registros de seguimiento](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/logging-management-events-with-cloudtrail.html).
+ EventBridge regla y función de IAM para permitir que este evento inicie nuestra canalización.
Si la utilizas CloudFormation para crear y gestionar tus canalizaciones, tu plantilla incluye contenido como el siguiente.
**nota**
La propiedad `Configuration` en la etapa de código fuente denominada `PollForSourceChanges`. Si la plantilla no incluye esa propiedad, `PollForSourceChanges` se establece en `true` de forma predeterminada.
------
#### [ 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
}
]
},
...
```
------
**Para crear una EventBridge regla con Amazon S3 como origen y CodePipeline destino del evento y aplicar la política de permisos**
1. En la plantilla, en`Resources`, utilice el `AWS::IAM::Role` CloudFormation recurso para configurar la función de IAM que le permitirá a su evento iniciar su canalización. Esta entrada crea un rol que utiliza dos políticas:
+ La primera política permite asumir el rol.
+ La segunda política concede permisos para iniciar la canalización.
**¿Por qué voy a hacer este cambio?** Añadir `AWS::IAM::Role` un recurso permite CloudFormation crear permisos para EventBridge. Este recurso se añade a tu CloudFormation pila.
------
#### [ 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 el `AWS::Events::Rule` CloudFormation recurso para añadir una EventBridge regla. Este patrón de eventos crea un evento que monitoriza `CopyObject`, `PutObject` y `CompleteMultipartUpload` en el bucket de origen de Amazon S3. Además, incluya un objetivo de la canalización. Cuando se produce `CopyObject`, `PutObject` o `CompleteMultipartUpload`, esta regla invoca `StartPipelineExecution` en la canalización de destino.
**¿Por qué voy a hacer este cambio?** Añadir el `AWS::Events::Rule` recurso CloudFormation permite crear el evento. Este recurso se añade a tu CloudFormation pila.
------
#### [ 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. Añada este fragmento a su primera plantilla para permitir la funcionalidad de pila cruzada:
------
#### [ 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. (Opcional) Para configurar un transformador de entrada con anulaciones de origen para un ID de imagen específico, utilice el siguiente fragmento de código YAML. En el siguiente ejemplo, se configura una anulación donde:
+ `actionName` (`Source` en este ejemplo) es el valor dinámico, que se define en la creación de la canalización, no se deriva del evento de origen.
+ `revisionType` (`S3_OBJECT_VERSION_ID` en este ejemplo) es el valor dinámico, que se define en la creación de la canalización, no se deriva del evento de origen.
+ En este ejemplo`revisionValue`, < *revisionValue* > se deriva de la variable de evento de origen.
```
---
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. Guarde la plantilla actualizada en el equipo local y abra la CloudFormation consola.
1. Seleccione la pila y luego elija **Create Change Set for Current Stack (Crear conjuntos de cambios para la pila actual)**.
1. Cargue su plantilla actualizada y, a continuación, consulte los cambios indicados en CloudFormation. Estos son los cambios que se realizarán en la pila. Debería ver los nuevos recursos en la lista.
1. Elija **Ejecutar**.
**Para editar el PollForSourceChanges parámetro de tu canalización**
**importante**
Al crear una canalización con este método, el parámetro `PollForSourceChanges` se establece en true de forma predeterminada si no se establece explícitamente en false. Al añadir la detección de cambios basada en eventos, debe añadir el parámetro a la salida y establecerlo en false para deshabilitar el sondeo. De lo contrario, la canalización comienza dos veces para un único cambio en el código fuente. Para obtener más información, consulte [Configuración válida para el parámetro `PollForSourceChanges`](PollForSourceChanges-defaults.md).
+ En la plantilla, cambie `PollForSourceChanges` por `false`. Si no ha incluido `PollForSourceChanges` en la definición de la canalización, añádalo y establézcalo en `false`.
**¿Por qué voy a hacer este cambio?** Al cambiar `PollForSourceChanges` a `false`, se desactivan las comprobaciones periódicas, por lo que únicamente puede utilizar la detección de cambios basada en eventos.
------
#### [ 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
}
```
------
**Para crear una segunda plantilla para los CloudTrail recursos de su canalización de Amazon S3**
+ En una plantilla independiente, en`Resources`, utilice los `AWS::CloudTrail::Trail` CloudFormation recursos `AWS::S3::Bucket``AWS::S3::BucketPolicy`, y para proporcionar una definición de bucket y un seguimiento sencillos CloudTrail.
**¿Por qué voy a hacer este cambio?** Dado el límite actual de cinco senderos por cuenta, el CloudTrail sendero debe crearse y administrarse por separado. (Consulte [los límites en AWS CloudTrail](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/WhatIsCloudTrail-Limits.html).) Sin embargo, puede incluir muchos buckets de Amazon S3 en un único registro de seguimiento, por lo que puede crear el registro de seguimiento una vez y, a continuación, añadir buckets de Amazon S3 para otras canalizaciones según sea necesario. Pegue lo siguiente en el segundo archivo de plantilla de ejemplo.
------
#### [ 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**
Al CloudFormation crear estos recursos, la canalización se activa cuando se crean o actualizan los archivos del repositorio.
No se detenga aquí. Aunque se haya creado la canalización, debe crear una segunda CloudFormation plantilla para la canalización de Amazon S3. Si no crea la segunda plantilla, la canalización no tendrá ninguna funcionalidad de detección de cambios.
```
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"
}
}
}
}
...
```
## Migre los canales de sondeo de una acción fuente GitHub (mediante una OAuth aplicación) a las conexiones
Puedes migrar una acción de origen GitHub (mediante una OAuth aplicación) para usar las conexiones de tu repositorio externo. Este es el método de detección de cambios recomendado para las canalizaciones con una acción de origen GitHub (mediante una OAuth aplicación).
En el caso de una canalización con una acción de origen GitHub (a través de una OAuth aplicación), te recomendamos modificar la canalización para usar una acción GitHub (a través de una GitHub aplicación), de forma que la detección de cambios se realice de forma automática. AWS CodeConnections Para obtener más información sobre cómo trabajar con conexiones, consulte [GitHub conexiones](connections-github.md).
### Crea una conexión a GitHub (consola)
Puede usar la consola para crear una conexión a GitHub.
#### Paso 1: reemplaza tu acción GitHub (a través de OAuth la aplicación)
Usa la página de edición del proceso para reemplazar tu acción GitHub (a través de OAuth la aplicación) por una acción GitHub (a través de GitHub la aplicación).
**Para reemplazar tu acción GitHub (a través de OAuth la aplicación)**
1. Inicia sesión en la CodePipeline consola.
1. Seleccione su canalización y, a continuación, elija **Editar**. Elija **Editar etapa** en la etapa de fuente. Aparece un mensaje en el que se recomienda actualizar la acción.
1. En **Action provider**, selecciona **GitHub (a través de GitHub la aplicación)**.
1. Realice una de las siguientes acciones:
+ En **Conexión**, si aún no ha creado una conexión con su proveedor, elija **Conectar a GitHub**. Continúe con el paso 2: cree una conexión a GitHub.
+ En **Conexión**, si ya ha creado una conexión con su proveedor, seleccione la conexión. Continúe con el Paso 3: Guardar la acción de origen para la conexión.
#### Paso 2: Crea una conexión a GitHub
Una vez que haya decidido crear la conexión, aparecerá la GitHub página **Conectar a**.
**Para crear una conexión a GitHub**
1. En la **configuración de la GitHub conexión**, el nombre de la conexión se muestra en **Nombre de la conexión**.
En **GitHub Aplicaciones**, selecciona la instalación de una aplicación o selecciona **Instalar una nueva aplicación** para crear una.
**nota**
Se instala una aplicación para todas las conexiones a un proveedor en particular. Si ya ha instalado la GitHub aplicación, selecciónela y omita este paso.
1. Si GitHub aparece la página de autorización, inicie sesión con sus credenciales y, a continuación, elija continuar.
1. En la página de instalación de la aplicación, aparece un mensaje que indica que la AWS CodeStar aplicación está intentando conectarse a tu GitHub cuenta.
**nota**
Solo instalas la aplicación una vez para cada GitHub cuenta. Si instaló la aplicación previamente, puede elegir **Configurar** para dirigirse a una página de modificación para la instalación de la aplicación o puede utilizar el botón Atrás para volver a la consola.
1. En la página **Instalar AWS CodeStar**, seleccione **Instalar**.
1. En la GitHub página **Conectar a**, se muestra el ID de conexión de la nueva instalación. Elija **Conectar**.
#### Paso 3: Guarda la acción GitHub de origen
Complete las actualizaciones en la página **Editar acción** para guardar la nueva acción fuente.
**Para guardar la acción GitHub de origen**
1. En **Repositorio**, introduzca el nombre del repositorio de terceros. En **Ramificación**, introduzca la ramificación en la que desea que la canalización detecte los cambios de origen.
**nota**
En **Repositorio**, escriba `owner-name/repository-name` como se muestra en este ejemplo:
```
my-account/my-repository
```
1. En **Formato del artefacto de salida**, debe elegir el formato de los artefactos.
+ Para almacenar los artefactos de salida de la GitHub acción mediante el método predeterminado, elija **CodePipelinedefault**. La acción accede a los archivos del GitHub repositorio y almacena los artefactos en un archivo ZIP en el almacén de artefactos de Pipeline.
+ Para almacenar un archivo JSON que contiene una referencia URL al repositorio de manera que las acciones posteriores puedan ejecutar comandos Git directamente, elija **Clonación completa**. Esta opción solo la pueden utilizar las acciones CodeBuild posteriores.
Si elige esta opción, tendrá que actualizar los permisos de su función de servicio de CodeBuild proyectos, tal y como se muestra en [Añade CodeBuild GitClone permisos para las conexiones a Bitbucket, Enterprise Server o .com GitHub GitHub GitLab](troubleshooting.md#codebuild-role-connections) la siguiente. Para ver un tutorial que muestra cómo utilizar la opción **Clonación completa**, consulte [Tutorial: Utilice un clon completo con una fuente de GitHub canalización](tutorials-github-gitclone.md).
1. En **Artefactos de salida**, puede conservar el nombre del artefacto de salida para esta acción, por ejemplo `SourceArtifact`. Seleccione **Listo** para cerrar la página **Editar acción**.
1. Seleccione **Listo** para cerrar la página de edición de etapa. Seleccione **Guardar** para cerrar la página de edición de la canalización.
### Crear una conexión a GitHub (CLI)
Puede usar AWS Command Line Interface (AWS CLI) para crear una conexión a GitHub.
Para ello, utilice el comando **create-connection**.
**importante**
Una conexión creada a través del AWS CLI o AWS CloudFormation está en `PENDING` estado de forma predeterminada. Después de crear una conexión con la CLI o CloudFormation, utilice la consola para editar la conexión y establecer su estado`AVAILABLE`.
**Para crear una conexión a GitHub**
1. Abra un terminal (Linux, macOS o Unix) o un símbolo del sistema (Windows). Utilice el AWS CLI para ejecutar el **create-connection** comando, especificando el `--provider-type` y `--connection-name` para la conexión. En este ejemplo, el nombre del proveedor de terceros es `GitHub` y el nombre especificado para la conexión es `MyConnection`.
```
aws codeconnections create-connection --provider-type GitHub --connection-name MyConnection
```
Si se ejecuta correctamente, este comando devuelve la información del ARN de la conexión, que será similar a lo siguiente.
```
{
"ConnectionArn": "arn:aws:codeconnections:us-west-2:account_id:connection/aEXAMPLE-8aad-4d5d-8878-dfcab0bc441f"
}
```
1. Utilice la consola para completar la conexión.
## Migre los canales de sondeo de una acción fuente GitHub (mediante una OAuth aplicación) a webhooks
Puedes migrar tu canalización para usar webhooks y detectar cambios en tu GitHub repositorio de origen. Esta migración a webhooks es solo para la acción GitHub (a través de OAuth la aplicación).
+ **Consola: **[Migre los canales de sondeo a webhooks (mediante OAuth aplicaciones) GitHub (acciones fuente) (consola)](#update-change-detection-console-github)
+ **CLI: **[Migre los canales de sondeo a webhooks GitHub (a través de OAuth la aplicación) (acciones fuente) (CLI)](#update-change-detection-cli-github)
+ **CloudFormation: ** [Actualiza las canalizaciones para los eventos push GitHub (a través de OAuth la aplicación) (acciones fuente) (CloudFormation plantilla)](#update-change-detection-cfn-github)
**importante**
Al crear CodePipeline webhooks, no utilices tus propias credenciales ni reutilices el mismo token secreto en varios webhooks. Para garantizar una seguridad óptima, genere un token secreto único para cada webhook que vaya a crear. El token secreto es una cadena arbitraria que tú proporcionas y que se GitHub utiliza para calcular y firmar las cargas útiles de los webhooks a las que se envían CodePipeline, a fin de proteger la integridad y la autenticidad de las cargas útiles de los webhooks. Usar sus propias credenciales o reutilizar el mismo token en varios webhooks puede provocar vulnerabilidades de seguridad.
### Migre los canales de sondeo a webhooks (mediante OAuth aplicaciones) GitHub (acciones fuente) (consola)
Para la acción de origen GitHub (a través de la OAuth aplicación), puedes usar la CodePipeline consola para actualizar tu canalización y usar webhooks para detectar cambios en tu GitHub repositorio de origen.
Sigue estos pasos para editar una canalización que utiliza sondeos (comprobaciones periódicas) y utilizarla EventBridge en su lugar. Si desea crear una canalización, consulte [Creación de una canalización, etapas y acciones](pipelines-create.md).
Al utilizar la consola, el parámetro `PollForSourceChanges` de la canalización se cambia automáticamente. El GitHub webhook se crea y se registra para ti.
**Para editar la etapa de código fuente de la canalización**
1. Inicie sesión en la CodePipeline consola Consola de administración de AWS y ábrala en [http://console.aws.amazon. com/codesuite/codepipeline/home](https://console.aws.amazon.com/codesuite/codepipeline/home).
Se muestran los nombres de todas las canalizaciones asociadas a tu AWS cuenta.
1. En **Nombre**, elija el nombre de la canalización que desea editar. Esto abre una vista detallada de la canalización, que incluye el estado de cada una de las acciones en cada etapa de la canalización.
1. En la página de detalles de la canalización, elija **Edit**.
1. En la etapa **Edit (Editar)**, elija el icono de edición en la acción de código fuente.
1. Amplía **las opciones de detección de cambios** y selecciona **Usar Amazon CloudWatch Events para iniciar automáticamente mi canalización cuando se produzca un cambio (recomendado)**.
Aparece un mensaje que indica que se CodePipeline crea un webhook GitHub para detectar los cambios en la fuente: AWS CodePipeline se creará un webhook automáticamente. Puede renunciar en las siguientes opciones. Elija **Actualizar**. Además del webhook, CodePipeline crea lo siguiente:
+ Un secreto, generado aleatoriamente y utilizado para autorizar la conexión a GitHub.
+ La URL de webhook se genera utilizando el punto de enlace público correspondiente a la región.
CodePipeline registra el webhook con GitHub. De este modo se suscribe la URL para recibir eventos del repositorio.
1. Cuando haya terminado de editar la canalización, elija **Save pipeline changes** para volver a la página de resumen.
Aparece un mensaje que muestra el nombre del webhook que se creará para la canalización. Elija **Guardar y continuar**.
1. Para probar tu acción, publica un cambio utilizando el AWS CLI para confirmar un cambio en la fuente especificada en la fase de origen de la canalización.
### Migre los canales de sondeo a webhooks GitHub (a través de OAuth la aplicación) (acciones fuente) (CLI)
Siga estos pasos para editar una canalización que utiliza comprobaciones periódicas para utilizar un webhook en su lugar. Si desea crear una canalización, consulte [Creación de una canalización, etapas y acciones](pipelines-create.md).
Para crear una canalización basada en eventos, debe editar el parámetro `PollForSourceChanges` de la canalización y, a continuación, crear los siguientes recursos manualmente:
+ GitHub webhook y parámetros de autorización
**Para crear y registrar su webhook**
**nota**
Cuando utilizas la CLI o CloudFormation para crear una canalización y añadir un webhook, debes deshabilitar las comprobaciones periódicas. Para deshabilitar las comprobaciones periódicas, debe añadir de forma explícita el parámetro `PollForSourceChanges` y establecerlo en false, tal y como se detalla en el último procedimiento que viene a continuación. De lo contrario, el valor predeterminado de una CLI o una CloudFormation canalización es que el `PollForSourceChanges` valor predeterminado sea verdadero y no se muestre en la salida de la estructura de la canalización. Para obtener más información sobre los PollForSourceChanges valores predeterminados, consulte. [Configuración válida para el parámetro `PollForSourceChanges`](PollForSourceChanges-defaults.md)
1. En un editor de texto, cree y guarde un archivo JSON para el webhook que desea crear. Utilice este archivo de ejemplo para un webhook denominado `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. Llame al comando **put-webhook** e incluya los parámetros `--cli-input` y `--region`.
El comando de muestra siguiente crea un webhook con el archivo JSON `webhook_json`.
```
aws codepipeline put-webhook --cli-input-json file://webhook_json.json --region "eu-central-1"
```
1. En la salida que se muestra en este ejemplo, se devuelven la URL y el ARN de un webhook denominado `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"
}]
}
```
En este ejemplo, se etiqueta el webhook con la clave `Project` y el valor `ProjectA`. Para obtener más información sobre cómo etiquetar recursos CodePipeline, consulte. [Etiquetado de recursos](tag-resources.md)
1. Use el comando **register-webhook-with-third-party** e incluya el parámetro `--webhook-name`.
El comando de muestra siguiente registra un webhook denominado `my-webhook`.
```
aws codepipeline register-webhook-with-third-party --webhook-name my-webhook
```
**Para editar el parámetro de tu canalización PollForSourceChanges**
**importante**
Al crear una canalización con este método, el parámetro `PollForSourceChanges` se establece en true de forma predeterminada si no se establece explícitamente en false. Al añadir la detección de cambios basada en eventos, debe añadir el parámetro a la salida y establecerlo en false para deshabilitar el sondeo. De lo contrario, la canalización comienza dos veces para un único cambio en el código fuente. Para obtener más información, consulte [Configuración válida para el parámetro `PollForSourceChanges`](PollForSourceChanges-defaults.md).
1. Ejecute el comando **get-pipeline** para copiar la estructura de canalización en un archivo JSON. Por ejemplo, para una canalización denominada `MyFirstPipeline`, debería escribir el siguiente comando:
```
aws codepipeline get-pipeline --name MyFirstPipeline >pipeline.json
```
Este comando no devuelve nada, pero el archivo creado debería aparecer en el directorio en el que se ejecutó el comando.
1. Abra el archivo JSON en cualquier editor de texto sin formato y edite la etapa de código fuente cambiando o añadiendo el parámetro `PollForSourceChanges`. En este ejemplo, para un repositorio llamado `UserGitHubRepo`, el parámetro está establecido en `false`.
**¿Por qué voy a hacer este cambio?** Al cambiar este parámetro, se desactivan las comprobaciones periódicas, por lo que únicamente puede utilizar la detección de cambios basada en eventos.
```
"configuration": {
"Owner": "name",
"Repo": "UserGitHubRepo",
"PollForSourceChanges": "false",
"Branch": "main",
"OAuthToken": "****"
},
```
1. Si está trabajando con la estructura de canalizaciones recuperada mediante el comando **get-pipeline**, debe editar la estructura en el archivo JSON quitando las líneas `metadata` del archivo. De lo contrario, el comando **update-pipeline** no puede utilizarlo. Quite la sección `"metadata"` de la estructura de canalizaciones del archivo JSON, incluido `{ }` y los campos `"created"`, `"pipelineARN"` y `"updated"`.
Por ejemplo, quite las siguientes líneas de la estructura:
```
"metadata": {
"pipelineArn": "arn:aws:codepipeline:region:account-ID:pipeline-name",
"created": "date",
"updated": "date"
},
```
Guarde el archivo.
1. Para aplicar los cambios, ejecute el comando **update-pipeline**, especificando el archivo JSON de la canalización, de forma similar a como se muestra a continuación:
**importante**
Asegúrese de incluir `file://` antes del nombre de archivo. Es obligatorio en este comando.
```
aws codepipeline update-pipeline --cli-input-json file://pipeline.json
```
Este comando devuelve la estructura completa de la canalización editada.
**nota**
El comando **update-pipeline** detiene la canalización. Si se está ejecutando una revisión en la canalización al ejecutar el comando **update-pipeline**, dicha ejecución se detiene. Debe iniciar manualmente la canalización para ejecutar dicha revisión en la canalización actualizada. Utilice el comando **start-pipeline-execution** para iniciar manualmente la canalización.
### Actualiza las canalizaciones para los eventos push GitHub (a través de OAuth la aplicación) (acciones fuente) (CloudFormation plantilla)
Sigue estos pasos para actualizar tu proceso (con una GitHub fuente), desde las comprobaciones periódicas (sondeos) hasta la detección de cambios basada en eventos mediante webhooks.
Para crear una canalización basada en eventos AWS CodeCommit, editas el `PollForSourceChanges` parámetro de la canalización y, a continuación, añades un recurso de GitHub webhook a la plantilla.
Si lo utilizas CloudFormation para crear y gestionar tus canalizaciones, la plantilla tiene un contenido como el siguiente.
**nota**
Tenga en cuenta la propiedad de configuración `PollForSourceChanges` de la etapa de código fuente. Si la plantilla no incluye esa propiedad, `PollForSourceChanges` se establece en `true` de forma predeterminada.
------
#### [ 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
}
]
},
...
```
------
**Para añadir parámetros y crear un webhook en la plantilla**
Te recomendamos encarecidamente que la utilices AWS Secrets Manager para almacenar tus credenciales. Si utiliza Secrets Manager, debe haber configurado y almacenado sus parámetros secretos en Secrets Manager. En este ejemplo, se utilizan referencias dinámicas a Secrets Manager para las GitHub credenciales de tu webhook. Para obtener más información, consulte [ Uso de referencias dinámicas para especificar valores de plantillas](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/dynamic-references.html#dynamic-references-secretsmanager).
**importante**
Al pasar parámetros del secreto, no introduzca el valor directamente en la plantilla. El valor se representa como texto no cifrado y, por lo tanto, se puede leer. Por motivos de seguridad, no utilices texto sin formato en la CloudFormation plantilla para almacenar tus credenciales.
Cuando utilizas la CLI o CloudFormation para crear una canalización y añadir un webhook, debes deshabilitar las comprobaciones periódicas.
**nota**
Para deshabilitar las comprobaciones periódicas, debe añadir de forma explícita el parámetro `PollForSourceChanges` y establecerlo en false, tal y como se detalla en el último procedimiento que viene a continuación. De lo contrario, el valor predeterminado de una CLI o una CloudFormation canalización es que el `PollForSourceChanges` valor predeterminado sea verdadero y no se muestre en la salida de la estructura de la canalización. Para obtener más información sobre los PollForSourceChanges valores predeterminados, consulte. [Configuración válida para el parámetro `PollForSourceChanges`](PollForSourceChanges-defaults.md)
1. En la plantilla, bajo `Resources`, añada los parámetros:
------
#### [ YAML ]
```
Parameters:
GitHubOwner:
Type: String
...
```
------
#### [ JSON ]
```
{
"Parameters": {
"BranchName": {
"Description": "GitHub branch name",
"Type": "String",
"Default": "main"
},
"GitHubOwner": {
"Type": "String"
},
...
```
------
1. Utilice el `AWS::CodePipeline::Webhook` CloudFormation recurso para añadir un webhook.
**nota**
El `TargetAction` especificado debe coincidir con la propiedad `Name` de su acción de código fuente definida en la canalización.
Si `RegisterWithThirdParty` está configurado en`true`, asegúrese de que el usuario asociado a él `OAuthToken` pueda establecer los ámbitos necesarios. GitHub El token y el webhook requieren los siguientes ámbitos: GitHub
+ `repo`: se utiliza para controlar totalmente la lectura y la extracción de artefactos de los repositorios públicos y privados en una canalización.
+ `admin:repo_hook`: se utiliza para el control total de los enlaces del repositorio.
De lo contrario, GitHub devuelve un 404. Para obtener más información acerca del error 404 devuelto, consulte [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. Guarde la plantilla actualizada en el equipo local y, a continuación, abra la CloudFormation consola.
1. Seleccione la pila y luego elija **Create Change Set for Current Stack (Crear conjuntos de cambios para la pila actual)**.
1. Cargue la plantilla y, a continuación, consulte los cambios indicados en CloudFormation. Estos son los cambios que se realizan en la pila. Debería ver los nuevos recursos en la lista.
1. Elija **Ejecutar**.
**Para editar el PollForSourceChanges parámetro de tu canalización**
**importante**
Al crear una canalización con este método, el parámetro `PollForSourceChanges` se establece en true de forma predeterminada si no se establece explícitamente en false. Al añadir la detección de cambios basada en eventos, debe añadir el parámetro a la salida y establecerlo en false para deshabilitar el sondeo. De lo contrario, la canalización comienza dos veces para un único cambio en el código fuente. Para obtener más información, consulte [Configuración válida para el parámetro `PollForSourceChanges`](PollForSourceChanges-defaults.md).
+ En la plantilla, cambie `PollForSourceChanges` por `false`. Si no ha incluido `PollForSourceChanges` en la definición de la canalización, añádalo y establézcalo en false.
**¿Por qué voy a hacer este cambio?** Al cambiar este parámetro a `false`, se desactivan las comprobaciones periódicas, por lo que únicamente puede utilizar la detección de cambios basada en eventos.
------
#### [ 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**
Al crear estos recursos con CloudFormation, el webhook definido se crea en el GitHub repositorio especificado. Al confirmar, se activará la canalización.
```
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
...
```