Zelfstudie: Aangepaste IoT Edge-modules maken en implementeren

Van toepassing op: IoT Edge 1.1

Belangrijk

IoT Edge 1.1 einddatum van de ondersteuning was 13 december 2022. Raadpleeg het levenscyclusbeleid van Microsoft voor informatie over hoe dit product of deze service, technologie of API wordt ondersteund. Zie IoT Edge-bijwerken voor meer informatie over het bijwerken naar de nieuwste versie van IoT Edge.

In dit artikel maken we drie IoT Edge-modules die berichten ontvangen van downstream IoT-apparaten, de gegevens uitvoeren via uw machine learning-model en vervolgens inzichten doorsturen naar IoT Hub.

IoT Edge-hub vereenvoudigt de communicatie tussen modules. Het gebruik van de IoT Edge-hub als berichtbroker houdt modules onafhankelijk van elkaar. Modules hoeven alleen de invoer op te geven waarmee de berichten worden geaccepteerd en de uitvoer waarmee ze berichten schrijven.

We willen dat het IoT Edge-apparaat vier dingen voor ons doet:

• Gegevens ontvangen van de downstreamapparaten.
• Voorspel de resterende levensduur (RUL) voor het apparaat dat de gegevens heeft verzonden.
• Verzend een bericht met de RUL voor het apparaat naar IoT Hub. Deze functie kan alleen worden gewijzigd om gegevens te verzenden als de RUL onder een opgegeven niveau daalt.
• Sla de gegevens van het downstreamapparaat op in een lokaal bestand op het IoT Edge-apparaat. Dit gegevensbestand wordt periodiek geüpload naar IoT Hub om de training van het machine learning-model te verfijnen. Het gebruik van bestandsupload in plaats van constante berichtstreaming is rendabeler.

Voor het uitvoeren van deze taken gebruiken we drie aangepaste modules:

• RUL Classifier: De turboFanRulClassifier-module die we hebben gemaakt in Een Azure Machine Learning-model trainen en implementeren is een standaard machine learning-module, waarmee een invoer met de naam 'amlInput' en een uitvoer met de naam amlOutput wordt weergegeven. De 'amlInput' verwacht dat de invoer er precies zo uitziet als de invoer die we naar de op ACI gebaseerde webservice hebben verzonden. Op dezelfde manier retourneert 'amlOutput' dezelfde gegevens als de webservice.

• Avro writer: Deze module ontvangt berichten op de invoer "avroModuleInput" en slaat het bericht in Avro-indeling op schijf op voor later uploaden naar IoT Hub.

• routermodule: De routermodule ontvangt berichten van downstreamapparaten, formatteert en verzendt de berichten vervolgens naar de classificatie. De module ontvangt vervolgens de berichten van de classifier en stuurt het bericht door naar de Avro-writer-module. Ten slotte verzendt de module alleen de RUL-voorspelling naar de IoT Hub.

  • Ingangen:

    • deviceInput-: ontvangt berichten van downstream apparaten
    • rulInput: ontvangt berichten van de 'amlOutput'

  • Uitvoer:

    • classificeren: verzendt berichten naar 'amlInput'
    • writeAvro: verzendt berichten naar 'avroModuleInput'
    • toIotHub: verzendt berichten naar $upstream, waarmee de berichten worden doorgegeven aan de verbonden IoT Hub

In het volgende diagram ziet u de modules, invoer, uitvoer en de IoT Edge Hub-routes voor de volledige oplossing:

De stappen in dit artikel worden doorgaans uitgevoerd door een cloudontwikkelaar.

In deze sectie van de zelfstudie leert u het volgende:

• Een IoT Edge-module maken op basis van aangepaste code.
• Genereer een Docker-image uit uw aangepaste module.
• IoT Hub-routering opnieuw configureren ter ondersteuning van uw aangepaste modules.
• Bouw, publiceer en implementeer uw aangepaste modules.

Benodigdheden

Dit artikel maakt deel uit van een reeks voor een zelfstudie over het gebruik van Azure Machine Learning in IoT Edge. Elk artikel in de reeks bouwt voort op het werk in het vorige artikel. Als u rechtstreeks bij dit artikel bent aangekomen, bezoek dan het eerste artikel in de reeks.

Een nieuwe IoT Edge-oplossing maken

Tijdens de uitvoering van onze tweede Azure Notebook hebben we een containerimage met ons RUL-model gemaakt en gepubliceerd. Azure Machine Learning, als onderdeel van het proces voor het maken van installatiekopieën, verpakt dat model, zodat de installatiekopie kan worden geïmplementeerd als een Azure IoT Edge-module.

In deze stap gaan we een Azure IoT Edge-oplossing maken met behulp van de module Azure Machine Learning en de module laten verwijzen naar de afbeelding die we hebben gepubliceerd met behulp van Azure Notebooks.

1. Open een extern bureaubladsessie naar uw ontwikkel-VM.

2. Open de map C:\source\IoTEdgeAndMlSample in Visual Studio Code.

3. Klik met de rechtermuisknop op het deelvenster Explorer (in de lege plek) en selecteer Nieuwe IoT Edge-oplossing.

   

4. Accepteer de standaardoplossingsnaam EdgeSolution-.

5. Kies Azure Machine Learning- als modulesjabloon.

6. Geef de module de naam turbofanRulClassifier.

7. Kies uw machine learning-werkruimte. Deze werkruimte is de turboFanDemo werkruimte die u hebt gemaakt in Zelfstudie: Een Azure Machine Learning-model trainen en implementeren

8. Selecteer de afbeelding die u hebt gemaakt tijdens het uitvoeren van Azure Notebook.

9. Bekijk de oplossing en let op de bestanden die zijn gemaakt:

   • deployment.template.json: Dit bestand bevat de definitie van elk van de modules in de oplossing. Er zijn drie secties waar u aandacht aan moet besteden in dit bestand:

     • registerreferenties: Definieert de set aangepaste containerregisters die u in uw oplossing gebruikt. Op dit moment zou het register van uw machine learning-werkruimte moeten bevatten, dit is waar uw Azure Machine Learning-afbeelding was opgeslagen. U kunt een willekeurig aantal containerregisters hebben, maar voor het gemak gebruiken we dit ene register voor alle modules.

       "registryCredentials": {
         "<your registry>": {
           "username": "$CONTAINER_REGISTRY_USERNAME_<your registry>",
           "password": "$CONTAINER_REGISTRY_PASSWORD_<your registry>",
           "address": "<your registry>.azurecr.io"
         }
       }
       

     • Modules: Deze sectie bevat de set door de gebruiker gedefinieerde modules die bij deze oplossing worden geleverd. De definitie van de turbofanRulClassifier-module verwijst naar de afbeelding in uw containerregister. Naarmate we meer modules aan de oplossing toevoegen, worden deze in deze sectie weergegeven.

       "modules": {
          "turbofanRulClassifier": {
            "version": "1.0",
            "type": "docker",
            "status": "running",
            "restartPolicy": "always",
            "settings": {
              "image": "turbofandemo2cd74296.azurecr.io/edgemlsample:1",
              "createOptions": {}
            }
          }
       }
       

     • Routes: we zullen in deze zelfstudie behoorlijk veel met routes werken. Routes bepalen hoe modules met elkaar communiceren. De bestaande route die door de sjabloon is gedefinieerd, komt niet overeen met de routering die we nodig hebben. Verwijder de turbofanRulClassifierToIoTHub route.

       "$edgeHub": {
          "properties.desired": {
            "schemaVersion": "1.0",
            "routes": {
              "turbofanRulClassifierToIoTHub": "FROM /messages/modules/turbofanRulClassifier/outputs/* INTO $upstream"
            },
            "storeAndForwardConfiguration": {
              "timeToLiveSecs": 7200
            }
          }
       }
       

   • deployment.debug.template.json: dit bestand is de foutopsporingsversie van deployment.template.json. Normaal gesproken moeten we dit bestand gesynchroniseerd houden met de inhoud van het deployment.template.json-bestand, maar dit is niet vereist voor deze zelfstudie.

   • .env: dit bestand is waar u de gebruikersnaam en het wachtwoord moet opgeven voor toegang tot uw register.

     CONTAINER_REGISTRY_USERNAME_<your registry name>=<ACR username>
     CONTAINER_REGISTRY_PASSWORD_<your registry name>=<ACR password>
     

     Notitie

     In deze tutorial worden beheerdersinloggegevens gebruikt voor Azure Container Registry, wat handig is voor ontwikkelings- en testsituaties. Wanneer u klaar bent voor productiescenario's, adviseren wij een authenticatieoptie met het minste aantal bevoegdheden, zoals service-principals. Zie Toegang tot uw containerregister beheren voor meer informatie.

10. Klik met de rechtermuisknop op het bestand deployment.template.json in Visual Studio Code Explorer en selecteer IoT Edge Solution-bouwen.

11. U ziet dat met deze opdracht een configuratiemap met een deployment.amd64.json-bestand wordt gemaakt. Dit bestand is de concrete implementatiesjabloon voor de oplossing.

Routermodule toevoegen

Vervolgens voegen we de routermodule toe aan onze oplossing. De routermodule verwerkt verschillende verantwoordelijkheden voor onze oplossing:

• Berichten ontvangen van downstreamapparaten: wanneer berichten vanaf downstreamapparaten binnenkomen op het IoT Edge-apparaat, ontvangt de routermodule het bericht en begint de routering van het bericht te organiseren.
• Berichten verzenden naar de module RUL-classificatie: wanneer een nieuw bericht wordt ontvangen van een downstreamapparaat, transformeert de routermodule het bericht naar de indeling die de RUL-classificatie verwacht. De router verzendt het bericht naar de RUL-classificatie voor een RUL-voorspelling. Zodra de classificatie een voorspelling heeft gedaan, wordt het bericht teruggestuurd naar de routermodule.
• RUL-berichten verzenden naar IoT Hub: wanneer de router berichten van de classificatie ontvangt, transformeert het het bericht zodat het alleen de essentiële informatie, apparaat-id en RUL bevat en het verkorte bericht naar de IoT-hub verzendt. Een verdere verfijning, die we hier niet hebben gedaan, verzendt alleen berichten naar de IoT Hub wanneer de RUL-voorspelling onder een drempelwaarde valt (bijvoorbeeld wanneer de RUL minder dan 100 cycli is). Door op deze manier te filteren, vermindert u het aantal berichten en verlaagt u de kosten van de IoT-hub.
• bericht verzenden naar de Avro Writer-module: om alle gegevens die door het downstreamapparaat worden verzonden, te behouden, verzendt de routermodule het volledige bericht dat van de classificatie is ontvangen naar de Avro Writer-module, die de gegevens persistent maakt en uploadt met behulp van het uploaden van IoT Hub-bestanden.

De routermodule is een belangrijk onderdeel van de oplossing die ervoor zorgt dat berichten in de juiste volgorde worden verwerkt.

De module maken en bestanden kopiëren

1. Klik met de rechtermuisknop op de map modules in Visual Studio Code en kies IoT Edge-module toevoegen.

2. Kies C#-module voor de modulesjabloon.

3. Benoem module turbofanRouter.

4. Wanneer u wordt gevraagd om uw Docker-installatiekopieopslagplaats, gebruikt u het register uit de machine learning-werkruimte (u vindt het register in het knooppunt registryCredentials van uw deployment.template.json-bestand). Deze waarde is het volledig gekwalificeerde adres voor het register, zoals <uw register>.azurecr.io/turbofanrouter.

   Notitie

   In dit artikel gebruiken we het Azure Container Registry dat is gemaakt door de Azure Machine Learning-werkruimte. Dit is puur voor het gemak. We kunnen een nieuw containerregister hebben gemaakt en onze modules daar hebben gepubliceerd.

5. Kopieer in terminal met behulp van een opdrachtpromptshell de bestanden uit de voorbeeldmodule naar de oplossing.

   copy c:\source\IoTEdgeAndMlSample\EdgeModules\modules\turbofanRouter\*.cs c:\source\IoTEdgeAndMlSample\EdgeSolution\modules\turbofanRouter\
   

6. Accepteer de prompt om het program.cs-bestand te overschrijven.

Routermodule bouwen

1. Selecteer in Visual Studio Code Terminal>Standaard build-taak configureren.

2. Selecteer Bestand tasks.json maken uit sjabloon.

3. Selecteer .NET Core.

4. Vervang de inhoud van tasks.json door de volgende code.

   {
     "version": "2.0.0",
     "tasks": [
       {
         "label": "build",
         "command": "dotnet",
         "type": "shell",
         "group": {
           "kind": "build",
           "isDefault": true
         },
         "args": [
           "build",
           "${workspaceFolder}/modules/turbofanRouter"
         ],
         "presentation": {
           "reveal": "always"
         },
         "problemMatcher": "$msCompile"
       }
     ]
   }
   

5. Sla tasks.jsonop en sluit deze.

6. Voer de build uit met Ctrl + Shift + B of , Terminal,>,. Voer de buildtaak uit.

Moduleroutes instellen

Zoals hierboven vermeld, gebruikt de IoT Edge-runtime routes die zijn geconfigureerd in het deployment.template.json-bestand om de communicatie tussen losjes gekoppelde modules te beheren. In deze sectie gaan we inzoomen op het instellen van de routes voor de turbofanRouter-module. We behandelen eerst de invoerroutes en gaan vervolgens verder met de uitvoer.

Invoer

1. In de Methode Init() van Program.cs registreren we twee callbacks voor de module:

   await ioTHubModuleClient.SetInputMessageHandlerAsync(EndpointNames.FromLeafDevice, LeafDeviceInputMessageHandler, ioTHubModuleClient);
   await ioTHubModuleClient.SetInputMessageHandlerAsync(EndpointNames.FromClassifier, ClassifierCallbackMessageHandler, ioTHubModuleClient);
   

2. De eerste callback luistert naar berichten die zijn verzonden naar de deviceInput sink. In het bovenstaande diagram zien we dat we berichten van een downstreamapparaat naar deze invoer willen routeren. Voeg in het bestand deployment.template.json een route toe waarmee de Edge-hub een bericht moet routeren dat is ontvangen door het IoT Edge-apparaat dat niet is verzonden door een IoT Edge-module in de invoer 'deviceInput' in de turbofanRouter-module:

   "leafMessagesToRouter": "FROM /messages/* WHERE NOT IS_DEFINED($connectionModuleId) INTO BrokeredEndpoint(\"/modules/turbofanRouter/inputs/deviceInput\")"
   

3. Voeg vervolgens een route toe voor berichten van de rulClassifier-module in de turbofanRouter-module:

   "classifierToRouter": "FROM /messages/modules/turbofanRulClassifier/outputs/amloutput INTO BrokeredEndpoint(\"/modules/turbofanRouter/inputs/rulInput\")"
   

Uitgangen

Voeg vier extra routes toe aan de $edgeHub routeparameter om uitvoer van de routermodule te verwerken.

1. Program.cs definieert de methode SendMessageToClassifier(), die gebruikmaakt van de moduleclient om een bericht naar de RUL-classificatie te verzenden met behulp van de route:

   "routerToClassifier": "FROM /messages/modules/turbofanRouter/outputs/classOutput INTO BrokeredEndpoint(\"/modules/turbofanRulClassifier/inputs/amlInput\")"
   

2. SendRulMessageToIotHub() gebruikt de moduleclient om alleen de RUL-gegevens voor het apparaat via de route naar de IoT Hub te verzenden:

   "routerToIoTHub": "FROM /messages/modules/turboFanRouter/outputs/hubOutput INTO $upstream"
   

3. SendMessageToAvroWriter() gebruikt de moduleclient om het bericht te verzenden met de RUL-gegevens die zijn toegevoegd aan de avroFileWriter-module.

   "routerToAvro": "FROM /messages/modules/turbofanRouter/outputs/avroOutput INTO BrokeredEndpoint(\"/modules/avroFileWriter/inputs/avroModuleInput\")"
   

4. HandleBadMessage() verzendt mislukte berichten naar de IoT Hub, waar ze later kunnen worden gerouteerd.

   "deadLetter": "FROM /messages/modules/turboFanRouter/outputs/deadMessages INTO $upstream"
   

Met alle routes bij elkaar zou uw knooppunt "$edgeHub" er als volgt uit moeten zien in JSON:

"$edgeHub": {
  "properties.desired": {
    "schemaVersion": "1.0",
    "routes": {
      "leafMessagesToRouter": "FROM /messages/* WHERE NOT IS_DEFINED($connectionModuleId) INTO BrokeredEndpoint(\"/modules/turbofanRouter/inputs/deviceInput\")",
      "classifierToRouter": "FROM /messages/modules/turbofanRulClassifier/outputs/amlOutput INTO BrokeredEndpoint(\"/modules/turbofanRouter/inputs/rulInput\")",
      "routerToClassifier": "FROM /messages/modules/turbofanRouter/outputs/classOutput INTO BrokeredEndpoint(\"/modules/turbofanRulClassifier/inputs/amlInput\")",
      "routerToIoTHub": "FROM /messages/modules/turboFanRouter/outputs/hubOutput INTO $upstream",
      "routerToAvro": "FROM /messages/modules/turbofanRouter/outputs/avroOutput INTO BrokeredEndpoint(\"/modules/avroFileWriter/inputs/avroModuleInput\")",
      "deadLetter": "FROM /messages/modules/turboFanRouter/outputs/deadMessages INTO $upstream"
    },
    "storeAndForwardConfiguration": {
      "timeToLiveSecs": 7200
    }
  }
}

Notitie

Door de turbofanRouter-module toe te voegen, is de volgende extra route gemaakt: turbofanRouterToIoTHub": "FROM /messages/modules/turbofanRouter/outputs/* INTO $upstream. Verwijder deze route, waarbij alleen de bovenstaande routes in uw deployment.template.json-bestand worden achtergelaten.

Avro Writer-module toevoegen

De Avro Writer-module heeft twee verantwoordelijkheden in onze oplossing om berichten op te slaan en bestanden te uploaden.

• Berichten opslaan: wanneer de Avro Writer-module een bericht ontvangt, wordt het bericht naar het lokale bestandssysteem in Avro-indeling geschreven. We gebruiken een bindingskoppeling, waarmee een map (in dit geval /data/avrofiles) wordt gekoppeld aan een pad in de container van de module. Met deze koppeling kan de module naar een lokaal pad (/avrofiles) schrijven en deze bestanden rechtstreeks vanaf het IoT Edge-apparaat toegankelijk maken.

• Bestanden uploaden: de Avro Writer-module gebruikt de functie voor het uploaden van Azure IoT Hub-bestanden om bestanden te uploaden naar een Azure-opslagaccount. Zodra een bestand is geüpload, verwijdert de module het bestand van de schijf

Module maken en bestanden kopiëren

1. Selecteer in Visual Studio Code View>Command Palette en zoek en selecteer vervolgens Python: Interpreter selecteren.

2. Selecteer uw geïnstalleerde Python-versie 3.7 of hoger.

3. Klik met de rechtermuisknop op de map modules in Visual Studio Code en kies IoT Edge-module toevoegen.

4. Kies Python-module.

5. Geef de module een naam avroFileWriter.

6. Wanneer u wordt gevraagd om uw Docker-installatiekopieënopslagplaats, gebruikt u hetzelfde register als u hebt gebruikt bij het toevoegen van de routermodule.

7. Kopieer bestanden uit de voorbeeldmodule naar de oplossing.

   copy C:\source\IoTEdgeAndMlSample\EdgeModules\modules\avroFileWriter\*.py C:\source\IoTEdgeAndMlSample\EdgeSolution\modules\avroFileWriter\
   

8. Accepteer het overschrijven van main.py.

9. U ziet dat filemanager.py en schema.py zijn toegevoegd aan de oplossing en dat main.py is bijgewerkt.

Notitie

Wanneer u een Python-bestand opent, wordt u mogelijk gevraagd pylint te installeren. Je hoeft de linter niet te installeren om deze handleiding te voltooien.

Bindingskoppeling voor gegevensbestanden

Zoals eerder vermeld, is de writer-module afhankelijk van de aanwezigheid van een bindingskoppeling om Avro-bestanden naar het bestandssysteem van het apparaat te schrijven.

Map toevoegen aan apparaat

1. Start in het Azure-portaal de VM van uw IoT Edge-apparaat als deze niet actief is. Maak er verbinding mee met behulp van SSH. Voor de verbinding is de DNS-naam vereist die u kunt kopiëren vanaf de overzichtspagina voor de VIRTUELE machine in Azure Portal.

   ssh -l <user>@<vm name>.<region>.cloudapp.azure.com
   

2. Nadat u zich hebt aangemeld, maakt u de map aan voor de opgeslagen berichten van downstream-apparaten.

   sudo mkdir -p /data/avrofiles
   

3. Werk mapmachtigingen bij om deze schrijfbaar te maken door de container.

   sudo chmod ugo+rw /data/avrofiles
   

4. Controleer of de map nu schrijfmachtigingen heeft voor gebruiker, groep en eigenaar.

   ls -la /data
   

   

Directory toevoegen aan de module

Als u de map wilt toevoegen aan de container van de module, wijzigen we de Dockerfiles die zijn gekoppeld aan de avroFileWriter-module. Er zijn drie Dockerfiles gekoppeld aan de module: Dockerfile.amd64, Dockerfile.amd64.debug en Dockerfile.arm32v7. Deze bestanden moeten gesynchroniseerd worden gehouden voor het geval we fouten willen opsporen of implementeren op een arm32-apparaat. Voor dit artikel richt u zich alleen op Dockerfile.amd64.

1. Open op de ontwikkel-VM de C:\source\IoTEdgeAndMlSample\EdgeSolution\modules\avoFileWriter\Dockerfile.amd64 bestand.

2. Wijzig het bestand zodat dit eruitziet als in het volgende voorbeeld:

   FROM ubuntu:xenial
   
   WORKDIR /app
   
   RUN apt-get update && apt-get install -y --no-install-recommends libcurl4-openssl-dev
   python3-pip libboost-python1.58-dev libpython3-dev && rm -rf /var/lib/apt/lists/*
   
   RUN pip3 install --upgrade pip
   COPY requirements.txt ./
   RUN pip install -r requirements.txt
   
   COPY . .
   
   RUN useradd -ms /bin/bash moduleuser
   RUN mkdir /avrofiles && chown moduleuser /avrofiles
   USER moduleuser
   
   CMD [ "python3", "-u", "./main.py" ]
   

   Met de opdrachten mkdir en chown wordt het Docker-buildproces geïnstrueerd om een map op het hoogste niveau met de naam /avrofiles in de installatiekopieën te maken en vervolgens de modulegebruiker de eigenaar van die map te maken. Het is belangrijk dat deze opdrachten worden ingevoegd nadat de modulegebruiker is toegevoegd aan de afbeelding met de opdracht useradd en voordat de context overschakelt naar de modulegebruiker (USER moduleuser).

3. Breng indien nodig de bijbehorende wijzigingen aan in Dockerfile.amd64.debug en Dockerfile.arm32v7.

Bindingsconfiguratie toevoegen aan avroFileWriter

De laatste stap van het maken van de binding is het bijwerken van de deployment.template.json -bestanden (en deployment.debug.template.json) met de bindgegevens.

1. Open deployment.template.json.

2. Wijzig de moduledefinitie voor avroFileWriter door de parameter Binds toe te voegen die de containermap /avrofiles verwijst naar de lokale map op het edge-apparaat. De moduledefinitie moet overeenkomen met dit voorbeeld:

   "avroFileWriter": {
     "version": "1.0",
     "type": "docker",
     "status": "running",
     "restartPolicy": "always",
     "settings": {
       "image": "${MODULES.avroFileWriter}",
       "createOptions": {
         "HostConfig": {
           "Binds": [
             "/data/avrofiles:/avrofiles"
           ]
         }
       }
     }
   }
   

Bind-mount voor toegang tot config.yaml

We moeten nog één binding toevoegen voor de writer-module. Met deze binding krijgt de module toegang tot het lezen van de verbindingsreeks uit het bestand /etc/iotedge/config.yaml op het IoT Edge-apparaat. We hebben de verbindingsreeks nodig om een IoTHubClient te maken, zodat we de upload_blob_async methode kunnen aanroepen om bestanden te uploaden naar de IoT-hub. De stappen voor het toevoegen van deze binding zijn vergelijkbaar met de stappen in de vorige sectie.

Directorymachtigingen bijwerken

1. Maak verbinding met uw IoT Edge-apparaat met behulp van SSH.

   ssh -l <user>@IoTEdge-<extension>.<region>.cloudapp.azure.com
   

2. Leesmachtiging toevoegen aan het bestand config.yaml.

   sudo chmod +r /etc/iotedge/config.yaml
   

3. Controleer of de machtigingen juist zijn ingesteld.

   ls -la /etc/iotedge/
   

4. Zorg ervoor dat de machtigingen voor config.yaml zijn -r--r--r--.

Map toevoegen aan module

1. Open op uw ontwikkelcomputer het bestand Dockerfile.amd64.

2. Voeg een extra set opdrachten voor mkdir en chown toe aan het bestand, zodat deze er als volgt uitziet:

   FROM ubuntu:xenial
   
   WORKDIR /app
   
   RUN apt-get update && apt-get install -y --no-install-recommends libcurl4-openssl-dev
   python3-pip libboost-python1.58-dev libpython3-dev && rm -rf /var/lib/apt/lists/\*
   
   RUN pip3 install --upgrade pip
   COPY requirements.txt ./
   RUN pip install -r requirements.txt
   
   COPY . .
   
   RUN useradd -ms /bin/bash moduleuser
   RUN mkdir /avrofiles && chown moduleuser /avrofiles
   RUN mkdir -p /app/iotconfig && chown moduleuser /app/iotconfig
   
   USER moduleuser
   
   CMD "python3", "-u", "./main.py"]
   

3. Breng de bijbehorende wijzigingen aan in Dockerfile.amd64.debug en Dockerfile.arm32v7.

De moduleconfiguratie bijwerken

1. Open het bestand deployment.template.json.

2. Wijzig de moduledefinitie voor avroFileWriter door een tweede regel toe te voegen aan de parameter Binds die de containermap (/app/iotconfig) verwijst naar de lokale map op het apparaat (/etc/iotedge).

   "avroFileWriter": {
     "version": "1.0",
     "type": "docker",
     "status": "running",
     "restartPolicy": "always",
     "settings": {
       "image": "${MODULES.avroFileWriter}",
       "createOptions": {
         "HostConfig": {
           "Binds": [
             "/data/avrofiles:/avrofiles",
             "/etc/iotedge:/app/iotconfig"
           ]
         }
       }
     }
   }
   

3. Breng de bijbehorende wijzigingen aan in deployment.debug.template.json.

Afhankelijkheden installeren

De writer-module heeft een afhankelijkheid van twee Python-bibliotheken, fastavro en PyYAML. We moeten de afhankelijkheden op onze ontwikkelmachine installeren en instructies geven aan het Docker-buildproces om ze in de afbeelding van onze module te installeren.

PyYAML

1. Open het C:\source\IoTEdgeAndMlSample\EdgeSolution\modules\avoFileWriter\requirements.txt-bestand op uw ontwikkelcomputer en voeg 'pyyaml' toe op een nieuwe regel in het bestand.

   azure-iothub-device-client~=1.4.3
   pyyaml
   

2. Open het bestand Dockerfile.amd64 en voeg een pip install opdracht toe om setuptools bij te werken.

   FROM ubuntu:xenial
   
   WORKDIR /app
   
   RUN apt-get update && \
       apt-get install -y --no-install-recommends libcurl4-openssl-dev python3-pip libboost-python1.58-dev libpython3-dev && \
       rm -rf /var/lib/apt/lists/\*
   
   RUN pip3 install --upgrade pip
   RUN pip install -U pip setuptools
   COPY requirements.txt ./
   RUN pip install -r requirements.txt
   
   COPY . .
   
   RUN useradd -ms /bin/bash moduleuser
   RUN mkdir /avrofiles && chown moduleuser /avrofiles
   RUN mkdir -p /app/iotconfig && chown moduleuser /app/iotconfig
   USER moduleuser
   
   CMD [ "python3", "-u", "./main.py" ]
   

3. Installeer pyyaml bij een opdrachtprompt op uw ontwikkelcomputer.

   pip install pyyaml
   

Fastavro

1. Voeg in requirements.txt fastavro toe na pyyaml.

   azure-iothub-device-client~=1.4.3
   pyyaml
   fastavro
   

2. Installeer fastavro op uw ontwikkelcomputer.

   pip install fastavro
   

IoT Hub opnieuw configureren

Door het IoT Edge-apparaat en de modules in het systeem te introduceren, hebben we onze verwachtingen gewijzigd over welke gegevens naar de hub worden verzonden en voor welk doel. We moeten de routering in de hub opnieuw configureren om ons aan te passen aan onze nieuwe realiteit.

Notitie

We configureren de hub opnieuw voordat we modules implementeren omdat sommige hubinstellingen, met name het uploaden van bestanden, correct moeten zijn ingesteld voor de avroFileWriter-module om correct te worden uitgevoerd

Route instellen voor RUL-berichten in IoT Hub

Nu de router en classificatie aanwezig zijn, verwachten we dat we reguliere berichten ontvangen die alleen de apparaat-id en de RUL-voorspelling voor het apparaat bevatten. We willen de RUL-gegevens omleiden naar een eigen opslaglocatie waar we de status van de apparaten kunnen bewaken, waar nodig rapporten kunnen maken en waarschuwingen kunnen activeren. Tegelijkertijd willen we dat alle apparaatgegevens die nog steeds rechtstreeks worden verzonden door een downstreamapparaat dat nog niet is gekoppeld aan ons IoT Edge-apparaat om door te gaan naar de huidige opslaglocatie.

Een RUL-berichtroute maken

1. Ga in Azure Portal naar uw IoT Hub.

2. Selecteer in het menu aan de linkerkant, onder Hub-instellingen, de berichtroutering.

3. Op het tabblad Routes, selecteer Toevoegen.

4. Noem de route RulMessageRoute.

5. Selecteer Eindpunt toevoegen rechts van de Endpoint selector en kies Storage.

6. Geef op de pagina Een opslageindpunt toevoegen het eindpunt een naam ruldata-.

7. Selecteer Een container kiezen.

8. Op de pagina Storage accounts, zoek het opslagaccount dat u in deze zelfstudie gebruikt, met de naam iotedgeandml<uniek achtervoegsel>.

9. Selecteer de ruldata container en klik op Selecteer.

10. Opnieuw op de pagina Een opslageindpunt toevoegen, selecteer Maken om het opslageindpunt te maken.

11. Ga terug naar de pagina Voeg een route toe, voor de Routing-query, vervang true door de volgende query:

    IS_DEFINED($body.PredictedRul) AND NOT IS_DEFINED($body.OperationalSetting1)
    

12. Vouw de sectie Test uit en vervolgens de sectie Berichttekst. Vervang de berichttekst door dit voorbeeld van onze verwachte berichten:

    {
      "ConnectionDeviceId": "aaLeafDevice_1",
      "CorrelationId": "b27e97bb-06c5-4553-a064-e9ad59c0fdd3",
      "PredictedRul": 132.62721409309165,
      "CycleTime": 64.0
    }
    

13. Selecteer Test route. Als de test is geslaagd, ziet u 'Het bericht komt overeen met de query'.

14. Klik op Opslaan.

TurbofanDeviceDataToStorage-route bijwerken

We willen de nieuwe voorspellingsgegevens niet routeren naar onze oude opslaglocatie, dus werk de route bij om deze te voorkomen.

1. Selecteer op de IoT Hub -pagina Berichtroutering het tabblad Routes.

2. Selecteer turbofanDeviceDataToStorageof een andere naam die u hebt gegeven aan de eerste gegevensroute van het apparaat.

3. Werk de routeringsquery bij naar

   IS_DEFINED($body.OperationalSetting1)
   

4. Vouw de sectie Test uit en vervolgens de sectie Berichttekst. Vervang het bericht door dit voorbeeld van onze verwachte berichten:

   {
     "Sensor13": 2387.96,
     "OperationalSetting1": -0.0008,
     "Sensor6": 21.61,
     "Sensor11": 47.2,
     "Sensor9": 9061.45,
     "Sensor4": 1397.86,
     "Sensor14": 8140.39,
     "Sensor18": 2388.0,
     "Sensor12": 522.87,
     "Sensor2": 642.42,
     "Sensor17": 391.0,
     "OperationalSetting3": 100.0,
     "Sensor1": 518.67,
     "OperationalSetting2": 0.0002,
     "Sensor20": 39.03,
     "DeviceId": 19.0,
     "Sensor5": 14.62,
     "PredictedRul": 212.00132402791962,
     "Sensor8": 2388.01,
     "Sensor16": 0.03,
     "CycleTime": 42.0,
     "Sensor21": 23.3188,
     "Sensor15": 8.3773,
     "Sensor3": 1580.09,
     "Sensor10": 1.3,
     "Sensor7": 554.57,
     "Sensor19": 100.0
   }
   

5. Selecteer Test route. Als de test is geslaagd, ziet u 'Het bericht komt overeen met de query'.

6. Selecteer Opslaan.

Uploaden van bestanden configureren

Configureer de functie voor het uploaden van IoT Hub-bestanden om de file writer-module in staat te stellen bestanden naar de opslag te uploaden.

1. Kies in het linkerdeelvenster in uw IoT Hub, onder Hub-instellingen, Bestand uploaden.

2. Selecteer Azure Storage container.

3. Selecteer uw opslagaccount in de lijst.

4. Selecteer de container die begint met azureml-blobstore waaraan een guid is toegevoegd en klik op Selecteren.

5. Selecteer Opslaan. De portal meldt u wanneer het opslaan is voltooid.

Notitie

We schakelen geen uploadmelding in voor deze zelfstudie, maar zie Een melding voor het uploaden van bestanden ontvangen voor meer informatie over het afhandelen van uploadmeldingen voor bestanden.

Modules bouwen, publiceren en implementeren

Nu we de configuratiewijzigingen hebben aangebracht, zijn we klaar om de images te bouwen en ze naar ons Azure-containerregister te publiceren. Het buildproces maakt gebruik van het deployment.template.json-bestand om te bepalen welke modules moeten worden gebouwd. De instellingen voor elke module, inclusief versie, vindt u in het module.json-bestand in de modulemap. Tijdens het buildproces wordt eerst een Docker-build uitgevoerd op de Dockerfiles die overeenkomen met de huidige configuratie in het module.json-bestand om een image te maken. Vervolgens publiceert het de afbeelding vanuit het module.json-bestand in het register met een versietag die overeenkomt met die in het module.json-bestand. Ten slotte produceert het een configuratiespecifiek implementatiemanifest (bijvoorbeeld deployment.amd64.json), dat we op het IoT Edge-apparaat gaan implementeren. Het IoT Edge-apparaat leest de informatie uit het implementatiemanifest en op basis van de instructies downloadt u de modules, configureert u de routes en stelt u de gewenste eigenschappen in. Deze implementatiemethode heeft twee bijwerkingen waarvan u rekening moet houden:

• implementatievertraging: omdat de IoT Edge-runtime de wijziging in de gewenste eigenschappen moet herkennen voordat deze opnieuw wordt geconfigureerd, kan het enige tijd duren nadat u uw modules hebt geïmplementeerd totdat de runtime ze ophaalt en het IoT Edge-apparaat gaat bijwerken.

• moduleversies zijn van belang: als u een nieuwe versie van de container van een module naar uw containerregister publiceert met behulp van dezelfde versietags als de vorige module, downloadt de runtime de nieuwe versie van de module niet. Er wordt een vergelijking uitgevoerd van de versietag van de lokale installatiekopieën en de gewenste installatiekopieën uit het implementatiemanifest. Als deze versies overeenkomen, voert de runtime geen actie uit. Daarom is het belangrijk om de versie van uw module te verhogen telkens wanneer u nieuwe wijzigingen wilt implementeren. Verhoog de versie door de eigenschap versie te wijzigen onder de eigenschap tag in het module.json bestand voor de module die u wijzigt. Vervolgens bouwt en publiceert u de module.

  {
    "$schema-version": "0.0.1",
    "description": "",
    "image": {
      "repository": "<your registry>.azurecr.io/avrofilewriter",
      "tag": {
        "version": "0.0.1",
        "platforms": {
          "amd64": "./Dockerfile.amd64",
          "amd64.debug": "./Dockerfile.amd64.debug",
          "arm32v7": "./Dockerfile.arm32v7"
        }
      },
      "buildOptions": []
    },
    "language": "python"
  }
  

Bouwen en publiceren

1. Start Docker op uw ontwikkel-VM als deze niet actief is.

2. Start in Visual Studio Code een nieuwe terminal met een opdrachtprompt en meld u aan bij uw Azure Container Registry (ACR).

U vindt de vereiste waarden voor de gebruikersnaam, het wachtwoord en de aanmeldingsserver in Azure Portal. De naam van het containerregister heeft het formaat "turbofandemo<unieke id>". Selecteer in het linkerdeelvenster onder Instellingende Toegangssleutels om ze te bekijken.

docker login -u <ACR username> -p <ACR password> <ACR login server>

1. Klik in Visual Studio Code met de rechtermuisknop op deployment.template.json en kies IoT Edge Solution bouwen en pushen.

Modules in het register weergeven

Zodra de build is voltooid, kunnen we de Azure-portal gebruiken om onze gepubliceerde modules te bekijken.

1. Open de Azure Container Registry voor deze handleiding. De naam van het containerregister heeft het formaat "turbofandemo<unieke id>".

2. Selecteer in het linkerpaneel, onder de Services, de optie Opslagplaatsen.

3. Houd er rekening mee dat beide modules die u hebt gemaakt, avrofilewriter en turbofanrouterworden weergegeven als opslagplaatsen.

4. Selecteer turbofanrouter en u ziet dat u één afbeelding hebt gepubliceerd met de tag 0.0.1-amd64.

   

Modules implementeren op een IoT Edge-apparaat

We hebben de modules in onze oplossing gebouwd en geconfigureerd, nu implementeren we de modules op het IoT Edge-apparaat.

1. Klik in Visual Studio Code met de rechtermuisknop op het bestand deployment.amd64.json in de configuratiemap.

2. Kies Implementatie maken voor één apparaat.

3. Kies uw IoT Edge-apparaat aaTurboFanEdgeDevice.

4. Vernieuw het deelvenster Azure IoT Hub-apparaten in Visual Studio Code Explorer. U ziet dat de drie nieuwe modules zijn geïmplementeerd, maar nog niet worden uitgevoerd.

5. Vernieuw na enkele minuten opnieuw en u ziet dat de modules worden uitgevoerd.

   

Notitie

Het kan enkele minuten duren voordat de modules zijn gestart en zich in een stabiele status bevinden. Gedurende die tijd ziet u mogelijk dat modules worden gestart en gestopt wanneer ze proberen verbinding te maken met de IoT Edge-hubmodule.

Fouten diagnosticeren

In deze sectie delen we enkele technieken om te begrijpen wat er mis is gegaan met een module of modules. Vaak kan een fout als eerste worden opgemerkt via de status in Visual Studio Code.

Mislukte modules identificeren

• Visual Studio Code: Bekijk het deelvenster Azure IoT Hub-apparaten. Als de meeste modules een actieve status hebben, maar er een is gestopt, moet u die gestopte module verder onderzoeken. Als alle modules een gestopte status hebben gedurende een lange periode, kan dit ook duiden op fouten.

• Azure Portal: Door naar uw IoT-hub in de portal te navigeren en vervolgens de pagina met apparaatdetails te vinden (onder IoT Edge, inzoomen op uw apparaat) kan het zijn dat een module een fout heeft gerapporteerd of nooit iets heeft gerapporteerd aan de IoT-hub.

Diagnostiek via het apparaat

Door u aan te melden bij het IoT Edge-apparaat (de Linux-VM in ons geval), kunt u toegang krijgen tot een groot aantal informatie over de status van uw modules. Het belangrijkste mechanisme dat we gebruiken, zijn de Docker-opdrachten waarmee we de containers en installatiekopieën op het apparaat kunnen onderzoeken.

1. Meld u aan bij uw IoT Edge-apparaat:

   ssh -l <user>@IoTEdge-<extension>.<region>.cloudapp.azure.com
   

2. Alle actieve containers weergeven. We verwachten een container te zien voor elke module met een naam die overeenkomt met de module. Deze opdracht geeft ook de exacte afbeelding voor de container weer, inclusief versie, zodat u deze kunt vergelijken met uw verwachtingen. U kunt ook afbeeldingen weergeven door 'container' te vervangen door 'afbeelding' in de opdracht.

   sudo docker container ls
   

3. Haal de logboeken voor een container op. Met deze opdracht wordt alles uitgevoerd dat is geschreven naar StdErr en StdOut in de container. Deze opdracht werkt voor containers die zijn gestart en die om een of andere reden zijn overleden. Het is ook handig om te begrijpen wat er is gebeurd met de edgeAgent- of edgeHub-containers.

   sudo docker container logs <container id>
   

4. Inspecteer een container. Met deze opdracht krijgt u een hoop informatie over de afbeelding. De gegevens kunnen worden gefilterd, afhankelijk van wat u zoekt. Als u bijvoorbeeld wilt zien of de bindingen op de avroFileWriter juist zijn, kunt u de opdracht gebruiken:

   sudo docker container inspect -f "{{ json .Mounts }}" avroFileWriter | python -m json.tool
   

5. Maak verbinding met een actieve container. Deze opdracht kan handig zijn als u de container wilt onderzoeken terwijl deze wordt uitgevoerd:

   sudo docker exec -it avroFileWriter bash
   

Hulpmiddelen opruimen

Deze zelfstudie maakt deel uit van een set waarin elk artikel voortbouwt op het werk dat in de vorige artikelen is uitgevoerd. Wacht met het opruimen van resources tot u de laatste tutorial hebt voltooid.

Volgende stappen

In dit artikel hebben we een IoT Edge-oplossing in Visual Studio Code gemaakt met drie modules: een classificatie, een router en een schrijver/uploader voor bestanden. We hebben de routes zo ingesteld dat de modules met elkaar kunnen communiceren op het edge-apparaat. We hebben de configuratie van het edge-apparaat gewijzigd en de Dockerfiles bijgewerkt om afhankelijkheden te installeren en bindingskoppelingen toe te voegen aan de containers van de modules.

Vervolgens hebben we de configuratie van de IoT Hub bijgewerkt om onze berichten te routeren op basis van het type en om bestandsuploads te verwerken. Nu alles is geïmplementeerd, hebben we de modules geïmplementeerd op het IoT Edge-apparaat en ervoor gezorgd dat de modules correct werden uitgevoerd.

Ga door naar het volgende artikel om te beginnen met het verzenden van gegevens en bekijk uw oplossing in actie.

Gegevens verzenden via transparante gateway-