

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

# Risoluzione dei problemi con Amazon EventBridge
<a name="eb-troubleshooting"></a>

Puoi utilizzare gli argomenti di questa sezione per risolvere i problemi di Amazon EventBridge .

**Suggerimento**  
Per verificare che i modelli degli eventi corrispondano agli eventi previsti, puoi utilizzare la EventBridge Sandbox per testare i modelli di eventi rispetto a eventi di esempio. Per ulteriori informazioni, consulta [Test dei modelli di eventi utilizzando la EventBridge Sandbox](eb-event-pattern-sandbox.md).

**Topics**
+ [La mia regola è stata eseguita ma la funzione Lambda non è stata richiamata](#eb-lam-function-not-invoked)
+ [Ho appena creato o modificato una regola ma non corrisponde a un evento di test](#eb-rule-does-not-match)
+ [La mia regola non è stata eseguita quando ho specificato `ScheduleExpression`](#eb-rule-did-not-trigger)
+ [La mia regola non è stata eseguita all'orario previsto](#eb-rule-did-not-trigger-on-time)
+ [La mia regola corrisponde alle chiamate API di servizio AWS globali, ma non è stata eseguita](#eb-rule-did-not-trigger-iam)
+ [Il ruolo IAM associato alla mia regola viene ignorato durante l'esecuzione della regola](#eb-iam-role-ignored)
+ [La mia regola ha un modello di eventi che dovrebbe corrispondere a una risorsa, ma nessun evento corrisponde](#eb-events-do-not-match-rule)
+ [Si è verificato un ritardo nella distribuzione del mio evento alla destinazione](#eb-delayed-event-delivery)
+ [Alcuni eventi non sono mai stati distribuiti nel target](#eb-never-delivered-to-target)
+ [La mia regola è stata eseguita più di una volta in risposta a un evento](#eb-rule-triggered-more-than-once)
+ [Come evitare loop infiniti](#eb-prevent-infinite-loops)
+ [I miei eventi non vengono distribuiti alla coda di Amazon SQS target](#eb-sqs-encrypted)
+ [La regola viene eseguita ma non vedo messaggi pubblicati nell'argomento Amazon SNS](#eb-no-messages-published-sns)
+ [Il mio argomento Amazon SNS dispone ancora delle autorizzazioni EventBridge anche dopo aver eliminato la regola associata all'argomento Amazon SNS](#eb-sns-permissions-persist)
+ [Con EventBridge quali chiavi di condizione IAM posso usare?](#eb-supported-access-policies)
+ [Come posso sapere quando EventBridge le regole vengono violate?](#eb-create-alarm-broken-event-rules)

## La mia regola è stata eseguita ma la funzione Lambda non è stata richiamata
<a name="eb-lam-function-not-invoked"></a>

Uno dei motivi per cui la funzione Lambda potrebbe non funzionare è che forse non disponi delle autorizzazioni appropriate. 

**Per verificare le autorizzazioni per la funzione Lambda**

1. Usando AWS CLI, esegui il comando seguente con la tua funzione e la tua AWS regione:

   ```
   aws lambda get-policy --function-name {{MyFunction}} --region {{us-east-1}}
   ```

   Vedrai il seguente output.

------
#### [ JSON ]

****  

   ```
   {
   "Version":"2012-10-17",		 	 	 
   "Statement": [
   {
   "Condition": {
   "ArnLike": {
   "AWS:SourceArn": "arn:aws:events:{{us-east-1}}:{{123456789012}}:rule/{{rule-name}}"
   }
   },
   "Action": "lambda:InvokeFunction",
   "Resource": "arn:aws:lambda:{{us-east-1}}:{{123456789012}}:function:{{function-name}}",
   "Effect": "Allow",
   "Principal": {
   "Service": "events.amazonaws.com"
   },
   "Sid": "MyId"
   }
   ],
   "Id": "default"
   }
   ```

------

1. Se viene visualizzato il messaggio seguente.

   ```
   A client error (ResourceNotFoundException) occurred when calling the GetPolicy operation: The resource you requested does not exist.
   ```

   Oppure, se viene visualizzato l'output ma non riesci a individuare events.amazonaws.com come entità attendibile nella policy, esegui il comando seguente:

   ```
   aws lambda add-permission \
   --function-name {{MyFunction}} \
   --statement-id {{MyId}} \
   --action 'lambda:InvokeFunction' \
   --principal events.amazonaws.com \
   --source-arn arn:aws:events:us-east-1:{{123456789012}}:rule/{{MyRule}}
   ```

1. Se l'output contiene un campo `SourceAccount`, devi rimuoverlo. Un'`SourceAccount`impostazione EventBridge impedisce di poter richiamare la funzione.

**Nota**  
Se il criterio non è corretto, puoi modificare la [regola](eb-rules.md) nella EventBridge console rimuovendola e quindi aggiungendola nuovamente alla regola. La EventBridge console imposta quindi le autorizzazioni corrette sulla [destinazione](eb-targets.md).  
Se utilizzi un alias o una versione specifico di Lambda, aggiungi il parametro `--qualifier` nei comandi `aws lambda get-policy` e `aws lambda add-permission`, come mostrato nel comando seguente:   

```
aws lambda add-permission \
--function-name {{MyFunction}} \
--statement-id {{MyId}} \
--action 'lambda:InvokeFunction' \
--principal events.amazonaws.com \
--source-arn arn:aws:events:us-east-1:{{123456789012}}:rule/{{MyRule}}
--qualifier {{alias or version}}
```

## Ho appena creato o modificato una regola ma non corrisponde a un evento di test
<a name="eb-rule-does-not-match"></a>

Quando apporti una modifica a una [regola](eb-rules.md) o alle relative [destinazioni](eb-targets.md), gli [eventi](eb-events.md) in entrata potrebbero non avviare o interrompere immediatamente la corrispondenza con regole nuove o aggiornate. È necessario un breve periodo di tempo affinché vengano applicate le modifiche. 

Se gli eventi continuano a non corrispondere dopo un breve periodo di tempo, controlla le CloudWatch metriche `TriggeredRules` e verifica `FailedInvocations` la tua regola. `Invocations` Per ulteriori informazioni su questi parametri, consulta [Monitoring Amazon EventBridge](eb-monitoring.md).

Se la regola è destinata a corrispondere a un evento di un AWS servizio, esegui una delle seguenti operazioni:
+ Usa l'azione `TestEventPattern` per verificare che il modello di eventi della tua regola corrisponda a un evento di test. Per ulteriori informazioni, [TestEventPattern](https://docs.aws.amazon.com/AmazonCloudWatchEvents/latest/APIReference/API_TestEventPattern.html)consulta *Amazon EventBridge API Reference*.
+ Usa la **Sandbox** sulla [EventBridge console](https://console.aws.amazon.com/events).

## La mia regola non è stata eseguita quando ho specificato `ScheduleExpression`
<a name="eb-rule-did-not-trigger"></a>

Assicurati di aver impostato la pianificazione per la [regola](eb-rules.md) nel fuso orario UTC\+0. Se `ScheduleExpression` è corretta, segui la procedura descritta in [Ho appena creato o modificato una regola ma non corrisponde a un evento di test](#eb-rule-does-not-match).

## La mia regola non è stata eseguita all'orario previsto
<a name="eb-rule-did-not-trigger-on-time"></a>

EventBridge esegue [le regole](eb-rules.md) entro un minuto dall'ora di inizio impostata. Il conteggio dell'orario di esecuzione viene avviato al momento della creazione della regola.

**Nota**  
Il tipo di distribuzione delle regole pianificate è `guaranteed` il che significa che gli eventi verranno attivati almeno una volta per ogni orario previsto.

Puoi utilizzare un'espressione Cron per richiamare le [destinazioni](eb-targets.md) a un orario specificato. Per creare una regola che viene eseguita ogni quattro ore al minuto 0, esegui una delle seguenti operazioni:
+ Nella EventBridge console, si utilizza l'espressione `0 0/4 * * ? *` cron.
+ Usando AWS CLI, si usa l'espressione`cron(0 0/4 * * ? *)`.

Ad esempio, per creare una regola denominata `TestRule` che viene eseguita ogni 4 ore utilizzando il AWS CLI, si utilizza il comando seguente.

```
aws events put-rule --name {{TestRule}} --schedule-expression 'cron(0 0/4 * * ? *)'
```

Per eseguire una regola ogni cinque minuti, utilizzi la seguente espressione Cron.

```
aws events put-rule --name {{TestRule}} --schedule-expression 'cron(0/5 * * * ? *)'
```

La risoluzione massima per una EventBridge regola che utilizza un'espressione cron è un minuto. La regola pianificata viene attivata entro tale minuto, ma non al secondo 0 preciso.

Poiché EventBridge tutti i servizi di destinazione sono distribuiti, può verificarsi un ritardo di diversi secondi tra l'esecuzione della regola pianificata e il momento in cui il servizio di destinazione esegue l'azione sulla risorsa di destinazione.

## La mia regola corrisponde alle chiamate API di servizio AWS globali, ma non è stata eseguita
<a name="eb-rule-did-not-trigger-iam"></a>

AWS servizi globali; come IAM e Amazon Route 53 sono disponibili solo nella regione Stati Uniti orientali (Virginia settentrionale), quindi gli eventi derivanti dalle chiamate AWS API dei servizi globali sono disponibili solo in quella regione. Per ulteriori informazioni, consulta [Eventi derivanti dai AWS servizi](eb-events.md#eb-service-event).

## Il ruolo IAM associato alla mia regola viene ignorato durante l'esecuzione della regola
<a name="eb-iam-role-ignored"></a>

EventBridge utilizza i ruoli IAM solo per [le regole](eb-rules.md) che inviano [eventi](eb-events.md) ai flussi Kinesis. Per le regole che richiamano funzioni Lambda o argomenti Amazon SNS, devi fornire [autorizzazioni basate su risorse](eb-use-resource-based.md).

Assicurati che gli AWS STS endpoint regionali siano abilitati, in modo che EventBridge possano utilizzarli quando assumeranno il ruolo IAM che hai fornito. *Per ulteriori informazioni, consulta [Attivazione e disattivazione AWS STS in una AWS regione nella Guida](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp_enable-regions.html) per l'utente IAM.*

## La mia regola ha un modello di eventi che dovrebbe corrispondere a una risorsa, ma nessun evento corrisponde
<a name="eb-events-do-not-match-rule"></a>

La maggior parte dei servizi utilizza i due punti (:) o la barra (/) come lo stesso carattere in Amazon Resource Names (ARNs)., ma EventBridge utilizza una corrispondenza esatta nei [modelli e nelle [regole](eb-rules.md) degli eventi](eb-event-patterns.md). AWS Assicurati di utilizzare i caratteri ARN corretti durante la creazione di modelli di eventi, facendo in modo che corrispondano alla sintassi ARN nell'[evento](eb-events.md) per il quale cercare corrispondenze.

Alcuni eventi, come gli eventi di chiamata AWS API from CloudTrail, non hanno nulla nel campo delle risorse.

## Si è verificato un ritardo nella distribuzione del mio evento alla destinazione
<a name="eb-delayed-event-delivery"></a>

EventBridge tenta di inviare un [evento](eb-events.md) a un [obiettivo](eb-targets.md) per un massimo di 24 ore, tranne negli scenari in cui la risorsa di destinazione è limitata. Il primo tentativo viene effettuato appena l'evento giunge nel flusso di eventi. Se il servizio di destinazione presenta problemi, riprogramma EventBridge automaticamente un'altra consegna. Se sono trascorse 24 ore dall'arrivo dell'evento, EventBridge interrompe il tentativo di consegna dell'evento e pubblica la metrica in. `FailedInvocations` CloudWatch Ti consigliamo di configurare una coda DLQ per archiviare gli eventi che non sono stati distribuiti correttamente a una destinazione. Per ulteriori informazioni, consulta [Utilizzo di code di lettere non recapitate per elaborare eventi non consegnati in EventBridge](eb-rule-dlq.md)

## Alcuni eventi non sono mai stati distribuiti nel target
<a name="eb-never-delivered-to-target"></a>

Se l'[obiettivo](eb-targets.md) di una EventBridge [regola](eb-rules.md) è limitato per un periodo di tempo prolungato, EventBridge potrebbe non essere possibile ritentare la consegna. Ad esempio, se la destinazione non è predisposta per gestire il traffico degli [eventi](eb-events.md) in entrata e il servizio di destinazione EventBridge limita le richieste effettuate per tuo conto, è possibile che non riprovi a recapitare. EventBridge 

## La mia regola è stata eseguita più di una volta in risposta a un evento
<a name="eb-rule-triggered-more-than-once"></a>

In rari casi, la stessa [regola](eb-rules.md) può essere eseguita più di una volta per un unico [evento](eb-events.md) o un orario pianificato, oppure la stessa [destinazione](eb-targets.md) può essere richiamata più di una volta per una determinata regola attivata. 

## Come evitare loop infiniti
<a name="eb-prevent-infinite-loops"></a>

In EventBridge, è possibile creare una [regola che porti a cicli infiniti, in cui la regola](eb-rules.md) viene eseguita ripetutamente. Se hai una regola che causa un loop infinito, riscrivila in modo che le azioni intraprese dalla regola non corrispondano alla stessa regola. 

Ad esempio, una regola che ACLs rileva le modifiche in un bucket Amazon S3 e quindi esegue il software per modificarle in un nuovo stato causa un ciclo infinito. Un modo per risolverlo consiste nel riscrivere la regola in modo ACLs che corrisponda solo a quelle in cattivo stato. 

Un loop infinito può generare rapidamente costi più alti di quelli previsti. Ti consigliamo di utilizzare il budgeting, che avvisa quando i costi superano il limite indicato. Per ulteriori informazioni, consulta [Gestione dei costi con i budget](https://docs.aws.amazon.com/awsaccountbilling/latest/aboutv2/budgets-managing-costs.html).

## I miei eventi non vengono distribuiti alla coda di Amazon SQS target
<a name="eb-sqs-encrypted"></a>

Se la tua coda Amazon SQS è crittografata, devi creare una chiave KMS gestita dal cliente e includere la seguente sezione di autorizzazione nella policy della chiave KMS. Per ulteriori informazioni, vedere [Configurazione delle autorizzazioni AWS KMS](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-key-management.html#sqs-what-permissions-for-sse).

```
{
  "Sid": "Allow EventBridge to use the key",
  "Effect": "Allow",
  "Principal": {
    "Service": "events.amazonaws.com"
  },
  "Action": [
    "kms:Decrypt",
    "kms:GenerateDataKey"
  ],
  "Resource": "*"
}
```

## La regola viene eseguita ma non vedo messaggi pubblicati nell'argomento Amazon SNS
<a name="eb-no-messages-published-sns"></a>

**Scenario 1**

Devi disporre dell'autorizzazione per pubblicare messaggi nel tuo argomento Amazon SNS. Usa il seguente comando usando AWS CLI, sostituendo us-east-1 con la tua regione e usando il tuo argomento ARN.

```
aws sns get-topic-attributes --region {{us-east-1}} --topic-arn "arn:aws:sns:{{us-east-1}}:{{123456789012}}:MyTopic"
```

Per disporre dell'autorizzazione corretta, gli attributi della policy devono essere simili a quanto segue.

------
#### [ JSON ]

****  

```
{
    "Version":"2012-10-17",		 	 	 
    "Id": "__default_policy_ID",
    "Statement": [
    {
    "Sid": "__default_statement_ID",
    "Effect": "Allow",
    "Principal": {
    "AWS": "*"
    },
    "Action": [
    "SNS:Subscribe",
    "SNS:ListSubscriptionsByTopic",
    "SNS:DeleteTopic",
    "SNS:GetTopicAttributes",
    "SNS:Publish",
    "SNS:RemovePermission",
    "SNS:AddPermission",
    "SNS:SetTopicAttributes"
    ],
    "Resource": "arn:aws:sns:us-east-1:123456789012:{{MyTopic}}",
    "Condition": {
    "StringEquals": {
    "AWS:SourceOwner": "123456789012"
    }
    }
    },
    {
    "Sid": "Allow_Publish_Events",
    "Effect": "Allow",
    "Principal": {
    "Service": "events.amazonaws.com"
    },
    "Action": "sns:Publish",
    "Resource": "arn:aws:sns:us-east-1:123456789012:{{MyTopic}}"
    }
    ]
    }
```

------

Se non vedi `events.amazonaws.com` con l'autorizzazione `Publish` nella tua policy, copia prima la policy corrente e aggiungi la seguente istruzione all'elenco delle istruzioni.

```
{\"Sid\":\"Allow_Publish_Events\",
\"Effect\":\"Allow\",\"Principal\":{\"Service\":\"events.amazonaws.com\"},
\"Action\":\"sns:Publish\",
\"Resource\":\"arn:aws:sns:us-east-1:123456789012:MyTopic\"}
```

Quindi imposta gli attributi dell'argomento utilizzando AWS CLI, usa il seguente comando.

```
aws sns set-topic-attributes --region {{us-east-1}} --topic-arn "arn:aws:sns:us-east-1:{{123456789012}}:MyTopic" --attribute-name Policy --attribute-value {{NEW_POLICY_STRING}}
```

**Nota**  
Se il criterio non è corretto, puoi anche modificare la [regola](eb-rules.md) nella EventBridge console rimuovendola e quindi aggiungendola nuovamente alla regola. EventBridge imposta le autorizzazioni corrette sulla [destinazione](eb-targets.md).

**Scenario 2**

Se l'argomento SNS è crittografato, devi includere la sezione seguente nella policy della chiave KMS.

```
{
  "Sid": "Allow EventBridge to use the key",
  "Effect": "Allow",
  "Principal": {
    "Service": "events.amazonaws.com"
  },
  "Action": [
    "kms:Decrypt",
    "kms:GenerateDataKey"
  ],
  "Resource": "*"
}
```

## Il mio argomento Amazon SNS dispone ancora delle autorizzazioni EventBridge anche dopo aver eliminato la regola associata all'argomento Amazon SNS
<a name="eb-sns-permissions-persist"></a>

Quando crei una [regola](eb-rules.md) con Amazon SNS come [destinazione](eb-targets.md), EventBridge aggiunge l'autorizzazione all'argomento Amazon SNS per tuo conto. Se elimini la regola poco dopo averla creata, EventBridge potresti non rimuovere l'autorizzazione dal tuo argomento Amazon SNS. In questo caso, puoi rimuovere l'autorizzazione dall'argomento utilizzando il comando `aws sns set-topic-attributes`. Per ulteriori informazioni sulle autorizzazioni basate su risorse per l'invio di eventi, consulta [Utilizzo di politiche basate sulle risorse per Amazon EventBridge](eb-use-resource-based.md).

## Con EventBridge quali chiavi di condizione IAM posso usare?
<a name="eb-supported-access-policies"></a>

EventBridge supporta le chiavi di condizione AWS-wide (vedi [IAM e AWS STS condition context keys](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_iam-condition-keys.html) nella *IAM User Guide*), oltre alle chiavi elencate in[Utilizzo delle condizioni delle policy IAM in Amazon EventBridge](eb-use-conditions.md).

## Come posso sapere quando EventBridge le regole vengono violate?
<a name="eb-create-alarm-broken-event-rules"></a>

Puoi utilizzare il seguente avviso per avvisarti quando EventBridge [le tue regole](eb-rules.md) vengono violate.

**Creazione di un allarme di avviso dell'interruzione delle regole**

1. Apri la CloudWatch console all'indirizzo [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/).

1. Scegli **Crea allarme**. Nel riquadro **CloudWatch Metriche per categoria**, scegli **Metriche degli eventi**.

1. Nell'elenco delle metriche, seleziona. **FailedInvocations**

1. Sopra il grafico, seleziona **Statistic** (Statistica), **Sum** (Somma).

1. In **Period** (Periodo), seleziona un valore, ad esempio **5 minutes** (5 minuti). Scegli **Next (Successivo)**.

1. In **Soglia di allarme**, per **Nome**, digita un nome univoco per l'allarme, ad esempio **myFailedRules**. In **Descrizione**, digita una descrizione dell'allarme, ad esempio **Le regole non distribuiscono eventi a destinazioni**.

1. In **is** (è), seleziona **>=** e **1**. In **for** (per), immetti **10**.

1. In **Actions** (Operazioni), in **Whenever this alarm** (Ogni volta che questo allarme), scegli **State is ALARM** (Lo stato è ALLARME).

1. In **Invia notifica a**, seleziona un argomento Amazon SNS esistente o creane uno. Per creare un nuovo argomento, seleziona **New list** (Nuovo elenco). Digita un nome per il nuovo argomento Amazon SNS, ad esempio:. **myFailedRules** 

1. In **Email list** (Elenco e-mail), digita un elenco separato da virgola di indirizzi e-mail a cui inviare una notifica quando lo stato dell'allarme passa a **ALARM**.

1. Scegli **Crea allarme**.