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à.
# Configura manualmente le integrazioni open source (Windows)
Usa questa guida per creare manualmente un bucket di serie temporali per i dati sulla velocità del vento che si collega a Grafana® e Node-RED®.
Installa e configura manualmente Node-RED, InfluxDB® e Grafana per controllare la configurazione della distribuzione. Microsoft Windows Puoi archiviare e gestire i dati delle serie temporali dai tuoi dispositivi utilizzando InfluxDB.
## Prerequisiti di configurazione manuale
Prima di iniziare, completa questi requisiti:
**Nota**
Esegui tutti i servizi (SiteWise Edge, InfluxDB, Node-RED e Grafana) sullo stesso host.
+ Installa un gateway V3 abilitato per MQTT. Per ulteriori informazioni, consulta [Gateway V3 compatibili con MQTT per Edge AWS IoT SiteWise](mqtt-enabled-v3-gateway.md).
+ Installa ed esegui questi servizi localmente:
+ InfluxDB OSS v2. [Per i passaggi di installazione, consulta Installa InfluxDB.](https://docs.influxdata.com/influxdb/v2/install/)
+ Nodo rosso. Per i passaggi di installazione, vedi [Installare Node-RED](https://nodered.org/docs/getting-started/local) localmente.
+ Grafana. Per i passaggi di installazione, consulta [Installare Grafana](https://grafana.com/docs/grafana/latest/setup-grafana/installation/).
# Configura l'archiviazione locale con InfluxDB
Con InfluxDB®, puoi archiviare localmente i dati delle serie temporali dai tuoi dispositivi. Lo scopo della capacità di archiviazione locale è mantenere la visibilità operativa durante le interruzioni della rete e ridurre la latenza per le applicazioni che richiedono tempi critici. È possibile eseguire analisi e visualizzazioni all'edge pur avendo la possibilità di inoltrare selettivamente i dati al cloud.
In questa sezione, crei un bucket di serie temporali per i dati sulla velocità del vento delle turbine e generi un token API per la connettività Grafana® e Node-RED®. Il bucket InfluxDB funge da contenitore di archiviazione dedicato per i dati delle serie temporali, in modo simile a un database nei sistemi tradizionali. Il token API consente un accesso programmatico sicuro ai dati.
**Per configurare InfluxDB**
1. [Dopo aver completato i passaggi preliminari e aver verificato che tutti gli strumenti siano in esecuzione sullo stesso host, apri il browser Web e vai su http://127.0.0.1:8086.](http://127.0.0.1:8086)
1. (Facoltativo) Abilita la crittografia TLS per una maggiore sicurezza. Per ulteriori informazioni, consulta [Abilitare la crittografia TLS](https://docs.influxdata.com/influxdb/v2/admin/security/enable-tls/) in. *InfluxData Documentation*
1. Crea un bucket InfluxDB di serie temporali per archiviare i dati da Node-RED. Il bucket fungerà da contenitore dedicato per i dati del parco eolico, consentendoti di organizzare e gestire le politiche di conservazione specifiche per questo set di dati. Per ulteriori informazioni, consulta [Gestire i bucket](https://docs.influxdata.com/influxdb/v2/admin/buckets/) in. *InfluxData Documentation*
1. (Facoltativo) Configura il periodo di conservazione dei dati per la tua edge location. L'impostazione di periodi di conservazione appropriati aiuta a gestire le risorse di storage in modo efficiente rimuovendo automaticamente i dati più vecchi che non sono più necessari per le operazioni locali.
Per informazioni sulla conservazione dei dati, consulta [Conservazione dei dati in InfluxDB](https://docs.influxdata.com/influxdb/v2/reference/internals/data-retention/) nel. *InfluxData Documentation*
1. Genera un token API per il bucket. Questo token consentirà una comunicazione sicura tra InfluxDB e altri componenti come Node-RED e Grafana. In questo modo, solo i servizi autorizzati possono leggere o scrivere nel tuo archivio dati. Per ulteriori informazioni, consulta [Creare un token](https://docs.influxdata.com/influxdb/cloud/admin/tokens/create-token/) in *InfluxData Documentation*.
Dopo aver completato questi passaggi, puoi archiviare i dati delle serie temporali nell'istanza InfluxDB, fornendo una base per la persistenza e l'analisi locali dei dati nell'ambiente edge.
# Configura i flussi Node-RED per l'integrazione dei dati AWS IoT SiteWise
Con Node-RED®, puoi implementare due flussi per gestire i dati tra i tuoi dispositivi e. AWS IoT SiteWise Questi flussi collaborano per creare una soluzione completa di gestione dei dati che affronti il flusso di dati sia locale che cloud.
+ **Flusso di pubblicazione dei dati**: pubblicazione nel cloud. Il flusso di pubblicazione dei dati invia i dati a. AWS IoT SiteWise Questo flusso simula un dispositivo a turbina generando i dati dei sensori, traducendoli in AWS IoT SiteWise formato e pubblicandoli nel broker SiteWise Edge MQTT. Ciò consente di sfruttare le funzionalità cloud AWS IoT SiteWise di archiviazione, analisi e integrazione con altri servizi. AWS
Per ulteriori informazioni, consulta [Configura il flusso di pubblicazione dei dati](windows-nodered-data-publish-flow.md).
+ **Flusso di conservazione dei dati**: archivia i dati all'edge. Il flusso di conservazione dei dati si iscrive al broker SiteWise Edge MQTT per ricevere i dati, tradurli in formato InfluxDB® e archiviarli localmente per il monitoraggio. Questo storage locale fornisce l'accesso immediato ai dati operativi, riduce la latenza per le applicazioni urgenti e garantisce la continuità durante le interruzioni della rete.
Per ulteriori informazioni, consulta [Configura il flusso di conservazione dei dati](windows-nodered-data-retention-flow.md).
Questi due flussi interagiscono per garantire che i dati vengano inviati AWS IoT SiteWise e archiviati localmente per un accesso immediato.
[Per accedere alla console Node-RED, vai su http://127.0.0.1:1880.](http://127.0.0.1:1880) Per informazioni sull'attivazione di TLS, consulta [Abilitare](https://docs.influxdata.com/influxdb/v2/admin/security/enable-tls/) la crittografia TLS.
# Configura il flusso di pubblicazione dei dati
Il flusso di pubblicazione dei dati utilizza tre nodi per creare una pipeline che invia i dati industriali al cloud. Questo flusso è essenziale per consentire l'analisi basata sul cloud, l'archiviazione a lungo termine e l'integrazione con altri servizi. AWS Innanzitutto, i dati simulati del dispositivo vengono inviati al broker SiteWise Edge MQTT. Il gateway raccoglie i dati dal broker e li trasmette al AWS IoT SiteWise cloud, dove è possibile sfruttare potenti funzionalità di analisi e visualizzazione.
+ **Inserimento dati**: riceve i dati del dispositivo dalle apparecchiature industriali o dai simulatori
+ **Traduttore di dati per AWS IoT SiteWise**: traduce i dati in AWS IoT SiteWise formato per garantire la compatibilità con il gateway Edge SiteWise
+ **Editore MQTT**: pubblica i dati sul broker SiteWise Edge MQTT, rendendoli disponibili sia agli utenti locali che a quelli cloud
![\[Un diagramma che mostra il flusso di pubblicazione dei dati Node-RED. Invia i dati simulati del dispositivo al broker SiteWise Edge MQTT per il ritiro da parte di SiteWise Edge Gateway e quindi sul cloud. AWS IoT SiteWise\]](http://docs.aws.amazon.com/it_it/iot-sitewise/latest/userguide/images/gateway-open-source-nodered-publish-flow.png)
## Configura il nodo di immissione dei dati
In questo esempio, il nodo di immissione dei dati utilizza un dispositivo simulato di turbina eolica che genera dati sulla velocità del vento. Questo nodo funge da punto di ingresso per i dati industriali, indipendentemente dal fatto che provengano da fonti simulate (come nel nostro esempio) o da apparecchiature industriali reali negli ambienti di produzione.
Utilizziamo un formato JSON personalizzato per il payload di dati per fornire una struttura standardizzata che funzioni in modo efficiente sia con gli strumenti di elaborazione locali che con il servizio cloud. AWS IoT SiteWise Questo formato include metadati essenziali come timestamp e indicatori di qualità oltre ai valori di misurazione effettivi, consentendo una gestione completa dei dati e il monitoraggio della qualità in tutta la pipeline. Importa il nodo di iniezione per ricevere dati simulati in questo formato JSON standardizzato con timestamp, indicatori di qualità e valori.
[https://nodered.org/docs/user-guide/nodes#inject](https://nodered.org/docs/user-guide/nodes#inject)
Il simulatore di turbine genera dati sulla velocità del vento ogni secondo in questo formato JSON standardizzato:
**Example : Payload di dati sulla turbina**
```
{
name: string, // Property name/identifier
timestamp: number, // Epoch time in nanoseconds
quality: "GOOD" | "UNCERTAIN" | "BAD",
value: number | string | boolean
}
```
Questo formato offre diversi vantaggi:
+ Il `name` campo identifica la proprietà o la misurazione specifica e consente di tracciare più punti dati dallo stesso dispositivo
+ La misurazione `timestamp` in nanosecondi garantisce un tracciamento preciso del tempo per un'analisi storica accurata
+ L'`quality`indicatore consente di filtrare e gestire i dati in base alla loro affidabilità
+ Il `value` campo flessibile supporta diversi tipi di dati per adattarsi a diverse uscite di sensori
**Example : Nodo di iniezione di un simulatore di turbina**
```
[
{
"id": "string",
"type": "inject",
"z": "string",
"name": "Turbine Simulator",
"props": [
{
"p": "payload.timestamp",
"v": "",
"vt": "date"
},
{
"p": "payload.quality",
"v": "GOOD",
"vt": "str"
},
{
"p": "payload.value",
"v": "$random()",
"vt": "jsonata"
},
{
"p": "payload.name",
"v": "/Renton/WindFarm/Turbine/WindSpeed",
"vt": "str"
}
],
"repeat": "1",
"crontab": "",
"once": false,
"onceDelay": "",
"topic": "",
"x": 270,
"y": 200,
"wires": [
[
"string"
]
]
}
]
```
## Configura un nodo per la traduzione dei dati
Il gateway SiteWise Edge richiede dati in un formato specifico per garantire la compatibilità con il AWS IoT SiteWise cloud. Il nodo Translator è un componente importante che converte i dati di input nel formato di AWS IoT SiteWise payload richiesto. Questa fase di traduzione garantisce che i dati industriali possano essere elaborati, archiviati e successivamente analizzati correttamente nell' AWS IoT SiteWise ambiente cloud.
Standardizzando il formato dei dati in questa fase, si abilita l'integrazione tra i dispositivi edge e il servizio cloud, dove è possibile utilizzare funzionalità di modellazione, analisi e visualizzazione degli asset. Usa questa struttura:
**Example : Struttura del payload per l'analisi dei dati SiteWise Edge**
```
{
"propertyAlias": "string",
"propertyValues": [
{
"value": {
"booleanValue": boolean,
"doubleValue": number,
"integerValue": number,
"stringValue": "string"
},
"timestamp": {
"timeInSeconds": number,
"offsetInNanos": number
},
"quality": "GOOD" | "UNCERTAIN" | "BAD",
}]
}
```
**Nota**
Abbinala `propertyAlias` alla tua gerarchia di argomenti MQTT (ad esempio,). `/Renton/WindFarm/Turbine/WindSpeed` Ciò garantisce che i dati siano associati correttamente alla proprietà corretta dell'asset in. AWS IoT SiteWise Per ulteriori informazioni, consulta il concetto «Alias del flusso di dati» in[AWS IoT SiteWise concetti](concept-overview.md).
1. Importa il nodo funzionale di esempio per la traduzione del AWS IoT SiteWise payload. Questa funzione gestisce la conversione dal formato di input standardizzato al formato AWS IoT SiteWise compatibile, garantendo la corretta formattazione del timestamp, gli indicatori di qualità e la digitazione dei valori.
```
[
{
"id": "string",
"type": "function",
"z": "string",
"name": "Translate to SiteWise payload",
"func": "let input = msg.payload;\nlet output = {};\n\noutput[\"propertyAlias\"] = input.name;\n\nlet propertyVal = {}\n\nlet timeInSeconds = Math.floor(input.timestamp / 1000);\nlet offsetInNanos = (input.timestamp % 1000) * 1000000;\n\npropertyVal[\"timestamp\"] = {\n \"timeInSeconds\": timeInSeconds,\n \"offsetInNanos\": offsetInNanos,\n};\n\npropertyVal[\"quality\"] = input.quality\n\nlet typeNameConverter = {\n \"number\": (x) => Number.isInteger(x) ? \"integerValue\" : \"doubleValue\",\n \"boolean\": (x) => \"booleanValue\",\n \"string\": (x) => \"stringValue\", \n}\nlet typeName = typeNameConverter[typeof input.value](input.value)\npropertyVal[\"value\"] = {}\npropertyVal[\"value\"][typeName] = input.value;\n\noutput[\"propertyValues\"] = [propertyVal]\n\nreturn {\n payload: JSON.stringify(output)\n};",
"outputs": 1,
"timeout": "",
"noerr": 0,
"initialize": "",
"finalize": "",
"libs": [],
"x": 530,
"y": 200,
"wires": [
[
"string"
]
]
}
]
```
1. Verificate che il JavaScript codice traduca correttamente i dati sulla velocità del vento. La funzione svolge diverse attività importanti:
+ Estrae il nome della proprietà dall'input e lo imposta come PropertyAlias
+ Converte il timestamp da millisecondi al formato richiesto di secondi e nanosecondi
+ Conserva l'indicatore di qualità per il monitoraggio dell'affidabilità dei dati
+ Rileva automaticamente il tipo di valore e lo formatta in base ai requisiti AWS IoT SiteWise
1. Connetti il nodo al flusso, collegandolo tra il nodo di input dei dati e l'editore MQTT.
*Per indicazioni sulla scrittura di una funzione specifica per le vostre esigenze aziendali, consultate [Writing Functions](https://nodered.org/docs/user-guide/writing-functions) nella documentazione Node-RED*
## Configurare l'editore MQTT
Dopo la traduzione, i dati sono pronti per la pubblicazione sul broker SiteWise Edge MQTT.
Configura l'editore MQTT con queste impostazioni per inviare dati al broker SiteWise Edge MQTT:
**Per importare il nodo di uscita MQTT**
1. Importa un nodo di configurazione in uscita MQTT utilizzando. `"type": "mqtt out"` I nodi di uscita MQTT consentono di condividere la configurazione di un broker.
1. Inserite le coppie chiave-valore per le informazioni relative alla connessione del broker MQTT e al routing dei messaggi.
Importa il nodo di esempio. `mqtt out`
**Example**
```
[
{
"id": "string",
"type": "mqtt out",
"z": "string",
"name": "Publish to MQTT broker",
"topic": "/Renton/WindFarm/Turbine/WindSpeed",
"qos": "1",
"retain": "",
"respTopic": "",
"contentType": "",
"userProps": "",
"correl": "",
"expiry": "",
"broker": "string",
"x": 830,
"y": 200,
"wires": []
},
{
"id": "string",
"type": "mqtt-broker",
"name": "emqx",
"broker": "127.0.0.1",
"port": "1883",
"clientid": "",
"autoConnect": true,
"usetls": false,
"protocolVersion": "5",
"keepalive": 15,
"cleansession": true,
"autoUnsubscribe": true,
"birthTopic": "",
"birthQos": "0",
"birthPayload": "",
"birthMsg": {},
"closeTopic": "",
"closePayload": "",
"closeMsg": {},
"willTopic": "",
"willQos": "0",
"willPayload": "",
"willMsg": {},
"userProps": "",
"sessionExpiry": ""
}
]
```
Il nodo di uscita MQTT di esempio crea la connessione MQTT con le seguenti informazioni:
+ Server: `127.0.0.1`
+ Porta: `1883`
+ Protocollo: `MQTT V5`
Quindi, il nodo di uscita MQTT configura il routing dei messaggi con le seguenti informazioni:
+ Argomento: `/Renton/WindFarm/Turbine/WindSpeed`
+ QoS: `1`
## Implementa e verifica i nodi
Dopo aver configurato i tre nodi del flusso di pubblicazione dei dati, segui questi passaggi per distribuire il flusso e verificare che i dati vengano trasmessi correttamente a AWS IoT SiteWise
**Per distribuire e verificare le connessioni**
1. Connect i tre nodi come mostrato nel flusso di pubblicazione dei dati.
![\[Data publish flow diagram showing input from turbine simulator to AWS IoT SiteWise to MQTT broker.\]](http://docs.aws.amazon.com/it_it/iot-sitewise/latest/userguide/images/gateway-open-source-nodered-publish-flow.png)
1. Scegli **Deploy** per applicare tutte le modifiche alla connessione dei nodi.
1. Vai alla [AWS IoT SiteWise console](https://console.aws.amazon.com/iotsitewise/) e scegli **Flussi di dati**.
1. Assicurati che **il prefisso Alias** sia selezionato nel menu a discesa. Quindi, cerca l'alias. `/Renton/WindFarm/Turbine/WindSpeed`
Se vedi l'alias corretto nella tua ricerca, significa che hai distribuito il flusso e verificato la trasmissione dei dati.
# Configura il flusso di conservazione dei dati
Il flusso di conservazione dei dati può essere utilizzato per mantenere la visibilità operativa ai margini. Ciò è utile durante le interruzioni della rete o quando è necessario l'accesso immediato ai dati. Questo flusso si iscrive al broker MQTT per ricevere i dati del dispositivo, li converte in formato InfluxDB® e li archivia localmente. Implementando questo flusso, si crea un archivio dati locale resiliente a cui gli operatori possono accedere senza dipendere dal cloud, che consente il monitoraggio in tempo reale e il processo decisionale a livello perimetrale.
Il flusso è composto da tre componenti chiave che interagiscono per garantire che i dati vengano acquisiti e archiviati correttamente:
+ **Client di abbonamento MQTT**: riceve i dati dal broker, garantendo l'acquisizione di tutti i dati industriali pertinenti
+ **Traduttore InfluxDB**: converte il AWS IoT SiteWise payload in formato InfluxDB, preparando i dati per un'archiviazione efficiente delle serie temporali
+ **Writer InfluxDB**: gestisce l'archiviazione locale, garantendo la persistenza e la disponibilità dei dati per le applicazioni locali
![\[Flusso di conservazione dei dati Node-RED\]](http://docs.aws.amazon.com/it_it/iot-sitewise/latest/userguide/images/gateway-open-source-nodered-data-retention.png)
## Configura il client di abbonamento MQTT
+ Configura il client di abbonamento MQTT in Node-RED per ricevere dati dal broker MQTT EMQX importando l'esempio seguente. AWS IoT SiteWise
**Example : MQTT nel nodo**
```
[
{
"id": "string",
"type": "mqtt in",
"z": "string",
"name": "Subscribe to MQTT broker",
"topic": "/Renton/WindFarm/Turbine/WindSpeed",
"qos": "1",
"datatype": "auto-detect",
"broker": "string",
"nl": false,
"rap": true,
"rh": 0,
"inputs": 0,
"x": 290,
"y": 340,
"wires": [
[
"string"
]
]
},
{
"id": "string",
"type": "mqtt-broker",
"name": "emqx",
"broker": "127.0.0.1",
"port": "1883",
"clientid": "",
"autoConnect": true,
"usetls": false,
"protocolVersion": "5",
"keepalive": 15,
"cleansession": true,
"autoUnsubscribe": true,
"birthTopic": "",
"birthQos": "0",
"birthPayload": "",
"birthMsg": {},
"closeTopic": "",
"closePayload": "",
"closeMsg": {},
"willTopic": "",
"willQos": "0",
"willPayload": "",
"willMsg": {},
"userProps": "",
"sessionExpiry": ""
}
]
```
Questo abbonamento garantisce che tutti i dati rilevanti pubblicati sul broker vengano acquisiti per l'archiviazione locale, fornendo una registrazione completa delle vostre operazioni industriali. Il nodo utilizza gli stessi parametri di connessione MQTT della [Configurare l'editore MQTT](windows-nodered-data-publish-flow.md#windows-nodered-mqtt-publisher-config) sezione, con le seguenti impostazioni di abbonamento:
+ Argomento — `/Renton/WindFarm/Turbine/WindSpeed`
+ QoS — `1`
Per ulteriori informazioni, vedere [Connect to an MQTT Broker](https://cookbook.nodered.org/mqtt/connect-to-broker) nella *Node-REDDocumentazione*.
## Configura il traduttore InfluxDB
[InfluxDB organizza i dati utilizzando [tag](https://docs.influxdata.com/influxdb/v1/concepts/glossary/#tag) per l'indicizzazione e campi per i valori.](https://docs.influxdata.com/influxdb/v1/concepts/glossary/#field) Questa organizzazione ottimizza le prestazioni delle query e l'efficienza di archiviazione per i dati delle serie temporali. Importa il nodo funzionale di esempio che contiene il JavaScript codice per convertire il AWS IoT SiteWise payload in formato InfluxDB. Il traduttore divide le proprietà in due gruppi:
+ Tag: proprietà di qualità e nome per un'indicizzazione efficiente
+ Campi: timestamp (in millisecondi dall'epoca) e valore
**Example : nodo funzionale di traduzione in un payload InfluxDB**
```
[
{
"id": "string",
"type": "function",
"z": "string",
"name": "Translate to InfluxDB payload",
"func": "let data = msg.payload;\n\nlet timeInSeconds = data.propertyValues[0].timestamp.timeInSeconds;\nlet offsetInNanos = data.propertyValues[0].timestamp.offsetInNanos;\nlet timestampInMilliseconds = (timeInSeconds * 1000) + (offsetInNanos / 1000000);\n\nmsg.payload = [\n {\n \"timestamp(milliseconds_since_epoch)\": timestampInMilliseconds,\n \"value\": data.propertyValues[0].value.doubleValue\n },\n {\n \"name\": data.propertyAlias,\n \"quality\": data.propertyValues[0].quality\n }\n]\n\nreturn msg",
"outputs": 1,
"timeout": "",
"noerr": 0,
"initialize": "",
"finalize": "",
"libs": [],
"x": 560,
"y": 340,
"wires": [
[
"string"
]
]
}
]
```
Per ulteriori opzioni di configurazione, consulta il [node-red-contrib-influxdb](https://github.com/mblackstock/node-red-contrib-influxdb)repository Node-RED. GitHub
## Configura lo scrittore InfluxDB
Il nodo writer InfluxDB è il componente finale del flusso di conservazione dei dati, responsabile della memorizzazione dei dati industriali nel database locale InfluxDB. Questa archiviazione locale è importante per mantenere la visibilità operativa durante le interruzioni della rete e fornire l'accesso immediato ai dati per applicazioni urgenti.
1. Installa il node-red-contrib-influxdb pacchetto tramite l'opzione Manage palette. Questo pacchetto fornisce i nodi necessari per connettere Node-RED con InfluxDB.
1. Aggiungi un nodo di uscita InfluxDB al tuo flusso. Questo nodo gestirà l'effettiva scrittura dei dati nel database InfluxDB.
1. Configura le proprietà del server per stabilire una connessione sicura alla tua istanza InfluxDB:
1. Imposta la versione su 2.0: specifica che ti stai connettendo a InfluxDB v2.x, che utilizza un'API diversa rispetto alle versioni precedenti
1. Imposta l'URL su: rimanda alla tua `http://127.0.0.1:8086` istanza locale di InfluxDB
1. Inserisci il tuo token di autenticazione InfluxDB. Questo token sicuro autorizza la connessione al tuo database. Il token è stato generato durante la [Configura l'archiviazione locale con InfluxDB](windows-influxdb-setup.md) procedura.
1. Specificate i parametri della posizione di archiviazione per definire dove e come verranno archiviati i dati:
1. Inserisci il nome della tua organizzazione InfluxDB: l'organizzazione è uno spazio di lavoro per un gruppo di utenti, a cui appartengono i bucket e le dashboard. [Per ulteriori informazioni, consulta Gestire le organizzazioni in. *InfluxData Documentation*](https://docs.influxdata.com/influxdb/v2/admin/organizations/)
1. Specificate il bucket InfluxDB (ad esempio,`WindFarmData`): il bucket è equivalente a un database nei sistemi tradizionali e funge da contenitore per i dati delle serie temporali
1. Imposta la misurazione InfluxDB (ad esempio,`TurbineData`): la misurazione è simile a una tabella nei database relazionali, che organizza i punti dati correlati
**Nota**
Trova il nome della tua organizzazione nella barra laterale sinistra dell'istanza InfluxDB. I concetti di organizzazione, bucket e misurazione sono fondamentali per il modello di organizzazione dei dati di InfluxDB. [Per ulteriori informazioni, consulta la documentazione di InfluxDB.](https://docs.influxdata.com/influxdb/v2/admin/organizations/)
## Implementa e verifica il flusso di conservazione
Dopo aver configurato tutti i componenti del flusso di conservazione dei dati, è necessario implementare e verificare che il sistema funzioni correttamente. Questa verifica garantisce che i dati industriali vengano archiviati correttamente a livello locale per l'accesso e l'analisi immediati.
1. Connect i tre nodi come illustrato nel diagramma del flusso di conservazione dei dati. Questo crea una pipeline completa dalla sottoscrizione dei dati all'archiviazione locale.
![\[Flusso di conservazione dei dati Node-RED\]](http://docs.aws.amazon.com/it_it/iot-sitewise/latest/userguide/images/gateway-open-source-nodered-data-retention.png)
1. Scegli **Deploy** per applicare le modifiche e attivare il flusso. Questo avvia il processo di raccolta e archiviazione dei dati.
1. Usa InfluxDB Data Explorer per interrogare e visualizzare i tuoi dati. Questo strumento consente di verificare che i dati vengano archiviati correttamente e di creare visualizzazioni iniziali dei dati delle serie temporali.
In Data Explorer, dovreste essere in grado di vedere le misurazioni della velocità del vento registrate nel tempo, a conferma del corretto funzionamento dell'intera pipeline, dalla generazione dei dati all'archiviazione locale.
Per ulteriori informazioni, vedere [Query in Data Explorer](https://docs.influxdata.com/influxdb/v2/query-data/execute-queries/data-explorer/) in. *InfluxData Documentation*
Con l'implementazione sia del flusso di pubblicazione dei dati che del flusso di conservazione dei dati, ora disponi di un sistema completo che invia i dati al AWS IoT SiteWise cloud mantenendo una copia locale per un accesso e una resilienza immediati. Questo approccio a doppio percorso ti garantisce di ottenere i vantaggi dell'analisi e dello storage basati sul cloud mantenendo al contempo la visibilità operativa all'edge.
# Configura Grafana per Edge SiteWise
Grafana® ti consente di creare dashboard di monitoraggio locali in tempo reale per i tuoi dati industriali. Visualizzando i dati archiviati in InfluxDB®, è possibile fornire agli operatori informazioni immediate sulle prestazioni delle apparecchiature, sull'efficienza dei processi e sui potenziali problemi. Questa visibilità ai margini è importante per le operazioni urgenti e per mantenere la continuità durante le interruzioni della rete.
## Configura la fonte di dati
Il collegamento di Grafana al tuo database InfluxDB crea un potente livello di visualizzazione per i tuoi dati industriali. Questa connessione consente dashboard di monitoraggio in tempo reale che gli operatori possono utilizzare per prendere decisioni informate senza dipendere dal cloud.
1. Accedi alla tua istanza Grafana localmente accedendo a [http://127.0.0.1:3000](http://127.0.0.1:3000) nel tuo browser. *Se è necessario abilitare TLS, puoi fare riferimento a [Configurare Grafana HTTPS per il traffico web sicuro](https://grafana.com/docs/grafana/latest/setup-grafana/set-up-https/) nella Grafana Labs Documentazione.*
1. Aggiungi una fonte di dati InfluxDB che punti al bucket di serie temporali InfluxDB in cui Node-RED scrive i dati. Ad esempio, `WindFarmData`. Questa connessione stabilisce il collegamento tra i dati memorizzati e la piattaforma di visualizzazione.
1. *Per istruzioni dettagliate, consulta [Configurare l'origine dati InfluxDB](https://grafana.com/docs/grafana/latest/datasources/influxdb/configure-influxdb-data-source/) nella Documentazione. Grafana Labs*
### Crea una dashboard Grafana per SiteWise i dati Edge
La creazione di una dashboard è il passaggio finale nella creazione di una soluzione di monitoraggio locale. I dashboard forniscono rappresentazioni visive dei dati industriali, semplificando l'identificazione di tendenze, anomalie e potenziali problemi a colpo d'occhio.
+ Segui la guida per creare una dashboard. Per ulteriori informazioni, consulta [Crea la tua prima dashboard](https://grafana.com/docs/grafana/latest/getting-started/build-first-dashboard/) nella *Grafana LabsDocumentazione*. Questo modello presuppone che il bucket abbia un nome `WindFarmData` e che la misurazione sia. `TurbineData`
Puoi anche utilizzare la guida rapida importando il modello di dashboard di esempio fornito per creare rapidamente una dashboard con un grafico delle serie temporali per i dati generati da Node-RED nella sezione precedente. Questo modello fornisce un punto di partenza che puoi personalizzare per soddisfare le tue esigenze di monitoraggio specifiche.
```
{
"__inputs": [
{
"name": "DS_WINDFARM-DEMO",
"label": "windfarm-demo",
"description": "",
"type": "datasource",
"pluginId": "influxdb",
"pluginName": "InfluxDB"
}
],
"__elements": {},
"__requires": [
{
"type": "grafana",
"id": "grafana",
"name": "Grafana",
"version": "11.6.0-pre"
},
{
"type": "datasource",
"id": "influxdb",
"name": "InfluxDB",
"version": "1.0.0"
},
{
"type": "panel",
"id": "timeseries",
"name": "Time series",
"version": ""
}
],
"annotations": {
"list": [
{
"builtIn": 1,
"datasource": {
"type": "grafana",
"uid": "-- Grafana --"
},
"enable": true,
"hide": true,
"iconColor": "rgba(0, 211, 255, 1)",
"name": "Annotations & Alerts",
"type": "dashboard"
}
]
},
"editable": true,
"fiscalYearStartMonth": 0,
"graphTooltip": 0,
"id": null,
"links": [],
"panels": [
{
"datasource": {
"type": "influxdb",
"uid": "${DS_WINDFARM-DEMO}"
},
"fieldConfig": {
"defaults": {
"color": {
"mode": "palette-classic"
},
"custom": {
"axisBorderShow": false,
"axisCenteredZero": false,
"axisColorMode": "text",
"axisLabel": "",
"axisPlacement": "auto",
"barAlignment": 0,
"barWidthFactor": 0.6,
"drawStyle": "line",
"fillOpacity": 0,
"gradientMode": "none",
"hideFrom": {
"legend": false,
"tooltip": false,
"viz": false
},
"insertNulls": false,
"lineInterpolation": "linear",
"lineWidth": 1,
"pointSize": 5,
"scaleDistribution": {
"type": "linear"
},
"showPoints": "auto",
"spanNulls": false,
"stacking": {
"group": "A",
"mode": "none"
},
"thresholdsStyle": {
"mode": "off"
}
},
"mappings": [],
"thresholds": {
"mode": "absolute",
"steps": [
{
"color": "green"
},
{
"color": "red",
"value": 80
}
]
}
},
"overrides": []
},
"gridPos": {
"h": 8,
"w": 12,
"x": 0,
"y": 0
},
"id": 1,
"options": {
"legend": {
"calcs": [],
"displayMode": "list",
"placement": "bottom",
"showLegend": true
},
"tooltip": {
"hideZeros": false,
"mode": "single",
"sort": "none"
}
},
"pluginVersion": "11.6.0-pre",
"targets": [
{
"datasource": {
"type": "influxdb",
"uid": "${DS_WINDFARM-DEMO}"
},
"query": "from(bucket: \"WindFarmData\")\n |> range(start: v.timeRangeStart, stop: v.timeRangeStop)\n |> filter(fn: (r) => r[\"_measurement\"] == \"TurbineData\")\n |> filter(fn: (r) => r[\"_field\"] == \"value\")\n |> filter(fn: (r) => r[\"name\"] == \"/Renton/WindFarm/Turbine/WindSpeed\")\n |> filter(fn: (r) => r[\"quality\"] == \"GOOD\")\n |> aggregateWindow(every: v.windowPeriod, fn: mean, createEmpty: false)\n |> yield(name: \"mean\")",
"refId": "A"
}
],
"title": "Panel Title",
"type": "timeseries"
}
],
"schemaVersion": 41,
"tags": [],
"templating": {
"list": []
},
"time": {
"from": "now-6h",
"to": "now"
},
"timepicker": {},
"timezone": "browser",
"title": "demo dashboard",
"uid": "fejc0t08o6d4wb",
"version": 1,
"weekStart": ""
}
```