Wprowadzenie do zarządzania urządzeniami (Python)

Artykuł
10/01/2024

Aplikacje zaplecza mogą używać elementów pierwotnych usługi Azure IoT Hub, 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 usługi IoT Hub.

Uwaga

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

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

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

Aplikację zaplecza w chmurze można użyć 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 uruchomienia. 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 urządzenia symulowanego za pośrednictwem centrum IoT. Wyświetla on 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 go nie masz, możesz utworzyć bezpłatne konto próbne w zaledwie kilka minut).
Centrum IoT w ramach subskrypcji platformy Azure. Jeśli nie masz jeszcze centrum, możesz wykonać kroki opisane w temacie Tworzenie centrum IoT Hub.
Urządzenie zarejestrowane w centrum IoT Hub. Jeśli nie masz urządzenia w centrum IoT Hub, wykonaj kroki opisane w temacie Rejestrowanie urządzenia.
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 Nawiązywanie połączenia z usługą IoT Hub (MQTT).

Rejestrowanie nowego urządzenia w centrum IoT

W tej sekcji użyjesz interfejsu wiersza polecenia platformy Azure do utworzenia tożsamości 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. To urządzenie parametry połączenia jest używane przez aplikację urządzenia do łączenia się z usługą IoT Hub jako urządzeniem.

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.

Ważne

Ten artykuł zawiera kroki łączenia urządzenia przy użyciu sygnatury dostępu współdzielonego, nazywanej również uwierzytelnianiem klucza symetrycznego. Ta metoda uwierzytelniania jest wygodna do testowania i oceny, ale uwierzytelnianie urządzenia przy użyciu certyfikatów X.509 jest bardziej bezpieczne. Aby dowiedzieć się więcej, zobacz Zabezpieczenia najlepszych rozwiązań > zabezpieczeń Zabezpieczenia zabezpieczeń Zabezpieczenia zabezpieczeń.

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} parametry połączenia urządzenia. Skopiowano tę parametry połączenia wcześniej w temacie 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ład metody bezpośredniej 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), zgodnie z sugestią w artykule Obsługa przejściowych błędów.

Pobieranie parametry połączenia centrum IoT

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 usługi IoT Hub, usługa wymaga uprawnień połączenia z usługą. Domyślnie każde centrum IoT Hub jest tworzone przy użyciu zasad dostępu współdzielonego o nazwie usługa , która przyznaje to uprawnienie.

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

W witrynie 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 hub wybierz pozycję Zasady dostępu współdzielonego.
Z listy zasad wybierz zasady usługi .
Skopiuj parametry połączenia podstawową i zapisz wartość.

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

Tworzenie aplikacji usługi w celu wyzwolenia ponownego uruchomienia

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ądzenia do odnajdywania czasu ostatniego ponownego uruchomienia tego urządzenia.

Ważne

Ten artykuł zawiera kroki nawiązywania połączenia z usługą przy użyciu sygnatury dostępu współdzielonego. Ta metoda uwierzytelniania jest wygodna do testowania i oceny, ale uwierzytelnianie w usłudze przy użyciu identyfikatora Entra firmy Microsoft lub tożsamości zarządzanych jest bardziej bezpieczne. Aby dowiedzieć się więcej, zobacz Security best practices Cloud security (Najlepsze rozwiązania > dotyczące zabezpieczeń w chmurze).

W usłudze Azure Cloud Shell lub w innym środowisku z językiem 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 usługą IoT Hub parametry połączenia skopiowaną wcześniej w sekcji Pobieranie parametry połączenia centrum IoT Hub. Zastąp wartość symbolu {deviceId} 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 o bliźniacze reprezentacje urządzenia i uzyskaj czas ostatniego ponownego uruchomienia.

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 wysłać zapytanie dotyczące bliźniaczej reprezentacji urządzenia, aby znaleźć czas ostatniego ponownego uruchomienia.
```
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

Twoje rozwiązania IoT mogą rozszerzać zdefiniowany zestaw wzorców zarządzania urządzeniami lub włączać wzorce niestandardowe przy użyciu bliźniaczej reprezentacji urządzenia i typów pierwotnych 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ądzenia

Zazwyczaj urządzenia są konfigurowane do wykonywania akcji w czasie, co minimalizuje 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żliwiają okno obsługi. Gdy urządzenie odbiera 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 rozruchu na urządzeniu. Użyto zgłoszonych właściwości, aby zgłosić ostatni czas ponownego rozruchu z urządzenia i wykonano zapytanie dotyczące bliźniaczej reprezentacji urządzenia w celu odnalezienia czasu ostatniego ponownego uruchomienia urządzenia z chmury.

Aby kontynuować rozpoczynanie pracy z usługą IoT Hub i wzorcami zarządzania urządzeniami, takimi jak kompleksowa aktualizacja obrazu oparta na obrazach w artykule Device Update for Azure IoT Hub using the Raspberry Pi 3 B+ Reference Image (Aktualizacja urządzenia dla usługi Azure IoT Hub przy użyciu obrazu referencyjnego urządzenia Raspberry Pi 3 B+).

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

Udostępnij za pośrednictwem

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 parametry połączenia centrum IoT

Tworzenie aplikacji usługi w celu wyzwolenia ponownego uruchomienia

Uruchamianie aplikacji

Dostosowywanie i rozszerzanie akcji zarządzania urządzeniami

Okna obsługi urządzenia

Następne kroki

Opinia

Dodatkowe zasoby