Kom igång med enhetshantering (Python)

Artikel
10/01/2024

Serverdelsappar kan använda Azure IoT Hub-primitiver, till exempel enhetstvillingar och direktmetoder, för att fjärrstarta och övervaka enhetshanteringsåtgärder på enheter. Den här artikeln visar hur en serverdelsapp och en enhetsapp kan arbeta tillsammans för att initiera och övervaka en omstart av fjärrenheter med hjälp av IoT Hub.

Kommentar

De funktioner som beskrivs i den här artikeln är endast tillgängliga på standardnivån för IoT Hub. Mer information om de grundläggande och standard-/kostnadsfria IoT Hub-nivåerna finns i Välj rätt IoT Hub-nivå för din lösning.

Använd en direktmetod för att initiera åtgärder för enhetshantering (till exempel omstart, fabriksåterställning och uppdatering av inbyggd programvara) från en serverdelsapp i molnet. Enheten ansvarar för:

Hantera metodbegäran som skickas från IoT Hub.
Initiera motsvarande enhetsspecifika åtgärd på enheten.
Tillhandahålla statusuppdateringar via rapporterade egenskaper till IoT Hub.

Du kan använda en serverdelsapp i molnet för att köra frågor för enhetstvillingar för att rapportera om förloppet för dina enhetshanteringsåtgärder.

Den här artikeln visar hur du skapar:

dmpatterns_getstarted_device.py: en simulerad enhetsapp med en direktmetod som startar om enheten och rapporterar den senaste omstartstiden. Direktmetoder anropas från molnet.
dmpatterns_getstarted_service.py: en Python-konsolapp som anropar direktmetoden i den simulerade enhetsappen via din IoT-hubb. Den visar svaret och uppdaterade rapporterade egenskaper.

Kommentar

Mer information om de SDK-verktyg som är tillgängliga för att skapa både enhets- och serverdelsappar finns i Azure IoT SDK:er.

Förutsättningar

Ett aktivt Azure-konto. (Om du inte har något konto kan du skapa ett kostnadsfritt konto på bara några minuter.)
En IoT-hubb i din Azure-prenumeration. Om du inte har någon hubb ännu kan du följa stegen i Skapa en IoT-hubb.
En enhet som är registrerad i din IoT-hubb. Om du inte har en enhet i din IoT-hubb följer du stegen i Registrera en enhet.
Python version 3.7 eller senare rekommenderas. Se till att använda en 32-bitars eller 64-bitars installation beroende på vad som krävs för din konfiguration. Se till att du lägger till Python i den plattformsspecifika miljövariabeln när du uppmanas att göra det under installationen.
Kontrollera att port 8883 är öppen i brandväggen. Enhetsexemplet i den här artikeln använder MQTT-protokollet, som kommunicerar via port 8883. Den här porten kan blockeras i vissa företags- och utbildningsnätverksmiljöer. Mer information och sätt att kringgå det här problemet finns i Ansluta till IoT Hub (MQTT).

Registrera en ny enhet i IoT-hubben

I det här avsnittet använder du Azure CLI för att skapa en enhetsidentitet för den här artikeln. Enhets-ID:n är skiftlägeskänsliga.

Öppna Azure Cloud Shell.
I Azure Cloud Shell kör du följande kommando för att installera Microsoft Azure IoT-tillägget för Azure CLI:
```
az extension add --name azure-iot
```

Skapa en ny enhetsidentitet med namnet myDeviceId och hämta enheten anslutningssträng med följande kommandon:

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

Viktigt!

Enhets-ID visas kanske i de loggar som samlas in för support och felsökning, så se till att undvika känslig information när du namnger det.

Anteckna enhetens anslutningssträng från resultatet. Den här enheten anslutningssträng används av enhetsappen för att ansluta till din IoT Hub som en enhet.

Skapa en enhetsapp med en direktmetod

I det här avsnittet får du:

Skapa en Python-konsolapp som svarar på en direktmetod som anropas av molnet.
Simulera en omstart av enheten.
Använd de rapporterade egenskaperna för att aktivera enhetstvillingfrågor för att identifiera enheter och när de senast startades om.

Viktigt!

Den här artikeln innehåller steg för att ansluta en enhet med en signatur för delad åtkomst, även kallad symmetrisk nyckelautentisering. Den här autentiseringsmetoden är praktisk för testning och utvärdering, men att autentisera en enhet med X.509-certifikat är en säkrare metod. Mer information finns i Metodtips > för säkerhet Anslutningssäkerhet.

Skapa enhetskoden i Azure Cloud Shell som du använde tidigare eller någon annan miljö med Python.

Kör följande kommando i kommandotolken för att installera paketet azure-iot-device :
```
pip install azure-iot-device
```
Skapa en fil med namnet dmpatterns_getstarted_device.py i arbetskatalogen med hjälp av en textredigerare.

Lägg till följande import instruktioner i början av filen dmpatterns_getstarted_device.py .

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

Lägg till variabeln CONNECTION_STRING . {deviceConnectionString} Ersätt platshållarvärdet med enhetens anslutningssträng. Du kopierade den här anslutningssträng tidigare i Registrera en ny enhet i IoT-hubben.
```
CONNECTION_STRING = "{deviceConnectionString}"
```

Lägg till följande funktion för att instansiera en klient som konfigurerats för direkta metoder på enheten.

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

Starta direktmetodexemplet och vänta.

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

Spara och stäng filen dmpatterns_getstarted_device.py .

Kommentar

För att göra det så enkelt som möjligt implementerar vi ingen princip för omförsök i den här självstudiekursen. I produktionskoden bör du implementera återförsöksprinciper (till exempel en exponentiell backoff), enligt vad som föreslås i artikeln Tillfälliga felhantering.

Hämta IoT Hub-anslutningssträng

I den här artikeln skapar du en serverdelstjänst som anropar en direktmetod på en enhet. Om du vill anropa en direktmetod på en enhet via IoT Hub behöver din tjänst behörighet för tjänstanslutning . Som standard skapas varje IoT Hub med en princip för delad åtkomst med namnet service som ger den här behörigheten.

Följ dessa steg för att hämta IoT Hub-anslutningssträng för tjänstprincipen:

I Azure Portal väljer du Resursgrupper. Välj den resursgrupp där hubben finns och välj sedan din hubb i listan över resurser.
Välj Principer för delad åtkomst i den vänstra rutan i din IoT-hubb.
I listan över principer väljer du tjänstprincipen.
Kopiera den primära anslutningssträng och spara värdet.

Mer information om principer och behörigheter för delad åtkomst i IoT Hub finns i Åtkomstkontroll och behörigheter.

Skapa en tjänstapp för att utlösa en omstart

I det här avsnittet skapar du en Python-konsolapp som initierar en fjärromstart på en enhet med hjälp av en direktmetod. Appen använder enhetstvillingfrågor för att identifiera den senaste omstartstiden för den enheten.

Viktigt!

Den här artikeln innehåller steg för att ansluta till en tjänst med hjälp av en signatur för delad åtkomst. Den här autentiseringsmetoden är praktisk för testning och utvärdering, men autentisering till en tjänst med Microsoft Entra-ID eller hanterade identiteter är en säkrare metod. Mer information finns i Metodtips för > säkerhet Molnsäkerhet.

Skapa konsolkoden i Azure Cloud Shell eller någon annan miljö med Python.

Kör följande kommando i kommandotolken för att installera paketet azure-iot-hub :
```
pip install azure-iot-hub
```
Skapa en fil med namnet dmpatterns_getstarted_service.py i arbetskatalogen med hjälp av en textredigerare.

Lägg till följande import instruktioner i början av filen dmpatterns_getstarted_service.py .

import sys, time

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

Lägg till följande variabeldeklarationer. {IoTHubConnectionString} Ersätt platshållarvärdet med IoT-hubben anslutningssträng du kopierade tidigare i Hämta IoT Hub-anslutningssträng. {deviceId} Ersätt platshållarvärdet med det enhets-ID som du registrerade i Registrera en ny enhet i IoT-hubben.
```
CONNECTION_STRING = "{IoTHubConnectionString}"
DEVICE_ID = "{deviceId}"

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

Lägg till följande funktion för att anropa enhetsmetoden för att starta om målenheten, sedan fråga efter enhetstvillingarna och hämta den senaste omstartstiden.

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

Spara och stäng filen dmpatterns_getstarted_service.py .

Köra apparna

Nu är du redo att köra enhetskoden och tjänstkoden som initierar en omstart av enheten.

I kommandotolken där du skapade enheten kör du följande kommando för att börja lyssna efter direktmetoden för omstart.
```
python dmpatterns_getstarted_device.py
```
I kommandotolken där du skapar tjänsten kör du följande kommando för att utlösa fjärromstarten och fråga efter enhetstvillingen för att hitta den senaste omstartstiden.
```
python dmpatterns_getstarted_service.py
```
Du ser enhetens svar på direktmetoden i konsolen.

Följande visar enhetens svar på direktmetoden för omstart:

Följande visar tjänsten som anropar direktmetoden för omstart och avsöker enhetstvillingen efter status:

Anpassa och utöka enhetshanteringsåtgärderna

Dina IoT-lösningar kan utöka den definierade uppsättningen med enhetshanteringsmönster eller aktivera anpassade mönster med hjälp av enhetstvillingen och primitiverna för moln-till-enhet-metoden. Andra exempel på åtgärder för enhetshantering är fabriksåterställning, uppdatering av inbyggd programvara, programuppdatering, energisparfunktioner, nätverks- och anslutningshantering samt datakryptering.

Fönster för enhetsunderhåll

Vanligtvis konfigurerar du enheter för att utföra åtgärder i taget som minimerar avbrott och stilleståndstid. Fönster för enhetsunderhåll är ett vanligt mönster för att definiera den tid då en enhet ska uppdatera sin konfiguration. Serverdelslösningarna kan använda önskade egenskaper för enhetstvillingen för att definiera och aktivera en princip på enheten som aktiverar ett underhållsperiod. När en enhet tar emot principen för underhållsperiod kan den använda den rapporterade egenskapen för enhetstvillingen för att rapportera status för principen. Serverdelsappen kan sedan använda enhetstvillingfrågor för att intyga efterlevnad av enheter och varje princip.

Nästa steg

I den här artikeln använde du en direktmetod för att utlösa en fjärromstart på en enhet. Du använde de rapporterade egenskaperna för att rapportera den senaste omstartstiden från enheten och frågade enhetstvillingen om att identifiera enhetens senaste omstartstid från molnet.

För att fortsätta komma igång med IoT Hub- och enhetshanteringsmönster, till exempel avbildningsbaserad uppdatering från slutpunkt till slutpunkt i artikeln Enhetsuppdatering för Azure IoT Hub med hjälp av raspberry Pi 3 B+-referensbilden.

Information om hur du utökar IoT-lösnings- och schemametodanrop på flera enheter finns i Schemalägga och sända jobb.

Dela via

Kom igång med enhetshantering (Python)

Förutsättningar

Registrera en ny enhet i IoT-hubben

Skapa en enhetsapp med en direktmetod

Hämta IoT Hub-anslutningssträng

Skapa en tjänstapp för att utlösa en omstart

Köra apparna

Anpassa och utöka enhetshanteringsåtgärderna

Fönster för enhetsunderhåll

Nästa steg

Feedback

Ytterligare resurser