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

Oktatóanyag: Képosztályozás végrehajtása a peremhálózaton a Custom Vision Service használatával

A következőkre vonatkozik:IoT Edge 1.5 pipa IoT Edge 1.5

Fontos

Az IoT Edge 1.5 LTS a támogatott kiadás. Az IoT Edge 1.4 LTS 2024. november 12-én megszűnik. Ha egy korábbi kiadáson dolgozik, olvassa el az IoT Edge frissítése című témakört.

Az Azure IoT Edge hatékonyabbá teszi az IoT-megoldásokat azáltal, hogy a számítási feladatokat a felhőből a peremhálózatra helyezi át. Ez a képesség kiválóan alkalmas olyan szolgáltatásokra, amelyek nagy mennyiségű adatot dolgoznak fel, például számítógépes látásmodelleket. Az Azure AI Custom Vision lehetővé teszi egyéni rendszerkép-osztályozók készítését és tárolóként való üzembe helyezését az eszközökön. Ez a két szolgáltatás együttesen lehetővé teszi a felhasználók számára, hogy képekből vagy videostreamekből származó megállapításokat találjanak anélkül, hogy az összes adatot a helyszínen kívülre továbbítanák. A Custom Vision egy osztályozót biztosít, amely összehasonlítja a képeket egy betanított modellel az elemzések létrehozásához.

Egy IoT Edge-eszközön például a Custom Vision meghatározhatja, hogy egy autópályán a szokásosnál nagyobb vagy alacsonyabb a forgalom, vagy hogy egy parkolóházban vannak-e rendelkezésre álló parkolóhelyek egy sorban. Ezeket a megállapításokat műveletvégzés céljából meg lehet osztani egy másik eszközzel.

Ebben az oktatóanyagban az alábbiakkal fog megismerkedni:

  • Képosztályozó létrehozása a Custom Vision használatával.
  • Dolgozzon ki egy IoT Edge-modult, amely lekérdezi a Custom Vision webkiszolgálót az eszközön.
  • Küldje el a képosztályozó eredményeit az IoT Hubnak.

Diagram – Oktatóanyag-architektúra, fázis- és üzembe helyezési osztályozó

Ha még nem rendelkezik Azure-fiókkal, első lépésként hozzon létre egy ingyenes fiókot.

Előfeltételek

Tipp.

Ez az oktatóanyag a Custom Vision és az Azure IoT Edge egy Raspberry Pi 3-mintaprojekt egyszerűsített verziója. Felhőbeli virtuális gépen fut, és statikus rendszerképek használatával tanítja be és teszteli a képosztályozót, ami segít az IoT Edge-en futó Custom Vision új felhasználóinak. A mintaprojekt fizikai hardvert használ, és beállít egy élő kameracsatornát a képosztályozó betanításához és teszteléséhez, ami hasznos lehet egy részletesebb, valós forgatókönyvet feltáró személy számára.

Képosztályozó létrehozása a Custom Vision használatával

Képosztályozó létrehozásához hozzon létre egy Custom Vision-projektet, és biztosítson betanítási képeket. A szakaszban elvégezhető lépésekkel kapcsolatos további információkért tekintse meg az Osztályozó létrehozása a Custom Vision használatával című cikket.

A képosztályozó létrehozása és betanítása után exportálja Docker-tárolóként, és helyezze üzembe egy IoT Edge-eszközön.

Új projekt létrehozása

  1. A webböngészőben lépjen a Custom Vision weblapjára.

  2. Válassza a Sign in (Bejelentkezés) gombot, és jelentkezzen be az Azure-erőforrásokhoz használt fiókkal.

  3. Válassza az Új projekt lehetőséget.

  4. Hozza létre a projektet az alábbi értékekkel:

    Mező Érték
    Név Adja meg a projekt nevét, például az EdgeTreeClassifier nevet.
    Leírás Választható projektleírás.
    Erőforrás Válasszon ki egy Olyan Azure-erőforráscsoportot, amely tartalmaz egy Custom Vision Service-erőforrást, vagy hozzon létre újat , ha még nem adott hozzá egyet.
    Projekttípusok Osztályozás
    Osztályozási típusok Multiclass (single tag per image) (Multiclass (egyetlen címke képenként))
    Tartományok General (compact) (Általános (kompakt))
    Exportálási képességek Alapszintű platformok (TensorFlow, CoreML, ONNX, ...)

  5. Válassza a Create project (Projekt létrehozása) lehetőséget.

Képek feltöltése és az osztályozó betanítása

A képosztályozó létrehozásához betanítási és tesztelési képekre van szükség.

  1. Klónozzon vagy töltsön le mintaképeket a Cognitive-CustomVision-Windows adattárból a helyi fejlesztői gépre.

    git clone https://github.com/Microsoft/Cognitive-CustomVision-Windows.git

  2. Térjen vissza a Custom Vision-projekthez, és válassza az Add images (Képek hozzáadása) lehetőséget.

  3. Tallózással keresse meg az Ön által helyileg klónozott Git-adattárat, és lépjen az első, Cognitive-CustomVision-Windows / Samples / Images / Hemlock nevű képmappára. Jelölje ki a mappában lévő mind a 10 képet, majd válassza a Megnyitás lehetőséget.

  4. Adja hozzá a címke hemlockját ehhez a képcsoporthoz, majd nyomja le az Enter billentyűt a címke alkalmazásához.

  5. Válassza az Upload 10 files (10 fájl feltöltése) lehetőséget.

    Hemlock címkével ellátott fájlok feltöltése a Custom Visionbe

  6. Amikor a képek feltöltése sikeresen befejeződött, válassza a Done (Kész) lehetőséget.

  7. Ismét válassza az Add images (Képek hozzáadása) lehetőséget.

  8. Tallózással keresse meg a második, Cognitive-CustomVision-Windows / Samples / Images / Japanese Cherry nevű képmappát. Válassza ki a mappában található 10 képet, majd válassza az Open lehetőséget.

  9. Adja hozzá a japanese cherry (japán cseresznye) címkét ehhez a képcsoporthoz, és nyomja le az enter billentyűt a címke alkalmazásához.

  10. Válassza az Upload 10 files (10 fájl feltöltése) lehetőséget. Amikor a képek feltöltése sikeresen befejeződött, válassza a Done (Kész) lehetőséget.

  11. Mindkét képkészlet címkézése és feltöltése után válassza a Betanítás lehetőséget az osztályozó betanításához.

Az osztályozó exportálása

  1. Az osztályozó betanítását követően válassza az Export (Exportálás) lehetőséget az osztályozó Performance (Teljesítmény) lapján.

    A betanított képosztályozó exportálása

  2. Platformként válassza a DockerFile lehetőséget.

  3. A verzió megadásakor válassza a Linux lehetőséget.

  4. Válassza az Exportálás lehetőséget.

  5. Az exportálás befejezése után válassza a Letöltés lehetőséget, és mentse a .zip csomagot helyileg a számítógépre. Bontsa ki a fájlokat a csomagból. Ezekkel a fájlokkal létrehozhat egy IoT Edge-modult, amely tartalmazza a képosztályozási kiszolgálót.

Ha elérte ezt a pontot, befejezte a Custom Vision-projekt létrehozását és betanítását. Az exportált fájlokat a következő szakaszban használhatja, a Custom Vision weblappal azonban már elkészült.

IoT Edge-megoldás létrehozása

Most már rendelkezik a képosztályozó tárolóverziójának fájljaival a fejlesztői gépen. Ebben a szakaszban beállítja a képosztályozó tárolót, hogy IoT Edge-modulként fusson. Egy második modult is létrehoz, amely a kérelmeket az osztályozónak küldi el, és üzenetekként küldi el az eredményeket az IoT Hubnak.

Új megoldás létrehozása

Egy megoldás logikus módját jelenti több modul fejlesztésének és megszervezésének egyetlen IoT Edge üzemelő példány számára. A megoldás egy vagy több modul kódját és az üzembe helyezési jegyzéket tartalmazza, amely deklarálja, hogyan konfigurálhatja őket egy IoT Edge-eszközön. Hozza létre a megoldást az Azure IoT Edge Fejlesztői eszköz parancssori (CLI) fejlesztői eszközével. Az eszköz használatának legegyszerűbb módja az IoT Edge Fejlesztői tároló futtatása a Dockerrel.

  1. Hozzon létre egy osztályozó nevű könyvtárat, és váltson a könyvtárra.

    mkdir CustomVisionSolution
cd CustomVisionSolution

  2. Futtassa az iotedgedev eszköz init parancsát egy új IoT Edge-megoldás létrehozásához. Az IoT Edge Dev Docker-tárolóban adja meg a következő parancsot:

    iotedgedev solution init --template python --module classifier

    Az iotedgedev megoldás init szkriptje több lépés elvégzését kéri, például:

    • Hitelesítés az Azure-ban
    • Azure-előfizetés kiválasztása
    • Erőforráscsoport kiválasztása vagy létrehozása
    • Azure IoT Hub kiválasztása vagy létrehozása
    • Azure IoT Edge-eszköz kiválasztása vagy létrehozása

    A parancs létrehoz egy új IoT Edge-megoldást egy osztályozó nevű modullal az aktuális munkakönyvtárban.

  3. Nyissa meg a megoldást a Visual Studio Code-ban.

A képosztályozó hozzáadása

A Visual Studio Code Python-modulsablonja tartalmaz néhány mintakódot, amelyet az IoT Edge teszteléséhez futtathat. Ebben a forgatókönyvben ezt a kódot nem fogja használni. Helyette a jelen szakaszban leírt lépésekkel cserélje le a mintakódot a korábban exportált képosztályozó-tárolóra.

  1. A fájlkezelőben tallózással keresse meg a letöltött és kibontott Custom Vision-csomagot. Másolja a tartalmakat a kibontott csomagból. Ez az app és az azureml mappákat, valamint a Dockerfile és a README fájlokat jelenti.

  2. A fájlkezelőben tallózással keresse meg azt a könyvtárat, ahol a Visual Studio Code létrehozta az IoT Edge-megoldást.

  3. Nyissa meg az osztályozó modulmappáját. Ha az előző szakaszban a javasolt értékeket használta, a mappastruktúrának a következőhöz hasonlóan kell kinéznie: CustomVisionSolution / modules / classifier.

  4. Illessze be a fájlokat a classifier mappába.

  5. Térjen vissza a Visual Studio Code-ablakhoz. A megoldás munkaterületének most a modulmappában található képosztályozó-fájlokat kell mutatnia.

  6. Cserélje le az eredeti Dockerfile.amd64 fájlt a Custom Vision-csomagból származó Dockerfile fájllal, azáltal, hogy törli az eredeti Dockerfile.amd64 fájlt, majd a Dockerfile fájlt átnevezi Dockerfile.amd64 fájlra.

  7. Mentse a módosításokat.

Szimulált kameramodul létrehozása

Egy valós egyéni látásmódú üzembe helyezés során a kamera élő képeket vagy videostreameket biztosít. Ebben a forgatókönyvben szimulálhatja a kamerát egy olyan modul létrehozásával, amely egy tesztképet küld a képosztályozónak.

Ebben a szakaszban hozzáadhatja az új modult a meglévő CustomVisionSolution megoldáshoz, és létrehozhatja a kóddal a szimulált kamerát.

  1. Az iotedgedev eszközzel adjon hozzá egy új modult a megoldáshoz. A parancs létrehoz egy cameracapture nevű új mappát a megoldás modulok mappájában.

    iotedgedev solution add --template python cameracapture

  2. Nyissa meg a main.py fájlt a modulok / cameracapture mappájában.

  3. Cserélje le a teljes fájlt az alábbi kódra. A mintakód POST kéréseket küld az osztályozómodulban futó rendszerkép-feldolgozó szolgáltatásnak. Ehhez a modultárolóhoz adjon hozzá egy mintaképet, amelyet a modultároló a kérésekben fog használni. A modultároló ezután becsomagolja a választ IoT Hub-üzenetként, és elküldi azt egy kimeneti üzenetsornak.

    # Copyright (c) Microsoft. All rights reserved.
# Licensed under the MIT license. See LICENSE file in the project root for
# full license information.

import time
import sys
import os
import requests
import json
from azure.iot.device import IoTHubModuleClient, Message

# global counters
SENT_IMAGES = 0

# global client
CLIENT = None

# Send a message to IoT Hub
# Route output1 to $upstream in deployment.template.json
def send_to_hub(strMessage):
    message = Message(bytearray(strMessage, 'utf8'))
    CLIENT.send_message_to_output(message, "output1")
    global SENT_IMAGES
    SENT_IMAGES += 1
    print( "Total images sent: {}".format(SENT_IMAGES) )

# Send an image to the image classifying server
# Return the JSON response from the server with the prediction result
def sendFrameForProcessing(imagePath, imageProcessingEndpoint):
    headers = {'Content-Type': 'application/octet-stream'}

    with open(imagePath, mode="rb") as test_image:
        try:
            response = requests.post(imageProcessingEndpoint, headers = headers, data = test_image)
            print("Response from classification service: (" + str(response.status_code) + ") " + json.dumps(response.json()) + "\n")
        except Exception as e:
            print(e)
            print("No response from classification service")
            return None

    return json.dumps(response.json())

def main(imagePath, imageProcessingEndpoint):
    try:
        print ( "Simulated camera module for Azure IoT Edge. Press Ctrl-C to exit." )

        try:
            global CLIENT
            CLIENT = IoTHubModuleClient.create_from_edge_environment()
        except Exception as iothub_error:
            print ( "Unexpected error {} from IoTHub".format(iothub_error) )
            return

        print ( "The sample is now sending images for processing and will indefinitely.")

        while True:
            classification = sendFrameForProcessing(imagePath, imageProcessingEndpoint)
            if classification:
                send_to_hub(classification)
            time.sleep(10)

    except KeyboardInterrupt:
        print ( "IoT Edge module sample stopped" )

if __name__ == '__main__':
    try:
        # Retrieve the image location and image classifying server endpoint from container environment
        IMAGE_PATH = os.getenv('IMAGE_PATH', "")
        IMAGE_PROCESSING_ENDPOINT = os.getenv('IMAGE_PROCESSING_ENDPOINT', "")
    except ValueError as error:
        print ( error )
        sys.exit(1)

    if ((IMAGE_PATH and IMAGE_PROCESSING_ENDPOINT) != ""):
        main(IMAGE_PATH, IMAGE_PROCESSING_ENDPOINT)
    else: 
        print ( "Error: Image path or image-processing endpoint missing" )

  4. Mentse a main.py fájlt.

  5. Nyissa meg a requirements.txt fájlt.

  6. Adjon meg egy új sort, amelyet egy kódtár tartalmazni fog a tárolóban.

    requests

  7. Mentse a requirements.txt fájlt.

Tesztkép hozzáadása a tárolóhoz

Ebben a forgatókönyvben ahelyett, hogy valódi kamerát használnánk egy képcsatorna biztosításához, egyetlen tesztképet használunk. A tesztképet az a GitHub-adattár tartalmazza, amelyet a betanítási képekhez töltött le korábban ebben az oktatóanyagban.

  1. Lépjen a tesztképhez, amely a következő helyen található: Cognitive-CustomVision-Windows / Samples / Images / Test.

  2. Másolja a test_image.jpg fájlt

  3. Keresse meg az IoT Edge-megoldás könyvtárát, és illessze be a tesztképet a modulok / cameracapture mappájába. A képnek ugyanabban a mappában kell lennie, mint ahol az előző szakaszban szerkesztett main.py fájl található.

  4. A Visual Studio Code-ban nyissa meg a CameraCapture modul Dockerfile.amd64 fájlját.

  5. A WORKDIR /app munkakönyvtárat létrehozó sor után adja hozzá az alábbi kódsort:

    ADD ./test_image.jpg .

  6. Mentse a Dockerfile-t.

Üzembehelyezési jegyzék előkészítése

Ebben az oktatóanyagban eddig egy egyéni látásmodellt tanított be, ami a faképeket osztályozza, és azt IoT Edge-modulként csomagolta. Ezután létrehozott egy második modult, amely lekérdezi a képosztályozó kiszolgálót, és az eredményeket eljuttatja az IoT Hubnak. Most már készen áll az üzembe helyezési jegyzék létrehozására, amely tájékoztatja az IoT Edge-eszközt, hogyan indíthatja el és futtathatja együtt ezt a két modult.

A Visual Studio Code-hoz készült IoT Edge-bővítmény egy sablont biztosít az egyes IoT Edge-megoldásokban, amelynek segítségével üzembehelyezési jegyzéket hozhat létre.

  1. Nyissa meg a deployment.template.json fájlt a megoldás mappájában.

  2. Állítsa be a regisztrációs adatbázis hitelesítő adatait a modulokhoz az üzembe helyezési jegyzékben.

    "registryCredentials": {
    "<registryName>": {
        "username": "<AcrUsername>",
        "password": "<AcrPassword>",
        "address": "<registryName>.azurecr.io"
    }
}

    Cserélje le <a registryName> nevet az Azure-tárolóregisztrációs adatbázis nevére, és cserélje le <az AcrUsername> és <az AcrPassword nevet> a beállításjegyzék felhasználónevére és jelszavára. Ezeket az értékeket az Azure-tárolóregisztrációs adatbázis Hozzáférési kulcsok szakaszában találja az Azure Portalon.

  3. Keresse meg a modulok szakaszt, amely három modult tartalmaz: a létrehozott kettőt, az osztályozót és a kamerakészletet, a harmadikat pedig alapértelmezés szerint a tempSensor tartalmazza.

  4. Törölje a tempSensor modult az összes paraméterével. Ez a modul mintaadatokat biztosít a tesztforgatókönyvekhez, de ebben az üzembe helyezésben nincs rá szükség.

  5. Ha a képosztályozó modulnak nem a classifier nevet adta, ellenőrizze a nevet, és győződjön meg arról, hogy csak kisbetűket tartalmaz. A cameracapture modul egy kérelemtár használatával hívja meg az osztályozó modult, amely az összes kérést kisbetűs formátumban formázza, és az IoT Edge kis- és nagybetűkre érzékeny.

  6. Minden rendszermodul edgeAgent és edgeHub esetében módosítsa a createOptions értékét sztringezett verzióra. Például:

    "createOptions": "{\"HostConfig\":{\"PortBindings\":{\"5671/tcp\":[{\"HostPort\":\"5671\"}],\"8883/tcp\":[{\"HostPort\":\"8883\"}],\"443/tcp\":[{\"HostPort\":\"443\"}]}}}"

  7. Minden rendszermodul edgeAgent és edgeHub esetében módosítsa a rendszerkép verzióját a legújabb 1.5-ös verzióra. Például:

    "image": "mcr.microsoft.com/azureiotedge-agent:1.5",
"image": "mcr.microsoft.com/azureiotedge-hub:1.5",

  8. Frissítse az osztályozó modul createOptions paraméterét egy sztringezett verzióra. Például:

    "createOptions": "{\"HostConfig\":{\"PortBindings\":{\"5671/tcp\":[{\"HostPort\":\"5671\"}],\"8883/tcp\":[{\"HostPort\":\"8883\"}],\"443/tcp\":[{\"HostPort\":\"443\"}]}}}"

  9. Frissítse a cameracapture modul createOptions paraméterét a következő JSON-val. Ez az információ olyan környezeti változókat hoz létre a modultárolóban, amelyek a main.py folyamatban vannak lekérve. Az üzembehelyezési jegyzékben szereplő információk segítségével a rendszerképet vagy a végpontot a modul lemezképének újraépítése nélkül módosíthatja.

    "createOptions": "{\"Env\":[\"IMAGE_PATH=test_image.jpg\",\"IMAGE_PROCESSING_ENDPOINT=http://classifier/image\"]}"

    Ha a Custom Vision-modulnak nem a classifier nevet adta, frissítse úgy a képfeldolgozó végpont értékét, hogy megegyezzen a modul nevével.

    Az osztályozó és a kameralap konfigurációjának például a következőhöz hasonlónak kell lennie:

    "modules": {
    "classifier": {
        "version": "1.0",
        "type": "docker",
        "status": "running",
        "restartPolicy": "always",
        "settings": {
            "image": "${MODULES.classifier}",
            "createOptions": "{\"HostConfig\":{\"PortBindings\":{\"5671/tcp\":[{\"HostPort\":\"5671\"}],\"8883/tcp\":[{\"HostPort\":\"8883\"}],\"443/tcp\":[{\"HostPort\":\"443\"}]}}}"
        }
    },
    "cameracapture": {
        "version": "1.0",
        "type": "docker",
        "status": "running",
        "restartPolicy": "always",
        "settings": {
            "image": "${MODULES.cameracapture}",
            "createOptions": "{\"Env\":[\"IMAGE_PATH=test_image.jpg\",\"IMAGE_PROCESSING_ENDPOINT=http://classifier/image\"]}"
        }
    }
}

  10. Mentse a deployment.template.json fájlt.

Az IoT Edge-megoldás létrehozása és leküldése

Miután létrehozta mindkét modult, és konfigurálta az üzembehelyezési jegyzéksablont, hozza létre a tárolólemezképeket, és küldje el őket a tárolóregisztrációs adatbázisba.

Amikor a rendszerképek a beállításjegyzékben vannak, üzembe helyezheti a megoldást az IoT Edge-eszközön. Az IoT Hubon keresztül állíthat be modulokat egy eszközön. Ebben a szakaszban be kell állítania az IoT Hubhoz való hozzáférést, majd az Azure CLI használatával üzembe helyezheti a megoldást az IoT Edge-eszközön.

Először hozza létre és küldje le a megoldást a tárolóregisztrációs adatbázisba.

  1. Nyissa meg a Visual Studio Code integrált terminálját a Terminál

  2. Jelentkezzen be a Dockerbe az alábbi parancs beírásával a terminálon az Azure Container Registry felhasználónévvel, jelszóval és bejelentkezési kiszolgálóval. Ezeket az értékeket lekérheti a beállításjegyzék Access-kulcsok szakaszából az Azure Portalon.

    docker login -u <AcrUsername> -p <AcrPassword> <AcrLoginServer>

    Előfordulhat, hogy biztonsági figyelmeztetést kap, amely a használatát --password-stdinjavasolja. Bár ez az ajánlott eljárás éles forgatókönyvekhez ajánlott, az oktatóanyag hatókörén kívül esik. További információkért tekintse meg a Docker bejelentkezési referenciát.

  3. A modul Docker-lemezképének létrehozásához és címkézéséhez használja a modul Docker-fájlját.

    docker build --rm -f "<DockerFilePath>" -t <ImageNameAndTag> "<ContextPath>"

    Ha például a rendszerképet a helyi beállításjegyzékhez vagy egy Azure-tárolóregisztrációs adatbázishoz szeretné létrehozni, használja a következő parancsokat:

    
# Build and tag the image for an Azure Container Registry. Replace <AcrRegistryName> with your own registry name.

docker build --rm -f "./modules/classifier/Dockerfile.amd64" -t <AcrRegistryName>.azurecr.io/classifier:0.0.1-amd64 "./modules/classifier"
docker build --rm -f "./modules/cameracapture/Dockerfile.amd64" -t <AcrRegistryName>.azurecr.io/cameracapture:0.0.1-amd64 "./modules/cameracapture"

Leküldéses modul Docker-rendszerképe

Adja meg a tárolóregisztrációs adatbázis hitelesítő adatait a Dockernek, hogy az le tudja küldeni a tárolólemezképet a tárolóregisztrációs adatbázisban lévő tárolóba.

  1. Jelentkezzen be a Dockerbe az Azure Container Registry (ACR) hitelesítő adataival.

    docker login -u <AcrUsername> -p <AcrPassword> <AcrLoginServer>

    Előfordulhat, hogy biztonsági figyelmeztetést kap, amely a használatát --password-stdinjavasolja. Bár ez az ajánlott eljárás éles forgatókönyvekhez, az oktatóanyag hatókörén kívül esik. További információkért tekintse meg a Docker bejelentkezési referenciát.

  2. Jelentkezzen be az Azure Container Registrybe. A parancs használatához telepítenie kell az Azure CLI-taz. Ez a parancs a tárolóregisztrációs adatbázisban található felhasználónevet és jelszót kéri a Beállítások

    az acr login -n <AcrRegistryName>

    Tipp.

    Ha az oktatóanyag bármely pontján kijelentkezik, ismételje meg a Docker és az Azure Container Registry bejelentkezési lépéseit a folytatáshoz.

  3. Küldje el a modul rendszerképét a helyi beállításjegyzékbe vagy egy tárolóregisztrációs adatbázisba.

    docker push <ImageName>

    Például:

    # Push the Docker image to an Azure Container Registry. Replace <AcrRegistryName> with your Azure Container Registry name.

az acr login --name <AcrRegistryName>
docker push <AcrRegistryName>.azurecr.io/classifier:0.0.1-amd64
docker push <AcrRegistryName>.azurecr.io/cameracapture:0.0.1-amd64

Az üzembehelyezési sablon frissítése

Frissítse a deployment.template.json fájlt a tárolóregisztrációs adatbázis lemezképének helyével. Módosítsa a rendszerkép értékét a beállításjegyzékbe leküldett képre. Például cserélje le a <AcrRegistryName> nevet a saját beállításjegyzék nevére az osztályozó és a cameracapture modulok képadatain.

"classifier": {
    "version": "1.0",
    "type": "docker",
    "status": "running",
    "restartPolicy": "always",
    "settings": {
        "image": "<AcrRegistryName>.azurecr.io/classifier:0.0.1-amd64",
        "createOptions": "{\"HostConfig\":{\"PortBindings\":{\"5671/tcp\":[{\"HostPort\":\"5671\"}],\"8883/tcp\":[{\"HostPort\":\"8883\"}],\"443/tcp\":[{\"HostPort\":\"443\"}]}}}"
    },
    "cameracapture": {
        "version": "1.0",
        "type": "docker",
        "status": "running",
        "restartPolicy": "always",
        "settings": {
            "image": "<AcrRegistryName>.azurecr.io/cameracapture:0.0.1-amd64",
            "createOptions": "{\"Env\":[\"IMAGE_PATH=test_image.jpg\",\"IMAGE_PROCESSING_ENDPOINT=http://classifier/image\"]}"
        }
    }
}

A végső üzembehelyezési jegyzék a következőhöz hasonlóan néz ki:

{
  "$schema-template": "4.0.0",
  "modulesContent": {
    "$edgeAgent": {
      "properties.desired": {
        "schemaVersion": "1.1",
        "runtime": {
          "type": "docker",
          "settings": {
            "minDockerVersion": "v1.25",
            "loggingOptions": "",
            "registryCredentials": {
              "<AcrRegistryName>": {
                "username": "<AcrUserName>",
                "password": "<AcrPassword>",
                "address": "<AcrRegistryName>.azurecr.io"
              }
            }
          }
        },
        "systemModules": {
          "edgeAgent": {
            "type": "docker",
            "settings": {
              "image": "mcr.microsoft.com/azureiotedge-agent:1.5",
              "createOptions": "{\"HostConfig\":{\"PortBindings\":{\"5671/tcp\":[{\"HostPort\":\"5671\"}],\"8883/tcp\":[{\"HostPort\":\"8883\"}],\"443/tcp\":[{\"HostPort\":\"443\"}]}}}"
            }
          },
          "edgeHub": {
            "type": "docker",
            "status": "running",
            "restartPolicy": "always",
            "settings": {
              "image": "mcr.microsoft.com/azureiotedge-hub:1.5",
              "createOptions": "{\"HostConfig\":{\"PortBindings\":{\"5671/tcp\":[{\"HostPort\":\"5671\"}],\"8883/tcp\":[{\"HostPort\":\"8883\"}],\"443/tcp\":[{\"HostPort\":\"443\"}]}}}"
            }
          }
        },
        "modules": {
          "classifier": {
            "version": "1.0",
            "type": "docker",
            "status": "running",
            "restartPolicy": "always",
            "settings": {
              "image": "<AcrRegistryName>.azurecr.io/classifier:0.0.1-amd64",
              "createOptions": "{\"HostConfig\":{\"PortBindings\":{\"5671/tcp\":[{\"HostPort\":\"5671\"}],\"8883/tcp\":[{\"HostPort\":\"8883\"}],\"443/tcp\":[{\"HostPort\":\"443\"}]}}}"
            }
          },
          "cameracapture": {
            "version": "1.0",
            "type": "docker",
            "status": "running",
            "restartPolicy": "always",
            "settings": {
              "image": "<AcrRegistryName>.azurecr.io/cameracapture:0.0.1-amd64",
              "createOptions": "{\"Env\":[\"IMAGE_PATH=test_image.jpg\",\"IMAGE_PROCESSING_ENDPOINT=http://classifier/image\"]}"
            }
          }
        }
      }
    },
    "$edgeHub": {
      "properties.desired": {
        "schemaVersion": "1.2",
        "routes": {
          "sensorToclassifier": "FROM /messages/modules/tempSensor/outputs/temperatureOutput INTO BrokeredEndpoint(\"/modules/classifier/inputs/input1\")",
          "classifierToIoTHub": "FROM /messages/modules/classifier/outputs/* INTO $upstream",
          "cameracaptureToIoTHub": "FROM /messages/modules/cameracapture/outputs/* INTO $upstream"
        },
        "storeAndForwardConfiguration": {
          "timeToLiveSecs": 7200
        }
      }
    }
  }
}

Modulok üzembe helyezése az eszközön

Ellenőrizze, hogy a beépített tárolólemezképek a tárolóregisztrációs adatbázisban vannak-e tárolva. Ezután helyezze üzembe őket egy eszközön a forgatókönyvhöz előkészített üzembehelyezési jegyzék deployment.template.json használatával.

Az IoT Edge Azure CLI set-modules parancsával üzembe helyezheti a modulokat az Azure IoT Hubon. Ha például az deployment.template.json fájlban definiált modulokat az IoT Edge <deviceName> IoT Hub <IotHubName-jére> szeretné telepíteni, használja az alábbi parancsot. Cserélje le a központnév, az eszközazonosító és a bejelentkezési IoT Hub kapcsolati sztring értékeit a sajátjaira.

az iot edge set-modules --hub-name <IotHubName> --device-id <DeviceName> --content ./deployment.template.json --login "HostName=my-iot-hub.azure-devices.net;SharedAccessKeyName=iothubowner;SharedAccessKey=<SharedAccessKey>"

Tipp.

Az IoT Hub kapcsolati sztring az Azure Portal megosztott hozzáférési kulcsával együtt is megtalálható. Nyissa meg az IoT Hub >biztonsági beállításait>, és nyissa meg az iothubowner megosztott hozzáférési szabályzatait>.

Győződjön meg arról, hogy az IoT Edge-eszköz fut.

Az eszköz alatt bontsa ki a Modulok elemet az üzembe helyezett és a futó modulok listájának megtekintéséhez. Válassza a frissítés gombot. Az új osztályozó és kamerarögzítő modulok a $edgeAgent és $edgeHub együtt futnak.

Azt is ellenőrizheti, hogy működik-e az összes modul magán az eszközön. Futtassa az alábbi parancsot az IoT Edge-eszközön a modulok állapotának megtekintéséhez.

iotedge list

A modulok elindítása eltarthat néhány percig. Az IoT Edge-futtatókörnyezetnek meg kell kapnia az új üzembehelyezési jegyzékfájlt, le kell húznia a modul lemezképeit a tároló futtatókörnyezetéből, majd el kell indítania minden új modult.

Osztályozási eredmények megtekintése

Az eszközön tekintse meg a cameracapture modul naplóit az elküldött üzenetek megtekintéséhez és az IoT Hub általi fogadásuk megerősítéséhez.

iotedge logs cameracapture

Például a következőhöz hasonló kimenetnek kell megjelennie:

admin@vm:~$ iotedge logs cameracapture
Simulated camera module for Azure IoT Edge. Press Ctrl-C to exit.
The sample is now sending images for processing and will indefinitely.
Response from classification service: (200) {"created": "2023-07-13T17:38:42.940878", "id": "", "iteration": "", "predictions": [{"boundingBox": null, "probability": 1.0, "tagId": "", "tagName": "hemlock"}], "project": ""}

Total images sent: 1
Response from classification service: (200) {"created": "2023-07-13T17:38:53.444884", "id": "", "iteration": "", "predictions": [{"boundingBox": null, "probability": 1.0, "tagId": "", "tagName": "hemlock"}], "project": ""}

Feljegyzés

Kezdetben csatlakozási hibák jelentkezhetnek a kamerakészlet modul kimenetében az üzembe helyezett és az indítási modulok közötti késés miatt.

A cameracapture modul automatikusan újra megismétli a kapcsolatot, amíg sikeres nem lesz. A sikeres csatlakozás után megjelennek a várt képbesorolási üzenetek.

A CameraCapture modul üzenetként küldött Custom Vision modul eredményei tartalmazzák annak a valószínűségét, hogy a kép hemlock vagy cseresznyefa. Mivel a kép borsikafű, úgy látod, hogy a valószínűség 1,0.

Az erőforrások eltávolítása

Ha folytatni szeretné a következő ajánlott cikket, tartsa meg a létrehozott erőforrásokat és konfigurációkat, és használja újra őket. Azt is megteheti, hogy ugyanezt az IoT Edge-eszközt használja teszteszközként.

Ellenkező esetben törölje a helyi konfigurációkat és az ebben a cikkben használt Azure-erőforrásokat a díjak elkerülése érdekében.

Azure-erőforrások törlése

Az Azure-erőforrások és -erőforráscsoportok törlése visszafordíthatatlan. Figyeljen, nehogy véletlenül rossz erőforráscsoportot vagy erőforrásokat töröljön. Ha az IoT Hubot egy meglévő erőforráscsoporton belül hozta létre, amelyben meg szeretné tartani az erőforrásokat, csak magát az IoT Hub-erőforrást törölje, nem pedig az erőforráscsoportot.

Az erőforrások törlése:

  1. Jelentkezzen be az Azure Portalra, és válassza az Erőforráscsoportok elemet.
  2. Válassza ki az IoT Edge teszterőforrásokat tartalmazó erőforráscsoport nevét.
  3. Tekintse át az erőforráscsoport által tartalmazott erőforrások listáját. Ha mindet törölni szeretné, válassza az Erőforráscsoport törlése lehetőséget. Ha csak néhányat szeretne törölni, az egyes erőforrásokat egyenként is törölheti.

Következő lépések

Ebben az oktatóanyagban betanított egy Custom Vision-modellt, és modulként üzembe helyezte azt egy IoT Edge-eszközön. Ezután létrehozott egy modult, amely le tudja kérdezni a képosztályozási szolgáltatást, és visszajelzést tud küldeni az eredményekről az IoT Hubnak.

Folytassa a következő oktatóanyagokkal, amelyekből megtudhatja, hogy az Azure IoT Edge hogyan segíthet az adatok üzleti elemzésekké alakításában a peremhálózaton.

Adatok tárolása a peremhálózaton SQL Server-adatbázisokkal

  • Last updated on