Carregue ficheiros do seu dispositivo para a nuvem com o Hub IoT do Azure (Python)

Artigo
01/29/2024

Este artigo demonstra como carregar um arquivo do Hub IoT para carregar um arquivo no armazenamento de blob do Azure, usando Python.

Os artigos Enviar telemetria de um dispositivo para um início rápido do hub IoT e Enviar mensagens da nuvem para o dispositivo com o Hub IoT mostram a funcionalidade básica de mensagens de dispositivo para nuvem e de nuvem para dispositivo do Hub IoT. O tutorial Configurar Roteamento de Mensagens com o Hub IoT mostra uma maneira confiável de armazenar mensagens do dispositivo para a nuvem no armazenamento de blobs do Microsoft Azure. No entanto, em alguns cenários, você não pode mapear facilmente os dados que seus dispositivos enviam para as mensagens relativamente pequenas de dispositivo para nuvem que o Hub IoT aceita. Por exemplo:

Vídeos
Arquivos grandes que contêm imagens
Dados de vibração amostrados em alta frequência
Alguma forma de dados pré-processados.

Esses arquivos geralmente são processados em lote na nuvem, usando ferramentas como o Azure Data Factory ou a pilha Hadoop . Quando você precisa carregar arquivos de um dispositivo, ainda pode usar a segurança e a confiabilidade do Hub IoT. Este artigo mostra-lhe como.

No final deste artigo, você executa o aplicativo de console Python FileUpload.py, que carrega um arquivo para o armazenamento usando o Python Device SDK.

Nota

O Hub IoT dá suporte a muitas plataformas e linguagens de dispositivo (incluindo C, Java, Python e JavaScript) por meio de SDKs de dispositivo IoT do Azure. Consulte o Azure IoT Developer Center para saber como conectar seu dispositivo ao Hub IoT do Azure.

Importante

A funcionalidade de carregamento de ficheiros em dispositivos que utilizam a autenticação da autoridade de certificação (CA) X.509 está em pré-visualização pública e o modo de pré-visualização tem de estar ativado. Está geralmente disponível em dispositivos que utilizam a autenticação de impressão digital X.509 ou o atestado de certificado X.509 com o Serviço de Aprovisionamento de Dispositivos do Azure. Para saber mais sobre a autenticação X.509 com o Hub IoT, consulte Certificados X.509 suportados.

Pré-requisitos

Uma conta ativa do Azure. (Se não tiver uma conta, pode criar uma conta gratuita em apenas alguns minutos.)
Um hub IoT. Crie um com a CLI ou o portal do Azure.
Um dispositivo registado. Registre um no portal do Azure.
Python versão 3.7 ou posterior é recomendado. Certifique-se de que utiliza a instalação de 32 ou 64 bits, conforme exigido pela sua configuração. Quando lhe for pedido durante a instalação, confirme que adiciona Python à variável de ambiente específica da sua plataforma.
A porta 8883 deve estar aberta no firewall. O exemplo de dispositivo neste artigo usa o protocolo MQTT, que se comunica pela porta 8883. Essa porta pode estar bloqueada em alguns ambientes de rede corporativa e educacional. Para obter mais informações e maneiras de contornar esse problema, consulte Conectando-se ao Hub IoT (MQTT).

Associar uma conta de Armazenamento do Azure ao Hub IoT

Para carregar arquivos de um dispositivo, você deve ter uma conta de Armazenamento do Azure e um contêiner de Armazenamento de Blob do Azure associados ao seu hub IoT. Depois de associar a conta de armazenamento e o contêiner ao hub IoT, o hub IoT pode fornecer os elementos de um URI SAS quando solicitado por um dispositivo. O dispositivo pode usar esses elementos para construir o URI SAS que ele usa para autenticar com o Armazenamento do Azure e carregar arquivos no contêiner de blob.

Para associar uma conta de Armazenamento do Azure ao seu hub IoT:

Em Configurações do Hub, selecione Carregamento de arquivo no painel esquerdo do seu hub IoT.
No painel Carregamento de arquivo, selecione Contêiner de Armazenamento do Azure. Para este artigo, é recomendável que sua conta de armazenamento e o Hub IoT estejam localizados na mesma região.
- Se você já tiver uma conta de armazenamento que deseja usar, selecione-a na lista.
- Para criar uma nova conta de armazenamento, selecione +Conta de armazenamento. Forneça um nome para a conta de armazenamento e verifique se o Local está definido para a mesma região do seu hub IoT e, em seguida, selecione OK. A nova conta é criada no mesmo grupo de recursos do seu hub IoT. Quando a implantação for concluída, selecione a conta de armazenamento na lista.
Depois de selecionar a conta de armazenamento, o painel Contêineres é aberto.
No painel Contêineres, selecione o contêiner de blob.
- Se você já tiver um contêiner de blob que deseja usar, selecione-o na lista e clique em Selecionar.
- Para criar um novo contêiner de blob, selecione + Contêiner. Forneça um nome para o novo contêiner. Para os fins deste artigo, você pode deixar todos os outros campos em seu padrão. Selecione Criar. Quando a implantação for concluída, selecione o contêiner na lista e clique em Selecionar.
De volta ao painel Carregamento de ficheiros, certifique-se de que as notificações de ficheiros estão definidas como Ativado. Você pode deixar todas as outras configurações em seus padrões. Selecione Salvar e aguarde a conclusão das configurações antes de passar para a próxima seção.

Para obter instruções mais detalhadas sobre como criar uma conta de Armazenamento do Azure, consulte Criar uma conta de armazenamento. Para obter instruções mais detalhadas sobre como associar uma conta de armazenamento e um contêiner de blob a um hub IoT, consulte Configurar carregamentos de arquivos usando o portal do Azure.

Carregar um ficheiro a partir de uma aplicação de dispositivo

Nesta seção, você cria o aplicativo de dispositivo para carregar um arquivo no hub IoT.

No prompt de comando, execute o seguinte comando para instalar o pacote azure-iot-device . Use este pacote para coordenar o carregamento de arquivos com seu hub IoT.
```
pip install azure-iot-device
```
No prompt de comando, execute o seguinte comando para instalar o pacote azure.storage.blob. Use este pacote para executar o upload do arquivo.
```
pip install azure.storage.blob
```
Crie um arquivo de teste que você carregará para o armazenamento de blobs.
Usando um editor de texto, crie um arquivo de FileUpload.py em sua pasta de trabalho.

Adicione as seguintes import instruções e variáveis no início do arquivo 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]"

No arquivo, substitua [Device Connection String] pela cadeia de conexão do dispositivo do hub IoT. Substitua [Full path to local file] pelo caminho para o arquivo de teste que você criou ou qualquer arquivo no seu dispositivo que você deseja carregar.

Crie uma função para carregar o arquivo para o armazenamento de blobs:

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)

Essa função analisa a estrutura de blob_info passada para ela para criar uma URL que ela usa para inicializar um azure.storage.blob.BlobClient. Em seguida, ele carrega seu arquivo no armazenamento de blob do Azure usando esse cliente.

Adicione o seguinte código para conectar o cliente e carregar o arquivo:

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()

Esse código cria um IoTHubDeviceClient e usa as seguintes APIs para gerenciar o carregamento de arquivos com seu hub IoT:

get_storage_info_for_blob obtém informações do seu hub IoT sobre a Conta de Armazenamento vinculada que você criou anteriormente. Essas informações incluem o nome do host, o nome do contêiner, o nome do blob e um token SAS. As informações de armazenamento são passadas para a função store_blob (criada na etapa anterior), para que o BlobClient nessa função possa se autenticar com o armazenamento do Azure. O método get_storage_info_for_blob também retorna um correlation_id, que é usado no método notify_blob_upload_status . O correlation_id é a maneira do Hub IoT marcar em qual blob você está trabalhando.
notify_blob_upload_status notifica o Hub IoT sobre o status da operação de armazenamento de blobs. Você passa o correlation_id obtido pelo método get_storage_info_for_blob . Ele é usado pelo Hub IoT para notificar qualquer serviço que possa estar escutando uma notificação sobre o status da tarefa de carregamento de arquivo.

Salve e feche o arquivo FileUpload.py .

Executar a aplicação

Agora você está pronto para executar o aplicativo.

Em um prompt de comando na pasta de trabalho, execute o seguinte comando:
```
python FileUpload.py
```
A captura de tela a seguir mostra a saída do aplicativo FileUpload :
Você pode usar o portal para exibir o arquivo carregado no contêiner de armazenamento que você configurou:

Próximos passos

Neste artigo, você aprendeu como usar o recurso de carregamento de arquivos do Hub IoT para simplificar o carregamento de arquivos de dispositivos. Pode continuar a explorar esta funcionalidade com os seguintes artigos:

Saiba mais sobre o Armazenamento de Blobs do Azure com os seguintes links:

Share via