Pré-requisitos Criar uma política do AWS IoT Criar e configurar uma coisa do AWS IoT Criar um modelo de ativo de dispositivo Criar um modelo de ativo de frota de dispositivos Criar e configurar um ativo de dispositivo Criar e configurar um ativo de frota de dispositivos Criar uma regra noAWS IoTEssencial para enviar dados aos ativos de dispositivo Executar o script do cliente do dispositivo Limpeza de recursos Solucionar problemas de uma regra

Ingerir dados no AWS IoT SiteWise de coisas do AWS IoT

É possível ingerir dados facilmente no AWS IoT SiteWise de uma frota de coisas do AWS IoT usando sombras de dispositivos. As sobras de dispositivos são objetos JSON que armazenam informações sobre o estado atual de um dispositivo do AWS IoT. Para obter mais informações, consulteServiço Device ShadownoAWS IoTGuia do desenvolvedor.

Depois de concluir este tutorial, você pode configurar uma operação no AWS IoT SiteWise com base em coisas do AWS IoT. Com as coisas do AWS IoT, também é possível integrar facilmente a operação com outros recursos úteis do AWS IoT. Por exemplo, é possível configurar recursos do AWS IoT para fazer as seguintes tarefas:

Defina regras adicionais para fazer streaming de dados noAWS IoT Events,Amazon DynamoDB, e outrosAWSServiços da . Para obter mais informações, consulteRegrasnoAWS IoTGuia do desenvolvedor.
Indexar, pesquisar e agregar os dados do dispositivo com o serviço de indexação de frotas do AWS IoT. Para obter mais informações, consulteServiço de indexação de frotanoAWS IoTGuia do desenvolvedor.
Auditar e proteger os dispositivos com o AWS IoT Device Defender. Para obter mais informações, consulte AWS IoT Device Defender no Guia do desenvolvedor do AWS IoT.

Neste tutorial, saiba como ingerir dados de sombras de dispositivos de coisas do AWS IoT em ativos no AWS IoT SiteWise. Para fazer isso, crie uma ou mais coisas do AWS IoT e execute um script que atualiza cada sombra de dispositivo de coisa dom dados de uso de CPU e memória. Use os dados de uso de CPU e memória neste tutorial para imitar dados de sensor realistas. Depois, crie uma regra com uma ação do AWS IoT SiteWise que envia esses dados para um ativo no AWS IoT SiteWise sempre que a sombra de dispositivo de uma coisa é atualizada. Para obter mais informações, consulte Ingerir dados usando regras do AWS IoT Core.

Tópicos

Pré-requisitos
Criar uma política do AWS IoT
Criar e configurar uma coisa do AWS IoT
Criar um modelo de ativo de dispositivo
Criar um modelo de ativo de frota de dispositivos
Criar e configurar um ativo de dispositivo
Criar e configurar um ativo de frota de dispositivos
Criar uma regra noAWS IoTEssencial para enviar dados aos ativos de dispositivo
Executar o script do cliente do dispositivo
Limpar recursos após o tutorial
Solucionar problemas de uma regra

Pré-requisitos

Para concluir este tutorial, você precisará do seguinte:

Uma conta da AWS. Se você não tiver uma, consulte Configurar uma conta da AWS.
Um computador de desenvolvimento que executa Windows, macOS, Linux ou Unix para acessar o AWS Management Console. Para obter mais informações, consulte Conceitos básicos sobre o AWS Management Console.
Um usuário do IAM com permissões de administrador.
Python 3 instalado no computador de desenvolvimento ou instalado no dispositivo que você deseja registrar como uma coisa do AWS IoT.

Criar uma política do AWS IoT

Neste procedimento, crie uma política do AWS IoT que conceda às coisas do AWS IoT acesso aos recursos usados neste tutorial.

Para criar uma política do AWS IoT

Faça login no AWS Management Console.
Revise as regiões da AWS onde o AWS IoT SiteWise é compatível. Mude para uma dessas regiões compatíveis, se necessário.
Navegue até o console do AWS IoT. Se um botão Get started (Começar a usar) for exibido, selecione-o.
No painel de navegação à esquerda, selecione Secure (Proteger) e Policies (Políticas).
Se uma caixa de diálogo You don’t have any policies yet (Você ainda não tem políticas), selecione Create a policy (Criar uma política). Caso contrário, escolha Create (Criar).
Insira um nome para a política do AWS IoT (por exemplo, SiteWiseTutorialDevicePolicy).

Em Add statements (Adicionar instruções), selecione Advanced mode (Modo avançado) para inserir a política a seguir no formulário JSON. Substitua region e account-id por sua região e seu ID da conta, como us-east-1 e 123456789012.


{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Effect": "Allow",
      "Action": "iot:Connect",
      "Resource": "arn:aws:iot:region:account-id:client/SiteWiseTutorialDevice*"
    },
    {
      "Effect": "Allow",
      "Action": "iot:Publish",
      "Resource": [
        "arn:aws:iot:region:account-id:topic/$aws/things/${iot:Connection.Thing.ThingName}/shadow/update",
        "arn:aws:iot:region:account-id:topic/$aws/things/${iot:Connection.Thing.ThingName}/shadow/delete",
        "arn:aws:iot:region:account-id:topic/$aws/things/${iot:Connection.Thing.ThingName}/shadow/get"
      ]
    },
    {
      "Effect": "Allow",
      "Action": "iot:Receive",
      "Resource": [
        "arn:aws:iot:region:account-id:topic/$aws/things/${iot:Connection.Thing.ThingName}/shadow/update/accepted",
        "arn:aws:iot:region:account-id:topic/$aws/things/${iot:Connection.Thing.ThingName}/shadow/delete/accepted",
        "arn:aws:iot:region:account-id:topic/$aws/things/${iot:Connection.Thing.ThingName}/shadow/get/accepted",
        "arn:aws:iot:region:account-id:topic/$aws/things/${iot:Connection.Thing.ThingName}/shadow/update/rejected",
        "arn:aws:iot:region:account-id:topic/$aws/things/${iot:Connection.Thing.ThingName}/shadow/delete/rejected"
      ]
    },
    {
      "Effect": "Allow",
      "Action": "iot:Subscribe",
      "Resource": [
        "arn:aws:iot:region:account-id:topicfilter/$aws/things/${iot:Connection.Thing.ThingName}/shadow/update/accepted",
        "arn:aws:iot:region:account-id:topicfilter/$aws/things/${iot:Connection.Thing.ThingName}/shadow/delete/accepted",
        "arn:aws:iot:region:account-id:topicfilter/$aws/things/${iot:Connection.Thing.ThingName}/shadow/get/accepted",
        "arn:aws:iot:region:account-id:topicfilter/$aws/things/${iot:Connection.Thing.ThingName}/shadow/update/rejected",
        "arn:aws:iot:region:account-id:topicfilter/$aws/things/${iot:Connection.Thing.ThingName}/shadow/delete/rejected"
      ]
    },
    {
      "Effect": "Allow",
      "Action": [
        "iot:GetThingShadow",
        "iot:UpdateThingShadow",
        "iot:DeleteThingShadow"
      ],
      "Resource": "arn:aws:iot:region:account-id:thing/SiteWiseTutorialDevice*"
    }
  ]
}

Essa política permite que as coisas do AWS IoT se conectem e interajam com sombras de dispositivos por mensagens MQTT. Para interagir com sombras de dispositivos, as coisas do AWS IoT publicam e recebem mensagens MQTT em tópicos que começam com $aws/things/thing-name/shadow/. Essa política usa uma variável de política de coisa ${iot:Connection.Thing.ThingName}, que substitui o nome da coisa conectada em cada tópico. A instrução iot:Connect limita quais coisas podem se conectar, assim, a variável de política de coisa só pode substituir nomes que começam com SiteWiseTutorialDevice.

Para obter mais informações, consulteVariáveis de política de coisasnoAWS IoTGuia do desenvolvedor.

nota

Essa política se aplica a coisas cujos nomes começam com SiteWiseTutorialDevice. Para usar um nome diferente para as coisas, é necessário atualizar a política de acordo.

Escolha Create (Criar).

Criar e configurar uma coisa do AWS IoT

Neste procedimento, crie e configure uma coisa do AWS IoT. É possível registrar o computador de desenvolvimento como uma coisa do AWS IoT para concluir este tutorial facilmente. Ao aplicar os conceitos deste tutorial em um aplicativo do mundo real, é possível criar e configurarAWS IoTcoisas em qualquer dispositivo que possa executar umAWS IoTSDK, incluindoAWS IoT Greengrasse FreeRTOS. Para obter mais informações, consulteAWS IoTSDKs danoAWS IoTGuia do desenvolvedor.

Como criar e configurar uma coisa do AWS IoT

Abra uma linha de comando e execute o comando a seguir a fim de criar um diretório para este tutorial.
```
mkdir iot-sitewise-rule-tutorial
cd iot-sitewise-rule-tutorial
```
Execute o comando a seguir a fim de criar um diretório para os certificados da coisa.
```
mkdir device1
```
Se você estiver criando coisas adicionais, incremente o número no nome do diretório de acordo para manter o controle de quais certificados pertencem a qual coisa.
Navegue até o console do AWS IoT.
No painel de navegação à esquerda, selecione Manage (Gerenciar) e Things (Coisas).
Se uma caixa de diálogo You don’t have any things yet (Você ainda não tem coisas), selecione Create a thing (Criar uma coisa). Caso contrário, escolha Create (Criar).
Na página Creating AWS IoT things (Criar coisas para IoT), escolha Create a single thing (Criar uma única coisa).
Na página Add your device to the device registry (Adicionar o dispositivo ao registro do dispositivo), insira um nome para a coisa do AWS IoT (por exemplo, SiteWiseTutorialDevice1) e selecione Next (Próximo). Se você estiver criando coisas adicionais, incremente o número no nome da coisa de acordo.

Importante
O nome da coisa deve corresponder ao nome usado na política criada anteriormente neste tutorial. Caso contrário, o dispositivo não poderá se conectar ao AWS IoT.
Na página Add a certificate for your thing (Adicionar um certificado à sua coisa), escolha Create certificate (Criar certificado). Os certificados permitem que o AWS IoT identifique os dispositivos com segurança.
Selecione os links de Download (Fazer download) para fazer download do certificado, da chave pública de da chave privada da coisa. Salve todos os três arquivos no diretório criado para os certificados da coisa (por exemplo, iot-sitewise-rule-tutorial/device1).

Importante
Essa é a única vez que você pode fazer download do certificado e das chaves da coisa. Eles são necessário para que o dispositivo possa se conectar ao AWS IoT.
Selecione o link Download (Fazer download) da CA raiz para abrir uma página de documentação onde você escolhe e faz download de um certificado CA raiz. Salve o certificado CA em iot-sitewise-rule-tutorial. Recomendamos fazer download do Amazon Root CA 1.
Selecione Ativar.
Selecione Attach a policy (Anexar uma política).
Na página Add a policy for your thing (Adicionar uma política à coisa), selecione a política criada anteriormente neste tutorial (SiteWiseTutorialDevicePolicy) e selecione Register Thing (Registrar coisa).
Agora você registrou uma coisa do AWS IoT no computador. Agora você pode executar uma dar próximas etapas a seguir:
- Prossiga para a próxima seção sem criar coisas adicionais do AWS IoT. É possível concluir este tutorial com somente uma coisa.
- Reputa as etapas nesta seção em outro computador ou dispositivo para criar mais coisas do AWS IoT. Para este tutorial, recomendamos que você siga esta opção para poder ingerir dados de uso de CPU e memória exclusivos de vários dispositivos.
- Reputa as etapas desta seção no mesmo dispositivo (o computador) para criar mais coisas do AWS IoT. Cada coisa do AWS IoT recebe dados de uso de CPU e memória semelhantes do computador, portanto, use essa abordagem para demonstrar a ingestão de dados não exclusivos de vários dispositivos.

Criar um modelo de ativo de dispositivo

Neste procedimento, crie um modelo de ativo no AWS IoT SiteWise para representar os dispositivos que fazem streaming de dados de uso de CPU e memória. Os modelos de ativo impõem informações consistentes em vários ativos do mesmo tipo para que você possa processar dados nos ativos que representam grupos de dispositivos. Para obter mais informações, consulte Modelagem de ativos industriais.

Como criar um modelo de ativo que representa um dispositivo

Navegue até o console do AWS IoT SiteWise.
No painel de navegação à esquerda, selecione Models (Modelos).
Escolha Create model (Criar modelo).
Insira um nome em Asset model information (Informações do modelo de ativo) (por exemplo, SiteWise Tutorial Device Model).
Em Measurement definitions (Definições de medição), faça o seguinte:
1. Em Name (Nome), insira CPU Usage.
2. Em Unit (Unidade), insira %.
3. Deixe o Data type (Tipo de dados) como Double (Duplo).
As propriedades de medição representam os fluxos de dados brutos de um dispositivo. Para obter mais informações, consulte Definindo fluxos de dados de equipamentos (medições).
Selecione Add measurement (Adicionar medição) para adicionar uma segunda propriedade de medição.
Na segunda linha, em Measurement definitions (Definições da medição), faça o seguinte:
1. Em Name (Nome), insira Memory Usage.
2. Em Unit (Unidade), insira %.
3. Deixe o Data type (Tipo de dados) como Double (Duplo).
Em Metric definitions (Definições de métrica), faça o seguinte:
1. Em Name (Nome), insira Average CPU Usage.
2. Em Formula (Fórmula), insira avg(CPU Usage). Selecione CPU Usage na lista de preenchimento automático quando ela for exibida.
3. Em Time interval (Intervalo de tempo), insira 5 minutes.
As propriedades da métrica definem cálculos de agregação que processam todos os pontos de dados de entrada em um intervalo e produzem um único ponto de dados por intervalo. Esta propriedade da métrica calcula o uso médio da CPU de cada dispositivo a cada cinco minutos. Para obter mais informações, consulte Agregar dados de propriedades e outros ativos (métricas).
Selecione Add metric (Adicionar métrica) para adicionar uma segunda propriedade de métrica.
Na segunda linha, em Metric definitions (Definições de métrica), faça o seguinte:
1. Em Name (Nome), insira Average Memory Usage.
2. Em Formula (Fórmula), insira avg(Memory Usage). Selecione Memory Usage na lista de preenchimento automático quando ela for exibida.
3. Em Time interval (Intervalo de tempo), insira 5 minutes.
Esta propriedade da métrica calcula o uso médio da memória de cada dispositivo a cada cinco minutos.
(Opcional) Adicione outras métricas que você esteja interessado em calcular de acordo com o dispositivo. Algumas funções interessantes incluem min e max. Para obter mais informações, consulte Usar expressões de fórmula. Na próxima seção, crie um ativo pai que pode calcular métricas usando dados de toda a frota de dispositivos.
Escolha Create model (Criar modelo).

Criar um modelo de ativo de frota de dispositivos

Nesse procedimento, crie um modelo de ativo no AWS IoT SiteWise para representar a frota de dispositivos. Neste modelo de ativo, defina uma hierarquia, que permite associar muitos ativos de dispositivo a um único ativo de frota. Depois, defina métricas no modelo de ativo da frota que agregam dados de todos os ativos de dispositivos associados para obter insights sobre a frota como um todo.

Como criar um modelo de ativo que representa uma frota de dispositivos

Navegue até o console do AWS IoT SiteWise.
No painel de navegação à esquerda, selecione Models (Modelos).
Escolha Create model (Criar modelo).
Insira um nome em Asset model information (Informações do modelo de ativo) (por exemplo, SiteWise Tutorial Device Fleet Model).
Em Hierarchy definitions (Definições de hierarquia), faça o seguinte:
1. Selecione Add hierarchy (Adicionar hierarquia).
2. Em Hierarchy name (Nome da hierarquia), insira Device.
3. Em Hierarchy model (Modelo da hierarquia), escolha o modelo de ativo do dispositivo (SiteWise Tutorial Device Model).
Uma hierarquia define uma relação entre um modelo de ativo pai (frota) e um modelo de ativo filho (dispositivo). Os ativos pai podem acessar os dados de propriedade dos ativos filhos. Ao criar ativos posteriormente, é necessário associar ativos filhos a ativos pai de acordo com uma definição de hierarquia no modelo de ativo pai. Para obter mais informações, consulte Definindo relacionamentos entre modelos de ativos (hierarquias).
Em Metric definitions (Definições de métrica), faça o seguinte:
1. Em Name (Nome), insira Average CPU Usage.
2. Em Formula (Fórmula), insira avg(Device | Average CPU Usage). Quando a lista de preenchimento automático for exibida, selecione Device para escolher uma hierarquia e selecione Average CPU Usage para escolher a métrica do ativo do dispositivo criado anteriormente.
3. Em Time interval (Intervalo de tempo), insira 5 minutes.
Essa propriedade da métrica calcula o uso médio da CPU de todos os ativos de dispositivo associados a um ativo de frota por meio da hierarquia Device.
Selecione Add metric (Adicionar métrica) para adicionar uma segunda propriedade de métrica.
Na segunda linha, em Metric definitions (Definições de métrica), faça o seguinte:
1. Em Name (Nome), insira Average Memory Usage.
2. Em Formula (Fórmula), insira avg(Device | Average Memory Usage). Quando a lista de preenchimento automático for exibida, selecione Device para escolher uma hierarquia e selecione Average Memory Usage para escolher a métrica do ativo do dispositivo criado anteriormente.
3. Em Time interval (Intervalo de tempo), insira 5 minutes.
Essa propriedade da métrica calcula o uso médio da memória de todos os ativos de dispositivo associados a um ativo de frota por meio da hierarquia Device.
(Opcional) Adicione outras métricas que você esteja interessado em calcular em toda a frota de dispositivos.
Escolha Create model (Criar modelo).

Criar e configurar um ativo de dispositivo

Neste procedimento, crie um ativo de dispositivo usando o modelo de ativo de dispositivo. Depois, defina aliases de propriedade para cada propriedade de medição. Um alias de propriedade é uma string que identifica exclusivamente uma propriedade de ativo. Posteriormente, você pode usar esses aliases, em vez do ID de ativo e do ID de propriedade, para identificar uma propriedade para a qual deve ser feito upload dos dados. Para obter mais informações, consulte Mapeamento de fluxos de dados industriais para propriedades de ativos.

Como criar um ativo de dispositivo e definir aliases de propriedade

Navegue até o console do AWS IoT SiteWise.
No painel de navegação à esquerda, escolha Assets (Ativos).
Selecione Create asset (Criar ativo).
Em Asset model (Modelo de ativo), escolha o modelo de ativo do dispositivo SiteWise Tutorial Device Model.
Em Name (Nome), insira SiteWise Tutorial Device 1.
Selecione Create asset (Criar ativo).
No novo ativo de dispositivo, selecione Edit (Editar).
Em CPU Usage, insira /tutorial/device/SiteWiseTutorialDevice1/cpu como o alias da propriedade. Inclua o nome da coisa do AWS IoT no alias da propriedade para poder ingerir dados de todos os dispositivos usando uma única regra do AWS IoT.
Em Memory Usage, insira /tutorial/device/SiteWiseTutorialDevice1/memory como o alias da propriedade.
Selecione Save asset (Salvar ativo).
Se você criou várias coisas do AWS IoT anteriormente, repita as etapas de 3 a 10 para cada dispositivo e incremente o número no nome do ativo e nos aliases da propriedade de acordo. Por exemplo, o nome de ativo do segundo dispositivo deve ser SiteWise Tutorial Device 2 e os aliases de suas propriedades devem ser /tutorial/device/SiteWiseTutorialDevice2/cpu e /tutorial/device/SiteWiseTutorialDevice2/memory.

Criar e configurar um ativo de frota de dispositivos

Neste procedimento, crie um ativo de frota de dispositivos do modelo de ativo de frota de dispositivos. Depois associe os ativos de dispositivo aos ativos de frota pra que as propriedades da métrica do ativo de frota possa agregar dados de vários dispositivos.

Como criar um ativo de frota de dispositivos e associar ativos de dispositivo

Navegue até o console do AWS IoT SiteWise.
No painel de navegação à esquerda, escolha Assets (Ativos).
Selecione Create asset (Criar ativo).
Em Asset model (Modelo de ativo), escolha o modelo de ativo da frota do dispositivo, SiteWise Tutorial Device Fleet Model.
Em Name (Nome), insira SiteWise Tutorial Device Fleet 1.
Selecione Create asset (Criar ativo).
No novo ativo de frota de dispositivos, selecione Edit (Editar).
Em Assets associated to this asset (Ativos associados a este ativo), selecione Add associated asset (Adicionar ativo associado).
Em Hierarchy (Hierarquia), selecione Device. Essa hierarquia identifica a relação hierárquica entre o dispositivo e os ativos da frota de dispositivos. Você definiu essa hierarquia no modelo de ativo de frota de dispositivos anteriormente neste tutorial.
Em Asset (Ativo), selecione o ativo do dispositivo, SiteWise Tutorial Device 1.
se você criou vários ativos de dispositivo anteriormente, repita as etapas de 8 a 10 para cada ativo de dispositivo criado.
Selecione Save asset (Salvar ativo).

Agora você deve ver os ativos do dispositivo organizados como uma hierarquia.

Criar uma regra noAWS IoTEssencial para enviar dados aos ativos de dispositivo

Neste procedimento, crie uma regra no AWS IoT Core que analisa as mensagens de notificação da sombra de dispositivo e envia dados aos ativos de dispositivo no AWS IoT SiteWise. Cada vez que a sombra do dispositivo é atualizada, o AWS IoT envia uma mensagem MQTT. É possível criar uma regra que seja executada quando as sombras do dispositivo são alteradas com base na mensagem MQTT. Nesse caso, você deseja processar a mensagem de atualização para extrair os valores da propriedade e enviá-los aos ativos do dispositivo no AWS IoT SiteWise.

Como criar uma regra com uma ação do AWS IoT SiteWise

Navegue até o console do AWS IoT.
No painel de navegação esquerdo, escolha Act (Agir) e Rules (Regras).
Se uma caixa de diálogo You don’t have any rules yet (Você ainda não tem regras), selecione Create a rule (Criar uma regra). Caso contrário, escolha Create (Criar).
Insira um nome e uma descrição para a regra.
Insira a instrução de consulta de regra a seguir.
```
SELECT
  *
FROM
  '$aws/things/+/shadow/update/accepted'
WHERE
  startsWith(topic(3), "SiteWiseTutorialDevice")
```
Essa instrução de consulta de regra funciona, pois o serviço de sombra do dispositivo publica atualizações de sombra em $aws/things/thingName/shadow/update/accepted. Para obter mais informações sobre sombras de dispositivos, consulteServiço Device ShadownoAWS IoTGuia do desenvolvedor.

Na cláusula WHERE, essa instrução de consulta de regra usa a função topic(3) para obter o nome da coisa do terceiro segmento do tópico. Depois, a instrução exclui os dispositivos com nomes que não correspondem aos dos dispositivos do tutorial. Para obter mais informações sobreAWS IoTSQL, consulteAWS IoTReferência SQL donoAWS IoTGuia do desenvolvedor.
Em Set one or more actions (Definir uma ou mais ações), selecione Add action (Adicionar ação).
NoSelecione uma açãoPage (página), escolhaEnvie dados de mensagem às propriedades do ativo noAWS IoT SiteWisepara criar umAWS IoT SiteWiseA ação da regra.
Escolha Configure action (Configurar ação) na parte inferior da página.
Na página Configure action (Configurar ação), conclua as seguintes etapas para configurar a ação de regra do AWS IoT SiteWise:
1. Selecione By property alias (Por alias da propriedade).
2. Em Property alias (Alias da propriedade), insira /tutorial/device/${topic(3)}/cpu.
  
  A sintaxe ${...} é um modelo de substituição. O AWS IoT avalia o conteúdo entre chaves. Esse modelo de substituição extrai o nome da coisa do tópico para criar um alias exclusivo para cada coisa. Para obter mais informações, consulteModelos de substituiçãonoAWS IoTGuia do desenvolvedor.
  
  nota
  Como uma expressão em um modelo de substituição é avaliado separadamente da instrução SELECT, não é possível usar um modelo de substituição para fazer referência a um alias criado usando uma cláusula AS. Você pode fazer referência somente às informações presentes na carga original, além das funções e dos operadores compatíveis.
3. Em Entry ID (ID da entrada), insira ${concat(topic(3), "-cpu-", floor(state.reported.timestamp))}.
  
  Os IDs de entrada identificam exclusivamente cada tentativa de entrada de valor. Se uma entrada retornar um erro, será possível encontrar o ID da entrada na saída do erro a fim de solucionar o problema. O modelo de substituição nesse ID de entrada combina o nome da coisa e o time stamp informado do dispositivo. Por exemplo, o ID da entrada resultante poderia ser SiteWiseTutorialDevice1-cpu-1579808494.
4. Em Time in seconds (Tempo em segundos), insira ${floor(state.reported.timestamp)}.
  
  Esse modelo de substituição calcula o tempo em segundos do time stamp informado do dispositivo. Neste tutorial, os dispositivos informam o time stamp em segundos em horário Unix epoch como um número de ponto flutuante.
5. Em Offset in nanos (Deslocamento em nanossegundos), insira ${floor((state.reported.timestamp % 1) * 1E9)}.
  
  Esse modelo de substituição calcula o deslocamento em nanossegundos do tempo em segundos convertendo a parte decimal do time stamp informado do dispositivo.
  nota
  O AWS IoT SiteWise exige que os dados tenham um time stamp atual no horário Unix epoch. Se os dispositivos não informarem a hora com precisão, você poderá obter a hora atual no mecanismo de regras do AWS IoT com timestamp(). Essa função informa o tempo em milissegundos, portanto, é necessário atualizar os parâmetros de tempo da ação de regra para os seguintes valores:
  Em Time in seconds (Tempo em segundos), insira ${floor(timestamp() / 1E3)}.
  
  Em Offset in nanos (Deslocamento em nanossegundos), insira ${(timestamp() % 1E3) * 1E6}.
6. Em Valor, informe ${state.reported.cpu}. Em modelos de substituição, use o operador . para recuperar um valor de dentro de uma estrutura JSON.
7. Em Data type (Tipo de dados), selecione Double (Duplo).
  
  Esse tipo de dados deve corresponder ao tipo de dados da propriedade de ativo definida no modelo de ativo.
8. Selecione Add entry (Adicionar entrada) para adicionar uma nova entrada à propriedade de uso de memória e conclua as seguintes etapas novamente para essa propriedade:
  1. Em Property alias (Alias da propriedade), insira /tutorial/device/${topic(3)}/memory.
  2. Em Entry ID (ID da entrada), insira ${concat(topic(3), "-memory-", floor(state.reported.timestamp))}.
  3. Em Time in seconds (Tempo em segundos), insira ${floor(state.reported.timestamp)}.
  4. Em Offset in nanos (Deslocamento em nanossegundos), insira ${floor((state.reported.timestamp % 1) * 1E9)}.
  5. Em Valor, informe ${state.reported.memory}.
  6. Em Data type (Tipo de dados), selecione Double (Duplo).
9. Em Root asset name (Nome do ativo raiz), selecione Select (Escolher) para expandir a lista e, depois, selecione o ativo da frota de dispositivos (SiteWise Tutorial Device Fleet 1).
10. UnderFunção, escolhaCriar função dopara criar uma função do IAM para essa ação de regra. Essa função permite que o AWS IoT envie dados para propriedades no ativo de frota de dispositivos e sua hierarquia de ativos.
11. Forneça um nome de função e escolha Create role (Criar função).
12. Selecione Add action.
(Opcional) Configure uma ação de erro que pode ser usada para solucionar problemas da regra. Para obter mais informações, consulte Solucionar problemas de uma regra.
Escolha Create rule (Criar regra) na parte inferior da página para concluir a criação da regra.

Executar o script do cliente do dispositivo

Como você não está usando um dispositivo real para informar dados, execute um script para atualizar a sombra do dispositivo da coisa do AWS IoT com uso da CPU e da memória a fim de imitar dados reais do sensor. Para executar o script, primeiro instale os pacotes Python necessários. Neste procedimento, instale os pacotes Python necessários e execute o script do cliente do dispositivo.

Como configurar e executar o script do cliente do dispositivo

Navegue até o console do AWS IoT.
Na parte inferior do painel de navegação à esquerda, selecione Settings (Configurações).
Salve o endpoint personalizado para uso com o script do cliente do dispositivo. Use esse endpoint para interagir com as sombras da coisa. Esse endpoint é exclusivo da conta na região atual.

O endpoint personalizado deve ser semelhante ao exemplo a seguir.
```
identifier.iot.region.amazonaws.com
```
Abra uma linha de comando e execute o comando a seguir para navegar até o diretório do tutorial criado anteriormente.
```
cd iot-sitewise-rule-tutorial
```
Execute o comando a seguir para instalar o AWS IoT Device SDK for Python.
```
pip3 install AWSIoTPythonSDK
```
Para obter mais informações, consulteAWS IoT Device SDK for PythonnoAWS IoTGuia do desenvolvedor
Execute o comando a seguir para instalar o psutil, um processo entre plataformas e uma biblioteca de utilitários do sistema.
```
pip3 install psutil
```
Para obter mais informações, consulte psutil no Python Package Index.

Crie um arquivo chamado thing_performance.py no iot-sitewise-rule-tutorial diretório e copie o código Python a seguir no arquivo.


from AWSIoTPythonSDK.MQTTLib import AWSIoTMQTTShadowClient

import json
import psutil
import argparse
import logging
import time

# Configures the argument parser for this program.
def configureParser():
    parser = argparse.ArgumentParser()
    parser.add_argument("-e", "--endpoint", action="store", required=True, dest="host",
            help="Your AWS IoT custom endpoint")
    parser.add_argument("-r", "--rootCA", action="store", required=True, dest="rootCAPath", help="Root CA file path")
    parser.add_argument("-c", "--cert", action="store", required=True, dest="certificatePath",
            help="Certificate file path")
    parser.add_argument("-k", "--key", action="store", required=True, dest="privateKeyPath",
            help="Private key file path")
    parser.add_argument("-p", "--port", action="store", dest="port", type=int, default=8883,
            help="Port number override")
    parser.add_argument("-n", "--thingName", action="store", required=True, dest="thingName",
            help="Targeted thing name")
    parser.add_argument("-d", "--requestDelay", action="store", dest="requestDelay", type=float, default=1,
            help="Time between requests (in seconds)")
    parser.add_argument("-v", "--enableLogging", action="store_true", dest="enableLogging",
            help="Enable logging for the AWS IoT Device SDK for Python")
    return parser


# An MQTT shadow client that uploads device performance data to AWS IoT at a regular interval.
class PerformanceShadowClient:
    def __init__(self, thingName, host, port, rootCAPath, privateKeyPath, certificatePath, requestDelay):
        self.thingName = thingName
        self.host = host
        self.port = port
        self.rootCAPath = rootCAPath
        self.privateKeyPath = privateKeyPath
        self.certificatePath = certificatePath
        self.requestDelay = requestDelay

    # Updates this thing's shadow with system performance data at a regular interval.
    def run(self):
        print("Connecting MQTT client for {}...".format(self.thingName))
        mqttClient = self.configureMQTTClient()
        mqttClient.connect()
        print("MQTT client for {} connected".format(self.thingName))
        deviceShadowHandler = mqttClient.createShadowHandlerWithName(self.thingName, True)

        print("Running performance shadow client for {}...\n".format(self.thingName))
        while True:
            performance = self.readPerformance()
            print("[{}]".format(self.thingName))
            print("CPU:\t{}%".format(performance["cpu"]))
            print("Memory:\t{}%\n".format(performance["memory"]))
            payload = { "state": { "reported": performance } }
            deviceShadowHandler.shadowUpdate(json.dumps(payload), self.shadowUpdateCallback, 5)
            time.sleep(args.requestDelay)

    # Configures the MQTT shadow client for this thing.
    def configureMQTTClient(self):
        mqttClient = AWSIoTMQTTShadowClient(self.thingName)
        mqttClient.configureEndpoint(self.host, self.port)
        mqttClient.configureCredentials(self.rootCAPath, self.privateKeyPath, self.certificatePath)
        mqttClient.configureAutoReconnectBackoffTime(1, 32, 20)
        mqttClient.configureConnectDisconnectTimeout(10)
        mqttClient.configureMQTTOperationTimeout(5)
        return mqttClient

    # Returns the local device's CPU usage, memory usage, and timestamp.
    def readPerformance(self):
        cpu = psutil.cpu_percent()
        memory = psutil.virtual_memory().percent
        timestamp = time.time()
        return { "cpu": cpu, "memory": memory, "timestamp": timestamp }
    
    # Prints the result of a shadow update call.
    def shadowUpdateCallback(self, payload, responseStatus, token):
        print("[{}]".format(self.thingName))
        print("Update request {} {}\n".format(token, responseStatus))


# Configures debug logging for the AWS IoT Device SDK for Python.
def configureLogging():
    logger = logging.getLogger("AWSIoTPythonSDK.core")
    logger.setLevel(logging.DEBUG)
    streamHandler = logging.StreamHandler()
    formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
    streamHandler.setFormatter(formatter)
    logger.addHandler(streamHandler)


# Runs the performance shadow client with user arguments.
if __name__ == "__main__":
    parser = configureParser()
    args = parser.parse_args()
    if (args.enableLogging):
        configureLogging()
    thingClient = PerformanceShadowClient(args.thingName, args.host, args.port, args.rootCAPath, args.privateKeyPath,
            args.certificatePath, args.requestDelay)
    thingClient.run()

Execute thing_performance.py na linha de comando com os seguintes parâmetros:
- -n,--thingName— o nome da coisa, comoSiteWiseTutorialDevice1.
- -e,--endpoint— Seu costumeAWS IoTendpoint que você salvou anteriormente neste procedimento.
- -r,--rootCA— o caminho para o seuAWS IoTCertificado CA raiz.
- -c,--cert— o caminho para o seuAWS IoTcertificado coisa.
- -k,--key— o caminho para o seuAWS IoTchave privada do certificado da coisa.
- -d,--requestDelay— (opcional) o tempo em segundos para esperar entre cada atualização de sombra do dispositivo. O padrão é de 1 segundo.
- -v,--enableLogging— (Opcional) Se esse parâmetro estiver presente, o script imprimirá mensagens de depuração doAWS IoT Device SDK for Python.
O comando deve ser semelhante ao exemplo a seguir.
```
python3 thing_performance.py \
  --thingName SiteWiseTutorialDevice1 \
  --endpoint identifier.iot.region.amazonaws.com \
  --rootCA AmazonRootCA1.pem \
  --cert device1/thing-id-certificate.pem.crt \
  --key device1/thing-id-private.pem.key
```
Se você estiver executando o script para coisas adicionais do AWS IoT, atualize o nome da coisa e o diretório do certificado de acordo.
Tente abrir e fechar programas no dispositivo para ver como os usos da CPU e da memória mudam. O script imprime cada leitura de uso de CPU e de memória. Se o script fizer upload de dados para o serviço de sombra do dispositivo com êxito, a saída do script deverá ser semelhante ao exemplo a seguir.
```
[SiteWiseTutorialDevice1]
CPU:    24.6%
Memory: 85.2%

[SiteWiseTutorialDevice1]
Update request e6686e44-fca0-44db-aa48-3ca81726f3e3 accepted
```
Siga estas etapas para verificar se o script está atualizando a sombra do dispositivo:
1. Navegue até o console do AWS IoT.
2. No painel de navegação à esquerda, selecione Manage (Gerenciar) e Things (Coisas).
3. Selecione a coisa, SiteWiseTutorialDevice1.
4. No painel de navegação à esquerda na página da coisa, selecione Shadow (Sombra).
5. Verifique se o Shadow state (Estado da sombra) se parece com o exemplo a seguir.
```
{
  "reported": {
    "cpu": 24.6,
    "memory": 85.2,
    "timestamp": 1579567542.2835066
  }
}
```
6. Se o estado da sombra da coisa estiver vazio ou não se parecer com o exemplo anterior, verifique se o script está sendo executado e se ele foi conectado com êxito ao AWS IoT. Se o script continuar atingindo o tempo-limite ao se conectar ao AWS IoT, verifique se a política de coisa está configurada de acordo com este tutorial.
Siga estas etapas para verificar se a ação da regra está enviando dados para o AWS IoT SiteWise:
1. Navegue até o console do AWS IoT SiteWise.
2. No painel de navegação à esquerda, escolha Assets (Ativos).
3. Selecione a seta ao lado do ativo de frota de dispositivos (SiteWise Tutorial Device Fleet 1) para expandir sua hierarquia de ativos e selecione o ativo de dispositivo (SiteWise Tutorial Device 1).
4. Selecione Measurements (Medidas).
5. Verifique se as células de Latest value (Valor mais recente) têm valores para as propriedades CPU Usage e Memory Usage.
6. Se as propriedades CPU Usage e Memory Usage não tiverem os valores mais recentes, atualize a página. Se os valores não forem exibidos em alguns minutos, consulte Solucionar problemas de uma regra.
Você concluiu este tutorial. Se quiser explorar visualizações dos dados em tempo real, você poderá configurar um portal no AWS IoT SiteWise Monitor. Para obter mais informações, consulte Monitorar dados com o AWS IoT SiteWise Monitor. Caso contrário, pressione CTRL+C no prompt de comando para interromper o script do cliente do dispositivo. É improvável que o programa Python envie mensagens suficientes para gerar cobranças, mas é uma melhor prática interromper o programa ao concluir.

Limpar recursos após o tutorial

Depois de concluir o tutorial, limpe os recursos para evitar a geração de cobranças adicionais.

Como excluir ativos hierárquicos no AWS IoT SiteWise

Navegue até o .AWS IoT SiteWiseconsole
No painel de navegação à esquerda, escolha Assets (Ativos).
Ao excluir ativos no AWS IoT SiteWise, primeiro é necessário desassociá-los.

Conclua as seguintes etapas para desassociar os ativos do dispositivo do ativo da frota de dispositivos:
1. Escolha o seu ativo de frota de dispositivos (SiteWise Tutorial Device Fleet 1).
2. Selecione Edit.
3. Em Assets associated to this asset (Ativos associados a este ativo), selecione Disassociate (Desassociar) para cada ativo de dispositivo associado a esse ativo da frota de dispositivos.
4. Selecione Save asset (Salvar ativo).
  
  Agora os ativos do dispositivo não estarão mais organizados como uma hierarquia.
Escolha o ativo do dispositivo (SiteWise Tutorial Device 1).
Escolha Delete (Excluir).
Na caixa de diálogo de confirmação, insira Delete e selecione Delete (Excluir).

Quando você exclui um ativo, o AWS IoT SiteWise descarta todos os dados das propriedades desse ativo.
Repita as etapas de 4 a 6 para cada ativo de dispositivo e para o ativo da frota de dispositivos (SiteWise Tutorial Device Fleet 1).

Como excluir modelos de ativos hierárquicos no AWS IoT SiteWise

Navegue até o console do AWS IoT SiteWise.
Caso ainda não tenha feito isso, exclua o dispositivo e os ativos da frota de dispositivos. Para obter mais informações, consulte o procedimento anterior. Não é possível excluir um modelo se você tem ativos que foram criados usando esse modelo.
No painel de navegação à esquerda, selecione Models (Modelos).
Escolha o seu modelo de ativos da frota de dispositivos (SiteWise Tutorial Device Fleet Model).

Ao excluir modelos de ativos hierárquicos, primeiro é necessário excluir o modelo de ativo pai.
Escolha Delete (Excluir).
Na caixa de diálogo de confirmação, insira Delete e selecione Delete (Excluir).
Repita as etapas de 4 a 6 para o modelo de ativo do dispositivo (SiteWise Tutorial Device Model).

Como desabilitar ou excluir uma regra no AWS IoT Core

Navegue até o console do AWS IoT.
No painel de navegação esquerdo, escolha Act (Agir) e Rules (Regras).
Escolha o menu na regra e escolha Disable (Desativar) ou Delete (Excluir).

Solucionar problemas de uma regra

Siga as etapas deste procedimento para solucionar problemas da regra se os dados de uso de CPU e de memória não estiverem aparecendo no AWS IoT SiteWise conforme esperado. Neste procedimento, configure a ação de regra de republicação como uma ação de erro para exibir mensagens de erro no cliente de teste MQTT. Também é possível configurar o registro em log noCloudWatchLogs para solucionar problemas. Para obter mais informações, consulte Solucionar problemas de uma ação de regra do AWS IoT SiteWise.

Como adicionar uma ação de erro de republicação a uma regra

Navegue até o console do AWS IoT.
No painel de navegação esquerdo, escolha Act (Agir) e Rules (Regras).
Escolha a regra que criou anteriormente.
Em Error action (Ação de erro), escolha Add action (Adicionar ação).
SelecioneRepublique uma mensagem em umAWS IoTtópico.
Escolha Configure action (Configurar ação) na parte inferior da página.
Em Topic (Tópico), insira sitewise/rule/tutorial/error. O AWS IoT Core republicará mensagens de erro nesse tópico.
Selecione Select (Escolher) para conceder ao AWS IoT Core acesso para executar a ação de erro.
SelecioneSelectAo lado da função criada anteriormente (por exemplo,SiteWiseTutorialDeviceRuleRole).
Escolha Update Role (Atualizar função) para adicionar outras permissões à função.
Selecione Add action.
Selecione a seta para trás no canto superior esquerdo do console para retornar à página inicial do console do AWS IoT.

Depois de configurar a ação de erro de republicação, você pode visualizar as mensagens de erro no cliente de teste MQTT no AWS IoT Core.

No procedimento a seguir, você se inscreve no tópico de erro no cliente de teste MQTT.

Como se inscrever no tópico de ação de erro

Navegue até o console do AWS IoT.
Na página de navegação à esquerda, selecione Test (Testar) para abrir o cliente de teste MQTT.
No campo Subscription topic (Tópico de assinatura), insira sitewise/rule/tutorial/error e selecione Subscribe to topic (Assinar o tópico).
Quando forem exibidas mensagens de erro, visualize a matriz failures em qualquer mensagem de erro para diagnosticar problemas. Para obter mais informações sobre possíveis problemas e como resolvê-los, consulte Solucionar problemas de uma ação de regra do AWS IoT SiteWise.

Se os erros não aparecerem, verifique se a regra está habilitada e se você se inscreveu no mesmo tópico que configurou na ação de erro de republicação. Se os erros ainda não aparecerem depois que você fizer isso, verifique se o script do dispositivo está sendo executado e se está atualizando a sombra do dispositivo com êxito.
nota
Também é possível assinar o tópico de atualização da sombra do dispositivo para visualizar a carga que a ação do AWS IoT SiteWise analisa. Para fazer isso, assine o tópico a seguir.
```
$aws/things/+/shadow/update/accepted
```

Atenção O Javascript está desativado ou não está disponível no seu navegador.

Para usar a documentação da AWS, o Javascript deve estar ativado. Consulte as páginas de Ajuda do navegador para obter instruções.

Convenções do documento

Calculando OEE

Visualizar e compartilhar dados do parque de energia eólica no SiteWise Monitor