

Avis de fin de support : le 20 mai 2026, AWS le support de AWS IoT Events. Après le 20 mai 2026, vous ne pourrez plus accéder à la AWS IoT Events console ni aux AWS IoT Events ressources. Pour plus d'informations, consultez [AWS IoT Events la fin du support](https://docs.aws.amazon.com/iotevents/latest/developerguide/iotevents-end-of-support.html).

Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.

# Gestion des notifications d'alarme dans AWS IoT Events
<a name="lambda-support"></a>

AWS IoT Events s'intègre à Lambda, offrant des fonctionnalités de traitement d'événements personnalisées. Cette section explique comment utiliser les fonctions Lambda dans vos modèles de AWS IoT Events détecteurs, ce qui vous permet d'exécuter une logique complexe, d'interagir avec des services externes et de mettre en œuvre une gestion sophistiquée des événements.

AWS IoT Events utilise une fonction Lambda pour gérer les notifications d'alarme. Vous pouvez utiliser la fonction Lambda fournie par AWS IoT Events ou en créer une nouvelle.

**Topics**
+ [Création d'une fonction Lambda dans AWS IoT Events](alarms-create-lambda.md)
+ [À l'aide de la fonction Lambda fournie par AWS IoT Events](use-alarm-notifications.md)
+ [Gérez l'accès des destinataires des alarmes à l'IAM Identity Center dans AWS IoT Events](sso-authorization-recipients.md)

# Création d'une fonction Lambda dans AWS IoT Events
<a name="alarms-create-lambda"></a>

AWS IoT Events fournit une fonction Lambda qui permet aux alarmes d'envoyer et de recevoir des notifications par e-mail et SMS.

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

Les exigences suivantes s'appliquent lorsque vous créez une fonction Lambda pour les alarmes :
+ Si votre alarme envoie des notifications par SMS, assurez-vous qu'Amazon SNS est configuré pour envoyer des SMS.
  + Pour plus d’informations, consultez la documentation suivante :
    + [Messagerie texte mobile avec Amazon SNS](https://docs.aws.amazon.com/sns/latest/dg/sns-mobile-phone-number-as-subscriber.html) et [identités d'origine pour les messages SMS Amazon SNS dans le guide du développeur *Amazon Simple* Notification](https://docs.aws.amazon.com/sns/latest/dg/channels-sms-originating-identities.html) Service.
    + [Qu'est-ce que la messagerie SMS destinée aux utilisateurs finaux d'AWS ?](https://docs.aws.amazon.com/sms-voice/latest/userguide/what-is-sms-mms.html) dans le *guide de AWS SMS l'utilisateur*.
+ Si votre alarme envoie des notifications par e-mail ou SMS, vous devez disposer d'un rôle IAM qui vous permet AWS Lambda de travailler avec Amazon SES et Amazon SNS.

  

  Exemple de politique :

------
#### [ 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" : "*"
          }
      ]
  }
  ```

------
+ Vous devez choisir la même AWS région pour les deux AWS IoT Events et AWS Lambda. Pour la liste des régions prises en charge, voir [AWS IoT Events points de terminaison et quotas et points](https://docs.aws.amazon.com/general/latest/gr/iot-events.html) de [AWS Lambda terminaison et quotas](https://docs.aws.amazon.com/general/latest/gr/lambda-service.html) dans le. *Référence générale d'Amazon Web Services*

# Déployez une fonction Lambda pour utiliser AWS IoT Events CloudFormation
<a name="alarms-create-lambda-cfn"></a>

Ce didacticiel utilise un CloudFormation modèle pour déployer une fonction Lambda. Ce modèle crée automatiquement un rôle IAM qui permet à la fonction Lambda de fonctionner avec Amazon SES et Amazon SNS.

Ce qui suit vous montre comment utiliser le AWS Command Line Interface (AWS CLI) pour créer une CloudFormation pile.

1. <a name="install-cli"></a>Dans le terminal de votre appareil, exécutez `aws --version` pour vérifier si vous avez installé le AWS CLI. Pour plus d’informations, consultez la section [Installation ou mise à jour vers la version la plus récente de l’ AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html) dans le *Guide de l’utilisateur AWS Command Line Interface *.

1. <a name="configure-cli"></a>Exécutez `aws configure list` pour vérifier si vous avez configuré le AWS CLI dans la AWS région qui contient toutes vos AWS ressources pour ce didacticiel. Pour plus d'informations, voir [Définir et afficher les paramètres de configuration à l'aide des commandes](https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-files.html#cli-configure-files-methods) du *Guide de AWS Command Line Interface l'utilisateur*

1. Téléchargez le CloudFormation modèle, [NotificationLambda.Template.Yaml.zip](samples/notificationLambda.template.yaml.zip).
**Note**  
Si vous rencontrez des difficultés pour télécharger le fichier, le modèle est également disponible dans le[CloudFormation modèle](alarms-create-lambda.md#cfn-template).

1. Décompressez le contenu et enregistrez-le localement en tant que `notificationLambda.template.yaml`.

1. Ouvrez un terminal sur votre appareil et accédez au répertoire dans lequel vous avez téléchargé le `notificationLambda.template.yaml` fichier.

1. Pour créer une CloudFormation pile, exécutez la commande suivante :

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

Vous pouvez modifier ce CloudFormation modèle pour personnaliser la fonction Lambda et son comportement.

**Note**  
AWS Lambda réessaie deux fois les erreurs de fonction. Si la fonction ne dispose pas de la capacité suffisante pour gérer toutes les demandes entrantes, des événements peuvent attendre dans la file d'attente pendant des heures ou des jours avant d'être envoyés à la fonction. Vous pouvez configurer une file d'attente de messages non remis (DLQ) sur la fonction pour capturer les événements qui n'ont pas été traités correctement. Pour plus d'informations, consultez [Appel asynchrone](https://docs.aws.amazon.com/lambda/latest/dg/invocation-async.html) dans le *Guide du développeur AWS Lambda *.

Vous pouvez également créer ou configurer la pile dans la CloudFormation console. Pour plus d'informations, consultez la section [Utilisation des piles](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/stacks.html) dans le *Guide de l'AWS CloudFormation utilisateur*.

# Création d'une fonction Lambda personnalisée pour AWS IoT Events
<a name="alarms-create-custom-lambda"></a>

Vous pouvez créer une fonction Lambda ou modifier celle fournie par. AWS IoT Events

Les exigences suivantes s'appliquent lorsque vous créez une fonction Lambda personnalisée.
+ Ajoutez des autorisations qui permettent à votre fonction Lambda d'effectuer des actions spécifiques et d'accéder aux AWS ressources.
+ Si vous utilisez la fonction Lambda fournie par AWS IoT Events, assurez-vous de choisir le runtime Python 3.7.

Exemple de fonction 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')
```

Pour plus d'informations, veuillez consulter [Présentation de AWS Lambda](https://docs.aws.amazon.com/lambda/latest/dg/welcome.html) dans le *Manuel du développeur AWS Lambda *.

## CloudFormation modèle
<a name="cfn-template"></a>

Utilisez le CloudFormation modèle suivant pour créer votre fonction 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')
```

# À l'aide de la fonction Lambda fournie par AWS IoT Events
<a name="use-alarm-notifications"></a>

Avec les notifications d'alarme, vous pouvez utiliser la fonction Lambda fournie par AWS IoT Events pour gérer les notifications d'alarme.

Les exigences suivantes s'appliquent lorsque vous utilisez la fonction Lambda fournie par AWS IoT Events pour gérer vos notifications d'alarme :
+ Vous devez vérifier l'adresse e-mail qui envoie les notifications par e-mail dans Amazon Simple Email Service (Amazon SES). Pour plus d'informations, consultez [Vérifier l'identité d'une adresse e-mail](https://docs.aws.amazon.com/ses/latest/dg/creating-identities.html#just-verify-email-proc) dans le manuel *Amazon Simple Email Service Developer Guide*.

  Si vous recevez un lien de vérification, cliquez dessus pour vérifier votre adresse e-mail. Vous pouvez également vérifier la présence d'un e-mail de vérification dans votre dossier de courrier indésirable.
+ Si votre alarme envoie des notifications par SMS, vous devez utiliser le format de numéro de téléphone international E.164 pour les numéros de téléphone. Ce format contient`+<country-calling-code><area-code><phone-number>`.

  Exemples de numéros de téléphone :    
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/iotevents/latest/developerguide/use-alarm-notifications.html)

  Pour trouver le code d'appel d'un pays, rendez-vous sur [countrycode.org](https://countrycode.org/).

  La fonction Lambda fournie par AWS IoT Events vérifie si vous utilisez des numéros de téléphone au format E.164. Cependant, il ne vérifie pas les numéros de téléphone. Si vous vous assurez que vous avez saisi des numéros de téléphone exacts mais que vous n'avez pas reçu de notifications par SMS, vous pouvez contacter les opérateurs téléphoniques. Les transporteurs peuvent bloquer les messages.

# Gérez l'accès des destinataires des alarmes à l'IAM Identity Center dans AWS IoT Events
<a name="sso-authorization-recipients"></a>

AWS IoT Events permet AWS IAM Identity Center de gérer l'accès SSO des destinataires des alarmes. La mise en œuvre d'IAM Identity Center pour les destinataires des AWS IoT Events notifications peut améliorer la sécurité et l'expérience utilisateur. Pour permettre à l'alarme d'envoyer des notifications aux destinataires, vous devez activer IAM Identity Center et ajouter des destinataires à votre boutique IAM Identity Center. Pour plus d'informations, consultez la section [Ajouter des utilisateurs](https://docs.aws.amazon.com/singlesignon/latest/userguide/addusers.html) dans le *guide de AWS IAM Identity Center l'utilisateur*.

**Important**  
Vous devez choisir la même AWS région pour AWS IoT Events AWS Lambda, et le centre d'identité IAM.
AWS Organizations ne prend en charge qu'une seule région du centre d'identité IAM à la fois. Si vous souhaitez rendre IAM Identity Center disponible dans une autre région, vous devez d'abord supprimer votre configuration IAM Identity Center actuelle. Pour plus d'informations, consultez les [données régionales du centre d'identité IAM](https://docs.aws.amazon.com/singlesignon/latest/userguide/regions.html#region-data) dans le *guide de AWS IAM Identity Center l'utilisateur*.