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à.
# AWS IoT SiteWise tutorial
Benvenuto nella pagina AWS IoT SiteWise dei tutorial. Questa crescente raccolta di tutorial ti fornisce le conoscenze e le competenze necessarie per navigare nelle complessità di. AWS IoT SiteWise Questi tutorial offrono una vasta gamma di argomenti di base per soddisfare le tue esigenze. Man mano che approfondisci i tutorial, scopri informazioni preziose su vari aspetti di. AWS IoT SiteWise
Ogni tutorial utilizza un esempio di attrezzatura specifico. Questi tutorial sono destinati agli ambienti di test e utilizzano nomi di società, modelli, risorse, proprietà fittizi e così via. Il loro scopo è di fornire linee guida di carattere generico. I tutorial non sono destinati all'uso diretto in un ambiente di produzione senza un'attenta revisione e adattamento per soddisfare le esigenze specifiche dell'organizzazione.
**Topics**
+ [Calcola l'OEE in AWS IoT SiteWise](calculate-oee.md)
+ [Inserisci dati AWS IoT SiteWise da oggetti AWS IoT](ingest-data-from-iot-things.md)
+ [Integra i dati in SiteWise Edge utilizzando un gateway V3 abilitato per MQTT](integrate_sitewise_edge_mqtt.md)
+ [Visualizza e condividi dati in Grafana](visualize-with-grafana.md)
+ [Visualizza e condividi i dati dei parchi eolici in Monitor SiteWise](monitor-wind-farm.md)
+ [Pubblica aggiornamenti dei valori delle proprietà su Amazon DynamoDB](publish-to-amazon-dynamodb.md)
# Calcola l'OEE in AWS IoT SiteWise
Questo tutorial fornisce un esempio specifico di come calcolare l'OEE (Overall Equipment Effectiveness, efficienza complessiva delle apparecchiature) di un processo di produzione. Trattandosi di un esempio, i tuoi calcoli o le formule reali dell'OEE potrebbero variare rispetto a quelli mostrati. In generale, l'OEE è definito da `Availability * Quality * Performance`. Per ulteriori informazioni sul calcolo dell'OEE, consulta [Overall equipment effectiveness](https://en.wikipedia.org/wiki/Overall_equipment_effectiveness) su *Wikipedia*.
## Prerequisiti
Per completare questo tutorial, è necessario configurare l'acquisizione di dati per un dispositivo con i seguenti tre flussi di dati:
+ `Equipment_State`— Un codice numerico che rappresenta lo stato della macchina, ad esempio inattività, guasto, arresto pianificato o funzionamento normale.
+ `Good_Count`— Un flusso di dati in cui ogni punto dati contiene il numero di operazioni riuscite a partire dall'ultimo punto dati.
+ `Bad_Count`— Un flusso di dati in cui ogni punto dati contiene il numero di operazioni non riuscite dall'ultimo punto dati.
Per configurare l'acquisizione di dati, consulta [Inserisci dati in AWS IoT SiteWise](industrial-data-ingestion.md). In assenza di un'operazione industriale disponibile, è possibile creare uno script che generi e carichi dati esemplificativi tramite l'API di AWS IoT SiteWise .
## Come calcolare l'OEE
In questo tutorial, si crea un modello di asset che calcola l'OEE in base a tre flussi di dati di input: `Equipment_State`, `Good_Count` e `Bad_Count`. In questo esempio, prendiamo in esame una macchina generica per il packaging, come quelle utilizzate per il confezionamento dello zucchero, delle patatine o della vernice. Nella [AWS IoT SiteWise console](https://console.aws.amazon.com/iotsitewise/), crea un modello di AWS IoT SiteWise asset con le seguenti misurazioni, trasformazioni e metriche. Quindi, potete creare una risorsa per rappresentare la macchina per l'imballaggio e osservare come AWS IoT SiteWise calcola l'OEE.
Definisci le seguenti [misurazioni](measurements.md) per rappresentare i flussi di dati non elaborati provenienti dalla macchina confezionatrice.
**Misurazioni**
+ `Equipment_State`— Un flusso di dati (o misurazione) che fornisce lo stato attuale della macchina confezionatrice in codici numerici:
+ `1024`— La macchina è inattiva.
+ `1020`— Un guasto, ad esempio un errore o un ritardo.
+ `1000`— Una sosta pianificata.
+ `1111`— Un'operazione normale.
+ `Good_Count`— Un flusso di dati in cui ogni punto dati contiene il numero di operazioni riuscite a partire dall'ultimo punto dati.
+ `Bad_Count`— Un flusso di dati in cui ogni punto dati contiene il numero di operazioni non riuscite dall'ultimo punto dati.
Utilizzando il flusso di dati di misurazione `Equipment_State` e i relativi codici, è possibile definire le seguenti [trasformazioni](transforms.md) (o misurazioni derivate). Le trasformazioni hanno una one-to-one relazione con le misurazioni grezze.
**Trasformazioni**
+ `Idle = eq(Equipment_State, 1024)`— Un flusso di dati trasformato che contiene lo stato di inattività della macchina.
+ `Fault = eq(Equipment_State, 1020)`— Un flusso di dati trasformato che contiene lo stato di guasto della macchina.
+ `Stop = eq(Equipment_State, 1000)`— Un flusso di dati trasformato che contiene lo stato di arresto pianificato della macchina.
+ `Running = eq(Equipment_State, 1111)`— Un flusso di dati trasformato che contiene il normale stato operativo della macchina.
Utilizzando le misurazioni non elaborate e quelle trasformate, è possibile definire i seguenti [parametri](metrics.md) che aggregano i dati della macchina per intervalli di tempo specificati. Per tutti i parametri che si vanno a definire in questa sezione bisogna scegliere lo stesso intervallo di tempo.
**Metriche**
+ `Successes = sum(Good_Count)`— Il numero di pacchi riempiti con successo nell'intervallo di tempo specificato.
+ `Failures = sum(Bad_Count)`— Il numero di pacchi riempiti senza successo nell'intervallo di tempo specificato.
+ `Idle_Time = statetime(Idle)`— Il tempo di inattività totale della macchina (in secondi) per intervallo di tempo specificato.
+ `Fault_Time = statetime(Fault)`— Il tempo totale di guasto della macchina (in secondi) per intervallo di tempo specificato.
+ `Stop_Time = statetime(Stop)`— Il tempo di arresto totale pianificato della macchina (in secondi) per intervallo di tempo specificato.
+ `Run_Time = statetime(Running)`— Il tempo totale di funzionamento della macchina (in secondi) senza problemi per un intervallo di tempo specificato.
+ `Down_Time = Idle_Time + Fault_Time + Stop_Time`— Il tempo di inattività totale della macchina (in secondi) nell'intervallo di tempo specificato, calcolato come somma degli stati della macchina diversi da. `Run_Time`
+ `Availability = Run_Time / (Run_Time + Down_Time)`— Il tempo di attività della macchina o la percentuale di tempo programmato in cui la macchina è disponibile a funzionare nell'intervallo di tempo specificato.
+ `Quality = Successes / (Successes + Failures)`— La percentuale della macchina di imballaggi riempiti con successo negli intervalli di tempo specificati.
+ `Performance = ((Successes + Failures) / Run_Time) / Ideal_Run_Rate`— Le prestazioni della macchina nell'intervallo di tempo specificato, espresse in percentuale rispetto alla velocità di esecuzione ideale (in secondi) per il processo.
Ad esempio, l'`Ideal_Run_Rate` potrebbero essere 60 pacchetti al minuto (1 pacchetto al secondo). Se il `Ideal_Run_Rate` valore è espresso al minuto o all'ora, è necessario dividerlo per il fattore di conversione unitario appropriato, espresso `Run_Time` in secondi.
+ `OEE = Availability * Quality * Performance`— L'efficacia complessiva dell'attrezzatura della macchina nell'intervallo di tempo specificato. Questa formula calcola l'OEE come una frazione su 1.
**Nota**
Se l'OEE è definito come una trasformazione, i valori di output vengono calcolati per ciascuno dei valori di input. Esiste la possibilità di generare valori imprevisti poiché la valutazione della trasformazione considera gli ultimi valori disponibili per tutte le proprietà che contribuiscono alla formula. Per gli aggiornamenti delle proprietà con lo stesso timestamp, i valori di output possono essere sovrascritti dagli aggiornamenti di altre proprietà in entrata. Ad esempio, quando si calcolano Disponibilità, Qualità e Prestazioni, l'OEE viene calcolato con gli ultimi punti dati disponibili per le altre due proprietà. Questi valori che contribuiscono condividono i timestamp e causano valori di output errati dell'OEE. L'ordine non è garantito per il calcolo delle trasformazioni.
# 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**.
# Integra i dati in SiteWise Edge utilizzando un gateway V3 abilitato per MQTT
Questo tutorial illustra l'integrazione di dispositivi e sensori di terze parti che utilizzano il protocollo di messaggistica MQTT con il gateway V3 abilitato per AWS IoT SiteWise MQTT. Imparerai come configurare un AWS IoT SiteWise edge gateway per raccogliere e monitorare i dati dai tuoi dispositivi abilitati per MQTT. AWS IoT SiteWise consente di raccogliere, elaborare e monitorare i dati delle apparecchiature industriali. Utilizza le funzionalità SiteWise Edge per ottimizzare le operazioni IoT industriali e trasformare i dati grezzi in informazioni fruibili.
In questo tutorial, utilizziamo i dati di una dimostrazione di un parco eolico per illustrare i concetti chiave. Dopo aver acquisito familiarità con il processo, puoi ripetere il tutorial con i tuoi dati.
Dopo aver completato questo tutorial, puoi eseguire le seguenti operazioni:
+ Imposta e configura un gateway V3 abilitato per MQTT per ricevere dati da dispositivi industriali
+ Elaborate e convalidate i messaggi MQTT in arrivo dalle vostre apparecchiature all'edge
+ Visualizza i dati del dispositivo AWS IoT SiteWise utilizzando una piattaforma di visualizzazione di terze parti
+ Invia i dati elaborati dal tuo edge gateway a per consentire l' Cloud AWS archiviazione centralizzata e ulteriori analisi
Inoltre, puoi sfruttare le funzionalità del tuo edge gateway connettendoti ad altri AWS IoT servizi per eseguire le seguenti attività:
+ Configura AWS IoT le regole per instradare i dati verso servizi come [Amazon S3](https://aws.amazon.com/s3/), [Amazon Timestream](https://aws.amazon.com/timestream/) e. [AWS Lambda](https://aws.amazon.com/lambda/)
+ Utilizzalo [AWS IoT Device Defender](https://aws.amazon.com/iot-device-defender/)per gestire e aggiornare in remoto le configurazioni del gateway.
+ Implementa l'autenticazione e l'autorizzazione sicure dei dispositivi utilizzando funzionalità AWS IoT di sicurezza. Per ulteriori informazioni, consulta [AWS IoT la sezione Sicurezza](https://docs.aws.amazon.com/iot/latest/developerguide/iot-security.html) nella *Guida per AWS IoT gli sviluppatori*.
+ Crea avvisi e notifiche automatici in base ai dati delle apparecchiature. Per ulteriori informazioni, consulta la sezione [Regole AWS IoT nella Guida per](https://docs.aws.amazon.com/iot/latest/developerguide/iot-rules.html) *gli AWS IoT sviluppatori*.
**Nota**
Questo tutorial fa riferimento a servizi, strumenti e documentazione di terze parti. AWS non è un fornitore o fornitore di prodotti o servizi di terze parti e non può garantire l'accuratezza delle informazioni fornite da fornitori esterni. Valuta e convalida tutti gli strumenti di terze parti prima della distribuzione.
**Topics**
+ [Prerequisiti](#gateway-tutorial-prerequisites)
+ [Fase 1: Creare una politica AWS IoT](#gateway-tutorial-create-iot-policy)
+ [Fase 2: Creare e configurare qualsiasi AWS IoT cosa](#gateway-tutorial-create-and-configure-aws-iot-thing)
+ [Fase 3: Configurazione del gateway V3 abilitato per SiteWise Edge MQTT](#gateway-tutorial-configure-your-edge-gateway)
+ [Passaggio 4: Installare il software SiteWise Edge gateway](#install-gateway-software)
+ [Fase 5: Configurare il broker EMQX per la connessione ad applicazioni esterne](#configure-emqx-broker-external-applications)
+ [Fase 6: Pubblicazione dei dati con Mosquitto](#add-mqtt-data-source)
+ [Fase 7: Specificare le destinazioni](#specify-destinations)
+ [Passaggio 8: Specificare i filtri di percorso](#specify-path-filters)
+ [Fase 9: Configurazione delle risorse AWS IoT](#configure-iot-resources)
+ [Passaggio 10: visualizza i tuoi dati](#visualize-your-data)
+ [Passaggio 11: ripulisci le risorse dopo il tutorial](#tutorial-clean-up-resources)
+ [Risorse aggiuntive](#additional-resources)
## Prerequisiti
Per completare questo tutorial, è necessario quanto segue:
+ Un Account AWS. Se non lo hai, consultare [Configura un account AWS](getting-started.md#set-up-aws-account).
+ Un utente AWS Identity and Access Management (IAM) con autorizzazioni di amministratore. Per ulteriori informazioni, consulta [Gestione delle identità e degli accessi per AWS IoT SiteWise](security-iam.md).
+ La versione più recente di quella Python installata sul tuo dispositivo.
**Importante**
Questo tutorial richiede l'uso di risorse create nel tutorial [Ingest data](ingest-data-from-iot-things.md). È necessario completarlo prima di procedere con questo tutorial.
## Fase 1: Creare una politica AWS IoT
Questo tutorial utilizza la AWS IoT politica che hai creato nel tutorial [Ingest data](ingest-data-from-iot-things.md). Questa politica stabilisce le regole di sicurezza per i tuoi dispositivi e crea una rappresentazione digitale dei tuoi dispositivi e sensori esterni. AWS IoT La policy consente ai dispositivi di terze parti di inviare dati AWS IoT Core utilizzando MQTT (Message Queuing Telemetry Transport). [Per ulteriori informazioni sui messaggi MQTT, consulta Cos'è MQTT?](https://aws.amazon.com/what-is/mqtt/) .
------
#### [ Console ]
Garantire il completamento di una AWS IoT politica. Per istruzioni dettagliate, consulta la [Fase 1](ingest-data-from-iot-things.md#ingestion-tutorial-create-iot-policy) del tutorial [Ingest data](ingest-data-from-iot-things.md).
**Per verificare di disporre di una politica attiva AWS IoT **
1. Passare alla [console AWS IoT](https://console.aws.amazon.com/iot/).
1. Nel riquadro di navigazione a sinistra, scegli **Titoli**, quindi **Politiche**.
1. Scegli la politica che hai creato. Ad esempio, **SiteWiseTutorialDevicePolicy**.
1. Verifica che lo stato della politica sia indicato come Attivo.
------
#### [ AWS CLI ]
Garantire il completamento di una AWS IoT politica. Per istruzioni dettagliate, consulta la [Fase 1](ingest-data-from-iot-things.md#ingestion-tutorial-create-iot-policy) del tutorial [Ingest data](ingest-data-from-iot-things.md).
Utilizzate il seguente comando AWS CLI [get-policy](https://docs.aws.amazon.com/cli/latest/reference/iot/get-policy.html) nel Command *Reference* per verificare di avere una policy attiva:AWS CLI AWS IoT
```
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 interagire con le ombre dei dispositivi, i AWS IoT 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 questo passaggio, registra il tuo dispositivo edge come AWS IoT oggetto e genera i certificati e le chiavi necessari per una comunicazione sicura con AWS IoT SiteWise Edge. Questo processo pone le basi affinché il dispositivo invii dati di terze parti tramite il gateway V3 abilitato per MQTT.
------
#### [ Console ]
Garantite il completamento delle fasi di creazione e configurazione di qualsiasi cosa. AWS IoT Per istruzioni dettagliate, consulta la [Fase 2](ingest-data-from-iot-things.md#rule-tutorial-create-iot-thing) del tutorial [Ingest data](ingest-data-from-iot-things.md).
**Per verificare di avere un elemento attivo AWS IoT **
1. Passare alla [console AWS IoT](https://console.aws.amazon.com/iot/).
1. Nel riquadro di navigazione a sinistra, scegli **Tutti i dispositivi**, quindi **Oggetti**.
1. Scegli l'oggetto che hai creato. Ad esempio, **SiteWiseTutorialDevice1**.
1. In **Certificati**, conferma che lo stato sia indicato come attivo.
------
#### [ AWS CLI ]
Garantisci il completamento delle fasi di creazione e configurazione di qualsiasi AWS IoT cosa. Per istruzioni dettagliate, consulta la [Fase 2](ingest-data-from-iot-things.md#rule-tutorial-create-iot-thing) del tutorial [Ingest data](ingest-data-from-iot-things.md).
Utilizzate il seguente AWS CLI comando per verificare di disporre di una AWS IoT policy attiva:
```
aws iot describe-thing --thing-name "SiteWiseTutorialDevice1"
```
------
Dopo aver completato questi passaggi, puoi connettere in modo sicuro il tuo dispositivo a AWS IoT SiteWise Edge. Hai creato una directory locale per archiviare i certificati e le chiavi che hai generato per l'autenticazione MQTT. Il dispositivo è registrato come AWS IoT dispositivo nella [AWS IoT console](https://console.aws.amazon.com/iot/) ed è pronto per integrare i dati con SiteWise Edge. Puoi connettere le tue apparecchiature industriali o altri dispositivi alla AWS IoT piattaforma e iniziare a importare dati in SiteWise Edge.
## Fase 3: Configurazione del gateway V3 abilitato per SiteWise Edge MQTT
In questo passaggio, create il gateway V3 abilitato per AWS IoT SiteWise Edge MQTT e configuratelo per ricevere dati dal broker EMQX. Il gateway funge da ponte tra i dispositivi e. AWS IoT Ciò consente di elaborare i dati localmente sulla periferia prima di inviarli a Cloud AWS. Questa configurazione riduce la larghezza di banda e riduce i ritardi nell'elaborazione del cloud.
------
#### [ Console ]
**Per creare un gateway V3 abilitato per AWS IoT SiteWise MQTT**
1. Accedere alla [Console di gestione AWS](https://console.aws.amazon.com/) e aprire la [console AWS IoT SiteWise](https://console.aws.amazon.com/iotsitewise/).
1. **Nel riquadro di navigazione a sinistra, scegli **Edge gateway, quindi scegli Crea gateway**.**
1. In **Deployment target**, scegli **Self-hosted gateway**.
1. *In Opzioni gateway self-hosted, scegli Gateway V3 **abilitato per MQTT, consigliato**.*
1. **In** Configurazione del gateway:
1. In **Nome gateway**, inserisci un nome per il tuo gateway. Ad esempio, **SiteWise Tutorial Device Gateway**.
1. Nel **sistema operativo del dispositivo Greengrass**, seleziona l'opzione appropriata per il tuo dispositivo.
1. In **Configurazione avanzata**:
1. Scegli **Configurazione predefinita**.
1. Immettere un nome per il dispositivo principale Greengrass o utilizzare il nome generato da. AWS IoT SiteWise
1. Selezionare **Create gateway (Crea gateway)**.
1. Nella finestra di dialogo di conferma, scegli **Genera e scarica** per generare un programma di installazione per il tuo gateway SiteWise Edge. Per ulteriori informazioni, consulta [Creare un gateway SiteWise Edge ospitato autonomamente](create-gateway-ggv2.md#configure-gateway-console).
**avvertimento**
Archivia il file di installazione in un luogo sicuro. Questo file non può essere rigenerato ed è necessario per completare la configurazione del gateway nei passaggi successivi.
------
#### [ AWS CLI ]
Utilizzalo AWS CLI per creare un gateway ospitato autonomamente. È necessario fornire un nome per il gateway, specificare la piattaforma e la versione del gateway. Per ulteriori informazioni, consulta [CreateGateway](https://docs.aws.amazon.com/iot-sitewise/latest/APIReference/API_CreateGateway.html) nella *documentazione di riferimento dell’API AWS IoT SiteWise *.
Per utilizzare questo esempio, sostituisci i segnaposto inseriti dall’utente con le informazioni appropriate.
```
aws iotsitewise create-gateway \
--gateway-name SiteWise Tutorial Device Gateway \
--gateway-platform greengrassV2={coreDeviceThingName=your-core-device-thing-name, coreDeviceOperatingSystem=LINUX_AMD64} \
--gateway-version 3 \
[--cli-input-json your-configuration]
```
+ `gateway-name`— Un nome univoco per il gateway, ad esempio`SiteWise Tutorial Device Gateway`.
+ `gateway-platform`— Entra`greengrassV2`. Per ulteriori informazioni, consulta [CreateGateway](https://docs.aws.amazon.com/iot-sitewise/latest/APIReference/API_CreateGateway.html) nella *documentazione di riferimento dell’API AWS IoT SiteWise *.
+ `coreDeviceThingName`— Il nome dell' AWS IoT oggetto per il tuo dispositivo AWS IoT Greengrass V2 principale. Ad esempio, `SiteWiseTutorialDevice1`.
+ `coreDeviceOperatingSystem`— Il sistema operativo del dispositivo principale in AWS IoT Greengrass V2. Per la versione 3 del gateway è necessario specificare il sistema operativo. Le opzioni includono:`LINUX_AARCH64`, e. `LINUX_AMD64` `WINDOWS_AMD64`
+ `gateway-version`— La versione del gateway.
+ `3`Utilizzatelo per la versione gateway per creare un gateway V3 abilitato per MQTT.
+ `cli-input-json`— Un file JSON contenente i parametri della richiesta.
Utilizzate il seguente AWS CLI comando per verificare che il gateway sia stato creato correttamente:
```
aws iotsitewise describe-gateway --gateway-id your-gateway-id
```
------
## Passaggio 4: Installare il software SiteWise Edge gateway
Per installare il software del gateway, utilizza il pacchetto di installazione scaricato nel passaggio precedente. Il processo di installazione configura i componenti necessari, avvia il servizio di base Greengrass e registra il dispositivo con. AWS IoT Greengrass Al termine dell'installazione, verifica che il gateway sia visualizzato nella [AWS IoT SiteWise console](https://console.aws.amazon.com/iotsitewise/) sotto **Edge gateway** e che il servizio Greengrass funzioni correttamente sul dispositivo.
Per istruzioni dettagliate, vedi [Installa il software AWS IoT SiteWise Edge gateway sul tuo dispositivo locale](install-gateway-software-on-local-device.md).
## Fase 5: Configurare il broker EMQX per la connessione ad applicazioni esterne
**Nota**
È necessario aver installato il gateway V3 abilitato per SiteWise Edge MQTT prima di procedere. Il gateway fornisce l'infrastruttura e le impostazioni di sicurezza necessarie per configurare il broker EMQX. La configurazione del broker fallirà senza una distribuzione attiva del gateway.
Configura il broker EMQX per consentire una comunicazione sicura tra i tuoi dispositivi IoT e le applicazioni esterne. Il broker EMQX funge da hub di messaggistica centrale che indirizza i dati tra dispositivi IoT, gateway e applicazioni. Il broker EMQX garantisce la consegna affidabile dei messaggi sul gateway e sulle applicazioni connesse all'edge. Per ulteriori informazioni, consulta [Connect applicazioni esterne al broker EMQX](connect-external-applications-emqx.md).
**Per configurare il broker EMQX**
1. Configurare il broker EMQX. Per istruzioni dettagliate sulla configurazione, seguire i passaggi 1-14 in [Aggiornamento della configurazione di distribuzione EMQX per l'](https://docs.aws.amazon.com/iot-sitewise/latest/userguide/configure-emqx-broker.html#update-emqx-broker-authentication)autenticazione.
1. Imposta gli argomenti MQTT per il monitoraggio dei parchi eolici. Per ulteriori informazioni sui requisiti MQTT, vedere. [Requisiti dell'argomento MQTT](connect-broker-payload-format.md#connect-broker-mqtt-requirements)
1. Utilizzo della CPU: `SiteWiseTutorialDevice/cpu`
1. Utilizzo della memoria: `SiteWiseTutorialDevice/memory`
1. Timestamp: `SiteWiseTutorialDevice/timestamp`
1. Rivedi la configurazione e completa la distribuzione.
1. Scegli **Conferma** per salvare le impostazioni.
1. Scegli **Avanti** fino a raggiungere la fase di **revisione**.
1. Nella pagina **Review (Verifica)**, scegli **Deploy (Distribuisci)**.
1. Attendi che la distribuzione venga completata correttamente prima di procedere.
1. Prepara i messaggi utilizzando il formato payload da inviare al broker EMQX. Per ulteriori informazioni sulla strutturazione dei payload, vedere [Aggiornamento della configurazione di distribuzione EMQX per l'autenticazione](https://docs.aws.amazon.com/iot-sitewise/latest/userguide/configure-emqx-broker.html#update-emqx-broker-authentication).
1. Implementa le seguenti misure di sicurezza:
1. Utilizza la crittografia Transport Layer Security (TLS) (porta 8833) per proteggere i dati in transito. Per ulteriori informazioni, consulta [Configura TLS per connessioni sicure al broker EMQX su Edge AWS IoT SiteWise](connect-app-to-broker.md#configure-tls-emqx-broker).
1. Configura l'autenticazione con nome utente e password per verificare l'identità dei dispositivi. Questa misura di sicurezza aiuta a proteggere i dati e garantisce che solo i dispositivi autorizzati possano connettersi al sistema. Per ulteriori informazioni, consulta [Abilita l'autenticazione con nome utente e password](configure-emqx-broker.md#emqx-broker-username-password-auth).
EMQX consente di creare regole di autorizzazione basate su identificatori come nome utente, indirizzo IP o ID client. Ciò è utile per controllare l'accesso ai dati. Per ulteriori informazioni, consulta [Imposta le regole di autorizzazione per AWS IoT SiteWise Edge in EMQX](authorization-rules-emqx-broker.md).
Dopo una corretta implementazione, il broker EMQX è configurato e pronto per connettersi in modo sicuro con applicazioni esterne.
**Nota**
Il formato del payload deve seguire una struttura specifica affinché AWS IoT SiteWise Edge elabori e inserisca correttamente i dati. Per ulteriori informazioni sulla struttura richiesta, vedere. [Struttura del payload JSON](connect-broker-payload-format.md#connect-broker-json-payload)
**Esempio: aggiungere CPU, memoria e payload JSON con timestamp**
**Payload JSON della CPU**
```
{
"propertyAlias": "SiteWiseTutorialDevice/cpu",
"propertyValues": [
{
"quality": "GOOD",
"timestamp": {
"offsetInNanos": 0,
"timeInSeconds": 1753206441
},
"value": {
"integerValue": 45.2
}
}
]
}
```
**Payload JSON di memoria**
```
{
"propertyAlias": "SiteWiseTutorialDevice/memory",
"propertyValues": [
{
"quality": "GOOD",
"timestamp": {
"offsetInNanos": 0,
"timeInSeconds": 1753206441
},
"value": {
"integerValue": 67.8
}
}
]
}
```
**Payload JSON con timestamp**
```
{
"propertyAlias": "SiteWiseTutorialDevice/timestamp",
"propertyValues": [
{
"quality": "GOOD",
"timestamp": {
"offsetInNanos": 0,
"timeInSeconds": 1753206441
},
"value": {
"integerValue": 23.5
}
}
]
}
```
**Nota**
Ogni payload JSON deve essere pubblicato separatamente come messaggio individuale. Non combinare più valori di proprietà in un unico messaggio. Invia ogni payload di CPU, memoria e timestamp come una pubblicazione MQTT distinta.
Il payload definisce la struttura JSON richiesta che i dispositivi IoT devono utilizzare per inviare i dati del dispositivo tramite il broker EMQX a Edge. SiteWise Questo formato garantisce la possibilità di identificare AWS IoT SiteWise i dispositivi ed elaborare le letture dei sensori. Dopo aver implementato queste configurazioni e strutture di carico utile, il sistema di monitoraggio del parco eolico è pronto per raccogliere ed elaborare i dati.
## Fase 6: Pubblicazione dei dati con Mosquitto
Dopo aver creato il gateway V3 abilitato per MQTT, configura Eclipse Mosquitto per inviare i dati di test a Edge. SiteWise Mosquitto è un broker di messaggi MQTT open source che utilizza il protocollo MQTT per una messaggistica leggera tra dispositivi. Il client Mosquitto consente di pubblicare messaggi su argomenti MQTT, simulando i dati dei sensori dei parchi eolici. Utilizzando Mosquitto, simula i dati del dispositivo senza richiedere servizi di terze parti o apparecchiature aggiuntive. Per ulteriori informazioni, consulta la [documentazione](https://mosquitto.org) sul sito Web ufficiale di Eclipse Mosquitto. In questo tutorial, i dati locali del tutorial [Ingest data e i dati](ingest-data-from-iot-things.md) fittizi vengono utilizzati a scopo dimostrativo.
**Usa il client CLI Mosquitto per testare il broker Edge EMQX SiteWise **
1. Installa Mosquitto sul tuo dispositivo locale. Per istruzioni dettagliate, consulta [Scarica Mosquitto sul sito Web ufficiale di Eclipse Mosquitto](https://mosquitto.org/download/).
1. Per ulteriori informazioni sulla connessione di applicazioni esterne per il trasferimento di dati industriali, vedere. [Connect applicazioni esterne al broker EMQX](connect-external-applications-emqx.md)
**Importante**
Assicuratevi che le impostazioni di connessione MQTT che configurate qui corrispondano alle impostazioni utilizzate nel comando di pubblicazione di Mosquitto. L'host deve essere l'indirizzo IP o il nome host del gateway Edge. SiteWise La porta è in genere 1883 (o 8883 se si utilizza SSL/TLS).
Usa Mosquitto per pubblicare i dati dei test. Apri una riga di comando ed esegui i seguenti comandi:
**Esempio: proprietà CPU**
```
mosquitto_pub -h localhost -p 1883 -t "SiteWiseTutorialDevice/cpu" -m '{
"propertyAlias": "SiteWiseTutorialDevice/cpu",
"propertyValues": [
{
"quality": "GOOD",
"timestamp": {
"timeInSeconds": 1753206441,
"offsetInNanos": 0
},
"value": {
"integerValue": 45.2
}
}
]
}'
```
**Esempio: proprietà di memoria**
```
mosquitto_pub -h localhost -p 1883 -t "SiteWiseTutorialDevice/memory" -m '{
"propertyAlias": "SiteWiseTutorialDevice/memory",
"propertyValues": [
{
"quality": "GOOD",
"timestamp": {
"timeInSeconds": 1753206441,
"offsetInNanos": 0
},
"value": {
"integerValue": 72.1
}
}
]
}'
```
**Esempio: proprietà Timestamp**
```
mosquitto_pub -h localhost -p 1883 -t "SiteWiseTutorialDevice/timestamp" -m '{
"propertyAlias": "SiteWiseTutorialDevice/timestamp",
"propertyValues": [
{
"quality": "GOOD",
"timestamp": {
"timeInSeconds": 1753206441,
"offsetInNanos": 0
},
"value": {
"integerValue": 1683000000
}
}
]
}'
```
**Nota**
L'utilizzo di `localhost` come indirizzo del broker EMQX è solo a scopo dimostrativo. Negli ambienti di produzione o durante la connessione da dispositivi esterni, è necessario utilizzare l'indirizzo del broker EMQX appropriato per la configurazione di distribuzione specifica. Per istruzioni dettagliate sulla connessione, vedere. [Connect un'applicazione al broker EMQX su Edge AWS IoT SiteWise](connect-app-to-broker.md)
## Fase 7: Specificare le destinazioni
In questo passaggio, specifica le destinazioni per determinare dove indirizzare i dati di origine. Utilizzalo AWS IoT SiteWise con il buffering di Amazon S3 come destinazione. Questa opzione offre un modo scalabile per archiviare ed elaborare i dati IoT.
------
#### [ Console ]
**Per aggiungere destinazioni**
1. Vai alla [AWS IoT SiteWise console](https://console.aws.amazon.com/iotsitewise/) e seleziona **Edge gateway**.
1. In **SiteWise Tutorial Device Gateway**, scegli **Aggiungi destinazioni**.
1. In **Dettagli di destinazione**, scegli **AWS IoT SiteWise bufferizzato con Amazon** S3. Per ulteriori informazioni sui tipi di destinazione, consulta [AWS IoT SiteWise Gateway](gw-destinations.md#source-destination) Destinations.
1. In **Nome destinazione**, inserisci un nome per la tua destinazione, ad esempio`SiteWise Tutorial S3 Destination`.
1. **Nelle impostazioni di caricamento S3**, inserisci la posizione del bucket S3. Ad esempio, `s3://sitewise-tutorial-mqtt-data-[your-account-id]`. *Per ulteriori informazioni su Amazon S3, consulta [Creazione, configurazione e utilizzo dei bucket Amazon S3 nella Guida per l'utente di Amazon Simple](https://docs.aws.amazon.com/AmazonS3/latest/userguide/creating-buckets-s3.html) Storage Service.*
1. In **Frequenza di caricamento dei dati**, inserisci un valore compreso tra 1 minuto e 30 giorni. Ad esempio, `1 minute`.
1. In **Impostazioni di archiviazione dei dati**:
1. Deseleziona **Copia i dati nell'archivio**. Sebbene questa impostazione sia consigliata per gli ambienti di produzione, non è necessaria per questo tutorial. Quando deselezioni questa opzione, l'opzione **Elimina dati da S3** viene deselezionata automaticamente.
1. Seleziona **Aggiungi destinazione**.
**Nota**
Questo tutorial utilizza un intervallo di 1 minuto per i test. Dopo aver completato il tutorial, puoi regolare questo intervallo in base alle tue esigenze di produzione o eliminarlo per evitare costi aggiuntivi.
------
#### [ AWS CLI ]
**Esempio: creazione di una nuova AWS IoT SiteWise destinazione con buffer utilizzando Amazon S3**
Usa [update-gateway-capability-configuration](https://docs.aws.amazon.com/cli/latest/reference/iotsitewise/update-gateway-capability-configuration.html)nel *AWS CLI Command Reference* per configurare l'editore. Imposta il parametro `capabilityNamespace` su `iotsitewise:publisher:3`.
```
{
"sources": [
{
"type": "MQTT"
}
],
"destinations": [
{
"type": "SITEWISE_BUFFERED",
"name": "your-s3-destination-name",
"config": {
"targetBucketArn": "arn:aws:s3:::amzn-s3-demo-bucket/Optional/SomeFolder",
"publishPolicy": {
"publishFrequency": "1m",
"localSizeLimitGB": 10
},
"siteWiseImportPolicy": {
"enableSiteWiseStorageImport": true,
"enableDeleteAfterImport": true,
"bulkImportJobRoleArn": "arn:aws:iam::123456789012:role/your-role-name"
}
},
"filters": [
{
"type": "PATH",
"config": {
"paths": [
"#"
]
}
}
]
}
]
}
```
Per ulteriori informazioni sulle destinazioni, vedere[Aggiungi una destinazione AWS IoT SiteWise con buffer utilizzando Amazon S3](destinations-buffered.md).
------
## Passaggio 8: Specificare i filtri di percorso
In questo passaggio, configurate i filtri di percorso per specificare quali argomenti MQTT monitorare per i dati del dispositivo del parco eolico.
I filtri di percorso seguono la specifica dei caratteri jolly dell'argomento MQTT, che supporta due caratteri speciali:
+ `+`— Questo simbolo rappresenta un carattere jolly a livello singolo, che corrisponde a qualsiasi stringa a un singolo livello.
+ `#`— Questo simbolo rappresenta un jolly a più livelli, che corrisponde a qualsiasi numero di livelli nella gerarchia degli argomenti.
**Nota**
Per ulteriori informazioni su altri filtri di percorso, vedere. [Caratteri speciali nei nomi dei filtri di percorso](gw-destinations.md#path-filters-special-characters)
------
#### [ Console ]
**Per configurare i filtri di percorso**
In **Filtri Path**:
1. Vai alla [AWS IoT SiteWise console](https://console.aws.amazon.com/iotsitewise/) e seleziona **Edge gateway**.
1. In **SiteWise Tutorial Device Gateway**, scegli **Aggiungi destinazioni**.
1. Scegli **Aggiungi filtri di percorso** per inserire manualmente i seguenti filtri di percorso:
+ `SiteWiseTutorialDevice/#`
+ `windfarm/+/turbine/+/performance/#`
+ `cpu/+/idle-time`
+ `cpu/+/interruption-count/+`
+ `+/memory/consumption`
+ `timestamp/+/measurement`
+ `device/+/status/+`
+ `system/+/performance-log`
1. Seleziona **Aggiungi destinazione**.
Per ulteriori informazioni sulle best practice per i filtri di percorso, consulta[Procedure consigliate per i filtri di percorso](gw-destinations.md#create-effective-path-filters).
------
#### [ AWS CLI ]
Utilizza i seguenti AWS CLI comandi per configurare i filtri di percorso:
**Esempio 1: dati del dispositivo che utilizzano caratteri jolly**
```
{
"destinations": [
{
"name": "All Device Data Destination"
}
],
"filters": [
{
"type": "PATH",
"config": {
"paths": [
"SiteWiseTutorialDevice/#",
"windfarm/+/turbine/+/performance/#"
]
}
}
]
}
```
Questa configurazione del filtro di percorso utilizza caratteri jolly a più livelli (\$1) per acquisire tutti i dati SiteWiseTutorialDevice e tutti i dati sulle prestazioni di qualsiasi turbina del parco eolico.
**Esempio 2: prestazioni della CPU e della memoria**
```
{
"destinations": [
{
"name": "Performance Metrics Destination"
}
],
"filters": [
{
"type": "PATH",
"config": {
"paths": [
"cpu/+/idle-time",
"+/memory/consumption",
"cpu/+/interruption-count/+"
]
}
}
]
}
```
Questo esempio acquisisce varie metriche della CPU (tempo di inattività e conteggio delle interruzioni) e dati sul consumo di memoria tra i dispositivi.
**Esempio 3: diagnostica del dispositivo**
```
{
"destinations": [
{
"name": "Device Diagnostics Destination"
}
],
"filters": [
{
"type": "PATH",
"config": {
"paths": [
"device/+/status/+",
"system/+/performance-log"
]
}
}
]
}
```
Questa configurazione utilizza il carattere `+` jolly per acquisire dati diagnostici da più dispositivi, in particolare i registri delle prestazioni del sistema e gli aggiornamenti dello stato del dispositivo.
Questi tre filtri di percorso corrispondono agli argomenti MQTT utilizzati per pubblicare i dati di test con Mosquitto. I filtri assicurano che il gateway SiteWise Edge acquisisca ed elabori i messaggi MQTT pertinenti. Per ulteriori informazioni su come aggiungere filtri di percorso, consulta. [Aggiungi filtri di percorso alle destinazioni AWS IoT SiteWise Edge](destinations-add-path-filters.md)
------
## Fase 9: Configurazione delle risorse AWS IoT
In questa fase, create i modelli e gli AWS IoT SiteWise asset necessari per rappresentare i dispositivi simulati di terze parti e abilitare l'ingestione dei dati attraverso il gateway perimetrale.
Prima di iniziare questo passaggio, dovreste aver completato i passaggi da 3 a 8 del tutorial [Ingest](ingest-data-from-iot-things.md) data. Questi passaggi stabiliscono i componenti fondamentali per l'integrazione dei dati di terze parti tramite il gateway V3 abilitato per MQTT. È inoltre necessario impostare regole che definiscono il modo in AWS IoT SiteWise cui confluiscono i dati dei sensori ed eseguire uno script client del dispositivo che simula i dati dei parchi eolici industriali.
**Per convalidare la configurazione delle risorse AWS IoT**
1. Usa il seguente AWS CLI comando per verificare di aver creato e configurato correttamente il SiteWise Tutorial Device Model e SiteWise il Tutorial Device Fleet Model:
```
aws iotsitewise describe-asset-model --asset-model-id your-device-model-id
```
Utilizzate il seguente AWS CLI comando per recuperare l'ID dei vostri modelli di asset:
```
aws iotsitewise list-asset-models
```
1. Utilizzate il seguente AWS CLI comando per verificare di aver creato e configurato correttamente la risorsa SiteWise Tutorial Device 1 e la risorsa SiteWise Tutorial Device Fleet 1:
```
aws iotsitewise describe-asset --asset-id your-asset-id
```
Utilizzate il seguente AWS CLI comando per recuperare l'ID delle vostre risorse:
```
aws iotsitewise list-assets
```
## Passaggio 10: visualizza i tuoi dati
Configura la versione open source di Grafana per visualizzare i dati dei dispositivi del tuo parco eolico. Grafana è una piattaforma di visualizzazione che mostra i dati operativi in tempo reale. Queste dashboard consentono di monitorare l'efficienza operativa e identificare le esigenze di manutenzione dell'infrastruttura. Per ulteriori informazioni sull'integrazione, consulta[Integrazione AWS IoT SiteWise con Grafana](grafana-integration.md).
**Per configurare Grafana**
1. Per istruzioni su come scaricare e installare l'ultima versione di Grafana, consulta Installa [Grafana sul sito Web ufficiale di Grafana](https://grafana.com/docs/grafana/latest/setup-grafana/installation/#install-grafana).
1. Per istruzioni di configurazione dettagliate specifiche per il tuo sistema operativo, consulta [Configura Grafana sul sito Web](https://grafana.com/docs/grafana/latest/setup-grafana/configure-grafana/#configure-grafana) ufficiale di Grafana.
1. Configura la fonte di AWS IoT SiteWise dati. Questo ti permette di configurare il AWS IoT SiteWise plugin sul tuo server Grafana. Per istruzioni dettagliate su come utilizzare il plug-in, consulta [Connect a an AWS IoT SiteWise data source](https://docs.aws.amazon.com/grafana/latest/userguide/using-iotsitewise-in-AMG.html) nella *Amazon Managed Grafana User* Guide.
**Importante**
Assicurati di avere l'ultima versione di Grafana per la compatibilità con la fonte di AWS IoT SiteWise dati.
Dopo aver completato questi passaggi, puoi creare e personalizzare i dashboard Grafana per visualizzare le metriche operative del tuo parco eolico. Ciò consente di monitorare e analizzare le prestazioni del parco eolico in periferia in tempo reale.
**Nota**
Questo tutorial utilizza la versione open source di Grafana AWS , ma offre anche Amazon Managed Grafana per ambienti di produzione. Amazon Managed Grafana è un servizio completamente gestito che elimina la necessità di configurare, configurare e gestire i propri server Grafana.
Prendi in considerazione l'aggiornamento ad Amazon Managed Grafana quando sei pronto a scalare la tua soluzione. Per istruzioni dettagliate su come collegare SiteWise i dati a Grafana, consulta il tutorial [Visualizza e condividi dati in Grafana](visualize-with-grafana.md).
Hai completato il tutorial. In questa procedura, hai configurato AWS IoT SiteWise Edge per integrare i dati di dispositivi di terze parti utilizzando un gateway V3 abilitato per MQTT. Questa configurazione consente di raccogliere, elaborare e visualizzare i dati delle apparecchiature industriali all'edge, riducendo la latenza e i costi operativi. Utilizzando la demo del parco eolico, hai raccolto ed elaborato metriche operative come i dati sull'utilizzo della CPU e della memoria tramite il tuo gateway V3 abilitato per MQTT.
Per migliorare la tua soluzione IoT, prendi in considerazione la possibilità di esplorare funzionalità avanzate come il rilevamento delle anomalie [Rileva le anomalie con Lookout for Equipment](anomaly-detection.md) sfruttando o integrando altri servizi AWS come Amazon Quick nella [Amazon Quick](https://docs.aws.amazon.com/quicksight/latest/user/welcome.html) *User Guide* per l'analisi avanzata.
## Passaggio 11: ripulisci le risorse dopo il tutorial
Dopo aver completato questo tutorial sull'integrazione dei dati in AWS IoT SiteWise Edge, ripulisci le risorse per evitare di incorrere in costi aggiuntivi.
**Per eliminare risorse gerarchiche in 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. 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).
**Nota**
Le risorse del dispositivo non sono più organizzate in modo gerarchico ora.
1. Scegliere l'asset dispositivo (**SiteWise Tutorial Device 1**).
1. Scegli **Elimina**.
1. Nella finestra di dialogo di conferma, immettete**Delete**, quindi scegliete **Elimina**.
1. Ripetete 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. Elimina il tuo dispositivo e le risorse del parco dispositivi.
1. Nel riquadro di navigazione a sinistra scegliere **Models (Modelli)**.
1. Scegliere l'asset parco istanze dei dispositivi (**SiteWise Tutorial Device Fleet Model**). Non è possibile eliminare un modello se sono presenti asset creati da quel modello.
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, immettete**Delete**, quindi scegliete 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**.
**Per eliminare un bucket Amazon S3**
1. Accedi alla console [Amazon S3](https://console.aws.amazon.com/s3/).
1. Nel riquadro di navigazione a sinistra, scegli **General Purpose Bucket**.
1. Nell'elenco dei bucket, seleziona il pulsante di opzione accanto al bucket che hai creato, quindi scegli **Vuoto** nella parte superiore della pagina.
1. **Nella finestra di dialogo di conferma, conferma l'eliminazione, quindi scegli Vuoto.**
1. Dopo che il bucket è vuoto, scegli **Elimina** per eliminarlo.
1. Nella finestra di dialogo di conferma, inserisci il nome del tuo bucket per confermare l'eliminazione.
1. Scegli **Delete Bucket** (Elimina bucket).
**Per eliminare un gateway SiteWise Edge**
1. Passare alla [console AWS IoT SiteWise](https://console.aws.amazon.com/iotsitewise/).
1. Nel riquadro di navigazione a sinistra, scegli **Edge gateway**.
1. In Gateway, scegli il gateway che hai creato per questo tutorial. Ad esempio, `SiteWise Tutorial Device Gateway`.
1. Scegli **Elimina**.
1. Per confermare che desideri eliminare il gateway, digita **Delete** nella finestra di dialogo di conferma, quindi scegli **Elimina** nella finestra che appare.
**Per eliminare il tuo oggetto IoT**
1. Passare alla [console AWS IoT](https://console.aws.amazon.com/iot/).
1. Nel riquadro di navigazione a sinistra, scegli **Gestisci**, quindi scegli **Cose**.
1. Seleziona l'oggetto IoT che hai creato per questo tutorial. Ad esempio, `SiteWiseTutorialDevice1`.
1. Scegli **Elimina**.
1. Nella finestra di dialogo di conferma, inserisci il nome dell'oggetto, quindi scegli **Elimina**.
**Per disinstallare AWS IoT Greengrass Core**
Disinstalla il software AWS IoT Greengrass Core dal tuo dispositivo locale. Per istruzioni dettagliate, consulta [Disinstallare il software AWS IoT Greengrass Core](https://docs.aws.amazon.com/greengrass/v2/developerguide/uninstall-greengrass-core-v2.html) nella *Guida per gli AWS IoT Greengrass sviluppatori, versione 2*.
**Importante**
La disinstallazione di Greengrass rimuove tutte le configurazioni e i dati locali. Assicurati di aver eseguito il backup di tutte le informazioni importanti prima di procedere.
**(Facoltativo) Per eliminare risorse di terze parti**
Dopo aver completato questo tutorial, valuta la possibilità di chiudere tutte le risorse esterne che hai creato. Questo aiuta a evitare che vengano addebitati addebiti da fornitori terzi.
## Risorse aggiuntive
Per ulteriori informazioni, consulta le seguenti risorse:
+ [Interagisci con altri AWS servizi](interact-with-other-services.md)
+ [Usa i gateway AWS IoT SiteWise Edge](gateways.md)
+ [Risoluzione dei problemi di un gateway SiteWise Edge](troubleshooting-gateway.md)
+ [Le migliori pratiche di sicurezza per AWS IoT SiteWise](security-best-practices.md)
+ [AWS Prezzi IoT](https://aws.amazon.com/iot-sitewise/pricing/)
+ [Inserisci dati in AWS IoT SiteWise](industrial-data-ingestion.md)
+ [Usa i tag in AWS IoT SiteWise](tag-basics.md)
# Visualizza e condividi dati in Grafana
Questo tutorial ti guida nella configurazione del plug-in di origine AWS IoT SiteWise dati con Grafana, una piattaforma di visualizzazione dei dati. Con Grafana, puoi creare dashboard che visualizzano e monitorano i tuoi dati industriali. In questo tutorial, viene utilizzato un set di dati di esempio tratto da una dimostrazione di un parco eolico per illustrare i concetti chiave. Dopo aver acquisito familiarità con il processo, puoi ripetere il tutorial con i tuoi dati.
Dopo aver completato questo tutorial, puoi fare quanto segue:
+ Raccogli, interroga e analizza i dati delle apparecchiature industriali
+ Crea dashboard Grafana interattivi per visualizzare le metriche delle prestazioni degli asset
+ Monitora i dati operativi tramite un'interfaccia unificata
+ Condividi le informazioni con il tuo team utilizzando le funzionalità di collaborazione di Grafana
+ Combina AWS IoT SiteWise i AWS dati con altre fonti di dati come [Amazon CloudWatch o Amazon](https://aws.amazon.com/cloudwatch/) [Timestream](https://aws.amazon.com/timestream/)
**Topics**
+ [Prerequisiti](#grafana-tutorial-prerequisites)
+ [Fase 1: configura il tuo spazio di lavoro Amazon Managed Grafana](#configure-workspace)
+ [Passaggio 2: aggiungi come fonte di dati AWS IoT SiteWise](#add-iot-data-source)
+ [Passaggio 3: crea una dashboard per esplorare e visualizzare i tuoi dati](#explore-your-data)
+ [(opzionale) Fase 4: Impostazione degli avvisi per monitorare le prestazioni](#set-up-alerts)
+ [Passaggio 5: Pulisci le risorse dopo il tutorial](#clean_up_resources)
+ [Risorse aggiuntive](#additional-resources)
## Prerequisiti
Per completare questo tutorial, è necessario quanto segue:
+ Un. Account AWS Se non lo hai, consultare [Configura un account AWS](getting-started.md#set-up-aws-account).
+ Un utente AWS Identity and Access Management (IAM) con autorizzazioni di amministratore. Per istruzioni dettagliate, vedi [Come AWS IoT SiteWise funziona con IAM](security_iam_service-with-iam.md).
+ Una AWS IoT SiteWise demo in esecuzione.
**Nota**
Questo tutorial richiede l'uso di risorse create nella versione [Use the AWS IoT SiteWise demo](getting-started-demo.md). È necessario completarlo prima di procedere con questo tutorial.
La creazione della demo richiede in genere circa 3 minuti. Se la demo non riesce a creare, potrebbe indicare che le autorizzazioni nel tuo AWS account non sono sufficienti. In questo caso, passa a un account con accesso amministrativo. Per ulteriori informazioni sulle autorizzazioni richieste, consultare [Come AWS IoT SiteWise funziona con IAM](security_iam_service-with-iam.md).
**Importante**
Conserva tutte le risorse dimostrative fino al completamento di questo tutorial. L'eliminazione di qualsiasi componente potrebbe interrompere la funzionalità della demo e influire sulla capacità di visualizzare i dati in Grafana.
## Fase 1: configura il tuo spazio di lavoro Amazon Managed Grafana
In questa procedura, crea e configura un'area di lavoro Amazon Managed Grafana per visualizzare i dati del tuo parco eolico.
1. Accedi alla console [Amazon Managed Grafana](https://console.aws.amazon.com/grafana/).
1. Scegli **Crea area di lavoro**.
1. In **Dettagli dell'area di lavoro**, inserisci un nome per il tuo spazio di lavoro, ad esempio. **SiteWiseTutorialDemo**
1. In Versione **Grafana, scegli la versione** più recente. Scegli questa versione per la maggior parte delle up-to-date funzionalità e funzionalità. Per ulteriori informazioni sui diversi set di versioni, consulta [Differenze tra le versioni di Grafana](https://docs.aws.amazon.com/grafana/latest/userguide/version-differences.html) nella *Amazon Managed Grafana* User Guide.
1. Scegli **Next (Successivo)**.
1. Nella sezione **Accesso tramite autenticazione**, scegli **AWS IAM Identity Center**.
+ Se AWS IAM Identity Center nel tuo account non è abilitato, ti verrà prima richiesto di configurarlo. Per istruzioni dettagliate su come configurare l'accesso degli utenti, consulta [gli esempi di policy basate sull'identità per Amazon Managed Grafana nella *Amazon* Managed Grafana](https://docs.aws.amazon.com/grafana/latest/userguide/security_iam_id-based-policy-examples.html#security_iam_id-based-policy-examples-create-workspace-standalone) User Guide.
1. **In **Tipo di autorizzazione**, scegli Servizio gestito.** Amazon Managed Grafana crea e configura automaticamente i ruoli e le autorizzazioni IAM necessari per tutte le fonti di AWS dati che scegli di utilizzare in questo spazio di lavoro. Per gli account dei membri dell'organizzazione, l'opzione Service managed è disponibile solo se l'account è designato come amministratore delegato. *Per informazioni sulla configurazione degli account di amministratore delegato, consulta [Registrare un account membro amministratore delegato](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/stacksets-orgs-delegated-admin.html) nella Guida per l'CloudFormation utente.*
1. In **Opzioni di configurazione di Workspace, esegui** le seguenti azioni:
1. Seleziona **Attiva gli avvisi Grafana**. Con questa impostazione, puoi creare e gestire avvisi tramite un'interfaccia centralizzata nel tuo spazio di lavoro. Per ulteriori informazioni, consulta gli [avvisi Working with Grafana](https://docs.aws.amazon.com/grafana/latest/userguide/alerts-overview.html) nella Amazon *Managed Grafana* User Guide.
1. Seleziona **Attiva la gestione dei plugin**. Ciò ti consente di installare, aggiornare e disinstallare i plugin nel tuo spazio di lavoro. Per ulteriori informazioni, consulta [Estendi il tuo spazio di lavoro con i plugin](https://docs.aws.amazon.com/grafana/latest/userguide/grafana-plugins.html) nella *Amazon Managed Grafana* User Guide.
**Importante**
Assicurati di abilitare la gestione dei plugin. Se non selezioni questa opzione, non puoi aggiungerla AWS IoT SiteWise come fonte di dati nel passaggio successivo.
1. In **Controllo dell'accesso alla rete**, scegli **Apri accesso**. In questo tutorial utilizzi i dati dimostrativi, in modo da rendere l'area di lavoro disponibile al pubblico.
+ **Accesso aperto**: consente all'area di lavoro di essere accessibile al pubblico.
+ **Accesso limitato**: limita l'accesso a intervalli IP o endpoint VPC specifici. Per ulteriori informazioni, consulta [Come funziona la connettività VPC](https://docs.aws.amazon.com/grafana/latest/userguide/AMG-configure-vpc.html#AMG-VPC-how-it-works) nella *Amazon Managed Grafana* User Guide.
1. Scegli **Next (Successivo)**.
1. Nella pagina **Impostazioni delle autorizzazioni gestite dal servizio**, scegli **Account corrente** per fare in modo che Amazon Managed Grafana crei automaticamente policy e autorizzazioni per l'accesso ai AWS dati all'interno del tuo account.
1. In **Origini dati, seleziona**. **AWS IoT SiteWise** Per ulteriori informazioni, consulta [Connect a an AWS IoT SiteWise data source](https://docs.aws.amazon.com/grafana/latest/userguide/using-iotsitewise-in-AMG.html) nella *Amazon Managed Grafana User* Guide.
1. (Facoltativo) In **Canali di notifica**, seleziona **Amazon SNS** per consentire l'invio degli avvisi Grafana tramite Amazon SNS. Questo crea una policy IAM che consente la pubblicazione su Amazon SNS di argomenti con nomi che iniziano con Grafana. È necessario completare la configurazione del canale di notifica in un secondo momento nella console Grafana all'interno dell'area di lavoro.
1. **Conferma i dettagli dell'area di lavoro e scegli Crea area di lavoro.** Questo processo richiede un paio di minuti.
1. Nella scheda **Autenticazione**, in **AWS IAM Identity Center**, assegna utenti o gruppi al tuo spazio di lavoro procedendo come segue:
1. Per assegnare l'utente che gestirà AWS IoT SiteWise i dati, scegli **Assegna nuovo** utente o gruppo. Quindi scegli **Rendi amministratore** dall'elenco a discesa **Azioni** per concedere loro i privilegi amministrativi.
**Importante**
Per gestire l'area di lavoro Grafana, devi assegnare il `Admin` ruolo ad almeno un utente. Questo utente avrà pieno accesso alla console dell'area di lavoro Grafana.
Ora hai impostato e configurato il tuo spazio di lavoro Grafana. Nella fase successiva, puoi aggiungerlo AWS IoT SiteWise come fonte di dati e iniziare a creare visualizzazioni per i dati del tuo parco eolico. Dal tuo spazio di lavoro, puoi interrogare, visualizzare e analizzare i dati industriali in tempo reale. *Per ulteriori informazioni sugli spazi di lavoro Amazon Managed Grafana, consulta Use [your Grafana workspace nella Amazon Managed Grafana](https://docs.aws.amazon.com/grafana/latest/userguide/using-grafana-workspace.html) User Guide.*
## Passaggio 2: aggiungi come fonte di dati AWS IoT SiteWise
Per aiutarti a visualizzare i tuoi dati, Amazon Managed Grafana include AWS il plug-in Data Sources, che semplifica il processo di connessione a. Servizi AWS Questo plugin è preinstallato nel tuo spazio di lavoro e fornisce un'interfaccia unificata per scoprire e configurare le risorse come fonti di dati. AWS Per la visualizzazione del tuo parco eolico, utilizzerai questo plugin per connetterti a. AWS IoT SiteWise Per ulteriori informazioni, consulta [Connect a an AWS IoT SiteWise data source](https://docs.aws.amazon.com/grafana/latest/userguide/using-iotsitewise-in-AMG.html) nella *Amazon Managed Grafana User* Guide.
Prima di poter iniziare a interrogare i dati del tuo parco eolico, il plug-in AWS Data Sources necessita delle autorizzazioni appropriate per accedere alle tue risorse. AWS IoT SiteWise Queste autorizzazioni sono state configurate automaticamente quando l'hai selezionata AWS IoT SiteWise come fonte di dati nel passaggio precedente. Per ulteriori informazioni sulle autorizzazioni dei plug-in, consulta [Autorizzazioni richieste](https://docs.aws.amazon.com/grafana/latest/userguide/AMG-configure-permissions.html) nella *Amazon Managed Grafana* User Guide.
**Per connetterti AWS IoT SiteWise al tuo spazio di lavoro Grafana**
1. Apri la console [Amazon Managed Grafana](https://console.aws.amazon.com/grafana/). Nella pagina dei dettagli dell'area di lavoro, scegli l'URL visualizzato sotto l'URL dell'area di lavoro **Grafana**. L'URL dell'area di lavoro apre la pagina di accesso alla console dell'area di lavoro Grafana.
1. Scegli **Accedi con AWS IAM Identity Center** e inserisci le tue credenziali. Queste credenziali funzionano solo se hai risposto all'e-mail di Amazon Managed Grafana che ti chiedeva di creare una password per IAM Identity Center.
1. Nel riquadro di navigazione a sinistra, scegli **App**, quindi **Origini AWS dati**, quindi seleziona la scheda. **Servizi AWS**
1. In **AWS IoT SiteWise**, scegli **Installa ora** per installare la versione più recente del AWS IoT SiteWise plug-in.
1. Vai alla scheda **Origini dati** e seleziona **IoT SiteWise** come servizio.
1. In **Regione predefinita**, seleziona la regione da cui desideri recuperare i dati, ad esempio **Stati Uniti orientali (Virginia settentrionale).**
1. Dopo aver specificato i parametri per il plug-in, seleziona **Aggiungi** origine dati.
1. Seleziona **Vai alle impostazioni.**
1. In **Dettagli di connessione**, seleziona **Salva e prova** per verificare che il servizio funzioni.
## Passaggio 3: crea una dashboard per esplorare e visualizzare i tuoi dati
In questo passaggio, crea una dashboard Grafana per visualizzare i dati dimostrativi del parco eolico che hai creato in precedenza. Le dashboard ti aiutano a monitorare i tuoi dati visualizzando più visualizzazioni in un'unica vista. Puoi utilizzare le dashboard per tenere traccia delle metriche, analizzare i modelli e ottenere informazioni dettagliate dai tuoi dati industriali. Per ulteriori informazioni, consulta [Crea la tua prima dashboard](https://docs.aws.amazon.com/grafana/latest/userguide/getting-started-grafanaui.html) nella *Amazon Managed Grafana User* Guide.
**Per creare la tua prima dashboard in Grafana**
1. Nel riquadro di navigazione a sinistra, seleziona **Dashboard**, quindi scegli **Crea dashboard** per iniziare a creare la tua prima dashboard.
1. Seleziona **Aggiungi visualizzazione**. Si apre l'editor del pannello in cui è possibile configurare le fonti di dati, le query e le impostazioni di visualizzazione.
1. Nella scheda **Query**, seleziona la fonte di AWS IoT SiteWise dati dal menu a discesa.
1. In **Tipo di query**, seleziona **Ottieni aggregati di valori di proprietà** dal menu a discesa per recuperare i valori aggregati delle proprietà degli asset nel tempo.
1. Seleziona **Esplora** per visualizzare le risorse disponibili nella tua gerarchia. Dalla scheda **Gerarchia**, seleziona **Demo Wind Farm Asset**, quindi seleziona **Demo Turbine** Asset 1.
1. In **Proprietà**, seleziona **Potenza media** tra le proprietà disponibili. Seleziona **Esegui interrogazioni** per eseguire la query in modo da poter visualizzare l'anteprima dell'output. La visualizzazione verrà aggiornata per mostrare i dati sulla potenza media di. `Demo Turbine Asset 1`
1. Nel riquadro di navigazione a destra, assegna un titolo al nuovo pannello, ad esempio**Turbine Demo 1 (Average Power)**. Scegliere **Apply (Applica)** per salvare le modifiche.
**avvertimento**
Ogni volta che apporti modifiche alla dashboard, salva la dashboard prima di aggiornare la pagina o uscire. Altrimenti, perderai i tuoi progressi.
1. Nell'angolo in alto a destra, seleziona **Salva dashboard**. Ti verrà richiesto di inserire un nome per la dashboard, ad esempio. **SiteWise Wind Farm Demo Dashboard**
1. Scegli **Save** (Salva).
Per informazioni sulla condivisione di dashboard, consulta la sezione [Condivisione di dashboard e pannelli](https://docs.aws.amazon.com/grafana/latest/userguide/v10-dash-sharing.html) nella *Amazon Managed Grafana* User Guide.
**Per aggiungere un altro pannello per visualizzare la velocità del vento**
1. Seleziona **Aggiungi visualizzazione** per aprire un pannello vuoto.
1. Nella scheda **Query**, seleziona la fonte di AWS IoT SiteWise dati dal menu a discesa.
1. In **Tipo di query**, seleziona **Ottieni il valore della proprietà** dal menu a discesa e in **Risorsa**, seleziona`Demo Wind Farm Asset`, quindi. `Demo Turbine Asset 1`
1. In **Proprietà**, seleziona **Velocità del vento** tra le proprietà disponibili. Seleziona **Esegui interrogazioni** per aggiornare le modifiche.
1. **In **Visualization**, seleziona Gauge.** Gli indicatori funzionano meglio per visualizzare singole metriche in tempo reale come la velocità del vento.
1. Nel riquadro di navigazione a destra, assegna un titolo al nuovo pannello, ad esempio. **Turbine Demo 1 (Wind Speed)**
1. In **Opzioni standard dalle opzioni** del pannello, seleziona **Unità**. Scegliete **Velocity**, quindi scegliete **meters/second (m/s).**
1. Scegliere **Apply (Applica)** per salvare le modifiche.
L'immagine seguente mostra come potrebbero apparire le dashboard Grafana una volta completato questo passaggio.
![\[Dashboard di esempio creati con i dati dimostrativi del parco eolico.\]](http://docs.aws.amazon.com/it_it/iot-sitewise/latest/userguide/images/updated-grafana.png)
## (opzionale) Fase 4: Impostazione degli avvisi per monitorare le prestazioni
Gli avvisi indicano cambiamenti di stato dopo che si sono verificati per identificare problemi di prestazioni delle apparecchiature industriali. Per ulteriori informazioni, consulta gli [avvisi di Amazon Managed Grafana](https://docs.aws.amazon.com/grafana/latest/userguide/alerts-overview.html) nella Amazon *Managed Grafana* User Guide.
**Per impostare avvisi in Grafana**
1. **Nella scheda **Regola** di`Turbine Demo 1 (Average Power)`, imposta **Evaluate every** to `5m` e For to.** `15m` Questa configurazione valuta la potenza media ogni 5 minuti e attiva un avviso se la condizione persiste per più di 15 minuti.
1. In **Condizioni**, seleziona **È SOTTO** e inserisci i watt. **7,020** Questa impostazione ti avviserà se le condizioni medie della turbina scendono al di sotto di 7.020 watt per più di 5 minuti. Per ulteriori informazioni sulla creazione di avvisi, [consulta i campi delle regole di avviso](https://docs.aws.amazon.com/grafana/latest/userguide/old-create-alerts.html#old-alert-rule-fields) nella *Amazon Managed Grafana* User Guide.
Hai completato il tutorial. In questa procedura, hai creato un'area di lavoro Grafana e l'hai configurata per visualizzare i dati del parco eolico da. AWS IoT SiteWise Hai creato una dashboard interattiva con diversi tipi di widget, tra cui un grafico delle serie temporali per la potenza media e un indicatore per la velocità del vento. Hai anche impostato avvisi per monitorare le prestazioni delle turbine, consentendoti di identificare potenziali problemi prima che interrompano la produzione. Potete continuare a migliorare la dashboard aggiungendo altre visualizzazioni, creando avvisi aggiuntivi o collegando altre fonti di AWS dati per ottenere informazioni più approfondite sulle vostre operazioni industriali.
## Passaggio 5: Pulisci le risorse dopo il tutorial
Dopo aver completato questo tutorial sulla visualizzazione dei dati con Grafana, ripulisci le tue risorse per evitare di incorrere in costi aggiuntivi.
** AWS IoT SiteWise Per eliminare la demo**
1. Passare alla [console AWS IoT SiteWise](https://console.aws.amazon.com/iotsitewise/).
1. **Nell'angolo in alto a destra della pagina, scegli Elimina demo.**
1. Nella finestra di dialogo di conferma immettere **DELETE** e quindi scegliere **Delete (Elimina)**.
Per ulteriori informazioni, consulta [Eliminare la AWS IoT SiteWise demo](getting-started-demo.md#delete-getting-started-demo).
Se elimini un Amazon Managed Grafana, vengono eliminati anche tutti i dati di configurazione per quell'area di lavoro. Ciò include dashboard, configurazione dell'origine dati, avvisi e istantanee.
**Per eliminare un'area di lavoro Amazon Managed Grafana**
1. Apri la console [Amazon Managed Grafana](https://console.aws.amazon.com/grafana/).
1. Nel riquadro di navigazione a sinistra, scegli l'icona del menu.
1. Seleziona **Tutte le aree di lavoro**.
1. Scegli il nome dell'area di lavoro che desideri eliminare.
1. Scegli **Elimina**.
1. **Per confermare l'eliminazione, inserisci il nome dell'area di lavoro e scegli Elimina.**
**Nota**
Questa procedura elimina un'area di lavoro. Le altre risorse potrebbero non essere eliminate. Ad esempio, i ruoli IAM utilizzati dal workspace non vengono eliminati (ma possono essere sbloccati se non sono più in uso).
Per ulteriori informazioni, consulta [Eliminare uno spazio di lavoro Amazon Managed Grafana](https://docs.aws.amazon.com/grafana/latest/userguide/AMG-edit-delete-workspace.html) nella Amazon *Managed Grafana* User Guide.
## Risorse aggiuntive
Per ulteriori informazioni sulla visualizzazione dei dati, consulta le seguenti risorse:
+ [Risoluzione dei problemi di identità e accesso ad Amazon Managed Grafana](https://docs.aws.amazon.com/grafana/latest/userguide/security_iam_troubleshoot.html) nella *Amazon Managed Grafana* User Guide
+ [Le migliori pratiche di sicurezza](https://docs.aws.amazon.com/grafana/latest/userguide/AMG-Security-Best-Practices.html) nella *Amazon Managed Grafana* User Guide
+ [Integrazione AWS IoT SiteWise con Grafana](grafana-integration.md)
+ [Elabora e visualizza i dati con SiteWise Edge e strumenti open sourceElabora e visualizza i dati su Edge](open-source-edge-integrations.md)
+ [Utenti, team e autorizzazioni](https://docs.aws.amazon.com/grafana/latest/userguide/Grafana-administration-authorization.html) nella *Amazon Managed Grafana* User Guide
+ [Autorizzazioni e policy di Amazon Managed Grafana per le fonti di AWS dati](https://docs.aws.amazon.com/grafana/latest/userguide/AMG-manage-permissions.html) nella Amazon *Managed Grafana* User Guide
# Visualizza e condividi i dati dei parchi eolici in Monitor SiteWise
Questo tutorial spiega come visualizzare e condividere dati industriali tramite applicazioni web gestite, note come portali. AWS IoT SiteWise Monitor Ogni *portale* comprende progetti e offre la flessibilità di scegliere quali dati sono accessibili all'interno di ciascun progetto. Quindi, specifica le persone della tua organizzazione che possono accedere a ciascun portale. I tuoi utenti accedono ai portali utilizzando AWS IAM Identity Center gli account, in modo che tu possa utilizzare il tuo archivio di identità esistente o uno store gestito da AWS.
Tu e gli utenti con le autorizzazioni sufficienti potete creare i pannelli di controllo in ogni progetto per visualizzare i dati di settore in modo significativo. Quindi, gli utenti possono visualizzare questi pannelli di controllo per ottenere rapidamente informazioni dettagliate sui dati e monitorare le operazioni. Puoi configurare autorizzazioni amministrative o di sola lettura per ogni progetto e per ogni utente della società. Per ulteriori informazioni, consulta [Monitora i dati con AWS IoT SiteWise Monitor](monitor-data.md).
Nel corso del tutorial, migliorerai la AWS IoT SiteWise demo, fornendo un set di dati di esempio per un parco eolico. Si configura un portale in SiteWise Monitor, si crea un progetto e si creano dashboard per visualizzare i dati del parco eolico. Il tutorial copre anche la creazione di utenti aggiuntivi, insieme all'assegnazione delle autorizzazioni per possedere o visualizzare il progetto e le dashboard associate.
**Nota**
Quando usi SiteWise Monitor, ti viene addebitato un costo per utente che accede a un portale (al mese). In questo tutorial vengono creati tre utenti, ma dovrà accedere solo un utente. Dopo aver completato questo tutorial, ti vengono addebitati i costi per un utente. Per ulteriori informazioni, consultare [AWS IoT SiteWise Prezzi](https://aws.amazon.com/iot-sitewise/pricing/).
**Topics**
+ [Prerequisiti](#monitor-tutorial-prerequisites)
+ [Passaggio 1: crea un portale in Monitor SiteWise](#monitor-tutorial-create-portal)
+ [Passaggio 2: accedi a un portale](#monitor-tutorial-sign-in-portal)
+ [Fase 3: Creare un progetto per un parco eolico](#monitor-tutorial-create-project)
+ [Fase 4: Crea una dashboard per visualizzare i dati del parco eolico](#monitor-tutorial-create-dashboard)
+ [Fase 5: Esplora il portale](#monitor-tutorial-explore-portal)
+ [Passaggio 6: Pulisci le risorse dopo il tutorial](#monitor-tutorial-clean-up-resources)
## Prerequisiti
Per completare questo tutorial, è necessario quanto segue:
+ Un Account AWS. 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 la pagina [Che cos'è Console di gestione AWS?](https://docs.aws.amazon.com/awsconsolehelpdocs/latest/gsg/what-is.html).
+ Un utente AWS Identity and Access Management (IAM) con autorizzazioni di amministratore.
+ Una demo di un parco AWS IoT SiteWise eolico funzionante. Quando configuri la demo, definisce i modelli e gli asset AWS IoT SiteWise e trasmette loro i dati per rappresentare un parco eolico. Per ulteriori informazioni, consulta [Usa la AWS IoT SiteWise demo](getting-started-demo.md).
+ Se hai abilitato IAM Identity Center nel tuo account, accedi al tuo account di AWS Organizations gestione. Per ulteriori informazioni, consulta [Concetti e terminologia di AWS Organizations](https://docs.aws.amazon.com/organizations/latest/userguide/orgs_getting-started_concepts.html). Se non hai abilitato IAM Identity Center, lo abiliterai in questo tutorial e imposterai il tuo account come account di gestione.
Se non riesci ad accedere al tuo account di AWS Organizations gestione, puoi completare parzialmente il tutorial purché nella tua organizzazione sia presente un utente IAM Identity Center. In questo caso, puoi creare il portale e le dashboard, ma non puoi creare nuovi utenti IAM Identity Center da assegnare ai progetti.
## Passaggio 1: crea un portale in Monitor SiteWise
In questa procedura crei un portale in AWS IoT SiteWise Monitor. Ogni *portale* è un'applicazione web gestita a cui tu e i tuoi utenti potete accedere con AWS IAM Identity Center gli account. Con IAM Identity Center, puoi utilizzare l'archivio di identità esistente della tua azienda o crearne uno gestito da AWS. I dipendenti della tua azienda possono accedere senza creare file separati Account AWS.
**Come creare un portale**
1. Accedi alla [console AWS IoT SiteWise](https://console.aws.amazon.com/iotsitewise/).
1. Controlla gli [AWS IoT SiteWise endpoint e le quote](https://docs.aws.amazon.com/general/latest/gr/iot-sitewise.html) dove AWS IoT SiteWise è supportato e cambia regione, se necessario. È necessario eseguire la AWS IoT SiteWise demo nella stessa regione.
1. Nel riquadro di navigazione a sinistra scegliere **Portals (Portali)**.
1. Selezionare **Create portal (Crea portale)**.
1. Se hai già abilitato IAM Identity Center, vai al passaggio 6. Altrimenti, completa i seguenti passaggi per abilitare IAM Identity Center:
1. Nella pagina **Abilita AWS IAM Identity Center (SSO)**, inserisci il tuo **indirizzo e-mail**, **nome** e **cognome** per creare un utente IAM Identity Center che diventi amministratore del portale. Utilizza un indirizzo e-mail a cui puoi accedere in modo da ricevere un'e-mail per impostare una password per il tuo nuovo utente IAM Identity Center.
In un portale, l'amministratore del portale crea i progetti e assegna gli utenti ai progetti. Sarà possibile configurare altri utenti in un secondo momento.
![\[La pagina «Abilita AWS IAM Identity Center (SSO)» del processo «Crea portale».\]](http://docs.aws.amazon.com/it_it/iot-sitewise/latest/userguide/images/sitewise-enable-sso-console.png)
1. Selezionare **Create user (Crea utente)**.
1. Nella pagina **Portal configuration (Configurazione portale)** completare i passaggi seguenti:
1. Immettere un nome per il portale, ad esempio **WindFarmPortal**.
1. (Facoltativo) Inserire una descrizione del portale. Se si dispone di più portali, utilizzare descrizioni significative per tenere traccia dei contenuti di ciascuno.
1. (Facoltativo) Carica un'immagine da visualizzare nel portale.
1. Immettete un indirizzo e-mail che gli utenti del portale possano contattare in caso di problemi con il portale e necessitano dell'aiuto dell' AWS amministratore dell'azienda per risolverlo.
1. Selezionare **Create portal (Crea portale)**.
1. Nella pagina **Invita amministratori**, puoi assegnare gli utenti di IAM Identity Center al portale come amministratori. Gli amministratori del portale gestiscono le autorizzazioni e i progetti all'interno di un portale. In questa pagina, effettuate le seguenti operazioni:
1. Seleziona un utente come amministratore del portale. Se hai abilitato IAM Identity Center in precedenza in questo tutorial, seleziona l'utente che hai creato.
![\[La pagina "Invite administrators (Invita amministratori)" del processo "Create portal (Crea portale)".\]](http://docs.aws.amazon.com/it_it/iot-sitewise/latest/userguide/images/monitor-wind-farm/sitewise-invite-portal-administrators-console.png)
1. Facoltativamente, è possibile avvalersi del comando **Send invite to selected users (Manda un invito agli utenti selezionati)**. Il tuo client di posta elettronica si apre e nel corpo del messaggio viene visualizzato un invito. È possibile personalizzare il messaggio e-mail prima di inviarlo agli amministratori del portale. È inoltre possibile inviare l'e-mail agli amministratori del portale in un secondo momento. Se stai provando SiteWise Monitor per la prima volta e sarai l'amministratore del portale, non devi inviarti un'e-mail.
1. Scegli **Next (Successivo)**.
1. Nella pagina **Assegna utenti, puoi assegnare** gli utenti di IAM Identity Center al portale. Gli amministratori del portale possono successivamente assegnare questi utenti come proprietari o visualizzatori del progetto. I proprietari dei progetti possono creare dashboard nei progetti. I visualizzatori dei progetti hanno accesso in sola lettura ai progetti a cui sono assegnati. In questa pagina, puoi creare utenti IAM Identity Center da aggiungere al portale.
**Nota**
Se non hai effettuato l'accesso al tuo account di AWS Organizations gestione, non puoi creare utenti IAM Identity Center. Scegli **Assegna utenti** per creare il portale senza utenti del portale, quindi salta questo passaggio.
In questa pagina, effettuate le seguenti operazioni:
1. Completa due volte i seguenti passaggi per creare due utenti IAM Identity Center:
1. Scegli **Crea utente** per aprire una finestra di dialogo in cui inserire i dettagli per il nuovo utente.
1. Inserisci un **indirizzo e-mail**, **nome** e **cognome** per il nuovo utente. IAM Identity Center invia all'utente un'e-mail per consentirgli di impostare la password. Se desideri accedere al portale come questi utenti, scegli un indirizzo email a cui puoi accedere. Ogni indirizzo e-mail deve essere unico. I tuoi utenti accedono al portale utilizzando il loro indirizzo e-mail come nome utente.
![\[La pagina "Portal details (Dettagli portale)" con "Assign users (Assegna utenti)" evidenziato.\]](http://docs.aws.amazon.com/it_it/iot-sitewise/latest/userguide/images/sso-widget-create-user-console.png)
1. Selezionare **Create user (Crea utente)**.
1. Seleziona i due utenti IAM Identity Center che hai creato nel passaggio precedente.
![\[La pagina «Assegna utenti» con i nuovi utenti di IAM Identity Center evidenziati.\]](http://docs.aws.amazon.com/it_it/iot-sitewise/latest/userguide/images/monitor-wind-farm/sitewise-choose-users-to-assign-console.png)
1. Scegli **Assegna utenti** per aggiungere questi utenti al portale.
La pagina dei portali si apre con il nuovo portale elencato.
## Passaggio 2: accedi a un portale
In questa procedura, accedi al nuovo portale utilizzando l' AWS IAM Identity Center utente che hai aggiunto al portale.
**Per accedere a un portale**
1. Nella pagina **Portals (Portali)** scegliere il **collegamento** del nuovo portale per aprire il portale in una nuova scheda.
![\[La pagina "Portals (Portali)" con il collegamento del portale della centrale eolica evidenziato.\]](http://docs.aws.amazon.com/it_it/iot-sitewise/latest/userguide/images/monitor-wind-farm/sitewise-choose-portal-link-console.png)
1. Se hai creato il tuo primo utente IAM Identity Center in precedenza nel tutorial, utilizza i seguenti passaggi per creare una password per il tuo utente:
1. Cercare l'email con l'oggetto **Invitation to join AWS IAM Identity Center**.
1. Aprire l'e-mail di invito e scegliere **Accept invitation**.
1. Nella nuova finestra, imposta una password per il tuo utente IAM Identity Center.
Se desideri accedere successivamente al portale come secondo e terzo utente IAM Identity Center che hai creato in precedenza, puoi anche completare questi passaggi per impostare le password per quegli utenti.
**Nota**
Se non hai ricevuto un'e-mail, puoi generare una password per il tuo utente nella console IAM Identity Center. Per ulteriori informazioni, consulta [Reimpostazione della password utente di IAM Identity Center per un utente finale](https://docs.aws.amazon.com/singlesignon/latest/userguide/reset-password-for-user.html) nella *Guida per l'AWS IAM Identity Center utente*.
1. Accedi al tuo IAM Identity Center **Username**e **Password**. Se hai creato il tuo utente IAM Identity Center in precedenza in questo tutorial, il tuo **Username**è l'indirizzo email dell'utente amministratore del portale che hai creato.
Tutti gli utenti del portale, incluso l'amministratore del portale, devono accedere con le proprie credenziali utente IAM Identity Center. Tali credenziali, in genere, non corrispondono a quelle utilizzate per accedere alla Console di gestione AWS.
![\[La pagina di accesso al portale.\]](http://docs.aws.amazon.com/it_it/iot-sitewise/latest/userguide/images/monitor-wind-farm/portal-sign-in-console.png)
1. Scegli **Sign in**.
Viene visualizzato il portale.
## Fase 3: Creare un progetto per un parco eolico
In questa procedura crei un progetto nel portale. I *progetti* sono risorse che definiscono una serie di autorizzazioni, risorse e dashboard, che puoi configurare per visualizzare i dati delle risorse in quel progetto. Con i progetti, è possibile definire chi ha accesso a sottoinsiemi specifici dell'operazione e come vengono visualizzati i dati di tali sottoinsiemi. È possibile assegnare agli utenti del portale come proprietari o visualizzatori di ciascun progetto. I proprietari del progetto possono creare dashboard per visualizzare i dati e condividere il progetto con altri utenti. I visualizzatori del progetto possono visualizzare i pannelli di controllo ma non modificarli. Per ulteriori informazioni sui ruoli in SiteWise Monitor, consulta. [SiteWise Monitora i ruoli](monitor-data.md#monitor-roles)
**Per creare un progetto di centrale eolica**
1. Nel riquadro di navigazione a sinistra del portale, scegli la scheda **Risorse**. Nella pagina **Risorse**, puoi esplorare tutte le risorse disponibili nel portale e aggiungere risorse ai progetti.
1. Nel browser degli asset, scegliere **Demo Wind Farm Asset**. Quando scegli una risorsa, puoi esplorarne i dati storici e in tempo reale. Puoi anche premere Shift per selezionare più risorse e confrontarne i dati side-by-side.
1. Scegli **Aggiungi risorsa al progetto** in alto a sinistra. I progetti contengono i pannelli di controllo che gli utenti del portale possono visualizzare per esplorare i dati. Ogni progetto ha accesso a un sottoinsieme delle tue risorse in AWS IoT SiteWise. Quando si aggiunge un asset a un progetto, tutti gli utenti con accesso a tale progetto possono anche accedere ai dati relativi all'asset e ai relativi elementi figlio.
![\[La pagina «Risorse» con l'asset dimostrativo del parco eolico e «Aggiungi risorsa al progetto» evidenziati.\]](http://docs.aws.amazon.com/it_it/iot-sitewise/latest/userguide/images/monitor-wind-farm/portal-add-asset-project-console.png)
1. Nella finestra di dialogo **Aggiungi risorsa al progetto**, scegli **Crea nuovo progetto**, quindi scegli **Avanti**.
![\[La finestra di dialogo «Aggiungi risorsa al progetto» con «Crea nuovo progetto» evidenziato.\]](http://docs.aws.amazon.com/it_it/iot-sitewise/latest/userguide/images/monitor-wind-farm/portal-choose-new-project-console.png)
1. Nella finestra di dialogo **Crea nuovo progetto**, inserisci un **nome** e una **descrizione del progetto** per il tuo progetto, quindi scegli **Aggiungi risorsa al progetto**.
![\[La finestra di dialogo «Crea nuovo progetto».\]](http://docs.aws.amazon.com/it_it/iot-sitewise/latest/userguide/images/monitor-wind-farm/portal-create-new-project-console.png)
Viene visualizzata la pagina del nuovo progetto.
1. Nella pagina del progetto, è possibile aggiungere utenti del portale come proprietari o visualizzatori del progetto.
**Nota**
Se non hai effettuato l'accesso al tuo account di AWS Organizations gestione, potresti non avere utenti del portale da assegnare a questo progetto, quindi puoi saltare questo passaggio.
In questa pagina, procedi come segue:
1. In **Proprietari del progetto**, scegli **Aggiungi proprietari** o **Modifica utenti**.
![\[La pagina "Project details (Dettagli progetto)" con "Assign users (Assegna utenti)" e "Edit users (Modifica utenti)" evidenziati.\]](http://docs.aws.amazon.com/it_it/iot-sitewise/latest/userguide/images/project-add-owners-console.png)
1. Scegliere l'utente da aggiungere come proprietario del progetto, **Mary Major**), quindi scegliere l'icona **>>**.
![\[La finestra di dialogo «Proprietari del progetto» con un utente evidenziato.\]](http://docs.aws.amazon.com/it_it/iot-sitewise/latest/userguide/images/monitor-wind-farm/project-choose-owner-console.png)
1. Scegli **Save** (Salva).
Il tuo utente IAM Identity Center **Mary Major**può accedere a questo portale per modificare i dashboard di questo progetto e condividerlo con altri utenti in questo portale.
1. **In **Visualizzatori del progetto**, scegli **Aggiungi visualizzatori o Modifica utenti.****
1. Scegliete l'utente da aggiungere come visualizzatore del progetto (ad esempio, **Mateo Jackson**), quindi scegliete l'icona **>>**.
1. Scegli **Save** (Salva).
L'utente di IAM Identity Center **Mateo Jackson**può accedere a questo portale per visualizzare, ma non modificare, le dashboard del progetto del parco eolico.
## Fase 4: Crea una dashboard per visualizzare i dati del parco eolico
In questa procedura crei i pannelli di controllo per visualizzare i dati demo della centrale eolica. I pannelli di controllo contengono visualizzazioni personalizzabili dei dati degli asset del progetto. Ogni visualizzazione può avere un tipo diverso, ad esempio un grafico a linee, un grafico a barre o un indicatore chiave di prestazione (KPI). Puoi scegliere il tipo di visualizzazione più adatto ai dati. I proprietari dei progetti possono modificare le dashboard, mentre i visualizzatori dei progetti possono solo visualizzare le dashboard per ottenere informazioni dettagliate.
**Per creare un pannello di controllo con visualizzazioni**
1. Nella pagina del nuovo progetto, scegli **Crea dashboard per creare una dashboard** e aprirne la pagina di modifica.
Nella pagina di modifica di un pannello di controllo è possibile trascinare le proprietà degli asset dalla gerarchia degli asset nel pannello di controllo per creare le visualizzazioni. Quindi è possibile modificare il titolo della visualizzazione, i titoli della legenda, il tipo, le dimensioni e la posizione per ogni visualizzazione nel pannello di controllo.
1. Inserisci un nome per la tua dashboard.
![\[La pagina di modifica "Dashboard (Pannello di controllo)" con il nome del pannello di controllo evidenziato.\]](http://docs.aws.amazon.com/it_it/iot-sitewise/latest/userguide/images/monitor-wind-farm/dashboard-edit-console.png)
1. Trascinare **Total Average Power** da **Demo Wind Farm Asset** nel pannello di controllo per creare una visualizzazione.
![\[La pagina di modifica «Dashboard» con la proprietà «Average Total Power» che trascina una proprietà dell'asset nella dashboard.\]](http://docs.aws.amazon.com/it_it/iot-sitewise/latest/userguide/images/monitor-wind-farm/dashboard-add-total-power-console.png)
1. Scegli **Demo Turbine Asset 1**di mostrare le proprietà di quella risorsa, quindi trascinala sulla dashboard **Wind Speed**per creare una visualizzazione della velocità del vento.
![\[La pagina di modifica "Dashboard (Pannello di controllo)" con la proprietà "Wind Speed (Velocità del vento)" di una turbina eolica evidenziata.\]](http://docs.aws.amazon.com/it_it/iot-sitewise/latest/userguide/images/monitor-wind-farm/dashboard-add-wind-speed-console.png)
1. Aggiungere **Wind Speed** alla nuova visualizzazione della velocità del vento per ogni **Demo Turbine Asset 2**, **3** e **4** (in questo ordine).
La visualizzazione **Wind Speed** è simile allo screenshot seguente.
![\[Una visualizzazione "Wind Speed (Velocità del vento)" che contiene quattro velocità del vento demo delle turbine eoliche.\]](http://docs.aws.amazon.com/it_it/iot-sitewise/latest/userguide/images/monitor-wind-farm/dashboard-add-all-wind-speeds-console.png)
1. Ripeti i passaggi 4 e 5 per le **Torque (KiloNewton Meter)**proprietà delle turbine eoliche per creare una visualizzazione della coppia delle turbine eoliche.
1. Scegliere l'icona del tipo di visualizzazione per la visualizzazione **Torque (KiloNewton Meter)**, quindi scegliere l'icona del grafico a barre.
![\[Una visualizzazione «Torque (KiloNewton Meter)» con il tipo di visualizzazione e le icone del grafico a barre.\]](http://docs.aws.amazon.com/it_it/iot-sitewise/latest/userguide/images/monitor-wind-farm/dashboard-change-torque-visualization-type-console.png)
1. Ripeti i passaggi 4 e 5 per le **Wind Direction**proprietà delle turbine eoliche per creare una visualizzazione della direzione del vento.
1. Scegliere l'icona del tipo di visualizzazione per la visualizzazione **Wind Direction**, quindi scegliere l'icona del grafico KPI (**30%**).
![\[Una visualizzazione "Wind Direction (Direzione del vento)" con il tipo di visualizzazione e le icone del grafico KPI evidenziate.\]](http://docs.aws.amazon.com/it_it/iot-sitewise/latest/userguide/images/monitor-wind-farm/dashboard-change-wind-direction-visualization-type-console.png)
1. (Facoltativo) Apportare altre modifiche al titolo della visualizzazione, ai titoli della legenda, al tipo, alle dimensioni e alla posizione per ogni visualizzazione in base alle esigenze.
1. Scegli **Salva dashboard** in alto a destra per salvare la dashboard.
Il pannello di controllo è simile allo screenshot seguente.
![\[Un pannello di controllo completo della centrale eolica.\]](http://docs.aws.amazon.com/it_it/iot-sitewise/latest/userguide/images/monitor-wind-farm/wind-farm-dashboard-console.png)
1. (Facoltativo) Creare un pannello di controllo aggiuntivo per ogni asset turbina eolica.
Come procedura consigliata, consigliamo di creare un pannello di controllo per ogni asset in modo che i visualizzatori dei progetti possano esaminare eventuali problemi relativi a ogni singolo asset. È possibile aggiungere solo fino a 5 asset per ogni visualizzazione, pertanto è necessario creare più pannelli di controllo per gli asset gerarchici in molti scenari.
Un pannello di controllo per una turbina eolica demo è simile allo screenshot seguente.
![\[Un pannello di controllo completo per turbine eoliche.\]](http://docs.aws.amazon.com/it_it/iot-sitewise/latest/userguide/images/monitor-wind-farm/wind-turbine-dashboard-console.png)
1. (Facoltativo) Modificare la timeline o selezionare i punti dati in una visualizzazione per esplorare i dati nel pannello di controllo. Per ulteriori informazioni, consulta [Visualizzazione dei dashboard](https://docs.aws.amazon.com/iot-sitewise/latest/appguide/view-dashboards.html) nella *Guida all'AWS IoT SiteWise Monitor applicazione*.
## Fase 5: Esplora il portale
In questa procedura, puoi esplorare il portale come utente con meno autorizzazioni rispetto a un amministratore del AWS IoT SiteWise portale.
**Per esplorare il portale e completare il tutorial**
+ (Facoltativo) Se hai aggiunto altri utenti al progetto come proprietari o visualizzatori, puoi accedere al portale come tali utenti. Ciò consente di esplorare il portale come utente con meno autorizzazioni rispetto a un amministratore del portale.
**Importante**
Ti viene addebitato un costo per ogni utente che accede a un portale. Per ulteriori informazioni, consultare [AWS IoT SiteWise Prezzi](https://aws.amazon.com/iot-sitewise/pricing/).
Per esplorare il portale con altri utenti, procedi come segue:
1. Scegli **Esci** nella parte inferiore sinistra del portale per uscire dall'applicazione web.
1. Scegli **Esci** in alto a destra nel portale dell'applicazione IAM Identity Center per disconnetterti dal tuo utente IAM Identity Center.
1. Accedi al portale come utente IAM Identity Center che hai assegnato come proprietario del progetto o visualizzatore del progetto. Per ulteriori informazioni, consulta [Passaggio 2: accedi a un portale](#monitor-tutorial-sign-in-portal).
Hai completato il tutorial. Una volta terminata l'esplorazione del parco eolico dimostrativo in SiteWise Monitor, segui la procedura successiva per ripulire le risorse.
## Passaggio 6: Pulisci le risorse dopo il tutorial
Una volta completato il tutorial puoi ripulire le risorse. Non viene addebitato alcun costo per AWS IoT SiteWise se gli utenti non accedono al portale, ma puoi eliminare il portale e gli utenti Elenco AWS IAM Identity Center . Gli asset della centrale eolica demo vengono eliminati alla fine della durata scelta al momento della creazione della demo oppure è possibile eliminare la demo manualmente. Per ulteriori informazioni, consulta [Eliminare la AWS IoT SiteWise demo](getting-started-demo.md#delete-getting-started-demo).
Utilizza le seguenti procedure per eliminare gli utenti del portale e di IAM Identity Center.
**Come eliminare un portale**
1. Passare alla [console AWS IoT SiteWise](https://console.aws.amazon.com/iotsitewise/).
1. Nel riquadro di navigazione a sinistra scegliere **Portals (Portali)**.
1. Scegli il tuo portale **WindFarmPortal**, quindi scegli **Elimina**.
Quando si elimina un portale o un progetto, gli asset associati ai progetti eliminati non sono interessati.
![\[La pagina "Portals (Portali)" con il portale della centrale eolica e "Delete (Elimina)" evidenziati.\]](http://docs.aws.amazon.com/it_it/iot-sitewise/latest/userguide/images/monitor-wind-farm/sitewise-choose-delete-portal-console.png)
1. Nella finestra di dialogo **Elimina portale**, scegli **Rimuovi amministratori e utenti**.
![\[La finestra di dialogo «Elimina portale» con l'opzione «Rimuovi amministratori e utenti» evidenziata.\]](http://docs.aws.amazon.com/it_it/iot-sitewise/latest/userguide/images/sitewise-delete-portal-remove-users-console.png)
1. Immettere **delete** per confermare l'eliminazione, quindi scegliere **Delete (Elimina)**.
![\[La finestra di dialogo «Elimina portale» con «Elimina» evidenziato.\]](http://docs.aws.amazon.com/it_it/iot-sitewise/latest/userguide/images/sitewise-delete-portal-confirm-delete-console.png)
**Per eliminare gli utenti di IAM Identity Center**
1. Accedi alla [console IAM Identity Center](https://console.aws.amazon.com/singlesignon).
1. Nel riquadro di navigazione a sinistra, seleziona **Users (Utenti)**.
1. Selezionare la casella di controllo per ogni utente da eliminare, quindi scegliere **Delete users (Elimina utenti)**.
![\[Pagina «Utenti» di IAM Identity Center con l'opzione «Elimina utenti» evidenziata.\]](http://docs.aws.amazon.com/it_it/iot-sitewise/latest/userguide/images/monitor-wind-farm/sso-choose-delete-users-console.png)
1. Nella finestra di dialogo **Elimina utenti**, inserisci**DELETE**, quindi scegli **Elimina utenti**.
![\[Finestra di dialogo «Elimina utenti» di IAM Identity Center.\]](http://docs.aws.amazon.com/it_it/iot-sitewise/latest/userguide/images/monitor-wind-farm/sso-delete-users-console.png)
# Pubblica aggiornamenti dei valori delle proprietà su Amazon DynamoDB
Questo tutorial introduce un modo pratico per archiviare i dati utilizzando [Amazon](https://aws.amazon.com/dynamodb/) DynamoDB, semplificando l'accesso ai dati storici degli asset senza dover interrogare ripetutamente l'API. AWS IoT SiteWise Dopo aver completato questo tutorial, puoi creare un software personalizzato che utilizza i dati degli asset, ad esempio una mappa in tempo reale della velocità e della direzione del vento su un intero parco eolico. Se desideri monitorare e visualizzare i tuoi dati senza implementare una soluzione software personalizzata, consulta. [Monitora i dati con AWS IoT SiteWise Monitor](monitor-data.md)
In questo tutorial, ti baserai sulla AWS IoT SiteWise demo che fornisce un set di dati di esempio per un parco eolico. Puoi configurare gli aggiornamenti dei valori delle proprietà dalla demo del parco eolico per inviare dati, tramite le regole AWS IoT Core, a una tabella DynamoDB che crei. Quando abiliti gli aggiornamenti dei valori delle proprietà, AWS IoT SiteWise invia i dati AWS IoT Core nei messaggi MQTT. Quindi, definisci le regole di AWS IoT base che eseguono azioni, come l'azione DynamoDB, a seconda del contenuto di tali messaggi. Per ulteriori informazioni, consulta [Interagisci con altri AWS servizi](interact-with-other-services.md).
**Topics**
+ [Prerequisiti](#dynamodb-tutorial-prerequisites)
+ [Fase 1: Configurare la pubblicazione degli AWS IoT SiteWise aggiornamenti dei valori delle proprietà](#dynamodb-tutorial-enable-value-notifications)
+ [Fase 2: Creare una regola in Core AWS IoT](#dynamodb-tutorial-create-iot-rule)
+ [Fase 3: Configurare l'azione della regola DynamoDB](#dynamodb-tutorial-configure-rule-action)
+ [Fase 4: Esplora i dati in DynamoDB](#dynamodb-tutorial-explore-dynamodb-data)
+ [Eseguire la pulizia delle risorse](#dynamodb-tutorial-clean-up-resources)
+ [Risorse aggiuntive](#dynamodb-tutorial-additional-resources)
## Prerequisiti
Per completare questo tutorial, è necessario quanto segue:
+ Un. Account AWS Se non lo hai, consultare [Configura un account AWS](getting-started.md#set-up-aws-account).
+ Un computer di sviluppo che esegue Windows, macOS, Linux o Unix per accedere a. Console di gestione AWS Per ulteriori informazioni, vedi [Cos'è il? Console di gestione AWS](https://docs.aws.amazon.com/awsconsolehelpdocs/latest/gsg/what-is.html)
+ Un utente AWS Identity and Access Management (IAM) con autorizzazioni di amministratore. Per istruzioni dettagliate, vedi [Come AWS IoT SiteWise funziona con IAM](security_iam_service-with-iam.md).
+ Una AWS IoT SiteWise demo in esecuzione. Per ulteriori informazioni, consulta [Usa la AWS IoT SiteWise demo](getting-started-demo.md).
**Nota**
Questo tutorial richiede l'uso di risorse create in[Usa la AWS IoT SiteWise demo](getting-started-demo.md). È necessario completarlo prima di procedere con questo tutorial.
**Importante**
Conserva tutte le risorse dimostrative fino al completamento di questo tutorial. L'eliminazione di qualsiasi componente potrebbe compromettere la funzionalità della demo e influire sulla capacità di completare il tutorial.
## Fase 1: Configurare la pubblicazione degli AWS IoT SiteWise aggiornamenti dei valori delle proprietà
In questa procedura, è possibile abilitare le notifiche del valore della proprietà per le proprietà **Wind Speed** degli asset turbine della demo. Dopo aver abilitato le notifiche sui valori delle proprietà, AWS IoT SiteWise pubblica ogni aggiornamento dei valori in un messaggio MQTT su AWS IoT Core.
**Per abilitare le notifiche di aggiornamento del valore della proprietà sulle proprietà degli asset**
1. Accedi alla [console AWS IoT SiteWise](https://console.aws.amazon.com/iotsitewise/).
1. Controlla gli [AWS IoT SiteWise endpoint e le quote](https://docs.aws.amazon.com/general/latest/gr/iot-sitewise.html) dove AWS IoT SiteWise è supportato e cambia AWS regione, se necessario. Passa a una regione in cui stai eseguendo la AWS IoT SiteWise demo.
1. Nel riquadro di navigazione a sinistra, scegli **Asset**.
1. Scegliere la freccia accanto a **Demo Wind Farm Asset** per espandere la gerarchia dell'asset della centrale eolica.
1. Scegli una turbina demo e seleziona **Modifica**.
1. Scegliere **Measurements (Misurazioni)**.
1. Aggiorna lo **stato di notifica MQTT della **Wind Speed****proprietà su **ATTIVO**.
1. Scegli **Save** (Salva) nella parte inferiore della pagina.
1. Ripetere i passaggi da 5 a 7 per ogni risorsa della turbina demo.
1. Scegliere una turbina demo (ad esempio, **Demo Turbine Asset 1**).
1. Scegliere **Measurements (Misurazioni)**.
1. Scegliere l'icona di copia accanto alla proprietà **Wind Speed** per copiare l'argomento di notifica negli Appunti. Salvare l'argomento di notifica da utilizzare più avanti in questo tutorial. È sufficiente registrare l'argomento di notifica da una turbina.
L'argomento di notifica dovrebbe essere simile all'esempio seguente.
```
$aws/sitewise/asset-models/a1b2c3d4-5678-90ab-cdef-11111EXAMPLE/assets/a1b2c3d4-5678-90ab-cdef-22222EXAMPLE/properties/a1b2c3d4-5678-90ab-cdef-33333EXAMPLE
```
## Fase 2: Creare una regola in Core AWS IoT
In questo passaggio, crea una regola in AWS IoT Core che analizzi i messaggi di notifica del valore della proprietà e inserisca i dati in una tabella Amazon DynamoDB. AWS IoT Le regole di base analizzano i messaggi MQTT ed eseguono azioni in base al contenuto e all'argomento di ciascun messaggio. Quindi, crei una regola con un'azione DynamoDB per inserire dati in una tabella DynamoDB che crei come parte di questo tutorial.
**Per creare una regola con un'azione DynamoDB**
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. In **Specificare le proprietà della regola**, inserisci un nome e una descrizione per la regola.
1. Individuare l'argomento di notifica salvato in precedenza in questo tutorial.
```
$aws/sitewise/asset-models/a1b2c3d4-5678-90ab-cdef-11111EXAMPLE/assets/a1b2c3d4-5678-90ab-cdef-22222EXAMPLE/properties/a1b2c3d4-5678-90ab-cdef-33333EXAMPLE
```
Sostituisci l'ID della risorsa (l'ID dopo`assets/`) nell'argomento con un`+`. Questo seleziona la proprietà della velocità del vento per tutte le turbine eoliche dimostrative. Il filtro dell’argomento `+` accetta tutti i nodi da un singolo livello in un argomento. L'argomento dovrebbe essere simile all'esempio seguente.
```
$aws/sitewise/asset-models/a1b2c3d4-5678-90ab-cdef-11111EXAMPLE/assets/+/properties/a1b2c3d4-5678-90ab-cdef-33333EXAMPLE
```
1. Immettere la seguente istruzione di query per la regola. Sostituire l'argomento nella sezione `FROM` con l'argomento di notifica.
```
SELECT
payload.assetId AS asset,
(SELECT VALUE (value.doubleValue) FROM payload.values) AS windspeed,
timestamp() AS timestamp
FROM
'$aws/sitewise/asset-models/a1b2c3d4-5678-90ab-cdef-11111EXAMPLE/assets/+/properties/a1b2c3d4-5678-90ab-cdef-33333EXAMPLE'
WHERE
type = 'PropertyValueUpdate'
```
1. In **Azioni relative alle regole**, vai all'**Azione 1**.
1. Nella pagina **Seleziona un'azione**, scegli **Dynamo DBv2**. Questo divide il messaggio in più colonne di una tabella DynamoDB
1. In **Nome tabella**, scegli **Crea** nuova tabella. Crei una tabella Amazon DynamoDB per ricevere i dati sulla velocità del vento dall'azione della regola.
1. In **Nome tabella** nella console [DynamoDB](https://console.aws.amazon.com/dynamodb/), inserisci un nome per la tabella.
1. Per la **chiave di partizione, procedi** come segue:
1. Inserisci **timestamp** come chiave di partizione.
1. Scegli il tipo **Numero**.
1. Selezionare la casella di controllo**Aggiungi chiave di ordinamento)**.
1. Immettere **asset** come chiave di ordinamento e lasciare il tipo di chiave di ordinamento predefinito **String**.
1. Scegliere **Create table (Crea tabella)**.
1. Tornare alla scheda con la pagina **Configura azione**.
1. Nella pagina di **azione Allega regola**, aggiorna l'elenco dei **nomi delle tabelle** e scegli la nuova tabella DynamoDB creata nel passaggio precedente.
## Fase 3: Configurare l'azione della regola DynamoDB
In questo passaggio, configura l'azione della regola di Amazon DynamoDB per inserire i dati dagli aggiornamenti dei valori delle proprietà nella tua nuova tabella DynamoDB.
**Per configurare l'azione della regola DynamoDB**
1. Scegli **Crea ruolo** per creare un ruolo IAM che conceda l'accesso AWS IoT Core per eseguire l'azione della regola.
1. Inserisci il nome di un ruolo, `WindSpeedDataRole` ad esempio. Scegli **Crea ruolo**.
1. Scegli **Next (Successivo)**.
1. Scegli **Crea** nella parte inferiore della pagina per completare la creazione della regola.
I dati degli asset dimostrativi dovrebbero iniziare a comparire nella tabella DynamoDB.
## Fase 4: Esplora i dati in DynamoDB
In questa fase, esplora i dati sulla velocità del vento degli asset dimostrativi nella tua nuova tabella Amazon DynamoDB.
**Per esplorare i dati degli asset in DynamoDB**
1. Tornate alla scheda con la tabella DynamoDB aperta.
1. Nella tabella creata in precedenza, scegli la scheda **Esplora gli elementi della tabella** per visualizzare i dati contenuti nella tabella. Aggiorna la pagina se non vedi righe nella tabella. Se le righe non vengono visualizzate dopo alcuni minuti, consulta [Risoluzione dei problemi relativi a una regola (DynamoDB)](troubleshoot-rule.md#dynamodb-tutorial-troubleshoot-rule).
1. In una riga nella tabella, scegliere l'icona di modifica per espandere i dati.
1. Scegliere la freccia accanto alla struttura della **windspeed** per espandere l'elenco dei punti dati della velocità del vento. Ogni elenco riflette un batch di punti dati sulla velocità del vento inviati AWS IoT SiteWise dalla demo del parco eolico. Se si imposta un'azione regola per uso personale, è possibile che si desideri un formato di dati diverso. Per ulteriori informazioni, consulta [Interroga le notifiche relative alle proprietà degli asset in AWS IoT SiteWise](query-notification-messages.md).
Ora che hai completato il tutorial, puoi disabilitare o eliminare la regola ed eliminare la tabella DynamoDB per evitare di incorrere in costi aggiuntivi. Per ripulire le risorse, consulta. [Eseguire la pulizia delle risorse](#dynamodb-tutorial-clean-up-resources)
Puoi anche imparare a creare applicazioni personalizzate per utilizzare e visualizzare questi dati. Per un tutorial guidato sulla visualizzazione AWS IoT SiteWise dei dati, consulta. [Visualizza e condividi dati in Grafana](visualize-with-grafana.md)
## Eseguire la pulizia delle risorse
Dopo aver completato questo tutorial, puoi pulire le risorse per evitare di incorrere in costi aggiuntivi.
**Per eliminare la demo AWS IoT SiteWise **
1. Passare alla [console AWS IoT SiteWise](https://console.aws.amazon.com/iotsitewise/).
1. **Nell'angolo in alto a destra della pagina, scegli Elimina demo.**
1. Nella finestra di dialogo di conferma immettere **DELETE** e quindi scegliere **Delete (Elimina)**.
Per ulteriori informazioni, consulta [Eliminare la AWS IoT SiteWise demo](getting-started-demo.md#delete-getting-started-demo).
Utilizza le seguenti procedure per disabilitare le notifiche di aggiornamento dei valori delle proprietà (se non hai eliminato la demo), disabilitare o eliminare la AWS IoT regola ed eliminare la tabella DynamoDB.
**Per disabilitare le notifiche di aggiornamento del valore della proprietà sulle proprietà degli asset**
1. Passare alla [console AWS IoT SiteWise](https://console.aws.amazon.com/iotsitewise/).
1. Nel riquadro di navigazione a sinistra, scegli **Asset**.
1. Scegliere la freccia accanto a **Demo Wind Farm Asset** per espandere la gerarchia dell'asset della centrale eolica.
1. Scegli una turbina demo e seleziona **Modifica**.
1. **Aggiorna lo **stato di notifica** della **Wind Speed**proprietà su INACTIVE.**
1. Scegli **Salva risorsa** nella parte inferiore della pagina.
1. Ripetere i passaggi da 4 a 6 per ogni asset turbina demo.
**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.
**Per eliminare una tabella DynamoDB**
1. Accedere alla console [DynamoDB](https://console.aws.amazon.com/dynamodb/).
1. Nel riquadro di navigazione a sinistra, selezionare **Tables (Tabelle)**.
1. Scegli la tabella che hai creato in precedenza, ad esempio. `WindSpeedData`
1. Scegli **Elimina**.
1. Nella finestra di dialogo di conferma, immettete **confirm** per eliminare la tabella.
## Risorse aggiuntive
Per ulteriori informazioni sull'utilizzo di DynamoDB e sul monitoraggio dei dati, consulta le seguenti risorse:
+ [Monitoraggio delle metriche all'interno della CloudWatch ](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Monitoring-metrics-with-Amazon-CloudWatch.html) *DynamoDB* Developer Guide
+ [Le migliori pratiche per progettare e utilizzare in modo efficace le chiavi di partizione nella](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/bp-partition-key-design.html) *DynamoDB* Developer Guide
+ [Regole contenute AWS IoT nella Guida per gli](https://docs.aws.amazon.com/iot/latest/developerguide/iot-rules.html) *sviluppatori AWS IoT *
+ [Visualizza e condividi dati in Grafana](visualize-with-grafana.md)