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.
# Conexión a Amazon S3: acciones de origen que utilizan EventBridge y AWS CloudTrail
Las instrucciones de esta sección proporcionan los pasos para crear la acción de origen de S3 que utiliza AWS CloudTrail los recursos que debe crear y administrar. Para utilizar la acción de origen de S3 EventBridge que no requiera AWS CloudTrail recursos adicionales, utilice las instrucciones de la CLI que se encuentran en[Migración de canalizaciones de sondeo con un origen de S3 habilitado para los eventos](update-change-detection.md#update-change-detection-S3-event).
**importante**
Este procedimiento proporciona los pasos para crear la acción de origen de S3 que utiliza recursos de AWS CloudTrail que el usuario debe crear y administrar. El procedimiento para crear esta acción sin AWS CloudTrail recursos no está disponible en la consola. Para utilizar la CLI, consulte [Migración de canalizaciones de sondeo con un origen de S3 habilitado para los eventos](update-change-detection.md#update-change-detection-S3-event).
Para añadir una acción de origen de Amazon S3 CodePipeline, puede elegir entre las siguientes opciones:
+ Utilice el asistente de **creación de canalización** de la CodePipeline consola ([Creación de una canalización personalizada (consola)](pipelines-create.md#pipelines-create-console)) o la página de **edición de acciones** para elegir la opción de proveedor de **S3**. La consola crea una EventBridge regla y un CloudTrail registro que inician la canalización cuando cambia la fuente.
+ AWS CLI Utilícela para añadir la configuración de la `S3` acción y crear recursos adicionales de la siguiente manera:
+ Utilice el ejemplo de configuración de acciones `S3` en [Referencia sobre la acción de origen de Amazon S3](action-reference-S3.md) para crear su acción, como se muestra en [Crear una canalización (CLI)](pipelines-create.md#pipelines-create-cli).
+ El método de detección de cambios consiste de forma predeterminada en iniciar la canalización sondeando el origen. Debe deshabilitar las comprobaciones periódicas y crear la regla de detección de cambios manualmente. Utilice uno de los siguientes métodos: [Crear una EventBridge regla para una fuente de Amazon S3 (consola)](create-cloudtrail-S3-source-console.md), [Crear una EventBridge regla para una fuente de Amazon S3 (CLI)](create-cloudtrail-S3-source-cli.md) o [Crear una EventBridge regla para una fuente de Amazon S3 (CloudFormation plantilla)](create-cloudtrail-S3-source-cfn.md).
AWS CloudTrail es un servicio que registra y filtra los eventos en su bucket de origen de Amazon S3. El registro envía los cambios filtrados en la fuente a la EventBridge regla. La EventBridge regla detecta el cambio de origen y, a continuación, inicia la canalización.
**Requisitos:**
+ Si no va a crear una ruta, utilice una AWS CloudTrail ruta existente para registrar los eventos en su bucket de origen de Amazon S3 y enviar los eventos filtrados a la EventBridge regla.
+ Cree o utilice un bucket de S3 existente donde AWS CloudTrail pueda almacenar sus archivos de registro. AWS CloudTrail debe tener los permisos necesarios para entregar archivos de registro a un bucket de Amazon S3. El bucket no se puede configurar como un bucket de [pago por solicitante](https://docs.aws.amazon.com/AmazonS3/latest/dev/RequesterPaysBuckets.html). Cuando crea un bucket de Amazon S3 como parte de la creación o actualización de una ruta en la consola, le AWS CloudTrail asigna los permisos necesarios a un bucket. Para obtener más información, consulte la [Política de buckets de Amazon S3 para CloudTrail](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/create-s3-bucket-policy-for-cloudtrail.html).
# Crear una EventBridge regla para una fuente de Amazon S3 (consola)
Antes de configurar una regla EventBridge, debe crear una AWS CloudTrail ruta. Para obtener más información, consulte [Creación de un registro de seguimiento en la consola](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/cloudtrail-create-a-trail-using-the-console-first-time.html).
**importante**
Si utilizas la consola para crear o editar tu canalización, la EventBridge regla y la AWS CloudTrail ruta se crearán automáticamente.
**Creación de un registro de seguimiento**
1. Abre la AWS CloudTrail consola.
1. En el panel de navegación, seleccione **Trails**.
1. Elija **Create Trail** (Crear registro de seguimiento). En **Trail name (Nombre de registro de seguimiento)**, escriba un nombre para el registro de seguimiento.
1. En **Storage location** (Ubicación de almacenamiento), cree o especifique el bucket que se utilizará para almacenar los archivos de log. De forma predeterminada, los buckets y los objetos de Amazon S3 son privados. Solo el propietario del recurso (la AWS cuenta que creó el depósito) puede acceder al depósito y a sus objetos. El depósito debe tener una política de recursos que permita AWS CloudTrail obtener permisos para acceder a los objetos del depósito.
1. En **Bucket y carpeta de registro de seguimiento**, especifique un bucket de Amazon S3 y el prefijo del objeto (nombre de la carpeta) para registrar los eventos de datos de todos los objetos de la carpeta. Puede agregar hasta 250 objetos de Amazon S3 a cada registro de seguimiento. Complete la información de la clave de cifrado requerida y seleccione **Siguiente**.
1. En **Tipo de evento**, elija **Eventos de administración**.
1. En **Eventos de administración**, elija **Escribir**. El registro de seguimiento consigna la actividad de la API para cada objeto de Amazon S3 (por ejemplo, `GetObject` y `PutObject`) con el bucket y el prefijo especificados.
1. Elija **Write (Escribir)**.
1. Si está satisfecho con el registro de seguimiento, elija **Crear registro de seguimiento**.
**Para crear una EventBridge regla que se dirija a su canalización con una fuente de Amazon S3**
1. Abre la EventBridge consola de Amazon en [https://console.aws.amazon.com/events/](https://console.aws.amazon.com/events/).
1. En el panel de navegación, seleccione **Reglas**. Deje el bus predeterminado seleccionado o elija un bus de eventos. Elija **Crear regla**.
1. En **Nombre**, introduzca un nombre para la regla.
1. En **Tipo de regla**, elija **Regla con un patrón de evento**. Elija **Siguiente**.
1. En **Fuente del evento**, selecciona **AWS eventos o eventos EventBridge asociados**.
1. En **Ejemplo de tipo de evento**, seleccione **Eventos de AWS **.
1. En **Ejemplos de eventos**, escriba S3 como palabra clave para filtrar. Elige **AWS API call via CloudTrail**.
1. En **Método de creación**, elija **Patrón de cliente (JSON editor)**.
Pegue el patrón de eventos que se muestra a continuación. Asegúrese de agregar el nombre del bucket y la clave de objeto S3 (o el nombre de clave) que identifica de forma única al objeto en el bucket como `requestParameters`. En este ejemplo, se crea una regla para un bucket denominado `amzn-s3-demo-source-bucket` y una clave de objeto de `my-files.zip`. Cuando se utiliza la ventana **Edit** (Editar) para especificar los recursos, la regla se actualiza para utilizar un patrón de eventos personalizado.
A continuación se muestra un patrón de eventos de muestra para copiar y pegar:
```
{
"source": [
"aws.s3"
],
"detail-type": [
"AWS API Call via CloudTrail"
],
"detail": {
"eventSource": [
"s3.amazonaws.com"
],
"eventName": [
"CopyObject",
"CompleteMultipartUpload",
"PutObject"
],
"requestParameters": {
"bucketName": [
"amzn-s3-demo-source-bucket"
],
"key": [
"my-files.zip"
]
}
}
}
```
1. Elija **Siguiente**.
1. En **Tipos de destino**, elija **Servicio de AWS **.
1. En **Seleccione un objetivo**, elija **CodePipeline**. En **ARN de canalización**, Introduzca el ARN de la canalización que se iniciará cuando la active esta regla.
**nota**
Para obtener el ARN de la canalización, ejecute el comando **get-pipeline**. El ARN de la canalización aparece en la salida. Se crea con el siguiente formato:
arn:aws:codepipeline::: *region* *account* *pipeline-name*
ARN de canalización de muestra:
arn:aws:codepipeline:us-east- 2:80398 EJEMPLO: MyFirstPipeline
1. Para crear o especificar una función de servicio de IAM que conceda EventBridge permisos para invocar el destino asociado a la regla (en este caso, el objetivo es): EventBridge CodePipeline
+ Seleccione **Crear una nueva función para este recurso específico** a fin de crear una función de servicio que le dé EventBridge permisos para iniciar las ejecuciones de su canalización.
+ Selecciona **Usar el rol existente** para introducir un rol de servicio que te dé EventBridge permisos para iniciar las ejecuciones de tu canalización.
1. (Opcional) Para especificar las anulaciones de origen con un ID de imagen específico, use el transformador de entrada para pasar los datos como parámetros en JSON. También puede usar el transformador de entrada para pasar variables de canalización.
+ Amplíe **Configuración adicional**.
En **Configurar entrada de destino**, elija **Configurar transformador de entrada**.
En la ventana de cuadro de diálogo, elija **Escribir el mío**. En el cuadro **Ruta de entrada**, escriba los siguientes pares clave-valor.
```
{"revisionValue": "$.detail.object.version-id"}
```
+ En el cuadro **Plantilla**, escriba los siguientes pares clave-valor.
```
{
"sourceRevisions": [
{
"actionName": "Source",
"revisionType": "S3_OBJECT_VERSION_ID",
"revisionValue": ""
}
],
"variables": [
{
"name": "Variable_Name",
"value": "Variable_Value"
}
]
}
```
+ Seleccione **Confirmar**.
1. Elija **Siguiente**.
1. En la página **Etiquetas**, elija **Siguiente:**
1. En la página **Revisar y crear**, revise la configuración de la regla. Si está satisfecho con la regla, elija **Create rule (Crear regla)**.
# Crear una EventBridge regla para una fuente de Amazon S3 (CLI)
**Para crear un AWS CloudTrail rastro 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.
# Crear una EventBridge regla para una fuente de Amazon S3 (CloudFormation plantilla)
Para utilizarla CloudFormation para crear una regla, actualice la plantilla como se muestra aquí.
**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
}
}
}
}
...
```
------