Caricare file da un dispositivo al cloud con l'hub IoT (Java)

Questa esercitazione illustra come usare le funzionalità di caricamento dei file di hub IoT usando Java. Per una panoramica del processo di caricamento dei file, vedere Upload File con hub IoT.

L’argomento di avvio rapido Inviare dati di telemetria da un dispositivo a un hub IoT e l’esercitazione Inviare messaggi da cloud a dispositivo con l'hub IoT illustrano le funzionalità di messaggistica di base da dispositivo a cloud e da cloud a dispositivo dell'hub IoT. L'esercitazione Configurare il routing dei messaggi con l'IoT Hub illustra come archiviare in modo affidabile i messaggi da dispositivo a cloud nell'archivio BLOB di Azure. Tuttavia in alcuni scenari non è possibile mappare facilmente i dati che i dispositivi inviano in messaggi relativamente ridotti da dispositivo a cloud, che l'hub IoT accetta. Ad esempio:

  • File di grandi dimensioni che contengono immagini
  • Video
  • Dati di vibrazione campionati ad alta frequenza
  • Qualche tipo di dati pre-elaborati.

Questi dati in genere vengono elaborati in batch nel cloud con strumenti come Azure Data Factory o lo stack Hadoop. Quando è necessario caricare file da un dispositivo, tuttavia, è comunque possibile usare la sicurezza e l'affidabilità di hub IoT. Questo esempio illustra come. Esistono anche due esempi disponibili https://github.com/Azure/azure-iot-sdk-java/tree/main/device/iot-device-samples/file-upload-sample/src/main/java/samples/com/microsoft/azure/sdk/iot in GitHub.

Nota

hub IoT supporta molte piattaforme e linguaggi di dispositivo (tra cui C, .NET e JavaScript) tramite sdk del dispositivo Azure IoT. Vedere il Centro per sviluppatori di IoT di Azure per istruzioni dettagliate su come connettere il dispositivo all'Hub IoT di Azure.

Importante

Le funzionalità di caricamento dei file nei dispositivi che usano l'autenticazione dell'autorità di certificazione X.509 sono in anteprima pubblica e la modalità di anteprima deve essere abilitata. È disponibile a livello generale nei dispositivi che usano l'autenticazione di identificazione personale X.509 o l'attestazione del certificato X.509 con il servizio Provisioning dispositivi di Azure. Per altre informazioni sull'autenticazione X.509 con hub IoT, vedere Certificati X.509 supportati.

Prerequisiti

  • Java SE Development Kit 8. Assicurarsi di selezionare Java 8 in Supporto a lungo termine per passare ai download per JDK 8.

  • Maven 3

  • Un account Azure attivo. Se non si dispone di un account, è possibile crearne uno gratuito in pochi minuti.

  • Assicurarsi che la porta 8883 sia aperta nel firewall. L'esempio di dispositivo di questo articolo usa il protocollo MQTT, che comunica tramite la porta 8883. Questa porta potrebbe essere bloccata in alcuni ambienti di rete aziendali e didattici. Per altre informazioni e soluzioni alternative per questo problema, vedere Connettersi all'hub IoT (MQTT).

Creare un hub IoT

Questa sezione illustra come creare un hub IoT usando il portale di Azure.

  1. Accedere al portale di Azure.

  2. Nella home page di Azure selezionare il pulsante + Crea una risorsa .

  3. Dal menu Categorie selezionare Internet delle cose e quindi hub IoT.

  4. Nella scheda Informazioni di base completare i campi come indicato di seguito:

    • Sottoscrizione Selezionare la sottoscrizione da usare per l'hub.

    • Gruppo di risorse: selezionare un gruppo di risorse o crearne uno nuovo. Per crearne uno nuovo, fare clic su Crea nuovo e specificare il nome da usare. Per usare un gruppo di risorse esistente, selezionarlo. Per altre informazioni, vedere l'articolo su come gestire gruppi di risorse di Azure Resource Manager.

    • Area: selezionare l'area in cui si vuole collocare l'hub. Selezionare la località più vicina. Alcune funzionalità, ad esempio i flussi dei dispositivi dell'hub IoT, sono disponibili solo in aree specifiche. Per queste funzionalità limitate, è necessario selezionare una delle aree supportate.

    • Nome dell'hub IoT: immettere un nome per l'hub. Questo nome deve essere univoco a livello globale, con lunghezza compresa tra 3 e 50 caratteri alfanumerici. Il nome può includere anche il carattere trattino ('-').

    Importante

    Dato che l'hub IoT sarà individuabile pubblicamente come endpoint DNS, evitare di includere nel nome informazioni personali o sensibili.

    Create a hub in the Azure portal.

  5. Selezionare Avanti: Rete per continuare a creare l'hub.

    Scegliere gli endpoint che i dispositivi possono usare per connettersi all'hub IoT. È possibile selezionare l'impostazione predefinita, l'accesso pubblico o scegliere Accesso privato. Accettare l'impostazione predefinita per questo esempio.

    Choose the endpoints that can connect.

  6. Selezionare Avanti: Gestione per continuare a creare l'hub.

    Set the size and scale for a new hub using the Azure portal.

    In questa schermata è possibile accettare le impostazioni predefinite. Se si preferisce, è possibile modificare uno dei campi seguenti:

    • Piano tariffario e livello di scalabilità: il piano e il livello selezionati. È possibile scegliere tra livelli diversi a seconda del numero di funzionalità che si desidera e della quantità di messaggi che si inviano al giorno tramite la soluzione. Il livello gratuito è utilizzabile a scopo di test e valutazione. Consente la connessione di 500 dispositivi all'hub e un massimo di 8.000 messaggi al giorno. Per ogni sottoscrizione di Azure è possibile creare un solo hub IoT nel livello gratuito.

      Se si usa una guida introduttiva, selezionare il livello gratuito.

    • Unità di hub IoT: Il numero di messaggi consentiti per unità al giorno dipende dal piano tariffario dell'hub. Se ad esempio si vuole che l'hub supporti 700.000 messaggi in ingresso, selezionare due unità del piano S1. Per informazioni dettagliate sulle altre opzioni relative al livello, vedere Scegliere il livello più adatto di hub IoT.

    • Microsoft Defender per IoT: attivare questa opzione per aggiungere un livello aggiuntivo di protezione dalle minacce a IoT e ai dispositivi. Questa opzione non è disponibile per gli hub del livello gratuito. Altre informazioni sulle raccomandazioni sulla sicurezza per hub IoT in Defender per IoT.

    • Controllo degli accessi in base al ruolo: scegliere come accedere all'hub IoT è gestito, se i criteri di accesso condiviso sono consentiti o solo il controllo degli accessi in base al ruolo è supportato. Per altre informazioni, vedere Controllare l'accesso alle hub IoT usando Azure Active Directory.

    • Partizioni da dispositivo a cloud: questa proprietà riguarda i messaggi da dispositivo a cloud al numero di lettori simultanei dei messaggi. La maggior parte degli hub richiede solo quattro partizioni.

  7. Selezionare Avanti: Tag per passare alla schermata successiva.

    I tag sono coppie nome/valore. È possibile assegnare lo stesso tag a più risorse e gruppi di risorse per classificare le risorse e consolidare la fatturazione. In questo documento non verranno aggiunti tag. Per altre informazioni, vedere Usare tag per organizzare le risorse di Azure.

    Assign tags for the hub using the Azure portal.

  8. Selezionare Avanti: Rivedi e crea per rivedere le scelte effettuate. Viene visualizzata una schermata simile a questa, ma con i valori selezionati durante la creazione dell'hub.

    Review information for creating the new hub.

  9. Selezionare Crea per avviare la distribuzione del nuovo hub. La distribuzione sarà in corso alcuni minuti durante la creazione dell'hub. Al termine della distribuzione, selezionare Vai alla risorsa per aprire il nuovo hub.

Registrare un nuovo dispositivo nell'hub IoT

In questa sezione si creerà un'identità del dispositivo nel registro delle identità dell'hub IoT. Un dispositivo non può connettersi all'hub a meno che non abbia una voce nel registro di identità. Per altre informazioni, vedere la Guida per gli sviluppatori dell'hub IoT.

  1. Nel menu di spostamento dell'hub IoT aprire Dispositivi, quindi selezionare Aggiungi dispositivo per aggiungere un dispositivo nell'hub IoT.

    Screen capture that shows how to create a device identity in the portal

  2. In Crea un dispositivo, specificare un nome per il nuovo dispositivo, ad esempio myDeviceId, quindi selezionare Salva. In questo modo viene creata un’identità del dispositivo per l'hub IoT. Lasciare controllate le chiavi generate automaticamente in modo che le chiavi primarie e secondarie vengano generate automaticamente.

    Screen capture that shows how to add a new device

    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.

  3. Dopo aver creato il dispositivo, aprire il dispositivo dall'elenco nel riquadro Dispositivi . Copiare la stringa di connessione primaria. Questa stringa di connessione viene usata dal codice del dispositivo per comunicare con l'hub.

    Per impostazione predefinita, le chiavi e le stringhe di connessione vengono mascherate come informazioni riservate. Se si fa clic sull'icona a forma di occhio, vengono visualizzati. Non è necessario rivelarli per copiarli con il pulsante copia.

    Screen capture that shows the device connection string

Nota

Il registro di identità dell'hub IoT archivia solo le identità del dispositivo per abilitare l'accesso sicuro all'hub. Archivia gli ID dispositivo e le chiavi da usare come credenziali di sicurezza e un flag di attivazione/disattivazione che consente di disabilitare l'accesso per un singolo dispositivo. Se l'applicazione deve archiviare altri metadati specifici del dispositivo, dovrà usare un archivio specifico dell'applicazione. Per altre informazioni, vedere la Guida per gli sviluppatori dell'hub IoT.

Associare un account di archiviazione di Azure all'hub IoT

Per caricare file da un dispositivo, è necessario avere un account Archiviazione di Azure e Archiviazione BLOB di Azure contenitore associato all'hub IoT. Dopo aver associato l'account di archiviazione e il contenitore all'hub IoT, l'hub IoT può fornire gli elementi di un URI di firma di accesso condiviso quando richiesto da un dispositivo. Il dispositivo può quindi usare questi elementi per costruire l'URI di firma di accesso condiviso usato per eseguire l'autenticazione con Archiviazione di Azure e caricare file nel contenitore BLOB.

Per associare un account Archiviazione di Azure all'hub IoT:

  1. In Impostazioni hub selezionare Caricamento file nel riquadro sinistro dell'hub IoT.

    Screen capture showing select file upload settings from the portal.

  2. Nel riquadro Caricamento file selezionare Archiviazione di Azure Contenitore. Per questo articolo, è consigliabile che l'account di archiviazione e hub IoT si trovino nella stessa area.

    • Se si ha già un account di archiviazione che si vuole usare, selezionarlo nell'elenco.

    • Per creare un nuovo account di archiviazione, selezionare +Archiviazione account. Specificare un nome per l'account di archiviazione e assicurarsi che Località sia impostata sulla stessa area dell'hub IoT, quindi selezionare OK. Il nuovo account viene creato nello stesso gruppo di risorse dell'hub IoT. Al termine della distribuzione, selezionare l'account di archiviazione nell'elenco.

    Dopo aver selezionato l'account di archiviazione, viene aperto il riquadro Contenitori .

  3. Nel riquadro Contenitori selezionare il contenitore BLOB.

    • Se si ha già un contenitore BLOB che si vuole usare, selezionarlo dall'elenco e fare clic su Seleziona.

    • Per creare un nuovo contenitore BLOB, selezionare + Contenitore. Specificare un nome per il nuovo contenitore. Ai fini di questo articolo, è possibile lasciare predefiniti tutti gli altri campi. Selezionare Crea. Al termine della distribuzione, selezionare il contenitore dall'elenco e fare clic su Seleziona.

  4. Tornare al riquadro Caricamento file , assicurarsi che le notifiche dei file siano impostate su . È possibile lasciare tutte le altre impostazioni predefinite. Selezionare Salva e attendere il completamento delle impostazioni prima di passare alla sezione successiva.

    Screen capture showing confirm file upload settings in the portal.

Per istruzioni più dettagliate su come creare un account Archiviazione di Azure, vedere Creare un account di archiviazione. Per istruzioni più dettagliate su come associare un account di archiviazione e un contenitore BLOB a un hub IoT, vedere Configurare i caricamenti di file usando il portale di Azure.

Creare un progetto con Maven

Creare una directory per il progetto e avviare una shell in tale directory. Nella riga di comando eseguire quanto segue

mvn archetype:generate -DgroupId=com.mycompany.app -DartifactId=my-app -DarchetypeArtifactId=maven-archetype-quickstart -DarchetypeVersion=1.4 -DinteractiveMode=false

Viene generata una directory con lo stesso nome di artifactId e una struttura di progetto standard:

  my-app
  |-- pom.xml
   -- src
      -- main
         -- java
            -- com
               -- mycompany
                  -- app
                     --App.Java

Usando un editor di testo, sostituire il file pom.xml con quanto segue:


<?xml version="1.0" encoding="UTF-8"?>

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>

  <groupId>com.mycompany.app</groupId>
  <artifactId>my-app</artifactId>
  <version>1.0-SNAPSHOT</version>

  <name>my-app</name>
  <!-- FIXME change it to the project's website -->
  <url>http://www.example.com</url>

  <properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <maven.compiler.source>1.7</maven.compiler.source>
    <maven.compiler.target>1.7</maven.compiler.target>
  </properties>

  <dependencies>
      <dependency>
      <groupId>com.microsoft.azure.sdk.iot</groupId>
      <artifactId>iot-device-client</artifactId>
      <version>1.30.1</version>
    </dependency>
    <dependency>
      <groupId>org.slf4j</groupId>
      <artifactId>slf4j-log4j12</artifactId>
      <version>1.7.29</version>
    </dependency>    
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.11</version>
      <scope>test</scope>
    </dependency>
  </dependencies>

  <build>
    <pluginManagement><!-- lock down plugins versions to avoid using Maven defaults (may be moved to parent pom) -->
      <plugins>
        <plugin>
          <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-compiler-plugin</artifactId>
            <version>3.3</version>
            <configuration>
              <source>1.7</source>
              <target>1.7</target>
            </configuration>
        </plugin>
        <plugin>
          <artifactId>maven-shade-plugin</artifactId>
          <version>2.4</version>
          <executions>
              <execution>
                  <phase>package</phase>
                  <goals>
                    <goal>shade</goal>
                  </goals>
                  <configuration>
                      <filters>
                          <filter>
                              <artifact>*:*</artifact>
                              <excludes>
                                  <exclude>META-INF/*.SF</exclude>
                                  <exclude>META-INF/*.RSA</exclude>
                              </excludes>
                          </filter>
                      </filters>
                      <shadedArtifactAttached>true</shadedArtifactAttached>
                      <shadedClassifierName>with-deps</shadedClassifierName>
                  </configuration>
              </execution>
          </executions>
        </plugin>
      </plugins>
    </pluginManagement>
  </build>
</project>

Caricare un file da un'app per dispositivi

Copiare il file da caricare nella cartella nell'albero my-app del progetto. Usando un editor di testo, sostituire App.java con il codice seguente. Specificare la stringa di connessione del dispositivo e il nome del file, dove indicato. La stringa di connessione del dispositivo è stata copiata al momento della registrazione del dispositivo.

package com.mycompany.app;

import com.azure.storage.blob.BlobClient;
import com.azure.storage.blob.BlobClientBuilder;
import com.microsoft.azure.sdk.iot.deps.serializer.FileUploadCompletionNotification;
import com.microsoft.azure.sdk.iot.deps.serializer.FileUploadSasUriRequest;
import com.microsoft.azure.sdk.iot.deps.serializer.FileUploadSasUriResponse;
import com.microsoft.azure.sdk.iot.device.DeviceClient;
import com.microsoft.azure.sdk.iot.device.IotHubClientProtocol;

import java.io.BufferedInputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.net.URISyntaxException;
import java.util.Scanner;

public class App 
{
    /**
     * Upload a single file to blobs using IoT Hub.
     *
     */
    public static void main(String[] args)throws IOException, URISyntaxException
    {
        String connString = "Your device connection string here";
        String fullFileName = "Path of the file to upload";

        System.out.println("Starting...");
        System.out.println("Beginning setup.");

        // File upload will always use HTTPS, DeviceClient will use this protocol only
        //   for the other services like Telemetry, Device Method and Device Twin.
        IotHubClientProtocol protocol = IotHubClientProtocol.MQTT;

        System.out.println("Successfully read input parameters.");

        DeviceClient client = new DeviceClient(connString, protocol);

        System.out.println("Successfully created an IoT Hub client.");

        try
        {
            File file = new File(fullFileName);
            if (file.isDirectory())
            {
                throw new IllegalArgumentException(fullFileName + " is a directory, please provide a single file name, or use the FileUploadSample to upload directories.");
            }

            System.out.println("Retrieving SAS URI from IoT Hub...");
            FileUploadSasUriResponse sasUriResponse = client.getFileUploadSasUri(new FileUploadSasUriRequest(file.getName()));

            System.out.println("Successfully got SAS URI from IoT Hub");
            System.out.println("Correlation Id: " + sasUriResponse.getCorrelationId());
            System.out.println("Container name: " + sasUriResponse.getContainerName());
            System.out.println("Blob name: " + sasUriResponse.getBlobName());
            System.out.println("Blob Uri: " + sasUriResponse.getBlobUri());

            System.out.println("Using the Azure Storage SDK to upload file to Azure Storage...");

            try
            {
                BlobClient blobClient =
                    new BlobClientBuilder()
                        .endpoint(sasUriResponse.getBlobUri().toString())
                        .buildClient();

                blobClient.uploadFromFile(fullFileName);
            }
            catch (Exception e)
            {
                System.out.println("Exception encountered while uploading file to blob: " + e.getMessage());

                System.out.println("Failed to upload file to Azure Storage.");

                System.out.println("Notifying IoT Hub that the SAS URI can be freed and that the file upload failed.");

                // Note that this is done even when the file upload fails. IoT Hub has a fixed number of SAS URIs allowed active
                // at any given time. Once you are done with the file upload, you should free your SAS URI so that other
                // SAS URIs can be generated. If a SAS URI is not freed through this API, then it will free itself eventually
                // based on how long SAS URIs are configured to live on your IoT Hub.
                FileUploadCompletionNotification completionNotification = new FileUploadCompletionNotification(sasUriResponse.getCorrelationId(), false);
                client.completeFileUpload(completionNotification);

                System.out.println("Notified IoT Hub that the SAS URI can be freed and that the file upload was a failure.");

                client.closeNow();
                return;
            }

            System.out.println("Successfully uploaded file to Azure Storage.");

            System.out.println("Notifying IoT Hub that the SAS URI can be freed and that the file upload was a success.");
            FileUploadCompletionNotification completionNotification = new FileUploadCompletionNotification(sasUriResponse.getCorrelationId(), true);
            client.completeFileUpload(completionNotification);
            System.out.println("Successfully notified IoT Hub that the SAS URI can be freed, and that the file upload was a success");
        }
        catch (Exception e)
        {
            System.out.println("On exception, shutting down \n" + " Cause: " + e.getCause() + " \nERROR: " +  e.getMessage());
            System.out.println("Shutting down...");
            client.closeNow();
        }

        System.out.println("Press any key to exit...");

        Scanner scanner = new Scanner(System.in);
        scanner.nextLine();
        System.out.println("Shutting down...");
        client.closeNow();
    }
}

Compilare ed eseguire l'applicazione

Al prompt dei comandi nella cartella my-app eseguire il comando seguente:

mvn clean package -DskipTests

Al termine della compilazione, eseguire il comando seguente per eseguire l'applicazione:

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

Per visualizzare il file caricato nel contenitore di archiviazione configurato, è possibile usare il portale:

Uploaded file

Ricevere la notifica di caricamento di un file

In questa sezione viene creata un'app console Java che riceve messaggi di notifica di caricamento file dall'hub IoT.

  1. Creare una directory per il progetto e avviare una shell in tale directory. Nella riga di comando eseguire quanto segue

    mvn archetype:generate -DgroupId=com.mycompany.app -DartifactId=my-app -DarchetypeArtifactId=maven-archetype-quickstart -DarchetypeVersion=1.4 -DinteractiveMode=false
    
  2. Al prompt dei comandi passare alla nuova cartella my-app.

  3. Usando un editor di testo, sostituire il pom.xml file nella my-app cartella con il codice seguente. L'aggiunta della dipendenza client del servizio consente di usare il pacchetto iothub-java-service-client nell'applicazione per comunicare con il servizio hub IoT:

    <?xml version="1.0" encoding="UTF-8"?>
    
    <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
      xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
      <modelVersion>4.0.0</modelVersion>
    
      <groupId>com.mycompany.app</groupId>
      <artifactId>my-app</artifactId>
      <version>1.0-SNAPSHOT</version>
    
      <name>my-app</name>
      <!-- FIXME change it to the project's website -->
      <url>http://www.example.com</url>
    
      <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <maven.compiler.source>1.7</maven.compiler.source>
        <maven.compiler.target>1.7</maven.compiler.target>
      </properties>
    
      <dependencies>
          <dependency>
          <groupId>com.microsoft.azure.sdk.iot</groupId>
          <artifactId>iot-device-client</artifactId>
          <version>1.30.1</version>
        </dependency>
        <dependency>
          <groupId>com.microsoft.azure.sdk.iot</groupId>
          <artifactId>iot-service-client</artifactId>
          <version>1.7.23</version>
        </dependency>
        <dependency>
          <groupId>org.slf4j</groupId>
          <artifactId>slf4j-log4j12</artifactId>
          <version>1.7.29</version>
        </dependency>    
        <dependency>
          <groupId>junit</groupId>
          <artifactId>junit</artifactId>
          <version>4.11</version>
          <scope>test</scope>
        </dependency>
      </dependencies>
    
      <build>
        <pluginManagement><!-- lock down plugins versions to avoid using Maven defaults (may be moved to parent pom) -->
          <plugins>
            <plugin>
              <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.3</version>
                <configuration>
                  <source>1.7</source>
                  <target>1.7</target>
                </configuration>
            </plugin>
            <plugin>
              <artifactId>maven-shade-plugin</artifactId>
              <version>2.4</version>
              <executions>
                  <execution>
                      <phase>package</phase>
                      <goals>
                        <goal>shade</goal>
                      </goals>
                      <configuration>
                          <filters>
                              <filter>
                                  <artifact>*:*</artifact>
                                  <excludes>
                                      <exclude>META-INF/*.SF</exclude>
                                      <exclude>META-INF/*.RSA</exclude>
                                  </excludes>
                              </filter>
                          </filters>
                          <shadedArtifactAttached>true</shadedArtifactAttached>
                          <shadedClassifierName>with-deps</shadedClassifierName>
                      </configuration>
                  </execution>
              </executions>
            </plugin>
          </plugins>
        </pluginManagement>
      </build>
    </project>
    

    Nota

    È possibile cercare la versione più recente di iot-service-client usando la ricerca di Maven.

  4. Salvare e chiudere il file pom.xml.

  5. Ottenere la stringa di connessione del servizio hub IoT.

    Per ottenere la stringa di connessione dell'hub IoT per i criteri del servizio, seguire questa procedura:

    1. Nel portale di Azure fare clic su Gruppi di risorse. Selezionare il gruppo di risorse in cui si trova l'hub e quindi selezionare l'hub dall'elenco di risorse.

    2. Nel riquadro sinistro dell'hub IoT selezionare Criteri di accesso condiviso.

    3. Dall'elenco dei criteri selezionare i criteri del servizio.

    4. In Chiavi di accesso condiviso selezionare l'icona di copia per la stringa di connessione primaria e salvare il valore.

    Screenshot that shows how to retrieve the connection string

    Per altre informazioni sui criteri di accesso condiviso e sulle autorizzazioni dell'hub IoT, vedere Controllo dell'accesso e autorizzazioni.

  6. Usando un editor di testo, aprire il my-app\src\main\java\com\mycompany\app\App.java file e sostituire il codice con il codice seguente.

    package com.mycompany.app;
    
    import com.microsoft.azure.sdk.iot.service.*;
    import java.io.IOException;
    import java.net.URISyntaxException;
    import java.util.concurrent.ExecutorService;
    import java.util.concurrent.Executors;
    
    
    public class App 
    {
        private static final String connectionString = "{Your service connection string here}";
        private static final IotHubServiceClientProtocol protocol = IotHubServiceClientProtocol.AMQPS;
    
        public static void main(String[] args) throws Exception
        {
            ServiceClient sc = ServiceClient.createFromConnectionString(connectionString, protocol);
    
            FileUploadNotificationReceiver receiver = sc.getFileUploadNotificationReceiver();
            receiver.open();
            FileUploadNotification fileUploadNotification = receiver.receive(2000);
    
            if (fileUploadNotification != null)
            {
                System.out.println("File Upload notification received");
                System.out.println("Device Id : " + fileUploadNotification.getDeviceId());
                System.out.println("Blob Uri: " + fileUploadNotification.getBlobUri());
                System.out.println("Blob Name: " + fileUploadNotification.getBlobName());
                System.out.println("Last Updated : " + fileUploadNotification.getLastUpdatedTimeDate());
                System.out.println("Blob Size (Bytes): " + fileUploadNotification.getBlobSizeInBytes());
                System.out.println("Enqueued Time: " + fileUploadNotification.getEnqueuedTimeUtcDate());
            }
            else
            {
                System.out.println("No file upload notification");
            }
    
            receiver.close();
        }
    
    }
    
  7. Salva e chiude il file my-app\src\main\java\com\mycompany\app\App.java.

  8. Usare il comando seguente per compilare l'app e verificare la presenza di errori:

    mvn clean package -DskipTests
    

Eseguire l'applicazione

A questo punto è possibile eseguire l'applicazione.

Al prompt dei comandi nella cartella my-app eseguire il comando seguente:

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

Lo screenshot seguente presenta l'output dell'app read-file-upload-notification:

Output from read-file-upload-notification app

Passaggi successivi

In questa esercitazione si è appreso come usare le funzionalità di caricamento file dell'hub IoT per semplificare i caricamenti di file dai dispositivi. È possibile continuare a esplorare le funzionalità e gli scenari dell'hub IoT vedendo i seguenti articoli:

Per altre informazioni sulle funzionalità dell'hub IoT, vedere: