Introduzione alla gestione dei dispositivi (Java)Get started with device management (Java)

Le app back-end possono usare primitive dell'hub IoT di Azure, ad esempio i metodi diretti e il dispositivo gemello, per avviare e monitorare le azioni di gestione nei dispositivi in modalità remota.Back-end apps can use Azure IoT Hub primitives, such as device twin and direct methods, to remotely start and monitor device management actions on devices. Questa esercitazione mostra il funzionamento combinato di un'app back-end e un'app per dispositivo per avviare e monitorare il riavvio remoto di un dispositivo tramite l'hub IoT.This tutorial shows you how a back-end app and a device app can work together to initiate and monitor a remote device reboot using IoT Hub.

Usare un metodo diretto per avviare le operazioni di gestione dei dispositivi, ad esempio il riavvio, il ripristino delle impostazioni predefinite e l'aggiornamento del firmware, da un'applicazione back-end nel cloud.Use a direct method to initiate device management actions (such as reboot, factory reset, and firmware update) from a back-end app in the cloud. Il dispositivo è responsabile per:The device is responsible for:

  • La gestione della richiesta di metodo inviata dall'hub IoT.Handling the method request sent from IoT Hub.
  • L'avvio, nel dispositivo, dell'azione corrispondente specifica del dispositivo.Initiating the corresponding device-specific action on the device.
  • Gli aggiornamenti di stato tramite le proprietà segnalate nell'hub IoT.Providing status updates through reported properties to IoT Hub.

È possibile usare un'applicazione back-end nel cloud per eseguire query di un dispositivo gemello in modo da creare report sullo stato di avanzamento delle operazioni di gestione del dispositivo.You can use a back-end app in the cloud to run device twin queries to report on the progress of your device management actions.

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

  • Creare un hub IoT nel portale di Azure e un'identità del dispositivo nell'hub IoT.Use the Azure portal to create an IoT Hub and create a device identity in your IoT hub.
  • Creare un'app per dispositivo simulato che implementa un metodo diretto per riavviare il dispositivo.Create a simulated device app that implements a direct method to reboot the device. I metodi diretti vengono richiamati dal cloud.Direct methods are invoked from the cloud.
  • Creare un'app che richiama il metodo diretto di riavvio nell'app per dispositivo simulato tramite l'hub IoT.Create an app that invokes the reboot direct method in the simulated device app through your IoT hub. Questa app controlla quindi le proprietà segnalate dal dispositivo per vedere quando l'operazione di riavvio viene completata.This app then monitors the reported properties from the device to see when the reboot operation is complete.

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

simulated-device.simulated-device. Questa app:This app:

  • Si connette all'hub IoT con l'identità del dispositivo creato in precedenza.Connects to your IoT hub with the device identity created earlier.
  • Riceve una chiamata del metodo diretto per il riavvio.Receives a reboot direct method call.
  • Simula un riavvio fisico.Simulates a physical reboot.
  • Segnala l'ora dell'ultimo riavvio con una proprietà segnalata.Reports the time of the last reboot through a reported property.

trigger-reboot.trigger-reboot. Questa app:This app:

  • Chiama un metodo diretto nell'app per dispositivo simulato.Calls a direct method in the simulated device app.
  • Mostra la risposta alla chiamata del metodo diretto inviata dal dispositivo simulatoDisplays the response to the direct method call sent by the simulated device
  • Consente di visualizzare le proprietà segnalate aggiornate.Displays the updated reported properties.

Nota

Per informazioni sugli SDK che consentono di compilare le applicazioni da eseguire nei dispositivi e i back-end della soluzione, vedere Azure IoT SDK.For information about the SDKs that you can use to build applications to run on devices and your solution back end, see Azure IoT SDKs.

Per completare questa esercitazione, sono necessari:To complete this tutorial, you need:

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.

Attivare un riavvio remoto nel dispositivo con un metodo direttoTrigger a remote reboot on the device using a direct method

In questa sezione si crea un'app console Java che:In this section, you create a Java console app that:

  1. Richiama il metodo diretto reboot nell'app per dispositivo simulato.Invokes the reboot direct method in the simulated device app.
  2. Visualizza la risposta.Displays the response.
  3. Esegue il polling delle proprietà segnalate inviate dal dispositivo per determinare quando viene completato il riavvio.Polls the reported properties sent from the device to determine when the reboot is complete.

Quest'app console si connette all'hub IoT per richiamare il metodo diretto e leggere le proprietà segnalate.This console app connects to your IoT Hub to invoke the direct method and read the reported properties.

  1. Creare una cartella vuota denominata dm-get-started.Create an empty folder called dm-get-started.

  2. Nella cartella dm-get-started creare un progetto Maven denominato trigger-reboot usando il comando seguente al prompt dei comandi.In the dm-get-started folder, create a Maven project called trigger-reboot using the following command at your command prompt. L'esempio seguente mostra un lungo comando singolo:The following shows a single, long command:

    mvn archetype:generate -DgroupId=com.mycompany.app -DartifactId=trigger-reboot -DarchetypeArtifactId=maven-archetype-quickstart -DinteractiveMode=false

  3. Al prompt dei comandi passare alla cartella trigger-reboot.At your command prompt, navigate to the trigger-reboot folder.

  4. In un editor di testo aprire il file pom.xml nella cartella trigger-reboot e aggiungere la dipendenza seguente al nodo dependencies .Using a text editor, open the pom.xml file in the trigger-reboot folder and add the following dependency to the dependencies node. Questa dipendenza consente di usare il pacchetto iot-service-client nell'app per comunicare con l'hub IoT:This dependency enables you to use the iot-service-client package in your app to communicate with your IoT hub:

    <dependency>
      <groupId>com.microsoft.azure.sdk.iot</groupId>
      <artifactId>iot-service-client</artifactId>
      <version>1.7.23</version>
      <type>jar</type>
    </dependency>
    

    Nota

    È possibile cercare la versione più recente di iot-service-client usando la ricerca di Maven.You can check for the latest version of iot-service-client using Maven search.

  5. Aggiungere il nodo build seguente dopo il nodo dependencies.Add the following build node after the dependencies node. Questa configurazione indica a Maven di usare Java 1.8 per compilare l'app:This configuration instructs Maven to use Java 1.8 to build the app:

    <build>
      <plugins>
        <plugin>
          <groupId>org.apache.maven.plugins</groupId>
          <artifactId>maven-compiler-plugin</artifactId>
          <version>3.3</version>
          <configuration>
            <source>1.8</source>
            <target>1.8</target>
          </configuration>
        </plugin>
      </plugins>
    </build>
    
  6. Salvare e chiudere il file pom.xml.Save and close the pom.xml file.

  7. Usando un editor di testo, aprire il file di origine trigger-reboot\src\main\java\com\mycompany\app\App.java.Using a text editor, open the trigger-reboot\src\main\java\com\mycompany\app\App.java source file.

  8. Aggiungere al file le istruzioni import seguenti:Add the following import statements to the file:

    import com.microsoft.azure.sdk.iot.service.devicetwin.DeviceMethod;
    import com.microsoft.azure.sdk.iot.service.devicetwin.MethodResult;
    import com.microsoft.azure.sdk.iot.service.exceptions.IotHubException;
    import com.microsoft.azure.sdk.iot.service.devicetwin.DeviceTwin;
    import com.microsoft.azure.sdk.iot.service.devicetwin.DeviceTwinDevice;
    
    import java.io.IOException;
    import java.util.concurrent.TimeUnit;
    import java.util.concurrent.Executors;
    import java.util.concurrent.ExecutorService;
    
  9. Aggiungere le variabili a livello di classe seguenti alla classe App .Add the following class-level variables to the App class. Sostituire {youriothubconnectionstring} con la stringa di connessione dell'hub IoT indicata nella sezione Creare un hub IoT:Replace {youriothubconnectionstring} with your IoT hub connection string you noted in the Create an IoT Hub section:

    public static final String iotHubConnectionString = "{youriothubconnectionstring}";
    public static final String deviceId = "myDeviceId";
    
    private static final String methodName = "reboot";
    private static final Long responseTimeout = TimeUnit.SECONDS.toSeconds(30);
    private static final Long connectTimeout = TimeUnit.SECONDS.toSeconds(5);
    
  10. Per implementare un thread che legge le proprietà segnalate da un dispositivo gemello ogni 10 secondi, aggiungere la seguente classe nidificata alla classe App:To implement a thread that reads the reported properties from the device twin every 10 seconds, add the following nested class to the App class:

    private static class ShowReportedProperties implements Runnable {
      public void run() {
        try {
          DeviceTwin deviceTwins = DeviceTwin.createFromConnectionString(iotHubConnectionString);
          DeviceTwinDevice twinDevice = new DeviceTwinDevice(deviceId);
          while (true) {
            System.out.println("Get reported properties from device twin");
            deviceTwins.getTwin(twinDevice);
            System.out.println(twinDevice.reportedPropertiesToString());
            Thread.sleep(10000);
          }
        } catch (Exception ex) {
          System.out.println("Exception reading reported properties: " + ex.getMessage());
        }
      }
    }
    
  11. Modificare la firma del metodo main escludendo le eccezioni seguenti:Modify the signature of the main method to throw the following exception:

    public static void main(String[] args) throws IOException
    
  12. Per richiamare il metodo diretto di riavvio sul dispositivo simulato, aggiungere il codice seguente al metodo main:To invoke the reboot direct method on the simulated device, add the following code to the main method:

    System.out.println("Starting sample...");
    DeviceMethod methodClient = DeviceMethod.createFromConnectionString(iotHubConnectionString);
    
    try
    {
      System.out.println("Invoke reboot direct method");
      MethodResult result = methodClient.invoke(deviceId, methodName, responseTimeout, connectTimeout, null);
    
      if(result == null)
      {
        throw new IOException("Invoke direct method reboot returns null");
      }
      System.out.println("Invoked reboot on device");
      System.out.println("Status for device:   " + result.getStatus());
      System.out.println("Message from device: " + result.getPayload());
    }
    catch (IotHubException e)
    {
        System.out.println(e.getMessage());
    }
    
  13. Per avviare il thread per eseguire il polling delle proprietà segnalate dal dispositivo simulato, aggiungere il codice seguente al metodo main:To start the thread to poll the reported properties from the simulated device, add the following code to the main method:

    ShowReportedProperties showReportedProperties = new ShowReportedProperties();
    ExecutorService executor = Executors.newFixedThreadPool(1);
    executor.execute(showReportedProperties);
    
  14. Per consentire all'utente di arrestare l'app, aggiungere il codice seguente al metodo main:To enable you to stop the app, add the following code to the main method:

    System.out.println("Press ENTER to exit.");
    System.in.read();
    executor.shutdownNow();
    System.out.println("Shutting down sample...");
    
  15. Salvare e chiudere il file trigger-reboot\src\main\java\com\mycompany\app\App.java.Save and close the trigger-reboot\src\main\java\com\mycompany\app\App.java file.

  16. Compilare l'app di back-end trigger riavvio e correggere eventuali errori.Build the trigger-reboot back-end app and correct any errors. Al prompt dei comandi passare alla cartella trigger-reboot ed eseguire il comando seguente:At your command prompt, navigate to the trigger-reboot folder and run the following command:

    mvn clean package -DskipTests

Creare un'app di dispositivo simulatoCreate a simulated device app

In questa sezione si crea un'app console Java che simula un dispositivo.In this section, you create a Java console app that simulates a device. L'app è in attesa della chiamata al metodo diretto di riavvio dall'hub IoT e risponde immediatamente.The app listens for the reboot direct method call from your IoT hub and immediately responds to that call. L'app viene quindi sospesa per un periodo di tempo per simulare il processo di riavvio prima di usare una proprietà segnalata per notificare all'app di back-end trigger-reboot il completamento del riavvio.The app then sleeps for a while to simulate the reboot process before it uses a reported property to notify the trigger-reboot back-end app that the reboot is complete.

  1. Nella cartella dm-get-started creare un progetto Maven denominato simulated-device usando il comando seguente nel prompt dei comandi.In the dm-get-started folder, create a Maven project called simulated-device using the following command at your command prompt. L'esempio seguente è un lungo comando singolo:The following is a single, long command:

    mvn archetype:generate -DgroupId=com.mycompany.app -DartifactId=simulated-device -DarchetypeArtifactId=maven-archetype-quickstart -DinteractiveMode=false

  2. Al prompt dei comandi passare alla cartella simulated-device.At your command prompt, navigate to the simulated-device folder.

  3. In un editor di testo aprire il file pom.xml nella cartella simulated-device e aggiungere la dipendenza seguente al nodo dependencies .Using a text editor, open the pom.xml file in the simulated-device folder and add the following dependency to the dependencies node. Questa dipendenza consente di usare il pacchetto iot-service-client nell'app per comunicare con l'hub IoT:This dependency enables you to use the iot-service-client package in your app to communicate with your IoT hub:

    <dependency>
      <groupId>com.microsoft.azure.sdk.iot</groupId>
      <artifactId>iot-device-client</artifactId>
      <version>1.3.32</version>
    </dependency>
    

    Nota

    È possibile cercare la versione più recente di iot-device-client usando la ricerca di Maven.You can check for the latest version of iot-device-client using Maven search.

  4. Aggiungere il nodo build seguente dopo il nodo dependencies.Add the following build node after the dependencies node. Questa configurazione indica a Maven di usare Java 1.8 per compilare l'app:This configuration instructs Maven to use Java 1.8 to build the app:

    <build>
      <plugins>
        <plugin>
          <groupId>org.apache.maven.plugins</groupId>
          <artifactId>maven-compiler-plugin</artifactId>
          <version>3.3</version>
          <configuration>
            <source>1.8</source>
            <target>1.8</target>
          </configuration>
        </plugin>
      </plugins>
    </build>
    
  5. Salvare e chiudere il file pom.xml.Save and close the pom.xml file.

  6. Usando un editor di testo, aprire il file di origine simulated-device\src\main\java\com\mycompany\app\App.java.Using a text editor, open the simulated-device\src\main\java\com\mycompany\app\App.java source file.

  7. Aggiungere al file le istruzioni import seguenti:Add the following import statements to the file:

    import com.microsoft.azure.sdk.iot.device.*;
    import com.microsoft.azure.sdk.iot.device.DeviceTwin.*;
    
    import java.io.IOException;
    import java.net.URISyntaxException;
    import java.time.LocalDateTime;
    import java.util.Scanner;
    import java.util.Set;
    import java.util.HashSet;
    
  8. Aggiungere le variabili a livello di classe seguenti alla classe App .Add the following class-level variables to the App class. Sostituire {yourdeviceconnectionstring} con la stringa di connessione del dispositivo indicata nella sezione Creare un'identità del dispositivo:Replace {yourdeviceconnectionstring} with the device connection string you noted in the Create a device identity section:

    private static final int METHOD_SUCCESS = 200;
    private static final int METHOD_NOT_DEFINED = 404;
    
    private static IotHubClientProtocol protocol = IotHubClientProtocol.MQTT;
    private static String connString = "{yourdeviceconnectionstring}";
    private static DeviceClient client;
    
  9. Per implementare un gestore di callback per gli eventi di stato del metodo diretto, aggiungere la classe nidificata seguente alla classe App:To implement a callback handler for direct method status events, add the following nested class to the App class:

    protected static class DirectMethodStatusCallback implements IotHubEventCallback
    {
      public void execute(IotHubStatusCode status, Object context)
      {
        System.out.println("IoT Hub responded to device method operation with status " + status.name());
      }
    }
    
  10. Per implementare un gestore di callback per gli eventi di stato del dispositivo gemello, aggiungere la classe nidificata seguente alla classe App:To implement a callback handler for device twin status events, add the following nested class to the App class:

    protected static class DeviceTwinStatusCallback implements IotHubEventCallback
    {
        public void execute(IotHubStatusCode status, Object context)
        {
            System.out.println("IoT Hub responded to device twin operation with status " + status.name());
        }
    }
    
  11. Per implementare un gestore di callback per gli eventi delle proprietà, aggiungere la classe nidificata seguente alla classe App:To implement a callback handler for property events, add the following nested class to the App class:

    protected static class PropertyCallback implements PropertyCallBack<String, String>
    {
      public void PropertyCall(String propertyKey, String propertyValue, Object context)
      {
        System.out.println("PropertyKey:     " + propertyKey);
        System.out.println("PropertyKvalue:  " + propertyKey);
      }
    }
    
  12. Per implementare un thread per simulare il riavvio del dispositivo, aggiungere la classe nidificata seguente alla classe App.To implement a thread to simulate the device reboot, add the following nested class to the App class. Il thread rimane inattivo per cinque secondi e quindi imposta la proprietà segnalata lastReboot:The thread sleeps for five seconds and then sets the lastReboot reported property:

    protected static class RebootDeviceThread implements Runnable {
      public void run() {
        try {
          System.out.println("Rebooting...");
          Thread.sleep(5000);
          Property property = new Property("lastReboot", LocalDateTime.now());
          Set<Property> properties = new HashSet<Property>();
          properties.add(property);
          client.sendReportedProperties(properties);
          System.out.println("Rebooted");
        }
        catch (Exception ex) {
          System.out.println("Exception in reboot thread: " + ex.getMessage());
        }
      }
    }
    
  13. Per implementare il metodo diretto nel dispositivo, aggiungere la classe nidificata seguente alla classe App.To implement the direct method on the device, add the following nested class to the App class. Quando l'app simulata riceve una chiamata al metodo diretto di riavvio, restituisce una conferma al chiamante e quindi avvia un thread per elaborare il riavvio:When the simulated app receives a call to the reboot direct method, it returns an acknowledgement to the caller and then starts a thread to process the reboot:

    protected static class DirectMethodCallback implements com.microsoft.azure.sdk.iot.device.DeviceTwin.DeviceMethodCallback
    {
      @Override
      public DeviceMethodData call(String methodName, Object methodData, Object context)
      {
        DeviceMethodData deviceMethodData;
        switch (methodName)
        {
          case "reboot" :
          {
            int status = METHOD_SUCCESS;
            System.out.println("Received reboot request");
            deviceMethodData = new DeviceMethodData(status, "Started reboot");
            RebootDeviceThread rebootThread = new RebootDeviceThread();
            Thread t = new Thread(rebootThread);
            t.start();
            break;
          }
          default:
          {
            int status = METHOD_NOT_DEFINED;
            deviceMethodData = new DeviceMethodData(status, "Not defined direct method " + methodName);
          }
        }
        return deviceMethodData;
      }
    }
    
  14. Modificare la firma del metodo main escludendo le eccezioni seguenti:Modify the signature of the main method to throw the following exceptions:

    public static void main(String[] args) throws IOException, URISyntaxException
    
  15. Per creare un'istanza di DeviceClient, aggiungere il codice seguente al metodo main:To instantiate a DeviceClient, add the following code to the main method:

    System.out.println("Starting device client sample...");
    client = new DeviceClient(connString, protocol);
    
  16. Per avviare l'ascolto delle chiamate al metodo diretto, aggiungere il codice seguente al metodo main:To start listening for direct method calls, add the following code to the main method:

    try
    {
      client.open();
      client.subscribeToDeviceMethod(new DirectMethodCallback(), null, new DirectMethodStatusCallback(), null);
      client.startDeviceTwin(new DeviceTwinStatusCallback(), null, new PropertyCallback(), null);
      System.out.println("Subscribed to direct methods and polling for reported properties. Waiting...");
    }
    catch (Exception e)
    {
      System.out.println("On exception, shutting down \n" + " Cause: " + e.getCause() + " \n" +  e.getMessage());
      client.close();
      System.out.println("Shutting down...");
    }
    
  17. Per arrestare il simulatore del dispositivo, aggiungere il codice seguente al metodo main:To shut down the device simulator, add the following code to the main method:

    System.out.println("Press any key to exit...");
    Scanner scanner = new Scanner(System.in);
    scanner.nextLine();
    scanner.close();
    client.close();
    System.out.println("Shutting down...");
    
  18. Salvare e chiudere il file simulated-device\src\main\java\com\mycompany\app\App.java.Save and close the simulated-device\src\main\java\com\mycompany\app\App.java file.

  19. Compilare l'app di back-end simulated-device e correggere eventuali errori.Build the simulated-device back-end app and correct any errors. Al prompt dei comandi passare alla cartella simulated-device ed eseguire il comando seguente:At your command prompt, navigate to the simulated-device folder and run the following command:

    mvn clean package -DskipTests

Eseguire le appRun the apps

A questo punto è possibile eseguire le app.You are now ready to run the apps.

  1. Eseguire questo comando al prompt dei comandi nella cartella simulated-device per iniziare ad ascoltare le chiamate ai metodi di riavvio dell'hub IoT:At a command prompt in the simulated-device folder, run the following command to begin listening for reboot method calls from your IoT hub:

    mvn exec:java -Dexec.mainClass="com.mycompany.app.App"

    App per il dispositivo simulato dell'hub IoT per Java per ascoltare le chiamate al metodo diretto di riavvio

  2. Eseguire questo comando al prompt dei comandi nella cartella trigger-reboot per chiamare un metodo di riavvio sul dispositivo simulato dell'hub IoT:At a command prompt in the trigger-reboot folder, run the following command to call the reboot method on your simulated device from your IoT hub:

    mvn exec:java -Dexec.mainClass="com.mycompany.app.App"

    App del servizio hub IoT per Java per chiamare il metodo diretto di riavvio

  3. Il dispositivo simulato risponde alla chiamata al metodo diretto di riavvio:The simulated device responds to the reboot direct method call:

    L'app del dispositivo simulato dell'hub IoT per Java risponde alla chiamata al metodo diretto

Personalizzare ed estendere le operazioni di gestione dei dispositiviCustomize and extend the device management actions

Le soluzioni IoT possono espandere il set definito di modelli di gestione dei dispositivi o abilitare modelli personalizzati mediante l'uso di primitive di metodo da cloud a dispositivo e del dispositivo gemello.Your IoT solutions can expand the defined set of device management patterns or enable custom patterns by using the device twin and cloud-to-device method primitives. Altri esempi di operazioni di gestione dei dispositivi includono il ripristino delle informazioni predefinite, l'aggiornamento del firmware, l'aggiornamento del software, il risparmio energia, la gestione di rete e connettività e la crittografia dei dati.Other examples of device management actions include factory reset, firmware update, software update, power management, network and connectivity management, and data encryption.

Finestre di manutenzione del dispositivoDevice maintenance windows

Configurare i dispositivi in modo che eseguano le azioni in un momento che riduce al minimo le interruzioni e i tempi di inattività.Typically, you configure devices to perform actions at a time that minimizes interruptions and downtime. Le finestre di manutenzione del dispositivo costituiscono un modello comunemente usato per definire il momento in cui un dispositivo deve eseguire l'aggiornamento della configurazione.Device maintenance windows are a commonly used pattern to define the time when a device should update its configuration. Le soluzioni di back-end possono usare le proprietà desiderate del dispositivo gemello per definire e attivare un criterio sul dispositivo che attiva una finestra di manutenzione.Your back-end solutions can use the desired properties of the device twin to define and activate a policy on your device that enables a maintenance window. Quando un dispositivo riceve il criterio della finestra di manutenzione, può usare la proprietà segnalata del dispositivo gemello per segnalare lo stato del criterio.When a device receives the maintenance window policy, it can use the reported property of the device twin to report the status of the policy. L'applicazione back-end può quindi usare le query del dispositivo gemello per attestare la conformità dei dispositivi e di tutti i criteri.The back-end app can then use device twin queries to attest to compliance of devices and each policy.

Passaggi successiviNext steps

In questa esercitazione è stato usato un metodo diretto per attivare un riavvio remoto su un dispositivo.In this tutorial, you used a direct method to trigger a remote reboot on a device. Sono state usate le proprietà segnalate per indicare l'ora dell'ultimo riavvio dal dispositivo ed è stata eseguita una query sul dispositivo gemello per ottenere l'ora dell'ultimo riavvio del dispositivo dal cloud.You used the reported properties to report the last reboot time from the device, and queried the device twin to discover the last reboot time of the device from the cloud.

Per altre informazioni sull'hub IoT e sui modelli di gestione dei dispositivi, ad esempio in modalità remota tramite l'aggiornamento del firmware air, vedere:To continue getting started with IoT Hub and device management patterns such as remote over the air firmware update, see:

Esercitazione: Come eseguire un aggiornamento del firmwareTutorial: How to do a firmware update

Per informazioni su come estendere la soluzione IoT e pianificare le chiamate al metodo su più dispositivi, vedere l'esercitazione Pianificare e trasmettere processi.To learn how to extend your IoT solution and schedule method calls on multiple devices, see the Schedule and broadcast jobs tutorial.

Per altre informazioni sulle attività iniziali con l'hub IoT, vedere Getting started with IoT Edge (Introduzione a IoT Edge).To continue getting started with IoT Hub, see Getting started with IoT Edge.