Kurz: Provádění klasifikace obrázků na hraničních zařízeních s využitím služby Custom Vision

2025-05-07

Platí pro: IoT Edge 1.5

Důležité

Podporovanou verzí je IoT Edge 1.5 LTS. IoT Edge 1.4 LTS je konec životnosti od 12. listopadu 2024. Pokud používáte starší verzi, podívejte se na článek Aktualizace IoT Edge.

Azure IoT Edge zefektivňuje řešení IoT přesunem úloh z cloudu na okraj. Tato schopnost se dobře hodí ke službám, které zpracovávají velké objemy dat, jako jsou modely počítačového zpracování obrazu. Azure AI Custom Vision umožňuje vytvářet vlastní klasifikátory imagí a nasazovat je do zařízení jako kontejnery. Tyto dvě služby umožňují uživatelům najít přehledy z obrázků nebo datových proudů videa, aniž by nejprve přenášeli všechna data mimo pracoviště. Custom Vision poskytuje klasifikátor, který porovnává obrázky s natrénovaným modelem za účelem generování přehledů.

Služba Custom Vision na zařízení IoT Edge může například určit, jestli má dálnice vyšší nebo nižší provoz než obvykle nebo jestli má parkovací garáž k dispozici parkovací místa na řádku. Tyto přehledy je možné sdílet s jinou službou, která na ně může reagovat.

V tomto kurzu se naučíte:

Vytvoření klasifikátoru obrázků s využitím služby Custom Vision
Vyvíjejte modul IoT Edge, který se dotazuje na webový server Custom Vision na zařízení.
Odeslání výsledků klasifikátoru obrázků do IoT Hubu

Diagram – architektura kurzu, fáze a nasazení klasifikátoru

Pokud nemáte účet Azure, vytvořte si bezplatný účet před tím, než začnete.

Požadavky

Návod

Tento kurz je zjednodušená verze služby Custom Vision a Azure IoT Edge v ukázkovém projektu Raspberry Pi 3 . Běží na cloudovém virtuálním počítači a používá statické obrázky k trénování a otestování klasifikátoru obrázků, který pomáhá někomu, kdo je ve službě Custom Vision ve službě IoT Edge nový. Ukázkový projekt používá fyzický hardware a nastavuje živý přenos kamery pro trénování a testování klasifikátoru obrázků, což je užitečné pro někoho, kdo zkoumá podrobnější scénáře v reálném prostředí.

Nastavte prostředí pro vývoj kontejnerů s Linuxem dokončením kurzu: Vývoj modulů IoT Edge pomocí editoru Visual Studio Code s upřednostňovaným vývojovým nástrojem pro Azure IoT Edge Dev Tool (CLI). Po dokončení kurzu se ujistěte, že jsou ve vašem vývojovém prostředí k dispozici následující požadavky:
- IoT Hub úrovně Free nebo Standard v Azure
- Zařízení s Azure IoT Edge s kontejnery Linuxu. Pomocí rychlých startů můžete nastavit zařízení s Linuxem nebo zařízení s Windows.
- Registr kontejneru, například Azure Container Registry.
- Visual Studio Code je nastavený pomocí rozšíření Azure IoT Hub .
- Stáhněte a nainstalujte do vývojového počítače systém pro správu kontejnerů kompatibilní s Dockerem . Nastavte ho pro spouštění kontejnerů Linuxu.
Pokud chcete vyvíjet modul IoT Edge se službou Custom Vision, ujistěte se, že jsou na vývojovém počítači nainstalované následující další požadavky:
- Krajta
- Lotr
- Rozšíření Python pro Visual Studio Code

Vytvoření klasifikátoru obrázků s využitím služby Custom Vision

Pokud chcete vytvořit klasifikátor obrázků, vytvořte projekt Custom Vision a poskytněte trénovací obrázky. Další informace o krocích, které provedete v této části, najdete v tématu Postup vytvoření klasifikátoru s využitím služby Custom Vision.

Po sestavení a trénování klasifikátoru image ho exportujte jako kontejner Dockeru a nasaďte ho do zařízení IoT Edge.

Vytvoření nového projektu

Ve webovém prohlížeči přejděte na webovou stránku služby Custom Vision.
Vyberte Přihlásit se a přihlaste se pomocí stejného účtu, který používáte pro přístup k prostředkům Azure.
Vyberte Nový projekt.

Vytvořte projekt s použitím následujících hodnot:

Pole	Hodnota
Název	Zadejte název projektu, například EdgeTreeClassifier.
Popis	Volitelný popis projektu.
Prostředek	Vyberte jednu z vašich skupin prostředků Azure, která obsahuje prostředek služby Custom Vision, nebo vytvořte nový , pokud jste ho ještě nepřidali.
Typy projektů	Klasifikace
Typy klasifikace	Více tříd (jedna značka na obrázek)
Domény	Obecné (kompaktní)
Možnosti exportu	Základní platformy (TensorFlow, CoreML, ONNX, ...)

Vyberte příkaz Vytvořit projekt.

Nahrání obrázků a trénování klasifikátoru

Vytvoření klasifikátoru obrázků vyžaduje sadu trénovacích obrázků a testovacích obrázků.

Na svůj místní vývojový počítač si naklonujte nebo stáhněte ukázkové obrázky z úložiště Cognitive-CustomVision-Windows.
```
git clone https://github.com/Microsoft/Cognitive-CustomVision-Windows.git
```
Vraťte se ke svému projektu služby Custom Vision a vyberte Přidat obrázky.
Přejděte do místního úložiště Git, které jste naklonovali, a pak do první složky s obrázky Cognitive-CustomVision-Windows / Samples / Images / Hemlock. Vyberte všech 10 obrázků ve složce a pak vyberte Otevřít.
Přidejte značku hemlock do této skupiny obrázků a stisknutím klávesy Enter značku použijte.
Vyberte Nahrát soubory (10).
Po úspěšném nahrání obrázků vyberte Hotovo.
Znovu vyberte Přidat obrázky.
Přejděte do druhé složky s obrázky Cognitive-CustomVision-Windows / Samples / Images / Japanese Cherry. Vyberte všech 10 obrázků ve složce a pak vyberte Otevřít.
Přidejte k této skupině obrázků značku japanese cherry (Sakura) a stiskněte Enter, aby se značka použila.
Vyberte Nahrát soubory (10). Po úspěšném nahrání obrázků vyberte Hotovo.
Po označení a nahrání sad obrázků vyberte Train pro spuštění tréninku klasifikátoru.

Export klasifikátoru

Po natrénování klasifikátoru na stránce Výkon klasifikátoru vyberte Exportovat.
Jako platformu vyberte DockerFile.
Jako verzi vyberte Linux.
Vyberte Exportovat.
Po dokončení exportu vyberte Stáhnout a uložit balíček .zip místně do počítače. Extrahujte z balíčku všechny soubory. Pomocí těchto souborů vytvořte modul IoT Edge, který obsahuje server klasifikace obrázků.

Až se k tomuto bodu dostanete, budete mít vytvořený a natrénovaný projekt služby Custom Vision. Exportované soubory použijete v další části, ale s webovou stránkou služby Custom Vision jste už skončili.

Vytvoření zařízení IoT Edge

Teď máte soubory pro kontejnerovou verzi klasifikátoru obrázků ve vašem vývojovém počítači. V této části nastavíte kontejner klasifikátoru obrázků tak, aby běžel jako modul IoT Edge. Také vytvoříte druhý modul, který publikuje požadavky na klasifikátor a odešle výsledky jako zprávy do IoT Hubu.

Vytvoření nového řešení

Řešení představuje logický způsob vývoje a uspořádání více modulů pro jedno nasazení IoT Edge. Řešení obsahuje kód pro jeden nebo více modulů a manifest nasazení, který deklaruje, jak je nakonfigurovat na zařízení IoT Edge. Vytvořte řešení pomocí vývojového nástroje azure IoT Edge Dev Tool (CLI). Nejjednodušším způsobem, jak tento nástroj použít, je spuštění vývojového kontejneru IoT Edge s Dockerem.

Vytvořte adresář s názvem classifier a přejděte do adresáře.
```
mkdir CustomVisionSolution
cd CustomVisionSolution
```
Spuštěním příkazu init nástroje iotedgedev vytvořte nové řešení IoT Edge. V kontejneru IoT Edge Dev Docker zadejte následující příkaz:
```
iotedgedev solution init --template python --module classifier
```
Inicializační skript řešení iotedgedev vás vyzve k provedení několika kroků, mezi které patří:
- Ověřování v Azure
- Volba předplatného Azure
- Volba nebo vytvoření skupiny prostředků
- Volba nebo vytvoření služby Azure IoT Hub
- Volba nebo vytvoření zařízení Azure IoT Edge
Příkaz vytvoří nové řešení IoT Edge s modulem pojmenovaným klasifikátorem v aktuálním pracovním adresáři.
Otevřete řešení v editoru Visual Studio Code.

Přidání klasifikátoru obrázků

Šablona modulu Python v editoru Visual Studio Code obsahuje ukázkový kód, který můžete spustit a otestovat IoT Edge. V tomto scénáři tento kód nevyužijete. Místo toho pomocí postupu v této části nahraďte vzorový kód kontejnerem klasifikátoru obrázků, který jste exportovali dříve.

V Průzkumníku souborů přejděte k balíčku služby Custom Vision, který jste stáhli a extrahovali. Zkopírujte veškerý obsah extrahovaného balíčku. Mělo by se jednat o dvě složky (app a azureml) a dva soubory (Dockerfile a README).
V Průzkumníku řešení přejděte do adresáře, který jste ve Visual Studio Code nastavili pro vytvoření řešení IoT Edge.
Otevřete složku modulu classifier. Pokud jste v předchozí části použili navrhované názvy, vypadá struktura složek takto: CustomVisionSolution / modules / classifier.
Vložte soubory do složky classifier.
Vraťte se do okna Visual Studio Code. Ve vašem pracovním prostoru řešení by se teď ve složce modulu měly zobrazit soubory klasifikátoru obrázků.
Nahraďte původní soubor Dockerfile.amd64 souborem Dockerfile z balíčku custom vision odstraněním původního souboru Dockerfile.amd64 a přejmenováním souboru Dockerfile na Dockerfile.amd64.
Uložte provedené změny.

Vytvoření modulu simulované kamery

Při skutečném nasazení vlastního vizuálního systému kamera poskytuje živé obrázky nebo videostreamy. V tomto scénáři budete simulovat kameru tím, že vytvoříte modul, který do klasifikátoru obrázků odešle testovací obrázek.

V této části do stejného řešení CustomVisionSolution přidáte nový modul a zadáte kód pro vytvoření simulované kamery.

Pomocí nástroje iotedgedev přidejte do řešení nový modul. Příkaz vytvoří novou složku s názvem cameracapture ve složce modulů vašeho řešení.
```
iotedgedev solution add --template python cameracapture
```
Otevřete soubor main.py ve složcecameracapture / .

Celý soubor nahraďte následujícím kódem. Tento vzorový kód odesílá požadavky POST do služby pro zpracování obrázků spuštěné v modulu classifier. Pro tento kontejner modulu zadáme ukázkový obrázek, který se použije v požadavcích. Kód pak zabalí odpověď do zprávy pro službu IoT Hub a odešle ji do výstupní fronty.

# 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" )

Uložte soubor main.py.
Otevřete soubor requirements.txt.
Přidejte nový řádek pro knihovnu, která se zahrne do kontejneru.
```
requests
```
Uložte soubor requirements.txt.

Přidání testovacího obrázku do kontejneru

Místo toho, abychom k poskytování kanálu obrázků pro tento scénář použili skutečnou kameru, použijeme jeden testovací obrázek. Testovací obrázek je součástí úložiště GitHub s trénovacími obrázky, které jste stáhli dříve v tomto kurzu.

Přejděte k testovacímu obrázku, který se nachází v umístění Cognitive-CustomVision-Windows / Samples / Images / Test.
Zkopírujte soubor test_image.jpg.
Přejděte do adresáře řešení IoT Edge a vložte testovací obrázek do složkycameracapture / . Obrázek musí být ve stejné složce jako soubor main.py, který jste upravovali v předchozí části.
V editoru Visual Studio Code otevřete soubor Dockerfile.amd64 pro modul cameracapture.
Za řádek, který určuje pracovní adresář (WORKDIR /app) přidejte následující řádek kódu:
```
ADD ./test_image.jpg .
```
Uložte soubor Dockerfile.

Příprava manifestu nasazení

Zatím jste v tomto kurzu natrénovali vlastní model zpracování obrazu, abyste klasifikovali obrázky stromů a tento model zabalili jako modul IoT Edge. Pak jste vytvořili druhý modul, který dotazuje server klasifikace obrázků a hlásí jeho výsledky do IoT Hubu. Nyní jste připraveni vytvořit manifest nasazení, který říká IoT Edge zařízení, jak tyto dva moduly spustit a provozovat společně.

Rozšíření IoT Edge pro Visual Studio Code poskytuje v každém řešení IoT Edge šablonu, která vám pomůže vytvořit manifest nasazení.

Otevřete soubor deployment.template.json ve složce řešení.
Nastavte přihlašovací údaje registru pro moduly v manifestu nasazení.
```
"registryCredentials": {
    "<registryName>": {
        "username": "<AcrUsername>",
        "password": "<AcrPassword>",
        "address": "<registryName>.azurecr.io"
    }
}
```
Nahraďte <registryName> názvem vašeho registru kontejneru Azure a nahraďte <AcrUsername> a <AcrPassword> uživatelským jménem a heslem pro váš registr. Tyto hodnoty najdete v části Přístupové klíče registru kontejneru Azure na webu Azure Portal.
Vyhledejte oddíl moduly, který obsahuje tři moduly: dva, které jste vytvořili, klasifikátor a zachycení kamery, a třetí, který je ve výchozím nastavení součástí, tempSensor.
Odstraňte modul tempSensor se všemi jeho parametry. Tento modul poskytuje ukázková data pro testovací scénáře, ale v tomto nasazení není potřeba.
Pokud jste modul klasifikace obrázků pojmenovali jinak než classifier, zkontrolujte teď název a ujistěte se, že obsahuje pouze malá písmena. Modul cameracapture volá modul klasifikátoru pomocí knihovny requests, která formátuje všechny požadavky malými písmeny, a IoT Edge rozlišuje malá a velká písmena.

Pro každý systémový modul edgeAgent a edgeHub změňte hodnotu createOptions na řetězcovou verzi. Například:

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

Pro každý systémový modul edgeAgent a EdgeHub změňte verzi image na nejnovější verzi 1.5. Například:
```
"image": "mcr.microsoft.com/azureiotedge-agent:1.5",
"image": "mcr.microsoft.com/azureiotedge-hub:1.5",
```

Aktualizujte parametr createOptions pro modul klasifikátoru na řetězcovou verzi. Například:

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

Aktualizujte parametr createOptions pro modul cameracapture následujícím kódem JSON. S použitím těchto informací se v kontejneru modulu vytvoří proměnné prostředí, které se načítají v procesu main.py. Zahrnutím těchto informací do manifestu nasazení můžete změnit image nebo koncový bod bez opětovného sestavení image modulu.

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

Pokud jste modul služby Custom Vision pojmenovali jinak než classifier, aktualizujte odpovídajícím způsobem hodnotu koncového bodu pro zpracování obrázků.

Například klasifikátor a konfigurace fotoaparátu by měly být podobné:

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

Uložte soubor deployment.template.json.

Sestavení a nasdílení řešení IoT Edge

Po vytvoření obou modulů a konfiguraci šablony manifestu nasazení sestavte image kontejneru a nasdílejte je do registru kontejneru.

Jakmile budou image ve vašem registru, můžete řešení nasadit do zařízení IoT Edge. Moduly na zařízení můžete nastavit prostřednictvím IoT Hubu. V této části nastavíte přístup ke službě IoT Hub a pak pomocí Azure CLI nasadíte řešení do zařízení IoT Edge.

Nejprve sestavte a odešlete řešení do registru kontejneru.

Výběrem možnosti Zobrazit>terminál otevřete integrovaný terminál editoru Visual Studio Code.
Přihlaste se k Dockeru zadáním následujícího příkazu v terminálu pomocí uživatelského jména, hesla a přihlašovacího serveru z registru kontejneru Azure. Tyto hodnoty můžete načíst z části Přístupové klíče vašeho registru na webu Azure Portal.
```
docker login -u <AcrUsername> -p <AcrPassword> <AcrLoginServer>
```
Může se zobrazit upozornění zabezpečení, které doporučuje použití --password-stdin. I když se tento osvědčený postup doporučuje pro produkční scénáře, je mimo rozsah tohoto kurzu. Další informace najdete v referenčních informacích k přihlášení dockeru.

Pomocí souboru Dockerfile modulu sestavte a označte obraz modulu Docker.

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

Pokud například chcete vytvořit image pro místní registr nebo registr kontejneru Azure, použijte následující příkazy:


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

Image Dockeru modulu push

Zadejte přihlašovací údaje registru kontejneru do Dockeru, aby mohla odeslat image kontejneru do úložiště v registru.

Přihlaste se k Dockeru pomocí přihlašovacích údajů služby Azure Container Registry (ACR).
```
docker login -u <AcrUsername> -p <AcrPassword> <AcrLoginServer>
```
Může se zobrazit upozornění zabezpečení, které doporučuje použití --password-stdin. I když se jedná o doporučený osvědčený postup pro produkční scénáře, je to mimo rozsah tohoto kurzu. Další informace najdete v referenčních informacích k přihlášení dockeru.
Přihlaste se ke službě Azure Container Registry. Abyste mohli tento příkaz použít, musíte az. Tento příkaz požádá o uživatelské jméno a heslo, které najdete v registru kontejneru vpřístupových klíčích>.
```
az acr login -n <AcrRegistryName>
```
Návod

Pokud se v některém okamžiku tohoto kurzu odhlásíte, opakujte kroky pro přihlášení do Dockeru a služby Azure Container Registry, abyste mohli pokračovat.

Vložte image modulu do místního registru nebo do registru kontejneru.

docker push <ImageName>

Například:

# 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

Aktualizace šablony nasazení

Aktualizujte soubor deployment.template.json s umístěním obrazu registru kontejneru. Změňte hodnotu image na image , kterou jste odeslali do registru. Nahraďte <například AcrRegistryName> názvem vašeho registru v hodnotách image pro moduly classifier a cameracapture:

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

Konečný manifest nasazení vypadá podobně jako následující:

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

Nasazení modulů do zařízení

Ověřte, že jsou vytvořené image kontejneru uložené v registru kontejneru. Pak je nasaďte do zařízení pomocí manifestu nasazení deployment.template.json připravení pro váš scénář.

K nasazení modulů do Azure IoT Hubu použijte příkaz IoT Edge Azure CLI set-modules. Pokud chcete například nasadit moduly definované v souboru deployment.template.json do IoT Hub Iot HubName <> pro zařízení <IoT Edge DeviceName>, použijte následující příkaz. Nahraďte hodnoty pro název centra, ID zařízení a přihlašovací připojovací řetězec ioT Hubu vlastními.

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

Návod

IoT Hub připojovací řetězec, včetně sdíleného přístupového klíče, najdete na webu Azure Portal. Přejděte do > zabezpečení služby IoT Hub>: Zásady> sdíleného přístupuiothubowner.

Ujistěte se, že je vaše zařízení IoT Edge spuštěné.

V zařízení rozbalte moduly a zobrazte seznam nasazených a spuštěných modulů. Vyberte tlačítko aktualizovat. Zobrazí se nové klasifikátor a moduly cameracapture spuštěné společně s $edgeAgent a $edgeHub.

Můžete také zkontrolovat, jestli jsou na vašem zařízení zprovozněné všechny moduly. Spuštěním následujícího příkazu na vašem zařízení IoT Edge zobrazte stav modulů.

iotedge list

Spuštění modulů může trvat několik minut. Modul runtime IoT Edge potřebuje získat nový manifest nasazení, stáhnout image modulů z modulu runtime kontejneru a pak spustit každý nový modul.

Zobrazení výsledků klasifikace

Na zařízení si prohlédněte protokoly modulu cameracapture, abyste viděli odeslané zprávy a potvrdili, že jsou přijaty službou IoT Hub.

iotedge logs cameracapture

Například byste měli vidět výstup podobný tomuto:

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

Poznámka:

Zpočátku se ve výstupu modulu cameracapture můžou zobrazovat chyby připojení kvůli zpoždění mezi nasazenými a spouštěcími moduly.

Modul cameracapture se automaticky opakovaně pokouší o připojení, dokud nebude úspěšné. Po úspěšném připojení se zobrazí očekávané zprávy klasifikace obrázků.

Výsledky z modulu Custom Vision, odeslané jako zprávy z modulu cameracapture, zahrnují pravděpodobnost, že je na obrázku tis nebo třešeň. Vzhledem k tomu, že obrázek obsahuje rostlinu náprstník (hemlock), vidíte pravděpodobnost jako 1,0.

Vyčištění prostředků

Pokud máte v plánu pokračovat k dalšímu doporučenému článku, ponechte prostředky a konfigurace, které jste vytvořili, a znovu je použijte. Také můžete dál používat stejné zařízení IoT Edge jako testovací zařízení.

Jinak odstraňte místní konfigurace a prostředky Azure, které jste použili v tomto článku, abyste se vyhnuli poplatkům.

Odstranění prostředků Azure

Odstranění prostředků Azure a skupin prostředků je nevratná akce. Ujistěte se, že nechtěně neodstraníte nesprávnou skupinu prostředků nebo prostředky. Pokud jste službu IoT Hub vytvořili v existující skupině prostředků, která obsahuje prostředky, které chcete zachovat, odstraňte pouze samotný prostředek IoT Hubu, nikoli skupinu prostředků.

Odstranění prostředků:

Přihlaste se k portálu Azure Portal a potom vyberte Skupiny prostředků.
Vyberte název skupiny prostředků, která obsahuje vaše testovací prostředky služby IoT Edge.
Zkontrolujte seznam prostředků, které vaše skupina prostředků obsahuje. Pokud chcete odstranit všechny prostředky, můžete vybrat možnost Odstranit skupinu prostředků. Pokud chcete odstranit jenom některé z nich, můžete vybrat jednotlivé prostředky, které chcete odstranit jednotlivě.

Další kroky

V tomto kurzu jste natrénovali model služby Custom Vision a nasadili jste ho jako modul do zařízení IoT Edge. Potom jste vytvořili modul, který může odesílat dotazy do služby klasifikace obrázků a hlásit její výsledky zpět do služby IoT Hub.

V dalších kurzech se dozvíte o dalších způsobech, jak vám Může Azure IoT Edge pomoct s přeměnou dat na obchodní přehledy na hraničních zařízeních.

Uložení dat na hraničních zařízeních s využitím databází SQL Serveru

Sdílet prostřednictvím