Ingira dados de coisas AWS IoT

Faça login no AWS Management Console.

Analise as AWS regiões em AWS IoT SiteWise que há suporte. Mude para uma dessas regiões compatíveis, se necessário.

Navegue até o console do AWS IoT. Se um botão Connect device for exibido, escolha-o.

No painel de navegação à esquerda, selecione Proteção e em seguida escolha Políticas.

Escolha Criar.

Insira um nome para a AWS IoT política (por exemplo,SiteWiseTutorialDevicePolicy).

Em Documento de política, escolha inserir JSONa seguinte política no JSON formulário. Substituir region e account-id com sua região e ID da conta, como us-east-1 123456789012 e.

{
  "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 seus AWS IoT dispositivos estabeleçam conexões e se comuniquem com sombras de dispositivos usando MQTT mensagens. Para obter mais informações sobre MQTT mensagens, consulte O que éMQTT? . Para interagir com as sombras do dispositivo, suas AWS IoT coisas publicam e recebem MQTT mensagens sobre tópicos que começam com$aws/things/thing-name/shadow/. Essa política incorpora uma variável de política conhecida como${iot:Connection.Thing.ThingName}. Essa variável substitui o nome da coisa conectada em cada tópico. A iot:Connect declaração define limitações sobre quais dispositivos podem estabelecer conexões, garantindo que a variável de política thing só possa substituir nomes começando comSiteWiseTutorialDevice.

Para obter mais informações, consulte Thing policy variables in the AWS IoT Developer Guide.

Escolha Criar.

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 esquerdo, escolha Todos os dispositivos na seção Gerenciar. Então, selecione 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). De outro modo, selecione Criar coisas.

Na página Criar coisas, escolha Criar uma única coisa e em seguida escolha Próximo.

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.

Na página Configurar certificado do dispositivo - opcional, selecione Gerar automaticamente um novo certificado (recomendado) e escolha Avançar. Os certificados AWS IoT permitem identificar seus dispositivos com segurança.

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.

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.

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

Selecione Done (Concluído).

Navegue até o console do AWS IoT SiteWise.

No painel de navegação à esquerda, selecione Modelos.

Escolha Criar modelo.

Em Detalhes do modelo, insira um nome para seu modelo. Por exemplo, SiteWise Tutorial Device Model.

Em Measurement definitions (Definições de medição), faça o seguinte:

1. Em Nome, insira CPU Usage.

2. Em 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 Defina fluxos de dados do equipamento (medições).

Selecione 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 Nome, insira Memory Usage.

2. Em 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 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. Essa propriedade métrica calcula o CPU uso médio de cada dispositivo a cada 5 minutos. Para obter mais informações, consulte Dados agregados de propriedades e outros ativos (métricas).

Selecione 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 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 Use expressões de fórmula. 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.

Escolha Criar modelo.

Navegue até o console do AWS IoT SiteWise.

No painel de navegação à esquerda, selecione Modelos.

Escolha Criar modelo.

Em Detalhes do modelo, insira um nome para seu modelo. Por exemplo, SiteWise Tutorial Device Fleet Model.

Em Hierarchy definitions (Definições de hierarquia), faça o seguinte:

1. Em Hierarchy name (Nome da hierarquia), insira Device.

2. 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 Definir hierarquias de modelos de ativos.

Em Metric definitions (Definições de métrica), faça o seguinte:

1. Em 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 métrica calcula o CPU uso médio de todos os ativos do dispositivo associados a um ativo da frota por meio da Device hierarquia.

Selecione 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 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 Criar modelo.

Navegue até o console do AWS IoT SiteWise.

No painel de navegação à esquerda, escolha Ativos.

Escolha Criar ativo.

Em Informações do modelo, escolha o modelo de ativo do seu dispositivo, SiteWise Tutorial Device Model.

Em Informações do ativo, insira um nome para seu ativo. Por exemplo, SiteWise Tutorial Device 1.

Escolha Criar ativo.

No novo ativo de dispositivo, selecione Editar.

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.

Em Memory Usage, insira /tutorial/device/SiteWiseTutorialDevice1/memory como o alias da propriedade.

Escolha Salvar.

Navegue até o console do AWS IoT SiteWise.

No painel de navegação à esquerda, escolha Ativos.

Escolha Criar ativo.

Em Modelo de informação, escolha o modelo de ativo da frota do dispositivo, SiteWise Tutorial Device Fleet Model.

Em Informações do ativo, insira um nome para seu ativo. Por exemplo, SiteWise Tutorial Device Fleet 1.

Escolha Criar ativo.

No novo ativo de frota de dispositivos, selecione Editar.

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.

2. Em Asset (Ativo), selecione o ativo do dispositivo, SiteWise Tutorial Device 1.

(Opcional) Se você criou vários ativos de dispositivo anteriormente, repita as etapas de 8 a 10 para cada ativo de dispositivo criado.

Escolha Salvar.

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

Navegue até o console do AWS IoT.

No painel de navegação à esquerda, escolha Roteamento de mensagens e Regras.

Escolha Criar Regra.

Insira um nome e uma descrição para a sua regra e selecione Avançar.

Insira a seguinte SQL declaração e escolha Avançar.

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 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 AWS IoT SQLreferência no Guia do AWS IoT desenvolvedor.

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

2. Em Property alias (Alias da propriedade), insira /tutorial/device/${topic(3)}/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 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.

3. Em ID de entrada - opcional, insira ${concat(topic(3), "-cpu-", floor(state.reported.timestamp))}.

   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.

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 - opcional, 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

   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(). 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 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.

7. Em Valor, informe ${state.reported.cpu}. Nos modelos de substituição, você usa o . operador para recuperar um valor de dentro de uma JSON estrutura.

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. Selecione By property alias (Por alias da propriedade).

   2. Em Property alias (Alias da propriedade), insira /tutorial/device/${topic(3)}/memory.

   3. Em ID de entrada - opcional, insira ${concat(topic(3), "-memory-", floor(state.reported.timestamp))}.

   4. Em Time in seconds (Tempo em segundos), insira ${floor(state.reported.timestamp)}.

   5. Em Offset in nanos - opcional, insira ${floor((state.reported.timestamp % 1) * 1E9)}.

   6. Em Data type (Tipo de dados), selecione Double (Duplo).

   7. Em Valor, informe ${state.reported.memory}.

9. Em IAMFunção, escolha Criar nova função para criar uma IAM função 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.

10. Forneça um nome de função e escolha Create role.

(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 ()AWS IoT SiteWise.

Escolha Próximo.

Revise as configurações do grupo de regras e selecione Criar para criar a regra.

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, consulte AWS IoT Device SDK for Python no Guia do desenvolvedor do AWS IoT .

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.

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()

Execute thing_performance.py na linha de comando com os seguintes parâmetros:

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.

Tente abrir e fechar programas em seu dispositivo para ver como o uso CPU e a memória mudam. O script imprime cada leitura CPU e o uso da 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 Todos os dispositivos e Coisas.

3. Escolha sua coisa, SiteWiseTutorialDevice.

4. 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 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 Ativos.

3. Selecione a seta ao lado do ativo de frota de dispositivos (SiteWise Tutorial Device Fleet 1 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 ()AWS IoT SiteWise.

Navegue até o console do AWS IoT SiteWise.

No painel de navegação à esquerda, escolha Ativos.

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 seu ativo de frota de dispositivos ( SiteWise Tutorial Device Fleet 1).

2. Selecione a opção Editar.

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. Escolha Salvar.

   Agora os ativos do dispositivo não estarão mais organizados como uma hierarquia.

Escolha o ativo do dispositivo (SiteWise Tutorial Device 1).

Escolha Excluir.

Na caixa de diálogo de confirmação, insira Delete e selecione Delete (Excluir).

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

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

Escolha o seu modelo de ativos da frota de dispositivos (SiteWise Tutorial Device Fleet Model).

Ao excluir modelos de ativos hierárquicos, comece excluindo primeiro o modelo de ativo principal.

Escolha 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).

Navegue até o console do AWS IoT.

No painel de navegação à esquerda, escolha Roteamento de mensagens e Regras.

Selecione sua regra e escolha Excluir.

Na caixa de diálogo de confirmação, insira o nome da regra e selecione Delete.