Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.
# Connessione ad azioni di origine di Amazon S3 che utilizzano e EventBridge AWS CloudTrail
Le istruzioni in questa sezione forniscono i passaggi per creare l'azione di origine S3 che utilizza AWS CloudTrail risorse che devi creare e gestire. Per utilizzare l'azione sorgente di S3 con EventBridge ciò che non richiede AWS CloudTrail risorse aggiuntive, usa le istruzioni CLI all'indirizzo. [Esegui la migrazione delle pipeline di polling con una fonte S3 abilitata per gli eventi](update-change-detection.md#update-change-detection-S3-event)
**Importante**
Questa procedura fornisce i passaggi per creare l'azione sorgente S3 che utilizza AWS CloudTrail risorse che devi creare e gestire. La procedura per creare questa azione senza AWS CloudTrail risorse non è disponibile nella console. Per utilizzare la CLI, vedere. [Esegui la migrazione delle pipeline di polling con una fonte S3 abilitata per gli eventi](update-change-detection.md#update-change-detection-S3-event)
Per aggiungere un'azione sorgente Amazon S3 CodePipeline, puoi scegliere tra:
+ Utilizza la CodePipeline console **Create pipeline** wizard ([Crea una pipeline personalizzata (console)](pipelines-create.md#pipelines-create-console)) o la pagina **Edit action** per scegliere l'opzione del provider **S3**. La console crea una EventBridge regola e un CloudTrail percorso che avviano la pipeline quando cambia la fonte.
+ Utilizzate il AWS CLI per aggiungere la configurazione dell'`S3`azione e creare risorse aggiuntive come segue:
+ Usa la configurazione dell'azione di `S3` esempio in [Riferimento all'azione del codice sorgente di Amazon S3](action-reference-S3.md) per creare l'azione come mostrato in[Creazione di una pipeline (CLI)](pipelines-create.md#pipelines-create-cli).
+ Per impostazione predefinita, il metodo di rilevamento delle modifiche avvia la pipeline interrogando la fonte. È necessario disabilitare i controlli periodici e creare manualmente la regola di rilevamento delle modifiche e la traccia. Utilizzate uno dei seguenti metodi: [Crea una EventBridge regola per una fonte Amazon S3 (console)](create-cloudtrail-S3-source-console.md)[Crea una EventBridge regola per un codice sorgente Amazon S3 (CLI)](create-cloudtrail-S3-source-cli.md), o[Crea una EventBridge regola per un codice sorgente Amazon S3 (modello)CloudFormation](create-cloudtrail-S3-source-cfn.md).
AWS CloudTrail è un servizio che registra e filtra gli eventi sul tuo bucket di origine Amazon S3. Il trail invia le modifiche alla fonte filtrate alla regola. EventBridge La EventBridge regola rileva la modifica all'origine e quindi avvia la pipeline.
**Requisiti:**
+ Se non stai creando un trail, usa un AWS CloudTrail trail esistente per registrare gli eventi nel tuo bucket di origine Amazon S3 e inviare eventi filtrati alla regola. EventBridge
+ Crea o usa un bucket S3 esistente in cui AWS CloudTrail archiviare i relativi file di registro. AWS CloudTrail deve disporre delle autorizzazioni necessarie per inviare i file di log a un bucket Amazon S3. Il bucket non può essere configurato come bucket con [pagamento a carico del richiedente](https://docs.aws.amazon.com/AmazonS3/latest/dev/RequesterPaysBuckets.html). Quando crei un bucket Amazon S3 come parte della creazione o dell'aggiornamento di un trail nella console, AWS CloudTrail assegna automaticamente le autorizzazioni necessarie a un bucket. Per ulteriori informazioni, consulta [Amazon S3 Bucket Policy](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/create-s3-bucket-policy-for-cloudtrail.html) per. CloudTrail
# Crea una EventBridge regola per una fonte Amazon S3 (console)
Prima di configurare una regola in EventBridge, devi creare un AWS CloudTrail percorso. Per ulteriori informazioni, consulta [Creazione di un trail nella console](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/cloudtrail-create-a-trail-using-the-console-first-time.html).
**Importante**
Se usi la console per creare o modificare la pipeline, la EventBridge regola e il AWS CloudTrail percorso vengono creati automaticamente.
**Come creare un trail**
1. Apri la AWS CloudTrail console.
1. Nel riquadro di navigazione selezionare **Trails** (Percorso).
1. Scegliere **Create trail (Creare trail)**. In **Trail name (Nome trail)**, immetti un nome per il trail.
1. In **Storage location (Percorso di storage)**, creare o specificare il bucket da utilizzare per archiviare i file di log. Per impostazione predefinita, i bucket e gli oggetti Amazon S3 sono privati. Solo il proprietario della risorsa (l' AWS account che ha creato il bucket) può accedere al bucket e ai suoi oggetti. Il bucket deve disporre di una politica delle risorse che consenta AWS CloudTrail le autorizzazioni di accesso agli oggetti nel bucket.
1. In **Trail log bucket and folder**, specifica un bucket Amazon S3 e il prefisso dell'oggetto (nome della cartella) per registrare gli eventi relativi ai dati per tutti gli oggetti nella cartella. Per ogni trail puoi aggiungere fino a 250 oggetti Amazon S3. **Completa le informazioni sulla chiave di crittografia richieste e scegli Avanti.**
1. Per **Tipo di evento**, scegli **Eventi di gestione**.
1. Per **gli eventi di gestione**, scegli **Scrivi**. Il percorso registra l'attività dell'API a livello di oggetto di Amazon S3 (ad esempio `GetObject` e`PutObject`) sul bucket e sul prefisso specificati.
1. Scegliere **Write (Scrivi)**.
1. **Se sei soddisfatto del percorso, scegli Crea percorso.**
**Per creare una EventBridge regola che abbia come target la tua pipeline con una fonte Amazon S3**
1. Apri la EventBridge console Amazon all'indirizzo [https://console.aws.amazon.com/events/](https://console.aws.amazon.com/events/).
1. Nel riquadro di navigazione, scegli **Regole**. Lascia selezionato il bus predefinito o scegli un bus per eventi. Scegli **Crea regola**.
1. In **Nome**, inserisci un nome per la regola.
1. In **Tipo di regola**, scegli **Regola con un modello di evento**. Scegli **Next (Successivo)**.
1. In **Origine evento**, scegli **AWS eventi o eventi EventBridge partner**.
1. In **Tipo di evento di esempio**, scegli **AWS eventi**.
1. In **Eventi di esempio**, digita S3 come parola chiave su cui filtrare. Scegli la **chiamata AWS API tramite CloudTrail**.
1. In **Metodo di creazione**, scegli **Customer pattern (editor JSON).**
Incolla lo schema di eventi fornito di seguito. Assicurati di aggiungere il nome del bucket e la chiave dell'oggetto S3 (o nome chiave) che identifica in modo univoco l'oggetto nel bucket come. `requestParameters` In questo esempio, viene creata una regola per un bucket denominato `amzn-s3-demo-source-bucket` e una chiave oggetto di. `my-files.zip` Quando utilizzi la finestra **Edit (Modifica)** per specificare le risorse, la regola viene aggiornata per l'utilizzo di un modello eventi personalizzato.
Di seguito è riportato un esempio di modello di eventi da copiare e incollare:
```
{
"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. Scegli **Next (Successivo)**.
1. In **Tipi di Target**, scegli **AWS service**.
1. In **Seleziona un obiettivo**, scegli **CodePipeline**. In **Pipeline ARN**, immettete l'ARN della pipeline per la pipeline da avviare in base a questa regola.
**Nota**
Per ottenere l'ARN della pipeline, esegui il comando **get-pipeline**. L'ARN della pipeline viene visualizzato nell'output. Il formato è il seguente:
*region**account*arn:aws:codepipeline::: *pipeline-name*
ARN della pipeline di esempio:
arn:aws:codepipeline:us-east- 2:80398 ESEMPIO: MyFirstPipeline
1. Per creare o specificare un ruolo di servizio IAM che conceda le EventBridge autorizzazioni per richiamare il target associato alla regola (in questo caso, l'obiettivo è): EventBridge CodePipeline
+ Scegli **Crea un nuovo ruolo per questa risorsa specifica per** creare un ruolo di servizio che ti dia EventBridge le autorizzazioni per avviare le esecuzioni della pipeline.
+ Scegli **Usa il ruolo esistente** per inserire un ruolo di servizio che ti dia EventBridge le autorizzazioni per avviare le esecuzioni della pipeline.
1. (Facoltativo) Per specificare le sostituzioni di origine con un ID di immagine specifico, utilizzate il trasformatore di input per passare i dati come parametri JSON. Puoi anche usare il trasformatore di input per passare le variabili della pipeline.
+ Espandere **Additional settings** (Impostazioni aggiuntive).
In **Configura l'input di destinazione**, scegli **Configura trasformatore di ingresso**.
Nella finestra di dialogo, scegli **Inserisci il mio.** Nella casella **Percorso di input**, digitate le seguenti coppie chiave-valore.
```
{"revisionValue": "$.detail.object.version-id"}
```
+ Nella casella **Modello**, digitate le seguenti coppie chiave-valore.
```
{
"sourceRevisions": [
{
"actionName": "Source",
"revisionType": "S3_OBJECT_VERSION_ID",
"revisionValue": ""
}
],
"variables": [
{
"name": "Variable_Name",
"value": "Variable_Value"
}
]
}
```
+ Scegli **Conferma**.
1. Scegli **Next (Successivo)**.
1. **Nella pagina **Tag**, scegli Avanti.**
1. Nella pagina **Rivedi e crea**, esamina la configurazione della regola. Se la regola ti soddisfa, scegli **Create rule** (Crea regola).
# Crea una EventBridge regola per un codice sorgente Amazon S3 (CLI)
**Per creare un AWS CloudTrail percorso e abilitare la registrazione**
Per utilizzare il AWS CLI per creare una traccia, chiamate il **create-trail** comando, specificando:
+ Il nome del trail.
+ Il bucket nel quale hai già applicato le policy del bucket per AWS CloudTrail.
Per ulteriori informazioni, vedere [Creazione di un percorso con l'interfaccia a riga di AWS comando](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/cloudtrail-create-and-update-a-trail-by-using-the-aws-cli.html).
1. Chiama il comando **create-trail** e includi i parametri `--name` e `--s3-bucket-name`.
**Perché occorre apportare questa modifica?** Questo crea il trail CloudTrail richiesto per il bucket di origine S3.
Il comando seguente utilizza `--name` e `--s3-bucket-name` per creare un trail denominato `my-trail` e un bucket denominato `amzn-s3-demo-source-bucket`.
```
aws cloudtrail create-trail --name my-trail --s3-bucket-name amzn-s3-demo-source-bucket
```
1. Chiama il comando **start-logging** e includi il parametro `--name`.
**Perché sto apportando questa modifica?** Questo comando avvia la CloudTrail registrazione per il bucket di origine e invia gli eventi a. EventBridge
Esempio:
Il comando seguente utilizza `--name` per avviare la registrazione su un trail denominato `my-trail`.
```
aws cloudtrail start-logging --name my-trail
```
1. Chiama il comando **put-event-selectors** e includi i parametri `--trail-name` e `--event-selectors`. Usa i selettori di eventi per specificare che desideri che il tuo trail registri gli eventi di dati per il tuo bucket di origine e invii gli eventi alla regola. EventBridge
**Perché sto apportando questa modifica?** Questo comando filtra gli eventi.
Esempio:
Il comando seguente utilizza `--trail-name` e `--event-selectors` per specificare gli eventi dati per un bucket e un prefisso di origine denominati `amzn-s3-demo-source-bucket/myFolder`.
```
aws cloudtrail put-event-selectors --trail-name my-trail --event-selectors '[{ "ReadWriteType": "WriteOnly", "IncludeManagementEvents":false, "DataResources": [{ "Type": "AWS::S3::Object", "Values": ["arn:aws:s3:::amzn-s3-demo-source-bucket/myFolder/file.zip"] }] }]'
```
**Per creare una EventBridge regola con Amazon S3 come origine dell'evento e CodePipeline come destinazione e applicare la politica delle autorizzazioni**
1. Concedi le autorizzazioni EventBridge da utilizzare per CodePipeline richiamare la regola. Per ulteriori informazioni, consulta [Utilizzo delle politiche basate sulle risorse per Amazon](https://docs.aws.amazon.com/eventbridge/latest/userguide/eb-use-resource-based.html). EventBridge
1. Usa l'esempio seguente per creare la politica di fiducia che EventBridge consenta di assumere il ruolo di servizio. Denominalo `trustpolicyforEB.json`.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": "events.amazonaws.com"
},
"Action": "sts:AssumeRole"
}
]
}
```
------
1. Utilizza il seguente comando per creare il ruolo `Role-for-MyRule` e collegare la policy di attendibilità.
**Perché occorre apportare questa modifica?** L'aggiunta di questa politica di fiducia al ruolo crea le autorizzazioni per EventBridge.
```
aws iam create-role --role-name Role-for-MyRule --assume-role-policy-document file://trustpolicyforEB.json
```
1. Crea il JSON della policy delle autorizzazioni, come mostrato qui per la pipeline denominata `MyFirstPipeline`. Denomina la policy delle autorizzazioni `permissionspolicyforEB.json`.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"codepipeline:StartPipelineExecution"
],
"Resource": [
"arn:aws:codepipeline:us-west-2:111122223333:MyFirstPipeline"
]
}
]
}
```
------
1. Utilizza il comando seguente per collegare la nuova policy delle autorizzazioni `CodePipeline-Permissions-Policy-for-EB` al ruolo `Role-for-MyRule` che hai creato.
```
aws iam put-role-policy --role-name Role-for-MyRule --policy-name CodePipeline-Permissions-Policy-For-EB --policy-document file://permissionspolicyforEB.json
```
1. Richiama il comando **put-rule** e includi i parametri `--name`, `--event-pattern` e `--role-arn`.
Il seguente comando di esempio crea una regola denominata `MyS3SourceRule`.
```
aws events put-rule --name "MyS3SourceRule" --event-pattern "{\"source\":[\"aws.s3\"],\"detail-type\":[\"AWS API Call via CloudTrail\"],\"detail\":{\"eventSource\":[\"s3.amazonaws.com\"],\"eventName\":[\"CopyObject\",\"PutObject\",\"CompleteMultipartUpload\"],\"requestParameters\":{\"bucketName\":[\"amzn-s3-demo-source-bucket\"],\"key\":[\"my-key\"]}}}
--role-arn "arn:aws:iam::ACCOUNT_ID:role/Role-for-MyRule"
```
1. Per aggiungere CodePipeline come destinazione, chiamate il **put-targets** comando e includete i `--targets` parametri `--rule` and.
Il comando seguente specifica che per la regola denominata `MyS3SourceRule`, la destinazione `Id` è composta dal numero uno, per indicare che in un elenco di destinazioni per la regola questa è la destinazione 1. Il comando specifica anche un esempio di `ARN` per la pipeline. La pipeline si avvia quando si verifica una modifica nel repository.
```
aws events put-targets --rule MyS3SourceRule --targets Id=1,Arn=arn:aws:codepipeline:us-west-2:80398EXAMPLE:TestPipeline
```
1. (Facoltativo) Per configurare un trasformatore di ingresso con sostituzioni di origine per un ID immagine specifico, utilizzate il seguente codice JSON nel comando CLI. L'esempio seguente configura un override in cui:
+ `Source`In questo esempio`actionName`, è il valore dinamico, definito al momento della creazione della pipeline, non derivato dall'evento di origine.
+ `S3_OBJECT_VERSION_ID`In questo esempio`revisionType`, è il valore dinamico, definito al momento della creazione della pipeline, non derivato dall'evento di origine.
+ Il`revisionValue`, < *revisionValue* > in questo esempio, è derivato dalla variabile dell'evento source.
```
{
"Rule": "my-rule",
"Targets": [
{
"Id": "MyTargetId",
"Arn": "ARN",
"InputTransformer": {
"InputPathsMap": {
"revisionValue": "$.detail.object.version-id"
},
"InputTemplate": {
"sourceRevisions": {
"actionName": "Source",
"revisionType": "S3_OBJECT_VERSION_ID",
"revisionValue": ""
}
}
}
}
]
}
```
**Per modificare il parametro della PollForSourceChanges pipeline**
**Importante**
Quando crei una pipeline con questo metodo, il parametro `PollForSourceChanges` è preimpostato su "true" se non viene impostato esplicitamente su "false". Quando aggiungi il rilevamento delle modifiche basato su eventi, devi aggiungere il parametro all'output e impostarlo su "false" per disabilitare il polling. In caso contrario, la pipeline si avvia due volte per una singola modifica dell'origine. Per informazioni dettagliate, vedi [Impostazioni valide per il `PollForSourceChanges` parametro](PollForSourceChanges-defaults.md).
1. Esegui il comando **get-pipeline** per copiare la struttura della pipeline in un file JSON. Ad esempio, per una pipeline denominata `MyFirstPipeline`, esegui il seguente comando:
```
aws codepipeline get-pipeline --name MyFirstPipeline >pipeline.json
```
Questo comando non restituisce alcun valore, ma nella directory in cui è stato eseguito dovrebbe comparire il file creato.
1. Apri il file JSON in qualsiasi editor di testo normale e modifica la fase di origine modificando il parametro `PollForSourceChanges` per un bucket denominato `amzn-s3-demo-source-bucket``false` come mostrato nell'esempio seguente.
**Perché occorre apportare questa modifica?** L'impostazione del parametro su `false` disattiva i controlli periodici, in modo che sia possibile utilizzare solo il rilevamento delle modifiche basato su eventi.
```
"configuration": {
"S3Bucket": "amzn-s3-demo-source-bucket",
"PollForSourceChanges": "false",
"S3ObjectKey": "index.zip"
},
```
1. Se stai utilizzando la struttura della pipeline recuperata tramite il comando **get-pipeline**, devi rimuovere le righe `metadata` dal file JSON. In caso contrario, il comando **update-pipeline** non è in grado di utilizzarlo. Rimuovi le righe `"metadata": { }` e i campi `"created"`, `"pipelineARN"` e `"updated"`.
Ad esempio, rimuovere dalla struttura le seguenti righe:
```
"metadata": {
"pipelineArn": "arn:aws:codepipeline:region:account-ID:pipeline-name",
"created": "date",
"updated": "date"
},
```
Salvare il file.
1. Per applicare le modifiche, eseguire il comando **update-pipeline**, specificando il file JSON della pipeline:
**Importante**
Assicurarsi di includere `file://` prima del nome del file. Questo è obbligatorio in questo comando.
```
aws codepipeline update-pipeline --cli-input-json file://pipeline.json
```
Questo comando restituisce l'intera struttura della pipeline modificata.
**Nota**
Il comando **update-pipeline** arresta la pipeline. Se è in corso di elaborazione una versione durante l'esecuzione del comando **update-pipeline**, tale elaborazione viene arrestata. Per elaborare tale versione utilizzando la pipeline aggiornata, devi avviare manualmente la pipeline. Utilizza il comando **start-pipeline-execution** per avviare manualmente la pipeline.
# Crea una EventBridge regola per un codice sorgente Amazon S3 (modello)CloudFormation
Per utilizzarla CloudFormation per creare una regola, aggiorna il modello come mostrato qui.
**Per creare una EventBridge regola con Amazon S3 come origine dell'evento e CodePipeline come destinazione e applicare la politica delle autorizzazioni**
1. Nel modello, sotto`Resources`, utilizza la `AWS::IAM::Role` CloudFormation risorsa per configurare il ruolo IAM che consente all'evento di avviare la pipeline. Questa voce crea un ruolo che utilizza due policy:
+ La prima policy consente di assumere quel ruolo.
+ La seconda policy fornisce le autorizzazioni per avviare la pipeline.
**Perché occorre apportare questa modifica?** L'aggiunta di `AWS::IAM::Role` risorse consente CloudFormation di creare autorizzazioni per. EventBridge Questa risorsa viene aggiunta al tuo CloudFormation stack.
------
#### [ YAML ]
```
EventRole:
Type: AWS::IAM::Role
Properties:
AssumeRolePolicyDocument:
Version: 2012-10-17
Statement:
-
Effect: Allow
Principal:
Service:
- events.amazonaws.com
Action: sts:AssumeRole
Path: /
Policies:
-
PolicyName: eb-pipeline-execution
PolicyDocument:
Version: 2012-10-17
Statement:
-
Effect: Allow
Action: codepipeline:StartPipelineExecution
Resource: !Join [ '', [ 'arn:aws:codepipeline:', !Ref 'AWS::Region', ':', !Ref 'AWS::AccountId', ':', !Ref AppPipeline ] ]
...
```
------
#### [ JSON ]
```
"EventRole": {
"Type": "AWS::IAM::Role",
"Properties": {
"AssumeRolePolicyDocument": {
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": [
"events.amazonaws.com"
]
},
"Action": "sts:AssumeRole"
}
]
},
"Path": "/",
"Policies": [
{
"PolicyName": "eb-pipeline-execution",
"PolicyDocument": {
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": "codepipeline:StartPipelineExecution",
"Resource": {
"Fn::Join": [
"",
[
"arn:aws:codepipeline:",
{
"Ref": "AWS::Region"
},
":",
{
"Ref": "AWS::AccountId"
},
":",
{
"Ref": "AppPipeline"
}
]
]
...
```
------
1. Usa la `AWS::Events::Rule` CloudFormation risorsa per aggiungere una EventBridge regola. Questo modello di eventi crea un evento che monitora `CopyObject` `PutObject` e `CompleteMultipartUpload` sul tuo bucket di origine Amazon S3. Inoltre, include una destinazione della pipeline. Quando si verifica `CopyObject`, `PutObject` o `CompleteMultipartUpload`, questa regola richiama `StartPipelineExecution` sulla pipeline di destinazione.
**Perché occorre apportare questa modifica?** L'aggiunta della `AWS::Events::Rule` risorsa consente di CloudFormation creare l'evento. Questa risorsa viene aggiunta al tuo CloudFormation stack.
------
#### [ YAML ]
```
EventRule:
Type: AWS::Events::Rule
Properties:
EventPattern:
source:
- aws.s3
detail-type:
- 'AWS API Call via CloudTrail'
detail:
eventSource:
- s3.amazonaws.com
eventName:
- CopyObject
- PutObject
- CompleteMultipartUpload
requestParameters:
bucketName:
- !Ref SourceBucket
key:
- !Ref SourceObjectKey
Targets:
-
Arn:
!Join [ '', [ 'arn:aws:codepipeline:', !Ref 'AWS::Region', ':', !Ref 'AWS::AccountId', ':', !Ref AppPipeline ] ]
RoleArn: !GetAtt EventRole.Arn
Id: codepipeline-AppPipeline
...
```
------
#### [ JSON ]
```
"EventRule": {
"Type": "AWS::Events::Rule",
"Properties": {
"EventPattern": {
"source": [
"aws.s3"
],
"detail-type": [
"AWS API Call via CloudTrail"
],
"detail": {
"eventSource": [
"s3.amazonaws.com"
],
"eventName": [
"CopyObject",
"PutObject",
"CompleteMultipartUpload"
],
"requestParameters": {
"bucketName": [
{
"Ref": "SourceBucket"
}
],
"key": [
{
"Ref": "SourceObjectKey"
}
]
}
}
},
"Targets": [
{
"Arn": {
"Fn::Join": [
"",
[
"arn:aws:codepipeline:",
{
"Ref": "AWS::Region"
},
":",
{
"Ref": "AWS::AccountId"
},
":",
{
"Ref": "AppPipeline"
}
]
]
},
"RoleArn": {
"Fn::GetAtt": [
"EventRole",
"Arn"
]
},
"Id": "codepipeline-AppPipeline"
}
]
}
}
},
...
```
------
1. Aggiungere questo snippet di codice al primo modello per consentire la funzionalità tra stack:
------
#### [ YAML ]
```
Outputs:
SourceBucketARN:
Description: "S3 bucket ARN that Cloudtrail will use"
Value: !GetAtt SourceBucket.Arn
Export:
Name: SourceBucketARN
```
------
#### [ JSON ]
```
"Outputs" : {
"SourceBucketARN" : {
"Description" : "S3 bucket ARN that Cloudtrail will use",
"Value" : { "Fn::GetAtt": ["SourceBucket", "Arn"] },
"Export" : {
"Name" : "SourceBucketARN"
}
}
...
```
------
1. (Facoltativo) Per configurare un trasformatore di ingresso con sostituzioni di sorgente per un ID di immagine specifico, utilizzate il seguente frammento di codice YAML. L'esempio seguente configura un override in cui:
+ `Source`In questo esempio`actionName`, è il valore dinamico, definito al momento della creazione della pipeline, non derivato dall'evento di origine.
+ `S3_OBJECT_VERSION_ID`In questo esempio`revisionType`, è il valore dinamico, definito al momento della creazione della pipeline, non derivato dall'evento di origine.
+ Il`revisionValue`, < *revisionValue* > in questo esempio, è derivato dalla variabile dell'evento source.
```
---
Rule: my-rule
Targets:
- Id: MyTargetId
Arn: pipeline-ARN
InputTransformer:
InputPathsMap:
revisionValue: "$.detail.object.version-id"
InputTemplate:
sourceRevisions:
actionName: Source
revisionType: S3_OBJECT_VERSION_ID
revisionValue: ''
```
1. Salva il modello aggiornato sul computer locale e apri la CloudFormation console.
1. Seleziona lo stack e scegli **Create Change Set for Current Stack (Crea set di modifiche per lo stack corrente)**.
1. Caricare il modello aggiornato e quindi visualizzare le modifiche elencate in CloudFormation. Queste sono le modifiche che verranno apportate allo stack. Le nuove risorse dovrebbero essere visibili nell'elenco.
1. Scegli **Esegui**.
**Per modificare i parametri della PollForSourceChanges pipeline**
**Importante**
Quando crei una pipeline con questo metodo, il parametro `PollForSourceChanges` è preimpostato su "true" se non viene impostato esplicitamente su "false". Quando aggiungi il rilevamento delle modifiche basato su eventi, devi aggiungere il parametro all'output e impostarlo su "false" per disabilitare il polling. In caso contrario, la pipeline si avvia due volte per una singola modifica dell'origine. Per informazioni dettagliate, vedi [Impostazioni valide per il `PollForSourceChanges` parametro](PollForSourceChanges-defaults.md).
+ Nel modello, modifica `PollForSourceChanges` in `false`. Se non hai incluso `PollForSourceChanges` nella definizione della pipeline, aggiungilo e impostalo su `false`.
**Perché occorre apportare questa modifica?** La modifica di `PollForSourceChanges` in `false` disattiva i controlli periodici, in modo che sia possibile utilizzare solo il rilevamento delle modifiche basato su eventi.
------
#### [ YAML ]
```
Name: Source
Actions:
-
Name: SourceAction
ActionTypeId:
Category: Source
Owner: AWS
Version: 1
Provider: S3
OutputArtifacts:
- Name: SourceOutput
Configuration:
S3Bucket: !Ref SourceBucket
S3ObjectKey: !Ref SourceObjectKey
PollForSourceChanges: false
RunOrder: 1
```
------
#### [ JSON ]
```
{
"Name": "SourceAction",
"ActionTypeId": {
"Category": "Source",
"Owner": "AWS",
"Version": 1,
"Provider": "S3"
},
"OutputArtifacts": [
{
"Name": "SourceOutput"
}
],
"Configuration": {
"S3Bucket": {
"Ref": "SourceBucket"
},
"S3ObjectKey": {
"Ref": "SourceObjectKey"
},
"PollForSourceChanges": false
},
"RunOrder": 1
}
```
------
**Per creare un secondo modello per le risorse della tua pipeline Amazon S3 CloudTrail**
+ In un modello separato, sotto`Resources`, utilizza le `AWS::CloudTrail::Trail` CloudFormation risorse `AWS::S3::Bucket``AWS::S3::BucketPolicy`, e per fornire una definizione e un percorso semplici per il bucket. CloudTrail
**Perché sto apportando questa modifica?** Dato l'attuale limite di cinque percorsi per account, il CloudTrail percorso deve essere creato e gestito separatamente. (Vedi [Limiti in AWS CloudTrail](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/WhatIsCloudTrail-Limits.html).) Tuttavia, puoi includere molti bucket Amazon S3 in un singolo trail, in modo da poter creare il trail una sola volta e poi aggiungere bucket Amazon S3 per altre pipeline, se necessario. Incolla quanto segue nel secondo file di modello di esempio.
------
#### [ YAML ]
```
###################################################################################
# Prerequisites:
# - S3 SourceBucket and SourceObjectKey must exist
###################################################################################
Parameters:
SourceObjectKey:
Description: 'S3 source artifact'
Type: String
Default: SampleApp_Linux.zip
Resources:
AWSCloudTrailBucketPolicy:
Type: AWS::S3::BucketPolicy
Properties:
Bucket: !Ref AWSCloudTrailBucket
PolicyDocument:
Version: 2012-10-17
Statement:
-
Sid: AWSCloudTrailAclCheck
Effect: Allow
Principal:
Service:
- cloudtrail.amazonaws.com
Action: s3:GetBucketAcl
Resource: !GetAtt AWSCloudTrailBucket.Arn
-
Sid: AWSCloudTrailWrite
Effect: Allow
Principal:
Service:
- cloudtrail.amazonaws.com
Action: s3:PutObject
Resource: !Join [ '', [ !GetAtt AWSCloudTrailBucket.Arn, '/AWSLogs/', !Ref 'AWS::AccountId', '/*' ] ]
Condition:
StringEquals:
s3:x-amz-acl: bucket-owner-full-control
AWSCloudTrailBucket:
Type: AWS::S3::Bucket
DeletionPolicy: Retain
AwsCloudTrail:
DependsOn:
- AWSCloudTrailBucketPolicy
Type: AWS::CloudTrail::Trail
Properties:
S3BucketName: !Ref AWSCloudTrailBucket
EventSelectors:
-
DataResources:
-
Type: AWS::S3::Object
Values:
- !Join [ '', [ !ImportValue SourceBucketARN, '/', !Ref SourceObjectKey ] ]
ReadWriteType: WriteOnly
IncludeManagementEvents: false
IncludeGlobalServiceEvents: true
IsLogging: true
IsMultiRegionTrail: true
...
```
------
#### [ JSON ]
```
{
"Parameters": {
"SourceObjectKey": {
"Description": "S3 source artifact",
"Type": "String",
"Default": "SampleApp_Linux.zip"
}
},
"Resources": {
"AWSCloudTrailBucket": {
"Type": "AWS::S3::Bucket",
"DeletionPolicy": "Retain"
},
"AWSCloudTrailBucketPolicy": {
"Type": "AWS::S3::BucketPolicy",
"Properties": {
"Bucket": {
"Ref": "AWSCloudTrailBucket"
},
"PolicyDocument": {
"Version": "2012-10-17",
"Statement": [
{
"Sid": "AWSCloudTrailAclCheck",
"Effect": "Allow",
"Principal": {
"Service": [
"cloudtrail.amazonaws.com"
]
},
"Action": "s3:GetBucketAcl",
"Resource": {
"Fn::GetAtt": [
"AWSCloudTrailBucket",
"Arn"
]
}
},
{
"Sid": "AWSCloudTrailWrite",
"Effect": "Allow",
"Principal": {
"Service": [
"cloudtrail.amazonaws.com"
]
},
"Action": "s3:PutObject",
"Resource": {
"Fn::Join": [
"",
[
{
"Fn::GetAtt": [
"AWSCloudTrailBucket",
"Arn"
]
},
"/AWSLogs/",
{
"Ref": "AWS::AccountId"
},
"/*"
]
]
},
"Condition": {
"StringEquals": {
"s3:x-amz-acl": "bucket-owner-full-control"
}
}
}
]
}
}
},
"AwsCloudTrail": {
"DependsOn": [
"AWSCloudTrailBucketPolicy"
],
"Type": "AWS::CloudTrail::Trail",
"Properties": {
"S3BucketName": {
"Ref": "AWSCloudTrailBucket"
},
"EventSelectors": [
{
"DataResources": [
{
"Type": "AWS::S3::Object",
"Values": [
{
"Fn::Join": [
"",
[
{
"Fn::ImportValue": "SourceBucketARN"
},
"/",
{
"Ref": "SourceObjectKey"
}
]
]
}
]
}
],
"ReadWriteType": "WriteOnly",
"IncludeManagementEvents": false
}
],
"IncludeGlobalServiceEvents": true,
"IsLogging": true,
"IsMultiRegionTrail": true
}
}
}
}
...
```
------