Samouczek: wykonywanie klasyfikacji obrazów na urządzeniach brzegowych za pomocą usługi Custom Vision

Dotyczy: IoT Edge 1.5

Ważne

Obsługiwana wersja usługi IoT Edge 1.5 LTS. Usługa IoT Edge 1.4 LTS kończy się od 12 listopada 2024 r. Jeśli korzystasz z wcześniejszej wersji, zobacz aktualizację Azure IoT Edge.

Usługa Azure IoT Edge sprawia, że rozwiązania IoT są wydajniejsze dzięki przeniesieniu obciążeń z chmury do brzegu sieci. Ta funkcja dobrze nadaje się do usług, które przetwarzają duże ilości danych, takich jak modele przetwarzania obrazów. Usługa Azure AI Custom Vision umożliwia tworzenie niestandardowych klasyfikatorów obrazów i wdrażanie ich na urządzeniach jako kontenerach. Te dwie usługi umożliwiają użytkownikom znajdowanie szczegółowych informacji z obrazów lub strumieni wideo bez uprzedniego przesyłania wszystkich danych poza siedzibą firmy. Usługa Custom Vision udostępnia klasyfikator, który porównuje obrazy z wytrenowanym modelem w celu generowania szczegółowych informacji.

Na przykład usługa Custom Vision na urządzeniu usługi IoT Edge może określić, czy autostrada ma większy lub niższy ruch niż zwykle, lub jeśli garaż ma dostępne miejsca parkingowe z rzędu. Te informacje można udostępnić innej usłudze w celu wykonania akcji.

Z tego samouczka dowiesz się, jak wykonywać następujące czynności:

Tworzenie klasyfikatora obrazów za pomocą usługi Custom Vision.
Opracuj moduł usługi IoT Edge, który wysyła zapytanie do serwera internetowego usługi Custom Vision na urządzeniu.
Wyślij wyniki klasyfikatora obrazów do usługi IoT Hub.

Diagram — architektura samouczka, etap i wdrażanie klasyfikatora

Jeśli nie masz jeszcze konta platformy Azure, przed rozpoczęciem utwórz bezpłatne konto.

Wymagania wstępne

Napiwek

Ten samouczek jest uproszczoną wersją usługi Custom Vision i usługi Azure IoT Edge w przykładowym projekcie urządzenia Raspberry Pi 3 . Działa na maszynie wirtualnej w chmurze i używa obrazów statycznych do trenowania i testowania klasyfikatora obrazów, co pomaga nowym użytkownikom usługi Custom Vision w ramach IoT Edge. Przykładowy projekt używa sprzętu fizycznego i ustawia przekaz na żywo z kamery w celu trenowania i testowania klasyfikatora obrazów, co jest przydatne dla osoby eksplorującej bardziej szczegółowy, realistyczny scenariusz.

Skonfiguruj swoje środowisko do tworzenia kontenerów w systemie Linux, kończąc samouczek: rozwijanie modułów IoT Edge przy użyciu Visual Studio Code z preferowanym narzędziem deweloperskim w wierszu poleceń (CLI) Azure IoT Edge Dev Tool. Po ukończeniu samouczka upewnij się, że w środowisku deweloperów są dostępne następujące wymagania wstępne:
- Bezpłatna lub standardowa usługa IoT Hub na platformie Azure
- Urządzenie z usługą Azure IoT Edge z kontenerami systemu Linux. Skorzystaj z instrukcji Szybki start, aby skonfigurować urządzenie z systemem Linux lub urządzenie z systemem Windows.
- Rejestr kontenerów, taki jak Azure Container Registry.
- Program Visual Studio Code został skonfigurowany za pomocą rozszerzenia usługi Azure IoT Hub .
- Pobierz i zainstaluj system zarządzania kontenerami zgodnym z platformą Docker na komputerze deweloperskim. Skonfiguruj go do uruchamiania kontenerów systemu Linux.
Aby opracować moduł usługi IoT Edge za pomocą usługi Custom Vision, upewnij się, że na twojej maszynie deweloperskiej są zainstalowane następujące dodatkowe wymagania wstępne:
- Pyton
- Usługa Git
- Rozszerzenie języka Python dla programu Visual Studio Code

Tworzenie klasyfikatora obrazów za pomocą usługi Custom Vision

Aby utworzyć klasyfikator obrazu, utwórz projekt usługi Custom Vision i udostępnij obrazy szkoleniowe. Aby uzyskać więcej informacji na temat kroków, które wykonasz w tej sekcji, zobacz Sposób tworzenia klasyfikatora za pomocą usługi Custom Vision.

Po utworzeniu i trenowaniu klasyfikatora obrazu wyeksportuj go jako kontener platformy Docker i wdróż go na urządzeniu usługi IoT Edge.

Tworzenie nowego projektu

W przeglądarce internetowej przejdź do strony internetowej usługi Custom Vision.
Wybierz pozycję Sign in (Zaloguj się) i zaloguj się za pomocą tego samego konta, którego używasz, aby uzyskać dostęp do zasobów platformy Azure.
Wybierz pozycję Nowy projekt.

Utwórz projekt z następującymi wartościami:

Pole	Wartość
Nazwisko	Podaj nazwę dla projektu, na przykład EdgeTreeClassifier.
opis	Opcjonalny opis projektu.
Zasób	Wybierz jedną z grup zasobów platformy Azure zawierającą zasób usługi Custom Vision Service lub utwórz nową , jeśli jeszcze jej nie dodano.
Typy projektów	Klasyfikacja
Typy klasyfikacji	Multiclass (single tag per image) (Multiklasa (pojedynczy tag na obrazie))
Domeny	General (compact) (Ogólne (kompaktowe))
Możliwości eksportowania	Platformy podstawowe (TensorFlow, CoreML, ONNX, ...)

Wybierz pozycję Utwórz projekt.

Przekazywanie obrazów i szkolenie klasyfikatora

Utworzenie klasyfikatora obrazów wymaga zestawu obrazów szkoleniowych i obrazów testowych.

Sklonuj lub pobierz przykładowe obrazy z repozytorium Cognitive-CustomVision-Windows na lokalnej maszynie deweloperskiej.
```
git clone https://github.com/Microsoft/Cognitive-CustomVision-Windows.git
```
Wróć do projektu usługi Custom Vision i wybierz pozycję Add images (Dodaj obrazy).
Przejdź do sklonowanego lokalnie repozytorium git, a następnie przejdź do pierwszego folderu obrazów Cognitive-CustomVision-Windows / Samples / Images / Hemlock. Wybierz wszystkie 10 obrazów w folderze, a następnie wybierz pozycję Otwórz.
Dodaj hemlock tagu do tej grupy obrazów, a następnie naciśnij Enter , aby zastosować tag.
Wybierz pozycję Upload 10 files (Przekaż 10 plików).
Po pomyślnym przekazaniu obrazów wybierz pozycję Done (Gotowe).
Wybierz ponownie pozycję Add images (Dodaj obrazy).
Przejdź do drugiego folderu obrazów Cognitive-CustomVision-Windows / Samples / Images / Japanese Cherry. Zaznacz wszystkie 10 obrazów w tym folderze, a następnie wybierz pozycję Open (Otwórz).
Dodaj do tej grupy obrazów tag wiśnia japońska, a następnie naciśnij klawisz Enter, aby zastosować ten tag.
Wybierz pozycję Upload 10 files (Przekaż 10 plików). Po pomyślnym przekazaniu obrazów wybierz pozycję Done (Gotowe).
Po tagowaniu i przekazaniu obu zestawów obrazów wybierz Trenuj, aby wytrenować klasyfikator.

Eksportowanie klasyfikatora

Po wyszkoleniu klasyfikatora wybierz pozycję Eksport (Eksportuj) na stronie Performance (Wydajność) klasyfikatora.
Jako platformę wybierz DockerFile.
Jako wersję wybierz Linux.
Wybierz Eksportuj.
Po zakończeniu eksportu wybierz pozycję Pobierz i zapisz pakiet .zip lokalnie na komputerze. Wyodrębnij wszystkie pliki z pakietu. Użyj tych plików, aby utworzyć moduł usługi IoT Edge zawierający serwer klasyfikacji obrazów.

W tym miejscu kończy się tworzenie i szkolenie projektu usługi Custom Vision. Wyeksportowane pliki zostaną użyte w następnej sekcji, ale na stronie internetowej usługi Custom Vision to już wszystko.

Tworzenie rozwiązania usługi IoT Edge

Masz teraz pliki dla klasyfikatora obrazów w wersji kontenera na maszynie deweloperskiej. W tej sekcji skonfigurujesz kontener klasyfikatora obrazów do uruchomienia jako moduł usługi IoT Edge. Utworzysz również drugi moduł, który publikuje żądania do klasyfikatora i wysyła wyniki jako komunikaty do usługi IoT Hub.

Utwórz nowe rozwiązanie

Rozwiązanie jest logicznym sposobem tworzenia i organizowania wielu modułów dla pojedynczego wdrożenia usługi IoT Edge. Rozwiązanie zawiera kod dla co najmniej jednego modułu i manifest wdrożenia, który deklaruje sposób ich konfigurowania na urządzeniu usługi IoT Edge. Utwórz rozwiązanie przy użyciu narzędzia programistycznego azure IoT Edge Dev Tool (CLI). Najprostszym sposobem użycia narzędzia jest uruchomienie kontenera deweloperskiego usługi IoT Edge przy użyciu platformy Docker.

Utwórz katalog o nazwie classifier i przejdź do katalogu.
```
mkdir CustomVisionSolution
cd CustomVisionSolution
```
Uruchom polecenie init narzędzia iotedgedev, aby stworzyć nowe rozwiązanie IoT Edge. W kontenerze usługi IoT Edge Dev Docker wprowadź następujące polecenie:
```
iotedgedev solution init --template python --module classifier
```
Skrypt inicjowania rozwiązania iotedgedev monituje o wykonanie kilku kroków, w tym:
- Uwierzytelnianie na platformie Azure
- Wybieranie subskrypcji platformy Azure
- Wybieranie lub tworzenie grupy zasobów
- Wybieranie lub tworzenie usługi Azure IoT Hub
- Wybieranie lub tworzenie urządzenia usługi Azure IoT Edge
Polecenie tworzy nowe rozwiązanie usługi IoT Edge z modułem o nazwie klasyfikator w bieżącym katalogu roboczym.
Otwórz rozwiązanie w programie Visual Studio Code.

Dodawanie klasyfikatora obrazów

Szablon modułu języka Python w programie Visual Studio Code zawiera przykładowy kod, który można uruchomić w celu przetestowania usługi IoT Edge. W tym scenariuszu ten kod nie będzie używany. Zamiast tego wykonaj kroki opisane w tej sekcji, aby zastąpić przykładowy kod wyeksportowanym wcześniej kontenerem klasyfikatora obrazów.

W eksploratorze plików przejdź do pobranego i wyodrębnionego pakietu usługi Custom Vision. Skopiuj całą zawartość z wyodrębnionego pakietu. Powinien on zawierać dwa foldery, app i azureml, oraz dwa pliki, Dockerfile i README.
W eksploratorze plików przejdź do katalogu, w którym program Visual Studio Code miał utworzyć rozwiązanie IoT Edge.
Otwórz folder modułu klasyfikatora. Jeśli w poprzedniej sekcji zostały użyte sugerowane nazwy, struktura folderów wygląda następująco: CustomVisionSolution / modules / classifier.
Wklej pliki do folderu classifier.
Wróć do okna programu Visual Studio Code. W folderze modułu w obszarze roboczym rozwiązania powinny teraz być widoczne pliki klasyfikatora obrazów.
Zastąp oryginalny plik Dockerfile.amd64 plikiem Dockerfile z pakietu custom vision, usuwając oryginalny plik Dockerfile.amd64 i zmieniając nazwę pliku Dockerfile na Dockerfile.amd64.
Zapisz zmiany.

Tworzenie modułu symulowanej kamery

W rzeczywistym wdrożeniu usługi Custom Vision aparat udostępnia obrazy na żywo lub strumienie wideo. W tym scenariuszu kamera będzie symulowana za pomocą modułu wysyłającego obraz testowy do klasyfikatora obrazów.

W tej sekcji dodasz nowy moduł do tego samego rozwiązania CustomVisionSolution i podasz kod umożliwiający utworzenie symulowanej kamery.

Użyj narzędzia iotedgedev , aby dodać nowy moduł do rozwiązania. Polecenie tworzy nowy folder o nazwie cameracapture w folderze modules rozwiązania.
```
iotedgedev solution add --template python cameracapture
```
Otwórz plik main.py w folderzecameracapture / .

Zastąp cały plik poniższym kodem. Ten przykładowy kod wysyła żądania POST do usługi przetwarzania obrazów działającej w module klasyfikatora. Ten moduł kontenera udostępniamy z przykładowym obrazem do użycia w żądaniach. Pakuje on następnie odpowiedź jako komunikat usługi IoT Hub i wysyła ją do kolejki wyjściowej.

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

Zapisz plik main.py.
Otwórz plik requirements.txt.
Dodaj nowy wiersz dotyczący biblioteki, która zostanie uwzględniona w kontenerze.
```
requests
```
Zapisz plik requirements.txt.

Dodawanie obrazu testowego do kontenera

Zamiast dostarczać źródło obrazów dla tego scenariusza przy użyciu prawdziwej kamery, użyjemy pojedynczego obrazu testowego. Obraz testowy znajduje się w repozytorium GitHub, które zostało pobrane na potrzeby obrazów szkoleniowych we wcześniejszej części tego samouczka.

Przejdź do obrazu testowego znajdującego się w folderze Cognitive-CustomVision-Windows / Samples / Images / Test.
Skopiuj plik test_image.jpg
Przejdź do katalogu rozwiązania IoT Edge i wklej obraz testowy do folderu modułów / cameracapture. Obraz powinien znajdować się w tym samym folderze co plik main.py, który był edytowany w poprzedniej sekcji.
W programie Visual Studio Code otwórz plik Dockerfile.amd64 dla modułu cameracapture.
Po wierszu określającym katalog roboczy WORKDIR /app dodaj następujący wiersz kodu:
```
ADD ./test_image.jpg .
```
Zapisz plik Dockerfile.

Przygotowanie manifestu wdrożenia

Do tej pory w tym samouczku przeszkoliłeś model Custom Vision do klasyfikacji obrazów drzew i zapakowałeś ten model jako moduł IoT Edge. Następnie utworzono drugi moduł, który wysyła zapytanie do serwera klasyfikacji obrazów i zgłasza wyniki do usługi IoT Hub. Teraz możesz utworzyć manifest wdrożenia, który informuje urządzenie IoT Edge, jak uruchamiać i działać te dwa moduły jednocześnie.

Rozszerzenie usługi IoT Edge dla programu Visual Studio Code zawiera w każdym rozwiązaniu IoT Edge szablon ułatwiający tworzenie manifestu wdrożenia.

Otwórz plik deployment.template.json w folderze rozwiązania.
Skonfiguruj poświadczenia rejestru dla modułów w manifeście wdrożenia.
```
"registryCredentials": {
    "<registryName>": {
        "username": "<AcrUsername>",
        "password": "<AcrPassword>",
        "address": "<registryName>.azurecr.io"
    }
}
```
Zastąp <registryName> nazwą swojego rejestru kontenerów platformy Azure, a <AcrUsername> i <AcrPassword> odpowiednio nazwą użytkownika i hasłem do rejestru. Te wartości można znaleźć w sekcji Klucze dostępu rejestru kontenerów platformy Azure w witrynie Azure Portal.
Znajdź sekcję modułów zawierającą trzy moduły: dwa utworzone, klasyfikator i aparat fotograficzny, a trzeci dołączony domyślnie tempSensor.
Usuń moduł tempSensor ze wszystkimi jego parametrami. Ten moduł zawiera przykładowe dane dla scenariuszy testowych, ale nie są potrzebne w tym wdrożeniu.
Jeśli moduł klasyfikacji obrazów został nazwany inaczej niż classifier, sprawdź teraz tę nazwę i upewnij się, że zawiera tylko małe litery. Moduł cameracapture wywołuje moduł klasyfikatora przy użyciu biblioteki żądań, która formatuje wszystkie żądania w małych literach, a w usłudze IoT Edge jest rozróżniana wielkość liter.

Dla każdego modułu systemowego edgeAgent i edgeHub zmień wartość createOptions na wersję ciągową. Przykład:

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

Dla każdego modułu systemowego edgeAgent i edgeHub zmień wersję obrazu na najnowszą wersję 1.5. Przykład:
```
"image": "mcr.microsoft.com/azureiotedge-agent:1.5",
"image": "mcr.microsoft.com/azureiotedge-hub:1.5",
```

Zaktualizuj parametr createOptions dla modułu klasyfikatora do wersji ciągowej. Przykład:

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

Zaktualizuj parametr createOptions dla modułu cameracapture przy użyciu następującego kodu JSON. Te informacje tworzą w kontenerze modułu zmienne środowiskowe, które są pobierane w procesie main.py. Dołączenie tych informacji w manifeście wdrożenia umożliwia zmianę obrazu lub punktu końcowego bez ponownego kompilowania obrazu modułu.

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

Jeśli moduł usługi Custom Vision został nazwany inaczej niż classifier, zaktualizuj odpowiednio wartość punktu końcowego przetwarzania obrazów.

Na przykład konfiguracja klasyfikatora i konfiguracja przechwytywania obrazu powinna być podobna do następującej:

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

Zapisz plik deployment.template.json.

Kompilowanie i wypychanie rozwiązania usługi IoT Edge

Po utworzeniu modułów i skonfigurowaniu szablonu manifestu wdrożenia skompiluj obrazy kontenerów i wypchnij je do rejestru kontenerów.

Gdy obrazy znajdą się w rejestrze, możesz wdrożyć rozwiązanie na urządzeniu usługi IoT Edge. Moduły można ustawić na urządzeniu za pośrednictwem usługi IoT Hub. W tej sekcji skonfigurujesz dostęp do usługi IoT Hub, a następnie użyjesz interfejsu wiersza polecenia platformy Azure do wdrożenia rozwiązania na urządzeniu usługi IoT Edge.

Najpierw skompiluj i wypchnij rozwiązanie do rejestru kontenerów.

Otwórz zintegrowany terminal programu Visual Studio Code, wybierając pozycję Wyświetl>terminal.
Zaloguj się do platformy Docker, wprowadzając następujące polecenie w terminalu przy użyciu nazwy użytkownika, hasła i serwera logowania z rejestru kontenerów platformy Azure. Te wartości można pobrać z sekcji Klucze dostępu rejestru w witrynie Azure Portal.
```
docker login -u <AcrUsername> -p <AcrPassword> <AcrLoginServer>
```
Może zostać wyświetlone ostrzeżenie o zabezpieczeniach, które zaleca użycie polecenia --password-stdin. Chociaż najlepsze rozwiązanie jest zalecane w przypadku scenariuszy produkcyjnych, wykracza poza zakres tego samouczka. Aby uzyskać więcej informacji, zobacz dokumentację logowania platformy Docker.

Użyj pliku Dockerfile modułu, aby skompilować i oznaczyć obraz platformy Docker modułu.

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

Aby na przykład skompilować obraz dla rejestru lokalnego lub rejestru kontenerów platformy Azure, użyj następujących poleceń:


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

Obraz platformy Docker modułu wypychania

Podaj poświadczenia rejestru kontenerów do platformy Docker, aby umożliwić wypchnięcie obrazu kontenera do magazynu w rejestrze.

Zaloguj się do platformy Docker przy użyciu poświadczeń usługi Azure Container Registry (ACR).
```
docker login -u <AcrUsername> -p <AcrPassword> <AcrLoginServer>
```
Może zostać wyświetlone ostrzeżenie o zabezpieczeniach, które zaleca użycie polecenia --password-stdin. Chociaż jest to zalecane najlepsze rozwiązanie dla scenariuszy produkcyjnych, wykracza poza zakres tego samouczka. Aby uzyskać więcej informacji, zobacz dokumentację logowania platformy Docker.
Zaloguj się do usługi Azure Container Registry. Aby użyć polecenia , musisz zainstalować interfejs wiersza polecenia platformy az Azure. To polecenie prosi o podanie nazwy użytkownika i hasła znalezionego w rejestrze kontenerów w obszarze Ustawienia>Klucze dostępu.
```
az acr login -n <AcrRegistryName>
```
Napiwek

Jeśli w dowolnym momencie tego samouczka wylogujesz się, powtórz kroki logowania do platformy Docker i usługi Azure Container Registry, aby kontynuować.

Wypchnij obraz modułu do rejestru lokalnego lub rejestru kontenerów.

docker push <ImageName>

Przykład:

# 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

Aktualizowanie szablonu wdrożenia

Zaktualizuj plik deployment.template.json z lokalizacją obrazu w rejestrze kontenerów. Zmień wartość obrazu na obraz przesłany do rejestru. Na przykład, zastąp <AcrRegistryName> nazwą Twojego rejestru w wartościach obrazu dla modułów klasyfikatora i przechwytywania obrazu.

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

Końcowy manifest wdrożenia wygląda podobnie do następującego:

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

Wdrażanie modułów na urządzeniu

Sprawdź, czy utworzone obrazy kontenerów są przechowywane w rejestrze kontenerów. Następnie wdróż je na urządzeniu przy użyciu manifestu wdrożenia deployment.template.json przygotowanego na potrzeby danego scenariusza.

Użyj polecenia set-modules interfejsu wiersza polecenia platformy Azure usługi IoT Edge, aby wdrożyć moduły w usłudze Azure IoT Hub. Aby na przykład wdrożyć moduły zdefiniowane w pliku deployment.template.json do usługi IoT Hub <IotHubName> dla urządzenia IoT Edge <DeviceName>, użyj następującego polecenia. Zastąp wartości hub-name, device-id i login IoT Hub parametry połączenia własnymi.

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

Napiwek

Możesz znaleźć parametry połączenia usługi IoT Hub, w tym klucz dostępu współdzielonego w witrynie Azure Portal. Przejdź do ustawień>dostępu współdzielonego iothubowner.

Upewnij się, że urządzenie usługi IoT Edge jest uruchomione.

W obszarze urządzenia rozwiń węzeł Moduły , aby wyświetlić listę wdrożonych i uruchomionych modułów. Wybierz przycisk odświeżenia. Zobaczysz nowe moduły klasyfikatora i przechwytywania kamerą działające razem z $edgeAgent i $edgeHub.

Możesz również sprawdzić, czy wszystkie moduły są wdrożone i uruchomione na samym urządzeniu. Na urządzeniu usługi IoT Edge uruchom następujące polecenie, aby wyświetlić stan modułów.

iotedge list

Uruchomienie modułów może potrwać kilka minut. Środowisko uruchomieniowe usługi IoT Edge musi otrzymać nowy manifest wdrożenia, ściągnąć obrazy modułów ze środowiska uruchomieniowego kontenera, a następnie uruchomić każdy nowy moduł.

Wyświetlanie wyników klasyfikacji

Na urządzeniu wyświetl dzienniki modułu cameracapture, aby wyświetlić wysłane komunikaty i potwierdzić, że są one odbierane przez usługę IoT Hub.

iotedge logs cameracapture

Na przykład powinny zostać wyświetlone dane wyjściowe podobne do następujących:

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

Uwaga

Początkowo mogą wystąpić błędy połączenia w części wychodzącej modułu cameracapture z powodu opóźnienia między zainstalowaniem i uruchomieniem modułów.

Moduł cameracapture automatycznie ponownie próbuje połączenia, dopóki się nie uda. Po pomyślnym nawiązaniu połączenia zobaczysz oczekiwane komunikaty klasyfikacji obrazów.

Wyniki z modułu Custom Vision, wysyłane jako komunikaty z modułu cameracapture, zawierają prawdopodobieństwo, że obraz przedstawia choinę lub drzewo wiśniowe. Ponieważ obraz przedstawia cykutę, widzisz prawdopodobieństwo jako 1.0.

Czyszczenie zasobów

Jeśli planujesz przejść do następnego zalecanego artykułu, zachowaj utworzone zasoby i konfiguracje i użyj ich ponownie. Możesz także nadal używać tego samego urządzenia usługi IoT Edge jako urządzenia testowego.

W przeciwnym razie usuń konfiguracje lokalne i zasoby platformy Azure użyte w tym artykule, aby uniknąć naliczania opłat.

Usuwanie zasobów platformy Azure

Usuwanie zasobów i grup zasobów platformy Azure jest nieodwracalne. Uważaj, aby nie usunąć przypadkowo niewłaściwych zasobów lub niewłaściwej grupy zasobów. Jeśli centrum IoT Hub zostało utworzone w istniejącej grupie zasobów zawierającej zasoby, które chcesz zachować, usuń tylko sam zasób usługi IoT Hub, a nie grupę zasobów.

Aby usunąć zasoby:

Zaloguj się do witryny Azure Portal, a następnie wybierz pozycję Grupy zasobów.
Wybierz nazwę grupy zasobów, która zawiera zasoby testowe usługi IoT Edge.
Przejrzyj listę zasobów, które zawiera grupa zasobów. Jeśli chcesz usunąć je wszystkie, możesz wybrać pozycję Usuń grupę zasobów. Jeśli chcesz usunąć tylko niektóre z nich, możesz wybrać każdy zasób, aby usunąć je indywidualnie.

Następne kroki

W tym samouczku wyszkoliliśmy model usługi Custom Vision i wdrożyliśmy go jako moduł na urządzeniu usługi IoT Edge. Następnie skompilowaliśmy moduł, który może wysyłać zapytania do usługi klasyfikacji obrazów i raportować wyniki do usługi IoT Hub.

Przejdź do następnych samouczków, aby dowiedzieć się więcej o innych sposobach, które usługa Azure IoT Edge może pomóc w przekształcaniu danych w szczegółowe informacje biznesowe na urządzeniach brzegowych.

Store data at the edge with SQL Server databases (Przechowywanie danych na brzegu sieci przy użyciu baz danych programu SQL Server)

Sprzężenie zwrotne

Czy ta strona była pomocna?

Last updated on 2025-05-07