

Avviso di fine del supporto: il 20 maggio 2026, AWS terminerà il supporto per AWS IoT Events. Dopo il 20 maggio 2026, non potrai più accedere alla AWS IoT Events console o AWS IoT Events alle risorse. Per ulteriori informazioni, consulta [AWS IoT Events Fine del supporto](https://docs.aws.amazon.com/iotevents/latest/developerguide/iotevents-end-of-support.html).

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

# Monitoraggio con allarmi in AWS IoT Events
<a name="iotevents-alarms"></a>

AWS IoT Events gli allarmi consentono di monitorare i dati in caso di modifiche. I dati possono essere metriche misurate per apparecchiature e processi. È possibile creare allarmi che inviano notifiche quando viene superata una soglia. Gli allarmi consentono di rilevare problemi, semplificare la manutenzione e ottimizzare le prestazioni delle apparecchiature e dei processi.

Gli allarmi sono esempi di modelli di allarme. Il modello di allarme specifica cosa rilevare, quando inviare le notifiche, chi riceve le notifiche e altro ancora. È inoltre possibile specificare una o più [azioni supportate](https://docs.aws.amazon.com/iotevents/latest/developerguide/iotevents-supported-actions.html) che si verificano quando lo stato dell'allarme cambia. AWS IoT Events indirizza [gli attributi di input](https://docs.aws.amazon.com/iotevents/latest/developerguide/iotevents-detector-input.html) derivati dai dati agli allarmi appropriati. Se i dati che stai monitorando non rientrano nell'intervallo specificato, viene richiamato l'allarme. Puoi anche confermare gli allarmi o impostarli sulla modalità snooze.

## Lavorare con AWS IoT SiteWise
<a name="alarms-collaborations.title"></a>

È possibile utilizzare gli AWS IoT Events allarmi per monitorare le proprietà degli asset in. AWS IoT SiteWise AWS IoT SiteWise invia i valori delle proprietà degli asset agli AWS IoT Events allarmi. AWS IoT Events invia lo stato di allarme a. AWS IoT SiteWise

AWS IoT SiteWise supporta anche allarmi esterni. Puoi scegliere allarmi esterni se utilizzi allarmi esterni AWS IoT SiteWise e disponi di una soluzione che restituisce i dati sullo stato degli allarmi. L'allarme esterno contiene una proprietà di misurazione che inserisce i dati sullo stato dell'allarme.

AWS IoT SiteWise non valuta lo stato degli allarmi esterni. Inoltre, non è possibile confermare o posticipare un allarme esterno quando lo stato dell'allarme cambia.

È possibile utilizzare la funzione SiteWise Monitor per visualizzare lo stato degli allarmi esterni nei SiteWise portali Monitor.

*Per ulteriori informazioni, consulta [Monitoraggio dei dati con allarmi](https://docs.aws.amazon.com/iot-sitewise/latest/userguide/industrial-alarms.html) nella *Guida per l'AWS IoT SiteWise utente* e [Monitoraggio con allarmi](https://docs.aws.amazon.com//iot-sitewise/latest/appguide/monitor-alarms.html) nella Guida all'SiteWise applicazione Monitor.*

## Conferma il flusso
<a name="acknowledge-flow"></a>

Quando crei un modello di allarme, scegli se abilitare il flusso di conferma. Se abiliti il flusso di conferma, il tuo team riceve una notifica quando lo stato dell'allarme cambia. Il tuo team può confermare l'allarme e lasciare una nota. Ad esempio, puoi includere le informazioni sull'allarme e le azioni che intendi intraprendere per risolvere il problema. Se i dati che stai monitorando non rientrano nell'intervallo specificato, viene richiamato l'allarme.

Gli allarmi hanno i seguenti stati:

`DISABLED`  
Quando l'allarme è attivo, non è pronto per valutare i dati. `DISABLED` Per abilitare l'allarme, è necessario impostarlo sullo `NORMAL` stato.

`NORMAL`  
Quando l'allarme è attivo`NORMAL`, è pronto per valutare i dati.

`ACTIVE`  
Se l'allarme è nello `ACTIVE` stato, viene richiamato. I dati che stai monitorando non rientrano nell'intervallo specificato.

`ACKNOWLEDGED`  
Quando l'allarme è nello `ACKNOWLEDGED` stato, l'allarme è stato richiamato e tu hai riconosciuto l'allarme.

`LATCHED`  
L'allarme è stato richiamato, ma non l'hai riconosciuto dopo un certo periodo di tempo. L'allarme passa automaticamente allo `NORMAL` stato.

`SNOOZE_DISABLED`  
Quando l'allarme è nello `SNOOZE_DISABLED` stato, viene disabilitato per un periodo di tempo specificato. Dopo l'orario di snooze, la sveglia passa automaticamente allo `NORMAL` stato.

# Creazione di un modello di allarme in AWS IoT Events
<a name="create-alarm-model"></a>

È possibile utilizzare gli AWS IoT Events allarmi per monitorare i dati e ricevere notifiche quando viene superata una soglia. Gli allarmi forniscono parametri che puoi utilizzare per creare o configurare un modello di allarme. Puoi utilizzare la AWS IoT Events console o l' AWS IoT Events API per creare o configurare il modello di allarme. Quando configuri il modello di allarme, le modifiche diventano effettive non appena arrivano nuovi dati.

## Requisiti
<a name="create-alarm-model-requirements"></a>

I seguenti requisiti si applicano quando si crea un modello di allarme.
+ È possibile creare un modello di allarme per monitorare un attributo di input AWS IoT Events o una proprietà di un asset in AWS IoT SiteWise.
  + Se si sceglie di monitorare un attributo di input in AWS IoT Events, [Crea un input per i modelli in AWS IoT Events](create-input-overview.md) prima di creare il modello di allarme.
  + Se scegliete di monitorare la proprietà di un asset, dovete [creare un modello di asset](https://docs.aws.amazon.com/iot-sitewise/latest/userguide/create-asset-models.html) AWS IoT SiteWise prima di creare il modello di allarme.
+ È necessario disporre di un ruolo IAM che consenta all'allarme di eseguire azioni e accedere alle AWS risorse. Per ulteriori informazioni, consulta [Configurazione delle autorizzazioni per AWS IoT Events](https://docs.aws.amazon.com/iotevents/latest/developerguide/iotevents-start.html).
+ Tutte le AWS risorse utilizzate in questo tutorial devono trovarsi nella stessa AWS regione.

## Creazione di un modello di allarme (console)
<a name="create-alarm-model-console"></a>

Di seguito viene illustrato come creare un modello di allarme per monitorare un AWS IoT Events attributo nella AWS IoT Events console.

1. Accedi alla [console AWS IoT Events](https://console.aws.amazon.com/iotevents/).

1. Nel pannello di navigazione, scegli **Modelli di allarme**.

1. Nella pagina **Modelli di allarme**, scegli **Crea modello di allarme**.

1. Nella sezione **Dettagli del modello di allarme**, procedi come segue:

   1. Immetti un nome univoco.

   1. (Opzionale) Immettere una descrizione.

1. Nella sezione **Obiettivo dell'allarme**, procedi come segue:
**Importante**  
Se scegliete la **proprietà dell'AWS IoT SiteWise asset**, dovete aver creato un modello di asset in AWS IoT SiteWise.

   1. Scegliete **AWS IoT Events l'attributo di input**.

   1. Scegli l'input.

   1. Scegli la chiave dell'attributo di input. Questo attributo di input viene utilizzato come chiave per creare l'allarme. AWS IoT Events indirizza gli ingressi associati a questa chiave verso l'allarme.
**Importante**  
Se il payload del messaggio di input non contiene questa chiave di attributo di input o se la chiave non si trova nello stesso percorso JSON specificato nella chiave, l'inserimento del messaggio non riuscirà. AWS IoT Events

1. Nella sezione **Definizioni delle soglie**, si definiscono l'attributo di input, il valore di soglia e l'operatore di confronto da AWS IoT Events utilizzare per modificare lo stato dell'allarme.

   1. Per l'**attributo di input**, scegli l'attributo che desideri monitorare.

      Ogni volta che questo attributo di input riceve nuovi dati, viene valutato per determinare lo stato dell'allarme.

   1. Per **Operatore**, scegli l'operatore di confronto. L'operatore confronta l'attributo di input con il valore di soglia dell'attributo.

      Puoi scegliere tra queste opzioni: 
      + **> maggiore di**
      + **>= maggiore o uguale a**
      + **< minore di**
      + **<= minore o uguale a**
      + **= uguale a**
      + **\$1 = diverso da**

   1. Per **Valore** di soglia, inserisci un numero o scegli un attributo negli AWS IoT Events input. AWS IoT Events confronta questo valore con il valore dell'attributo di input scelto. 

   1. (Facoltativo) Per **la gravità**, utilizzate un numero che il team comprenda per riflettere la gravità di questo allarme.

1. (Facoltativo) Nella sezione **Impostazioni di notifica**, configura le impostazioni di notifica per l'allarme.

   Puoi aggiungere fino a 10 notifiche. Per **Notifica 1**, procedi come segue:

   1. Per **Protocollo**, scegli una delle seguenti opzioni:
      + **E-mail e testo**: l'allarme invia una notifica SMS e una notifica e-mail.
      + **E-mail**: l'allarme invia una notifica via e-mail.
      + **Testo**: l'allarme invia una notifica via SMS.

   1. Per **Mittente**, specifica l'indirizzo e-mail che può inviare notifiche relative a questo allarme.

      Per aggiungere altri indirizzi e-mail all'elenco dei mittenti, scegli **Aggiungi** mittente. 

   1. (Facoltativo) Per **Destinatario, scegli il destinatario**.

      Per aggiungere altri utenti all'elenco dei destinatari, scegli **Aggiungi nuovo utente**. Devi aggiungere nuovi utenti al tuo negozio IAM Identity Center prima di poterli aggiungere al tuo modello di allarme. Per ulteriori informazioni, consulta [Gestisci l'accesso a IAM Identity Center dei destinatari degli allarmi in AWS IoT Events](sso-authorization-recipients.md).

   1. (Facoltativo) Per **Messaggio personalizzato aggiuntivo**, inserisci un messaggio che descriva cosa rileva l'allarme e quali azioni devono intraprendere i destinatari.

1. Nella sezione **Istanza**, puoi abilitare o disabilitare tutte le istanze di allarme create sulla base di questo modello di allarme.

1. Nella sezione **Impostazioni avanzate**, procedi come segue:

   1. Per il **flusso di conferma**, puoi abilitare o disabilitare le notifiche.
      + Se scegli **Abilitato**, ricevi una notifica quando lo stato dell'allarme cambia. È necessario confermare la notifica prima che lo stato di allarme possa tornare alla normalità.
      + Se scegli **Disabilitato**, non è richiesta alcuna azione. L'allarme passa automaticamente allo stato normale quando la misurazione ritorna all'intervallo specificato.

      Per ulteriori informazioni, consulta [Conferma il flusso](iotevents-alarms.md#acknowledge-flow).

   1. Per **Autorizzazioni**, scegli una delle seguenti opzioni:
      + Puoi **creare un nuovo ruolo dai modelli di AWS policy** e creare AWS IoT Events automaticamente un ruolo IAM per te. 
      + Puoi **utilizzare un ruolo IAM esistente** che consente a questo modello di allarme di eseguire azioni e accedere ad altre AWS risorse.

      Per ulteriori informazioni, consulta [Identity and Access Management per AWS IoT Events](https://docs.aws.amazon.com/iotevents/latest/developerguide/security-iam.html).

   1. Per **le impostazioni di notifica aggiuntive**, è possibile modificare la AWS Lambda funzione per gestire le notifiche di allarme. Scegli una delle seguenti opzioni per la tua AWS Lambda funzione:
      + **Crea una nuova AWS Lambda funzione**: AWS IoT Events crea una nuova AWS Lambda funzione per te.
      + **Usa una AWS Lambda funzione esistente**: utilizza una AWS Lambda funzione esistente scegliendo il nome di una AWS Lambda funzione. 

      Per ulteriori informazioni sulle azioni possibili, vedere[AWS IoT Events lavorare con altri AWS servizi](iotevents-other-aws-services.md).

   1. (Facoltativo) In **Imposta l'azione dello stato**, puoi aggiungere una o più AWS IoT Events azioni da intraprendere quando lo stato dell'allarme cambia.

1. (Facoltativo) Puoi aggiungere **tag** per gestire gli allarmi. Per ulteriori informazioni, consulta [Tagging delle risorse AWS IoT Events](https://docs.aws.amazon.com/iotevents/latest/developerguide/tagging-iotevents.html).

1. Scegli **Create** (Crea).

# Risposta agli allarmi in AWS IoT Events
<a name="respond-to-alarms"></a>

Rispondere efficacemente agli allarmi è un aspetto importante della gestione dei sistemi IoT con. AWS IoT Events Esplora vari modi per configurare e gestire gli allarmi, tra cui: impostazione di canali di notifica, definizione di procedure di escalation e implementazione di azioni di risposta automatizzate. Impara a creare condizioni di allarme personalizzate, assegnare priorità agli avvisi e integrarti con altri AWS servizi per creare un sistema di gestione degli allarmi reattivo per le tue applicazioni IoT.

Se hai abilitato il [flusso di conferma](https://docs.aws.amazon.com/iotevents/latest/developerguide/iotevents-alarms.html#acknowledge-flow), ricevi notifiche quando lo stato dell'allarme cambia. Per rispondere all'allarme, puoi confermare, disabilitare, abilitare, ripristinare o posticipare l'allarme.

------
#### [ Console ]

Di seguito viene illustrato come rispondere a un allarme nella AWS IoT Events console.

1. Accedi alla [console AWS IoT Events](https://console.aws.amazon.com/iotevents/).

1. Nel pannello di navigazione, scegli **Modelli di allarme**.

1. Scegli il modello di allarme di destinazione.

1. Nella sezione **Elenco degli allarmi**, scegli l'allarme di destinazione.

1. Puoi scegliere una delle seguenti opzioni da **Azioni**:
   + **Conferma**: l'allarme passa allo `ACKNOWLEDGED` stato.
   + **Disabilita**: l'allarme passa allo `DISABLED` stato.
   + **Abilita**: l'allarme passa allo `NORMAL` stato.
   + **Ripristina**: l'allarme passa allo `NORMAL` stato.
   + **Snooze**, quindi procedi come segue:

     1. **Scegli la durata dello **snooze o inserisci una lunghezza dello** snooze personalizzata.**

     1. Scegli **Save** (Salva).

     L'allarme passa allo stato `SNOOZE_DISABLED`

   Per ulteriori informazioni sugli stati di allarme, vedere[Conferma il flusso](iotevents-alarms.md#acknowledge-flow).

------
#### [ API ]

Per rispondere a uno o più allarmi, puoi utilizzare le seguenti operazioni AWS IoT Events API:
+ [BatchAcknowledgeAlarm](https://docs.aws.amazon.com/iotevents/latest/apireference/API_iotevents-data_BatchAcknowledgeAlarm.html)
+ [BatchDisableAlarm](https://docs.aws.amazon.com/iotevents/latest/apireference/API_iotevents-data_BatchDisableAlarm.html)
+ [BatchEnableAlarm](https://docs.aws.amazon.com/iotevents/latest/apireference/API_iotevents-data_BatchEnableAlarm.html)
+ [BatchResetAlarm](https://docs.aws.amazon.com/iotevents/latest/apireference/API_iotevents-data_BatchResetAlarm.html)
+ [BatchSnoozeAlarm](https://docs.aws.amazon.com/iotevents/latest/apireference/API_iotevents-data_BatchSnoozeAlarm.html)

------

# Gestione delle notifiche di allarme in AWS IoT Events
<a name="lambda-support"></a>

AWS IoT Events si integra con Lambda, offrendo funzionalità personalizzate di elaborazione degli eventi. Questa sezione esplora come utilizzare le funzioni Lambda all'interno AWS IoT Events dei modelli di rilevatori, consentendoti di eseguire logiche complesse, interagire con servizi esterni e implementare una gestione sofisticata degli eventi.

AWS IoT Events utilizza una funzione Lambda per gestire le notifiche di allarme. È possibile utilizzare la funzione Lambda fornita da AWS IoT Events o crearne una nuova.

**Topics**
+ [Creazione di una funzione Lambda in AWS IoT Events](alarms-create-lambda.md)
+ [Utilizzo della funzione Lambda fornita da AWS IoT Events](use-alarm-notifications.md)
+ [Gestisci l'accesso a IAM Identity Center dei destinatari degli allarmi in AWS IoT Events](sso-authorization-recipients.md)

# Creazione di una funzione Lambda in AWS IoT Events
<a name="alarms-create-lambda"></a>

AWS IoT Events fornisce una funzione Lambda che consente agli allarmi di inviare e ricevere notifiche e-mail e SMS.

## Requisiti
<a name="alarms-lambda-requirements"></a>

I seguenti requisiti si applicano quando si crea una funzione Lambda per gli allarmi:
+ Se il tuo allarme invia notifiche SMS, assicurati che Amazon SNS sia configurato per recapitare messaggi SMS.
  + Per ulteriori informazioni, consulta la seguente documentazione:
    + [Messaggi di testo mobili con identità Amazon SNS](https://docs.aws.amazon.com/sns/latest/dg/sns-mobile-phone-number-as-subscriber.html) [e Origination per i messaggi SMS di Amazon SNS nella Amazon Simple](https://docs.aws.amazon.com/sns/latest/dg/channels-sms-originating-identities.html) *Notification Service Developer Guide.*
    + [Cos'è AWS End User Messaging SMS?](https://docs.aws.amazon.com/sms-voice/latest/userguide/what-is-sms-mms.html) nella *Guida AWS SMS per l'utente*.
+ Se il tuo allarme invia notifiche e-mail o SMS, devi disporre di un ruolo IAM che AWS Lambda consenta di lavorare con Amazon SES e Amazon SNS.

  

  Politica di esempio:

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

****  

  ```
  {
      "Version":"2012-10-17",		 	 	 
      "Statement": [
          {
              "Effect": "Allow",
              "Action": [
                  "ses:GetIdentityVerificationAttributes",
                  "ses:SendEmail",
                  "ses:VerifyEmailIdentity"
              ],
              "Resource": "*"
          },
          {
              "Effect": "Allow",
              "Action": [
                  "sns:Publish",
                  "sns:OptInPhoneNumber",
                  "sns:CheckIfPhoneNumberIsOptedOut",
                  "sms-voice:DescribeOptedOutNumbers"
              ],
              "Resource": "*"
          },
          {
              "Effect": "Deny",
              "Action": "sns:Publish",
              "Resource": "arn:aws:sns:*:*:*"
          },
          {
            "Effect" : "Allow",
            "Action" : [
              "logs:CreateLogGroup",
              "logs:CreateLogStream",
              "logs:PutLogEvents"
            ],
            "Resource" : "*"
          }
      ]
  }
  ```

------
+ È necessario scegliere la stessa AWS regione per entrambi AWS IoT Events e AWS Lambda. Per l'elenco delle regioni supportate, consulta [AWS IoT Events endpoint e quote](https://docs.aws.amazon.com/general/latest/gr/iot-events.html) e [AWS Lambda endpoint e quote](https://docs.aws.amazon.com/general/latest/gr/lambda-service.html) in. *Riferimenti generali di Amazon Web Services*

# Implementa una funzione Lambda per l'utilizzo AWS IoT Events CloudFormation
<a name="alarms-create-lambda-cfn"></a>

Questo tutorial utilizza un CloudFormation modello per distribuire una funzione Lambda. Questo modello crea automaticamente un ruolo IAM che consente alla funzione Lambda di funzionare con Amazon SES e Amazon SNS.

Di seguito viene illustrato come utilizzare la AWS Command Line Interface (AWS CLI) per creare uno CloudFormation stack.

1. <a name="install-cli"></a>Nel terminale del tuo dispositivo, `aws --version` esegui per verificare se hai installato il AWS CLI. Per ulteriori informazioni, consulta [Installing or updating to the latest version of the AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html) nella *Guida per l'utente dell'AWS Command Line Interface *.

1. <a name="configure-cli"></a>Esegui `aws configure list` per verificare se lo hai configurato AWS CLI nella AWS regione che ha tutte le AWS risorse per questo tutorial. Per ulteriori informazioni, consulta [Impostare e visualizzare le impostazioni di configurazione utilizzando i comandi](https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-files.html#cli-configure-files-methods) nella *Guida AWS Command Line Interface per l'utente*

1. Scarica il CloudFormation modello, [NotificationLambda.template.yaml.zip](samples/notificationLambda.template.yaml.zip).
**Nota**  
Se hai difficoltà a scaricare il file, il modello è disponibile anche in. [CloudFormation modello](alarms-create-lambda.md#cfn-template)

1. Decomprimere il contenuto e salvarlo localmente come `notificationLambda.template.yaml`.

1. Apri un terminale sul tuo dispositivo e vai alla directory in cui hai scaricato il `notificationLambda.template.yaml` file.

1. Per creare uno CloudFormation stack, esegui il seguente comando:

   ```
   aws cloudformation create-stack --stack-name notificationLambda-stack --template-body file://notificationLambda.template.yaml --capabilities CAPABILITY_IAM
   ```

È possibile modificare questo CloudFormation modello per personalizzare la funzione Lambda e il relativo comportamento.

**Nota**  
AWS Lambda riprova due volte gli errori di funzione. Se la funzione non dispone di capacità sufficiente per gestire tutte le richieste in entrata, gli eventi possono attendere in coda per ore o giorni per essere inviati alla funzione. È possibile configurare una coda di messaggi non recapitati (DLQ) sulla funzione per acquisire gli eventi che non sono stati elaborati correttamente. Per ulteriori informazioni, consulta [Chiamata asincrona](https://docs.aws.amazon.com/lambda/latest/dg/invocation-async.html) nella *Guida per gli sviluppatori AWS Lambda *.

Puoi anche creare o configurare lo stack nella console. CloudFormation Per ulteriori informazioni, consulta [Working with stacks](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/stacks.html), nella Guida per l'*AWS CloudFormation utente*.

# Creazione di una funzione Lambda personalizzata per AWS IoT Events
<a name="alarms-create-custom-lambda"></a>

È possibile creare una funzione Lambda o modificare quella fornita da. AWS IoT Events

I seguenti requisiti si applicano quando si crea una funzione Lambda personalizzata.
+ Aggiungi autorizzazioni che consentono alla funzione Lambda di eseguire azioni specifiche e AWS accedere alle risorse.
+ Se usi la funzione Lambda fornita da AWS IoT Events, assicurati di scegliere il runtime Python 3.7.

Esempio di funzione Lambda:

```
import boto3
import json
import logging
import datetime
logger = logging.getLogger()
logger.setLevel(logging.INFO)
ses = boto3.client('ses')
sns = boto3.client('sns')
def check_value(target):
  if target:
    return True
  return False

# Check whether email is verified. Only verified emails are allowed to send emails to or from.
def check_email(email):
  if not check_value(email):
    return False
  result = ses.get_identity_verification_attributes(Identities=[email])
  attr = result['VerificationAttributes']
  if (email not in attr or attr[email]['VerificationStatus'] != 'Success'):
      logging.info('Verification email for {} sent. You must have all the emails verified before sending email.'.format(email))
      ses.verify_email_identity(EmailAddress=email)
      return False
  return True

# Check whether the phone holder has opted out of receiving SMS messages from your account
def check_phone_number(phone_number):
  try:
    result = sns.check_if_phone_number_is_opted_out(phoneNumber=phone_number)
    if (result['isOptedOut']):
        logger.info('phoneNumber {} is not opt in of receiving SMS messages. Phone number must be opt in first.'.format(phone_number))
        return False
    return True
  except Exception as e:
    logging.error('Your phone number {} must be in E.164 format in SSO. Exception thrown: {}'.format(phone_number, e))
    return False

def check_emails(emails):
  result = True
  for email in emails:
      if not check_email(email):
          result = False
  return result

def lambda_handler(event, context):
  logging.info('Received event: ' + json.dumps(event))
  nep = json.loads(event.get('notificationEventPayload'))
  alarm_state = nep['alarmState']
  default_msg = 'Alarm ' + alarm_state['stateName'] + '\n'
  timestamp = datetime.datetime.utcfromtimestamp(float(nep['stateUpdateTime'])/1000).strftime('%Y-%m-%d %H:%M:%S')
  alarm_msg = "{} {} {} at {} UTC ".format(nep['alarmModelName'], nep.get('keyValue', 'Singleton'), alarm_state['stateName'], timestamp)
  default_msg += 'Sev: ' + str(nep['severity']) + '\n'
  if (alarm_state['ruleEvaluation']):
    property = alarm_state['ruleEvaluation']['simpleRule']['inputProperty']
    default_msg += 'Current Value: ' + str(property) + '\n'
    operator = alarm_state['ruleEvaluation']['simpleRule']['operator']
    threshold = alarm_state['ruleEvaluation']['simpleRule']['threshold']
    alarm_msg += '({} {} {})'.format(str(property), operator, str(threshold))
  default_msg += alarm_msg + '\n'

  emails = event.get('emailConfigurations', [])
  logger.info('Start Sending Emails')
  for email in emails:
    from_adr = email.get('from')
    to_adrs = email.get('to', [])
    cc_adrs = email.get('cc', [])
    bcc_adrs = email.get('bcc', [])
    msg = default_msg + '\n' + email.get('additionalMessage', '')
    subject = email.get('subject', alarm_msg)
    fa_ver = check_email(from_adr)
    tas_ver = check_emails(to_adrs)
    ccas_ver = check_emails(cc_adrs)
    bccas_ver = check_emails(bcc_adrs)
    if (fa_ver and tas_ver and ccas_ver and bccas_ver):
      ses.send_email(Source=from_adr,
                     Destination={'ToAddresses': to_adrs, 'CcAddresses': cc_adrs, 'BccAddresses': bcc_adrs},
                     Message={'Subject': {'Data': subject}, 'Body': {'Text': {'Data': msg}}})
      logger.info('Emails have been sent')

  logger.info('Start Sending SNS message to SMS')
  sns_configs = event.get('smsConfigurations', [])
  for sns_config in sns_configs:
    sns_msg = default_msg + '\n' + sns_config.get('additionalMessage', '')
    phone_numbers = sns_config.get('phoneNumbers', [])
    sender_id = sns_config.get('senderId')
    for phone_number in phone_numbers:
        if check_phone_number(phone_number):
          if check_value(sender_id):
            sns.publish(PhoneNumber=phone_number, Message=sns_msg, MessageAttributes={'AWS.SNS.SMS.SenderID':{'DataType': 'String','StringValue': sender_id}})
          else:
            sns.publish(PhoneNumber=phone_number, Message=sns_msg)
          logger.info('SNS messages have been sent')
```

Per ulteriori informazioni, consulta [Cos'è AWS Lambda?](https://docs.aws.amazon.com/lambda/latest/dg/welcome.html) nella *Guida per gli sviluppatori AWS Lambda *.

## CloudFormation modello
<a name="cfn-template"></a>

Usa il seguente CloudFormation modello per creare la tua funzione Lambda.

```
AWSTemplateFormatVersion: '2010-09-09'
Description: 'Notification Lambda for Alarm Model'
Resources:
  NotificationLambdaRole:
    Type: AWS::IAM::Role
    Properties:
      AssumeRolePolicyDocument:
        Statement:
          - Effect: Allow
            Principal:
              Service: lambda.amazonaws.com
            Action: sts:AssumeRole
      Path: "/"
      ManagedPolicyArns:
        - 'arn:aws:iam::aws:policy/AWSLambdaExecute'
      Policies:
        - PolicyName: "NotificationLambda"
          PolicyDocument:
            Version: "2012-10-17"		 	 	 
            Statement:
              - Effect: "Allow"
                Action:
                  - "ses:GetIdentityVerificationAttributes"
                  - "ses:SendEmail"
                  - "ses:VerifyEmailIdentity"
                Resource: "*"
              - Effect: "Allow"
                Action:
                  - "sns:Publish"
                  - "sns:OptInPhoneNumber"
                  - "sns:CheckIfPhoneNumberIsOptedOut"
                  - "sms-voice:DescribeOptedOutNumbers"
                Resource: "*"
              - Effect: "Deny"
                Action:
                  - "sns:Publish"
                Resource: "arn:aws:sns:*:*:*"
  NotificationLambdaFunction:              
    Type: AWS::Lambda::Function
    Properties:
      Role: !GetAtt NotificationLambdaRole.Arn
      Runtime: python3.7
      Handler: index.lambda_handler
      Timeout: 300
      MemorySize: 3008
      Code:
        ZipFile: |
          import boto3
          import json
          import logging
          import datetime
          logger = logging.getLogger()
          logger.setLevel(logging.INFO)
          ses = boto3.client('ses')
          sns = boto3.client('sns')
          def check_value(target):
            if target:
              return True
            return False

          # Check whether email is verified. Only verified emails are allowed to send emails to or from.
          def check_email(email):
            if not check_value(email):
              return False
            result = ses.get_identity_verification_attributes(Identities=[email])
            attr = result['VerificationAttributes']
            if (email not in attr or attr[email]['VerificationStatus'] != 'Success'):
                logging.info('Verification email for {} sent. You must have all the emails verified before sending email.'.format(email))
                ses.verify_email_identity(EmailAddress=email)
                return False
            return True

          # Check whether the phone holder has opted out of receiving SMS messages from your account
          def check_phone_number(phone_number):
            try:
              result = sns.check_if_phone_number_is_opted_out(phoneNumber=phone_number)
              if (result['isOptedOut']):
                  logger.info('phoneNumber {} is not opt in of receiving SMS messages. Phone number must be opt in first.'.format(phone_number))
                  return False
              return True
            except Exception as e:
              logging.error('Your phone number {} must be in E.164 format in SSO. Exception thrown: {}'.format(phone_number, e))
              return False

          def check_emails(emails):
            result = True
            for email in emails:
                if not check_email(email):
                    result = False
            return result

          def lambda_handler(event, context):
            logging.info('Received event: ' + json.dumps(event))
            nep = json.loads(event.get('notificationEventPayload'))
            alarm_state = nep['alarmState']
            default_msg = 'Alarm ' + alarm_state['stateName'] + '\n'
            timestamp = datetime.datetime.utcfromtimestamp(float(nep['stateUpdateTime'])/1000).strftime('%Y-%m-%d %H:%M:%S')
            alarm_msg = "{} {} {} at {} UTC ".format(nep['alarmModelName'], nep.get('keyValue', 'Singleton'), alarm_state['stateName'], timestamp)
            default_msg += 'Sev: ' + str(nep['severity']) + '\n'
            if (alarm_state['ruleEvaluation']):
              property = alarm_state['ruleEvaluation']['simpleRule']['inputProperty']
              default_msg += 'Current Value: ' + str(property) + '\n'
              operator = alarm_state['ruleEvaluation']['simpleRule']['operator']
              threshold = alarm_state['ruleEvaluation']['simpleRule']['threshold']
              alarm_msg += '({} {} {})'.format(str(property), operator, str(threshold))
            default_msg += alarm_msg + '\n'

            emails = event.get('emailConfigurations', [])
            logger.info('Start Sending Emails')
            for email in emails:
              from_adr = email.get('from')
              to_adrs = email.get('to', [])
              cc_adrs = email.get('cc', [])
              bcc_adrs = email.get('bcc', [])
              msg = default_msg + '\n' + email.get('additionalMessage', '')
              subject = email.get('subject', alarm_msg)
              fa_ver = check_email(from_adr)
              tas_ver = check_emails(to_adrs)
              ccas_ver = check_emails(cc_adrs)
              bccas_ver = check_emails(bcc_adrs)
              if (fa_ver and tas_ver and ccas_ver and bccas_ver):
                ses.send_email(Source=from_adr,
                               Destination={'ToAddresses': to_adrs, 'CcAddresses': cc_adrs, 'BccAddresses': bcc_adrs},
                               Message={'Subject': {'Data': subject}, 'Body': {'Text': {'Data': msg}}})
                logger.info('Emails have been sent')

            logger.info('Start Sending SNS message to SMS')
            sns_configs = event.get('smsConfigurations', [])
            for sns_config in sns_configs:
              sns_msg = default_msg + '\n' + sns_config.get('additionalMessage', '')
              phone_numbers = sns_config.get('phoneNumbers', [])
              sender_id = sns_config.get('senderId')
              for phone_number in phone_numbers:
                  if check_phone_number(phone_number):
                    if check_value(sender_id):
                      sns.publish(PhoneNumber=phone_number, Message=sns_msg, MessageAttributes={'AWS.SNS.SMS.SenderID':{'DataType': 'String','StringValue': sender_id}})
                    else:
                      sns.publish(PhoneNumber=phone_number, Message=sns_msg)
                    logger.info('SNS messages have been sent')
```

# Utilizzo della funzione Lambda fornita da AWS IoT Events
<a name="use-alarm-notifications"></a>

Con le notifiche di allarme, è possibile utilizzare la funzione Lambda fornita da AWS IoT Events per gestire le notifiche di allarme.

I seguenti requisiti si applicano quando si utilizza la funzione Lambda fornita da AWS IoT Events per gestire le notifiche di allarme:
+ È necessario verificare l'indirizzo e-mail che invia le notifiche e-mail in Amazon Simple Email Service (Amazon SES). Per ulteriori informazioni, consulta la sezione [Verifica dell'identità di un indirizzo e-mail](https://docs.aws.amazon.com/ses/latest/dg/creating-identities.html#just-verify-email-proc), nella *Amazon Simple Email Service Developer Guide*.

  Se ricevi un link di verifica, fai clic sul link per verificare il tuo indirizzo e-mail. Puoi anche controllare se c'è un'email di verifica nella cartella spam.
+ Se la sveglia invia notifiche SMS, è necessario utilizzare la formattazione dei numeri di telefono internazionali E.164 per i numeri di telefono. Questo formato contiene. `+<country-calling-code><area-code><phone-number>`

  Numeri di telefono di esempio:    
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/iotevents/latest/developerguide/use-alarm-notifications.html)

  [Per trovare il prefisso internazionale, vai su countrycode.org.](https://countrycode.org/)

  La funzione Lambda fornita da AWS IoT Events verifica se si utilizzano numeri di telefono in formato E.164. Tuttavia, non verifica i numeri di telefono. Se ti assicuri di aver inserito numeri di telefono corretti ma di non aver ricevuto notifiche SMS, puoi contattare i gestori telefonici. I gestori potrebbero bloccare i messaggi.

# Gestisci l'accesso a IAM Identity Center dei destinatari degli allarmi in AWS IoT Events
<a name="sso-authorization-recipients"></a>

AWS IoT Events utilizza AWS IAM Identity Center per gestire l'accesso SSO dei destinatari degli allarmi. L'implementazione di IAM Identity Center per i destinatari AWS IoT Events delle notifiche può migliorare la sicurezza e l'esperienza utente. Per consentire all'allarme di inviare notifiche ai destinatari, devi abilitare IAM Identity Center e aggiungere i destinatari al tuo archivio IAM Identity Center. Per ulteriori informazioni, consulta [Add Users](https://docs.aws.amazon.com/singlesignon/latest/userguide/addusers.html) in *AWS IAM Identity Center User* Guide.

**Importante**  
Devi scegliere la stessa AWS regione per e per AWS IoT Events IAM Identity Center. AWS Lambda
AWS Organizations supporta solo una regione IAM Identity Center alla volta. Se desideri rendere IAM Identity Center disponibile in una regione diversa, devi prima eliminare la configurazione corrente di IAM Identity Center. Per ulteriori informazioni, consulta [IAM Identity Center Region Data](https://docs.aws.amazon.com/singlesignon/latest/userguide/regions.html#region-data) in *AWS IAM Identity Center User Guide*.