Plánování a vysílání úloh (Python)

Článek
10/01/2024

Pomocí služby Azure IoT Hub můžete plánovat a sledovat úlohy, které aktualizují miliony zařízení. Použití úloh k:

Aktualizace požadovaných vlastností
Aktualizace značek
Vyvolání přímých metod

Koncepčně úloha zabalí jednu z těchto akcí a sleduje průběh provádění u sady zařízení, která je definovaná dotazem dvojčete zařízení. Back-endová aplikace může například pomocí úlohy vyvolat metodu restartování na 10 000 zařízeních určených dotazem dvojčete zařízení a naplánovat ji v budoucnu. Tato aplikace pak může sledovat průběh, když každé z těchto zařízení přijme a spustí metodu restartování.

Další informace o jednotlivých funkcích najdete v těchto článcích:

Dvojče zařízení a vlastnosti: Začínáme s dvojčaty zařízení a principy a používání dvojčat zařízení ve službě IoT Hub
Přímé metody: Příručka pro vývojáře ioT Hubu – přímé metody

Poznámka:

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

V tomto článku se dozvíte, jak vytvořit dvě aplikace v Pythonu:

Aplikace simulovaného zařízení v Pythonu simDevice.py, která implementuje přímou metodu s názvem lockDoor, kterou může volat back-endová aplikace.
Konzolová aplikace Pythonu scheduleJobService.py, která vytvoří dvě úlohy. Jedna úloha volá přímou metodu lockDoor a jiná úloha odesílá aktualizace požadovaných vlastností do více zařízení.

Poznámka:

Další informace o dostupných nástrojích SDK pro sestavení zařízení i back-endových aplikací najdete v sadách SDK .

Požadavky

Aktivní účet Azure (Pokud účet nemáte, můžete si během několika minut vytvořit bezplatný účet.)
Centrum IoT ve vašem předplatném Azure Pokud centrum ještě nemáte, můžete postupovat podle kroků v tématu Vytvoření centra IoT.
Zařízení zaregistrované ve službě IoT Hub. Pokud ve službě IoT Hub nemáte zařízení, postupujte podle pokynů v části Registrace zařízení.
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.

Vytvoření aplikace simulovaného zařízení

V této části vytvoříte konzolovou aplikaci Pythonu, která reaguje na přímou metodu volanou cloudem, která aktivuje simulovanou metodu lockDoor .

Důležité

Tento článek obsahuje postup připojení zařízení pomocí sdíleného přístupového podpisu, označovaného také jako ověřování symetrického klíče. Tato metoda ověřování je vhodná pro testování a vyhodnocení, ale ověřování zařízení pomocí certifikátů X.509 je bezpečnější přístup. Další informace najdete v tématu Zabezpečení osvědčených postupů > zabezpečení připojení.

Na příkazovém řádku spusťte následující příkaz a nainstalujte balíček azure-iot-device :
```
pip install azure-iot-device
```
Pomocí textového editoru vytvořte v pracovním adresáři nový simDevice.py soubor.
Na začátek souboru simDevice.py přidejte následující import příkazy a proměnné. Nahraďte deviceConnectionString připojovací řetězec zařízení, které jste vytvořili výše:
```
import time
from azure.iot.device import IoTHubDeviceClient, MethodResponse

CONNECTION_STRING = "{deviceConnectionString}"
```

Definujte následující funkci, která vytvoří instanci klienta a nakonfiguruje ji tak, aby reagovala na metodu lockDoor , a také přijímat aktualizace dvojčat zařízení:

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

    # Define behavior for responding to the lockDoor direct method
    def method_request_handler(method_request):
        if method_request.name == "lockDoor":
            print("Locking Door!")

            resp_status = 200
            resp_payload = {"Response": "lockDoor called successfully"}
            method_response = MethodResponse.create_from_method_request(
                method_request=method_request,
                status=resp_status,
                payload=resp_payload
            )
            client.send_method_response(method_response)

    # Define behavior for receiving a twin patch
    def twin_patch_handler(twin_patch):
        print("")
        print("Twin desired properties patch received:")
        print(twin_patch)

    # Set the handlers on the client
    try:
        print("Beginning to listen for 'lockDoor' direct method invocations...")
        client.on_method_request_received = method_request_handler
        print("Beginning to listen for updates to the Twin desired properties...")
        client.on_twin_desired_properties_patch_received = twin_patch_handler
    except:
        # If something goes wrong while setting the handlers, clean up the client
        client.shutdown()
        raise

Přidejte následující kód pro spuštění ukázky:

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

    print ("IoTHubDeviceClient waiting for commands, press Ctrl-C to exit")
    try:
        while True:
            time.sleep(100)
    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 simDevice.py .

Poznámka:

Aby bylo všechno jednoduché, tento článek neimplementuje zásadu opakování. V produkčním kódu byste měli implementovat zásady opakování (například exponenciální zpoždování), jak je doporučeno v článku Zpracování přechodných chyb.

Získání připojovací řetězec ioT Hubu

V tomto článku vytvoříte back-endovou službu, která vyvolá přímou metodu na zařízení a aktualizuje dvojče zařízení. Služba potřebuje oprávnění k připojení služby k volání přímé metody na zařízení. Služba také potřebuje oprávnění ke čtení a zápisu registru registru ke čtení a zápisu registru identit. Neexistují žádné výchozí zásady sdíleného přístupu, které obsahují pouze tato oprávnění, takže ho musíte vytvořit.

Pokud chcete vytvořit zásadu sdíleného přístupu, která uděluje oprávnění pro připojení služby, čtení registru a zápis registru a získat připojovací řetězec pro tuto zásadu, postupujte takto:

Otevřete centrum IoT na webu Azure Portal. Nejjednodušší způsob, jak se dostat do centra IoT, je vybrat skupiny prostředků, vybrat skupinu prostředků, ve které se nachází centrum IoT, a pak ze seznamu prostředků vybrat centrum IoT.
V levém podokně centra IoT vyberte zásady sdíleného přístupu.
V horní nabídce nad seznamem zásad vyberte Přidat zásady sdíleného přístupu.
V podokně Přidat zásady sdíleného přístupu zadejte popisný název zásady, například serviceAndRegistryReadWrite. V části Oprávnění vyberte Možnost Zápis registru a Připojení služby (Při výběru možnosti Zápis registru se automaticky vybere čtení registru) a pak vyberte Přidat.
Zpátky na stránce Zásady sdíleného přístupu vyberte novou zásadu ze seznamu zásad.
V novém podokně, které se zobrazí, vyberte ikonu kopírování pro primární připojovací řetězec a uložte hodnotu.

Další informace ozásadách

Důležité

Tento článek obsahuje postup připojení ke službě pomocí sdíleného přístupového podpisu. Tato metoda ověřování je vhodná pro testování a vyhodnocení, ale ověřování ve službě pomocí MICROSOFT Entra ID nebo spravovaných identit je bezpečnější přístup. Další informace najdete v tématu Osvědčené postupy > zabezpečení cloudu.

Naplánování úloh pro volání přímé metody a aktualizaci vlastností dvojčete zařízení

V této části vytvoříte konzolovou aplikaci Pythonu, která zahájí vzdálené uzamčení zařízení pomocí přímé metody a aktualizuje také požadované vlastnosti dvojčete zařízení.

Na příkazovém řádku spusťte následující příkaz a nainstalujte balíček azure-iot-hub :
```
pip install azure-iot-hub
```
Pomocí textového editoru vytvořte v pracovním adresáři nový scheduleJobService.py soubor.

Na začátek souboru scheduleJobService.py přidejte následující import příkazy a proměnné. {IoTHubConnectionString} Zástupný symbol nahraďte službou IoT Hub připojovací řetězec, kterou jste zkopírovali dříve v připojovací řetězec Get the IoT Hub. {deviceId} Zástupný symbol nahraďte ID zařízení (název) z registrovaného zařízení:

import os
import sys
import datetime
import time
import threading
import uuid
import msrest

from azure.iot.hub import IoTHubJobManager, IoTHubRegistryManager
from azure.iot.hub.models import JobProperties, JobRequest, Twin, TwinProperties, CloudToDeviceMethod

CONNECTION_STRING = "{IoTHubConnectionString}"
DEVICE_ID = "{deviceId}"

METHOD_NAME = "lockDoor"
METHOD_PAYLOAD = "{\"lockTime\":\"10m\"}"
UPDATE_PATCH = {"building":43,"floor":3}
TIMEOUT = 60
WAIT_COUNT = 5

# Create IoTHubJobManager
iothub_job_manager = IoTHubJobManager.from_connection_string(CONNECTION_STRING)

Přidejte následující metody pro spuštění úloh, které volají přímou metodu a dvojče zařízení:

def device_method_job(job_id, device_id, execution_time):
    print ( "" )
    print ( "Scheduling job: " + str(job_id) )

    job_request = JobRequest()
    job_request.job_id = job_id
    job_request.type = "scheduleDeviceMethod"
    job_request.start_time = datetime.datetime.utcnow().isoformat()
    job_request.cloud_to_device_method = CloudToDeviceMethod(method_name=METHOD_NAME, payload=METHOD_PAYLOAD)
    job_request.max_execution_time_in_seconds = execution_time
    job_request.query_condition = "DeviceId in ['{}']".format(device_id)

    new_job_response = iothub_job_manager.create_scheduled_job(job_id, job_request)

def device_twin_job(job_id, device_id, execution_time):
    print ( "" )
    print ( "Scheduling job " + str(job_id) )

    job_request = JobRequest()
    job_request.job_id = job_id
    job_request.type = "scheduleUpdateTwin"
    job_request.start_time = datetime.datetime.utcnow().isoformat()
    job_request.update_twin = Twin(etag="*", properties=TwinProperties(desired=UPDATE_PATCH))
    job_request.max_execution_time_in_seconds = execution_time
    job_request.query_condition = "DeviceId in ['{}']".format(device_id)

    new_job_response = iothub_job_manager.create_scheduled_job(job_id, job_request)

Přidejte následující kód, který naplánuje úlohy a aktualizuje stav úlohy. Patří sem také rutina main :

def iothub_jobs_sample_run():
    try:
        method_job_id = uuid.uuid4()
        device_method_job(method_job_id, DEVICE_ID, TIMEOUT)

        print ( "" )
        print ( "Direct method called with Job Id: " + str(method_job_id) )

        twin_job_id = uuid.uuid4()
        device_twin_job(twin_job_id, DEVICE_ID, TIMEOUT)

        print ( "" )
        print ( "Device twin called with Job Id: " + str(twin_job_id) )

        while True:
            print ( "" )

            method_job_status = iothub_job_manager.get_scheduled_job(method_job_id)
            print ( "...job " + str(method_job_id) + " " + method_job_status.status )

            twin_job_status = iothub_job_manager.get_scheduled_job(twin_job_id)
            print ( "...job " + str(twin_job_id) + " " + twin_job_status.status )

            print ( "Job status posted, press Ctrl-C to exit" )
            time.sleep(WAIT_COUNT)

    except msrest.exceptions.HttpOperationError as ex:
        print ( "" )
        print ( "HTTP error {}".format(ex.response.text) )
        return
    except Exception as ex:
        print ( "" )
        print ( "Unexpected error {}".format(ex) )
        return
    except KeyboardInterrupt:
        print ( "" )
        print ( "IoTHubService sample stopped" )

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

    iothub_jobs_sample_run()

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

Spuštění aplikací

Nyní můžete spustit aplikace.

Na příkazovém řádku v pracovním adresáři spusťte následující příkaz, který začne naslouchat přímé metodě restartování:
```
python simDevice.py
```
V jiném příkazovém řádku v pracovním adresáři spusťte následující příkaz, který aktivuje úlohy, které zamknou dveře a aktualizují dvojče:
```
python scheduleJobService.py
```
V konzole se zobrazí odpovědi zařízení na přímou metodu a aktualizaci dvojčat zařízení.

Další kroky

V tomto článku jste naplánovali úlohy, které spustí přímou metodu a aktualizují vlastnosti dvojčete zařízení.

Pokud chcete pokračovat ve zkoumání vzorů správy ioT Hubu a zařízení, aktualizujte image ve službě Device Update pro Azure IoT Hub pomocí referenční image Raspberry Pi 3 B+.

Sdílet prostřednictvím

Plánování a vysílání úloh (Python)

Požadavky

Vytvoření aplikace simulovaného zařízení

Získání připojovací řetězec ioT Hubu

Naplánování úloh pro volání přímé metody a aktualizaci vlastností dvojčete zařízení

Spuštění aplikací

Další kroky

Váš názor

Další materiály