

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

# Utilizzo EventBridge con le pipeline di Image Builder
<a name="ev-rules-for-pipeline"></a>

AWS e i servizi partner trasmettono gli eventi agli EventBridge event bus di Amazon quasi in tempo reale. Puoi anche inviare i tuoi eventi personalizzati. I bus per eventi utilizzano regole per indirizzare ogni evento verso uno o più obiettivi.

Image Builder funziona EventBridge in due direzioni indipendenti:
+ **Avvia la creazione di una pipeline a partire da una regola. ** È possibile impostare una pipeline di Image Builder come destinazione della regola, in modo EventBridge da eseguire la pipeline quando un evento corrisponde alla regola o quando viene attivato un programma. Consulta [Attiva una pipeline costruita in base a una pianificazione](#ev-rules-schedule-pipeline) e [Attiva una pipeline creata a partire da un pattern di eventi](#ev-trigger-pipeline-pattern).
+ **Reagisci agli eventi inviati da Image Builder. ** Image Builder pubblica gli eventi sul bus degli eventi predefinito quando si verificano modifiche significative, ad esempio quando un'immagine diventa `AVAILABLE` o una scansione rileva CVE. Puoi abbinare questi eventi a una regola e indirizzarli verso obiettivi come una funzione Lambda o un argomento di Amazon SNS per avviare le tue automazioni. Per informazioni, consulta [Reagisci agli eventi inviati da Image Builder](#ev-create-reaction-rule).

Per ulteriori informazioni sugli eventi inviati da Image Builder e sui campi di ciascun evento, consulta. [Messaggi di eventi inviati da Image Builder](integ-eventbridge.md#integ-eb-event-summary)

**Nota**  
I bus per eventi sono Region-specific. Una regola e le risorse richiamate si trovano in genere nella stessa regione; per passare da una regione all'altra, scegli come destinazione un bus di eventi nella regione di destinazione. Image Builder pubblica i suoi eventi sul bus di eventi predefinito nella regione in cui viene eseguita la compilazione.

**Topics**
+ [EventBridge termini](#ev-terms)
+ [Visualizza EventBridge le regole per la tua pipeline di Image Builder](#ev-rules-pipeline-tab)
+ [Attiva una pipeline costruita in base a una pianificazione](#ev-rules-schedule-pipeline)
+ [Attiva una pipeline creata a partire da un pattern di eventi](#ev-trigger-pipeline-pattern)
+ [Reagisci agli eventi inviati da Image Builder](#ev-create-reaction-rule)

## EventBridge termini
<a name="ev-terms"></a>

I seguenti termini ti aiutano a capire come si EventBridge integra con le tue pipeline di Image Builder.

Event  
Descrive una modifica in un ambiente che potrebbe influire su una o più risorse dell'applicazione. L'ambiente può essere un AWS ambiente, un servizio o un'applicazione di un partner SaaS oppure una delle tue applicazioni o servizi. Puoi anche impostare eventi programmati su una sequenza temporale.

Router di eventi  
Una pipeline che riceve dati sugli eventi da applicazioni e servizi.

Origine  
Il servizio o l'applicazione che ha inviato l'evento al bus degli eventi.

Target  
Una risorsa o un endpoint che EventBridge richiama quando corrisponde a una regola, fornendo i dati dall'evento alla destinazione.

Regola  
Una regola trova gli eventi in entrata corrispondenti e li invia alle destinazioni per l'elaborazione. Una singola regola può inviare un evento a più destinazioni, che possono quindi essere eseguite in parallelo. Le regole si basano su un modello di eventi o su una pianificazione.

Pattern  
Un pattern di eventi definisce la struttura dell'evento e i campi a cui una regola corrisponde per avviare l'azione target.

Schedule  
Le regole di pianificazione eseguono un'azione in base a una pianificazione, ad esempio l'esecuzione di una pipeline di Image Builder per aggiornare un'immagine su base trimestrale. Esistono due tipi di espressioni di pianificazione:   
+ **Espressioni cron**: corrispondono a criteri di pianificazione specifici utilizzando la sintassi cron che può delineare criteri semplici, ad esempio una esecuzione settimanale in un giorno specifico. È inoltre possibile stabilire criteri più complessi, ad esempio l'esecuzione trimestrale il quinto giorno del mese, tra le 2:00 e le 4:00.
+ **Espressioni di frequenza**: specificate un intervallo regolare quando viene richiamato l'obiettivo, ad esempio ogni 12 ore.

## Visualizza EventBridge le regole per la tua pipeline di Image Builder
<a name="ev-rules-pipeline-tab"></a>

La ** scheda ** EventBridge delle regole nella pagina dei ** dettagli delle pipeline di ** immagini di Image Builder mostra i bus di EventBridge eventi a cui l'account ha accesso e le regole per il bus di eventi selezionato che si applicano alla pipeline corrente. Questa scheda si collega anche direttamente alla EventBridge console per la creazione di nuove risorse.

**Azioni che si collegano alla EventBridge console**
+ **Crea un bus di eventi **
+ **Creare una regola**

Per saperne di più EventBridge, consulta i seguenti argomenti nella * Amazon EventBridge User Guide*.
+ [Che cos'è Amazon EventBridge ](https://docs.aws.amazon.com/eventbridge/latest/userguide/eb-what-is.html)
+ [Bus per EventBridge eventi Amazon ](https://docs.aws.amazon.com/eventbridge/latest/userguide/eb-event-bus.html)
+ [ EventBridge Eventi Amazon ](https://docs.aws.amazon.com/eventbridge/latest/userguide/eb-events.html)
+ [ EventBridge Regole di Amazon ](https://docs.aws.amazon.com/eventbridge/latest/userguide/eb-rules.html)

## Attiva una pipeline costruita in base a una pianificazione
<a name="ev-rules-schedule-pipeline"></a>

Imposta una pipeline di Image Builder come destinazione di una regola di EventBridge pianificazione per aggiornare un'immagine con una cadenza regolare. L'esempio seguente crea una regola che avvia la creazione di una pipeline ogni 90 giorni.

**Nota**  
Una pipeline può anche avere una propria ** pianificazione integrata ** (un'espressione cron o rate memorizzata nella pipeline). Tale pianificazione è gestita da Image Builder ed è separata da qualsiasi regola: EventBridge   
Usa la pianificazione della ** pipeline ** per una semplice ricostruzione ricorrente. Può anche effettuare il gate di build in base agli aggiornamenti delle dipendenze e disabilitare automaticamente una pipeline in errore. Vedi `Schedule` nel riferimento alle API di * EC2 Image Builder. *
Usa una ** EventBridge regola ** per avviare una build da un pattern di eventi o per estendere un trigger a più target.

------
#### [ Console di gestione AWS ]

1. Apri la console EC2 Image Builder all'indirizzo [ https://console.aws.amazon.com/imagebuilder/](https://console.aws.amazon.com/imagebuilder/).

1. Per visualizzare un elenco delle pipeline di immagini create con il tuo account, scegli ** Image pipelines ** dal pannello di navigazione.
**Nota**  
L'elenco delle pipeline di immagini include un indicatore del tipo di immagine di output creata dalla pipeline: AMI o. Docker

1. Per visualizzare i dettagli o modificare una pipeline, scegliete il link relativo al nome della ** pipeline. ** Si apre la vista dei dettagli della pipeline.
**Nota**  
Puoi anche selezionare la casella di controllo accanto al nome della ** pipeline**, quindi scegliere ** Visualizza dettagli. **

1. Apri la ** scheda ** EventBridge delle regole.

1. Mantieni il bus di eventi predefinito preselezionato nel ** pannello ** Event Bus.

1. Scegli **Crea regola**. Verrai reindirizzato alla ** pagina ** Create rule nella EventBridge console Amazon.

1. Inserisci un nome e una descrizione per la regola. Il nome della regola deve essere univoco all'interno del bus di eventi per la regione selezionata.

1. Nel ** pannello ** Definisci modello, scegliete l'**opzione ** Pianificazione. Questo espande il pannello, con tutte le ** opzioni selezionate per la tariffa ** fissa.

1. Inserisci `90` nella prima casella e seleziona ** Giorni ** dall'elenco a discesa.

1. Esegui le seguenti azioni nel pannello ** Seleziona obiettivi**:

   1. Seleziona `EC2 Image Builder` dall'elenco a ** discesa ** Target.

   1. Per applicare la regola a una pipeline di Image Builder, selezionate la pipeline di destinazione dall'elenco a discesa ** Image Pipeline. **

   1. EventBridge necessita dell'autorizzazione per avviare una build per la pipeline selezionata. Per questo esempio, mantieni l'opzione predefinita ** Crea un nuovo ruolo per questa risorsa specifica. **

   1. Scegliere **Add target (Aggiungi target)**.

1. Scegli **Crea**

**Nota**  
La EventBridge console corrente può creare pianificazioni tramite EventBridge Scheduler e le etichette e i passaggi esatti possono cambiare nel tempo. La * Amazon EventBridge User Guide collegata * è autorevole per l'attuale esperienza sulla console.

------
#### [ AWS CLI ]

Questi passaggi creano una regola di pianificazione che avvia la creazione di una pipeline ogni 90 giorni. EventBridge ha bisogno di un ruolo IAM che possa assumere per utilizzare `imagebuilder:StartImagePipelineExecution` la pipeline.

1. Crea una regola con un'espressione di frequenza:

   ```
   aws events put-rule \
     --name refresh-image-every-90-days \
     --schedule-expression "rate(90 days)"
   ```

1. Crea un ruolo IAM che EventBridge possa assumere, con questa politica di fiducia:

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

   Allega una policy di autorizzazioni che consenta l'avvio della pipeline:

   ```
   {
       "Version": "2012-10-17",
       "Statement": [{
           "Effect": "Allow",
           "Action": "imagebuilder:StartImagePipelineExecution",
           "Resource": "arn:aws:imagebuilder:{{us-west-2}}:{{111122223333}}:image-pipeline/{{my-pipeline}}"
       }]
   }
   ```

1. Aggiungi la pipeline come destinazione della regola, facendo riferimento al ruolo del passaggio precedente:

   ```
   aws events put-targets \
     --rule refresh-image-every-90-days \
     --targets '[{
       "Id": "1",
       "Arn": "arn:aws:imagebuilder:{{us-west-2}}:{{111122223333}}:image-pipeline/{{my-pipeline}}",
       "RoleArn": "arn:aws:iam::{{111122223333}}:role/{{EventBridgeImageBuilderRole}}"
     }]'
   ```

1. Conferma che l'obiettivo è collegato:

   ```
   aws events list-targets-by-rule --rule refresh-image-every-90-days
   ```

------

**Nota**  
Per ulteriori informazioni sulle impostazioni per le regole di espressione dei tassi che non sono trattate in questo esempio, consulta [ Rate expressions ](https://docs.aws.amazon.com/eventbridge/latest/userguide/eb-create-rule-schedule.html#eb-rate-expressions) nella * Amazon EventBridge User Guide*.

## Attiva una pipeline creata a partire da un pattern di eventi
<a name="ev-trigger-pipeline-pattern"></a>

Invece di una pianificazione, puoi avviare una creazione di pipeline quando un evento corrisponde a uno schema. Crea una regola con un pattern di eventi, quindi aggiungi la tua pipeline come destinazione (con lo stesso ruolo IAM descritto in[Attiva una pipeline costruita in base a una pianificazione](#ev-rules-schedule-pipeline)).

L'esempio seguente avvia una build ogni volta che diventa un'immagine di base specifica, ad esempio `AVAILABLE` per concatenare una build di immagine dipendente al termine dell'immagine di base. Il `resources` prefisso assegna la regola all'immagine di base in modo che corrisponda solo a quell'immagine e non all'output della pipeline dipendente:

```
{
    "source": ["aws.imagebuilder"],
    "detail-type": ["EC2 Image Builder Image State Change"],
    "detail": {
        "state": { "status": ["AVAILABLE"] }
    },
    "resources": [{
        "prefix": "arn:aws:imagebuilder:{{us-west-2}}:{{111122223333}}:image/{{my-base-image}}/"
    }]
}
```

**Importante**  
Ambita il pattern dell'evento all'immagine di base, come mostrato dal `resources` prefisso in questo esempio. Un pattern che corrisponde a tutte le immagini dell'account corrisponde anche all'`AVAILABLE`immagine di output della pipeline dipendente, che riavvia la pipeline e può creare un ciclo di compilazione infinito. Filtra in base al nome specifico dell'immagine di base o al prefisso ARN in modo che la regola corrisponda solo all'immagine desiderata.

------
#### [ Console di gestione AWS ]

1. Apri la EventBridge console Amazon all'indirizzo. [ https://console.aws.amazon.com/events/ ](https://console.aws.amazon.com/events/)

1. Scegli ** Regole**, quindi ** Crea regola**. Mantieni il bus di ** eventi ** predefinito.

1. Inserite un nome e una descrizione. In Tipo di ** regola**, scegli ** Regola con uno schema di eventi**.

1. Per la fonte dell'evento, scegli ** Altro ** e incolla il modello di evento qui sopra nella ** casella Modello ** evento.

1. Nel ** pannello ** Seleziona obiettivi, scegli `EC2 Image Builder` dall'elenco a ** discesa ** Target, quindi scegli la pipeline da creare dall'elenco a discesa ** Image Pipeline**.

1. EventBridge necessita dell'autorizzazione per avviare la pipeline. Mantieni l'opzione predefinita per ** creare un nuovo ruolo per questa risorsa ** specifica.

1. Scegli **Crea regola**.

------
#### [ AWS CLI ]

Crea la regola e aggiungi la pipeline come destinazione:

```
aws events put-rule \
  --name rebuild-on-base-available \
  --event-pattern '{"source":["aws.imagebuilder"],"detail-type":["EC2 Image Builder Image State Change"],"detail":{"state":{"status":["AVAILABLE"]}},"resources":[{"prefix":"arn:aws:imagebuilder:{{us-west-2}}:{{111122223333}}:image/{{my-base-image}}/"}]}'

aws events put-targets \
  --rule rebuild-on-base-available \
  --targets '[{"Id":"1","Arn":"arn:aws:imagebuilder:{{us-west-2}}:{{111122223333}}:image-pipeline/{{dependent-pipeline}}","RoleArn":"arn:aws:iam::{{111122223333}}:role/{{EventBridgeImageBuilderRole}}"}]'
```

------

Per gli eventi che puoi abbinare e i relativi campi, vedi[Messaggi di eventi inviati da Image Builder](integ-eventbridge.md#integ-eb-event-summary).

## Reagisci agli eventi inviati da Image Builder
<a name="ev-create-reaction-rule"></a>

Image Builder pubblica gli eventi sul bus eventi predefinito quando le risorse raggiungono punti significativi, ad esempio quando un'immagine cambia stato, una scansione viene completata, una fase del flusso di lavoro si interrompe per l'input o una pipeline viene automaticamente disabilitata. Puoi abbinare questi eventi a una regola e indirizzarli a un obiettivo per avviare la tua automazione. I modelli più comuni includono:
+ Invia una notifica a un team tramite un argomento di Amazon SNS quando un'immagine diventa `AVAILABLE` o`FAILED`.
+ Richiama una funzione Lambda per registrare una nuova AMI in un archivio di parametri, avviare test di conformità esterni o aggiornare una pipeline di distribuzione.
+ Avvisa sui risultati di sicurezza quando una scansione riporta CVE critici.
+ Promuovi un flusso di lavoro di approvazione quando una fase `WaitForAction` del flusso di lavoro sospende una compilazione.

Per agire su un evento inviato da Image Builder, crea una regola il cui modello di evento corrisponda all'evento `source` (`aws.imagebuilder`) e`detail-type`, facoltativamente, restringa i campi all'interno. `detail` Quindi aggiungi il target che esegue l'automazione.

**Esempio: notifica sul completamento dell'immagine (`AVAILABLE`o`FAILED`) **

```
{
    "source": ["aws.imagebuilder"],
    "detail-type": ["EC2 Image Builder Image State Change"],
    "detail": {
        "state": { "status": ["AVAILABLE", "FAILED"] }
    }
}
```

**Esempio: invia un avviso solo quando una scansione rileva CVE critici **

Usa un matcher numerico in modo che le scansioni pulite non attivino la regola:

```
{
    "source": ["aws.imagebuilder"],
    "detail-type": ["EC2 Image Builder CVE Detected"],
    "detail": {
        "finding-severity-counts": {
            "critical": [{ "numeric": [">", 0] }]
        }
    }
}
```

------
#### [ Console di gestione AWS ]

1. Apri la console Amazon all'indirizzo EventBridge . [ https://console.aws.amazon.com/events/ ](https://console.aws.amazon.com/events/)

1. Scegli ** Regole**, quindi ** Crea regola**. Mantieni il bus di ** eventi ** predefinito.

1. Inserite un nome e una descrizione. In Tipo di ** regola**, scegli ** Regola con uno schema di eventi**.

1. Per l'origine dell'evento, scegli ** Altro ** e incolla uno dei modelli di evento sopra riportati nella ** casella Schema ** evento.

1. Scegli il tuo obiettivo, ad esempio un argomento Amazon SNS o una funzione Lambda, e completa le impostazioni del target.

1. Scegli **Crea regola**.

------
#### [ AWS CLI ]

Crea la regola e invia gli eventi corrispondenti a un argomento di Amazon SNS:

```
aws events put-rule \
  --name image-available-or-failed \
  --event-pattern '{"source":["aws.imagebuilder"],"detail-type":["EC2 Image Builder Image State Change"],"detail":{"state":{"status":["AVAILABLE","FAILED"]}}}'

aws events put-targets \
  --rule image-available-or-failed \
  --targets '[{"Id":"1","Arn":"arn:aws:sns:{{us-west-2}}:{{111122223333}}:{{image-status}}"}]'
```

EventBridge richiede anche l'autorizzazione per inviare eventi al tuo target. Per ulteriori informazioni sulle autorizzazioni richieste da ciascun tipo di destinazione, consulta [ Autorizzazioni per l'invio di eventi agli obiettivi ](https://docs.aws.amazon.com/eventbridge/latest/userguide/eb-targets.html#targets-permissions) e [ Utilizzo delle politiche basate sulle risorse per Amazon EventBridge ](https://docs.aws.amazon.com/eventbridge/latest/userguide/eb-use-resource-based.html) nella Amazon User Guide. * EventBridge *

------

**Nota**  
Quando rispondi all'`EC2 Image Builder Workflow Step Waiting`evento, il tuo target può chiamare `SendWorkflowStepAction` con il mittente dell'evento e un numero `workflow-step-execution-id` di o. `action` `RESUME` `STOP` Per informazioni, consulta [WaitForAction](wfdoc-step-actions.md#wfdoc-step-action-waitfor).