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á.
# Ingira dados para AWS IoT SiteWise extrair coisas AWS IoT
Saiba como ingerir dados AWS IoT SiteWise de uma frota de AWS IoT coisas usando sombras de dispositivos neste tutorial. As *sombras do dispositivo* são objetos JSON que armazenam informações sobre o estado atual de um AWS IoT dispositivo. Para obter mais informações, consulte [Device shadow service](https://docs.aws.amazon.com/iot/latest/developerguide/iot-device-shadows.html) no *AWS IoT Developer Guide*
Depois de concluir este tutorial, você pode configurar uma operação AWS IoT SiteWise com base em AWS IoT coisas. Ao usar AWS IoT coisas, você pode integrar sua operação com outros recursos úteis do AWS IoT. Por exemplo, você pode configurar AWS IoT recursos para realizar as seguintes tarefas:
+ Configurar regras adicionais para fazer streaming de dados para [AWS IoT Events](https://docs.aws.amazon.com/iotevents/latest/developerguide/), [Amazon DynamoDB](https://docs.aws.amazon.com/dynamodb/), and other e outros serviços da AWS . Para ter mais informações, consulte [Regras](https://docs.aws.amazon.com/iot/latest/developerguide/iot-rules.html) no *Guia do desenvolvedor do AWS IoT *.
+ Indexe, pesquise e agregue os dados do seu dispositivo com o serviço de indexação de AWS IoT frotas. Para obter mais informações, consulte [Serviço de indexação de frota](https://docs.aws.amazon.com/iot/latest/developerguide/iot-indexing.html) no *AWS IoT Guia do desenvolvedor*.
+ Audite e proteja seus dispositivos com AWS IoT Device Defender. Para saber mais, consulte [AWS IoT Device Defender](https://docs.aws.amazon.com/iot-device-defender/latest/devguide/what-is-device-defender.html) no *Guia do desenvolvedor do AWS IoT *.
Neste tutorial, você aprende como ingerir dados das sombras AWS IoT dos dispositivos das coisas até os ativos em. AWS IoT SiteWise Para fazer isso, você cria uma ou mais AWS IoT coisas e executa um script que atualiza a sombra do dispositivo de cada coisa com dados de uso da CPU e da memória. Use os dados de uso de CPU e memória neste tutorial para imitar dados de sensor realistas. Em seguida, você cria uma regra com uma AWS IoT SiteWise ação que envia esses dados para um ativo AWS IoT SiteWise sempre que a sombra do dispositivo de uma coisa é atualizada. Para obter mais informações, consulte [Ingira dados para AWS IoT SiteWise usar regras AWS IoT Core](iot-rules.md).
**Topics**
+ [Pré-requisitos](#rule-ingestion-tutorial-prerequisites)
+ [Etapa 1: criar uma AWS IoT política](#ingestion-tutorial-create-iot-policy)
+ [Etapa 2: criar e configurar qualquer AWS IoT coisa](#rule-tutorial-create-iot-thing)
+ [Etapa 3: criar um modelo de ativo do dispositivo](#rule-tutorial-create-device-model)
+ [Etapa 4: criar um modelo de ativo da frota de dispositivos](#rule-tutorial-create-fleet-model)
+ [Etapa 5: criar e configurar um ativo de dispositivo](#rule-tutorial-create-device-assets)
+ [Etapa 6: criar e configurar um ativo de frota de dispositivos](#rule-tutorial-create-fleet-asset)
+ [Etapa 7: criar uma regra no AWS IoT Core para enviar dados aos ativos do dispositivo](#rule-tutorial-create-iot-rule)
+ [Etapa 8: executar o script de cliente do dispositivo](#rule-tutorial-run-script)
+ [Etapa 9: limpar os recursos após o tutorial](#rule-tutorial-clean-up-resources)
## Pré-requisitos
Para concluir este tutorial, você precisará do seguinte:
+ Uma AWS conta. Se você não tiver uma, consulte [Configurar uma AWS conta](getting-started.md#set-up-aws-account).
+ Um computador de desenvolvimento executando WindowsmacOS,Linux,, ou Unix para acessar Console de gerenciamento da AWS o. Para obter mais informações, consulte [Conceitos básicos sobre o Console de gerenciamento da AWS](https://docs.aws.amazon.com/awsconsolehelpdocs/latest/gsg/getting-started.html).
+ Um usuário AWS Identity and Access Management (IAM) com permissões de administrador.
+ Python3 instalado em seu computador de desenvolvimento ou instalado no dispositivo que você deseja registrar como AWS IoT algo.
## Etapa 1: criar uma AWS IoT política
Neste procedimento, crie uma AWS IoT política que permita que suas AWS IoT coisas acessem os recursos usados neste tutorial.
------
#### [ Console ]
Use o procedimento a seguir para criar uma AWS IoT política usando o AWS IoT Core console:
**Para criar uma AWS IoT política**
1. Faça login no [Console de gerenciamento da AWS](https://docs.aws.amazon.com/awsconsolehelpdocs/latest/gsg/what-is.html).
1. Analise as [AWS regiões](https://docs.aws.amazon.com/general/latest/gr/iot-sitewise.html) em AWS IoT SiteWise que há suporte. Mude para uma dessas regiões compatíveis, se necessário.
1. Navegue até o [console do AWS IoT](https://console.aws.amazon.com/iot/). Se o botão **Conectar dispositivo** for exibido, escolha-o.
1. No painel de navegação à esquerda, selecione **Proteção** e em seguida escolha **Políticas**.
1. Escolha **Criar**.
1. Insira um nome para a AWS IoT política (por exemplo,**SiteWiseTutorialDevicePolicy**).
1. Em **Documento de política**, escolha **JSON** para inserir a seguinte política no formato JSON. *account-id*Substitua *region* e por sua região e ID da conta, como **us-east-1** **123456789012** e.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": "iot:Connect",
"Resource": "arn:aws:iot:us-east-1:123456789012:client/SiteWiseTutorialDevice*"
},
{
"Effect": "Allow",
"Action": "iot:Publish",
"Resource": [
"arn:aws:iot:us-east-1:123456789012:topic/$aws/things/${iot:Connection.Thing.ThingName}/shadow/update",
"arn:aws:iot:us-east-1:123456789012:topic/$aws/things/${iot:Connection.Thing.ThingName}/shadow/delete",
"arn:aws:iot:us-east-1:123456789012:topic/$aws/things/${iot:Connection.Thing.ThingName}/shadow/get"
]
},
{
"Effect": "Allow",
"Action": "iot:Receive",
"Resource": [
"arn:aws:iot:us-east-1:123456789012:topic/$aws/things/${iot:Connection.Thing.ThingName}/shadow/update/accepted",
"arn:aws:iot:us-east-1:123456789012:topic/$aws/things/${iot:Connection.Thing.ThingName}/shadow/delete/accepted",
"arn:aws:iot:us-east-1:123456789012:topic/$aws/things/${iot:Connection.Thing.ThingName}/shadow/get/accepted",
"arn:aws:iot:us-east-1:123456789012:topic/$aws/things/${iot:Connection.Thing.ThingName}/shadow/update/rejected",
"arn:aws:iot:us-east-1:123456789012:topic/$aws/things/${iot:Connection.Thing.ThingName}/shadow/delete/rejected"
]
},
{
"Effect": "Allow",
"Action": "iot:Subscribe",
"Resource": [
"arn:aws:iot:us-east-1:123456789012:topicfilter/$aws/things/${iot:Connection.Thing.ThingName}/shadow/update/accepted",
"arn:aws:iot:us-east-1:123456789012:topicfilter/$aws/things/${iot:Connection.Thing.ThingName}/shadow/delete/accepted",
"arn:aws:iot:us-east-1:123456789012:topicfilter/$aws/things/${iot:Connection.Thing.ThingName}/shadow/get/accepted",
"arn:aws:iot:us-east-1:123456789012:topicfilter/$aws/things/${iot:Connection.Thing.ThingName}/shadow/update/rejected",
"arn:aws:iot:us-east-1:123456789012:topicfilter/$aws/things/${iot:Connection.Thing.ThingName}/shadow/delete/rejected"
]
},
{
"Effect": "Allow",
"Action": [
"iot:GetThingShadow",
"iot:UpdateThingShadow",
"iot:DeleteThingShadow"
],
"Resource": "arn:aws:iot:us-east-1:123456789012:thing/SiteWiseTutorialDevice*"
}
]
}
```
------
1. Escolha **Criar**.
------
#### [ AWS CLI ]
**Importante**
Essa política usa curingas para permanecer dentro dos limites de tamanho da AWS IoT SiteWise CLI. Para obter permissões mais restritivas com caminhos de tópicos explícitos, crie a política por meio do AWS IoT SiteWise console. Para obter mais informações, consulte o exemplo de política de IoT fornecido na guia.
Use o AWS CLI comando a seguir para criar uma política de IoT:
```
aws iot create-policy \
--policy-name "SiteWiseTutorialDevicePolicy" \
--policy-document '{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": "iot:Connect",
"Resource": "arn:aws:iot:region:account-id:client/SiteWiseTutorialDevice*"
},
{
"Effect": "Allow",
"Action": ["iot:Publish", "iot:Receive"],
"Resource": [
"arn:aws:iot:region:account-id:topic/$aws/things/${iot:Connection.Thing.ThingName}/shadow/*"
]
},
{
"Effect": "Allow",
"Action": "iot:Subscribe",
"Resource": [
"arn:aws:iot:region:account-id:topicfilter/$aws/things/${iot:Connection.Thing.ThingName}/shadow/*"
]
},
{
"Effect": "Allow",
"Action": [
"iot:GetThingShadow",
"iot:UpdateThingShadow",
"iot:DeleteThingShadow"
],
"Resource": "arn:aws:iot:region:account-id:thing/SiteWiseTutorialDevice*"
}
]
}'
```
Para verificar se sua política foi criada com êxito, use o seguinte comando:
```
aws iot get-policy --policy-name "SiteWiseTutorialDevicePolicy"
```
------
Essa política permite que seus AWS IoT dispositivos estabeleçam conexões e se comuniquem com sombras de dispositivos usando mensagens MQTT. Para ter mais informações sobre as mensagens MQTT, consulte [O que é MQTT?](https://aws.amazon.com/what-is/mqtt/). Para interagir com as sombras do dispositivo, suas AWS IoT coisas publicam e recebem mensagens MQTT sobre tópicos que começam com. `$aws/things/thing-name/shadow/` Essa política incorpora uma variável da política de coisas conhecida como `${iot:Connection.Thing.ThingName}`. Essa variável substitui o nome da coisa conectada em cada tópico. A instrução `iot:Connect` define limitações sobre quais dispositivos podem estabelecer conexões, garantindo que a variável da política de coisas só possa substituir nomes que começam com `SiteWiseTutorialDevice`.
Para obter mais informações, consulte [Thing policy variables](https://docs.aws.amazon.com/iot/latest/developerguide/iot-policy-variables.html) in the *AWS IoT Developer Guide*.
**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.
## Etapa 2: criar e configurar qualquer AWS IoT coisa
Neste procedimento, você cria e configura qualquer AWS IoT coisa. Você pode designar seu computador de desenvolvimento como uma AWS IoT coisa. À medida que você avança, lembre-se de que os princípios que está aprendendo aqui podem ser aplicados a projetos reais. Você tem a flexibilidade de criar e configurar AWS IoT coisas em qualquer dispositivo capaz de executar um AWS IoT SDK, incluindo AWS IoT Greengrass FreeRTOS. Para saber mais, consulte [AWS IoT SDKs](https://docs.aws.amazon.com/iot/latest/developerguide/iot-sdks.html) no *Guia do desenvolvedor do AWS IoT *.
------
#### [ Console ]
**Para criar e configurar qualquer AWS IoT coisa**
1. 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
```
1. 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.
1. Navegue até o [console do AWS IoT](https://console.aws.amazon.com/iot/).
1. No painel de navegação à esquerda, escolha **Todos os dispositivos** na seção **Gerenciar**. Então, selecione **Things (Coisas)**.
1. 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)**. De outro modo, selecione **Criar coisas**.
1. Na página **Criar coisas**, escolha **Criar uma única coisa** e em seguida escolha **Próximo**.
1. Na página **Especificar propriedades** do item, insira um nome para o item AWS IoT (por exemplo,**SiteWiseTutorialDevice1**) e escolha **Avançar**. 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 que você criou na *Etapa 1: Criando uma AWS IoT política*. Caso contrário, seu dispositivo não conseguirá se conectar AWS IoT a.
1. Na página **Configurar certificado do dispositivo - *opcional***, escolha **Gerar automaticamente um novo certificado (recomendado)** e escolha **Avançar**. Os certificados AWS IoT permitem identificar seus dispositivos com segurança.
1. Na página **Anexar políticas ao certificado - *opcional***, selecione a política que você criou na *Etapa 1: Criando uma AWS IoT política* e escolha **Criar coisa**.
1. Na caixa de diálogo **Baixar certificados e chaves**, faça o seguinte:
1. 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.
1. Escolha o link de **Download** para baixar um certificado CA raiz. Salve o certificado CA em **iot-sitewise-rule-tutorial**. Recomendamos fazer download do Amazon Root CA 1.
1. Selecione **Concluído**.
------
#### [ AWS CLI ]
Siga estas etapas para criar e configurar qualquer AWS IoT coisa usando o AWS CLI:
1. Abra uma linha de comando e execute o comando a seguir para criar um diretório para este tutorial:
```
mkdir iot-sitewise-rule-tutorial
```
1. Navegue até o diretório do tutorial:
```
cd iot-sitewise-rule-tutorial
```
1. Execute o comando a seguir para criar um diretório para os certificados do seu produto:
```
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.
1. Crie qualquer AWS IoT coisa:
```
aws iot create-thing --thing-name "SiteWiseTutorialDevice1"
```
**Importante**
O nome da coisa deve corresponder ao padrão de nome usado na política que você criou na Etapa 1. Caso contrário, seu dispositivo não conseguirá se conectar AWS IoT a.
1. Crie um certificado e salve os arquivos. Observe o ARN do certificado na saída. Você precisará dele nas próximas etapas:
```
aws iot create-keys-and-certificate \
--set-as-active \
--certificate-pem-outfile "device1/device.pem.crt" \
--public-key-outfile "device1/public.pem.key" \
--private-key-outfile "device1/private.pem.key"
```
1. Anexe a política que você criou na Etapa 1 ao certificado:
```
aws iot attach-policy \
--policy-name "SiteWiseTutorialDevicePolicy" \
--target "certificate-arn"
```
1. Anexe o certificado à coisa:
```
aws iot attach-thing-principal \
--thing-name "SiteWiseTutorialDevice1" \
--principal "certificate-arn"
```
1. Baixe o certificado CA raiz da Amazon:
```
curl https://www.amazontrust.com/repository/AmazonRootCA1.pem > AmazonRootCA1.pem
```
Esse certificado é necessário para que seu dispositivo se conecte com sucesso AWS IoT.
**Importante**
Armazene seus certificados e chaves com segurança. Você não pode baixar essas credenciais novamente depois de criá-las.
------
Agora você registrou AWS IoT alguma coisa no seu computador. Siga uma das seguintes etapas:
+ Continue com a *Etapa 3: Criar um modelo de ativo de dispositivo* sem criar AWS IoT coisas adicionais. É 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 AWS IoT coisa recebe dados de uso de CPU e memória semelhantes do seu computador, então use essa abordagem para demonstrar a ingestão de dados não exclusivos de vários dispositivos.
## Etapa 3: criar um modelo de ativo do dispositivo
Neste procedimento, você cria um modelo de ativo AWS IoT SiteWise para representar seus dispositivos que transmitem dados de uso de CPU e memória. Para processar dados em ativos que representam grupos de dispositivos, os modelos de ativo impõem informações consistentes em vários ativos do mesmo tipo. Para obter mais informações, consulte [Modelar ativos industriais](industrial-asset-models.md).
**Como criar um modelo de ativo que representa um dispositivo**
1. Navegue até o [console do AWS IoT SiteWise](https://console.aws.amazon.com/iotsitewise/).
1. No painel de navegação à esquerda, selecione **Modelos**.
1. Escolha **Criar modelo de ativo**.
1. Em **Detalhes do modelo**, insira um nome para seu modelo. Por exemplo, .**SiteWise Tutorial Device Model**
1. Em **Measurement definitions (Definições de medição)**, faça o seguinte:
1. Em **Nome**, insira **CPU Usage**.
1. Em **Unidade**, insira **%**.
1. 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 [Definir fluxos de dados de equipamentos (medições)](measurements.md).
1. Selecione **Adicionar medição** para adicionar uma segunda propriedade de medição.
1. Na segunda linha, em **Measurement definitions (Definições da medição)**, faça o seguinte:
1. Em **Nome**, insira **Memory Usage**.
1. Em **Unidade**, insira **%**.
1. Deixe o **Data type (Tipo de dados)** como **Double (Duplo)**.
1. Em **Metric definitions (Definições de métrica)**, faça o seguinte:
1. Em **Nome**, insira **Average CPU Usage**.
1. Em **Formula (Fórmula)**, insira **avg(CPU Usage)**. Selecione **CPU Usage** na lista de preenchimento automático quando ela for exibida.
1. 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)](metrics.md).
1. Selecione **Adicionar métrica** para adicionar uma segunda propriedade de métrica.
1. Na segunda linha, em **Metric definitions (Definições de métrica)**, faça o seguinte:
1. Em **Nome**, insira **Average Memory Usage**.
1. Em **Formula (Fórmula)**, insira **avg(Memory Usage)**. Selecione **Memory Usage** na lista de preenchimento automático quando ela for exibida.
1. 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.
1. (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](formula-expressions.md). Na In *Etapa 4:, Criando um modelo de ativo de frota de dispositivo*, você pode criar um ativo pai que pode calcular métricas usando dados de toda a sua frota de dispositivos.
1. Escolha **Criar modelo**.
## Etapa 4: criar um modelo de ativo da frota de dispositivos
Neste procedimento, você cria um modelo de ativo AWS IoT SiteWise para simbolizar sua coleção de dispositivos. Nesse modelo de ativo, estabeleça uma estrutura que permite vincular vários ativos de dispositivo a um ativo abrangente da frota. Depois disso, descreva métricas no modelo de ativo da frota para consolidar dados de todos os ativos de dispositivo conectados. Essa abordagem oferece insights abrangentes sobre o desempenho coletivo de toda a frota.
**Como criar um modelo de ativo que representa uma frota de dispositivos**
1. Navegue até o [console do AWS IoT SiteWise](https://console.aws.amazon.com/iotsitewise/).
1. No painel de navegação à esquerda, selecione **Modelos**.
1. Escolha **Criar modelo de ativo**.
1. Em **Detalhes do modelo**, insira um nome para seu modelo. Por exemplo, .**SiteWise Tutorial Device Fleet Model**
1. Em **Hierarchy definitions (Definições de hierarquia)**, faça o seguinte:
1. Em **Hierarchy name (Nome da hierarquia)**, insira **Device**.
1. 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 [As hierarquias de ativos representam relacionamentos de equipamentos](industrial-asset-models.md#asset-hierarchies).
1. Em **Metric definitions (Definições de métrica)**, faça o seguinte:
1. Em **Nome**, insira **Average CPU Usage**.
1. Em **Formula (Fórmula)**, insira **avg(Device \$1 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.
1. 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**.
1. Selecione **Adicionar métrica** para adicionar uma segunda propriedade de métrica.
1. Na segunda linha, em **Metric definitions (Definições de métrica)**, faça o seguinte:
1. Em **Nome**, insira **Average Memory Usage**.
1. Em **Formula (Fórmula)**, insira **avg(Device \$1 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.
1. 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**.
1. (Opcional) Adicione outras métricas que você esteja interessado em calcular em toda a frota de dispositivos.
1. Escolha **Criar modelo**.
## Etapa 5: criar e configurar um ativo de dispositivo
Neste procedimento, gere um ativo de dispositivo baseado no modelo de ativo do dispositivo. Depois, defina aliases de propriedade para cada propriedade de medição. Um *alias de propriedade* é uma string exclusiva que identifica uma propriedade de ativo. Posteriormente, você poderá identificar uma propriedade para upload de dados usando os aliases em vez do ID de ativo e do ID de propriedade. Para obter mais informações, consulte [Gerencie fluxos de dados para AWS IoT SiteWise](manage-data-streams.md).
**Como criar um ativo de dispositivo e definir aliases de propriedade**
1. Navegue até o [console do AWS IoT SiteWise](https://console.aws.amazon.com/iotsitewise/).
1. No painel de navegação à esquerda, escolha **Ativos**.
1. Escolha **Criar ativo**.
1. Em **Informações do modelo**, escolha o modelo de ativo do seu dispositivo, **SiteWise Tutorial Device Model**.
1. Em **Informações do ativo**, insira um nome para seu ativo. Por exemplo, .**SiteWise Tutorial Device 1**
1. Escolha **Criar ativo**.
1. No novo ativo de dispositivo, selecione **Editar**.
1. Em **Medições**:
1. Em **CPU Usage**, insira **/tutorial/device/SiteWiseTutorialDevice1/cpu** como o alias da propriedade. Você inclui o nome da AWS IoT coisa no alias da propriedade para poder ingerir dados de todos os seus dispositivos usando uma única AWS IoT regra.
1. Em **Memory Usage**, insira **/tutorial/device/SiteWiseTutorialDevice1/memory** como o alias da propriedade.
1. Escolha **Salvar**.
Se você criou várias AWS IoT coisas 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**.
## Etapa 6: criar e configurar um ativo de frota de dispositivos
Neste procedimento, crie um ativo de frota de dispositivos com base no modelo de ativo da frota de dispositivos. Depois, vincule os ativos de dispositivo individuais ao ativo da frota. Essa associação permite que as propriedades de métrica do ativo da frota compilem e analisem dados de vários dispositivos. Esses dados oferecem uma visão consolidada do desempenho coletivo de toda a frota.
**Como criar um ativo de frota de dispositivos e associar ativos de dispositivo**
1. Navegue até o [console do AWS IoT SiteWise](https://console.aws.amazon.com/iotsitewise/).
1. No painel de navegação à esquerda, escolha **Ativos**.
1. Escolha **Criar ativo**.
1. Em **Modelo de informação**, escolha o modelo de ativo da frota do dispositivo, **SiteWise Tutorial Device Fleet Model**.
1. Em **Informações do ativo**, insira um nome para seu ativo. Por exemplo, .**SiteWise Tutorial Device Fleet 1**
1. Escolha **Criar ativo**.
1. No novo ativo de frota de dispositivos, selecione **Editar**.
1. Em **Ativos associados a esse ativo**, escolha **Adicionar ativo associado** e faça o seguinte:
1. 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.
1. Em **Asset (Ativo)**, selecione o ativo do dispositivo, **SiteWise Tutorial Device 1**.
1. (Opcional) Se você criou vários ativos de dispositivo anteriormente, repita as etapas de 8 a 10 para cada ativo de dispositivo criado.
1. Escolha **Salvar**.
Agora você deve ver os ativos do dispositivo organizados como uma hierarquia.
## Etapa 7: criar uma regra no AWS IoT Core para enviar dados aos ativos do dispositivo
Neste procedimento, estabeleça uma regra no AWS IoT Core. A regra foi criada para interpretar as mensagens de notificação das sombras do dispositivo e transmitir os dados para os ativos do seu dispositivo em AWS IoT SiteWise. Cada vez que a sombra do seu dispositivo é atualizada, 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, o objetivo é processar a mensagem de atualização, extrair os valores de propriedade e transmiti-los aos ativos de dispositivo no AWS IoT SiteWise.
**Para criar uma regra com uma AWS IoT SiteWise ação**
1. Navegue até o [console do AWS IoT](https://console.aws.amazon.com/iot/).
1. No painel de navegação à esquerda, escolha **Roteamento de mensagens** e **Regras**.
1. Escolha **Criar regra**.
1. Insira um nome e uma descrição para a sua regra e selecione **Avançar**.
1. Insira a instrução a seguir e escolha **Executar**.
```
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, consulte [Device shadow service](https://docs.aws.amazon.com/iot/latest/developerguide/iot-device-shadows.html) no *AWS IoT Developer Guide*.
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 sobre AWS IoT SQL, consulte a [referência de AWS IoT SQL](https://docs.aws.amazon.com/iot/latest/developerguide/iot-sql-reference.html) no *Guia do AWS IoT desenvolvedor*.
1. Em **Ações de regra**, escolha **Enviar dados de mensagem para propriedades do ativo em AWS IoT SiteWise** e faça o seguinte:
1. Selecione **By property alias (Por alias da propriedade)**.
1. Em **Property alias (Alias da propriedade)**, insira **/tutorial/device/\$1\$1topic(3)\$1/cpu**.
A `${...}` sintaxe é um modelo de substituição. AWS IoT avalia o conteúdo dentro das 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, consulte [Modelos de substituição](https://docs.aws.amazon.com/iot/latest/developerguide/iot-substitution-templates.html) no *Guia do desenvolvedor* do AWS IoT .
**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.
1. Em **ID de entrada - *opcional***, insira **\$1\$1concat(topic(3), "-cpu-", floor(state.reported.timestamp))\$1**.
A entrada identifica de IDs forma exclusiva 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`.
1. Em **Time in seconds (Tempo em segundos)**, insira **\$1\$1floor(state.reported.timestamp)\$1**.
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.
1. Em **Offset in nanos - *opcional***, insira **\$1\$1floor((state.reported.timestamp % 1) \$1 1E9)\$1**.
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**
AWS IoT SiteWise requer que seus dados tenham um carimbo de data/hora atual na época do Unix. 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 [time stamp()](https://docs.aws.amazon.com/iot/latest/developerguide/iot-sql-functions.html#iot-function-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 **\$1\$1floor(timestamp() / 1E3)\$1**.
Em **Offset in nanos (Deslocamento em nanossegundos)**, insira **\$1\$1(timestamp() % 1E3) \$1 1E6\$1**.
1. 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.
1. Em **Valor**, informe **\$1\$1state.reported.cpu\$1**. Em modelos de substituição, use o operador `.` para recuperar um valor de dentro de uma estrutura JSON.
1. 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. Selecione **By property alias (Por alias da propriedade)**.
1. Em **Property alias (Alias da propriedade)**, insira **/tutorial/device/\$1\$1topic(3)\$1/memory**.
1. Em **ID de entrada - *opcional***, insira **\$1\$1concat(topic(3), "-memory-", floor(state.reported.timestamp))\$1**.
1. Em **Time in seconds (Tempo em segundos)**, insira **\$1\$1floor(state.reported.timestamp)\$1**.
1. Em **Offset in nanos - *opcional***, insira **\$1\$1floor((state.reported.timestamp % 1) \$1 1E9)\$1**.
1. Em **Data type (Tipo de dados)**, selecione **Double (Duplo)**.
1. Em **Valor**, informe **\$1\$1state.reported.memory\$1**.
1. Em **Perfil do IAM**,selecione **Create new role** para criar um perfil do IAM para essa ação de regra. Essa função permite enviar dados AWS IoT para propriedades em seu ativo de frota de dispositivos e sua hierarquia de ativos.
1. Forneça um nome de função e escolha **Create role**.
1. (Opcional) Configure uma ação de erro que pode ser usada para solucionar problemas da regra. Para obter mais informações, consulte [Solucionar problemas em uma regra (AWS IoT SiteWise)](troubleshoot-rule.md#rule-tutorial-troubleshoot-rule).
1. Escolha **Próximo**.
1. Revise as configurações do grupo de regras e selecione **Criar** para criar a regra.
## Etapa 8: executar o script de cliente do dispositivo
Neste tutorial, você não usa um dispositivo real para relatar dados. Em vez disso, você executa um script para atualizar AWS IoT a sombra do dispositivo com o uso da CPU e da memória para imitar dados reais do sensor. Para executar o script, primeiro é necessário instalar os pacotes Python necessários. Neste procedimento, instale os pacotes Python necessários e execute o script de cliente do dispositivo.
**Como configurar e executar o script do cliente do dispositivo**
1. Navegue até o [console do AWS IoT](https://console.aws.amazon.com/iot/).
1. Na parte inferior do painel de navegação à esquerda, selecione **Settings (Configurações)**.
1. 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
```
1. 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
```
1. Execute o comando a seguir para instalar o AWS IoT Device SDK for Python.
```
pip3 install AWSIoTPythonSDK
```
Para obter mais informações, consulte [AWS IoT Device SDK for Python](https://docs.aws.amazon.com/iot/latest/developerguide/iot-sdks.html#iot-python-sdk) no *Guia do desenvolvedor do AWS IoT *.
1. 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](https://pypi.org/project/psutil/) no *Python Package Index*.
1. Crie um arquivo chamado `thing_performance.py` no `iot-sitewise-rule-tutorial` diretório e copie o código Python a seguir no arquivo.
```
import AWSIoTPythonSDK.MQTTLib as AWSIoTPyMQTT
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 = AWSIoTPyMQTT.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()
```
1. Execute **thing\$1performance.py** na linha de comando com os seguintes parâmetros:
+ `-n`, `--thingName` – o nome da coisa, como **SiteWiseTutorialDevice1**.
+ `-e`, `--endpoint` — Seu AWS IoT endpoint personalizado que você salvou anteriormente neste procedimento.
+ `-r`, `--rootCA` — O caminho para seu certificado CA AWS IoT raiz.
+ `-c`, `--cert` — O caminho para seu AWS IoT certificado.
+ `-k`, `--key` — O caminho para sua AWS IoT chave privada de certificado.
+ `-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 do AWS 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 outras AWS IoT coisas, atualize o nome do item e o diretório do certificado adequadamente.
1. 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
```
1. Siga estas etapas para verificar se o script está atualizando a sombra do dispositivo:
1. Navegue até o [console do AWS IoT](https://console.aws.amazon.com/iot/).
1. No painel de navegação à esquerda, selecione **Todos os dispositivos** e **Coisas**.
1. Escolha sua coisa, **SiteWiseTutorialDevice**.
1. Escolha a guia **Sombras do dispositivo**, escolha **Sombra clássica** e verifique se o **estado da sombra** se parece com o exemplo a seguir.
```
{
"reported": {
"cpu": 24.6,
"memory": 85.2,
"timestamp": 1579567542.2835066
}
}
```
Se o estado de sombra da sua coisa estiver vazio ou não se parecer com o exemplo anterior, verifique se o script está sendo executado e conectado com êxito AWS IoT. Se o tempo limite do script persistir ao se conectar AWS IoT, verifique se sua [política de coisas](#ingestion-tutorial-create-iot-policy) está configurada de acordo com este tutorial.
1. 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](https://console.aws.amazon.com/iotsitewise/).
1. No painel de navegação à esquerda, escolha **Ativos**.
1. Escolha a seta ao lado do ativo da frota de dispositivos (**SiteWise Tutorial Device Fleet 1**) para expandir sua hierarquia de ativos e, em seguida, escolha o ativo do dispositivo (**SiteWise Tutorial Device1**).
1. Selecione **Measurements (Medidas)**.
1. Verifique se as células de **Latest value (Valor mais recente)** têm valores para as propriedades **CPU Usage** e **Memory Usage**.
![\[Captura de tela com “Medições” em destaque.\]](http://docs.aws.amazon.com/pt_br/iot-sitewise/latest/userguide/images/rule-ingestion/sitewise-view-measurement-values-console.png)
1. 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 em uma regra (AWS IoT SiteWise)](troubleshoot-rule.md#rule-tutorial-troubleshoot-rule).
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 [Monitore dados com AWS IoT SiteWise Monitor](monitor-data.md). De outro modo, pressione **CTRL\$1C** 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.
## Etapa 9: limpar os recursos após o tutorial
**nota**
Os recursos criados neste tutorial são necessários para o tutorial [Integrar dados no SiteWise Edge](integrate_sitewise_edge_mqtt.md). Não limpe os recursos desta etapa se você planeja concluí-la.
Depois de concluir o tutorial sobre a ingestão de dados de AWS IoT coisas, limpe seus recursos para evitar cobranças adicionais.
**Para excluir ativos hierárquicos no AWS IoT SiteWise**
1. Navegue até o [console do AWS IoT SiteWise](https://console.aws.amazon.com/iotsitewise/).
1. No painel de navegação à esquerda, escolha **Ativos**.
1. Ao excluir ativos em AWS IoT SiteWise, você deve primeiro desassociá-los.
Conclua as seguintes etapas para desassociar os ativos do dispositivo do ativo da frota de dispositivos:
1. Escolha o ativo da frota do seu dispositivo (**SiteWise Tutorial Device Fleet 1**).
1. Escolha **Editar**.
1. 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.
1. Escolha **Salvar**.
Agora os ativos do dispositivo não estarão mais organizados como uma hierarquia.
1. Escolha o ativo do dispositivo (**SiteWise Tutorial Device 1**).
1. Escolha **Excluir**.
1. Na caixa de diálogo de confirmação, insira **Delete** e selecione **Delete (Excluir)**.
1. 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**).
**Para excluir modelos hierárquicos de ativos no AWS IoT SiteWise**
1. Navegue até o [console do AWS IoT SiteWise](https://console.aws.amazon.com/iotsitewise/).
1. 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](#rule-tutorial-delete-assets). Não é possível excluir um modelo se você tem ativos que foram criados usando esse modelo.
1. No painel de navegação à esquerda, selecione **Modelos**.
1. Escolha o seu modelo de ativos da frota de dispositivos (**SiteWise Tutorial Device Fleet Model**).
Ao excluir modelos de ativo hierárquicos, comece excluindo o modelo de ativo pai.
1. Escolha **Excluir**.
1. Na caixa de diálogo de confirmação, insira **Delete** e selecione **Delete (Excluir)**.
1. Repita as etapas de 4 a 6 para o modelo de ativo do dispositivo (**SiteWise Tutorial Device Model**).
**Para desativar ou excluir uma regra no AWS IoT Core**
1. Navegue até o [console do AWS IoT](https://console.aws.amazon.com/iot/).
1. No painel de navegação à esquerda, escolha **Roteamento de mensagens** e **Regras**.
1. Selecione sua regra e escolha **Excluir**.
1. Na caixa de diálogo de confirmação, insira o nome da regra e selecione **Delete**.