Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.
# Inserisci dati AWS IoT SiteWise da oggetti AWS IoT
Scopri come importare dati AWS IoT SiteWise da una serie di dispositivi utilizzando AWS IoT le ombre dei dispositivi in questo tutorial. *Le ombre dei dispositivi* sono oggetti JSON che memorizzano le informazioni sullo stato corrente di un dispositivo. AWS IoT *Per ulteriori informazioni, consulta [Device shadow service nella Device Shadow](https://docs.aws.amazon.com/iot/latest/developerguide/iot-device-shadows.html)AWS IoT Guide.*
Dopo aver completato questo tutorial, puoi impostare un'operazione in AWS IoT SiteWise base agli AWS IoT elementi. Utilizzando AWS IoT le cose, è possibile integrare l'operazione con altre utili funzionalità di AWS IoT. Ad esempio, è possibile configurare AWS IoT le funzionalità per eseguire le seguenti attività:
+ Configura regole aggiuntive per lo streaming di dati verso [AWS IoT Events](https://docs.aws.amazon.com/iotevents/latest/developerguide/)[Amazon DynamoDB](https://docs.aws.amazon.com/dynamodb/) e altri servizi. AWS Per ulteriori informazioni, consulta [Rules](https://docs.aws.amazon.com/iot/latest/developerguide/iot-rules.html) nella *AWS IoT Developer* Guide.
+ Indicizza, cerca e aggrega i dati del tuo dispositivo con il servizio di indicizzazione del AWS IoT parco veicoli. *Per ulteriori informazioni, consulta il [servizio di indicizzazione del parco veicoli nella Guida per gli sviluppatori](https://docs.aws.amazon.com/iot/latest/developerguide/iot-indexing.html).AWS IoT *
+ Controlla e proteggi i tuoi dispositivi con. AWS IoT Device Defender Per ulteriori informazioni, consulta la sezione [AWS IoT Device Defender](https://docs.aws.amazon.com/iot-device-defender/latest/devguide/what-is-device-defender.html) nella *Guida per gli sviluppatori di AWS IoT *.
In questo tutorial, imparerai a trasferire i dati dalle ombre dei dispositivi AWS IoT Things agli asset in esso contenuti. AWS IoT SiteWise A tale scopo, create uno o più AWS IoT elementi ed eseguite uno script che aggiorna l'ombra del dispositivo di ogni elemento con i dati sull'utilizzo della CPU e della memoria. In questo tutorial usi i dati di utilizzo della CPU e della memoria per imitare i dati realistici del sensore. Quindi, crei una regola con un' AWS IoT SiteWise azione che invia questi dati a una risorsa AWS IoT SiteWise ogni volta che lo shadow del dispositivo si aggiorna. Per ulteriori informazioni, consulta [Inserisci dati per AWS IoT SiteWise utilizzare le regole AWS IoT Core](iot-rules.md).
**Topics**
+ [Prerequisiti](#rule-ingestion-tutorial-prerequisites)
+ [Fase 1: Creare una AWS IoT politica](#ingestion-tutorial-create-iot-policy)
+ [Fase 2: Creare e configurare qualsiasi AWS IoT cosa](#rule-tutorial-create-iot-thing)
+ [Fase 3: Creazione di un modello di asset per dispositivi](#rule-tutorial-create-device-model)
+ [Fase 4: Creazione di un modello di asset per il parco dispositivi](#rule-tutorial-create-fleet-model)
+ [Passaggio 5: Creare e configurare una risorsa del dispositivo](#rule-tutorial-create-device-assets)
+ [Fase 6: Creare e configurare un parco di dispositivi](#rule-tutorial-create-fleet-asset)
+ [Passaggio 7: crea una regola in AWS IoT Core per inviare dati alle risorse del dispositivo](#rule-tutorial-create-iot-rule)
+ [Passaggio 8: Esegui lo script del client del dispositivo](#rule-tutorial-run-script)
+ [Fase 9: Pulisci le risorse dopo il tutorial](#rule-tutorial-clean-up-resources)
## Prerequisiti
Per completare questo tutorial, è necessario quanto segue:
+ Un AWS account. Se non lo hai, consultare [Configura un account AWS](getting-started.md#set-up-aws-account).
+ Un computer di sviluppo che esegue WindowsmacOS,Linux, o Unix per accedere a Console di gestione AWS. Per ulteriori informazioni, consulta [Nozioni di base su Console di gestione AWS](https://docs.aws.amazon.com/awsconsolehelpdocs/latest/gsg/getting-started.html).
+ Un utente AWS Identity and Access Management (IAM) con autorizzazioni di amministratore.
+ Python3 installato sul tuo computer di sviluppo o installato sul dispositivo che desideri registrare come dispositivo AWS IoT .
## Fase 1: Creare una AWS IoT politica
In questa procedura, crea una AWS IoT politica che consenta ai tuoi AWS IoT oggetti di accedere alle risorse utilizzate in questo tutorial.
------
#### [ Console ]
Utilizza la seguente procedura per creare una AWS IoT politica utilizzando la AWS IoT Core console:
**Per creare una AWS IoT politica**
1. Accedi alla [Console di gestione AWS](https://docs.aws.amazon.com/awsconsolehelpdocs/latest/gsg/what-is.html).
1. Consulta le [AWS regioni](https://docs.aws.amazon.com/general/latest/gr/iot-sitewise.html) in cui AWS IoT SiteWise è supportato. Passare a una di queste regioni supportate, se necessario.
1. Passare alla [console AWS IoT](https://console.aws.amazon.com/iot/). Se viene visualizzato **il pulsante Connect device**, selezionalo.
1. Nel riquadro di navigazione a sinistra, scegli **Sicurezza**, quindi scegli **Politiche**.
1. Scegli **Create** (Crea).
1. Inserisci un nome per la AWS IoT politica (ad esempio,**SiteWiseTutorialDevicePolicy**).
1. In **Documento di politica**, scegli **JSON** per inserire la seguente politica in formato JSON. Sostituisci *region* e *account-id* con la tua regione e l'ID dell'account, ad esempio **us-east-1** e. **123456789012**
------
#### [ 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. Scegli **Create** (Crea).
------
#### [ AWS CLI ]
**Importante**
Questa policy utilizza i caratteri jolly per rimanere entro AWS IoT SiteWise i limiti delle dimensioni della CLI. Per autorizzazioni più restrittive con percorsi tematici espliciti, crea invece la policy tramite la console. AWS IoT SiteWise Per ulteriori informazioni, consulta l'esempio di policy IoT fornito nella scheda.
Usa il seguente AWS CLI comando per creare una policy 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*"
}
]
}'
```
Per verificare che la tua policy sia stata creata correttamente, usa il seguente comando:
```
aws iot get-policy --policy-name "SiteWiseTutorialDevicePolicy"
```
------
Questa policy consente ai AWS IoT dispositivi di stabilire connessioni e comunicare con le ombre dei dispositivi utilizzando messaggi MQTT. Per ulteriori informazioni sui messaggi MQTT, consulta [Che cos'](https://aws.amazon.com/what-is/mqtt/)è MQTT? . Per interagire con AWS IoT le ombre dei dispositivi, i tuoi dispositivi pubblicano e ricevono messaggi MQTT 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:Connect`istruzione 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](https://docs.aws.amazon.com/iot/latest/developerguide/iot-policy-variables.html) nella *AWS IoT Developer Guide*.
**Nota**
Questa policy si applica agli oggetti i cui nomi iniziano con `SiteWiseTutorialDevice`. Per utilizzare un nome diverso per gli oggetti, è necessario aggiornare la policy di conseguenza.
## Fase 2: Creare e configurare qualsiasi AWS IoT cosa
In questa procedura, si crea e si configura qualsiasi AWS IoT cosa. È possibile designare il computer di sviluppo come qualsiasi AWS IoT cosa. Man mano che progredisci, ricorda che i principi che stai imparando qui possono essere applicati a progetti reali. Hai la flessibilità di creare e configurare AWS IoT cose su qualsiasi dispositivo in grado di eseguire un AWS IoT SDK, inclusi AWS IoT Greengrass FreerTOS. Per ulteriori informazioni, consulta la sezione [AWS IoT SDKs](https://docs.aws.amazon.com/iot/latest/developerguide/iot-sdks.html) nella *Guida per gli sviluppatori di AWS IoT *.
------
#### [ Console ]
**Per creare e configurare qualsiasi cosa AWS IoT**
1. 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
```
1. 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.
1. Passare alla [console AWS IoT](https://console.aws.amazon.com/iot/).
1. Nel riquadro di navigazione a sinistra, scegli **Tutti i dispositivi** nella sezione **Gestisci**. Quindi, scegliere **Things (Oggetti)**.
1. Se viene visualizzata la finestra di dialogo**You don't have any things yet (Non hai ancora oggetti)**, selezionare **Create a thing (Crea un oggetto)**. Altrimenti, scegli **Crea cose**.
1. Nella pagina **Creazione di elementi**, scegli **Crea un singolo elemento**, quindi scegli **Avanti**.
1. Nella pagina **Specificare le proprietà** dell'oggetto, inserisci un nome per l' AWS IoT oggetto (ad esempio**SiteWiseTutorialDevice1**), quindi scegli **Avanti**. Se si stanno creando altri oggetti, incrementare il numero nel nome dell'oggetto di conseguenza.
**Importante**
Il nome dell'oggetto deve corrispondere al nome utilizzato nella politica creata nel *Passaggio 1: Creazione di una AWS IoT politica*. In caso contrario, il dispositivo non potrà connettersi a AWS IoT.
1. 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.
1. Nella pagina **Allega politiche al certificato - *opzionale***, seleziona la politica creata nel *Passaggio 1: Creazione di una AWS IoT politica* e scegli **Crea oggetto**.
1. 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.
1. 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.
1. Seleziona **Fatto**.
------
#### [ AWS CLI ]
Segui questi passaggi per creare e configurare AWS IoT qualsiasi cosa utilizzando AWS CLI:
1. Apri una riga di comando ed esegui il seguente comando per creare una directory per questo tutorial:
```
mkdir iot-sitewise-rule-tutorial
```
1. Vai alla cartella del tutorial:
```
cd iot-sitewise-rule-tutorial
```
1. Esegui il comando seguente per creare una directory per i certificati del tuo 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.
1. Crea qualsiasi AWS IoT cosa:
```
aws iot create-thing --thing-name "SiteWiseTutorialDevice1"
```
**Importante**
Il nome dell'oggetto deve corrispondere al modello di denominazione utilizzato nella politica creata nel passaggio 1. In caso contrario, il dispositivo non potrà connettersi a AWS IoT.
1. Crea un certificato e salva i file. Annota l'ARN del certificato dall'output: ti servirà nei passaggi successivi:
```
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. Allega la politica che hai creato nel passaggio 1 al certificato:
```
aws iot attach-policy \
--policy-name "SiteWiseTutorialDevicePolicy" \
--target "certificate-arn"
```
1. Allega il certificato all'oggetto:
```
aws iot attach-thing-principal \
--thing-name "SiteWiseTutorialDevice1" \
--principal "certificate-arn"
```
1. Scarica il certificato Amazon root CA:
```
curl https://www.amazontrust.com/repository/AmazonRootCA1.pem > AmazonRootCA1.pem
```
Questo certificato è necessario per consentire al dispositivo di connettersi correttamente a AWS IoT.
**Importante**
Archivia i tuoi certificati e le tue chiavi in modo sicuro. Non è possibile scaricare nuovamente queste credenziali dopo averle create.
------
Ora hai registrato AWS IoT qualcosa sul tuo computer. Esegui uno dei seguenti passaggi successivi:
+ Continua con la *Fase 3: Creazione di un modello di asset del dispositivo* senza creare AWS IoT elementi aggiuntivi. È possibile completare questo tutorial con un solo oggetto.
+ Ripetere la procedura descritta in questa sezione su un altro computer o dispositivo per creare altri oggetti AWS IoT . Per questo tutorial, si consiglia di seguire questa opzione in modo da poter inserire dati di utilizzo univoci della CPU e della memoria da più dispositivi.
+ Ripetere la procedura descritta in questa sezione sullo stesso dispositivo (computer) per creare più oggetti AWS IoT . Ogni AWS IoT oggetto riceve dati simili sull'utilizzo della CPU e della memoria dal computer, quindi utilizza questo approccio per dimostrare l'acquisizione di dati non univoci da più dispositivi.
## Fase 3: Creazione di un modello di asset per dispositivi
In questa procedura, create un modello di asset AWS IoT SiteWise per rappresentare i dispositivi che trasmettono i dati sull'utilizzo della CPU e della memoria. Per elaborare i dati in asset che rappresentano gruppi di dispositivi, i modelli di asset applicano informazioni coerenti su più asset dello stesso tipo. Per ulteriori informazioni, consulta [Asset industriali modello](industrial-asset-models.md).
**Per creare un modello di asset che rappresenta un dispositivo**
1. Passare alla [console AWS IoT SiteWise](https://console.aws.amazon.com/iotsitewise/).
1. Nel riquadro di navigazione a sinistra scegliere **Models (Modelli)**.
1. Scegliete **Crea modello di asset**.
1. In **Dettagli del modello**, inserisci un nome per il tuo modello. Ad esempio, **SiteWise Tutorial Device Model**.
1. In **Measurement definitions (Definizioni misurazione)**, effettuare le seguenti operazioni:
1. In **Nome**, inserisci **CPU Usage**.
1. In **Unit (Unità)**, immettere **%**.
1. 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)](measurements.md).
1. Scegli **Aggiungi nuova misurazione** per aggiungere una seconda proprietà di misurazione.
1. Nella seconda riga sotto **Measurement definitions (Definizioni misurazione)**, effettuare le seguenti operazioni:
1. In **Nome**, inserisci **Memory Usage**.
1. In **Unit (Unità)**, immettere **%**.
1. Lasciare **Data type (Tipo di dati)** come **Double (Doppio)**.
1. In **Metric definitions (Definizioni parametri)**, effettuare le seguenti operazioni:
1. In **Nome**, inserisci **Average CPU Usage**.
1. In **Formula (Formula)**, immettere **avg(CPU Usage)** . Scegliere **CPU Usage** dall'elenco di completamento automatico quando viene visualizzato.
1. 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à dei parametri calcola l'utilizzo medio della CPU di ogni dispositivo ogni 5 minuti. Per ulteriori informazioni, consulta [Aggrega i dati provenienti da proprietà e altre risorse (metriche)](metrics.md).
1. Scegli **Aggiungi nuova metrica** per aggiungere una seconda proprietà metrica.
1. Nella seconda riga sotto **Metric definitions (Definizioni parametri)**, effettuare le seguenti operazioni:
1. In **Nome**, inserisci **Average Memory Usage**.
1. In **Formula (Formula)**, immettere **avg(Memory Usage)** . Scegliere **Memory Usage** dall'elenco di completamento automatico quando viene visualizzato.
1. 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.
1. (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](formula-expressions.md). 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.
1. Scegli **Crea modello**.
## Fase 4: Creazione di un modello di asset per il parco dispositivi
In questa procedura, create un modello di asset che simboleggi la vostra collezione di dispositivi. AWS IoT SiteWise All'interno di questo modello di asset, stabilisci una struttura che ti consente di collegare numerosi dispositivi a un unico asset globale della flotta. Successivamente, definisci le metriche nel modello di asset della flotta per consolidare i dati di tutti gli asset dei dispositivi connessi. Questo approccio fornisce informazioni complete sulle prestazioni collettive dell'intero parco veicoli.
**Per creare un modello di asset che rappresenta un parco istanze dei dispositivi**
1. Passare alla [console AWS IoT SiteWise](https://console.aws.amazon.com/iotsitewise/).
1. Nel riquadro di navigazione a sinistra scegliere **Models (Modelli)**.
1. Scegli **Crea modello di asset**.
1. In **Dettagli del modello**, inserisci un nome per il tuo modello. Ad esempio, **SiteWise Tutorial Device Fleet Model**.
1. In **Hierarchy definitions (Definizioni gerarchie)**, effettuare le seguenti operazioni:
1. In **Hierarchy name (Nome gerarchia)**, immettere **Device**.
1. 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 [Le gerarchie degli asset rappresentano le relazioni tra le apparecchiature](industrial-asset-models.md#asset-hierarchies).
1. In **Metric definitions (Definizioni parametri)**, effettuare le seguenti operazioni:
1. In **Nome**, inserisci **Average CPU Usage**.
1. In **Formula (Formula)**, immettere **avg(Device \$1 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.
1. In **Time interval (Intervallo di tempo)**, immettere **5 minutes**.
Questa proprietà del parametro calcola l'utilizzo medio della CPU di tutti gli asset dispositivo associati a un asset parco istanze tramite la gerarchia **Device**.
1. Scegli **Aggiungi nuova metrica** per aggiungere una seconda proprietà metrica.
1. Nella seconda riga sotto **Metric definitions (Definizioni parametri)**, effettuare le seguenti operazioni:
1. In **Nome**, inserisci **Average Memory Usage**.
1. In **Formula (Formula)**, immettere **avg(Device \$1 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.
1. 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**.
1. (Facoltativo) Aggiungere altri parametri che devono essere calcolati per il parco istanze dei dispositivi.
1. Scegli **Crea modello**.
## Passaggio 5: Creare e configurare una risorsa del dispositivo
In questa procedura, si genera una risorsa del dispositivo basata sul modello di risorsa del dispositivo. Quindi, definisci gli alias per ogni proprietà di misurazione. Un *alias di proprietà* è una stringa univoca che identifica la proprietà di una risorsa. Successivamente, potete identificare una proprietà per il caricamento dei dati utilizzando gli alias anziché l'ID della risorsa e l'ID della proprietà. Per ulteriori informazioni, consulta [Gestisci i flussi di dati per AWS IoT SiteWise](manage-data-streams.md).
**Per creare un asset dispositivo e definire gli alias di proprietà**
1. Passare alla [console AWS IoT SiteWise](https://console.aws.amazon.com/iotsitewise/).
1. Nel riquadro di navigazione a sinistra, scegli **Asset**.
1. Selezionare **Create asset (Crea asset)**.
1. In **Informazioni sul modello**, scegliete il modello di asset del dispositivo,**SiteWise Tutorial Device Model**.
1. In **Informazioni sulla risorsa**, inserite un nome per la risorsa. Ad esempio, **SiteWise Tutorial Device 1**.
1. Selezionare **Create asset (Crea asset)**.
1. Per il nuovo asset dispositivo, scegliere **Edit (Modifica)**.
1. In **Misurazioni**:
1. 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 dati da tutti i tuoi dispositivi utilizzando un'unica AWS IoT regola.
1. In **Memory Usage**, immettere **/tutorial/device/SiteWiseTutorialDevice1/memory** come alias di proprietà.
1. Scegli **Save** (Salva).
Se hai creato più AWS IoT elementi in precedenza, ripeti i passaggi da 3 a 10 per ogni dispositivo e incrementa di conseguenza il numero nel nome della risorsa e negli alias delle proprietà. Ad esempio, il nome del secondo asset dispositivo dovrebbe essere **SiteWise Tutorial Device 2** e i relativi alias di proprietà dovrebbero essere **/tutorial/device/SiteWiseTutorialDevice2/cpu** e **/tutorial/device/SiteWiseTutorialDevice2/memory**.
## Fase 6: Creare e configurare un parco di dispositivi
In questa procedura, si crea un asset di parco dispositivi derivato dal modello di parco dispositivi utilizzato. Quindi, colleghi le risorse dei singoli dispositivi alla risorsa del parco dispositivi. Questa associazione consente alle proprietà metriche dell'asset della flotta di compilare e analizzare i dati provenienti da più dispositivi. Questi dati forniscono una visione consolidata delle prestazioni collettive dell'intera flotta.
**Per creare un asset parco istanze dei dispositivi e associare asset dispositivo**
1. Passare alla [console AWS IoT SiteWise](https://console.aws.amazon.com/iotsitewise/).
1. Nel riquadro di navigazione a sinistra, scegli **Asset**.
1. Selezionare **Create asset (Crea asset)**.
1. In **Informazioni sul modello**, scegli il modello di asset della flotta di dispositivi,**SiteWise Tutorial Device Fleet Model**.
1. In **Informazioni sulla risorsa**, inserisci un nome per la risorsa. Ad esempio, **SiteWise Tutorial Device Fleet 1**.
1. Selezionare **Create asset (Crea asset)**.
1. Per il nuovo asset parco istanze dei dispositivi, scegliere **Edit (Modifica)**.
1. 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.
1. In **Asset**, scegliere l'asset dispositivo **SiteWise Tutorial Device 1**.
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.
1. Scegli **Save** (Salva).
A questo punto gli asset dispositivo vengono visualizzati organizzati in gerarchia.
## Passaggio 7: crea una regola in AWS IoT Core per inviare dati alle risorse del dispositivo
In questa procedura, stabilisci una regola in AWS IoT Core. La regola è progettata per interpretare i messaggi di notifica provenienti dalle ombre del dispositivo e trasmettere i dati alle risorse del dispositivo. AWS IoT SiteWise Ogni volta che lo shadow del dispositivo si aggiorna, AWS IoT invia un messaggio MQTT. Puoi creare una regola che intraprende un'azione quando le shadow del dispositivo cambiano in base al messaggio MQTT. In questo caso, l'obiettivo è gestire il messaggio di aggiornamento, estrarre i valori delle proprietà e trasmetterli alle risorse del dispositivo. AWS IoT SiteWise
**Creare una regola con un' AWS IoT SiteWise azione**
1. Passare alla [console AWS IoT](https://console.aws.amazon.com/iot/).
1. Nel riquadro di navigazione a sinistra, scegli **Routing dei messaggi**, quindi scegli **Regole**.
1. Scegli **Crea regola**.
1. Inserisci un nome e una descrizione per la regola, quindi scegli **Avanti**.
1. Immettete la seguente istruzione SQL e scegliete **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](https://docs.aws.amazon.com/iot/latest/developerguide/iot-device-shadows.html) 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 su AWS IoT SQL, consulta il [riferimento AWS IoT SQL](https://docs.aws.amazon.com/iot/latest/developerguide/iot-sql-reference.html) nella *AWS IoT Developer Guide*.
1. 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à)**.
1. In **Property alias (Alias proprietà)**, immettere **/tutorial/device/\$1\$1topic(3)\$1/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](https://docs.aws.amazon.com/iot/latest/developerguide/iot-substitution-templates.html) 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.
1. In **Entry ID, *facoltativo, inserisci***. **\$1\$1concat(topic(3), "-cpu-", floor(state.reported.timestamp))\$1**
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`.
1. In **Time in seconds (Ora in secondi)**, immettere **\$1\$1floor(state.reported.timestamp)\$1**.
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.
1. In **Offset in nanos - *facoltativo***, inserisci. **\$1\$1floor((state.reported.timestamp % 1) \$1 1E9)\$1**
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()](https://docs.aws.amazon.com/iot/latest/developerguide/iot-sql-functions.html#iot-function-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 **\$1\$1floor(timestamp() / 1E3)\$1**.
In **Offset in nanos (Offset in nanosecondi)**, immettere **\$1\$1(timestamp() % 1E3) \$1 1E6\$1**.
1. 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.
1. In **Valore**, immetti **\$1\$1state.reported.cpu\$1**. Nei modelli di sostituzione, è possibile utilizzare l'operatore `.` per recuperare un valore all'interno di una struttura JSON.
1. 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à)**.
1. In **Property alias (Alias proprietà)**, immettere **/tutorial/device/\$1\$1topic(3)\$1/memory**.
1. *In **Entry ID -** facoltativo, inserisci.* **\$1\$1concat(topic(3), "-memory-", floor(state.reported.timestamp))\$1**
1. In **Time in seconds (Ora in secondi)**, immettere **\$1\$1floor(state.reported.timestamp)\$1**.
1. In **Offset in nanos - *opzionale, inserisci***. **\$1\$1floor((state.reported.timestamp % 1) \$1 1E9)\$1**
1. In **Data type (Tipo di dati)**, scegliere **Double (Doppio)**.
1. In **Valore**, immetti **\$1\$1state.reported.memory\$1**.
1. In **Ruolo IAM**, scegli **Crea nuovo ruolo** per creare un ruolo IAM per questa azione della regola. Questo ruolo consente di AWS IoT inviare dati alle proprietà della flotta di dispositivi e della relativa gerarchia degli asset.
1. Inserisci il nome del ruolo e scegli **Crea**.
1. (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](troubleshoot-rule.md#rule-tutorial-troubleshoot-rule).
1. Scegli **Next (Successivo)**.
1. Controlla le impostazioni e scegli **Crea** per creare la regola.
## Passaggio 8: Esegui lo script del client del dispositivo
In questo tutorial, non stai utilizzando un dispositivo reale per riportare i dati. Invece, esegui uno script per aggiornare l'ombra del dispositivo in uso con l'utilizzo della CPU e della memoria per imitare i dati reali dei sensori. AWS IoT Per eseguire lo script, è necessario prima installare Python i pacchetti richiesti. In questa procedura, si Python installano i pacchetti richiesti e quindi si esegue lo script client del dispositivo.
**Per configurare ed eseguire lo script client del dispositivo**
1. Passare alla [console AWS IoT](https://console.aws.amazon.com/iot/).
1. Nella parte inferiore del riquadro di spostamento a sinistra scegliere **Settings (Impostazioni)**.
1. 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
```
1. Aprire una riga di comando ed eseguire il comando seguente per passare alla directory creata in precedenza nel tutorial.
```
cd iot-sitewise-rule-tutorial
```
1. 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 Python](https://docs.aws.amazon.com/iot/latest/developerguide/iot-sdks.html#iot-python-sdk)la *Guida per AWS IoT gli sviluppatori*
1. 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](https://pypi.org/project/psutil/) nell'*indice dei pacchetti Python*.
1. 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()
```
1. Esegui **thing\$1performance.py** dalla riga di comando con i parametri seguenti:
+ `-n`, `--thingName` — Nome del tuo oggetto, ad esempio**SiteWiseTutorialDevice1**.
+ `-e`, `--endpoint` — L' AWS IoT endpoint personalizzato salvato in precedenza in questa procedura.
+ `-r`, `--rootCA` — Il percorso del certificato CA AWS IoT principale.
+ `-c`, `--cert` — Il percorso del tuo certificato AWS IoT Thing.
+ `-k`, `--key` — Il percorso della chiave privata del tuo AWS IoT Thing Certificate.
+ `-d`, `--requestDelay` — (Facoltativo) Il tempo di attesa, in secondi, tra un aggiornamento dello shadow del dispositivo e l'altro. Il valore predefinito è 1 secondo.
+ `-v`, `--enableLogging` — (Facoltativo) Se questo parametro è presente, lo script stampa i messaggi di debug da. SDK per dispositivi AWS IoT per Python
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.
1. Provare ad aprire e chiudere i programmi sul dispositivo per vedere come cambiano gli utilizzi della CPU e della memoria. Lo script stampa ogni lettura dell'utilizzo della CPU e 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
```
1. Attenersi alla seguente procedura per verificare che lo script aggiorni la shadow del dispositivo:
1. Passare alla [console AWS IoT](https://console.aws.amazon.com/iot/).
1. Nel riquadro di navigazione a sinistra, scegli **Tutti i dispositivi**, quindi scegli **Cose**.
1. Scegli quello che fa per te, **SiteWiseTutorialDevice**.
1. 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](#ingestion-tutorial-create-iot-policy) sia configurata in base a questo tutorial.
1. Attenersi alla seguente procedura per verificare che l'azione di regola invii dati ad AWS IoT SiteWise:
1. Passare alla [console AWS IoT SiteWise](https://console.aws.amazon.com/iotsitewise/).
1. Nel riquadro di navigazione a sinistra, scegli **Asset**.
1. Scegliete la freccia accanto alla risorsa del vostro parco dispositivi (**SiteWise Tutorial Device Fleet 1**) per espanderne la gerarchia degli asset, quindi scegliete la risorsa del dispositivo (**SiteWise Tutorial Device1**).
1. Scegliere **Measurements (Misurazioni)**.
1. Verificare che le celle **Latest value (Valore più recente)** abbiano i valori per le proprietà **CPU Usage** e **Memory Usage**.
![\[Schermata con «Misurazioni» evidenziate.\]](http://docs.aws.amazon.com/it_it/iot-sitewise/latest/userguide/images/rule-ingestion/sitewise-view-measurement-values-console.png)
1. 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](troubleshoot-rule.md#rule-tutorial-troubleshoot-rule).
Il tutorial è stato completato. Per esplorare le visualizzazioni dei dati in tempo reale, è possibile configurare un portale in AWS IoT SiteWise Monitor. Per ulteriori informazioni, consulta [Monitora i dati con AWS IoT SiteWise Monitor](monitor-data.md). In caso contrario, è possibile premere **CTRL\$1C** nel prompt dei comandi per arrestare lo script client del dispositivo. È improbabile che il programma Python invii un numero di messaggi tale da comportare un addebito, ma è consigliabile arrestare il programma al termine delle operazioni.
## Fase 9: Pulisci le risorse dopo il tutorial
**Nota**
Le risorse create in questo tutorial sono necessarie per il tutorial [Integrate data into SiteWise Edge](integrate_sitewise_edge_mqtt.md). Non ripulite le risorse in questo passaggio se avete intenzione di completarlo.
Dopo aver completato il tutorial sull'acquisizione di dati dagli AWS IoT oggetti, ripulisci le risorse per evitare di incorrere in costi aggiuntivi.
**Per eliminare risorse gerarchiche in AWS IoT SiteWise**
1. [Vai alla console AWS IoT SiteWise](https://console.aws.amazon.com/iotsitewise/)
1. Nel riquadro di navigazione a sinistra, scegli **Asset**.
1. 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**).
1. Scegli **Modifica**.
1. 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.
1. Scegli **Save** (Salva).
A questo punto gli asset dispositivo non sono più organizzati in gerarchia.
1. Scegliere l'asset dispositivo (**SiteWise Tutorial Device 1**).
1. Scegli **Elimina**.
1. Nella finestra di dialogo di conferma immettere **Delete** e quindi scegliere **Delete (Elimina)**.
1. Ripeti i passaggi da 4 a 6 per ogni risorsa del dispositivo e per la risorsa del parco dispositivi (**SiteWise Tutorial Device Fleet 1**).
**Per eliminare i modelli di asset gerarchici in AWS IoT SiteWise**
1. Passare alla [console AWS IoT SiteWise](https://console.aws.amazon.com/iotsitewise/).
1. Se non è già stato fatto, eliminare gli asset del dispositivo e del parco istanze dei dispositivi. Per ulteriori informazioni, consultare [la procedura precedente](#rule-tutorial-delete-assets). Non è possibile eliminare un modello se sono presenti asset creati da quel modello.
1. Nel riquadro di navigazione a sinistra scegliere **Models (Modelli)**.
1. 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.
1. Scegli **Elimina**.
1. Nella finestra di dialogo di conferma immettere **Delete** e quindi scegliere **Delete (Elimina)**.
1. Ripetere i passaggi da 4 a 6 per il modello di asset del dispositivo (**SiteWise Tutorial Device Model**).
**Per disabilitare o eliminare una regola in AWS IoT Core**
1. Passare alla [console AWS IoT](https://console.aws.amazon.com/iot/).
1. Nel riquadro di navigazione a sinistra, scegli **Routing dei messaggi**, quindi scegli **Regole**.
1. Seleziona la tua regola e scegli **Elimina**.
1. Nella finestra di dialogo di conferma, inserisci il nome della regola, quindi scegli **Elimina**.