Taken plannen en uitzenden (Python)

Artikel
10/01/2024

Gebruik Azure IoT Hub om taken te plannen en bij te houden die miljoenen apparaten bijwerken. Taken gebruiken om:

Gewenste eigenschappen bijwerken
Tags bijwerken
Directe methoden aanroepen

Conceptueel verpakt een taak een van deze acties en houdt de voortgang van de uitvoering bij op een set apparaten, die wordt gedefinieerd door een apparaatdubbelquery. Een back-end-app kan bijvoorbeeld een taak gebruiken om een methode voor opnieuw opstarten aan te roepen op 10.000 apparaten, opgegeven door een apparaatdubbelquery en gepland op een later tijdstip. Deze toepassing kan vervolgens de voortgang bijhouden terwijl elk van deze apparaten de methode voor opnieuw opstarten ontvangt en uitvoert.

Meer informatie over elk van deze mogelijkheden vindt u in deze artikelen:

Apparaatdubbel en eigenschappen: Aan de slag met apparaatdubbels en Apparaatdubbels begrijpen en gebruiken in IoT Hub
Directe methoden: Ontwikkelaarshandleiding voor IoT Hub - directe methoden

Notitie

De functies die in dit artikel worden beschreven, zijn alleen beschikbaar in de standaardlaag van de IoT Hub. Zie De juiste IoT Hub-laag voor uw oplossing kiezen voor meer informatie over de Basic- en Standard-/gratis IoT Hub-lagen.

In dit artikel leest u hoe u twee Python-apps maakt:

Een door Python gesimuleerde apparaat-app, simDevice.py, die een directe methode implementeert met de naam lockDoor, die kan worden aangeroepen door de back-end-app.
Een Python-console-app, scheduleJobService.py, waarmee twee taken worden gemaakt. Een taak roept de directe lockDoor-methode aan en een andere taak verzendt gewenste eigenschapsupdates naar meerdere apparaten.

Notitie

Zie Azure IoT SDK's voor meer informatie over de SDK-hulpprogramma's die beschikbaar zijn voor het bouwen van zowel apparaat- als back-end-apps.

Vereisten

Een actief Azure-account. (Als u geen account hebt, kunt u binnen een paar minuten een gratis account maken.)
Een IoT-hub in uw Azure-abonnement. Als u nog geen hub hebt, kunt u de stappen volgen in Een IoT-hub maken.
Een apparaat dat is geregistreerd in uw IoT-hub. Als u geen apparaat in uw IoT-hub hebt, volgt u de stappen in Een apparaat registreren.
Python versie 3.7 of hoger wordt aanbevolen. Zorg ervoor dat u de 32-bits of 64-bits installatie gebruikt, zoals vereist door uw configuratie. Zorg ervoor dat u Python toevoegt aan uw platformspecifieke omgevingsvariabele als u hierom wordt gevraagd tijdens de installatie.

Een gesimuleerde apparaattoepassing maken

In deze sectie maakt u een Python-console-app die reageert op een directe methode die wordt aangeroepen door de cloud, waarmee een gesimuleerde lockDoor-methode wordt geactiveerd.

Belangrijk

Dit artikel bevat stappen voor het verbinden van een apparaat met behulp van een Shared Access Signature, ook wel symmetrische sleutelverificatie genoemd. Deze verificatiemethode is handig voor testen en evalueren, maar het verifiëren van een apparaat met X.509-certificaten is een veiligere benadering. Zie Best practices > voor beveiliging voor verbindingsbeveiliging voor meer informatie.

Voer bij de opdrachtprompt de volgende opdracht uit om het pakket azure-iot-device te installeren:
```
pip install azure-iot-device
```
Maak met behulp van een teksteditor een nieuw simDevice.py-bestand in uw werkmap.
Voeg de volgende import instructies en variabelen toe aan het begin van het simDevice.py-bestand . Vervang deviceConnectionString door de verbindingsreeks van het apparaat dat u hierboven hebt gemaakt:
```
import time
from azure.iot.device import IoTHubDeviceClient, MethodResponse

CONNECTION_STRING = "{deviceConnectionString}"
```

Definieer de volgende functie, waarmee een client wordt geïnstitueert en geconfigureerd om te reageren op de lockDoor-methode , en apparaatdubbelupdates te ontvangen:

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

Voeg de volgende code toe om het voorbeeld uit te voeren:

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

Sla het simDevice.py bestand op en sluit het.

Notitie

Om het eenvoudig te houden, implementeert dit artikel geen beleid voor opnieuw proberen. In productiecode moet u beleid voor opnieuw proberen implementeren (zoals een exponentiële uitstel), zoals wordt voorgesteld in het artikel Tijdelijke foutafhandeling.

De IoT Hub-verbindingsreeks ophalen

In dit artikel maakt u een back-endservice die een directe methode op een apparaat aanroept en de apparaatdubbel bijwerken. De service heeft de machtiging serviceverbinding nodig om een directe methode op een apparaat aan te roepen. De service heeft ook de lees- en schrijfmachtigingen voor het register nodig om het identiteitsregister te lezen en te schrijven. Er is geen standaardbeleid voor gedeelde toegang dat alleen deze machtigingen bevat, dus u moet er een maken.

Voer de volgende stappen uit om een beleid voor gedeelde toegang te maken dat serviceverbinding, registerlees- en registerschrijfmachtigingen verleent en om een verbindingsreeks voor dit beleid op te halen:

Open uw IoT-hub in Azure Portal. De eenvoudigste manier om naar uw IoT-hub te gaan, is door resourcegroepen te selecteren, de resourcegroep te selecteren waar uw IoT-hub zich bevindt en vervolgens uw IoT-hub te selecteren in de lijst met resources.
Selecteer in het linkerdeelvenster van uw IoT-hub beleid voor gedeelde toegang.
Selecteer in het bovenste menu boven de lijst met beleidsregels de optie Beleid voor gedeelde toegang toevoegen.
Voer in het deelvenster Beleid voor gedeelde toegang toevoegen een beschrijvende naam in voor uw beleid, bijvoorbeeld: serviceAndRegistryReadWrite. Selecteer onder Machtigingen Register Schrijven en Service Connect (Register lezen wordt automatisch geselecteerd wanneer u Register schrijven selecteert) en selecteer Vervolgens Toevoegen.
Selecteer op de pagina Beleid voor gedeelde toegang uw nieuwe beleid in de lijst met beleidsregels.
Selecteer in het nieuwe deelvenster dat wordt weergegeven het kopieerpictogram voor de primaire verbindingsreeks en sla de waarde op.

Zie Toegangsbeheer en machtigingen voor meer informatie over beleid en machtigingen voor gedeelde toegang van IoT Hub.

Belangrijk

Dit artikel bevat stappen voor het maken van verbinding met een service met behulp van een handtekening voor gedeelde toegang. Deze verificatiemethode is handig voor testen en evalueren, maar verificatie bij een service met Microsoft Entra ID of beheerde identiteiten is een veiligere benadering. Zie Best practices > voor beveiliging voor cloudbeveiliging voor meer informatie.

Taken plannen voor het aanroepen van een directe methode en het bijwerken van de eigenschappen van een apparaatdubbel

In deze sectie maakt u een Python-console-app waarmee een externe lockDoor op een apparaat wordt gestart met behulp van een directe methode en ook de gewenste eigenschappen van de apparaatdubbel worden bijgewerkt.

Voer bij de opdrachtprompt de volgende opdracht uit om het pakket azure-iot-hub te installeren:
```
pip install azure-iot-hub
```
Maak met behulp van een teksteditor een nieuw scheduleJobService.py-bestand in uw werkmap.

Voeg de volgende import instructies en variabelen toe aan het begin van het scheduleJobService.py-bestand . Vervang de {IoTHubConnectionString} tijdelijke aanduiding door de IoT-hub verbindingsreeks die u eerder hebt gekopieerd in De IoT-hub ophalen verbindingsreeks. Vervang de {deviceId} tijdelijke aanduiding door de apparaat-id (de naam) van uw geregistreerde apparaat:

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)

Voeg de volgende methoden toe om de taken uit te voeren die de directe methode en apparaatdubbel aanroepen:

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)

Voeg de volgende code toe om de taken te plannen en de taakstatus bij te werken. Neem ook de main routine op:

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

Sla het scheduleJobService.py-bestand op en sluit het.

De toepassingen uitvoeren

U kunt nu de toepassingen gaan uitvoeren.

Voer bij de opdrachtprompt in uw werkmap de volgende opdracht uit om te beginnen met luisteren naar de directe methode voor opnieuw opstarten:
```
python simDevice.py
```
Voer bij een andere opdrachtprompt in uw werkmap de volgende opdracht uit om de taken te activeren om de deur te vergrendelen en de dubbel bij te werken:
```
python scheduleJobService.py
```
U ziet de reacties van het apparaat op de directe methode en de update van apparaatdubbels in de console.

Volgende stappen

In dit artikel hebt u taken gepland om een directe methode uit te voeren en de eigenschappen van de apparaatdubbel bij te werken.

Als u ioT Hub- en apparaatbeheerpatronen wilt blijven verkennen, werkt u een afbeelding bij in de zelfstudie Apparaatupdate voor Azure IoT Hub met behulp van de Raspberry Pi 3 B+ Reference Image.

Delen via

Taken plannen en uitzenden (Python)

Vereisten

Een gesimuleerde apparaattoepassing maken

De IoT Hub-verbindingsreeks ophalen

Taken plannen voor het aanroepen van een directe methode en het bijwerken van de eigenschappen van een apparaatdubbel

De toepassingen uitvoeren

Volgende stappen

Feedback

Aanvullende resources