

Aviso de fim do suporte: em 20 de maio de 2026, AWS encerrará o suporte para AWS IoT Events. Depois de 20 de maio de 2026, você não poderá mais acessar o AWS IoT Events console ou os AWS IoT Events recursos. Para obter mais informações, consulte [AWS IoT Events Fim do suporte](https://docs.aws.amazon.com/iotevents/latest/developerguide/iotevents-end-of-support.html).

As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.

# Gerenciando notificações de alarme em AWS IoT Events
<a name="lambda-support"></a>

AWS IoT Events integra-se ao Lambda, oferecendo recursos personalizados de processamento de eventos. Esta seção explora como usar as funções do Lambda em AWS IoT Events seus modelos de detectores, permitindo que você execute uma lógica complexa, interaja com serviços externos e implemente um tratamento sofisticado de eventos.

AWS IoT Events usa uma função Lambda para gerenciar notificações de alarme. Você pode usar a função Lambda fornecida por AWS IoT Events ou criar uma nova.

**Topics**
+ [Criação de uma função Lambda em AWS IoT Events](alarms-create-lambda.md)
+ [Usando a função Lambda fornecida pelo AWS IoT Events](use-alarm-notifications.md)
+ [Gerencie o acesso dos destinatários do alarme ao IAM Identity Center em AWS IoT Events](sso-authorization-recipients.md)

# Criação de uma função Lambda em AWS IoT Events
<a name="alarms-create-lambda"></a>

AWS IoT Events fornece uma função Lambda que permite que os alarmes enviem e recebam notificações por e-mail e SMS.

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

Os seguintes requisitos se aplicam ao criar uma função do Lambda para alarmes:
+ Se seu alarme enviar notificações por SMS, certifique-se de que o Amazon SNS esteja configurado para entregar mensagens SMS.
  + Para saber mais, consulte a documentação a seguir:
    + [Mensagens de texto móveis com Amazon SNS](https://docs.aws.amazon.com/sns/latest/dg/sns-mobile-phone-number-as-subscriber.html) e [identidades de originação para mensagens SMS do Amazon SNS no Guia do desenvolvedor do *Amazon*](https://docs.aws.amazon.com/sns/latest/dg/channels-sms-originating-identities.html) Simple Notification Service.
    + [O que é o AWS End User Messaging SMS?](https://docs.aws.amazon.com/sms-voice/latest/userguide/what-is-sms-mms.html) no *Guia do AWS SMS usuário*.
+ Se seu alarme enviar notificações por e-mail ou SMS, você deverá ter uma função do IAM que permita AWS Lambda trabalhar com o Amazon SES e o Amazon SNS.

  

  Exemplo de política:

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

------
+ Você deve escolher a mesma AWS região para AWS IoT Events AWS Lambda e. Para obter a lista de regiões compatíveis, consulte [Endpoints e cotas do AWS IoT Events](https://docs.aws.amazon.com/general/latest/gr/iot-events.html) e [Endpoints e cotas do AWS Lambda](https://docs.aws.amazon.com/general/latest/gr/lambda-service.html) no *Referência geral da Amazon Web Services*.

# Implemente uma função Lambda para usar AWS IoT Events CloudFormation
<a name="alarms-create-lambda-cfn"></a>

Este tutorial usa um CloudFormation modelo para implantar uma função Lambda. Esse modelo cria automaticamente um perfil do IAM que permite que a função do Lambda funcione com o Amazon SES e o Amazon SNS.

Veja a seguir como usar o AWS Command Line Interface (AWS CLI) para criar uma CloudFormation pilha.

1. <a name="install-cli"></a>No terminal do seu dispositivo, execute `aws --version` para verificar se você instalou AWS CLI o. Para obter mais informações, consulte [Instalar ou atualizar para a versão mais recente da AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html) no *Guia do usuário do AWS Command Line Interface *.

1. <a name="configure-cli"></a>Execute `aws configure list` para verificar se você configurou o AWS CLI na AWS região que tem todos os seus AWS recursos para este tutorial. Para obter mais informações, consulte [Definir e visualizar as configurações usando comandos](https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-files.html#cli-configure-files-methods) no *Guia AWS Command Line Interface do usuário*

1. Faça o download do CloudFormation modelo, [NotificationLambda.template.yaml.zip](samples/notificationLambda.template.yaml.zip).
**nota**  
Se você tiver dificuldade em baixar o arquivo, o modelo também está disponível no [CloudFormation modelo](alarms-create-lambda.md#cfn-template).

1. Descompacte o conteúdo e salve-o localmente como `notificationLambda.template.yaml`.

1. Abra um terminal em seu dispositivo e navegue até o diretório em que você fez o download do arquivo `notificationLambda.template.yaml`.

1. Para criar uma CloudFormation pilha, execute o seguinte comando:

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

Você pode modificar esse CloudFormation modelo para personalizar a função Lambda e seu comportamento.

**nota**  
AWS Lambda repete os erros de função duas vezes. Se a função não tiver capacidade suficiente para lidar com todas as solicitações em andamento, os eventos poderão ter de aguardar na fila por horas ou dias até serem enviados para a função. É possível configurar uma fila de mensagens não entregues (DLQ) na função para capturar eventos que não foram processados com êxito. Para obter mais informações, consulte [Invocação assíncrona](https://docs.aws.amazon.com/lambda/latest/dg/invocation-async.html) no *Guia do desenvolvedor do AWS Lambda *.

Você também pode criar ou configurar a pilha no CloudFormation console. Para mais informações, consulte [Como trabalhar com pilhas](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/stacks.html) no *Guia do usuário do AWS CloudFormation *.

# Criação de uma função Lambda personalizada para AWS IoT Events
<a name="alarms-create-custom-lambda"></a>

Você pode criar uma função do Lambda ou modificar a fornecida pelo AWS IoT Events.

Os seguintes requisitos se aplicam ao criar uma função do Lambda personalizada.
+ Adicione permissões que permitam que sua função Lambda execute ações específicas e acesse AWS recursos.
+ Se você usar a função Lambda fornecida por AWS IoT Events, certifique-se de escolher o tempo de execução do Python 3.7.

Exemplo da função do 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')
```

Para obter mais informações, consulte [O que é o AWS Lambda?](https://docs.aws.amazon.com/lambda/latest/dg/welcome.html) no *Guia do desenvolvedor do AWS Lambda *.

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

Use o CloudFormation modelo a seguir para criar sua função 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')
```

# Usando a função Lambda fornecida pelo AWS IoT Events
<a name="use-alarm-notifications"></a>

Com as notificações de alarme, você pode usar a função Lambda fornecida por AWS IoT Events para gerenciar notificações de alarme.

Os requisitos a seguir se aplicam quando você usa a função do Lambda fornecida pelo AWS IoT Events para gerenciar suas notificações de alarme:
+ Você deve verificar o endereço de e-mail que envia as notificações por e-mail no Amazon Simple Email Service (Amazon SES). Para ter mais informações, consulte [Verifying an email address identity](https://docs.aws.amazon.com/ses/latest/dg/creating-identities.html#just-verify-email-proc) no *Guia do desenvolvedor do Amazon Simple Email Service*.

  Se receber um link de verificação, clique no link para verificar seu endereço de e-mail. Você também pode verificar se há um e-mail de verificação na pasta de spam.
+ Se o alarme enviar notificações por SMS, você deverá usar a formatação de número de telefone internacional E.164 para números de telefone. Esse formato contém `+<country-calling-code><area-code><phone-number>`.

  Exemplos de números de telefone:    
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/iotevents/latest/developerguide/use-alarm-notifications.html)

  Para encontrar o código de chamada de um país, acesse [countrycode.org](https://countrycode.org/).

  A função Lambda fornecida por AWS IoT Events verifica se você usa números de telefone no formato E.164. No entanto, ele não verifica os números de telefone. Se você garantir que inseriu números de telefone corretos, mas não recebeu notificações por SMS, entre em contato com as operadoras telefônicas. As operadoras podem bloquear as mensagens.

# Gerencie o acesso dos destinatários do alarme ao IAM Identity Center em AWS IoT Events
<a name="sso-authorization-recipients"></a>

AWS IoT Events usa Centro de Identidade do AWS IAM para gerenciar o acesso SSO dos destinatários dos alarmes. A implementação do IAM Identity Center para destinatários de AWS IoT Events notificações pode aprimorar a segurança e a experiência do usuário. Para ativar o alarme para enviar notificações aos destinatários, você deve ativar o IAM Identity Center e adicionar destinatários à sua loja do IAM Identity Center. Para obter mais informações, consulte [Adicionar usuários](https://docs.aws.amazon.com/singlesignon/latest/userguide/addusers.html) no *Guia do usuário do Centro de Identidade do AWS IAM *.

**Importante**  
Você deve escolher a mesma AWS região para AWS IoT Events, AWS Lambda, e o IAM Identity Center.
AWS Organizations só oferece suporte a uma região do IAM Identity Center por vez. Se você quiser disponibilizar o IAM Identity Center em uma região diferente, primeiro exclua a configuração atual do IAM Identity Center. Para obter mais informações, consulte [Dados da região do IAM Identity Center](https://docs.aws.amazon.com/singlesignon/latest/userguide/regions.html#region-data) no *Guia do usuário do Centro de Identidade do AWS IAM *.