Wprowadzenie do zarządzania urządzeniami (Python)

Artykuł
03/16/2023

Aplikacje zaplecza mogą używać Azure IoT Hub pierwotnych, takich jak bliźniacze reprezentacje urządzeń i metody bezpośrednie, do zdalnego uruchamiania i monitorowania akcji zarządzania urządzeniami na urządzeniach. W tym artykule pokazano, jak aplikacja zaplecza i aplikacja urządzenia mogą współpracować w celu zainicjowania i monitorowania ponownego uruchomienia urządzenia zdalnego przy użyciu IoT Hub.

Uwaga

Funkcje opisane w tym artykule są dostępne tylko w warstwie Standardowa IoT Hub. Aby uzyskać więcej informacji na temat warstw podstawowych i standardowych/bezpłatnych IoT Hub, zobacz Wybieranie odpowiedniej warstwy IoT Hub dla rozwiązania.

Użyj metody bezpośredniej, aby zainicjować akcje zarządzania urządzeniami (takie jak ponowne uruchomienie, resetowanie do ustawień fabrycznych i aktualizacja oprogramowania układowego) z aplikacji zaplecza w chmurze. Urządzenie jest odpowiedzialne za:

Obsługa żądania metody wysyłanego z IoT Hub.
Inicjowanie odpowiedniej akcji specyficznej dla urządzenia.
Dostarczanie aktualizacji stanu za pośrednictwem zgłoszonych właściwości do IoT Hub.

Możesz użyć aplikacji zaplecza w chmurze do uruchamiania zapytań bliźniaczych reprezentacji urządzenia w celu raportowania postępu akcji zarządzania urządzeniami.

W tym artykule pokazano, jak utworzyć:

dmpatterns_getstarted_device.py: symulowana aplikacja urządzenia z metodą bezpośrednią, która ponownie uruchamia urządzenie i zgłasza czas ostatniego ponownego rozruchu. Metody bezpośrednie są wywoływane z chmury.
dmpatterns_getstarted_service.py: aplikacja konsolowa języka Python, która wywołuje metodę bezpośrednią w aplikacji symulowanego urządzenia za pośrednictwem centrum IoT. Wyświetla odpowiedź i zaktualizowane zgłoszone właściwości.

Uwaga

Aby uzyskać więcej informacji na temat narzędzi zestawu SDK dostępnych do kompilowania aplikacji zarówno urządzeń, jak i zaplecza, zobacz Zestawy SDK usługi Azure IoT.

Wymagania wstępne

Aktywne konto platformy Azure. (Jeśli nie masz konta, możesz utworzyć bezpłatne konto w ciągu zaledwie kilku minut).
Centrum IoT. Utwórz go za pomocą interfejsu wiersza polecenia lub Azure Portal.
Zarejestrowane urządzenie. Zarejestruj jeden w Azure Portal.
Zalecane jest użycie języka Python w wersji 3.7 lub nowszej. Upewnij się, że używasz 32-bitowej lub 64-bitowej instalacji zgodnie z wymaganiami konfiguracji. Po wyświetleniu monitu podczas instalacji upewnij się, że język Python został dodany do zmiennej środowiskowej specyficznej dla platformy.
Upewnij się, że port 8883 jest otwarty w zaporze. Przykład urządzenia w tym artykule używa protokołu MQTT, który komunikuje się za pośrednictwem portu 8883. Ten port może zostać zablokowany w niektórych środowiskach sieci firmowych i edukacyjnych. Aby uzyskać więcej informacji i sposobów obejścia tego problemu, zobacz Łączenie się z IoT Hub (MQTT).

Rejestrowanie nowego urządzenia w centrum IoT

W tej sekcji użyjesz interfejsu wiersza polecenia platformy Azure, aby utworzyć tożsamość urządzenia dla tego artykułu. W identyfikatorach urządzeń jest uwzględniana wielkość liter.

Otwórz usługę Azure Cloud Shell.
W usłudze Azure Cloud Shell uruchom następujące polecenie, aby zainstalować rozszerzenie Microsoft Azure IoT dla interfejsu wiersza polecenia platformy Azure:
```
az extension add --name azure-iot
```
Utwórz nową tożsamość urządzenia o nazwie myDeviceId i pobierz parametry połączenia urządzenia za pomocą następujących poleceń:
```
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
```
Ważne

Identyfikator urządzenia może być widoczny w dziennikach zbieranych na potrzeby obsługi klienta i rozwiązywania problemów, dlatego upewnij się, żeby unikać poufnych informacji podczas nadawania mu nazwy.

Zanotuj parametry połączenia urządzenia z wyniku. Te parametry połączenia urządzenia są używane przez aplikację urządzenia do nawiązywania połączenia z IoT Hub jako urządzenia.

Tworzenie aplikacji urządzenia przy użyciu metody bezpośredniej

W tej sekcji omówiono następujące zagadnienia:

Utwórz aplikację konsolową języka Python, która odpowiada na metodę bezpośrednią wywoływaną przez chmurę.
Symulowanie ponownego uruchomienia urządzenia.
Użyj zgłoszonych właściwości, aby włączyć zapytania bliźniaczej reprezentacji urządzenia w celu zidentyfikowania urządzeń i ich ostatniego ponownego uruchomienia.

W usłudze Azure Cloud Shell użyto wcześniej lub dowolnego innego środowiska w języku Python utwórz kod urządzenia.

W wierszu polecenia uruchom następujące polecenie, aby zainstalować pakiet azure-iot-device :
```
pip install azure-iot-device
```
Za pomocą edytora tekstów utwórz plik o nazwie dmpatterns_getstarted_device.py w katalogu roboczym.

Dodaj następujące import instrukcje na początku pliku dmpatterns_getstarted_device.py .

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

Dodaj zmienną CONNECTION_STRING . Zastąp wartość symbolu zastępczego {deviceConnectionString} parametrami połączenia urządzenia. Skopiowano te parametry połączenia wcześniej w obszarze Rejestrowanie nowego urządzenia w centrum IoT.
```
CONNECTION_STRING = "{deviceConnectionString}"
```

Dodaj następującą funkcję, aby utworzyć wystąpienie klienta skonfigurowanego pod kątem metod bezpośrednich na urządzeniu.

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

Uruchom przykładową metodę bezpośrednią i zaczekaj.

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

Zapisz i zamknij plik dmpatterns_getstarted_device.py .

Uwaga

Dla uproszczenia ten samouczek nie zawiera opisu wdrożenia żadnych zasad ponawiania. W kodzie produkcyjnym należy zaimplementować zasady ponawiania prób (takie jak wycofywanie wykładnicze), jak pokazano w artykule Obsługa błędów przejściowych.

Pobieranie parametrów połączenia centrum IoT Hub

W tym artykule utworzysz usługę zaplecza, która wywołuje metodę bezpośrednią na urządzeniu. Aby wywołać metodę bezpośrednią na urządzeniu za pośrednictwem IoT Hub, usługa wymaga uprawnienia połączenia z usługą. Domyślnie każda IoT Hub jest tworzona z zasadami dostępu współdzielonego o nazwie usługa, która przyznaje to uprawnienie.

Aby uzyskać IoT Hub parametry połączenia dla zasad usługi, wykonaj następujące kroki:

W Azure Portal wybierz pozycję Grupy zasobów. Wybierz grupę zasobów, w której znajduje się centrum, a następnie wybierz centrum z listy zasobów.
W okienku po lewej stronie centrum IoT wybierz pozycję Zasady dostępu współdzielonego.
Z listy zasad wybierz zasady usługi .
Skopiuj podstawowe parametry połączenia i zapisz wartość.

Aby uzyskać więcej informacji na temat zasad i uprawnień dostępu współdzielonego IoT Hub, zobacz Kontrola dostępu i uprawnienia.

Tworzenie aplikacji usługi w celu wyzwolenia ponownego rozruchu

W tej sekcji utworzysz aplikację konsolową języka Python, która inicjuje zdalny ponowny rozruch na urządzeniu przy użyciu metody bezpośredniej. Aplikacja używa zapytań bliźniaczych reprezentacji urządzeń do odnajdywania czasu ostatniego ponownego rozruchu dla tego urządzenia.

W usłudze Azure Cloud Shell lub innym środowisku w języku Python utwórz kod konsoli.

W wierszu polecenia uruchom następujące polecenie, aby zainstalować pakiet azure-iot-hub :
```
pip install azure-iot-hub
```
Za pomocą edytora tekstów utwórz plik o nazwie dmpatterns_getstarted_service.py w katalogu roboczym.

Dodaj następujące import instrukcje na początku pliku dmpatterns_getstarted_service.py .

import sys, time

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

Dodaj następujące deklaracje zmiennych. Zastąp wartość symbolu {IoTHubConnectionString} zastępczego parametrami połączenia centrum IoT Hub skopiowanymi wcześniej w sekcji Pobieranie parametrów połączenia centrum IoT. {deviceId} Zastąp wartość symbolu zastępczego identyfikatorem urządzenia zarejestrowanym w obszarze Rejestrowanie nowego urządzenia w centrum IoT.
```
CONNECTION_STRING = "{IoTHubConnectionString}"
DEVICE_ID = "{deviceId}"

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

Dodaj następującą funkcję, aby wywołać metodę urządzenia w celu ponownego uruchomienia urządzenia docelowego, a następnie wykonaj zapytanie dotyczące bliźniaczych reprezentacji urządzenia i uzyskaj czas ostatniego ponownego rozruchu.

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

Zapisz i zamknij plik dmpatterns_getstarted_service.py .

Uruchamianie aplikacji

Teraz możesz uruchomić kod urządzenia i kod usługi, który inicjuje ponowne uruchomienie urządzenia.

W wierszu polecenia, w którym utworzono urządzenie, uruchom następujące polecenie, aby rozpocząć nasłuchiwanie metody bezpośredniej ponownego rozruchu.
```
python dmpatterns_getstarted_device.py
```
W wierszu polecenia, w którym tworzysz usługę, uruchom następujące polecenie, aby wyzwolić zdalny ponowny rozruch i wykonać zapytanie dotyczące bliźniaczej reprezentacji urządzenia, aby znaleźć czas ostatniego ponownego rozruchu.
```
python dmpatterns_getstarted_service.py
```
W konsoli zostanie wyświetlona odpowiedź urządzenia na metodę bezpośrednią.

Poniżej przedstawiono odpowiedź urządzenia na metodę bezpośrednią ponownego rozruchu:

Poniżej przedstawiono usługę wywołującą metodę bezpośrednią ponownego rozruchu i sondując bliźniacze reprezentację urządzenia pod kątem stanu:

Dostosowywanie i rozszerzanie akcji zarządzania urządzeniami

Rozwiązania IoT mogą rozszerzać zdefiniowany zestaw wzorców zarządzania urządzeniami lub włączać wzorce niestandardowe przy użyciu elementów pierwotnych metody bliźniaczej reprezentacji urządzenia i metody chmury do urządzenia. Inne przykłady akcji zarządzania urządzeniami obejmują resetowanie do ustawień fabrycznych, aktualizację oprogramowania, aktualizację oprogramowania, zarządzanie energią, zarządzanie siecią i łącznością oraz szyfrowanie danych.

Okna obsługi urządzeń

Zazwyczaj można skonfigurować urządzenia do wykonywania akcji w czasie, które minimalizują przerwy i przestoje. Okna obsługi urządzeń są często używanym wzorcem do definiowania czasu aktualizacji konfiguracji urządzenia. Rozwiązania zaplecza mogą używać żądanych właściwości bliźniaczej reprezentacji urządzenia do definiowania i aktywowania zasad na urządzeniu, które umożliwia okno obsługi. Gdy urządzenie otrzyma zasady okna obsługi, może użyć zgłaszanej właściwości bliźniaczej reprezentacji urządzenia, aby zgłosić stan zasad. Aplikacja zaplecza może następnie używać zapytań bliźniaczych reprezentacji urządzenia, aby potwierdzić zgodność urządzeń i poszczególnych zasad.

Następne kroki

W tym artykule użyto metody bezpośredniej do wyzwolenia zdalnego ponownego uruchomienia na urządzeniu. Za pomocą zgłoszonych właściwości zgłosiliśmy czas ostatniego ponownego rozruchu z urządzenia i wykonano zapytanie dotyczące bliźniaczej reprezentacji urządzenia w celu odnalezienia czasu ostatniego ponownego rozruchu urządzenia z chmury.

Aby kontynuować rozpoczynanie pracy z wzorcami zarządzania IoT Hub i urządzeniami, takimi jak kompleksowa aktualizacja obrazu w aktualizacji urządzeń dla Azure IoT Hub artykułu przy użyciu obrazu referencyjnego urządzenia Raspberry Pi 3 B+.

Aby dowiedzieć się, jak rozszerzyć rozwiązanie IoT i zaplanować wywołania metody na wielu urządzeniach, zobacz Planowanie i emisja zadań.

Share via

Wprowadzenie do zarządzania urządzeniami (Python)

Wymagania wstępne

Rejestrowanie nowego urządzenia w centrum IoT

Tworzenie aplikacji urządzenia przy użyciu metody bezpośredniej

Pobieranie parametrów połączenia centrum IoT Hub

Tworzenie aplikacji usługi w celu wyzwolenia ponownego rozruchu

Uruchamianie aplikacji

Dostosowywanie i rozszerzanie akcji zarządzania urządzeniami

Okna obsługi urządzeń

Następne kroki

Dodatkowe zasoby