

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

# Monitoramento com alarmes em AWS IoT Events
<a name="iotevents-alarms"></a>

AWS IoT Events os alarmes ajudam você a monitorar seus dados em busca de alterações. Os dados podem ser indicadores que você mede para seus equipamentos e processos. É possível criar alarmes que enviam notificações quando um limite é violado. Os alarmes ajudam você a detectar problemas, racionalizar a manutenção e otimizar o desempenho de seus equipamentos e processos.

Alarmes são exemplos de modelos de alarme. O modelo de alarme especifica o que detectar, quando enviar notificações, quem é notificado e muito mais. Você também pode especificar uma ou mais [ações suportadas](https://docs.aws.amazon.com/iotevents/latest/developerguide/iotevents-supported-actions.html) que ocorrem quando o estado do alarme muda. AWS IoT Events direciona [os atributos de entrada](https://docs.aws.amazon.com/iotevents/latest/developerguide/iotevents-detector-input.html) derivados de seus dados para os alarmes apropriados. Se os dados que você está monitorando estiverem fora do intervalo especificado, o alarme será invocado. Você também pode reconhecer os alarmes ou configurá-los para o modo de soneca.

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

Você pode usar AWS IoT Events alarmes para monitorar as propriedades do ativo em AWS IoT SiteWise. AWS IoT SiteWise envia valores de propriedades de ativos para AWS IoT Events alarmes. AWS IoT Events envia o estado do alarme para AWS IoT SiteWise.

AWS IoT SiteWise também suporta alarmes externos. Você pode escolher alarmes externos se usar alarmes externos AWS IoT SiteWise e tiver uma solução que retorne os dados do estado do alarme. O alarme externo contém uma propriedade de medição que ingere os dados do estado do alarme.

AWS IoT SiteWise não avalia o estado dos alarmes externos. Além disso, não é possível reconhecer ou adiar um alarme externo quando o estado do alarme muda.

Você pode usar o recurso SiteWise Monitor para visualizar o estado dos alarmes externos nos portais do SiteWise Monitor.

Para obter mais informações, consulte [Monitoramento de dados com alarmes](https://docs.aws.amazon.com/iot-sitewise/latest/userguide/industrial-alarms.html) no *Guia do AWS IoT SiteWise usuário* e [Monitoramento com alarmes](https://docs.aws.amazon.com//iot-sitewise/latest/appguide/monitor-alarms.html) no Guia de *aplicação do SiteWise Monitor*.

## Fluxo de reconhecimento
<a name="acknowledge-flow"></a>

Ao criar um modelo de alarme, você escolhe se deseja ativar o fluxo de reconhecimento. Se você ativar o fluxo de reconhecimento, a sua equipe será notificada quando o estado do alarme mudar. A sua equipe pode reconhecer o alarme e deixar uma observação. Por exemplo, é possível incluir as informações do alarme e as ações que vai tomar para resolver o problema. Se os dados que você está monitorando estiverem fora do intervalo especificado, o alarme será invocado.

Os alarmes têm um dos seguintes estados:

`DISABLED`  
Quando o alarme está no estado `DISABLED`, ele não está pronto para avaliar os dados. Para ativar o alarme, você deve alterar o alarme para o estado `NORMAL`.

`NORMAL`  
Quando o alarme está no estado `NORMAL`, ele está pronto para avaliar os dados.

`ACTIVE`  
Se o alarme estiver no estado `ACTIVE`, o alarme será invocado. Os dados que você está monitorando estão fora do intervalo especificado.

`ACKNOWLEDGED`  
Quando o alarme está no estado `ACKNOWLEDGED`, o alarme foi invocado e você reconheceu o alarme.

`LATCHED`  
O alarme foi invocado, mas você não o reconheceu após um período de tempo. O alarme muda automaticamente para o estado `NORMAL`.

`SNOOZE_DISABLED`  
Quando o alarme está no estado `SNOOZE_DISABLED`, o alarme é desativado por um período de tempo especificado. Após o tempo de soneca, o alarme muda automaticamente para o estado `NORMAL`.

# Criando um modelo de alarme em AWS IoT Events
<a name="create-alarm-model"></a>

Você pode usar AWS IoT Events alarmes para monitorar seus dados e ser notificado quando um limite for violado. Os alarmes fornecem parâmetros que você usa para criar ou configurar um modelo de alarme. Você pode usar o AWS IoT Events console ou a AWS IoT Events API para criar ou configurar o modelo de alarme. Quando você configura o modelo de alarme, as alterações entram em vigor à medida em que novos dados chegam.

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

Os seguintes requisitos se aplicam ao criar um modelo de alarme.
+ Você pode criar um modelo de alarme para monitorar um atributo de entrada AWS IoT Events ou uma propriedade de ativo em AWS IoT SiteWise.
  + Se você optar por monitorar um atributo de entrada em AWS IoT Events, [Crie uma entrada para modelos em AWS IoT Events](create-input-overview.md) antes de criar o modelo de alarme.
  + Se você optar por monitorar uma propriedade de ativo, deverá [criar um modelo de ativo](https://docs.aws.amazon.com/iot-sitewise/latest/userguide/create-asset-models.html) AWS IoT SiteWise antes de criar o modelo de alarme.
+ Você deve ter uma função do IAM que permita que seu alarme execute ações e acesse AWS recursos. Para obter mais informações, consulte [Configuração de permissões do IAM para o AWS IoT Events](https://docs.aws.amazon.com/iotevents/latest/developerguide/iotevents-start.html).
+ Todos os AWS recursos que este tutorial usa devem estar na mesma AWS região.

## Como criar um modelo de alarme (console)
<a name="create-alarm-model-console"></a>

Veja a seguir como criar um modelo de alarme para monitorar um AWS IoT Events atributo no AWS IoT Events console.

1. Faça login no [console do AWS IoT Events](https://console.aws.amazon.com/iotevents/).

1. No painel de navegação, selecione **Modelos de alarme**.

1. Na página **Modelos de alarme**, selecione **Criar modelo de alarme**.

1. Na seção **Detalhes de modelos de alarme**, faça o seguinte:

   1. Insira um nome exclusivo.

   1. (Opcional) Insira uma descrição.

1. Na seção **Alvo do alarme**, faça o seguinte:
**Importante**  
Se escolher **Propriedade do ativo do AWS IoT SiteWise **, você deverá ter criado um modelo de ativo no AWS IoT SiteWise.

   1. Escolha o **atributo de entrada do AWS IoT Events **.

   1. Escolha a entrada.

   1. Escolha a chave do atributo de entrada. Esse atributo de entrada é usado como uma chave para criar o alarme. AWS IoT Events direciona as entradas associadas a essa chave para o alarme.
**Importante**  
Se a carga útil de mensagem de entrada não contiver essa chave de atributo de entrada ou se a chave não estiver no mesmo caminho JSON especificado na chave, a mensagem falhará na ingestão no AWS IoT Events.

1. Na seção **Definições de limite**, você define o atributo de entrada, o valor limite e o operador de comparação AWS IoT Events usados para alterar o estado do alarme.

   1. Em **Atributo de entrada**, escolha o atributo que você deseja monitorar.

      Cada vez que esse atributo de entrada recebe novos dados, ele é avaliado para determinar o estado do alarme.

   1. Em **Operador**, escolha o operador de comparação. O operador compara seu atributo de entrada com o valor limite do seu atributo.

      É possível escolher entre as seguintes opções: 
      + **> maior que**
      + **>= maior ou igual a**
      + **< menor que**
      + **<= menor ou igual a**
      + **= igual a**
      + **\$1= não igual a**

   1. Para **Valor** limite, insira um número ou escolha um atributo nas AWS IoT Events entradas. AWS IoT Events compara esse valor com o valor do atributo de entrada que você escolher. 

   1. (Opcional) Para **Gravidade**, use um número que sua equipe entenda para refletir a gravidade desse alarme.

1. (Opcional) Na seção **Configurações de notificação**, defina as configurações de notificação para o alarme.

   É possível adicionar até 10 notificações. Em **Notificação 1**, faça o seguinte:

   1. Em **Protocolo**, escolha uma das seguintes opções:
      + **E-mail e texto**: o alarme envia uma notificação por SMS e uma notificação por e-mail.
      + **E-mail**: o alarme envia uma notificação por e-mail.
      + **Texto**: o alarme envia uma notificação por SMS.

   1. Para **Remetente**, especifique o endereço de e-mail que pode enviar notificações sobre esse alarme.

      Para adicionar mais endereços de e-mail à sua lista de remetentes, escolha **Adicionar remetente**. 

   1. (Opcional) Em **Destinatário**, escolha o destinatário.

      Para adicionar mais usuários à sua lista de destinatários, escolha **Adicionar novo usuário**. Você deve adicionar novos usuários à sua loja do IAM Identity Center antes de poder adicioná-los ao seu modelo de alarme. Para obter mais informações, consulte [Gerencie o acesso dos destinatários do alarme ao IAM Identity Center em AWS IoT Events](sso-authorization-recipients.md).

   1. (Opcional) Em **Mensagem personalizada adicional**, insira uma mensagem que descreva o que o alarme detecta e quais ações os destinatários devem tomar.

1. Na seção **Instância**, é possível ativar ou desativar todas as instâncias de alarme criadas com base nesse modelo de alarme.

1. Na seção **Configurações avançadas**, faça o seguinte:

   1. Para o **Fluxo de reconhecimento**, você pode ativar ou desativar as notificações.
      + Se for **Ativado**, você receberá uma notificação quando o estado do alarme mudar. Você precisa escolher confirmar a notificação antes que o estado de alarme possa retornar para o normal.
      + Se você escolher **Desativado**, nenhuma ação será necessária. O alarme muda automaticamente para o estado normal quando de medição retorna ao intervalo especificado.

      Para obter mais informações, consulte [Fluxo de reconhecimento](iotevents-alarms.md#acknowledge-flow).

   1. Para **Permissões**, selecione uma das seguintes opções:
      + Você pode **criar uma nova função a partir de modelos de AWS política** e criar AWS IoT Events automaticamente uma função do IAM para você. 
      + Você pode **usar uma função existente do IAM** que permite que esse modelo de alarme execute ações e acesse outros AWS recursos.

      Para obter mais informações, consulte [Gerenciamento de identidade e acesso do AWS IoT Events](https://docs.aws.amazon.com/iotevents/latest/developerguide/security-iam.html).

   1. Para **Configurações adicionais de notificação**, você pode editar sua AWS Lambda função para gerenciar as notificações de alarme. Escolha uma das seguintes opções para sua AWS Lambda função:
      + **Crie uma nova AWS Lambda função** - AWS IoT Events cria uma nova AWS Lambda função para você.
      + **Use uma AWS Lambda função existente** - Use uma AWS Lambda função existente escolhendo um nome de AWS Lambda função. 

      Para obter mais informações sobre as ações possíveis, consulte [AWS IoT Events trabalhando com outros AWS serviços](iotevents-other-aws-services.md).

   1. (Opcional) Em **Definir ação de estado**, você pode adicionar uma ou mais AWS IoT Events ações a serem tomadas quando o estado do alarme mudar.

1. (Opcional) Você pode adicionar **Tags** para gerenciar os seus alarmes. Para obter mais informações, consulte [Marcar seus recursos do AWS IoT Events](https://docs.aws.amazon.com/iotevents/latest/developerguide/tagging-iotevents.html).

1. Escolha **Criar**.

# Respondendo aos alarmes em AWS IoT Events
<a name="respond-to-alarms"></a>

Responder aos alarmes de forma eficaz é um aspecto importante do gerenciamento de sistemas de IoT com. AWS IoT Events Explore várias maneiras de configurar e lidar com alarmes, incluindo: configurar canais de notificação, definir procedimentos de escalonamento e implementar ações de resposta automatizadas. Aprenda a criar condições de alarme diferenciadas, priorizar alertas e integrar-se a outros AWS serviços para criar um sistema de gerenciamento de alarmes responsivo para seus aplicativos de IoT.

Se você ativou o [fluxo de reconhecimento](https://docs.aws.amazon.com/iotevents/latest/developerguide/iotevents-alarms.html#acknowledge-flow), você receberá uma notificação quando o estado do alarme mudar. Para responder ao alarme, você pode reconhecer, desativar, ativar, redefinir ou suspender o alarme.

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

Veja a seguir como responder a um alarme no console do AWS IoT Events .

1. Faça login no [console do AWS IoT Events](https://console.aws.amazon.com/iotevents/).

1. No painel de navegação, selecione **Modelos de alarme**.

1. Escolha o modelo de alarme alvo.

1. Na seção **Lista de alarmes**, escolha o alarme alvo.

1. É possível escolher uma das seguintes **Ações**:
   + **Reconhecer**: o alarme muda para o estado `ACKNOWLEDGED`.
   + **Desativar**: o alarme muda para o estado `DISABLED`.
   + **Ativar**: o alarme muda para o estado `NORMAL`.
   + **Redefinir**: o alarme muda para o estado `NORMAL`.
   + **Suspender,** e em seguida, faça o seguinte:

     1. Escolha a **Duração da suspensão** ou insira uma **Duração de suspensão personalizada**.

     1. Escolha **Salvar**.

     O alarme muda para o estado `SNOOZE_DISABLED`

   Para mais informações sobre esses estados, consulte [Fluxo de reconhecimento](iotevents-alarms.md#acknowledge-flow).

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

Para responder a um ou mais alarmes, você pode usar as seguintes operações de 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)

------

# 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 *.