Usare le proprietà desiderate per configurare i dispositivi (Node)Use desired properties to configure devices (Node)

IntroduzioneIntroduction

In Introduzione ai dispositivi gemelli dell'hub IoT è stato illustrato come impostare i metadati dei dispositivi dal back-end della soluzione usando tag, come segnalare le condizioni dei dispositivi da un'app per dispositivo con le proprietà segnalate e come eseguire query su tali informazioni con un linguaggio simile a SQL.In Get started with IoT Hub device twins, you learned how to set device metadata from your solution back end using tags, report device conditions from a device app using reported properties, and query this information using a SQL-like language.

In questa esercitazione verrà illustrato come usare le proprietà desiderate del dispositivo gemello con le proprietà segnalate per configurare in remoto le app per dispositivi.In this tutorial, you learn how to use the device twin's desired properties along with reported properties, to remotely configure device apps. In particolare, questa esercitazione descrive come le proprietà segnalate e desiderate di un dispositivo gemello supportano la configurazione in più passaggi di un'applicazione per dispositivi e come ottenere nel back-end della soluzione la visibilità dello stato di tale operazione in tutti i dispositivi.More specifically, this tutorial shows how a device twin's reported and desired properties enable a multi-step configuration of a device application, and provide the visibility to the solution back end of the status of this operation across all devices. Per altre informazioni sul ruolo delle configurazioni del dispositivo, vedere Panoramica della gestione dei dispositivi con l'hub IoT.You can find more information regarding the role of device configurations in Overview of device management with IoT Hub.

In genere, l'uso di dispositivi gemelli abilita il back-end della soluzione per specificare la configurazione voluta per i dispositivi gestiti, invece di inviare comandi specifici.At a high level, using device twins enables the solution back end to specify the desired configuration for the managed devices, instead of sending specific commands. Il dispositivo ha quindi la responsabilità di configurare il modo migliore per aggiornare la propria configurazione (importante negli scenari IoT in cui le condizioni specifiche del dispositivo influiscono sulla possibilità di eseguire immediatamente determinati comandi) segnalando continuamente al back-end della soluzione lo stato corrente e le potenziali condizioni di errore del processo di aggiornamento.This puts the device in charge of setting up the best way to update its configuration (important in IoT scenarios where specific device conditions affect the ability to immediately carry out specific commands), while continually reporting to the solution back end the current state and potential error conditions of the update process. Questo modello è determinante per gestire grandi set di dispositivi, perché offre al back-end della soluzione la visibilità completa dello stato del processo di configurazione in tutti i dispositivi.This pattern is instrumental to the management of large sets of devices, as it enables the solution back end to have full visibility of the state of the configuration process across all devices.

Nota

Negli scenari in cui i dispositivi sono controllati in modo più interattivo (come nel caso dell'attivazione di una ventola da un'app controllata dall'utente), può essere opportuno usare metodi diretti.In scenarios where devices are controlled in a more interactive fashion (turn on a fan from a user-controlled app), consider using direct methods.

In questa esercitazione, il back-end della soluzione modifica la configurazione della telemetria di un dispositivo di destinazione e di conseguenza l'app per dispositivi segue un processo in più passaggi per applicare un aggiornamento della configurazione (che richiede ad esempio un riavvio del modulo software che nell'esercitazione viene simulato con un semplice ritardo).In this tutorial, the solution back end changes the telemetry configuration of a target device and, as a result of that, the device app follows a multi-step process to apply a configuration update (for example, requiring a software module restart, which this tutorial simulates with a simple delay).

Il back-end della soluzione archivia la configurazione nelle proprietà desiderate del dispositivo gemello nel modo seguente:The solution back end stores the configuration in the device twin's desired properties in the following way:

    {
        ...
        "properties": {
            ...
            "desired": {
                "telemetryConfig": {
                    "configId": "{id of the configuration}",
                    "sendFrequency": "{config}"
                }
            }
            ...
        }
        ...
    }

Nota

Dato che le configurazioni possono essere oggetti complessi, per semplificarne il confronto vengono assegnati ID univoci (hash o GUID).Since configurations can be complex objects, they are assigned unique IDs (hashes or GUIDs) to simplify their comparisons.

L'app per dispositivi segnala la propria configurazione corrente eseguendo il mirroring della proprietà desiderata telemetryConfig nelle proprietà segnalate:The device app reports its current configuration mirroring the desired property telemetryConfig in the reported properties:

    {
        "properties": {
            ...
            "reported": {
                "telemetryConfig": {
                    "changeId": "{id of the current configuration}",
                    "sendFrequency": "{current configuration}",
                    "status": "Success",
                }
            }
            ...
        }
    }

Si noti che la proprietà segnalata telemetryConfig ha una proprietà status aggiuntiva usata per segnalare lo stato del processo di aggiornamento della configurazione.Note how the reported telemetryConfig has an additional property status, used to report the state of the configuration update process.

Quando viene ricevuta una nuova configurazione desiderata, l'app per dispositivi segnala una configurazione in sospeso modificando le informazioni:When a new desired configuration is received, the device app reports a pending configuration by changing the information:

    {
        "properties": {
            ...
            "reported": {
                "telemetryConfig": {
                    "changeId": "{id of the current configuration}",
                    "sendFrequency": "{current configuration}",
                    "status": "Pending",
                    "pendingConfig": {
                        "changeId": "{id of the pending configuration}",
                        "sendFrequency": "{pending configuration}"
                    }
                }
            }
            ...
        }
    }

In un secondo momento l'app per dispositivi segnala l'esito positivo o negativo dell'operazione aggiornando la proprietà sopra indicata.Then, at some later time, the device app reports the success or failure of this operation by updating the above property. Si noti che il back-end della soluzione può eseguire in qualsiasi momento query sullo stato del processo di configurazione in tutti i dispositivi.Note how the solution back end is able, at any time, to query the status of the configuration process across all the devices.

Questa esercitazione illustra come:This tutorial shows you how to:

  • Creare un'app per dispositivo simulato che riceve aggiornamenti di configurazione dal back-end della soluzione e segnala più aggiornamenti come proprietà segnalate nel processo di aggiornamento della configurazione.Create a simulated device app that receives configuration updates from the solution back end, and reports multiple updates as reported properties on the configuration update process.
  • Creare un'app back-end che aggiorna la configurazione desiderata di un dispositivo e quindi esegue query sul processo di aggiornamento della configurazione.Create a back-end app that updates the desired configuration of a device, and then queries the configuration update process.

Al termine di questa esercitazione si avranno due app console Node.js:At the end of this tutorial, you will have two Node.js console apps:

  • SimulateDeviceConfiguration.js, un'app per dispositivo simulata che attende un aggiornamento della configurazione desiderata e segnala lo stato di un processo di aggiornamento della configurazione simulata.SimulateDeviceConfiguration.js, a simulated device app that waits for a desired configuration update and reports the status of a simulated configuration update process.
  • SetDesiredConfigurationAndQuery.js, un'app back-end di Node.js, che imposta la configurazione desiderata in un dispositivo ed esegue query sul processo di aggiornamento della configurazione.SetDesiredConfigurationAndQuery.js, a Node.js back-end app, which sets the desired configuration on a device and queries the configuration update process.

Nota

L'articolo Azure IoT SDK contiene informazioni sui componenti Azure IoT SDK che consentono di compilare le app back-end e per dispositivi.The article Azure IoT SDKs provides information about the Azure IoT SDKs that you can use to build both device and back-end apps.

Per completare l'esercitazione, sono necessari gli elementi seguenti:To complete this tutorial you need the following:

  • Node.js 4.0.x o versione successiva.Node.js version 4.0.x or later.
  • Un account Azure attivo.An active Azure account. Se non si ha un account, è possibile creare un account gratuito in pochi minuti.(If you don't have an account, you can create a free account in just a couple of minutes.)

Se si è seguita l'esercitazione Introduzione ai dispositivi gemelli sono già disponibili un hub IoT e un'identità del dispositivo denominata myDeviceId. È quindi possibile saltare la sezione Creare l'app per dispositivo simulato.If you followed the Get started with device twins tutorial, you already have an IoT hub and a device identity called myDeviceId; and you can skip to the Create the simulated device app section.

Creare un hub IoTCreate an IoT hub

Creare un hub IoT per connettere l'app per dispositivo simulato.Create an IoT hub for your simulated device app to connect to. La procedura seguente illustra come completare questa attività usando il portale di Azure.The following steps show you how to complete this task by using the Azure portal.

  1. Accedere al portale di Azure.Sign in to the Azure portal.
  2. Selezionare Nuovo > Internet delle cose > Hub IoT.Select New > Internet of Things > IoT Hub.

    Indice del portale di Azure

  3. Nel riquadro Hub IoT immettere le informazioni seguenti per l'hub IoT:In the IoT hub pane, enter the following information for your IoT hub:

    • Nome: creare un nome per l'hub IoT.Name: Create a name for your IoT hub. Se il nome immesso è valido, viene visualizzato un segno di spunta verde.If the name you enter is valid, a green check mark appears.

    Importante

    L'hub IoT sarà individuabile pubblicamente come endpoint DNS, quindi evitare di indicare informazioni riservate nell'assegnazione del nome.The IoT hub will be publicly discoverable as a DNS endpoint, so make sure to avoid any sensitive information while naming it.

    • Piano tariffario e livello di scalabilità: per questa esercitazione selezionare il livello F1 gratuito.Pricing and scale tier: For this tutorial, select the F1 - Free tier. Per altre informazioni, vedere la pagina relativa a piano tariffario e livello di scalabilità.For more information, see the Pricing and scale tier.

    • Gruppo di risorse: creare un gruppo di risorse per ospitare l'hub IoT o usarne uno esistente.Resource group: Create a resource group to host the IoT hub or use an existing one. Per altre informazioni, vedere l'articolo su come usare i gruppi di risorse per gestire le risorse di Azure.For more information, see Use resource groups to manage your Azure resources

    • Località: selezionare la località più vicina.Location: Select the closest location to you.

    • Aggiungi al dashboard: selezionare questa opzione per semplificare l'accesso all'hub IoT dal dashboard.Pin to dashboard: Check this option for easy access to your IoT hub from the dashboard.

      Finestra Hub IoT

  4. Fare clic su Crea.Click Create. La creazione dell'hub IoT può richiedere alcuni minuti.Your IoT hub might take a few minutes to create. È possibile monitorare lo stato di avanzamento nel riquadro Notifiche.You can monitor the progress in the Notifications pane.

Ora che è stato creato un hub IoT, individuare le informazioni importanti che consentono di connettere dispositivi e applicazioni all'hub IoT.Now that you have created an IoT hub, locate the important information that you use to connect devices and applications to your IoT hub.

  1. Dopo avere creato l'hub IoT, fare clic sul nuovo riquadro dell'hub IoT nel portale di Azure per aprire la finestra delle proprietà.When the IoT hub has been created successfully, click the new tile for your IoT hub in the Azure portal to open the properties window for the new IoT hub. Annotare il Nome host, quindi fare clic su Criteri di accesso condiviso.Make a note of the Hostname, and then click Shared access policies.

    Finestra del nuovo hub IoT

  2. In Criteri di accesso condivisi fare clic sul criterio iothubowner, quindi copiare e annotare la stringa di connessione dell'hub IoT nella finestra iothubowner.In Shared access policies, click the iothubowner policy, and then copy and make note of the IoT Hub connection string in the iothubowner window. Per altre informazioni, vedere Controllo di accesso nella "Guida per gli sviluppatori dell'hub IoT".For more information, see Access control in the "IoT Hub developer guide."

    Criteri di accesso condivisi

Creare un'identità del dispositivoCreate a device identity

In questa sezione si usa uno strumento di Node.js denominato iothub-explorer per creare un'identità del dispositivo per questa esercitazione.In this section, you use a Node.js tool called iothub-explorer to create a device identity for this tutorial. Gli ID dispositivo fanno distinzione tra maiuscole e minuscole.Device IDs are case sensitive.

  1. Eseguire il codice seguente nell'ambiente della riga di comando:Run the following in your command-line environment:

    npm install -g iothub-explorer@latest

  2. Eseguire quindi il comando indicato di seguito per accedere all'hub.Then, run the following command to login to your hub. Sostituire {iot hub connection string} con la stringa di connessione all'hub IoT copiata prima:Substitute {iot hub connection string} with the IoT Hub connection string you previously copied:

    iothub-explorer login "{iot hub connection string}"

  3. Creare infine una nuova identità del dispositivo denominata myDeviceId con il comando:Finally, create a new device identity called myDeviceId with the command:

    iothub-explorer create myDeviceId --connection-string

    Importante

    L'ID dispositivo può essere visibile nei log raccolti per il supporto tecnico e la risoluzione dei problemi, quindi evitare di indicare informazioni riservate nell'assegnazione del nome.The device ID may be visible in the logs collected for customer support and troubleshooting, so make sure to avoid any sensitive information while naming it.

Annotare la stringa di connessione del dispositivo visualizzata nei risultati.Make a note of the device connection string from the result. Questa stringa di connessione del dispositivo viene usata dall'app del dispositivo per la connessione all'hub IoT come dispositivo.This device connection string is used by the device app to connect to your IoT Hub as a device.

Per creare identità del dispositivo a livello di codice, vedere Introduzione all'hub IoT.Refer to Getting started with IoT Hub to programmatically create device identities.

Creare l'app per dispositivo simulataCreate the simulated device app

In questa sezione si crea un'app console Node.js che si connette all'hub come myDeviceId, attende un aggiornamento della configurazione desiderata e quindi segnala gli aggiornamenti nel processo di aggiornamento della configurazione simulata.In this section, you create a Node.js console app that connects to your hub as myDeviceId, waits for a desired configuration update and then reports updates on the simulated configuration update process.

  1. Creare una nuova cartella vuota denominata simulatedeviceconfiguration.Create a new empty folder called simulatedeviceconfiguration. Nella cartella simulatedeviceconfiguration creare un nuovo file package.json immettendo il comando seguente al prompt dei comandi.In the simulatedeviceconfiguration folder, create a new package.json file using the following command at your command prompt. Accettare tutte le impostazioni predefinite:Accept all the defaults:

    npm init
    
  2. Eseguire questo comando al prompt dei comandi nella cartella simulatedeviceconfiguration per installare i pacchetti azure-iot-device e azure-iot-device-mqtt:At your command prompt in the simulatedeviceconfiguration folder, run the following command to install the azure-iot-device, and azure-iot-device-mqtt package:

    npm install azure-iot-device azure-iot-device-mqtt --save
    
  3. Usando un editor di testo, creare un nuovo file SimulateDeviceConfiguration.js nella cartella simulatedeviceconfiguration.Using a text editor, create a new SimulateDeviceConfiguration.js file in the simulatedeviceconfiguration folder.
  4. Aggiungere il codice seguente al file SimulateDeviceConfiguration.js e sostituire il segnaposto {device connection string} con la stringa di connessione copiata quando si è creata l'identità del dispositivo myDeviceId:Add the following code to the SimulateDeviceConfiguration.js file, and substitute the {device connection string} placeholder with the device connection string you copied when you created the myDeviceId device identity:

     'use strict';
     var Client = require('azure-iot-device').Client;
     var Protocol = require('azure-iot-device-mqtt').Mqtt;
    
     var connectionString = '{device connection string}';
     var client = Client.fromConnectionString(connectionString, Protocol);
    
     client.open(function(err) {
         if (err) {
             console.error('could not open IotHub client');
         } else {
             client.getTwin(function(err, twin) {
                 if (err) {
                     console.error('could not get twin');
                 } else {
                     console.log('retrieved device twin');
                     twin.properties.reported.telemetryConfig = {
                         configId: "0",
                         sendFrequency: "24h"
                     }
                     twin.on('properties.desired', function(desiredChange) {
                         console.log("received change: "+JSON.stringify(desiredChange));
                         var currentTelemetryConfig = twin.properties.reported.telemetryConfig;
                         if (desiredChange.telemetryConfig &&desiredChange.telemetryConfig.configId !== currentTelemetryConfig.configId) {
                             initConfigChange(twin);
                         }
                     });
                 }
             });
         }
     });
    

    L'oggetto Client espone tutti i metodi necessari per interagire con i dispositivi gemelli dal dispositivo.The Client object exposes all the methods required to interact with device twins from the device. Il codice precedente, dopo avere inizializzato l'oggetto Client, recupera il dispositivo gemello per myDeviceId e collega un gestore per l'aggiornamento nelle proprietà desiderate.The previous code, after it initializes the Client object, retrieves the device twin for myDeviceId, and attaches a handler for the update on desired properties. Il gestore verifica che esista una richiesta di modifica della configurazione effettiva confrontando gli elementi configId, quindi richiama un metodo che avvia la modifica della configurazione.The handler verifies that there is an actual configuration change request by comparing the configIds, then invokes a method that starts the configuration change.

    Si noti che per semplicità il codice precedente usa un valore predefinito hardcoded per la configurazione iniziale.Note that for the sake of simplicity, the previous code uses a hard-coded default for the initial configuration. Una vera app probabilmente caricherebbe tale configurazione da una risorsa di archiviazione locale.A real app would probably load that configuration from a local storage.

    Importante

    Gli eventi di modifica delle proprietà desiderate vengono generati sempre una volta al momento della connessione del dispositivo. Controllare che esista una modifica effettiva nelle proprietà desiderate prima di eseguire eventuali azioni.Desired property change events are always emitted once at device connection, make sure to check that there is an actual change in the desired properties before performing any action.

  5. Aggiungere i metodi seguenti prima della chiamata a client.open():Add the following methods before the client.open() invocation:

     var initConfigChange = function(twin) {
         var currentTelemetryConfig = twin.properties.reported.telemetryConfig;
         currentTelemetryConfig.pendingConfig = twin.properties.desired.telemetryConfig;
         currentTelemetryConfig.status = "Pending";
    
         var patch = {
         telemetryConfig: currentTelemetryConfig
         };
         twin.properties.reported.update(patch, function(err) {
             if (err) {
                 console.log('Could not report properties');
             } else {
                 console.log('Reported pending config change: ' + JSON.stringify(patch));
                 setTimeout(function() {completeConfigChange(twin);}, 60000);
             }
         });
     }
    
     var completeConfigChange =  function(twin) {
         var currentTelemetryConfig = twin.properties.reported.telemetryConfig;
         currentTelemetryConfig.configId = currentTelemetryConfig.pendingConfig.configId;
         currentTelemetryConfig.sendFrequency = currentTelemetryConfig.pendingConfig.sendFrequency;
         currentTelemetryConfig.status = "Success";
         delete currentTelemetryConfig.pendingConfig;
    
         var patch = {
             telemetryConfig: currentTelemetryConfig
         };
         patch.telemetryConfig.pendingConfig = null;
    
         twin.properties.reported.update(patch, function(err) {
             if (err) {
                 console.error('Error reporting properties: ' + err);
             } else {
                 console.log('Reported completed config change: ' + JSON.stringify(patch));
             }
         });
     };
    

    Il metodo initConfigChange aggiorna le proprietà segnalate nell'oggetto dispositivo gemello locale con la richiesta di aggiornamento della configurazione e imposta lo stato su Pending (Sospeso), quindi aggiorna il dispositivo gemello nel servizio.The initConfigChange method updates reported properties on the local device twin object with the configuration update request and sets the status to Pending, then updates the device twin on the service. Dopo l'aggiornamento del dispositivo gemello, simula un processo a esecuzione prolungata che termina con l'esecuzione di completeConfigChange.After successfully updating the device twin, it simulates a long running process that terminates in the execution of completeConfigChange. Questo metodo aggiorna le proprietà segnalate del dispositivo gemello locale impostando lo stato su Success e rimuovendo l'oggetto pendingConfig,This method updates the local device twin's reported properties setting the status to Success and removing the pendingConfig object. quindi aggiorna il dispositivo gemello nel servizio.It then updates the device twin on the service.

    Si noti che, per risparmiare larghezza di banda, le proprietà segnalate vengono aggiornate specificando solo le proprietà da modificare (denominate patch nel codice precedente), invece di sostituire l'intero documento.Note that, to save bandwidth, reported properties are updated by specifying only the properties to be modified (named patch in the above code), instead of replacing the whole document.

    Nota

    Questa esercitazione non simula alcun comportamento per gli aggiornamenti della configurazione simultanei.This tutorial does not simulate any behavior for concurrent configuration updates. Alcuni processi di aggiornamento della configurazione potrebbero consentire modifiche della configurazione di destinazione mentre l'aggiornamento è in esecuzione, altre potrebbero doverle accodare e altri ancora rifiutarle con una condizione di errore.Some configuration update processes might be able to accommodate changes of target configuration while the update is running, others might have to queue them, and others could reject them with an error condition. È importante tenere in considerazione il comportamento desiderato per il processo di configurazione specifico e aggiungere la logica appropriata prima di iniziare la modifica della configurazione.Make sure to consider the desired behavior for your specific configuration process, and add the appropriate logic before initiating the configuration change.

  6. Eseguire l'app per dispositivo:Run the device app:

     node SimulateDeviceConfiguration.js
    

    Dovrebbe essere visualizzato il messaggio retrieved device twin.You should see the message retrieved device twin. Mantenere l'app in esecuzione.Keep the app running.

Creare l'app di servizioCreate the service app

In questa sezione si creerà un'app console Node.js che aggiorna le proprietà desiderate nel dispositivo gemello associato a myDeviceId con un nuovo oggetto di configurazione di telemetria.In this section, you will create a Node.js console app that updates the desired properties on the device twin associated with myDeviceId with a new telemetry configuration object. Viene quindi effettuata una query dei dispositivi gemelli archiviati nell'hub IoT e viene visualizzata la differenza tra la configurazione desiderata e quella segnalata del dispositivo.It then queries the device twins stored in the IoT hub and shows the difference between the desired and reported configurations of the device.

  1. Creare una nuova cartella vuota denominata setdesiredandqueryapp.Create a new empty folder called setdesiredandqueryapp. Nella cartella setdesiredandqueryapp creare un nuovo file package.json immettendo il comando seguente al prompt dei comandi.In the setdesiredandqueryapp folder, create a new package.json file using the following command at your command prompt. Accettare tutte le impostazioni predefinite:Accept all the defaults:

    npm init
    
  2. Eseguire questo comando al prompt dei comandi nella cartella setdesiredandqueryapp per installare il pacchetto azure-iothub:At your command prompt in the setdesiredandqueryapp folder, run the following command to install the azure-iothub package:

    npm install azure-iothub node-uuid --save
    
  3. Con un editor di testo creare un nuovo file SetDesiredAndQuery.js nella cartella setdesiredandqueryapp.Using a text editor, create a new SetDesiredAndQuery.js file in the setdesiredandqueryapp folder.
  4. Aggiungere il codice seguente al file SetDesiredAndQuery.js e sostituire il segnaposto {iot hub connection string} con la stringa di connessione dell'hub IoT copiata quando è stato creato l'hub:Add the following code to the SetDesiredAndQuery.js file, and substitute the {iot hub connection string} placeholder with the IoT Hub connection string you copied when you created your hub:

     'use strict';
     var iothub = require('azure-iothub');
     var uuid = require('node-uuid');
     var connectionString = '{iot hub connection string}';
     var registry = iothub.Registry.fromConnectionString(connectionString);
    
     registry.getTwin('myDeviceId', function(err, twin){
         if (err) {
             console.error(err.constructor.name + ': ' + err.message);
         } else {
             var newConfigId = uuid.v4();
             var newFrequency = process.argv[2] || "5m";
             var patch = {
                 properties: {
                     desired: {
                         telemetryConfig: {
                             configId: newConfigId,
                             sendFrequency: newFrequency
                         }
                     }
                 }
             }
             twin.update(patch, function(err) {
                 if (err) {
                     console.error('Could not update twin: ' + err.constructor.name + ': ' + err.message);
                 } else {
                     console.log(twin.deviceId + ' twin updated successfully');
                 }
             });
             setInterval(queryTwins, 10000);
         }
     });
    

    L'oggetto Registry espone tutti i metodi necessari per interagire con i dispositivi gemelli dal servizio.The Registry object exposes all the methods required to interact with device twins from the service. Il codice precedente, dopo avere inizializzato l'oggetto Registry, recupera il dispositivo gemello per myDeviceId e ne aggiorna le proprietà desiderate con un nuovo oggetto di configurazione della telemetria.The previous code, after it initializes the Registry object, retrieves the device twin for myDeviceId, and updates its desired properties with a new telemetry configuration object. quindi chiama l'evento della funzione queryTwins ogni 10 secondi.After that, it calls the queryTwins function event 10 seconds.

    Importante

    Questa applicazione effettua una query dell'hub IoT ogni 10 secondi a scopo illustrativo.This application queries IoT Hub every 10 seconds for illustrative purposes. Usare le query per generare i report destinati all'utente in più dispositivi e non per rilevare le modifiche.Use queries to generate user-facing reports across many devices, and not to detect changes. Se la soluzione richiede notifiche in tempo reale degli eventi del dispositivo, usare le notifiche relative al dispositivo gemello.If your solution requires real-time notifications of device events, use twin notifications.

    ..

  5. Aggiungere il codice seguente subito prima della chiamata a registry.getDeviceTwin() per implementare la funzione queryTwins:Add the following code right before the registry.getDeviceTwin() invocation to implement the queryTwins function:

     var queryTwins = function() {
         var query = registry.createQuery("SELECT * FROM devices WHERE deviceId = 'myDeviceId'", 100);
         query.nextAsTwin(function(err, results) {
             if (err) {
                 console.error('Failed to fetch the results: ' + err.message);
             } else {
                 console.log();
                 results.forEach(function(twin) {
                     var desiredConfig = twin.properties.desired.telemetryConfig;
                     var reportedConfig = twin.properties.reported.telemetryConfig;
                     console.log("Config report for: " + twin.deviceId);
                     console.log("Desired: ");
                     console.log(JSON.stringify(desiredConfig, null, 2));
                     console.log("Reported: ");
                     console.log(JSON.stringify(reportedConfig, null, 2));
                 });
             }
         });
     };
    

    Il codice precedente effettua una query dei dispositivi gemelli archiviati nell'hub IoT e visualizza la configurazione della telemetria desiderata e quella segnalata.The previous code queries the device twins stored in the IoT hub and prints the desired and reported telemetry configurations. Vedere il linguaggio di query dell'hub IoT per informazioni su come generare report avanzati in tutti i dispositivi.Refer to the IoT Hub query language to learn how to generate rich reports across all your devices.

  6. Con SimulateDeviceConfiguration.js in esecuzione, eseguire l'applicazione con:With SimulateDeviceConfiguration.js running, run the application with:

     node SetDesiredAndQuery.js 5m
    

    Si potrà osservare la configurazione segnalata passare da Success a Pending e di nuovo a Success con la nuova frequenza di invio attiva di cinque minuti e non più di 24 ore.You should see the reported configuration change from Success to Pending to Success again with the new active send frequency of five minutes instead of 24 hours.

    Importante

    Tra l'operazione relativa al report del dispositivo e il risultato della query si verifica un ritardo fino a un minuto,There is a delay of up to a minute between the device report operation and the query result. che consente all'infrastruttura della query di funzionare su una scala molto ampia.This is to enable the query infrastructure to work at very high scale. Per recuperare visualizzazioni coerenti di un solo dispositivo gemello, usare il metodo getDeviceTwin nella classe Registry.To retrieve consistent views of a single device twin use the getDeviceTwin method in the Registry class.

Passaggi successiviNext steps

In questa esercitazione è stata impostata una configurazione desiderata come proprietà desiderate da un'app back-end ed è stata scritta un'app per dispositivo simulato per rilevare tale modifica e simulare un processo di aggiornamento in più fasi che segnala lo stato come proprietà segnalate al dispositivo gemello.In this tutorial, you set a desired configuration as desired properties from a back-end app, and wrote a simulated device app to detect that change and simulate a multi-step update process reporting its status as reported properties to the device twin.

Per altre informazioni, vedere le risorse seguenti:Use the following resources to learn how to: