Caricare file dal dispositivo al cloud con hub IoT di Azure (Python)

Articolo
06/24/2023

Questo articolo illustra come caricare file funzionalità di hub IoT caricare un file nell'archivio BLOB di Azure usando Python.

La guida introduttiva Inviare dati di telemetria da un dispositivo a un hub IoT e Inviare messaggi da cloud a dispositivo con hub IoT articoli illustrano le funzionalità di messaggistica da dispositivo a cloud e da cloud a dispositivo di hub IoT. L'esercitazione Configurare il routing dei messaggi con hub IoT illustra un modo per archiviare in modo affidabile i messaggi da dispositivo a cloud nell'archivio BLOB di Microsoft Azure. In alcuni scenari, tuttavia, non è possibile eseguire facilmente il mapping dei dati inviati dai dispositivi nei messaggi da dispositivo a cloud relativamente piccoli accettati hub IoT. Ad esempio:

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

Questi file vengono in genere elaborati in batch nel cloud, usando strumenti come Azure Data Factory o lo stack Hadoop . Quando è necessario caricare i file da un dispositivo, è comunque possibile usare la sicurezza e affidabilità dell'hub IoT. Questo articolo illustra i passaggi da eseguire.

Alla fine di questo articolo si esegue l'app console Python FileUpload.py, che carica un file nell'archiviazione usando Python Device SDK.

Nota

hub IoT supporta molte piattaforme e linguaggi per dispositivi (tra cui C, Java, Python e JavaScript) tramite Azure IoT SDK per dispositivi. Fare riferimento al Centro per sviluppatori Azure IoT per informazioni su come connettere il dispositivo a hub IoT di Azure.

Importante

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

Prerequisiti

Un account Azure attivo. Se non si dispone di un account, è possibile crearne uno gratuito in pochi minuti.
Un hub IoT. Crearne uno con l'interfaccia della riga di comando o il portale di Azure.
Un dispositivo registrato. Registrarne uno nel portale di Azure.
È consigliabile usare Python versione 3.7 o successive. Assicurarsi di usare le installazioni a 32 bit o 64 bit, come richiesto dalla configurazione. Quando richiesto durante l'installazione, assicurarsi di aggiungere Python alla variabile di ambiente specifica per la piattaforma.
La porta 8883 deve essere 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).

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 i file nel contenitore BLOB.

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

In Impostazioni hub selezionare Caricamento file nel riquadro sinistro dell'hub IoT.
Nel riquadro Caricamentofile selezionare Archiviazione di Azure Contenitore. Per questo articolo, è consigliabile che l'account di archiviazione e hub IoT trovarsi 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 visualizzato il riquadro Contenitori .
Nel riquadro Contenitori selezionare il contenitore BLOB.
- Se si ha già un contenitore BLOB che si vuole usare, selezionarlo nell'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 tutti gli altri campi come predefiniti. Seleziona Crea. Al termine della distribuzione, selezionare il contenitore dall'elenco e fare clic su Seleziona.
Tornare al riquadro Caricamento file, assicurarsi che le notifiche dei file siano impostate su Sì. È possibile lasciare tutte le altre impostazioni predefinite. Selezionare Salva e attendere il completamento delle impostazioni prima di passare alla sezione successiva.

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.

Caricare un file da un'app per dispositivi

In questa sezione viene creata l'app del dispositivo per caricare un file nell'hub IoT.

Al prompt dei comandi eseguire il comando seguente per installare il pacchetto azure-iot-device . Questo pacchetto viene usato per coordinare il caricamento del file con l'hub IoT.
```
pip install azure-iot-device
```
Al prompt dei comandi eseguire il comando seguente per installare il pacchetto azure.storage.blob. Usare questo pacchetto per eseguire il caricamento del file.
```
pip install azure.storage.blob
```
Creare un file di test che verrà caricato nell'archivio BLOB.
Con un editor di testo, creare un file FileUpload.py nella cartella di lavoro.

Aggiungere le variabili e le istruzioni import seguenti all'inizio del file FileUpload.py.

import os
from azure.iot.device import IoTHubDeviceClient
from azure.core.exceptions import AzureError
from azure.storage.blob import BlobClient

CONNECTION_STRING = "[Device Connection String]"
PATH_TO_FILE = r"[Full path to local file]"

Nel file sostituire [Device Connection String] con la stringa di connessione del dispositivo dell'hub IoT. Sostituire [Full path to local file] con il percorso del file di test creato o di qualsiasi file nel dispositivo da caricare.

Creare una funzione per caricare il file nell'archivio BLOB:

def store_blob(blob_info, file_name):
    try:
        sas_url = "https://{}/{}/{}{}".format(
            blob_info["hostName"],
            blob_info["containerName"],
            blob_info["blobName"],
            blob_info["sasToken"]
        )

        print("\nUploading file: {} to Azure Storage as blob: {} in container {}\n".format(file_name, blob_info["blobName"], blob_info["containerName"]))

        # Upload the specified file
        with BlobClient.from_blob_url(sas_url) as blob_client:
            with open(file_name, "rb") as f:
                result = blob_client.upload_blob(f, overwrite=True)
                return (True, result)

    except FileNotFoundError as ex:
        # catch file not found and add an HTTP status code to return in notification to IoT Hub
        ex.status_code = 404
        return (False, ex)

    except AzureError as ex:
        # catch Azure errors that might result from the upload operation
        return (False, ex)

Questa funzione analizza la struttura blob_info passata per creare un URL usato per inizializzare azure.storage.blob.BlobClient. Carica quindi il file nell'archivio BLOB di Azure usando questo client.

Aggiungere il codice seguente per connettere il client e caricare il file:

def run_sample(device_client):
    # Connect the client
    device_client.connect()

    # Get the storage info for the blob
    blob_name = os.path.basename(PATH_TO_FILE)
    storage_info = device_client.get_storage_info_for_blob(blob_name)

    # Upload to blob
    success, result = store_blob(storage_info, PATH_TO_FILE)

    if success == True:
        print("Upload succeeded. Result is: \n") 
        print(result)
        print()

        device_client.notify_blob_upload_status(
            storage_info["correlationId"], True, 200, "OK: {}".format(PATH_TO_FILE)
        )

    else :
        # If the upload was not successful, the result is the exception object
        print("Upload failed. Exception is: \n") 
        print(result)
        print()

        device_client.notify_blob_upload_status(
            storage_info["correlationId"], False, result.status_code, str(result)
        )

def main():
    device_client = IoTHubDeviceClient.create_from_connection_string(CONNECTION_STRING)

    try:
        print ("IoT Hub file upload sample, press Ctrl-C to exit")
        run_sample(device_client)
    except KeyboardInterrupt:
        print ("IoTHubDeviceClient sample stopped")
    finally:
        # Graceful exit
        device_client.shutdown()


if __name__ == "__main__":
    main()

Questo codice crea un IoTHubDeviceClient e usa le API seguenti per gestire il caricamento del file con l'hub IoT:

get_storage_info_for_blob ottiene informazioni dall'hub IoT sull'account Archiviazione collegato creato in precedenza. Queste informazioni includono il nome host, il nome del contenitore, il nome del BLOB e un token di firma di accesso condiviso. Le informazioni di archiviazione vengono passate alla funzione store_blob (creata nel passaggio precedente), in modo che BlobClient in tale funzione possa eseguire l'autenticazione con Archiviazione di Azure. Il metodo get_storage_info_for_blob restituisce anche un correlation_id, utilizzato nel metodo notify_blob_upload_status . Il correlation_id è hub IoT modo di contrassegnare il BLOB su cui si sta lavorando.
notify_blob_upload_status notifica hub IoT dello stato dell'operazione di archiviazione BLOB. Si passa il correlation_id ottenuto dal metodo get_storage_info_for_blob . Viene usato da hub IoT per notificare a qualsiasi servizio che potrebbe essere in ascolto di una notifica sullo stato dell'attività di caricamento file.

Salvare e chiudere il file FileUpload.py .

Eseguire l'applicazione

A questo punto è possibile eseguire l'applicazione.

Al prompt dei comandi nella cartella di lavoro eseguire il comando seguente:
```
python FileUpload.py
```
Lo screenshot seguente mostra l'output dell'app FileUpload:
Per visualizzare il file caricato nel contenitore di archiviazione configurato, è possibile usare il portale:

Passaggi successivi

In questo articolo si è appreso come usare la funzionalità di caricamento dei file di hub IoT per semplificare i caricamenti di file dai dispositivi. È possibile continuare a esplorare questa funzionalità con gli articoli seguenti:

Altre informazioni sulle Archiviazione BLOB di Azure con i collegamenti seguenti: