Samouczek: tworzenie i wdrażanie niestandardowych modułów usługi IoT Edge

Dotyczy: IoT Edge 1.1

Ważne

Data zakończenia wsparcia usługi IoT Edge 1.1 wynosiła 13 grudnia 2022 r.. Zapoznaj się z cyklem życia produktów firmy Microsoft, aby uzyskać informacje na temat sposobu obsługi tego produktu lub interfejsu API albo tej usługi lub technologii. Aby uzyskać więcej informacji na temat aktualizowania do najnowszej wersji usługi IoT Edge, zobacz Update IoT Edge.

W tym artykule utworzymy trzy moduły usługi IoT Edge, które odbierają komunikaty z podrzędnych urządzeń IoT, uruchamiają dane za pośrednictwem modelu uczenia maszynowego, a następnie przekazują szczegółowe informacje do usługi IoT Hub.

Centrum usługi IoT Edge ułatwia komunikację modułów. Używanie centrum usługi IoT Edge jako brokera komunikatów utrzymuje moduły niezależne od siebie. Moduły muszą tylko określić dane wejściowe, na których akceptują komunikaty i dane wyjściowe, do których zapisują komunikaty.

Chcemy, aby urządzenie usługi IoT Edge wykonało dla nas cztery czynności:

• Odbieranie danych z urządzeń podrzędnych.
• Przewidywanie pozostałego okresu eksploatacji (RUL) dla urządzenia, które wysłało dane.
• Wyślij komunikat zawierający RUL dla urządzenia do IoT Hub. Tę funkcję można zmodyfikować w celu wysyłania danych tylko wtedy, gdy poziom RUL spadnie poniżej określonego poziomu.
• Zapisz dane urządzenia podrzędnego w pliku lokalnym na urządzeniu usługi IoT Edge. Ten plik danych jest okresowo przekazywany do usługi IoT Hub w celu uściślenia trenowania modelu uczenia maszynowego. Używanie przesyłania plików zamiast ciągłego przesyłania strumieniowego komunikatów jest bardziej opłacalne.

Aby wykonać te zadania, użyjemy trzech modułów niestandardowych:

• Klasyfikator RUL: Moduł turboFanRulClassifier utworzony w module Train and deploy an Azure Machine Learning model (Trenowanie i wdrażanie modelu usługi Azure Machine Learning ) to standardowy moduł uczenia maszynowego, który uwidacznia dane wejściowe o nazwie "amlInput" i dane wyjściowe o nazwie "amlOutput". Wyrażenie "amlInput" oczekuje, że dane wejściowe będą wyglądać dokładnie tak, jak dane wejściowe wysyłane do usługi internetowej opartej na usłudze ACI. Podobnie wyrażenie "amlOutput" zwraca te same dane co usługa internetowa.

• Zapis Avro: Ten moduł odbiera komunikaty na wejściu "avroModuleInput" i zapisuje komunikat w formacie Avro na dysku, do późniejszego przesłania do IoT Hub.

• Moduł routera: Moduł routera odbiera komunikaty z urządzeń podrzędnych, a następnie formatuje i wysyła komunikaty do klasyfikatora. Następnie moduł odbiera komunikaty z klasyfikatora i przekazuje komunikat do modułu zapisywania Avro. Na koniec moduł wysyła tylko przewidywanie RUL do usługi IoT Hub.

  • Wejścia:

    • deviceInput: odbiera komunikaty z urządzeń podrzędnych
    • rulInput: odbiera komunikaty z "amlOutput"

  • Wyniki

    • classify: wysyła komunikaty do "amlInput"
    • writeAvro: wysyła komunikaty do "avroModuleInput"
    • toIotHub: wysyła komunikaty do $upstream, która przekazuje komunikaty do połączonego centrum IoT Hub

Na poniższym diagramie przedstawiono moduły, dane wejściowe, dane wyjściowe i trasy usługi IoT Edge Hub dla pełnego rozwiązania:

Kroki opisane w tym artykule są zwykle wykonywane przez dewelopera rozwiązań w chmurze.

W tej sekcji samouczka dowiesz się, jak wykonywać następujące działania:

• Utwórz moduł usługi IoT Edge na podstawie kodu niestandardowego.
• Wygeneruj obraz Docker z własnego modułu.
• Skonfiguruj ponownie routing usługi IoT Hub w celu obsługi modułów niestandardowych.
• Kompilowanie, publikowanie i wdrażanie modułów niestandardowych.

Wymagania wstępne

Ten artykuł jest częścią serii samouczka dotyczącego korzystania z usługi Azure Machine Learning w usłudze IoT Edge. Każdy artykuł z serii opiera się na pracy w poprzednim artykule. Jeśli dotarłeś bezpośrednio do tego artykułu, odwiedź pierwszy artykuł z serii .

Tworzenie nowego rozwiązania usługi IoT Edge

Podczas wykonywania drugiego z naszych dwóch notesów platformy Azure utworzyliśmy i opublikowaliśmy obraz kontenera zawierający nasz model RUL. Usługa Azure Machine Learning, w ramach procesu tworzenia obrazu, spakowała ten model, aby obraz można było wdrożyć jako moduł Azure IoT Edge.

W tym kroku utworzymy rozwiązanie usługi Azure IoT Edge przy użyciu modułu "Azure Machine Learning" i wskażemy moduł do obrazu opublikowanego przy użyciu usługi Azure Notebooks.

1. Otwórz sesję pulpitu zdalnego na twojej maszynie wirtualnej do rozwoju.

2. Otwórz folder C:\source\IoTEdgeAndMlSample w programie Visual Studio Code.

3. Kliknij prawym przyciskiem myszy panel eksploratora (w pustym miejscu) i wybierz pozycję Nowe rozwiązanie usługi IoT Edge.

   

4. Zaakceptuj domyślną nazwę rozwiązania EdgeSolution.

5. Wybierz usługę Azure Machine Learning jako szablon modułu.

6. Nadaj modułowi nazwę turbofanRulClassifier.

7. Wybierz obszar roboczy uczenia maszynowego. Ten obszar roboczy to obszar roboczy turboFanDemo utworzony w artykule Samouczek: trenowanie i wdrażanie modelu usługi Azure Machine Learning

8. Wybierz obraz utworzony podczas uruchamiania usługi Azure Notebook.

9. Przyjrzyj się rozwiązaniu i zwróć uwagę na pliki, które zostały utworzone:

   • deployment.template.json: Ten plik zawiera definicję poszczególnych modułów w rozwiązaniu. W tym pliku należy zwrócić uwagę na trzy sekcje:

     • Poświadczenia rejestru: Definiuje zestaw niestandardowych rejestrów kontenerów używanych w rozwiązaniu. Obecnie powinien zawierać rejestr z obszaru roboczego uczenia maszynowego, który jest miejscem przechowywania obrazu Azure Machine Learning. Można mieć dowolną liczbę rejestrów kontenerów, ale dla uproszczenia użyjemy tego rejestru dla wszystkich modułów.

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

     • Moduły: Ta sekcja zawiera zestaw modułów zdefiniowanych przez użytkownika, które są dostępne w tym rozwiązaniu. Definicja składnika turbofanRulClassifier odnosi się do obrazu w rejestrze kontenerów. W miarę dodawania kolejnych modułów do rozwiązania będą one wyświetlane w tej sekcji.

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

     • Trasy: będziemy dość dużo pracować z trasami w tym samouczku. Trasy definiują sposób komunikowania się modułów ze sobą. Istniejąca trasa zdefiniowana przez szablon nie jest zgodna z potrzebnym routingiem. Usuń trasę turbofanRulClassifierToIoTHub.

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

   • deployment.debug.template.json: ten plik jest wersją debugowania deployment.template.json. Zazwyczaj należy zachować synchronizację tego pliku z zawartością pliku deployment.template.json, ale nie jest to wymagane w tym samouczku.

   • .env: ten plik to miejsce, w którym należy podać nazwę użytkownika i hasło na potrzeby uzyskiwania dostępu do rejestru.

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

     Uwaga / Notatka

     W tym samouczku są używane poświadczenia logowania administratora dla Azure Container Registry, co jest wygodne w przypadku scenariuszy tworzenia i testowania. Gdy wszystko będzie gotowe do scenariuszy produkcyjnych, zalecamy opcję uwierzytelniania z najmniejszymi uprawnieniami, taką jak jednostki usługi. Aby uzyskać więcej informacji, zobacz Zarządzanie dostępem do rejestru kontenerów.

10. Kliknij prawym przyciskiem myszy plik deployment.template.json w Eksploratorze programu Visual Studio Code i wybierz pozycję Kompiluj rozwiązanie usługi IoT Edge.

11. Zwróć uwagę, że to polecenie tworzy folder konfiguracji z plikiem deployment.amd64.json. Ten plik jest konkretnym szablonem wdrożenia dla rozwiązania.

Dodawanie modułu routera

Następnie dodamy moduł Router do naszego rozwiązania. Moduł Router obsługuje kilka obowiązków związanych z naszym rozwiązaniem:

• Odbieranie komunikatów z urządzeń podrzędnych: gdy komunikaty docierają do urządzenia usługi IoT Edge z urządzeń podrzędnych, moduł Router odbiera komunikat i rozpoczyna organizowanie routingu komunikatu.
• Wysyłanie komunikatów do modułu klasyfikatora RUL: po odebraniu nowego komunikatu z urządzenia podrzędnego moduł Router przekształca komunikat w format oczekiwany przez klasyfikator RUL. Router wysyła komunikat do klasyfikatora RUL na potrzeby przewidywania RUL. Po dokonaniu przewidywania klasyfikator wysyła komunikat z powrotem do modułu Router.
• Wysyłanie komunikatów RUL do usługi IoT Hub: gdy router odbiera komunikaty z klasyfikatora, przekształca komunikat tak, aby zawierał tylko podstawowe informacje, identyfikator urządzenia i RUL oraz wysyła skrócony komunikat do centrum IoT. Dalsze uściślenie, którego nie zrobiliśmy w tym miejscu, spowoduje wysłanie komunikatów do usługi IoT Hub tylko wtedy, gdy przewidywanie RUL spadnie poniżej progu (na przykład wtedy, gdy wartość RUL jest mniejsza niż 100 cykli). Filtrowanie w ten sposób zmniejszy ilość komunikatów i zmniejszy koszty centrum IoT Hub.
• Wyślij komunikat do modułu zapisywania Avro: aby zachować wszystkie dane wysyłane przez urządzenie podrzędne, moduł Router wysyła cały komunikat odebrany z klasyfikatora do modułu zapisywania Avro, który będzie utrwalać i przekazywać dane przy użyciu przekazywania pliku usługi IoT Hub.

Moduł Router jest ważnym elementem rozwiązania, który zapewnia przetwarzanie komunikatów w odpowiedniej kolejności.

Tworzenie modułu i kopiowanie plików

1. Kliknij prawym przyciskiem myszy folder modules w programie Visual Studio Code i wybierz polecenie Dodaj moduł usługi IoT Edge.

2. Wybierz moduł języka C# dla szablonu modułu.

3. Nadaj modułowi nazwę turbofanRouter.

4. Po wyświetleniu monitu o podanie swojego repozytorium obrazów Docker, użyj rejestru z przestrzeni roboczej uczenia maszynowego (rejestr znajduje się w węźle registryCredentials pliku deployment.template.json). Ta wartość jest w pełni kwalifikowanym adresem rejestru, takim jak <twój rejestr>.azurecr.io/turbofanrouter.

   Uwaga / Notatka

   W tym artykule użyjemy usługi Azure Container Registry utworzonej przez obszar roboczy usługi Azure Machine Learning. Jest to wyłącznie dla wygody. Mogliśmy utworzyć nowy rejestr kontenerów i opublikować tam nasze moduły.

5. W Terminalu, korzystając z powłoki wiersza poleceń, skopiuj pliki z przykładowego modułu do rozwiązania.

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

6. Zaakceptuj monit o zastąpienie pliku program.cs.

Moduł budowy routera

1. W programie Visual Studio Code wybierz pozycję Terminal>Skonfiguruj domyślne zadanie kompilacji.

2. Wybierz Utwórz plik tasks.json z szablonu.

3. Wybierz pozycję .NET Core.

4. Zastąp zawartość tasks.json następującym kodem.

   {
     "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. Zapisz i zamknij tasks.json.

6. Uruchom kompilację za pomocą Ctrl + Shift + BTerminala>Uruchom zadanie kompilacji.

Konfigurowanie tras modułów

Jak wspomniano powyżej, środowisko uruchomieniowe usługi IoT Edge używa tras skonfigurowanych w pliku deployment.template.json do zarządzania komunikacją między luźno powiązanymi modułami. W tej sekcji dowiesz się, jak skonfigurować trasy dla modułu turbofanRouter. Najpierw omówimy trasy wejściowe, a następnie przejdziemy do danych wyjściowych.

Dane wejściowe

1. W metodzie Init() Program.cs rejestrujemy dwa wywołania zwrotne dla modułu:

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

2. Pierwsze wywołanie zwrotne nasłuchuje komunikaty wysyłane do odbiornika deviceInput. Na powyższym diagramie widać, że chcemy kierować wiadomości z dowolnego urządzenia podrzędnego do tego wejścia. W pliku deployment.template.json dodaj trasę, która nakazuje węzłowi brzegowemu kierowanie jakichkolwiek komunikatów odebranych przez urządzenie IoT Edge, nie wysłanych przez moduł IoT Edge, do wejścia o nazwie "deviceInput" w module turbofanRouter.

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

3. Następnie dodaj trasę dla komunikatów z modułu rulClassifier do modułu turbofanRouter:

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

Wyniki

Dodaj cztery dodatkowe trasy do parametru trasy $edgeHub, aby obsługiwać dane wyjściowe z modułu Router.

1. Program.cs definiuje metodę SendMessageToClassifier(), która używa klienta modułu do wysyłania komunikatu do klasyfikatora RUL przy użyciu trasy:

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

2. Funkcja SendRulMessageToIotHub() używa klienta modułu do wysyłania tylko danych RUL dla urządzenia do usługi IoT Hub za pośrednictwem trasy:

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

3. Funkcja SendMessageToAvroWriter() używa klienta modułu do wysyłania komunikatu z danymi RUL dodanymi do modułu avroFileWriter.

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

4. Funkcja HandleBadMessage() wysyła nieudane komunikaty w górę strumienia do usługi IoT Hub, gdzie mogą być dalej kierowane.

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

Po uwzględnieniu wszystkich tras węzeł "$edgeHub" powinien mieć następującą strukturę JSON:

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

Uwaga / Notatka

Dodanie modułu turbofanRouter spowodowało utworzenie następującej dodatkowej trasy: turbofanRouterToIoTHub": "FROM /messages/modules/turbofanRouter/outputs/* INTO $upstream. Usuń tę trasę, pozostawiając tylko trasy wymienione powyżej w pliku deployment.template.json.

Dodaj moduł zapisywania Avro

Moduł Avro Writer w naszym rozwiązaniu ma dwa zadania: przechowywanie komunikatów i przekazywanie plików.

• Przechowuj komunikaty: gdy moduł zapisywania Avro odbiera komunikat, zapisuje komunikat w lokalnym systemie plików w formacie Avro. Używamy instalacji powiązania, która instaluje katalog (w tym przypadku /data/avrofiles) do ścieżki w kontenerze modułu. To zamontowanie umożliwia modułowi zapisywanie do lokalnej ścieżki (/avrofiles) i bezpośredni dostęp do tych plików z urządzenia IoT Edge.

• Przekazywanie plików: moduł zapisywania Avro używa funkcji przekazywania plików usługi Azure IoT Hub do przekazywania plików na konto usługi Azure Storage. Po pomyślnym przekazaniu pliku moduł usuwa plik z dysku

Tworzenie modułu i kopiowanie plików

1. W programie Visual Studio Code wybierz pozycję Wyświetl>paletę poleceń, a następnie wyszukaj i wybierz pozycję Python: Wybierz interpreter.

2. Wybierz zainstalowaną wersję języka Python w wersji 3.7 lub nowszej.

3. Kliknij prawym przyciskiem myszy folder modules w programie Visual Studio Code i wybierz polecenie Dodaj moduł usługi IoT Edge.

4. Wybierz pozycję Moduł Python.

5. Nadaj modułowi avroFileWriternazwę .

6. Po wyświetleniu monitu o repozytorium obrazów platformy Docker, użyj tego samego rejestru, którego użyłeś przy dodawaniu modułu router.

7. Skopiuj pliki z przykładowego modułu do rozwiązania.

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

8. Zaakceptuj zastąpienie main.py.

9. Zwróć uwagę, że filemanager.py i schema.py zostały dodane do rozwiązania i main.py zostały zaktualizowane.

Uwaga / Notatka

Po otwarciu pliku języka Python może zostać wyświetlony monit o zainstalowanie narzędzia pylint. Aby ukończyć ten samouczek, nie trzeba instalować narzędzia linter.

Wiązanie instalacji dla plików danych

Jak wspomniano wcześniej, moduł zapisywania opiera się na obecności instalacji powiązanej, aby zapisywać pliki Avro w systemie plików urządzenia.

Dodawanie katalogu do urządzenia

1. W Azure Portal uruchom maszynę wirtualną urządzenia IoT Edge, jeśli nie jest włączona. Połącz się z nim przy użyciu protokołu SSH. Połączenie wymaga nazwy DNS, którą można skopiować ze strony przeglądu maszyny wirtualnej w witrynie Azure Portal.

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

2. Po zalogowaniu utwórz katalog, w ramach którego będą przechowywane zapisane komunikaty urządzenia podrzędnego.

   sudo mkdir -p /data/avrofiles
   

3. Zaktualizuj uprawnienia katalogu, aby umożliwić zapisywanie go przez kontener.

   sudo chmod ugo+rw /data/avrofiles
   

4. Sprawdź, czy katalog posiada teraz uprawnienia do zapisu (w) dla użytkownika, grupy i właściciela.

   ls -la /data
   

   

Dodawanie katalogu do modułu

Aby dodać katalog do kontenera modułu, zmodyfikujemy pliki Dockerfile skojarzone z modułem avroFileWriter. Istnieją trzy pliki Dockerfile skojarzone z modułem: Dockerfile.amd64, Dockerfile.amd64.debug i Dockerfile.arm32v7. Te pliki powinny być synchronizowane w przypadku, gdy chcemy debugować lub wdrażać na urządzeniu arm32. W tym artykule skoncentruj się tylko na pliku Dockerfile.amd64.

1. Na maszynie wirtualnej dewelopera otwórz plik C:\source\IoTEdgeAndMlSample\EdgeSolution\modules\avoFileWriter\Dockerfile.amd64 .

2. Zmodyfikuj plik tak, aby wyglądał jak w poniższym przykładzie:

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

   Polecenia mkdir i chown instruują proces kompilacji platformy Docker, aby utworzyć katalog najwyższego poziomu o nazwie /avrofiles na obrazie, a następnie, aby użytkownik modułu był właścicielem tego katalogu. Ważne jest, aby te polecenia były wstawiane po dodaniu użytkownika modułu do obrazu za pomocą polecenia useradd i przed przełączeniem kontekstu do użytkownika modułu o nazwie moduleuser (USER moduleuser).

3. W razie potrzeby wprowadź odpowiednie zmiany w plikach Dockerfile.amd64.debug i Dockerfile.arm32v7.

Dodaj konfigurację powiązania do avroFileWriter

Ostatnim krokiem tworzenia powiązania jest zaktualizowanie plików deployment.template.json (i deployment.debug.template.json) przy użyciu powiązanych informacji.

1. Otwórz deployment.template.json.

2. Zmodyfikuj definicję modułu avroFileWriter, dodając Binds parametr wskazujący katalog kontenera /avrofiles do katalogu lokalnego na urządzeniu brzegowym. Definicja modułu powinna być zgodna z tym przykładem:

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

Montowanie bind w celu uzyskania dostępu do config.yaml

Musimy dodać jeszcze jedno powiązanie dla modułu dla pisarza. To powiązanie zapewnia modułowi dostęp do odczytu parametrów połączenia z pliku /etc/iotedge/config.yaml na urządzeniu usługi IoT Edge. Potrzebujemy parametrów połączenia, aby utworzyć obiekt IoTHubClient, aby można było wywołać metodę upload_blob_async w celu przekazania plików do centrum IoT. Kroki dodawania tego powiązania są podobne do tych w poprzedniej sekcji.

Aktualizowanie uprawnień do katalogu

1. Nawiąż połączenie z urządzeniem usługi IoT Edge przy użyciu protokołu SSH.

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

2. Dodaj uprawnienie do odczytu do pliku config.yaml.

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

3. Sprawdź, czy uprawnienia są ustawione poprawnie.

   ls -la /etc/iotedge/
   

4. Upewnij się, że uprawnienia dla pliku config.yaml to -r--r--r--.

Dodawanie katalogu do modułu

1. Na komputerze deweloperskim otwórz plik Dockerfile.amd64 .

2. Dodaj dodatkowy zestaw poleceń mkdir i chown do pliku, aby wyglądał następująco:

   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. Wprowadź odpowiednie zmiany w plikach Dockerfile.amd64.debug i Dockerfile.arm32v7.

Aktualizowanie konfiguracji modułu

1. Otwórz plik deployment.template.json.

2. Zmodyfikuj definicję modułu avroFileWriter, dodając drugi wiersz do Binds parametru, który wskazuje katalog kontenera (/app/iotconfig) do katalogu lokalnego na urządzeniu (/etc/iotedge).

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

3. Wprowadź odpowiednie zmiany w deployment.debug.template.json.

Instalowanie zależności

Moduł zapisywania przyjmuje zależność od dwóch bibliotek języka Python, fastavro i PyYAML. Musimy zainstalować zależności na naszej maszynie deweloperskiej i poinstruować proces kompilacji Dockera, aby zainstalował je na obrazie naszego modułu.

PyYAML

1. Na swojej maszynie deweloperskiej otwórz plik C:\source\IoTEdgeAndMlSample\EdgeSolution\modules\avoFileWriter\requirements.txt i dodaj "pyyaml" w nowym wierszu w pliku.

   azure-iothub-device-client~=1.4.3
   pyyaml
   

2. Otwórz plik Dockerfile.amd64 i dodaj pip install polecenie , aby uaktualnić narzędzia setuptools.

   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. W wierszu polecenia zainstaluj plik pyyaml na maszynie dewelopera.

   pip install pyyaml
   

Fastavro

1. W requirements.txtdodaj fastavro po PyYAML.

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

2. Zainstaluj program fastavro na maszynie deweloperów.

   pip install fastavro
   

Ponowne konfigurowanie usługi IoT Hub

Wprowadzając urządzenie i moduły usługi IoT Edge do systemu, zmieniliśmy nasze oczekiwania dotyczące tego, jakie dane będą wysyłane do centrum i w jakim celu. Musimy ponownie skonfigurować trasowanie w węźle, aby poradzić sobie z naszą nową sytuacją.

Uwaga / Notatka

Ponownie skonfigurujemy centrum przed wdrożeniem modułów, ponieważ niektóre ustawienia centrum, w szczególności przekazywanie plików, muszą być poprawnie skonfigurowane, aby moduł avroFileWriter działał poprawnie

Konfigurowanie trasy dla komunikatów RUL w usłudze IoT Hub

W przypadku routera i klasyfikatora spodziewamy się otrzymywać regularne komunikaty zawierające tylko identyfikator urządzenia i przewidywanie RUL dla urządzenia. Chcemy kierować dane RUL do własnej lokalizacji przechowywania, w której możemy monitorować stan urządzeń, tworzyć raporty i wyzwalać alerty zgodnie z potrzebami. Jednocześnie chcemy, aby wszystkie dane urządzenia, które są nadal wysyłane bezpośrednio przez urządzenie podrzędne, które nie zostało jeszcze dołączone do naszego urządzenia usługi IoT Edge, nadal będą kierowane do bieżącej lokalizacji magazynu.

Tworzenie trasy komunikatów RUL

1. W witrynie Azure Portal przejdź do usługi IoT Hub.

2. Z menu w okienku po lewej stronie w obszarze Ustawienia centrum wybierz pozycję Routing komunikatów.

3. Na karcie Trasy wybierz pozycję Dodaj.

4. Nadaj trasie nazwę RulMessageRoute.

5. Wybierz pozycję Dodaj punkt końcowy z prawej strony selektora punktów końcowych i wybierz pozycję Magazyn.

6. Na stronie Dodawanie punktu końcowego magazynu nadaj punktowi końcowemu nazwę ruldata.

7. Wybierz Wybierz kontener.

8. Na stronie Konta magazynu znajdź konto magazynu używane w tym samouczku, które nosi nazwę iotedgeandml<unikatowy sufiks>.

9. Wybierz kontener ruldata i kliknij pozycję Wybierz.

10. Po powrocie na stronę Dodawanie punktu końcowego magazynu, wybierz Utwórz, aby utworzyć punkt końcowy magazynu.

11. Wróć na stronę Dodawanie trasy, a dla zapytania dotyczącego trasowania zastąp true następującym zapytaniem:

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

12. Rozwiń sekcję Test , a następnie sekcję Treść komunikatu . Zastąp treść wiadomości tym przykładem naszych oczekiwanych komunikatów:

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

13. Wybierz Testuj trasę. Jeśli test zakończy się pomyślnie, zostanie wyświetlony komunikat "Komunikat pasował do zapytania".

14. Kliknij przycisk Zapisz.

Aktualizacja trasy turbofanDeviceDataToStorage

Nie chcemy kierować nowych danych przewidywania do naszej starej lokalizacji przechowywania, więc zaktualizuj trasę, aby jej zapobiec.

1. Na stronie Routowanie wiadomości usługi IoT Hub wybierz kartę Trasy.

2. Wybierz turbofanDeviceDataToStorage lub dowolną nazwę nadaną początkowej trasie danych urządzenia.

3. Aktualizowanie zapytania routingu do

   IS_DEFINED($body.OperationalSetting1)
   

4. Rozwiń sekcję Test , a następnie sekcję Treść komunikatu . Zastąp komunikat tym przykładem naszych oczekiwanych komunikatów:

   {
     "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. Wybierz Testuj trasę. Jeśli test zakończy się pomyślnie, zostanie wyświetlony komunikat "Komunikat pasował do zapytania".

6. Wybierz Zapisz.

Konfigurowanie przekazywania plików

Skonfiguruj funkcję przekazywania plików usługi IoT Hub, aby umożliwić modułowi zapisywania plików przekazywanie plików do magazynu.

1. W menu okienka po lewej stronie w usłudze IoT Hub w obszarze Ustawienia centrum wybierz pozycję Przekaż plik.

2. Wybierz pozycję Kontener usługi Azure Storage.

3. Wybierz konto magazynu z listy.

4. Wybierz kontener rozpoczynający się od azureml-blobstore z identyfikatorem GUID, a następnie kliknij Wybierz.

5. Wybierz Zapisz. Portal powiadamia o zakończeniu zapisywania.

Uwaga / Notatka

Nie włączamy powiadomienia o przesyłaniu plików w tym samouczku, ale zobacz Odbieranie powiadomienia o przekazywaniu pliku, aby uzyskać szczegółowe informacje na temat obsługi powiadomień o przesyłaniu plików.

Kompilowanie, publikowanie i wdrażanie modułów

Teraz, gdy wprowadziliśmy zmiany konfiguracji, możemy przystąpić do kompilowania obrazów i publikowania ich w rejestrze kontenerów platformy Azure. Proces kompilacji używa pliku deployment.template.json do określenia, które moduły należy skompilować. Ustawienia dla każdego modułu, w tym wersji, znajdują się w pliku module.json w folderze modułu. Proces kompilacji najpierw uruchamia kompilację platformy Docker na plikach Dockerfile pasujących do bieżącej konfiguracji znajdującej się w pliku module.json w celu utworzenia obrazu. Następnie publikuje obraz w rejestrze z pliku module.json z tagiem wersji pasującym do tego w pliku module.json. Na koniec tworzy manifest wdrożenia specyficzny dla konfiguracji (na przykład deployment.amd64.json), który zostanie wdrożony na urządzeniu usługi IoT Edge. Urządzenie usługi IoT Edge odczytuje informacje z manifestu wdrożenia, a na podstawie instrukcji pobierze moduły, skonfiguruje trasy i ustawi wszelkie żądane właściwości. Ta metoda wdrażania ma dwa skutki uboczne, o których należy pamiętać:

• Opóźnienie wdrożenia: ponieważ środowisko uruchomieniowe usługi IoT Edge musi rozpoznać zmianę żądanych właściwości przed rozpoczęciem ponownej konfiguracji, może upłynąć trochę czasu po wdrożeniu modułów, dopóki środowisko uruchomieniowe nie uruchomi ich i zacznie aktualizować urządzenie usługi IoT Edge.

• Wersje modułów mają znaczenie: jeśli opublikujesz nową wersję kontenera modułu w rejestrze kontenerów przy użyciu tych samych tagów wersji co poprzedni moduł, środowisko uruchomieniowe nie pobierze nowej wersji modułu. Wykonuje porównanie tagu wersji obrazu lokalnego i żądanego obrazu z manifestu wdrożenia. Jeśli te wersje są zgodne, środowisko uruchomieniowe nie podejmuje żadnej akcji. Dlatego ważne jest, aby zwiększać wersję modułu za każdym razem, gdy chcesz wdrożyć nowe zmiany. Zwiększ wersję, zmieniając właściwość version w ramach właściwości tagu w pliku module.json dla zmieniającego się modułu. Następnie skompiluj i opublikuj moduł.

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

Tworzenie i publikowanie

1. Na maszynie wirtualnej dewelopera uruchom platformę Docker, jeśli nie jest uruchomiona.

2. W programie Visual Studio Code uruchom nowy terminal z wierszem polecenia i zaloguj się do rejestru kontenerów platformy Azure (ACR).

Wymagane wartości nazwy użytkownika, hasła i serwera logowania można znaleźć w witrynie Azure Portal. Nazwa rejestru kontenerów ma format "turbofandemo<unique id>". W menu okienka po lewej stronie w obszarze Ustawienia wybierz pozycję Klucze dostępu , aby je wyświetlić.

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

1. W programie Visual Studio Code kliknij prawym przyciskiem myszy pozycję deployment.template.json i wybierz pozycję Kompiluj i wypychaj rozwiązanie usługi IoT Edge.

Wyświetlanie modułów w rejestrze

Po pomyślnym zakończeniu kompilacji będziemy mogli przejrzeć opublikowane moduły za pomocą witryny Azure Portal.

1. Otwórz usługę Azure Container Registry na potrzeby tego samouczka. Nazwa rejestru kontenerów ma format "turbofandemo<unique id>".

2. W menu okienka po lewej stronie w obszarze Usługi wybierz pozycję Repozytoria.

3. Pamiętaj, że oba utworzone moduły avrofilewriter i turbofanrouter są wyświetlane jako repozytoria.

4. Wybierz turbofanrouter i zwróć uwagę, że opublikowano jeden obraz oznaczony jako 0.0.1-amd64.

   

Wdrażanie modułów na urządzenie IoT Edge

Skompilowaliśmy i skonfigurowaliśmy moduły w naszym rozwiązaniu, a teraz wdrożymy moduły na urządzeniu usługi IoT Edge.

1. W programie Visual Studio Code kliknij prawym przyciskiem myszy plik deployment.amd64.json w folderze konfiguracji.

2. Wybierz pozycję Utwórz wdrożenie dla pojedynczego urządzenia.

3. Wybierz urządzenie IoT Edge aaTurboFanEdgeDevice.

4. Odśwież panel urządzenia usługi Azure IoT Hub w Eksploratorze programu Visual Studio Code. Powinieneś zobaczyć, że trzy nowe moduły zostały wdrożone, ale nie są jeszcze uruchomione.

5. Odśwież ponownie po kilku minutach i zobaczysz uruchomione moduły.

   

Uwaga / Notatka

Uruchomienie modułów i osiedlenie się w stanie stabilnego działania może potrwać kilka minut. W tym czasie moduły mogą być uruchamiane i zatrzymywane podczas próby nawiązania połączenia z modułem centrum usługi IoT Edge.

Diagnozowanie błędów

W tej sekcji udostępniamy kilka technik zrozumienia, co poszło nie tak z modułem lub modułami. Często można najpierw wykryć błąd na podstawie statusu w programie Visual Studio Code.

Identyfikowanie modułów, które zakończyły się niepowodzeniem

• Visual Studio Code: Zapoznaj się z panelem urządzeń usługi Azure IoT Hub. Jeśli większość modułów jest w stanie uruchomienia, ale jeden został zatrzymany, należy dokładniej zbadać ten zatrzymany moduł. Jeśli wszystkie moduły są w stanie zatrzymanym przez długi czas, może również wskazywać na awarię.

• Azure portal: Przechodząc do centrum IoT w portalu, a następnie wyszukując szczegóły urządzenia (w obszarze IoT Edge, idź do swojego urządzenia), możesz stwierdzić, że moduł zgłosił błąd lub nigdy nie zgłosił niczego do IoT hub.

Diagnozowanie z urządzenia

Logując się do urządzenia usługi IoT Edge (maszyna wirtualna z systemem Linux w naszym przypadku), możesz uzyskać dostęp do dużej ilości informacji o stanie modułów. Głównym mechanizmem, którego używamy, są polecenia platformy Docker, które pozwalają nam badać kontenery i obrazy na urządzeniu.

1. Zaloguj się do urządzenia usługi IoT Edge:

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

2. Wyświetl listę wszystkich uruchomionych kontenerów. Oczekujemy, że kontener dla każdego modułu będzie mieć nazwę odpowiadającą modułowi. Ponadto to polecenie wyświetla dokładny obraz kontenera, w tym wersję, aby można było dopasować je do oczekiwań. Możesz również wyświetlić listę obrazów, zamieniając "image" na "container" w poleceniu.

   sudo docker container ls
   

3. Pobierz dzienniki dla kontenera. To polecenie wyświetla wszystko, co zostało zapisane do StdErr i StdOut w kontenerze. To polecenie działa w przypadku kontenerów, które rozpoczęły działanie, a następnie zostały zatrzymane z jakiegoś powodu. Warto również zrozumieć, co dzieje się z kontenerami edgeAgent lub edgeHub.

   sudo docker container logs <container id>
   

4. Sprawdzanie kontenera. To polecenie udostępnia mnóstwo informacji o obrazie. Dane można filtrować w zależności od tego, czego szukasz. Jeśli na przykład chcesz sprawdzić, czy powiązania w pliku avroFileWriter są poprawne, możesz użyć polecenia :

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

5. Nawiąż połączenie z uruchomionym kontenerem. To polecenie może być przydatne, jeśli chcesz zbadać kontener podczas jego działania:

   sudo docker exec -it avroFileWriter bash
   

Uprzątnij zasoby

Ten samouczek jest częścią zestawu, w którym każdy artykuł opiera się na pracy wykonanej w poprzednich. Poczekaj z wyczyszczeniem wszystkich zasobów, aż ukończysz ostatni samouczek.

Dalsze kroki

W tym artykule utworzyliśmy rozwiązanie usługi IoT Edge w programie Visual Studio Code z trzema modułami: klasyfikatorem, routerem i modułem zapisywania/przekazywania plików. Skonfigurujemy trasy, aby umożliwić modułom komunikowanie się ze sobą na urządzeniu brzegowym. Zmodyfikowaliśmy konfigurację urządzenia brzegowego i zaktualizowaliśmy plik Dockerfile, aby zainstalować zależności i dodać dowiązania do kontenerów modułów.

Następnie zaktualizowaliśmy konfigurację usługi IoT Hub, aby kierować komunikaty na podstawie typu i obsługiwać przekazywanie plików. Po wdrożeniu wszystkich modułów na urządzeniu usługi IoT Edge upewniliśmy się, że moduły działają prawidłowo.

Przejdź do następnego artykułu, aby rozpocząć wysyłanie danych i zobaczyć rozwiązanie w działaniu.

Wysyłanie danych za pośrednictwem przezroczystej bramy