Megosztás a következőn keresztül:

Oktatóanyag: Egyéni IoT Edge-modulok létrehozása és üzembe helyezése

A következőkre vonatkozik:igen ikon IoT Edge 1.1

Fontos

Az IoT Edge 1.1 támogatási dátumának vége 2022. december 13.,. A termék, szolgáltatás, technológia vagy API támogatásáról a Microsoft-termékek életciklusa című leírásból tájékozódhat. További információ az IoT Edge legújabb verziójára való frissítésről: IoT Edge frissítése.

Ebben a cikkben három IoT Edge-modult hozunk létre, amelyek üzeneteket fogadnak az alsóbb rétegbeli IoT-eszközökről, futtatják az adatokat a gépi tanulási modellen keresztül, majd továbbítjuk az elemzéseket az IoT Hubnak.

Az IoT Edge Hub megkönnyíti a modul kommunikációt. Az IoT Edge Hub üzenetközvetítőként való használata független marad egymástól a moduloktól. A moduloknak csak azokat a bemeneteket kell megadniuk, amelyeken üzeneteket fogadnak, valamint azokat a kimeneteket, amelyekre üzeneteket írnak.

Azt szeretnénk, hogy az IoT Edge-eszköz négy dolgot hajt végre számunkra:

  • Adatok fogadása az alsóbb rétegbeli eszközökről.
  • Az adatokat küldő eszköz hátralévő hasznos élettartamának (RUL) előrejelzése.
  • Küldjön egy üzenetet az eszköz RUL-jával az IoT Hubnak. Ez a függvény csak akkor módosítható úgy, hogy adatokat küldjön, ha az RUL egy megadott szint alá esik.
  • Mentse az alsóbb rétegbeli eszköz adatait egy helyi fájlba az IoT Edge-eszközön. Ezt az adatfájlt rendszeresen feltölti az IoT Hubra a gépi tanulási modell betanításának finomítása érdekében. Az állandó üzenetstreamelés helyett a fájlfeltöltés használata költséghatékonyabb.

A feladatok elvégzéséhez három egyéni modult használunk:

  • RUL-osztályozó: Az Azure Machine Learning-modell betanítása és üzembe helyezése során létrehozott turboFanRulClassifier modul egy szabványos gépi tanulási modul, amely egy "amlInput" nevű bemenetet és egy "amlOutput" nevű kimenetet tesz elérhetővé. Az "amlInput" elvárja, hogy a bemenete pontosan úgy nézzen ki, mint az ACI-alapú webszolgáltatásnak küldött bemenet. Hasonlóképpen, az "amlOutput" ugyanazokat az adatokat adja vissza, mint a webszolgáltatás.

  • Avro író: Ez a modul az "avroModuleInput" bemeneten fogadja az üzeneteket, és Avro formátumban megőrzi az üzenetet lemezre, hogy később feltölthesse őket az IoT Hubra.

  • Útválasztó modul: Az útválasztó modul fogadja az alsóbb rétegbeli eszközöktől érkező üzeneteket, majd formázja és elküldi az üzeneteket az osztályozónak. A modul ezután megkapja az üzeneteket az osztályozótól, és továbbítja az üzenetet az Avro-író modulnak. Végül a modul csak az RUL-előrejelzést küldi el az IoT Hubnak.

    • Bemenetek:

      • deviceInput: üzeneteket fogad az alsóbb rétegbeli eszközökről
      • rulInput: üzeneteket fogad az "amlOutput"

    • Kimenetek:

      • classify: üzeneteket küld az "amlInput"
      • writeAvro: üzeneteket küld az "avroModuleInput" számára
      • toIotHub: üzeneteket küld a $upstream, amely átadja az üzeneteket a csatlakoztatott IoT Hubnak

Az alábbi ábra a teljes megoldás moduljait, bemeneteit, kimeneteit és IoT Edge Hub-útvonalait mutatja be:

IoT Edge három modul architektúradiagramja

A cikkben szereplő lépéseket általában egy felhőfejlesztő hajtja végre.

Az oktatóanyag ezen szakaszában a következőket sajátíthatja el:

  • Hozzon létre egy IoT Edge-modult egyéni kódból.
  • Hozzon létre egy Docker-lemezképet az egyéni modulból.
  • Konfigurálja újra az IoT Hub-útválasztást az egyéni modulok támogatásához.
  • Egyéni modulokat hozhat létre, tehet közzé és helyezhet üzembe.

Előfeltételek

Ez a cikk az Azure Machine Learning IoT Edge-en való használatával kapcsolatos oktatóanyagok sorozatának része. A sorozat minden cikke az előző cikkben szereplő munkára épül. Ha közvetlenül ehhez a cikkhez jutott, először látogasson el a első cikkére a sorozatban.

Új IoT Edge-megoldás létrehozása

A két Azure Notebook második verziójának végrehajtása során létrehoztunk és közzétettünk egy RUL-modellt tartalmazó tárolórendszerképet. Az Azure Machine Learning a rendszerkép-létrehozási folyamat részeként úgy csomagolta be ezt a modellt, hogy a rendszerkép Üzembe helyezhető legyen Azure IoT Edge-modulként.

Ebben a lépésben létrehozunk egy Azure IoT Edge-megoldást az "Azure Machine Learning" modullal, és a modult az Azure Notebooks használatával közzétett rendszerképre irányítjuk.

  1. Nyisson meg egy távoli asztali munkamenetet a fejlesztői virtuális gép számára.

  2. Nyissa meg a C:\source\IoTEdgeAndMlSample mappát a Visual Studio Code-ban.

  3. Kattintson a jobb gombbal a kezelőpanelre (az üres területen), és válassza az Új IoT Edge-megoldás lehetőséget.

    Új IoT Edge-megoldás létrehozása

  4. Fogadja el az alapértelmezett EdgeSolution megoldásnevet.

  5. Válassza az Azure Machine Learninget modulsablonként.

  6. Nevezze el a modul turbofanRulClassifier nevét.

  7. Válassza ki a gépi tanulási munkaterületet. Ez a munkaterület az oktatóanyagban létrehozott turboFanDemo munkaterület : Azure Machine Learning-modell betanítása és üzembe helyezése

  8. Válassza ki az Azure Notebook futtatása közben létrehozott képet.

  9. Tekintse meg a megoldást, és figyelje meg a létrehozott fájlokat:

    • deployment.template.json: Ez a fájl tartalmazza a megoldás egyes moduljainak definícióját. Ebben a fájlban három szakaszra kell figyelni:

      • Beállításjegyzék hitelesítő adatai: Meghatározza a megoldásban használt egyéni tárolóregisztrációs adatbázisok készletét. Jelenleg a gépi tanulási munkaterület beállításjegyzékét kell tartalmaznia, ahol az Azure Machine Learning-rendszerképet tárolták. Tetszőleges számú tárolóregisztrációs adatbázist használhat, de az egyszerűség kedvéért ezt az egy beállításjegyzéket fogjuk használni az összes modulhoz.

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

      • Modulok: Ez a szakasz a megoldáshoz tartozó, felhasználó által definiált modulokat tartalmazza. A turbofanRulClassifier modul definíciója a konténerregisztrációjában található képre mutat. Ahogy további modulokat adunk hozzá a megoldáshoz, ezek ebben a szakaszban jelennek meg.

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

      • Útvonalak: ebben az oktatóanyagban elég sokat fogunk dolgozni az útvonalakkal. Az útvonalak határozzák meg, hogyan kommunikálnak a modulok egymással. A sablon által definiált meglévő útvonal nem egyezik meg a szükséges útválasztással. Törölje az turbofanRulClassifierToIoTHub útvonalat.

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

    • deployment.debug.template.json: ez a fájl a deployment.template.jsonhibakeresési verziója. Ezt a fájlt általában szinkronizálni kell a deployment.template.json fájl tartalmával, de ehhez az oktatóanyaghoz nem szükséges.

    • .env: ebben a fájlban kell megadnia a regisztrációs adatbázis eléréséhez szükséges felhasználónevet és jelszót.

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

      Megjegyzés:

      Ez az oktatóanyag rendszergazdai bejelentkezési hitelesítő adatokat használ az Azure Container Registryhez, amelyek fejlesztési és tesztelési forgatókönyvek esetén kényelmesek. Ha készen áll az éles helyzetekre, azt javasoljuk, hogy válasszon minimális jogosultságú hitelesítési opciót, például a szolgáltatási főfelhasználókat. További információ: A tárolóregisztrációs adatbázishoz való hozzáférés kezelése.

  10. Kattintson a jobb gombbal a deployment.template.json fájlra a Visual Studio Code Explorerben, és válassza az IoT Edge-megoldás létrehozása lehetőséget.

  11. Figyelje meg, hogy ez a parancs létrehoz egy konfigurációs mappát egy deployment.amd64.json fájllal. Ez a fájl a megoldás konkrét üzembehelyezési sablonja.

Router modul hozzáadása

Ezután hozzáadjuk a Router modult a megoldáshoz. Az Útválasztó modul több feladatot is kezel a megoldásunkért:

  • Üzenetek fogadása az alsóbb rétegbeli eszközökről: amikor az üzenetek az IoT Edge-eszközre érkeznek az alsóbb rétegbeli eszközökről, az Útválasztó modul megkapja az üzenetet, és megkezdi az üzenet útválasztásának vezénylését.
  • Üzenetek küldése az RUL-osztályozó modulba: ha egy alsóbb rétegbeli eszközről új üzenet érkezik, az Útválasztó modul az RUL-osztályozó által várt formátumra alakítja át az üzenetet. Az útválasztó elküldi az üzenetet az RUL-osztályozónak egy RUL-előrejelzéshez. Miután az osztályozó előrejelzést készített, visszaküldi az üzenetet az Útválasztó modulnak.
  • RUL-üzenetek küldése az IoT Hubra: amikor az útválasztó üzeneteket fogad az osztályozótól, átalakítja az üzenetet úgy, hogy csak az alapvető információkat, az eszközazonosítót és az RUL-t tartalmazza, és elküldi a rövidített üzenetet az IoT Hubnak. Egy további finomítás, amelyet itt nem végeztünk el, csak akkor küldene üzeneteket az IoT Hubnak, ha az RUL-előrejelzés egy küszöbérték alá esik (például ha az RUL kevesebb, mint 100 ciklus). Az ily módon történő szűrés csökkenti az üzenetek mennyiségét és az IoT Hub költségeit.
  • Üzenet küldése az Avro Writer modulnak: az alsóbb rétegbeli eszköz által küldött összes adat megőrzése érdekében az Útválasztó modul elküldi az osztályozótól kapott teljes üzenetet az Avro Writer modulnak, amely megőrzi és feltölti az adatokat az IoT Hub-fájlfeltöltéssel.

Az Útválasztó modul a megoldás fontos része, amely biztosítja az üzenetek megfelelő sorrendben történő feldolgozását.

A modul létrehozása és fájlok másolása

  1. Kattintson a jobb gombbal a Visual Studio Code modulok mappájára, és válassza az IoT Edge-modul hozzáadása lehetőséget.

  2. Válassza a C# modult a modulsablonhoz.

  3. Nevezze el a modul turbofanRouter nevét.

  4. Amikor a rendszer kéri a Docker-lemezképtárat, használja a beállításjegyzéket a gépi tanulási munkaterületről (a beállításjegyzéket a deployment.template.json fájl beállításjegyzék-hitelesítő adatai csomópontjában találja). Ez az érték a beállításjegyzék teljes címének ,például <a registry.azurecr.io/turbofanrouter>.

    Megjegyzés:

    Ebben a cikkben az Azure Machine Learning-munkaterület által létrehozott Azure Container Registryt használjuk. Ez pusztán a kényelem kedvéért van. Létrehozhattunk volna egy új tárolóregisztrációs adatbázist, és közzétettük volna ott a modulokat.

  5. A terminálban parancssori felülettel másolja a mintamodul fájljait a megoldásba.

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

  6. Fogadja el a program.cs fájl felülírására vonatkozó kérést.

Útválasztó modul létrehozása

  1. A Visual Studio Code-ban válassza a Terminál>Alapértelmezett építési feladat konfigurálása lehetőséget.

  2. Válassza a „tasks.json fájl létrehozása sablonból” lehetőséget.

  3. Válassza a .NET Core lehetőséget.

  4. Cserélje le a tasks.json tartalmát a következő kódra.

    {
  "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. Mentse és zárja be tasks.json.

  6. Futtassa a buildet Ctrl + Shift + B vagy a Terminál>Futtatás Build feladat használatával.

Modulútvonalak beállítása

Ahogy fentebb említettük, az IoT Edge-futtatókörnyezet a deployment.template.json fájlban konfigurált útvonalakat használja a lazán összekapcsolt modulok közötti kommunikáció kezelésére. Ebben a szakaszban bemutatjuk, hogyan állíthatja be a turbofanRouter modul útvonalait. Először a bemeneti útvonalakat fogjuk lefedni, majd továbblépünk a kimenetekre.

Bemenetek

  1. A Program.cs Init() metódusában két visszahívást regisztrálunk a modulhoz:

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

  2. Az első visszahívás figyeli a deviceInput végpontnak küldött üzeneteket. A fenti ábrán látható, hogy az üzeneteket bármely alsóbb rétegbeli eszközről erre a bemenetre szeretnénk irányítani. A deployment.template.json fájlban adjon hozzá egy útvonalat, amely arra utasítja az edge hubot, hogy a turbofanRouter modul "deviceInput" nevű bemenetére irányítsa az IoT Edge-modul által nem küldött IoT Edge-eszköz által fogadott üzeneteket:

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

  3. Ezután adja hozzá az rulClassifier modulból érkező üzenetek útvonalát a turbofanRouter modulhoz:

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

Kimenetek

Adjon hozzá négy további útvonalat a $edgeHub útvonalparaméterhez az Útválasztó modul kimeneteinek kezeléséhez.

  1. Program.cs a SendMessageToClassifier() metódust határozza meg, amely a modulügyféllel küld üzenetet az RUL-osztályozónak az útvonal használatával:

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

  2. A SendRulMessageToIotHub() a modulügyfél használatával csak az eszköz RUL-adatait küldi el az IoT Hubra az útvonalon keresztül:

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

  3. A SendMessageToAvroWriter() a modulügyféllel küldi el az üzenetet az avroFileWriter modulhoz hozzáadott RUL-adatokkal.

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

  4. A HandleBadMessage() sikertelen üzeneteket küld az IoT Hub felé, ahol később irányíthatók.

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

Az összes útvonal együttvéve, a "$edgeHub" csomópontnak a következő JSON-hoz hasonlóan kell kinéznie.

"$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
    }
  }
}

Megjegyzés:

A turbofanRouter modul hozzáadása a következő további útvonalat hozta létre: turbofanRouterToIoTHub": "FROM /messages/modules/turbofanRouter/outputs/* INTO $upstream. Távolítsa el ezt az útvonalat, és csak a fent felsorolt útvonalakat hagyja meg a deployment.template.json fájlban.

Az Avro író modul hozzáadása

Az Avro Writer modulnak két feladata van a megoldásban, hogy üzeneteket tároljon és fájlokat töltsön fel.

  • Üzenetek tárolása: amikor az Avro-író modul üzenetet kap, az Avro formátumban írja az üzenetet a helyi fájlrendszerbe. Egy bind mountot használunk, amely egy könyvtárat (ebben az esetben /data/avrofiles) a modul tárolójának egyik útvonalába csatlakoztat. Ez a csatlakozás lehetővé teszi a modul számára, hogy helyi elérési útra (/avrofiles) írjon, és ezek a fájlok közvetlenül az IoT Edge-eszközről is elérhetők legyenek.

  • Fájlok feltöltése: Az Avro Writer modul az Azure IoT Hub fájlfeltöltési funkciójával tölt fel fájlokat egy Azure Storage-fiókba. A fájl sikeres feltöltése után a modul törli a fájlt a lemezről

Modul létrehozása és fájlok másolása

  1. A Visual Studio Code-ban válassza a Nézet>Parancspaletta lehetőséget, majd keresse meg és válassza a Python: Értelmező kiválasztása lehetőséget.

  2. Válassza ki a telepített Python 3.7-es vagy újabb verzióját.

  3. Kattintson a jobb gombbal a Visual Studio Code modulok mappájára, és válassza az IoT Edge-modul hozzáadása lehetőséget.

  4. Válassza a Python Module (Python-modul) lehetőséget.

  5. Nevezze el a modult avroFileWriter.

  6. Amikor a rendszer kéri a Docker-lemezképtárat, használja ugyanazt a beállításjegyzéket, amelyet az Útválasztó modul hozzáadásakor használt.

  7. Másolja a fájlokat a mintamodulból a megoldásba.

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

  8. Fogadja el a main.py felülírását.

  9. Figyelje meg, hogy filemanager.py és schema.py lett hozzáadva a megoldáshoz, és main.py frissült.

Megjegyzés:

Python-fájl megnyitásakor előfordulhat, hogy a rendszer kérni fogja a pylint telepítését. Az oktatóanyag elvégzéséhez nem kell telepítenie a lintert.

Adatfájlok kötött csatolása

Ahogy korábban említettük, az írómodul egy bind mount jelenlétére támaszkodik, hogy Avro-fájlokat írjon az eszköz fájlrendszerére.

Címtár hozzáadása az eszközhöz

  1. Ha nem fut, indítsa el az IoT Edge-eszköz virtuális gépét az Azure Portalon. Csatlakozzon hozzá SSH használatával. A kapcsolathoz a virtuális gép áttekintési oldaláról másolható DNS-név szükséges az Azure Portalon.

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

  2. Bejelentkezés után hozza létre azt a könyvtárat, amely a mentett alsóbb rétegbeli eszközüzeneteket fogja tárolni.

    sudo mkdir -p /data/avrofiles

  3. Állítsa be a könyvtár-engedélyeket úgy, hogy a tároló tudjon írni bele.

    sudo chmod ugo+rw /data/avrofiles

  4. Ellenőrizze, hogy a címtár rendelkezik-e írási (w) engedéllyel a felhasználó, a csoport és a tulajdonos számára.

    ls -la /data

    Címtárengedélyek avrofile-hoz

Könyvtár hozzáadása a modulhoz

Ha hozzá szeretné adni a könyvtárat a modul tárolójához, módosítjuk az avroFileWriter modulhoz társított Dockerfile-fájlokat. A modulhoz három Dockerfile tartozik: Dockerfile.amd64, Dockerfile.amd64.debug és Dockerfile.arm32v7. Ezeket a fájlokat szinkronban kell tartani, ha egy arm32-eszközön szeretnénk hibakeresést vagy üzembe helyezést végezni. Ebben a cikkben csak a Dockerfile.amd64 fájlra koncentráljon.

  1. A fejlesztői virtuális gépen nyissa meg a C:\source\IoTEdgeAndMlSample\EdgeSolution\modules\avoFileWriter\Dockerfile.amd64 fájlt.

  2. Módosítsa a fájlt úgy, hogy az a következő példához hasonlóan nézzen ki:

    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" ]

    A mkdir parancsok és chown parancsok arra utasítják a Docker buildelési folyamatát, hogy hozzon létre egy legfelső szintű könyvtárat /avrofiles néven a képen, majd a modulusert állítsa a könyvtár tulajdonosává. Fontos, hogy ezeket a parancsokat beszúrjuk, miután hozzáadták a modul felhasználóját a képhez a useradd paranccsal, és mielőtt a környezet átvált moduluserre (USER moduleuser).

  3. Szükség esetén módosítsa a Dockerfile.amd64.debug és a Dockerfile.arm32v7 megfelelő módosításait.

Kötéskonfiguráció hozzáadása az avroFileWriterhez

A kötés létrehozásának utolsó lépése a deployment.template.json (és deployment.debug.template.json) fájlok frissítése a kötési adatokkal.

  1. Nyissa meg deployment.template.json.

  2. Módosítsa az avroFileWriter moduldefinícióját úgy, hogy hozzáadja azt a Binds paramétert, amely a tárolókönyvtárat /avrofiles a peremeszköz helyi könyvtárához hozzárendeli. A moduldefiníciónak egyeznie kell a példával:

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

Bind mount beállítása a config.yaml-hez való hozzáféréshez

Még egy kötést kell hozzáadnunk az írómodulhoz. Ez a kötés hozzáférést biztosít a modulnak a kapcsolati sztring beolvasásához az IoT Edge-eszközön található /etc/iotedge/config.yaml fájlból. Szükségünk van a kapcsolati sztringre egy IoTHubClient létrehozásához, hogy meghívhassuk a upload_blob_async metódust, amellyel fájlokat tölthetünk fel az IoT Hubra. A kötés hozzáadásának lépései az előző szakaszban ismertetettekhez hasonlóak.

Címtárengedély frissítése

  1. Csatlakozzon IoT Edge-eszközéhez SSH használatával.

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

  2. Olvasási engedély hozzáadása a config.yaml fájlhoz.

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

  3. Ellenőrizze, hogy az engedélyek megfelelően vannak-e beállítva.

    ls -la /etc/iotedge/

  4. Győződjön meg arról, hogy a config.yaml engedélyei -r--r--r--.

Könyvtár hozzáadása a modulhoz

  1. A fejlesztői gépen nyissa meg a Dockerfile.amd64 fájlt.

  2. Adjon hozzá egy további halmazt mkdir és chown parancsokat a fájlhoz, így a következőképpen néz ki:

    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. Végezze el a dockerfile.amd64.debug és a Dockerfile.arm32v7 megfelelő módosításait.

A modul konfigurációjának frissítése

  1. Nyissa meg a deployment.template.json fájlt.

  2. Módosítsa az avroFileWriter moduldefinícióját úgy, hogy hozzáad egy második sort a Binds paraméterhez, amely a tárolókönyvtárat (/app/iotconfig) az eszköz helyi könyvtárához (/etc/iotedge) irányítja.

    "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. Végezze el a megfelelő módosításokat a deployment.debug.template.json.

Függőségek telepítése

Az írómodul két Python-kódtártól, a fastavro-tól és a PyYAML-ből függ. Telepíteni kell a függőségeket a fejlesztői gépen, és utasítanunk kell a Docker buildelési folyamatát, hogy telepítse őket a modul rendszerképében.

PyYAML

  1. Nyissa meg a fájlt a fejlesztői gépen, és adja hozzá a C:\source\IoTEdgeAndMlSample\EdgeSolution\modules\avoFileWriter\requirements.txt "pyyaml" szót a fájl új sorához.

    azure-iothub-device-client~=1.4.3
pyyaml

  2. Nyissa meg a Dockerfile.amd64 fájlt, és adjon hozzá egy pip install parancsot a telepítők frissítéséhez.

    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. Egy parancssorban telepítse a pyyaml-et a fejlesztői gépre.

    pip install pyyaml

Fastavro

  1. requirements.txt-ban adj hozzá a fastavro-t a pyyaml után.

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

  2. Telepítse a fastavro-t a fejlesztőgépre.

    pip install fastavro

Az IoT Hub újrakonfigurálását

Az IoT Edge-eszköz és -modulok rendszerbe való bevezetésével megváltoztattuk az elvárásainkat azzal kapcsolatban, hogy milyen adatokat küldünk el a központnak és milyen célra. Az új valóság kezeléséhez újra kell konfigurálni az útválasztást a központban.

Megjegyzés:

A modulok üzembe helyezése előtt újrakonfiguráljuk a központot, mert az avroFileWriter modul megfelelő futtatásához be kell állítani néhány központbeállítást, különösen a fájlfeltöltést.

RUL-üzenetek útvonalának beállítása az IoT Hubban

Az útválasztó és az osztályozó helyén normál üzeneteket fogunk kapni, amelyek csak az eszköz azonosítóját és az eszköz RUL-előrejelzését tartalmazzák. Az RUL-adatokat a saját tárolóhelyére szeretnénk irányítani, ahol szükség szerint figyelhetjük az eszközök állapotát, jelentéseket készíthetünk és riasztásokat hozhatunk létre. Ugyanakkor azt szeretnénk, hogy az IoT Edge-eszközhöz még nem csatlakoztatott alsóbb rétegbeli eszköz által közvetlenül küldött eszközadatok továbbra is az aktuális tárolóhelyre legyenek irányítva.

RUL-üzenetútvonal létrehozása

  1. Az Azure Portalon keresse meg az IoT Hubot.

  2. A bal oldali panel menüjében, a Központi beállítások területen válassza az Üzenet útválasztása lehetőséget.

  3. Az Útvonalak lapon válassza a Hozzáadás lehetőséget.

  4. Nevezze el az RulMessageRoute útvonalat.

  5. Válassza a Végpontválasztótól jobbra található Végpont hozzáadása lehetőséget, és válassza a Storage lehetőséget.

  6. A Storage-végpont hozzáadása lapon adja meg a végpont ruldata nevét.

  7. Válasszon egy tárolót.

  8. A Tárfiókok lapon keresse meg az oktatóanyag során használt tárfiókot, amelynek neve iotedgeandml<egyedi utótag>.

  9. Jelölje ki a ruldata-tárolót , és kattintson a Kiválasztás gombra.

  10. A Tárvégpont hozzáadása lapon válassza a Létrehozás lehetőséget a tárvégpont létrehozásához.

  11. A útvonal hozzáadása lapra visszatérve, az Útválasztás lekérdezés-hez cserélje le true a következő lekérdezésre:

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

  12. Bontsa ki a Teszt szakaszt, majd az Üzenet törzsszakaszt . Cserélje le az üzenet törzsét a várt üzeneteink alábbi példájára:

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

  13. Válassza a Tesztútvonal lehetőséget. Ha a teszt sikeres, a következőt látja: "Az üzenet megfelelt a lekérdezésnek".

  14. Kattintson a Mentés lehetőségre.

TurbofanDeviceDataToStorage útvonal frissítése

Nem akarjuk az új előrejelzési adatokat a régi tárolóhelyre továbbítani, ezért frissítse az útvonalat ennek elkerülése érdekében.

  1. Az IoT Hub üzenet-útválasztási lapján válassza az Útvonalak lapot.

  2. Válassza a turbofanDeviceDataToStorage lehetőséget, vagy bármilyen nevet, amelyet a kezdeti eszközadat-útvonalnak adott.

  3. Az útválasztási lekérdezés frissítése

    IS_DEFINED($body.OperationalSetting1)

  4. Bontsa ki a Teszt szakaszt, majd az Üzenet törzsszakaszt . Cserélje le az üzenetet a várt üzeneteink egyikének példájára.

    {
  "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. Válassza a Tesztútvonal lehetőséget. Ha a teszt sikeres, a következőt látja: "Az üzenet megfelelt a lekérdezésnek".

  6. Válassza az Mentésgombot.

Fájlfeltöltés konfigurálása

Konfigurálja az IoT Hub fájlfeltöltési funkcióját, hogy a fájlíró modul fájlokat töltsön fel a tárolóba.

  1. Az IoT Hub bal oldali panel menüjében a Hub beállításai alatt válassza a Fájlfeltöltés lehetőséget.

  2. Válassza az Azure Storage-tárolót.

  3. Válassza ki a tárfiókot a listából.

  4. Válassza ki azt a tárolót, amely azureml-blobstore névvel és egy guid-dal kezdődik, majd kattintson a Kiválasztás.

  5. Válassza az Mentésgombot. A portál értesíti Önt, ha a mentés befejeződött.

Megjegyzés:

Ebben az oktatóanyagban nem kapcsoljuk be a feltöltési értesítést, de a fájlfeltöltési értesítés kezelésével kapcsolatos részletekért lásd: Fájlfeltöltési értesítés fogadása .

Modulok létrehozása, közzététele és üzembe helyezése

Most, hogy végrehajtottuk a konfigurációs módosításokat, készen állunk a rendszerképek összeállítására és közzétételére az Azure Container Registryben. A buildelési folyamat a deployment.template.json fájllal határozza meg, hogy mely modulokat kell létrehozni. Az egyes modulok beállításai, beleértve a verziókat is, a modul mappájában található module.json fájlban találhatók. Az építési folyamat először egy Docker-buildet futtat a module.json fájlban található jelenlegi konfigurációnak megfelelő Dockerfile-okon az image létrehozásához. Ezután közzéteszi a képet a regisztrációs adatbázisban a module.json fájlból, a module.json fájlban lévő verziócímkével megegyezően. Végül létrehoz egy konfigurációspecifikus üzembehelyezési jegyzékfájlt (például deployment.amd64.json), amelyet az IoT Edge-eszközön fogunk üzembe helyezni. Az IoT Edge-eszköz beolvassa az információkat az üzembehelyezési jegyzékből, és az utasítások alapján letölti a modulokat, konfigurálja az útvonalakat, és beállítja a kívánt tulajdonságokat. Ennek az üzembe helyezési módszernek két mellékhatása van, amelyekről tisztában kell lennie:

  • Üzembe helyezési késés: mivel az IoT Edge-futtatókörnyezetnek fel kell ismernie a kívánt tulajdonságok módosítását az újrakonfigurálás megkezdése előtt, a modulok üzembe helyezése után eltarthat egy ideig, amíg a futtatókörnyezet fel nem veszi őket, és elkezdi frissíteni az IoT Edge-eszközt.

  • A modulverziók számítanak: ha a modul tárolójának új verzióját az előző modulhoz hasonló verziócímkék használatával teszi közzé a tárolóregisztrációs adatbázisban, a futtatókörnyezet nem tölti le a modul új verzióját. Összehasonlítja a helyi rendszerkép verziócímkéjét és a kívánt lemezképet az üzembe helyezési jegyzékből. Ha ezek a verziók egyeznek, a futtatókörnyezet nem hajt végre műveletet. Ezért fontos, hogy minden alkalommal növelje a modul verzióját, amikor új módosításokat szeretne üzembe helyezni. Növelje a verziót úgy, hogy módosítja a verziótulajdonságot a módosító modul module.json fájljában lévő címketulajdonság alatt. Ezután hozza létre és tegye közzé a modult.

    {
  "$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"
}

Építs és tegyél közzé

  1. Ha nem fut, indítsa el a Dockert a fejlesztői virtuális gépen.

  2. A Visual Studio Code-ban indítsa el az új terminált egy parancssor használatával, és jelentkezzen be az Azure Container Registrybe (ACR).

A szükséges felhasználónevet, jelszót és bejelentkezési kiszolgálói értékeket az Azure Portalon találja. A tárolóregisztrációs adatbázis neve "turbofandemo<unique id>" formátumú. A bal oldali panel menüjében, a Beállítások alatt válassza a Hozzáférési kulcsok lehetőséget a megtekintéshez.

docker login -u <ACR username> -p <ACR password> <ACR login server>
  1. A Visual Studio Code-ban kattintson a jobb gombbal a deployment.template.json, és válassza a Build and Push IoT Edge Solution (IoT Edge-megoldás létrehozása és leküldése) lehetőséget.

Modulok megtekintése a beállításjegyzékben

A build sikeres befejezése után az Azure Portal használatával áttekinthetjük a közzétett modulokat.

  1. Ehhez az oktatóanyaghoz nyissa meg az Azure Container Registryt. A tárolóregisztrációs adatbázis neve "turbofandemo<unique id>" formátumú.

  2. A bal oldali panel menüjében, a Szolgáltatások területen válassza az Adattárak lehetőséget.

  3. Vegye figyelembe, hogy mindkét létrehozott modul, az avrofilewriter és a turbofanrouter adattárként jelenik meg.

  4. Válassza a turbofanrouter lehetőséget, és vegye figyelembe, hogy közzétett egy 0.0.1-amd64 címkével ellátott képet.

    A turbofanrouter első címkézett verziójának megtekintése

Modulok üzembe helyezése IoT Edge-eszközön

A modulokat a megoldásban építettük és konfiguráltuk, most pedig üzembe helyezzük a modulokat az IoT Edge-eszközön.

  1. A Visual Studio Code-ban kattintson a jobb gombbal a deployment.amd64.json fájlra a konfigurációs mappában.

  2. Válassza az Üzembe helyezés létrehozása önálló eszközhöz lehetőséget.

  3. Válassza ki az IoT Edge-eszközt, aaTurboFanEdgeDevice-t.

  4. Frissítse az Azure IoT Hub-eszközök panelt a Visual Studio Code Explorerben. Látnia kell, hogy a három új modul üzembe van helyezve, de még nem fut.

  5. Néhány perc múlva újra frissítsen, és látni fogja, hogy a modulok futnak.

    Futó modulok megtekintése a Visual Studio Code-ban

Megjegyzés:

Több percig is eltarthat, amíg a modulok elindulnak, és állandó futási állapotba kerülnek. Ez idő alatt előfordulhat, hogy a modulok elindulnak és leállnak, amikor megpróbálnak kapcsolatot létesíteni az IoT Edge hub modullal.

Hibák diagnosztizálása

Ebben a szakaszban bemutatunk néhány technikát a modulokkal vagy modulokkal kapcsolatos hibák megértéséhez. Gyakran először a Visual Studio Code állapotából lehet hibát észlelni.

Sikertelen modulok azonosítása

  • Visual Studio Code: Tekintse meg az Azure IoT Hub-eszközök panelt. Ha a legtöbb modul futó állapotban van, de az egyik le van állítva, a leállított modult tovább kell vizsgálnia. Ha az összes modul hosszú ideig leállt állapotban van, az is meghibásodást jelezhet.

  • Azure Portal: Ha a portálon navigál az IoT Hubra, majd megkeresi az eszköz részleteit tartalmazó oldalt (az IoT Edge alatt, részletezi az eszközét), azt tapasztalhatja, hogy egy modul hibát jelentett, vagy soha nem jelentett semmit az IoT Hubnak.

Diagnosztizálás az eszközről

Ha bejelentkezik az IoT Edge-eszközre (esetünkben a Linux rendszerű virtuális gépre), számos információt kaphat a modulok állapotáról. Az általunk használt fő mechanizmus a Docker-parancsok, amelyek segítségével megvizsgálhatjuk az eszközön található tárolókat és lemezképeket.

  1. Jelentkezzen be az IoT Edge-eszközre:

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

  2. Az összes futó tároló listázása. Minden modulhoz látni fogunk egy tárolót, amelynek neve megfelel a modulnak. Ez a parancs emellett felsorolja a tároló pontos rendszerképét, beleértve a verziót is, hogy megfeleljen a vártnak. A képeket úgy is listázhatja, hogy a parancsban a "tároló" helyett "kép"-t ír.

    sudo docker container ls

  3. Szerezze meg a konténer naplóit. Ez a parancs megjeleníti, amiket a tárolóban lévő StdErr-be és StdOut-ba írtak. Ez a parancs azoknál a tárolóknál működik, amelyek valamilyen okból el lettek indítva, majd elpusztultak. Az edgeAgent vagy edgeHub-tárolókkal kapcsolatos események megértéséhez is hasznos.

    sudo docker container logs <container id>

  4. Vizsgálja meg a tárolót. Ez a parancs rengeteg információt ad a képről. Az adatok a keresett adatoktól függően szűrhetők. Ha például látni szeretné, hogy az avroFileWriter kötései helyesek-e, használhatja a következő parancsot:

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

  5. Csatlakozzon egy futó tárolóhoz. Ez a parancs akkor lehet hasznos, ha a tárolót futás közben szeretné megvizsgálni:

    sudo docker exec -it avroFileWriter bash

Erőforrások tisztítása

Ez az oktatóanyag egy olyan készlet része, amelyben minden cikk az előzőekben elvégzett munkára épül. Kérjük, várjon a források takarításával, amíg be nem fejezi a végső oktatóanyagot.

Következő lépések

Ebben a cikkben létrehoztunk egy IoT Edge-megoldást a Visual Studio Code-ban három modullal: egy osztályozóval, egy útválasztóval és egy fájlíróval/feltöltővel. Az útvonalakat úgy állítottuk be, hogy a modulok kommunikálhassanak egymással a peremeszközön. Módosítottuk a peremeszköz konfigurációját, és frissítettük a Docker-fájlokat a függőségek telepítéséhez és a modulok tárolóihoz való kötések hozzáadásához.

Ezután frissítettük az IoT Hub konfigurációját, hogy típus alapján irányíthassuk az üzeneteket, és kezelhessük a fájlfeltöltéseket. Minden a helyén volt, üzembe helyeztük a modulokat az IoT Edge-eszközön, és meggyőződtünk arról, hogy a modulok megfelelően futnak.

Folytassa a következő cikkben az adatok küldésének megkezdéséhez és a megoldás működés közbeni megtekintéséhez.

Adatok küldése transzparens átjárón keresztül

  • Last updated on