Začínáme se správou zařízení (Python)

Článek
03/16/2023

Back-endové aplikace můžou pomocí Azure IoT Hub primitiv, jako jsou dvojčata zařízení a přímé metody, vzdáleně spouštět a monitorovat akce správy zařízení na zařízeních. V tomto článku se dozvíte, jak back-endová aplikace a aplikace zařízení můžou spolupracovat na zahájení a monitorování vzdáleného restartování zařízení pomocí IoT Hub.

Poznámka

Funkce popsané v tomto článku jsou k dispozici pouze na úrovni Standard IoT Hub. Další informace o úrovních IoT Hub Basic a Standard/Free najdete v tématu Volba správné IoT Hub úrovně pro vaše řešení.

K zahájení akcí správy zařízení (jako je restartování, obnovení továrního nastavení a aktualizace firmwaru) z back-endové aplikace v cloudu použijte přímou metodu. Zařízení zodpovídá za:

Zpracování požadavku metody odeslaného z IoT Hub
Inicializování odpovídající akce specifické pro zařízení na zařízení.
Poskytování aktualizací stavu prostřednictvím ohlášených vlastností IoT Hub.

Pomocí back-endové aplikace v cloudu můžete spouštět dotazy dvojčat zařízení a hlásit tak průběh akcí správy zařízení.

V tomto článku se dozvíte, jak vytvořit:

dmpatterns_getstarted_device.py: aplikace simulovaného zařízení s přímou metodou, která zařízení restartuje a hlásí čas posledního restartování. Přímé metody se volají z cloudu.
dmpatterns_getstarted_service.py: konzolová aplikace Pythonu, která volá přímou metodu v aplikaci simulovaného zařízení prostřednictvím služby IoT Hub. Zobrazí odpověď a aktualizuje ohlášené vlastnosti.

Poznámka

Další informace o nástrojích sady SDK, které jsou k dispozici pro vytváření aplikací pro zařízení i back-end, najdete v tématu Sady SDK Pro Azure IoT.

Požadavky

Aktivní účet Azure. (Pokud účet nemáte, můžete si bezplatný účet vytvořit za pár minut.)
Centrum IoT. Vytvořte ho pomocí rozhraní příkazového řádku nebo Azure Portal.
Zaregistrované zařízení. Zaregistrujte jednu v Azure Portal.
Doporučuje se Python verze 3.7 nebo novější. Ujistěte se, že používáte 32bitovou, nebo 64bitovou instalaci podle požadavků vašeho nastavení. Po zobrazení výzvy v průběhu instalace nezapomeňte přidat Python do proměnné prostředí pro konkrétní platformu.
Ujistěte se, že je v bráně firewall otevřený port 8883. Ukázka zařízení v tomto článku používá protokol MQTT, který komunikuje přes port 8883. Tento port může být v některých podnikových a vzdělávacích síťových prostředích blokovaný. Další informace a způsoby, jak tento problém obejít, najdete v tématu Připojení k IoT Hub (MQTT).

Registrace nového zařízení ve službě IoT Hub

V této části použijete Azure CLI k vytvoření identity zařízení pro tento článek. V ID zařízení se rozlišují malá a velká písmena.

Otevřete Azure Cloud Shell.
V Azure Cloud Shell spuštěním následujícího příkazu nainstalujte rozšíření Microsoft Azure IoT pro Azure CLI:
```
az extension add --name azure-iot
```
Pomocí těchto příkazů vytvořte novou identitu zařízení s názvem myDeviceId a načtěte připojovací řetězec zařízení:
```
az iot hub device-identity create --device-id myDeviceId --hub-name {Your IoT Hub name} --resource-group {Resource group of the Hub}
az iot hub device-identity connection-string show --device-id myDeviceId --hub-name {Your IoT Hub name} --resource-group {Resource group of the Hub} -o table
```
Důležité

ID zařízení se může zobrazit v protokolech shromažďovaných pro účely zákaznické podpory a řešení potíží, proto se ujistěte, že při pojmenování nepoužíváte žádné citlivé údaje.

Poznamenejte si připojovací řetězec zařízení z výsledku. Tento připojovací řetězec zařízení používá aplikace zařízení k připojení k vašemu IoT Hub jako zařízení.

Vytvoření aplikace zařízení pomocí přímé metody

V této části:

Vytvořte konzolovou aplikaci Pythonu, která reaguje na přímou metodu volanou cloudem.
Simulace restartování zařízení
Pomocí ohlášených vlastností povolte dotazy dvojčat zařízení k identifikaci zařízení a jejich posledního restartování.

V Azure Cloud Shell, které jste dříve použili, nebo v jakémkoli jiném prostředí s Pythonem vytvořte kód zařízení.

Spuštěním následujícího příkazu na příkazovém řádku nainstalujte balíček azure-iot-device :
```
pip install azure-iot-device
```
Pomocí textového editoru vytvořte v pracovním adresáři soubor s názvem dmpatterns_getstarted_device.py .

Na začátek souboru dmpatterns_getstarted_device.py přidejte následující import příkazy.

import time
import datetime
from azure.iot.device import IoTHubDeviceClient, MethodResponse

Přidejte proměnnou CONNECTION_STRING . {deviceConnectionString} Zástupnou hodnotu nahraďte připojovacím řetězcem zařízení. Tento připojovací řetězec jste dříve zkopírovali v části Registrace nového zařízení v centru IoT.
```
CONNECTION_STRING = "{deviceConnectionString}"
```

Přidejte následující funkci pro vytvoření instance klienta nakonfigurovaného pro přímé metody na zařízení.

def create_client():
    # Instantiate the client
    client = IoTHubDeviceClient.create_from_connection_string(CONNECTION_STRING)

    # Define the handler for method requests
    def method_request_handler(method_request):
        if method_request.name == "rebootDevice":
            # Act on the method by rebooting the device
            print("Rebooting device")
            time.sleep(20)
            print("Device rebooted")

            # ...and patching the reported properties
            current_time = str(datetime.datetime.now())
            reported_props = {"rebootTime": current_time}
            client.patch_twin_reported_properties(reported_props)
            print( "Device twins updated with latest rebootTime")

            # Create a method response indicating the method request was resolved
            resp_status = 200
            resp_payload = {"Response": "This is the response from the device"}
            method_response = MethodResponse(method_request.request_id, resp_status, resp_payload)

        else:
            # Create a method response indicating the method request was for an unknown method
            resp_status = 404
            resp_payload = {"Response": "Unknown method"}
            method_response = MethodResponse(method_request.request_id, resp_status, resp_payload)

        # Send the method response
        client.send_method_response(method_response)

    try:
        # Attach the handler to the client
        client.on_method_request_received = method_request_handler
    except:
        # In the event of failure, clean up
        client.shutdown()

    return client

Spusťte ukázku přímé metody a počkejte.

def main():
    print ("Starting the IoT Hub Python sample...")
    client = create_client()

    print ("Waiting for commands, press Ctrl-C to exit")
    try:
        # Wait for program exit
        while True:
            time.sleep(1000)
    except KeyboardInterrupt:
        print("IoTHubDeviceClient sample stopped")
    finally:
        # Graceful exit
        print("Shutting down IoT Hub Client")
        client.shutdown()

if __name__ == '__main__':
    main()

Uložte a zavřete soubor dmpatterns_getstarted_device.py .

Poznámka

Za účelem zjednodušení tento kurz neimplementuje žádné zásady opakování. V produkčním kódu byste měli implementovat zásady opakování (například exponenciální zpochybnění), jak navrhuje článek Zpracování přechodných chyb.

Získání připojovacího řetězce služby IoT Hub

V tomto článku vytvoříte back-endovou službu, která na zařízení vyvolá přímou metodu. K vyvolání přímé metody na zařízení prostřednictvím IoT Hub potřebuje vaše služba oprávnění připojení služby. Ve výchozím nastavení se každá IoT Hub vytvoří se zásadou sdíleného přístupu s názvem služba, která toto oprávnění uděluje.

Chcete-li získat IoT Hub připojovací řetězec pro zásady služby, postupujte takto:

V Azure Portal vyberte Skupiny prostředků. Vyberte skupinu prostředků, ve které se nachází vaše centrum, a pak vyberte centrum ze seznamu prostředků.
V levém podokně centra IoT vyberte Zásady sdíleného přístupu.
V seznamu zásad vyberte zásadu služby .
Zkopírujte primární připojovací řetězec a hodnotu uložte.

Další informace o IoT Hub zásady a oprávnění sdíleného přístupu najdete v tématu Řízení přístupu a oprávnění.

Vytvoření aplikace služby pro aktivaci restartování

V této části vytvoříte konzolovou aplikaci Pythonu, která zahájí vzdálené restartování zařízení pomocí přímé metody. Aplikace používá dotazy dvojčat zařízení ke zjištění času posledního restartování daného zařízení.

V Azure Cloud Shell nebo jiném prostředí s Pythonem vytvořte kód konzoly.

Spuštěním následujícího příkazu na příkazovém řádku nainstalujte balíček azure-iot-hub :
```
pip install azure-iot-hub
```
Pomocí textového editoru vytvořte v pracovním adresáři soubor s názvem dmpatterns_getstarted_service.py .

Na začátek souboru dmpatterns_getstarted_service.py přidejte následující import příkazy.

import sys, time

from azure.iot.hub import IoTHubRegistryManager
from azure.iot.hub.models import CloudToDeviceMethod, CloudToDeviceMethodResult, Twin

Přidejte následující deklarace proměnných. {IoTHubConnectionString} Nahraďte hodnotu zástupného symbolu připojovacím řetězcem služby IoT Hub, který jste zkopírovali dříve v části Získání připojovacího řetězce služby IoT Hub. {deviceId} Zástupnou hodnotu nahraďte ID zařízení, které jste zaregistrovali v části Registrace nového zařízení ve službě IoT Hub.
```
CONNECTION_STRING = "{IoTHubConnectionString}"
DEVICE_ID = "{deviceId}"

METHOD_NAME = "rebootDevice"
METHOD_PAYLOAD = "{\"method_number\":\"42\"}"
TIMEOUT = 60
WAIT_COUNT = 10
```

Přidejte následující funkci, která vyvolá metodu zařízení k restartování cílového zařízení, pak se dotazuje na dvojčata zařízení a získá čas posledního restartování.

def iothub_devicemethod_sample_run():
    try:
        # Create IoTHubRegistryManager
        registry_manager = IoTHubRegistryManager(CONNECTION_STRING)

        print ( "" )
        print ( "Invoking device to reboot..." )

        # Call the direct method.
        deviceMethod = CloudToDeviceMethod(method_name=METHOD_NAME, payload=METHOD_PAYLOAD)
        response = registry_manager.invoke_device_method(DEVICE_ID, deviceMethod)

        print ( "" )
        print ( "Successfully invoked the device to reboot." )

        print ( "" )
        print ( response.payload )

        while True:
            print ( "" )
            print ( "IoTHubClient waiting for commands, press Ctrl-C to exit" )

            status_counter = 0
            while status_counter <= WAIT_COUNT:
                twin_info = registry_manager.get_twin(DEVICE_ID)

                if twin_info.properties.reported.get("rebootTime") != None :
                    print ("Last reboot time: " + twin_info.properties.reported.get("rebootTime"))
                else:
                    print ("Waiting for device to report last reboot time...")

                time.sleep(5)
                status_counter += 1

    except Exception as ex:
        print ( "" )
        print ( "Unexpected error {0}".format(ex) )
        return
    except KeyboardInterrupt:
        print ( "" )
        print ( "IoTHubDeviceMethod sample stopped" )

if __name__ == '__main__':
    print ( "Starting the IoT Hub Service Client DeviceManagement Python sample..." )
    print ( "    Connection string = {0}".format(CONNECTION_STRING) )
    print ( "    Device ID         = {0}".format(DEVICE_ID) )

    iothub_devicemethod_sample_run()

Uložte a zavřete soubor dmpatterns_getstarted_service.py .

Spouštění aplikací

Teď jste připraveni spustit kód zařízení a kód služby, který zahájí restartování zařízení.

Na příkazovém řádku, kde jste zařízení vytvořili, spusťte následující příkaz, který začne naslouchat přímé metodě restartování.
```
python dmpatterns_getstarted_device.py
```
Na příkazovém řádku, kde službu vytváříte, spusťte následující příkaz, který aktivuje vzdálené restartování a dotazem na dvojče zařízení zjistí čas posledního restartování.
```
python dmpatterns_getstarted_service.py
```
V konzole se zobrazí odpověď zařízení na přímou metodu.

Následující příklad ukazuje odpověď zařízení na metodu přímého restartování:

Následující příklad ukazuje službu, která volá přímou metodu restartování a dotazuje se dvojčete zařízení na stav:

Přizpůsobení a rozšíření akcí správy zařízení

Vaše řešení IoT můžou rozšířit definovanou sadu vzorů správy zařízení nebo povolit vlastní vzory pomocí primitiv dvojčat zařízení a metod typu cloud-zařízení. Mezi další příklady akcí správy zařízení patří obnovení továrního nastavení, aktualizace firmwaru, aktualizace softwaru, řízení spotřeby, správa sítě a připojení a šifrování dat.

Časová období údržby zařízení

Obvykle se zařízení konfigurují tak, aby prováděla akce v době, která minimalizuje přerušení a výpadky. Časová období údržby zařízení se běžně používají k definování času, kdy má zařízení aktualizovat svou konfiguraci. Vaše back-endová řešení můžou pomocí požadovaných vlastností dvojčete zařízení definovat a aktivovat zásadu, která umožňuje časové období údržby. Když zařízení obdrží zásady časového období údržby, může pomocí ohlášené vlastnosti dvojčete zařízení nahlásit stav zásad. Back-endová aplikace pak může pomocí dotazů na dvojčete zařízení osvědčovat dodržování předpisů u zařízení a jednotlivých zásad.

Další kroky

V tomto článku jste použili přímou metodu k aktivaci vzdáleného restartování zařízení. Pomocí ohlášených vlastností jste nahlásili čas posledního restartování zařízení a dotazovali jste dvojče zařízení, abyste zjistili čas posledního restartování zařízení z cloudu.

Pokud chcete pokračovat v začátcích se vzory správy IoT Hub a zařízení, jako je například kompletní aktualizace na základě obrázků ve službě Device Update pro Azure IoT Hub článek s využitím referenční image Raspberry Pi 3 B+.

Informace o rozšíření řešení IoT a plánování volání metod na více zařízeních najdete v tématu Plánování a vysílání úloh.

Share via

Začínáme se správou zařízení (Python)

Požadavky

Registrace nového zařízení ve službě IoT Hub

Vytvoření aplikace zařízení pomocí přímé metody

Získání připojovacího řetězce služby IoT Hub

Vytvoření aplikace služby pro aktivaci restartování

Spouštění aplikací

Přizpůsobení a rozšíření akcí správy zařízení

Časová období údržby zařízení

Další kroky

Další materiály