Migrar los canales de sondeo para utilizar la detección de cambios basada en eventos

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

2. Copie y pegue el siguiente código en el PollingPipelinesExtractorscript. Realice una de las siguientes acciones siguientes:

   • 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))

3. 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 de acciones en origen de Amazon S3.

   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.

Para editar la etapa de código fuente de la canalización

1. Inicie sesión AWS Management Console y abra la CodePipeline consola en http://console.aws.amazon.com/codesuite/codepipeline/home.

   Se muestran los nombres de todas las canalizaciones asociadas a tu AWS cuenta.

2. 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.

3. En la página de detalles de la canalización, elija Edit.

4. En la etapa Edit (Editar), elija el icono de edición en la acción de código fuente.

5. 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.

6. 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.

7. 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.

Para editar el PollForSourceChanges parámetro de tu canalización

1. Ejecuta el get-pipeline comando para copiar la estructura de la canalización en un JSON archivo. 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.

2. Abra el JSON archivo en cualquier editor de texto sin formato y edite la etapa de origen cambiando el PollForSourceChanges parámetro afalse, 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"
   },

3. Si está trabajando con la estructura de tuberías recuperada mediante el get-pipeline comando, elimine las metadata líneas del JSON archivo. 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.

4. Para aplicar los cambios, ejecute el update-pipeline comando especificando el JSON archivo de canalizació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.

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. 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.

      {
          "Version": "2012-10-17",
          "Statement": [
              {
                  "Effect": "Allow",
                  "Principal": {
                      "Service": "events.amazonaws.com"
                  },
                  "Action": "sts:AssumeRole"
              }
          ]
      }

   2. 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

   3. Cree la política de permisosJSON, como se muestra en este ejemplo, para la canalización denominadaMyFirstPipeline. Ponga un nombre a la política de permisos permissionspolicyforEB.json.

      {
          "Version": "2012-10-17",
          "Statement": [
              {
                  "Effect": "Allow",
                  "Action": [
                      "codepipeline:StartPipelineExecution"
                  ],
                  "Resource": [
                      "arn:aws:codepipeline:us-west-2:80398EXAMPLE:MyFirstPipeline"
                  ]
              }
          ]
      }
      

   4. 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

2. 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 AWS 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"

3. 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

Para actualizar tu AWS CloudFormation plantilla de canalización y crear una regla EventBridge

1. En la plantilla, enResources, usa el AWS::IAM::Role AWS CloudFormation recurso para configurar el IAM rol que permite a tu evento iniciar 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 AWS CloudFormation permite crear permisos para EventBridge. Este recurso se añade a tu AWS 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"
                       }
                     ]
   
   ...

2. En la plantilla, enResources, usa el AWS::Events::Rule AWS 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 AWS CloudFormation crear el evento. Este recurso se añade a tu AWS 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"
         }
       ]
     }
   },

3. Guarde la plantilla actualizada en el equipo local y luego abra la consola de AWS CloudFormation .

4. Seleccione la pila y luego elija Create Change Set for Current Stack (Crear conjuntos de cambios para la pila actual).

5. Cargue la plantilla y, a continuación, consulte los cambios indicados en AWS CloudFormation. Estos son los cambios que se realizan en la pila. Debería ver los nuevos recursos en la lista.

6. Elija Ejecutar.

Para editar el PollForSourceChanges parámetro de tu canalización

• 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
      }
    ]
  },
        

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. 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.

      {
          "Version": "2012-10-17",
          "Statement": [
              {
                  "Effect": "Allow",
                  "Principal": {
                      "Service": "events.amazonaws.com"
                  },
                  "Action": "sts:AssumeRole"
              }
          ]
      }

   2. 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

   3. Crea la política de permisosJSON, como se muestra aquí para la canalización nombradaMyFirstPipeline. Ponga un nombre a la política de permisos permissionspolicyforEB.json.

      {
          "Version": "2012-10-17",
          "Statement": [
              {
                  "Effect": "Allow",
                  "Action": [
                      "codepipeline:StartPipelineExecution"
                  ],
                  "Resource": [
                      "arn:aws:codepipeline:us-west-2:80398EXAMPLE:MyFirstPipeline"
                  ]
              }
          ]
      }
      

   4. 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

2. 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"

3. Para CodePipeline añadirla como destino, ejecuta el put-targets comando e incluye los --targets parámetros --rule y.

   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

1. Ejecuta el get-pipeline comando para copiar la estructura de la canalización en un JSON archivo. 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.

2. Abra el JSON archivo en cualquier editor de texto sin formato y edite la etapa de origen cambiando el PollForSourceChanges parámetro de un bucket denominado amzn-s3-demo-source-bucket afalse, 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"
   },

3. Si está trabajando con la estructura de tuberías recuperada mediante el get-pipeline comando, debe eliminar las metadata líneas del JSON archivo. 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.

4. Para aplicar los cambios, ejecute el update-pipeline comando especificando el JSON archivo de canalizació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.

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, enResources, utilice el AWS::IAM::Role AWS CloudFormation recurso para configurar el IAM rol 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 AWS CloudFormation permite crear permisos para EventBridge. Este recurso se añade a tu AWS 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"
                         }
                       ]
                     ]
   
   ...

2. Usa el AWS::Events::Rule AWS 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 AWS CloudFormation permite crear el evento. Este recurso se añade a tu AWS 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"
           }
         ]
       }
     }
   },
   
   ...

3. Guarde la plantilla actualizada en el equipo local y abra la consola de AWS CloudFormation .

4. Seleccione la pila y luego elija Create Change Set for Current Stack (Crear conjuntos de cambios para la pila actual).

5. Cargue su plantilla actualizada y, a continuación, consulte los cambios indicados en AWS CloudFormation. Estos son los cambios que se realizarán en la pila. Debería ver los nuevos recursos en la lista.

6. Elija Ejecutar.

Para editar el PollForSourceChanges parámetro de tu canalización

• 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 AWS CloudTrail ruta y habilitar el registro

Para usar el AWS CLI para crear un rastro, ejecute el create-trail comando y especifique:

Para obtener más información, consulte Crear una ruta con la interfaz de línea de AWS comandos.

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 CloudTrail rastro 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

2. 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

3. 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. 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.

      {
          "Version": "2012-10-17",
          "Statement": [
              {
                  "Effect": "Allow",
                  "Principal": {
                      "Service": "events.amazonaws.com"
                  },
                  "Action": "sts:AssumeRole"
              }
          ]
      }

   2. 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

   3. Crea la política de permisosJSON, como se muestra aquí para la canalización nombradaMyFirstPipeline. Ponga un nombre a la política de permisos permissionspolicyforEB.json.

      {
          "Version": "2012-10-17",
          "Statement": [
              {
                  "Effect": "Allow",
                  "Action": [
                      "codepipeline:StartPipelineExecution"
                  ],
                  "Resource": [
                      "arn:aws:codepipeline:us-west-2:80398EXAMPLE:MyFirstPipeline"
                  ]
              }
          ]
      }
      

   4. 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

2. 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"

3. Para CodePipeline añadirla 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

Para editar el PollForSourceChanges parámetro de tu canalización

1. Ejecuta el get-pipeline comando para copiar la estructura de la canalización en un JSON archivo. 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.

2. Abra el JSON archivo en cualquier editor de texto sin formato y edite la etapa de origen cambiando el PollForSourceChanges parámetro de un bucket denominado amzn-s3-demo-source-bucket afalse, 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"
   },

3. Si está trabajando con la estructura de tuberías recuperada mediante el get-pipeline comando, debe eliminar las metadata líneas del JSON archivo. 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.

4. Para aplicar los cambios, ejecute el update-pipeline comando especificando el JSON archivo de canalizació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.

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, enResources, utilice el AWS::IAM::Role AWS CloudFormation recurso para configurar el IAM rol 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 AWS CloudFormation permite crear permisos para EventBridge. Este recurso se añade a tu AWS 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"
                         }
                       ]
                     ]
   
   ...

2. Usa el AWS::Events::Rule AWS 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 AWS CloudFormation permite crear el evento. Este recurso se añade a tu AWS 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"
           }
         ]
       }
     }
   },
   
   ...

3. 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"
         }
       }
   
   ...

4. Guarde la plantilla actualizada en su ordenador local y abra la AWS CloudFormation consola.

5. Seleccione la pila y luego elija Create Change Set for Current Stack (Crear conjuntos de cambios para la pila actual).

6. Cargue su plantilla actualizada y, a continuación, consulte los cambios indicados en AWS CloudFormation. Estos son los cambios que se realizarán en la pila. Debería ver los nuevos recursos en la lista.

7. Elija Ejecutar.

Para editar el PollForSourceChanges parámetro de tu canalización

• 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, enResources, utilice los AWS::CloudTrail::Trail AWS CloudFormation recursos AWS::S3::BucketAWS::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.) 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
        }
      }
    }
  }
  
  ...

Para reemplazar la GitHub acción de la versión 1

1. Inicia sesión en la CodePipeline consola.

2. 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.

3. En Action provider, selecciona GitHub (versión 2).

4. Realice una de las siguientes acciones siguientes:

   • 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.

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.

2. Si GitHub aparece la página de autorización, inicie sesión con sus credenciales y, a continuación, elija continuar.

3. 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.

4. En la página Instalar AWS CodeStar, seleccione Instalar.

5. En la GitHub página Conectar a, se muestra el ID de conexión de la nueva instalación. Elija Conectar.

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

2. 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 desde el GitHub repositorio y almacena los artefactos en un ZIP archivo en el almacén de artefactos de Pipeline.

   • Para almacenar un JSON archivo que contenga una URL referencia al repositorio para que las acciones posteriores puedan ejecutar comandos de Git directamente, selecciona 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 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.

3. 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.

4. 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.

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 ARN información de conexión similar a la siguiente.

   {
       "ConnectionArn": "arn:aws:codeconnections:us-west-2:account_id:connection/aEXAMPLE-8aad-4d5d-8878-dfcab0bc441f"
   }

2. Utilice la consola para completar la conexión.

Para editar la etapa de código fuente de la canalización

1. Inicie sesión en la CodePipeline consola AWS Management Console y ábrala en http://console.aws.amazon.com/codesuite/codepipeline/home.

   Se muestran los nombres de todas las canalizaciones asociadas a tu AWS cuenta.

2. 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.

3. En la página de detalles de la canalización, elija Edit.

4. En la etapa Edit (Editar), elija el icono de edición en la acción de código fuente.

5. 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.

   • El webhookURL, generado mediante el punto final público de la región.

   CodePipeline registra el webhook con. GitHub Esto lo suscribe URL para recibir los eventos del repositorio.

6. 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.

7. Para probar tu acción, publica un cambio utilizando el AWS CLI para confirmar un cambio en la fuente especificada en la etapa de origen de la canalización.

Para crear y registrar su webhook

1. En un editor de texto, cree y guarde un JSON archivo para el webhook que desee 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"
   	 }
       }
   }

2. Llame al comando put-webhook e incluya los parámetros --cli-input y --region.

   El siguiente comando de ejemplo crea un webhook con el webhook_json JSON archivo.

   aws codepipeline put-webhook --cli-input-json file://webhook_json.json --region "eu-central-1"

3. En el resultado que se muestra en este ejemplo, ARN se devuelven los caracteres URL y para 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

4. 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

1. Ejecuta el get-pipeline comando para copiar la estructura de la canalización en un JSON archivo. 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.

2. Abra el JSON archivo en cualquier editor de texto sin formato y edite la etapa de origen cambiando o añadiendo el PollForSourceChanges parámetro. 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": "****"
   },

3. Si está trabajando con la estructura de tuberías recuperada mediante el get-pipeline comando, debe editar la estructura del JSON archivo eliminando las metadata líneas del archivo. De lo contrario, el comando update-pipeline no puede utilizarlo. Elimine la "metadata" sección de la estructura de tuberías del JSON archivo, incluidos los "updated" campos: { } y "created""pipelineARN", y.

   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.

4. Para aplicar los cambios, ejecute el update-pipeline comando especificando el JSON archivo de canalización, similar al siguiente:

   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 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.

Cuando utilices CLI o AWS CloudFormation para crear una canalización y añadir un webhook, debes deshabilitar las comprobaciones periódicas.

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"
   		},
   
   ...

2. Utilice el AWS::CodePipeline::Webhook AWS 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 entrue, 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.

   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
       }
   },
   
   ...

3. Guarde la plantilla actualizada en el equipo local y, a continuación, abra la AWS CloudFormation consola.

4. Seleccione la pila y luego elija Create Change Set for Current Stack (Crear conjuntos de cambios para la pila actual).

5. Cargue la plantilla y, a continuación, consulte los cambios indicados en AWS CloudFormation. Estos son los cambios que se realizan en la pila. Debería ver los nuevos recursos en la lista.

6. Elija Ejecutar.

Para editar el PollForSourceChanges parámetro de tu canalización

• 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
      }]