As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.
# Conectando-se às ações de origem do Amazon S3 que usam e EventBridge AWS CloudTrail
As instruções nesta seção fornecem as etapas para criar a ação de origem do S3 que usa AWS CloudTrail recursos que você deve criar e gerenciar. Para usar a ação de origem do S3 com uma ação EventBridge que não exija AWS CloudTrail recursos adicionais, use as instruções da CLI em. [Migrar pipelines de sondagem com uma origem do S3 habilitada para eventos](update-change-detection.md#update-change-detection-S3-event)
**Importante**
Este procedimento fornece as etapas para criar a ação de origem do S3 que usa recursos do AWS CloudTrail que você deve criar e gerenciar. O procedimento para criar essa ação sem AWS CloudTrail recursos não está disponível no console. Para usar a CLI, consulte [Migrar pipelines de sondagem com uma origem do S3 habilitada para eventos](update-change-detection.md#update-change-detection-S3-event).
Para adicionar uma ação de origem do Amazon S3 CodePipeline, você escolhe:
+ Use o assistente de **criação de pipeline** do CodePipeline console ([Criar um pipeline personalizado (console)](pipelines-create.md#pipelines-create-console)) ou a página **Editar ação** para escolher a opção de provedor do **S3**. O console cria uma EventBridge regra e uma CloudTrail trilha que inicia seu pipeline quando a fonte muda.
+ Use o AWS CLI para adicionar a configuração de ação para a `S3` ação e criar recursos adicionais da seguinte forma:
+ Use o exemplo de configuração de ação `S3` em [Referência da ação de origem do Amazon S3](action-reference-S3.md) para criar sua ação, conforme mostrado em [Criar um pipeline (CLI)](pipelines-create.md#pipelines-create-cli).
+ O método de detecção de alterações assume como padrão iniciar o pipeline por meio da sondagem da origem. Você deve desabilitar as verificações periódicas e criar a regra e a trilha de detecção de alterações manualmente. Use um dos seguintes métodos: [Crie uma EventBridge regra para uma fonte do Amazon S3 (console)](create-cloudtrail-S3-source-console.md), [Crie uma EventBridge regra para uma fonte do Amazon S3 (CLI)](create-cloudtrail-S3-source-cli.md) ou [Crie uma EventBridge regra para uma fonte do Amazon S3 (modelo)CloudFormation](create-cloudtrail-S3-source-cfn.md).
AWS CloudTrail é um serviço que registra e filtra eventos em seu bucket de origem do Amazon S3. A trilha envia as alterações da fonte filtrada para a EventBridge regra. A EventBridge regra detecta a alteração na fonte e, em seguida, inicia seu pipeline.
**Requisitos:**
+ Se você não estiver criando uma trilha, use uma AWS CloudTrail trilha existente para registrar eventos em seu bucket de origem do Amazon S3 e enviar eventos filtrados para a regra. EventBridge
+ Crie ou use um bucket S3 existente onde AWS CloudTrail possa armazenar seus arquivos de log. AWS CloudTrail deve ter as permissões necessárias para entregar arquivos de log em um bucket do Amazon S3. O bucket não pode ser configurado como um bucket de [Pagamento pelo solicitante](https://docs.aws.amazon.com/AmazonS3/latest/dev/RequesterPaysBuckets.html). Quando você cria um bucket do Amazon S3 como parte da criação ou atualização de uma trilha no console, AWS CloudTrail anexa as permissões necessárias a um bucket para você. Para obter mais informações, consulte a [Política de bucket do Amazon S3](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/create-s3-bucket-policy-for-cloudtrail.html) para. CloudTrail
# Crie uma EventBridge regra para uma fonte do Amazon S3 (console)
Antes de configurar uma regra em EventBridge, você deve criar uma AWS CloudTrail trilha. Para obter mais informações, consulte [Criar uma trilha no console](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/cloudtrail-create-a-trail-using-the-console-first-time.html).
**Importante**
Se você usa o console para criar ou editar seu pipeline, sua EventBridge regra e AWS CloudTrail trilha são criadas para você.
**Para criar uma trilha**
1. Abra o AWS CloudTrail console.
1. No painel de navegação, selecione **Trilhas**.
1. Escolha **Create Trail (Criar trilha)**. Em **Trail name (Nome da trilha)**, informe um nome para a trilha.
1. Em **Storage location** (Local de armazenamento), crie ou especifique o bucket a ser usado para armazenar os arquivos de log. Por padrão, os buckets e objetos do Amazon S3 são privados. Somente o proprietário do recurso (a AWS conta que criou o bucket) pode acessar o bucket e seus objetos. O bucket deve ter uma política de recursos que permita AWS CloudTrail permissões para acessar os objetos no bucket.
1. Em **Bucket e pasta de log de trilha**, especifique um bucket do Amazon S3 e o prefixo do objeto (nome da pasta) para registrar em log os eventos de dados de todos os objetos da pasta. Para cada trilha, você pode adicionar até 250 objetos do Amazon S3. Preencha as informações necessárias da chave de criptografia e escolha **Próximo**.
1. Em **Tipo de evento**, escolha **Eventos de gerenciamento**.
1. Em **Eventos de gerenciamento**, escolha **Editar**. A trilha registra a atividade da API no nível do objeto do Amazon S3 (por exemplo, `GetObject` e `PutObject`) no bucket e no prefixo especificados.
1. Selecione **Write (Gravar)**.
1. Se você estiver satisfeito com a trilha, escolha **Criar trilha**.
**Para criar uma EventBridge regra que tenha como alvo seu pipeline com uma fonte do Amazon S3**
1. Abra o EventBridge console da Amazon em [https://console.aws.amazon.com/events/](https://console.aws.amazon.com/events/).
1. No painel de navegação, escolha **Regras**. Deixe o barramento padrão selecionado ou escolha um barramento de eventos. Escolha **Criar regra**.
1. Em **Nome**, insira um nome para a regra.
1. Em **Tipo de regra**, escolha **Regra com um padrão de eventos**. Escolha **Próximo**.
1. Em **Fonte do evento**, escolha **AWS eventos ou eventos de EventBridge parceiros**.
1. Em **Tipo de evento de amostra**, escolha **Eventos do AWS **.
1. Em **Eventos de amostra**, digite S3 como a palavra-chave que servirá como base para a filtragem. Escolha a **chamada de AWS API via CloudTrail**.
1. Em **Método de criação**, escolha **Padrão personalizado (editor JSON)**.
Cole o padrão de evento fornecido abaixo. Certifique-se de adicionar o nome do bucket e a chave de objeto do S3 (ou o nome da chave) que identifica o objeto no bucket como `requestParameters`. Neste exemplo, uma regra é criada para um bucket chamado `amzn-s3-demo-source-bucket` e a chave de objeto `my-files.zip`. Quando você usa a janela **Edit** (Editar) para especificar os recursos, a regra é atualizada para usar um padrão de evento personalizado.
Veja a seguir um exemplo de padrão de evento para copiar e colar:
```
{
"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. Escolha **Próximo**.
1. Em **Tipos de destino**, escolha **Serviço da AWS **.
1. Em **Selecionar um alvo**, escolha **CodePipeline**. Em **ARN do pipeline**, insira o ARN do pipeline a ser iniciado por esta regra.
**nota**
Para obter o ARN do pipeline, execute o comando **get-pipeline**. O ARN do pipeline é exibido na saída. Ele é construído neste formato:
arn: aws:codepipeline::: *region* *account* *pipeline-name*
Exemplo de ARN do pipeline:
arn:aws:codepipeline:us-east- 2:80398 EXEMPLO: MyFirstPipeline
1. Para criar ou especificar uma função de serviço do IAM que conceda EventBridge permissões para invocar o destino associado à sua EventBridge regra (nesse caso, o alvo é CodePipeline):
+ Escolha **Criar uma nova função para esse recurso específico** para criar uma função de serviço que dê EventBridge permissões para você iniciar suas execuções de funil.
+ Escolha **Usar função existente** para inserir uma função de serviço que conceda EventBridge permissões para você iniciar suas execuções de funil.
1. (Opcional) Para especificar substituições de origem com um ID de imagem específico, use o transformador de entrada para passar os dados como parâmetros JSON. Você também pode usar o transformador de entrada para passar variáveis de pipeline.
+ Expanda **Additional settings** (Configurações adicionais).
Em **Configurar entrada de destino**, escolha **Configurar transformador de entrada**.
Na janela de diálogo, escolha **Inserir um próprio**. Na caixa **Caminho de entrada**, digite os pares de chave-valor a seguir.
```
{"revisionValue": "$.detail.object.version-id"}
```
+ Na caixa **Modelo**, digite os pares de chave-valor a seguir.
```
{
"sourceRevisions": [
{
"actionName": "Source",
"revisionType": "S3_OBJECT_VERSION_ID",
"revisionValue": ""
}
],
"variables": [
{
"name": "Variable_Name",
"value": "Variable_Value"
}
]
}
```
+ Escolha **Confirmar**.
1. Escolha **Próximo**.
1. Na página **Tags**, selecione **Próximo**.
1. Na página **Revisar e criar**, revise a configuração da regra. Se você estiver satisfeito com a regra, escolha **Create rule**.
# Crie uma EventBridge regra para uma fonte do Amazon S3 (CLI)
**Para criar uma AWS CloudTrail trilha e ativar o registro**
Para usar o AWS CLI para criar uma trilha, chame o **create-trail** comando, especificando:
+ O nome da trilha.
+ O bucket ao qual você já aplicou a política de bucket do AWS CloudTrail.
Para obter mais informações, consulte [Criação de uma trilha com a interface da linha de AWS comando](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/cloudtrail-create-and-update-a-trail-by-using-the-aws-cli.html).
1. Use o comando **create-trail** e inclua os parâmetros `--name` e `--s3-bucket-name`.
**Por que estou fazendo essa alteração?** Isso cria a trilha do CloudTrail necessária para o bucket de origem do S3.
O comando a seguir usa `--name` e `--s3-bucket-name` para criar uma trilha denominada `my-trail` e um bucket chamado de `amzn-s3-demo-source-bucket`.
```
aws cloudtrail create-trail --name my-trail --s3-bucket-name amzn-s3-demo-source-bucket
```
1. Use o comando **start-logging** e inclua o parâmetro `--name`.
**Por que estou fazendo essa alteração? ** Esse comando inicia o CloudTrail registro do seu bucket de origem e envia eventos para EventBridge.
Exemplo:
O comando a seguir utiliza `--name` para iniciar o registro em log em uma trilha denominada `my-trail`.
```
aws cloudtrail start-logging --name my-trail
```
1. Use o comando **put-event-selectors** e inclua os parâmetros `--trail-name` e `--event-selectors`. Use seletores de eventos para especificar que você deseja que sua trilha registre eventos de dados para seu bucket de origem e envie os eventos para a EventBridge regra.
**Por que estou fazendo essa alteração? ** Esse comando filtra eventos.
Exemplo:
O comando a seguir utiliza `--trail-name` e `--event-selectors` para especificar eventos de dados para um bucket de origem e prefixo denominado `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 criar uma EventBridge regra com o Amazon S3 como fonte e destino do evento e CodePipeline aplicar a política de permissões**
1. Conceda permissões EventBridge para usar CodePipeline para invocar a regra. Para obter mais informações, consulte [Uso de políticas baseadas em recursos para a Amazon](https://docs.aws.amazon.com/eventbridge/latest/userguide/eb-use-resource-based.html). EventBridge
1. Use o exemplo a seguir para criar a política de confiança que permita assumir EventBridge a função de serviço. Chame-o de `trustpolicyforEB.json`.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": "events.amazonaws.com"
},
"Action": "sts:AssumeRole"
}
]
}
```
------
1. Use o comando a seguir para criar a função `Role-for-MyRule` e anexar a política de confiança.
**Por que estou fazendo essa alteração?** Adicionar essa política de confiança à função cria permissões para EventBridge.
```
aws iam create-role --role-name Role-for-MyRule --assume-role-policy-document file://trustpolicyforEB.json
```
1. Crie o JSON da política de permissões, conforme mostrado aqui para o pipeline chamado `MyFirstPipeline`. Nomeie a politica de permissões `permissionspolicyforEB.json`.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"codepipeline:StartPipelineExecution"
],
"Resource": [
"arn:aws:codepipeline:us-west-2:111122223333:MyFirstPipeline"
]
}
]
}
```
------
1. Use o comando a seguir para anexar a nova política de permissões `CodePipeline-Permissions-Policy-for-EB` à função `Role-for-MyRule` criada.
```
aws iam put-role-policy --role-name Role-for-MyRule --policy-name CodePipeline-Permissions-Policy-For-EB --policy-document file://permissionspolicyforEB.json
```
1. Use o comando **put-rule** e inclua os parâmetros `--name`, `--event-pattern` e `--role-arn`.
O exemplo de comando a seguir cria uma regra chamada `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 adicionar CodePipeline como destino, chame o **put-targets** comando e inclua `--rule` `--targets` os parâmetros e.
O comando a seguir especifica que, para a regra denominada `MyS3SourceRule`, o `Id` do destino é composto do número um, indicando que, em uma lista de destinos para a regra, esse é o destino 1. O comando também especifica um `ARN` de exemplo para o pipeline. O pipeline é iniciado quando uma alteração é feita no repositório.
```
aws events put-targets --rule MyS3SourceRule --targets Id=1,Arn=arn:aws:codepipeline:us-west-2:80398EXAMPLE:TestPipeline
```
1. (Opcional) Para configurar um transformador de entrada com substituições de origem para um ID de imagem específico, use o JSON a seguir no comando da CLI. O exemplo a seguir configura uma substituição na qual:
+ O `actionName`, `Source` neste exemplo, é o valor dinâmico, definido na criação do pipeline, não derivado do evento de origem.
+ O `revisionType`, `S3_OBJECT_VERSION_ID` neste exemplo, é o valor dinâmico, definido na criação do pipeline, não derivado do evento de origem.
+ O`revisionValue`, < *revisionValue* > neste exemplo, é derivado da variável de evento de origem.
```
{
"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 o PollForSourceChanges parâmetro do seu funil**
**Importante**
Ao criar um pipeline com esse método, o parâmetro `PollForSourceChanges` é padronizado como verdadeiro se não for explicitamente definido como falso. Ao adicionar a detecção de alterações baseada em eventos, é necessário adicionar o parâmetro a sua saída e defini-lo como falso para desativar a sondagem. Caso contrário, o pipeline inicia duas vezes para uma única alteração de origem. Para obter detalhes, consulte [Configurações válidas para o parâmetro `PollForSourceChanges`](PollForSourceChanges-defaults.md).
1. Execute o **get-pipeline** comando para copiar a estrutura do pipeline em um arquivo JSON. Por exemplo, para um pipeline nomeado `MyFirstPipeline`, execute o seguinte comando:
```
aws codepipeline get-pipeline --name MyFirstPipeline >pipeline.json
```
Este comando retorna nada, mas o arquivo que você criou deve aparecer no diretório onde você executou o comando.
1. Abra o arquivo JSON em qualquer editor de texto plano e, para editar o estágio de origem, altere o parâmetro `PollForSourceChanges` de um bucket denominado `amzn-s3-demo-source-bucket` para `false`, conforme mostrado neste exemplo.
**Por que estou fazendo essa alteração?** A configuração deste parâmetro para `false` desativa as verificações periódicas para que você possa utilizar apenas a detecção de alterações baseada em eventos.
```
"configuration": {
"S3Bucket": "amzn-s3-demo-source-bucket",
"PollForSourceChanges": "false",
"S3ObjectKey": "index.zip"
},
```
1. Se você estiver trabalhando com a estrutura do pipeline recuperada por meio do comando **get-pipeline**, é necessário remover as linhas `metadata` do arquivo JSON. Caso contrário, o comando **update-pipeline** não é capaz de utilizá-la. Remova as linhas `"metadata": { }`, `"created"`, `"pipelineARN"` e os campos `"updated"`.
Por exemplo, remova as seguintes linhas da estrutura:
```
"metadata": {
"pipelineArn": "arn:aws:codepipeline:region:account-ID:pipeline-name",
"created": "date",
"updated": "date"
},
```
Salve o arquivo.
1. Para aplicar suas alterações, execute o comando **update-pipeline** especificando o arquivo JSON do pipeline:
**Importante**
Não se esqueça de incluir `file://` antes do nome de arquivo. Ele é obrigatório nesse comando.
```
aws codepipeline update-pipeline --cli-input-json file://pipeline.json
```
Este comando retorna toda a estrutura do pipeline editado.
**nota**
O comando **update-pipeline** interrompe o pipeline. Se uma revisão estiver sendo executada pelo pipeline quando você executar o comando **update-pipeline**, essa execução será interrompida. Você deve iniciar manualmente o pipeline para executar a revisão através do pipeline atualizado. Use o comando **start-pipeline-execution** para iniciar manualmente o pipeline.
# Crie uma EventBridge regra para uma fonte do Amazon S3 (modelo)CloudFormation
Para usar CloudFormation para criar uma regra, atualize seu modelo conforme mostrado aqui.
**Para criar uma EventBridge regra com o Amazon S3 como fonte e destino do evento e CodePipeline aplicar a política de permissões**
1. No modelo, em`Resources`, use o `AWS::IAM::Role` CloudFormation recurso para configurar a função do IAM que permite que seu evento inicie seu pipeline. Essa entrada cria uma função que utiliza duas políticas:
+ A primeira política permite que a função seja assumida.
+ A segunda política fornece permissões para iniciar o pipeline.
**Por que estou fazendo essa alteração?** Adicionar `AWS::IAM::Role` recursos permite CloudFormation criar permissões para EventBridge. Esse recurso é adicionado à sua CloudFormation pilha.
------
#### [ 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. Use o `AWS::Events::Rule` CloudFormation recurso para adicionar uma EventBridge regra. Esse padrão de evento cria um evento que monitora `CopyObject`, `PutObject` e `CompleteMultipartUpload` no bucket de origem do Amazon S3. Além disso, inclua um destino de seu pipeline. Quando `CopyObject`, `PutObject` ou `CompleteMultipartUpload` ocorrer, essa regra invoca `StartPipelineExecution` em seu pipeline de destino.
**Por que estou fazendo essa alteração?** Adicionar o `AWS::Events::Rule` recurso permite CloudFormation criar o evento. Esse recurso é adicionado à sua CloudFormation pilha.
------
#### [ 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. Adicione este trecho ao primeiro modelo para permitir a funcionalidade de pilha 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 um transformador de entrada com substituições de origem para um ID de imagem específico, use o trecho YAML a seguir. O exemplo a seguir configura uma substituição na qual:
+ O `actionName`, `Source` neste exemplo, é o valor dinâmico, definido na criação do pipeline, não derivado do evento de origem.
+ O `revisionType`, `S3_OBJECT_VERSION_ID` neste exemplo, é o valor dinâmico, definido na criação do pipeline, não derivado do evento de origem.
+ O`revisionValue`, < *revisionValue* > neste exemplo, é derivado da variável de evento de origem.
```
---
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. Salve o modelo atualizado no computador local e abra o CloudFormation console.
1. Selecione sua pilha e clique em **Create Change Set for Current Stack (Criar conjunto de alterações para a pilha atual)**.
1. Carregue o modelo atualizado e, em seguida, visualize as alterações listadas no CloudFormation. Essas são as alterações que serão feitas na pilha. Seus novos recursos devem ser exibidos na lista.
1. Clique em **Executar**.
**Para editar o PollForSourceChanges parâmetro do seu funil**
**Importante**
Ao criar um pipeline com esse método, o parâmetro `PollForSourceChanges` é padronizado como verdadeiro se não for explicitamente definido como falso. Ao adicionar a detecção de alterações baseada em eventos, é necessário adicionar o parâmetro a sua saída e defini-lo como falso para desativar a sondagem. Caso contrário, o pipeline inicia duas vezes para uma única alteração de origem. Para obter detalhes, consulte [Configurações válidas para o parâmetro `PollForSourceChanges`](PollForSourceChanges-defaults.md).
+ No modelo, altere `PollForSourceChanges` para `false`. Se você não incluir `PollForSourceChanges` na sua definição de pipeline, adicione-o e configure para `false`.
**Por que estou fazendo essa alteração?** A alteração de `PollForSourceChanges` para `false` desativa as verificações periódicas para que você possa utilizar apenas a detecção de alterações baseada em 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 criar um segundo modelo para os recursos do seu pipeline do Amazon S3 CloudTrail**
+ Em um modelo separado, em`Resources`, use o`AWS::S3::Bucket`,`AWS::S3::BucketPolicy`, e `AWS::CloudTrail::Trail` CloudFormation recursos para fornecer uma definição simples de bucket e uma trilha para CloudTrail.
**Por que estou fazendo essa alteração? ** Dado o limite atual de cinco trilhas por conta, a CloudTrail trilha deve ser criada e gerenciada separadamente. (Consulte [Limites em AWS CloudTrail](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/WhatIsCloudTrail-Limits.html).) No entanto, você pode incluir vários buckets do Amazon S3 em uma única trilha, para que possa criar a trilha uma vez e adicionar buckets do Amazon S3 para outros pipelines, conforme for necessário. Cole o seguinte no arquivo do segundo modelo de exemplo.
------
#### [ 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
}
}
}
}
...
```
------