Share via

Taken plannen en uitzenden (Python)

  • Artikel

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 volgt de voortgang van de uitvoering op basis van een set apparaten, die wordt gedefinieerd door een query voor apparaatdubbels. 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 query voor een apparaatdubbel en gepland op een later tijdstip. Die toepassing kan vervolgens de voortgang bijhouden wanneer elk van deze apparaten de methode voor opnieuw opstarten ontvangt en uitvoert.

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

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 lagen Basic en Standard/free IoT Hub.

In dit artikel wordt beschreven hoe u twee Python-apps maakt:

  • Een gesimuleerde Python-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. De ene taak roept de directe methode lockDoor aan en een andere taak verzendt de 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. Maak er een met de CLI of de Azure Portal.

  • Een geregistreerd apparaat. Registreer er een in de Azure Portal.

  • 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 door de cloud wordt aangeroepen, die een gesimuleerde lockDoor-methode activeert.

  1. Voer bij de opdrachtprompt de volgende opdracht uit om het pakket azure-iot-device te installeren:

    pip install azure-iot-device

  2. Maak met behulp van een teksteditor een nieuw simDevice.py-bestand in uw werkmap.

  3. Voeg de volgende import instructies en variabelen toe aan het begin van het simDevice.py-bestand . Vervang door deviceConnectionString de connection string van het apparaat dat u hierboven hebt gemaakt:

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

CONNECTION_STRING = "{deviceConnectionString}"

  4. Definieer de volgende functie, waarmee een client wordt geïnstitueert en geconfigureerd om te reageren op de lockDoor-methode , en om updates voor apparaatdubbels 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

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

  6. Sla het simDevice.py-bestand op en sluit het.

Notitie

Om het eenvoudig te houden, wordt in dit artikel geen beleid voor opnieuw proberen geïmplementeerd. 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 connection string ophalen

In dit artikel maakt u een back-endservice die een directe methode op een apparaat aanroept en de apparaatdubbel bijwerkt. 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, lees- en schrijfmachtigingen voor het register verleent en om een connection string voor dit beleid op te halen:

  1. Open uw IoT-hub in de Azure Portal. De eenvoudigste manier om naar uw IoT-hub te gaan, is door Resourcegroepen te selecteren, de resourcegroep te selecteren waarin uw IoT-hub zich bevindt en vervolgens uw IoT-hub te selecteren in de lijst met resources.

  2. Selecteer In het linkerdeelvenster van uw IoT-hub de optie Beleid voor gedeelde toegang.

  3. Selecteer In het bovenste menu boven de lijst met beleidsregels de optie Beleid voor gedeelde toegang toevoegen.

  4. Voer in het deelvenster Beleid voor gedeelde toegang toevoegen een beschrijvende naam in voor uw beleid. bijvoorbeeld: serviceAndRegistryReadWrite. Selecteer onder Machtigingen de optie Register schrijven en Service Connect (Register lezen wordt automatisch geselecteerd wanneer u Register schrijven selecteert) en selecteer vervolgens Toevoegen.

    Schermopname van het toevoegen van een nieuw toegangsbeleid in de IoT Hub van de Azure Portal.

  5. Selecteer op de pagina Gedeeld toegangsbeleid uw nieuwe beleid in de lijst met beleidsregels.

  6. Selecteer in het nieuwe deelvenster dat wordt weergegeven het kopieerpictogram voor de primaire connection string en sla de waarde op.

    Schermopname van het ophalen van de primaire connection string uit een toegangsbeleid in de IoT Hub van de Azure Portal.

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

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 die een externe lockDoor op een apparaat start met behulp van een directe methode en ook de gewenste eigenschappen van de apparaatdubbel bijwerkt.

  1. Voer bij de opdrachtprompt de volgende opdracht uit om het pakket azure-iot-hub te installeren:

    pip install azure-iot-hub

  2. Maak met een teksteditor een nieuw scheduleJobService.py-bestand in uw werkmap.

  3. 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-connection string die u eerder hebt gekopieerd in De IoT-hub ophalen connection string. 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)

  4. 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)

  5. Voeg de volgende code toe om de taken te plannen en de taakstatus bij te werken. Neem ook de routine op 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()

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

De toepassingen uitvoeren

U kunt nu de toepassingen gaan uitvoeren.

  1. Voer bij de opdrachtprompt in uw werkmap de volgende opdracht uit om te luisteren naar de directe methode voor opnieuw opstarten:

    python simDevice.py

  2. 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

  3. U ziet de apparaatreacties op de update van de directe methode en apparaatdubbels in de console.

    voorbeeld van IoT Hub-taak 1 -- apparaatuitvoer

    voorbeeld van IoT Hub-taak 2-- apparaatuitvoer

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 Device Update voor Azure IoT Hub zelfstudie met behulp van de Raspberry Pi 3 B+ Reference Image.