Acquisisci dati dalle cose AWS IoT

Accedi alla AWS Management Console.

Consulta le AWS regioni in cui AWS IoT SiteWise è supportato. Passare a una di queste regioni supportate, se necessario.

Passare alla console AWS IoT. Se viene visualizzato il pulsante Connect device, selezionalo.

Nel riquadro di navigazione a sinistra, scegli Sicurezza, quindi scegli Politiche.

Scegli Create (Crea) .

Inserisci un nome per la AWS IoT politica (ad esempio,SiteWiseTutorialDevicePolicy).

In Documento di politica, scegli JSONdi inserire la seguente politica nel JSON modulo. Replace (Sostituisci) region e account-id con la tua regione e l'ID dell'account, ad esempio us-east-1 e123456789012.

{
  "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*"
    }
  ]
}

Questa politica consente ai AWS IoT dispositivi di stabilire connessioni e comunicare con le ombre dei dispositivi tramite MQTT messaggi. Per ulteriori informazioni sui MQTT messaggi, consulta Cos'èMQTT? . Per interagire con AWS IoT le ombre dei dispositivi, i tuoi contenuti pubblicano e ricevono MQTT messaggi su argomenti che iniziano con$aws/things/thing-name/shadow/. Questa politica incorpora una variabile di policy relativa agli oggetti nota come. ${iot:Connection.Thing.ThingName} Questa variabile sostituisce il nome dell'oggetto connesso in ogni argomento. L'iot:Connectistruzione stabilisce delle limitazioni sui dispositivi che possono stabilire connessioni, assicurando che la variabile thing policy possa sostituire solo i nomi che iniziano con. SiteWiseTutorialDevice

Per ulteriori informazioni, vedere Thing policy variables nella AWS IoT Developer Guide.

Scegli Create (Crea) .

Aprire una riga di comando ed eseguire il comando seguente per creare una directory per questo tutorial.

mkdir iot-sitewise-rule-tutorial
cd iot-sitewise-rule-tutorial

Eseguire il seguente comando per creare una directory per i certificati dell'oggetto.

mkdir device1

Se si stanno creando altri oggetti, incrementa il numero nel nome della directory di conseguenza per tenere traccia di quali certificati appartengono a quale oggetto.

Passare alla console AWS IoT.

Nel riquadro di navigazione a sinistra, scegli Tutti i dispositivi nella sezione Gestisci. Quindi, scegliere Things (Oggetti).

Se viene visualizzata la finestra di dialogoYou don't have any things yet (Non hai ancora oggetti), selezionare Create a thing (Crea un oggetto). Altrimenti, scegli Crea cose.

Nella pagina Creazione di elementi, scegli Crea un singolo elemento, quindi scegli Avanti.

Nella pagina Specificare le proprietà dell'oggetto, inserisci un nome per l' AWS IoT oggetto (ad esempioSiteWiseTutorialDevice1), quindi scegli Avanti. Se si stanno creando altri oggetti, incrementare il numero nel nome dell'oggetto di conseguenza.

Nella pagina Configura il certificato del dispositivo - opzionale, scegli Genera automaticamente un nuovo certificato (consigliato), quindi scegli Avanti. I certificati consentono AWS IoT di identificare in modo sicuro i dispositivi.

Nella pagina Allega politiche al certificato - opzionale, seleziona la politica creata nel Passaggio 1: Creazione di una AWS IoT politica e scegli Crea oggetto.

Nella finestra di dialogo Scarica certificati e chiavi, procedi come segue:

1. Scegliere i collegamenti Download per scaricare il certificato, la chiave pubblica e la chiave privata dell'oggetto. Salvare tutti e tre i file nella directory creata per i certificati dell'oggetto (ad esempio, iot-sitewise-rule-tutorial/device1).

   Importante

   Questo è l'unico momento in cui è possibile scaricare il certificato e le chiavi dell'oggetto, necessari per connettere correttamente il dispositivo ad AWS IoT.

2. Scegliete il link Download per scaricare un certificato CA root. Salvare il certificato CA radice in iot-sitewise-rule-tutorial. Consigliamo di scaricare Amazon Root CA 1.

Seleziona Fatto.

Passare alla console AWS IoT SiteWise.

Nel riquadro di navigazione a sinistra scegliere Models (Modelli).

Scegli Crea modello.

In Dettagli del modello, inserisci un nome per il tuo modello. Ad esempio SiteWise Tutorial Device Model.

In Measurement definitions (Definizioni misurazione), effettuare le seguenti operazioni:

1. In Nome, inserisci CPU Usage.

2. In Unit (Unità), immettere %.

3. Lasciare Data type (Tipo di dati) come Double (Doppio).

Le proprietà di misurazione rappresentano i flussi di dati non elaborati di un dispositivo. Per ulteriori informazioni, consulta Definisci i flussi di dati provenienti dalle apparecchiature (misurazioni).

Scegli Aggiungi nuova misurazione per aggiungere una seconda proprietà di misurazione.

Nella seconda riga sotto Measurement definitions (Definizioni misurazione), effettuare le seguenti operazioni:

1. In Nome, inserisci Memory Usage.

2. In Unit (Unità), immettere %.

3. Lasciare Data type (Tipo di dati) come Double (Doppio).

In Metric definitions (Definizioni parametri), effettuare le seguenti operazioni:

1. In Nome, inserisci Average CPU Usage.

2. In Formula (Formula), immettere avg(CPU Usage) . Scegliere CPU Usage dall'elenco di completamento automatico quando viene visualizzato.

3. In Time interval (Intervallo di tempo), immettere 5 minutes.

Le proprietà dei parametri definiscono i calcoli di aggregazione che elaborano tutti i punti dati di input per un intervallo e generano un singolo punto dati per ogni intervallo. Questa proprietà metrica calcola l'CPUutilizzo medio di ogni dispositivo ogni 5 minuti. Per ulteriori informazioni, consulta Aggrega i dati provenienti da proprietà e altre risorse (metriche).

Scegli Aggiungi nuova metrica per aggiungere una seconda proprietà metrica.

Nella seconda riga sotto Metric definitions (Definizioni parametri), effettuare le seguenti operazioni:

1. In Nome, inserisci Average Memory Usage.

2. In Formula (Formula), immettere avg(Memory Usage) . Scegliere Memory Usage dall'elenco di completamento automatico quando viene visualizzato.

3. In Time interval (Intervallo di tempo), immettere 5 minutes.

Questa proprietà dei parametri calcola l'utilizzo medio della memoria di ogni dispositivo ogni 5 minuti.

(Facoltativo) Aggiungere altri parametri che devono essere calcolati per ogni dispositivo. Alcune funzioni interessanti sono min e max. Per ulteriori informazioni, consulta Usa espressioni di formule. Nella Fase 4: Creazione di un modello di asset per il parco dispositivi, crei una risorsa principale in grado di calcolare le metriche utilizzando i dati dell'intero parco dispositivi.

Scegli Crea modello.

Passare alla console AWS IoT SiteWise.

Nel riquadro di navigazione a sinistra scegliere Models (Modelli).

Scegli Crea modello.

In Dettagli del modello, inserisci un nome per il tuo modello. Ad esempio SiteWise Tutorial Device Fleet Model.

In Hierarchy definitions (Definizioni gerarchie), effettuare le seguenti operazioni:

1. In Hierarchy name (Nome gerarchia), immettere Device.

2. Nel Hierarchy model (Modello gerarchia), scegliere il modello di asset dispositivo (SiteWise Tutorial Device Model).

Una gerarchia definisce una relazione tra un modello di asset padre (parco istanze) e un modello di asset figlio (dispositivo). Gli asset padre possono accedere ai dati delle proprietà degli asset figlio. Quando si creano gli asset in un secondo momento, è necessario associare gli asset figlio agli asset padre in base a una definizione di gerarchia nel modello di asset padre. Per ulteriori informazioni, consulta Definite le gerarchie dei modelli di asset.

In Metric definitions (Definizioni parametri), effettuare le seguenti operazioni:

1. In Nome, inserisci Average CPU Usage.

2. In Formula (Formula), immettere avg(Device | Average CPU Usage) . Quando viene visualizzato l'elenco di completamento automatico, selezionare Device per scegliere una gerarchia, quindi selezionare Average CPU Usage per scegliere il parametro dall'asset dispositivo creato in precedenza.

3. In Time interval (Intervallo di tempo), immettere 5 minutes.

Questa proprietà metrica calcola l'CPUutilizzo medio di tutte le risorse del dispositivo associate a una risorsa del parco veicoli attraverso la Device gerarchia.

Scegli Aggiungi nuova metrica per aggiungere una seconda proprietà della metrica.

Nella seconda riga sotto Metric definitions (Definizioni parametri), effettuare le seguenti operazioni:

1. In Nome, inserisci Average Memory Usage.

2. In Formula (Formula), immettere avg(Device | Average Memory Usage) . Quando viene visualizzato l'elenco di completamento automatico, selezionare Device per scegliere una gerarchia, quindi selezionare Average Memory Usage per scegliere il parametro dall'asset dispositivo creato in precedenza.

3. In Time interval (Intervallo di tempo), immettere 5 minutes.

Questa proprietà del parametro calcola l'utilizzo medio della memoria di tutti gli asset dispositivo associati a un asset parco istanze tramite la gerarchia Device.

(Facoltativo) Aggiungere altri parametri che devono essere calcolati per il parco istanze dei dispositivi.

Scegli Crea modello.

Passare alla console AWS IoT SiteWise.

Nel riquadro di navigazione a sinistra, scegli Asset.

Selezionare Create asset (Crea asset).

In Informazioni sul modello, scegliete il modello di asset del dispositivo,SiteWise Tutorial Device Model.

In Informazioni sulla risorsa, inserite un nome per la risorsa. Ad esempio SiteWise Tutorial Device 1.

Selezionare Create asset (Crea asset).

Per il nuovo asset dispositivo, scegliere Edit (Modifica).

In CPU Usage, immettere /tutorial/device/SiteWiseTutorialDevice1/cpu come alias di proprietà. Includi il nome dell' AWS IoT oggetto nell'alias della proprietà, in modo da poter importare i dati da tutti i tuoi dispositivi utilizzando un'unica AWS IoT regola.

In Memory Usage, immettere /tutorial/device/SiteWiseTutorialDevice1/memory come alias di proprietà.

Seleziona Salva.

Passare alla console AWS IoT SiteWise.

Nel riquadro di navigazione a sinistra, scegli Asset.

Selezionare Create asset (Crea asset).

In Informazioni sul modello, scegli il modello di asset della flotta di dispositivi,SiteWise Tutorial Device Fleet Model.

In Informazioni sull'asset, inserisci un nome per il tuo asset. Ad esempio SiteWise Tutorial Device Fleet 1.

Selezionare Create asset (Crea asset).

Per il nuovo asset parco istanze dei dispositivi, scegliere Edit (Modifica).

In Risorse associate a questa risorsa, scegliete Aggiungi risorsa associata ed effettuate le seguenti operazioni:

1. In Hierarchy (Gerarchia), scegliere Device. Questa gerarchia identifica la relazione di gerarchia tra gli asset parco istanze dei dispositivi e gli asset dispositivi. Questa gerarchia è stata definita nel modello di asset parco istanze dei dispositivi in precedenza in questo tutorial.

2. In Asset, scegliere l'asset dispositivo SiteWise Tutorial Device 1.

(Facoltativo) Se in precedenza avete creato più risorse per dispositivo, ripetete i passaggi da 8 a 10 per ogni risorsa del dispositivo che avete creato.

Seleziona Salva.

A questo punto gli asset dispositivo vengono visualizzati organizzati in gerarchia.

Passare alla console AWS IoT.

Nel riquadro di navigazione a sinistra, scegli Routing dei messaggi, quindi scegli Regole.

Scegli Crea regola.

Inserisci un nome e una descrizione per la regola, quindi scegli Avanti.

Inserisci la seguente SQL dichiarazione e scegli Avanti.

SELECT
  *
FROM
  '$aws/things/+/shadow/update/accepted'
WHERE
  startsWith(topic(3), "SiteWiseTutorialDevice")

Questa istruzione di query di regola funziona perché il servizio shadow del dispositivo pubblica gli aggiornamenti shadow in $aws/things/thingName/shadow/update/accepted. Per ulteriori informazioni sulle ombre dei dispositivi, consulta Device shadow service nella AWS IoT Device Shadow Guide.

Nella clausola WHERE, questa istruzione di query di regola utilizza la funzione topic(3) per ottenere il nome dell'oggetto dal terzo segmento dell'argomento. Quindi, l'istruzione esclude i dispositivi con nomi che non corrispondono a quelli dei dispositivi del tutorial. Per ulteriori informazioni in merito AWS IoT SQL, consulta il AWS IoT SQLriferimento nella Guida per gli AWS IoT sviluppatori.

In Azioni relative alle regole, scegliete Invia i dati dei messaggi alle proprietà degli asset in AWS IoT SiteWise ed effettuate le seguenti operazioni:

1. Scegliere By property alias (Per alias di proprietà).

2. In Property alias (Alias proprietà), immettere /tutorial/device/${topic(3)}/cpu.

   La ${...} sintassi è un modello sostitutivo. AWS IoT valuta il contenuto all'interno delle parentesi. Questo modello di sostituzione esegue il pull del nome dell'oggetto dall'argomento per creare un alias univoco per ogni oggetto. Per ulteriori informazioni, consulta Modelli sostitutivi nella Guida per gli sviluppatori.AWS IoT

   Nota

   Poiché un'espressione in un modello di sostituzione viene valutata separatamente dall'istruzione SELECT, non puoi utilizzare un modello di sostituzione per fare riferimento a un alias creato utilizzando una clausola AS. È possibile fare riferimento solo alle informazioni presenti nel payload originale, oltre alle funzioni e agli operatori supportati.

3. In Entry ID, facoltativo, inserisci. ${concat(topic(3), "-cpu-", floor(state.reported.timestamp))}

   L'immissione identifica IDs in modo univoco ogni tentativo di inserimento del valore. Se una voce restituisce un errore, è possibile trovare l'ID voce nell'output dell'errore per risolvere il problema. Il modello di sostituzione in questo ID voce combina il nome dell'oggetto e il timestamp restituito del dispositivo. Ad esempio, l'ID voce risultante potrebbe essere simile a SiteWiseTutorialDevice1-cpu-1579808494.

4. In Time in seconds (Ora in secondi), immettere ${floor(state.reported.timestamp)}.

   Questo modello di sostituzione calcola l'ora in secondi dal timestamp restituito del dispositivo. In questo tutorial, i dispositivi restituiscono il timestamp in secondi nel formato di ora epoch Unix come numero a virgola mobile.

5. In Offset in nanos - facoltativo, inserisci. ${floor((state.reported.timestamp % 1) * 1E9)}

   Questo modello di sostituzione calcola l'offset in nanosecondi dall'ora in secondi convertendo la parte decimale del timestamp restituito del dispositivo.

   Nota

   AWS IoT SiteWise richiede che i dati abbiano un timestamp corrente in Unix Epoch Time. Se i dispositivi non restituiscono l'ora in modo accurato, è possibile che l'ora corrente restituita dal motore di regole AWS IoT sia timestamp(). Questa funzione segnala l'ora in millisecondi, quindi è necessario aggiornare i parametri dell'ora dell'azione di regola ai seguenti valori:

   • In Time in seconds (Ora in secondi), immettere ${floor(timestamp() / 1E3)}.

   • In Offset in nanos (Offset in nanosecondi), immettere ${(timestamp() % 1E3) * 1E6}.

6. In Data type (Tipo di dati), scegliere Double (Doppio).

   Questo tipo di dati deve corrispondere al tipo di dati della proprietà dell'asset definita nel modello di asset.

7. In Valore, immetti ${state.reported.cpu}. Nei modelli sostitutivi, si utilizza l'.operatore per recuperare un valore dall'interno di una struttura. JSON

8. Scegliere Add entry (Aggiungi voce) per aggiungere una nuova voce per la proprietà di utilizzo della memoria e completare nuovamente i passaggi seguenti per questa proprietà:

   1. Scegliere By property alias (Per alias di proprietà).

   2. In Property alias (Alias proprietà), immettere /tutorial/device/${topic(3)}/memory.

   3. In Entry ID (facoltativo), immettere. ${concat(topic(3), "-memory-", floor(state.reported.timestamp))}

   4. In Time in seconds (Ora in secondi), immettere ${floor(state.reported.timestamp)}.

   5. In Offset in nanos - opzionale, inserisci. ${floor((state.reported.timestamp % 1) * 1E9)}

   6. In Data type (Tipo di dati), scegliere Double (Doppio).

   7. In Valore, immetti ${state.reported.memory}.

9. In IAMRuolo, scegli Crea nuovo ruolo per creare un IAM ruolo per questa azione della regola. Questo ruolo consente di AWS IoT inviare dati alle proprietà del parco dispositivi e della relativa gerarchia di risorse.

10. Inserisci il nome del ruolo e scegli Crea.

(Facoltativo) Configurare un'azione di errore che è possibile utilizzare per risolvere i problemi della regola. Per ulteriori informazioni, consulta Risolvere i problemi relativi a una regola ()AWS IoT SiteWise.

Scegli Next (Successivo).

Controlla le impostazioni e scegli Crea per creare la regola.

Passare alla console AWS IoT.

Nella parte inferiore del riquadro di spostamento a sinistra scegliere Settings (Impostazioni).

Salvare l'endpoint personalizzato da utilizzare con lo script client del dispositivo. Usare questo endpoint per interagire con le shadow dell'oggetto. Questo endpoint è univoco per l'account nella regione corrente.

L'endpoint personalizzato è simile all'esempio seguente.

identifier.iot.region.amazonaws.com

Aprire una riga di comando ed eseguire il comando seguente per passare alla directory creata in precedenza nel tutorial.

cd iot-sitewise-rule-tutorial

Eseguire il comando seguente per installare SDK per dispositivi AWS IoT per Python.

pip3 install AWSIoTPythonSDK

Per ulteriori informazioni, consulta SDK per dispositivi AWS IoT per Pythonla Guida per AWS IoT gli sviluppatori

Eseguire il seguente comando per installare psutil, un processo multipiattaforma e una libreria di utilità di sistema.

pip3 install psutil

Per ulteriori informazioni, consultare psutil nell'indice dei pacchetti Python.

Creare un file chiamato thing_performance.py nella directory iot-sitewise-rule-tutorial e quindi copiare il seguente codice Python nel file.

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

Esegui thing_performance.py dalla riga di comando con i parametri seguenti:

Il comando è simile al seguente esempio:

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 state eseguendo lo script per altre AWS IoT operazioni, aggiornate di conseguenza il nome dell'oggetto e la directory del certificato.

Prova ad aprire e chiudere i programmi sul dispositivo per vedere come cambiano gli usi CPU e la memoria. Lo script stampa tutti CPU i dati relativi all'utilizzo della memoria. Se lo script carica i dati nel servizio shadow del dispositivo correttamente, l'output dello script è simile all'esempio seguente.

[SiteWiseTutorialDevice1]
CPU:    24.6%
Memory: 85.2%

[SiteWiseTutorialDevice1]
Update request e6686e44-fca0-44db-aa48-3ca81726f3e3 accepted

Attenersi alla seguente procedura per verificare che lo script aggiorni la shadow del dispositivo:

1. Passare alla console AWS IoT.

2. Nel riquadro di navigazione a sinistra, scegli Tutti i dispositivi, quindi scegli Cose.

3. Scegli quello che fa per te, SiteWiseTutorialDevice.

4. Scegliete la scheda Device Shadows, scegliete Classic Shadow e verificate che lo stato Shadow sia simile al seguente esempio.

   {
     "reported": {
       "cpu": 24.6,
       "memory": 85.2,
       "timestamp": 1579567542.2835066
     }
   }

   Se lo stato shadow della cosa è vuoto o non assomiglia all'esempio precedente, controlla che lo script sia in esecuzione e che la connessione sia avvenuta correttamente. AWS IoT Se lo script continua a scadere durante la connessione a AWS IoT, verifica che la policy relativa alle cose sia configurata secondo questo tutorial.

Attenersi alla seguente procedura per verificare che l'azione di regola invii dati ad AWS IoT SiteWise:

1. Passare alla console AWS IoT SiteWise.

2. Nel riquadro di navigazione a sinistra, scegli Asset.

3. Scegliere la freccia accanto all'asset parco istanze dei dispositivi (SiteWise Tutorial Device Fleet 1 1) per espandere la gerarchia degli asset, quindi scegliere l'asset dispositivo (SiteWise Tutorial Device 1).

4. Scegliere Measurements (Misurazioni).

5. Verificare che le celle Latest value (Valore più recente) abbiano i valori per le proprietà CPU Usage e Memory Usage.

   

6. Se le proprietà CPU Usage e Memory Usage non hanno i valori più recenti, aggiornare la pagina. Se i valori non vengono visualizzati dopo pochi minuti, consultare Risolvere i problemi relativi a una regola ()AWS IoT SiteWise.

Vai alla console AWS IoT SiteWise

Nel riquadro di navigazione a sinistra, scegli Asset.

Quando eliminate delle risorse in AWS IoT SiteWise, dovete prima dissociarle.

Completare la procedura seguente per dissociare gli asset del dispositivo dall'asset parco istanze dei dispositivi:

1. Scegliete la risorsa del parco dispositivi (SiteWise Tutorial Device Fleet 1).

2. Scegli Modifica.

3. In Assets associated to this asset (Asset associati a questo asset), scegliere Disassociate (Dissocia) per ogni asset dispositivo associato a questo asset parco istanze dei dispositivi.

4. Seleziona Salva.

   A questo punto gli asset dispositivo non sono più organizzati in gerarchia.

Scegliere l'asset dispositivo (SiteWise Tutorial Device 1).

Scegli Elimina.

Nella finestra di dialogo di conferma immettere Delete e quindi scegliere Delete (Elimina).

Ripeti i passaggi da 4 a 6 per ogni risorsa del dispositivo e per la risorsa del parco dispositivi (SiteWise Tutorial Device Fleet 1).

Passare alla console AWS IoT SiteWise.

Se non è già stato fatto, eliminare gli asset del dispositivo e del parco istanze dei dispositivi. Per ulteriori informazioni, consultare la procedura precedente. Non è possibile eliminare un modello se sono presenti asset creati da quel modello.

Nel riquadro di navigazione a sinistra scegliere Models (Modelli).

Scegliere l'asset parco istanze dei dispositivi (SiteWise Tutorial Device Fleet Model).

Quando eliminate i modelli di asset gerarchici, iniziate eliminando prima il modello di asset principale.

Scegli Elimina.

Nella finestra di dialogo di conferma immettere Delete e quindi scegliere Delete (Elimina).

Ripetere i passaggi da 4 a 6 per il modello di asset del dispositivo (SiteWise Tutorial Device Model).

Passare alla console AWS IoT.

Nel riquadro di navigazione a sinistra, scegli Routing dei messaggi, quindi scegli Regole.

Seleziona la tua regola e scegli Elimina.

Nella finestra di dialogo di conferma, inserisci il nome della regola, quindi scegli Elimina.