Udostępnij za pośrednictwem

Samouczek: tworzenie modułów IoT Edge przy użyciu Visual Studio Code

Applies to:IoT Edge 1.5 znacznik wyboru IoT Edge 1.5

Ważne

IoT Edge 1.5 LTS to wspierana wersja. IoT Edge 1.4 LTS osiągnął koniec życia 12 listopada 2024 r. Jeśli używasz wcześniejszej wersji, zobacz Update IoT Edge.

W tym samouczku pokazano, jak tworzyć i wdrażać kod na urządzenia IoT Edge. moduły Azure IoT Edge umożliwiają wdrażanie kodu, który uruchamia logikę biznesową bezpośrednio na urządzeniu IoT Edge. W kodzie Deploy na urządzeniu z systemem Linux skonfigurowano urządzenie IoT Edge i wdrożono moduł z Azure Marketplace.

W tym artykule opisano kroki korzystania z dwóch narzędzi programistycznych IoT Edge:

  • Azure IoT Edge Dev Tool wiersz poleceń (CLI), który jest preferowany do rozwoju.
  • rozszerzenie narzędzi Azure IoT Edge dla Visual Studio Code, które znajduje się w trybie konserwacji.

Użyj przycisku selektora narzędzi na początku tego artykułu, aby wybrać narzędzie.

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

  • Skonfiguruj swój komputer do programowania
  • Tworzenie nowego projektu przy użyciu narzędzi IoT Edge
  • Skompiluj projekt jako kontener Docker i zapisz go w rejestrze kontenerów Azure
  • Wdrażanie kodu na urządzeniu IoT Edge

Moduł IoT Edge utworzony w tym samouczku filtruje dane temperatury generowane przez urządzenie. Wysyła wiadomości do wyższych poziomów tylko wtedy, gdy temperatura przekracza ustawiony próg. Tego rodzaju analiza na brzegu sieci pomaga zmniejszyć ilość danych wysyłanych do chmury i przechowywanych w chmurze.

Wymagania wstępne

Maszyna deweloperna:

  • Użyj własnego komputera lub maszyny wirtualnej.
  • Upewnij się, że maszyna developerska obsługuje wirtualizację zagnieżdżoną w celu uruchomienia silnika kontenerów.
  • Większość systemów operacyjnych z uruchomionym silnikiem kontenerów można używać do rozwijania modułów IoT Edge dla urządzeń z systemem Linux. Samouczek używa komputera z systemem Windows, ale wskazuje również znane różnice w systemach macOS i Linux.
  • Zainstaluj Visual Studio Code
  • Zainstaluj Azure CLI.

Urządzenie Azure IoT Edge:

Zasoby w chmurze:

Jeśli nie masz konta Azure, przed rozpoczęciem utwórz konto free.

Wskazówka

Aby uzyskać wskazówki dotyczące debugowania interaktywnego w Visual Studio Code lub Visual Studio 2022:

W tym samouczku opisano kroki programowania dla Visual Studio Code.

Najważniejsze pojęcia

Ten samouczek przeprowadzi Cię przez proces tworzenia modułu IoT Edge. Moduł IoT Edge to kontener z kodem wykonywalnym. Na urządzeniu IoT Edge można wdrożyć co najmniej jeden moduł. Moduły wykonują określone zadania, takie jak pozyskiwanie danych z czujników, czyszczenie i analizowanie danych lub wysyłanie komunikatów do IoT Hub. Aby uzyskać więcej informacji, zobacz Understand Azure IoT Edge modules.

Podczas opracowywania modułów IoT Edge należy zrozumieć różnicę między maszyną dewelopera a docelowym urządzeniem IoT Edge, na którym jest wdrażany moduł. Kontener, który utworzysz do przechowywania kodu modułu, musi być zgodny z systemem operacyjnym urządzenia docelowego. Na przykład najbardziej typowym scenariuszem jest opracowanie modułu na komputerze Windows przeznaczonym dla urządzenia z systemem Linux z systemem IoT Edge. W takim przypadku system operacyjny kontenera to Linux. Podczas pracy z tym samouczkiem należy pamiętać o różnicy między systemem operacyjnym maszyny dewelopera i systemem operacyjnym kontenera.

Wskazówka

Jeśli używasz IoT Edge dla systemu Linux w systemie Windows urządzenie docelowe w twoim scenariuszu jest maszyną wirtualną z systemem Linux, a nie hostem Windows.

Ten samouczek dotyczy urządzeń z systemem IoT Edge z kontenerami systemu Linux. Użyj preferowanego systemu operacyjnego, o ile maszyna programowa uruchamia kontenery systemu Linux. Visual Studio Code jest zalecane do pracy z kontenerami systemu Linux, więc ten samouczek go używa. Można również użyć Visual Studio, chociaż istnieją różnice w obsłudze między dwoma narzędziami.

W poniższej tabeli wymieniono obsługiwane scenariusze programowania dla kontenerów systemu Linux w Visual Studio Code i Visual Studio.

Visual Studio Code Visual Studio 2019/2022
Architektura urządzenia z systemem Linux Linux AMD64
Linux ARM32v7
Linux ARM64		 Linux AMD64
Linux ARM32
Linux ARM64
Azure services Azure Functions
Azure Stream Analytics
Azure Machine Learning
Języki C
C#
Java
Node.js
Python		 C
C#
Więcej informacji Azure IoT Edge dla Visual Studio Code Azure IoT Edge Tools for Visual Studio 2019
Azure IoT Edge Tools for Visual Studio 2022

Zainstalować silnik kontenerów

moduły IoT Edge są pakowane jako kontenery, dlatego potrzebujesz System zarządzania kontenerami zgodny z platformąDocker na maszynie deweloperów do ich kompilowania i zarządzania nimi. Docker Desktop jest popularnym wyborem do programowania, ponieważ ma silną obsługę funkcji. Program Docker Desktop na Windows umożliwia przełączanie się między kontenerami systemu Linux i kontenerami Windows, dzięki czemu można opracowywać moduły dla różnych typów urządzeń IoT Edge.

Użyj dokumentacji platformy Docker, aby zainstalować platformę Docker na komputerze deweloperskim:

Konfigurowanie narzędzi

Zainstaluj opartą na Pythonie Azure IoT Edge Dev Tool, by utworzyć rozwiązanie IoT Edge. Dostępne są dwie opcje:

Ważne

Narzędzia Azure IoT Edge dla rozszerzenia Visual Studio Code są w trybie maintenance. Preferowanym narzędziem programistycznym jest narzędzie deweloperskie Azure IoT Edge wiersza poleceń (CLI).

Użyj rozszerzeń IoT dla Visual Studio Code, aby tworzyć moduły IoT Edge. Te rozszerzenia oferują szablony projektów, automatyzują tworzenie manifestu wdrożenia i umożliwiają monitorowanie urządzeń IoT Edge i zarządzanie nimi. W tej sekcji zainstalujesz Visual Studio Code i rozszerzenie IoT, a następnie skonfigurujesz konto Azure w celu zarządzania zasobami IoT Hub z poziomu Visual Studio Code.

  1. Zainstaluj rozszerzenie Azure IoT Edge.
  2. Zainstaluj rozszerzenie Azure IoT Hub.
  3. Po zainstalowaniu rozszerzeń otwórz paletę poleceń, wybierając pozycję Wyświetl > paletę poleceń.
  4. W palecie poleceń wyszukaj i wybierz pozycję Azure IoT Hub: Wybierz IoT Hub. Postępuj zgodnie z monitami, aby wybrać subskrypcję Azure i IoT Hub.
  5. Otwórz sekcję eksploratora Visual Studio Code, wybierając ikonę na pasku działań lub wybierając pozycję View > Explorer.
  6. W dolnej części sekcji eksploratora rozwiń zwinięte menu Azure IoT Hub/Urządzenia. Zostaną wyświetlone urządzenia i urządzenia IoT Edge skojarzone z IoT Hub wybrane za pomocą palety poleceń.

Instalowanie narzędzi specyficznych dla języka

Zainstaluj narzędzia specyficzne dla języka, w którym programujesz:

Tworzenie rejestru kontenerów

W tym samouczku użyjesz rozszerzeń Azure IoT Edge i Azure IoT Hub do utworzenia modułu i utworzenia obrazu kontenera z plików. Następnie wypchniesz ten obraz do rejestru, który przechowuje obrazy i zarządza nimi. Na koniec wdrożysz obraz z rejestru, aby był uruchamiany na urządzeniu IoT Edge.

Ważne

Rozszerzenie Azure IoT Edge do Visual Studio Code jest w trybie konserwacji.

Do przechowywania obrazów kontenerów możesz użyć dowolnego rejestru zgodnego z platformą Docker. Dwie popularne usługi rejestru kontenerów Docker to Azure Container Registry i Docker Hub. Ten samouczek wykorzystuje Azure Container Registry.

Jeśli nie masz jeszcze rejestru kontenerów, wykonaj następujące kroki, aby utworzyć nowy w Azure:

  1. W portalu Azure wybierz Utwórz zasób>Kontenery>Rejestr Kontenerów.

  2. Podaj następujące wymagane wartości do utworzenia rejestru kontenerów:

    Pole Wartość
    Subskrypcja Wybierz subskrypcję z listy rozwijanej.
    Grupa zasobów Użyj tej samej grupy zasobów dla wszystkich zasobów testowych tworzonych podczas szybkiego uruchamiania i samouczków IoT Edge, na przykład IoTEdgeResources.
    Nazwa rejestru Podaj unikatową nazwę.
    Lokalizacja Wybierz bliską lokalizację.
    SKU Wybierz pozycję Podstawowa.

  3. Wybierz Recenzuj + Utwórz, a następnie Utwórz.

  4. Wybierz nowy rejestr kontenerów w sekcji Resources na stronie głównej portalu Azure, aby go otworzyć.

  5. W okienku po lewej stronie rejestru kontenerów wybierz pozycję Klucze dostępu z menu znajdującego się w obszarze Ustawienia.

    Zrzut ekranu przedstawiający lokalizację menu Klucze dostępu.

  6. Włącz użytkownika administratora za pomocą przycisku przełącznika i wyświetl nazwę użytkownika i hasło dla rejestru kontenerów.

  7. Skopiuj wartości serwera logowania, nazwy użytkownika i hasła i zapisz je w dogodnym miejscu. Tych wartości używasz w całym tym samouczku, aby zapewnić dostęp do rejestru kontenerów.

Tworzenie nowego projektu modułu

Rozszerzenie Azure IoT Edge oferuje szablony projektów dla wszystkich obsługiwanych języków modułów IoT Edge w Visual Studio Code. Te szablony obejmują wszystkie pliki i kod, które należy wdrożyć, aby przetestować IoT Edge, lub dać punkt wyjścia do dostosowania szablonu przy użyciu własnej logiki biznesowej.

Tworzenie szablonu projektu

IoT Edge Dev Tool upraszcza programowanie Azure IoT Edge za pomocą poleceń opartych na zmiennych środowiskowych. Ułatwia rozpoczęcie opracowywania IoT Edge przy użyciu kontenera deweloperskiego IoT Edge i szkieletu rozwiązania IoT Edge zawierającego domyślny moduł i wszystkie wymagane pliki konfiguracji.

  1. Utwórz katalog dla rozwiązania w żądanej ścieżce. Przejdź do katalogu iotedgesolution.

    mkdir c:\dev\iotedgesolution
cd c:\dev\iotedgesolution

  2. Użyj polecenia iotedgedev solution init, aby utworzyć rozwiązanie i skonfigurować Azure IoT Hub w wybranym języku programowania:

    iotedgedev solution init --template csharp

Polecenie iotedgedev solution init wyświetla monit o wykonanie kilku kroków, w tym:

  • Uwierzytelnianie w Azure
  • Wybieranie subskrypcji Azure
  • Wybieranie lub tworzenie grupy zasobów
  • Wybieranie lub tworzenie Azure IoT Hub
  • Wybieranie lub tworzenie urządzenia Azure IoT Edge

Użyj Visual Studio Code i rozszerzenia Azure IoT Edge. Zacznij od utworzenia rozwiązania, a następnie wygeneruj pierwszy moduł w tym rozwiązaniu. Każde rozwiązanie może zawierać wiele modułów.

  1. Wybierz pozycję Wyświetl > paletę poleceń.
  2. W palecie poleceń wprowadź i uruchom polecenie Azure IoT Edge: New IoT Edge Solution.
  3. Przejdź do folderu, w którym chcesz utworzyć nowe rozwiązanie, a następnie wybierz pozycję Wybierz folder.
  4. Wprowadź nazwę rozwiązania.
  5. Wybierz szablon modułu, aby preferowany język programowania był pierwszym modułem w rozwiązaniu.
  6. Wprowadź nazwę modułu. Wybierz unikatową nazwę w rejestrze kontenerów.
  7. Wprowadź nazwę repozytorium obrazów modułu. Visual Studio Code automatycznie wypełnia nazwę modułu jako localhost:5000/<twoja_nazwa_modułu>. Zastąp je własnymi informacjami rejestru. Użyj hosta lokalnego , jeśli używasz lokalnego rejestru platformy Docker do testowania. Jeśli używasz Azure Container Registry, użyj serwera Login z ustawień rejestru. Serwer logowania wygląda jak <nazwa rejestru>.azurecr.io. Zastąp tylko część ciągu localhost:5000, aby końcowy wynik wyglądał następująco: <nazwa rejestru>.azurecr.io/<nazwa modułu>.

Visual Studio Code pobiera podane informacje, tworzy rozwiązanie IoT Edge, a następnie ładuje je w nowym oknie.

Po utworzeniu rozwiązania te główne pliki znajdują się w rozwiązaniu:

  • Folder .vscode zawiera plik konfiguracji launch.json.

  • Folder modules zawiera podfoldery dla każdego modułu. W każdym podfolderze plik module.json kontroluje sposób kompilowania i wdrażania modułów.

  • Plik env zawiera listę zmiennych środowiskowych. Zmienna środowiskowa rejestru kontenerów jest domyślnie localhost:5000 .

  • Dwa pliki wdrażania modułu, deployment.template.json i deployment.debug.template.json, zawierają listę modułów do wdrożenia na urządzeniu. Domyślnie lista zawiera moduły systemu IoT Edge (edgeAgent i edgeHub) oraz przykładowe moduły, takie jak:

    Uwaga

    Dokładne zainstalowane moduły mogą zależeć od wybranego języka.

Ustawianie wersji środowiska uruchomieniowego IoT Edge

Najnowsza stabilna wersja modułu systemu IoT Edge to 1.5. Ustaw moduły systemowe na wersję 1.5.

  1. W Visual Studio Code otwórz plik manifestu wdrożenia deployment.template.json. Manifest deployment to dokument JSON opisujący moduły do skonfigurowania na docelowym urządzeniu IoT Edge.

  2. Zmień wersję środowiska uruchomieniowego dla obrazów modułów środowiska uruchomieniowego systemu edgeAgent i edgeHub. Jeśli na przykład chcesz użyć środowiska uruchomieniowego IoT Edge w wersji 1.5, zmień następujące wiersze w pliku manifestu wdrożenia:

    "systemModules": {
    "edgeAgent": {

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

    "edgeHub": {

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

Podaj poświadczenia rejestru agentowi IoT Edge

Plik środowiska przechowuje poświadczenia dla rejestru kontenerów i udostępnia je środowisku uruchomieniowemu IoT Edge. Środowisko uruchomieniowe wymaga tych poświadczeń, aby ściągnąć obrazy kontenerów na urządzenie IoT Edge.

Rozszerzenie IoT Edge próbuje ściągnąć poświadczenia rejestru kontenerów z Azure i wypełnić je w pliku środowiska.

Uwaga

Plik środowiska jest tworzony tylko wtedy, gdy udostępnisz repozytorium obrazów dla modułu. Jeśli zaakceptowano domyślne ustawienia localhost do testowania i debugowania lokalnie, nie musisz deklarować zmiennych środowiskowych.

Sprawdź, czy twoje poświadczenia istnieją. Jeśli nie, dodaj je teraz:

  1. Jeśli Azure Container Registry jest rejestrem, ustaw nazwę użytkownika i hasło Azure Container Registry. Pobierz te wartości z menu Ustawienia>Klucze dostępu w portalu Azure.

  2. Otwórz plik .env w rozwiązaniu modułu.

  3. Dodaj wartości username i password skopiowane z rejestru kontenerów usługi Azure. Na przykład:

    CONTAINER_REGISTRY_SERVER="myacr.azurecr.io"
CONTAINER_REGISTRY_USERNAME="myacr"
CONTAINER_REGISTRY_PASSWORD="<registry_password>"

  4. Zapisz zmiany w pliku env .

Uwaga

W tym samouczku są używane poświadczenia administratora dla Azure Container Registry, co jest wygodne w przypadku scenariuszy rozwoju i testowania. Gdy jesteś gotowy na scenariusze produkcyjne, zalecamy użycie opcji uwierzytelniania o najniższych uprawnieniach, takich jak wewnętrzne identyfikatory lub tokeny z zakresem repozytorium. Aby uzyskać więcej informacji, zobacz Zarządzanie dostępem do rejestru kontenerów.

Architektura docelowa

Wybierz architekturę docelową dla każdego rozwiązania, ponieważ ma to wpływ na sposób kompilowania i uruchamiania kontenera. Wartość domyślna to Linux AMD64. Na potrzeby tego samouczka użyj maszyny wirtualnej z systemem Ubuntu jako urządzenia IoT Edge i zachowaj domyślną amd64.

Jeśli musisz zmienić architekturę docelową rozwiązania, wykonaj następujące kroki.

  1. Otwórz paletę poleceń i wyszukaj Azure IoT Edge: Ustaw domyślną platformę docelową rozwiązania edge lub wybierz ikonę skrótu na pasku bocznym u dołu okna.
  2. Na palecie poleceń wybierz architekturę docelową z listy opcji.

Architektura docelowa jest ustawiana podczas tworzenia obrazu kontenera w późniejszym kroku.

Aktualizowanie modułu przy użyciu kodu niestandardowego

Każdy szablon zawiera przykładowy kod, który pobiera symulowane dane czujnika z modułu SimulatedTemperatureSensor i kieruje go do IoT Hub. Przykładowy moduł odbiera komunikaty i przekazuje je dalej. Funkcjonalność przepływu pracy pokazuje ważną koncepcję w IoT Edge: jak moduły komunikują się ze sobą.

Każdy moduł może mieć wiele kolejek wejściowych i wyjściowych zadeklarowanych w kodzie. Centrum IoT Edge uruchomione na urządzeniu kieruje komunikaty z danych wyjściowych jednego modułu do danych wejściowych co najmniej jednego modułu. Określony kod do deklarowania danych wejściowych i wyjściowych różni się między językami, ale koncepcja jest taka sama dla wszystkich modułów. Aby uzyskać więcej informacji na temat routingu między modułami, zobacz Deklarowanie tras.

Przykładowy kod języka C# dostarczany z szablonem projektu używa klasy ModuleClient z zestawu SDK IoT Hub dla .NET.

  1. W eksploratorze Visual Studio Code otwórz modules > filtermodule > ModuleBackgroundService.cs.

  2. Przed przestrzenią nazwową filtermodule dodaj trzy using instrukcje dla typów, które są używane później:

    using System.Collections.Generic;     // For KeyValuePair<>
using Microsoft.Azure.Devices.Shared; // For TwinCollection
using Newtonsoft.Json;                // For JsonConvert

  3. Dodaj zmienną temperatureThreshold do ModuleBackgroundService klasy . Ta zmienna ustawia wartość, która musi przekraczać mierzoną temperaturę, aby dane zostały wysłane do IoT Hub.

    static int temperatureThreshold { get; set; } = 25;

  4. Dodaj klasy MessageBody, Machine i Ambient. Te klasy definiują oczekiwany schemat treści komunikatów przychodzących.

    class MessageBody
{
    public Machine machine {get;set;}
    public Ambient ambient {get; set;}
    public string timeCreated {get; set;}
}
class Machine
{
    public double temperature {get; set;}
    public double pressure {get; set;}
}
class Ambient
{
    public double temperature {get; set;}
    public int humidity {get; set;}
}

  5. ExecuteAsync Znajdź funkcję. Ta funkcja tworzy i konfiguruje obiekt ModuleClient, który umożliwia modułowi łączenie się z lokalnym środowiskiem uruchomieniowym Azure IoT Edge w celu wysyłania i odbierania komunikatów. Po utworzeniu ModuleClient, kod odczytuje wartość temperatureThreshold z konfigurowanych właściwości bliźniaka modułu. Kod rejestruje wywołanie zwrotne w celu odbierania komunikatów z centrum IoT Edge za pośrednictwem punktu końcowego o nazwie input1.

    Zastąp wywołanie ProcessMessageAsync metody nową, która aktualizuje nazwę punktu końcowego i metodę wywoływaną po nadejściu danych wejściowych. Ponadto dodaj metodę SetDesiredPropertyUpdateCallbackAsync, aby umożliwić aktualizacje żądanych właściwości. Aby wprowadzić tę zmianę, zastąp ostatni wiersz ExecuteAsync metody następującym kodem:

    // Register a callback for messages that are received by the module.
// await _moduleClient.SetInputMessageHandlerAsync("input1", PipeMessage, cancellationToken);

// Read the TemperatureThreshold value from the module twin's desired properties
var moduleTwin = await _moduleClient.GetTwinAsync();
await OnDesiredPropertiesUpdate(moduleTwin.Properties.Desired, _moduleClient);

// Attach a callback for updates to the module twin's desired properties.
await _moduleClient.SetDesiredPropertyUpdateCallbackAsync(OnDesiredPropertiesUpdate, null);

// Register a callback for messages that are received by the module. Messages received on the inputFromSensor endpoint are sent to the FilterMessages method.
await _moduleClient.SetInputMessageHandlerAsync("inputFromSensor", FilterMessages, _moduleClient);

  6. Dodaj metodę OnDesiredPropertiesUpdate do klasy ModuleBackgroundService. Ta metoda odbiera aktualizacje żądanych właściwości z bliźniaczej reprezentacji modułu i aktualizuje zmienną temperatureThreshold w celu dopasowania. Wszystkie moduły mają swoje cyfrowe bliźniaki, dzięki czemu można skonfigurować kod działający wewnątrz modułu bezpośrednio z poziomu chmury.

    static Task OnDesiredPropertiesUpdate(TwinCollection desiredProperties, object userContext)
{
    try
    {
        Console.WriteLine("Desired property change:");
        Console.WriteLine(JsonConvert.SerializeObject(desiredProperties));

        if (desiredProperties["TemperatureThreshold"]!=null)
            temperatureThreshold = desiredProperties["TemperatureThreshold"];

    }
    catch (AggregateException ex)
    {
        foreach (Exception exception in ex.InnerExceptions)
        {
            Console.WriteLine();
            Console.WriteLine("Error when receiving desired property: {0}", exception);
        }
    }
    catch (Exception ex)
    {
        Console.WriteLine();
        Console.WriteLine("Error when receiving desired property: {0}", ex.Message);
    }
    return Task.CompletedTask;
}

  7. Dodaj metodę FilterMessages . Ta metoda jest wywoływana za każdym razem, gdy moduł odbiera komunikat z centrum IoT Edge. Filtrowane są komunikaty zgłaszające temperatury poniżej wartości progowej ustawionej w module. Dodaje również do komunikatu atrybut MessageType z wartością ustawioną na Alert:

    async Task<MessageResponse> FilterMessages(Message message, object userContext)
{
    var counterValue = Interlocked.Increment(ref _counter);
    try
    {
        ModuleClient moduleClient = (ModuleClient)userContext;
        var messageBytes = message.GetBytes();
        var messageString = Encoding.UTF8.GetString(messageBytes);
        Console.WriteLine($"Received message {counterValue}: [{messageString}]");

        // Get the message body.
        var messageBody = JsonConvert.DeserializeObject<MessageBody>(messageString);

        if (messageBody != null && messageBody.machine.temperature > temperatureThreshold)
        {
            Console.WriteLine($"Machine temperature {messageBody.machine.temperature} " +
                $"exceeds threshold {temperatureThreshold}");
            using (var filteredMessage = new Message(messageBytes))
            {
                foreach (KeyValuePair<string, string> prop in message.Properties)
                {
                    filteredMessage.Properties.Add(prop.Key, prop.Value);
                }

                filteredMessage.Properties.Add("MessageType", "Alert");
                await moduleClient.SendEventAsync("output1", filteredMessage);
            }
        }

        // Indicate that the message treatment is completed.
        return MessageResponse.Completed;
    }
    catch (AggregateException ex)
    {
        foreach (Exception exception in ex.InnerExceptions)
        {
            Console.WriteLine();
            Console.WriteLine("Error in sample: {0}", exception);
        }
        // Indicate that the message treatment is not completed.
        var moduleClient = (ModuleClient)userContext;
        return MessageResponse.Abandoned;
    }
    catch (Exception ex)
    {
        Console.WriteLine();
        Console.WriteLine("Error in sample: {0}", ex.Message);
        // Indicate that the message treatment is not completed.
        ModuleClient moduleClient = (ModuleClient)userContext;
        return MessageResponse.Abandoned;
    }
}

  8. Zapisz plik ModuleBackgroundService.cs.

  9. W eksploratorze Visual Studio Code otwórz plik deployment.template.json w obszarze roboczym rozwiązania IoT Edge.

  10. Ponieważ zmieniliśmy nazwę punktu końcowego, na który nasłuchuje moduł, musimy również zaktualizować trasy w manifeście wdrożenia, aby usługa edgeHub wysyłała komunikaty do nowego punktu końcowego.

    Znajdź sekcję routes w bliźniaczej reprezentacji modułu $edgeHub . Zaktualizuj trasę sensorTofiltermodule, zastępując input1 przez inputFromSensor.

    "sensorTofiltermodule": "FROM /messages/modules/tempSensor/outputs/temperatureOutput INTO BrokeredEndpoint(\"/modules/filtermodule/inputs/inputFromSensor\")"

  11. Dodaj bliźniacze reprezentację modułu filtermodule do manifestu wdrożenia. Wstaw następującą zawartość JSON na dole sekcji modulesContent, po bliźniaczej reprezentacji modułu $edgeHub:

       "filtermodule": {
       "properties.desired":{
           "TemperatureThreshold":25
       }
   }

  12. Zapisz plik deployment.template.json.

Kompilowanie i publikowanie rozwiązania

Zaktualizowano kod modułu i szablon wdrożenia, aby ułatwić zrozumienie niektórych kluczowych pojęć związanych z wdrażaniem. Teraz możesz zbudować obraz kontenera modułu i przesłać go do rejestru kontenerów.

W Visual Studio Code otwórz plik manifestu wdrożenia deployment.template.json. Manifest deployment opisuje moduły do skonfigurowania na docelowym urządzeniu IoT Edge. Przed wdrożeniem należy zaktualizować dane uwierzytelniające Azure Container Registry i obrazy modułów z odpowiednimi wartościami createOptions. Aby uzyskać więcej informacji na temat wartości createOptions, zobacz Jak skonfigurować opcje tworzenia kontenera dla modułów IoT Edge.

Jeśli używasz Azure Container Registry do przechowywania obrazu modułu, dodaj poświadczenia do sekcji modulesContent > edgeAgent > settings > registryCredentials w deployment.template.json. Zastąp myacr własną nazwą rejestru i podaj hasło oraz adres serwera logowania. Na przykład:

"registryCredentials": {
    "myacr": {
        "username": "myacr",
        "password": "<your_acr_password>",
        "address": "myacr.azurecr.io"
    }
}

Dodaj lub zastąp następującą zawartość reprezentowaną jako tekst wartością createOptions dla każdego systemu (edgeHub i *edgeAgent) oraz modułu niestandardowego (filtermodule i tempSensor). W razie potrzeby zmień wartości:

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

Na przykład konfiguracja powinna być podobna do następującej filtermodule :

"filtermodule": {
"version": "1.0",
"type": "docker",
"status": "running",
"restartPolicy": "always",
"settings": {
   "image": "myacr.azurecr.io/filtermodule:0.0.1-amd64",
   "createOptions": "{\"HostConfig\":{\"PortBindings\":{\"5671/tcp\":[{\"HostPort\":\"5671\"}],\"8883/tcp\":[{\"HostPort\":\"8883\"}],\"443/tcp\":[{\"HostPort\":\"443\"}]}}}"
}

Tworzenie obrazu modułu Docker

Otwórz zintegrowany terminal Visual Studio Code, wybierając Terminal > Nowy terminal.

Użyj polecenia , dotnet publish aby skompilować obraz kontenera dla architektury systemów Linux i amd64. Zmień katalog na katalog filtermodule w projekcie i uruchom dotnet publish polecenie .

dotnet publish --os linux --arch x64 /t:PublishContainer

Obecnie szablon narzędzia iotedgedev jest skierowany na .NET 7.0, który osiągnął koniec wsparcia w maju 2024 r. Zaktualizuj projekt do wersji docelowej .NET 8.0 (LTS, obsługiwanej do listopada 2026 r.), edytując0 filtermodule.csproj i zmieniając wartości TargetFramework i PackageReference. Plik filtermodule.csproj powinien wyglądać następująco:

<Project Sdk="Microsoft.NET.Sdk.Worker">
    <PropertyGroup>
        <TargetFramework>net8.0</TargetFramework>
        <Nullable>enable</Nullable>
        <ImplicitUsings>enable</ImplicitUsings>
    </PropertyGroup>
    <ItemGroup>
        <PackageReference Include="Microsoft.Azure.Devices.Client" Version="1.42.0" />
        <PackageReference Include="Microsoft.Extensions.Hosting" Version="8.0.0" />
    </ItemGroup>
</Project>

Oznacz obraz Dockera informacjami o rejestrze kontenerów, wersją i architekturą. Zastąp myacr własną nazwą rejestru.

docker tag filtermodule myacr.azurecr.io/filtermodule:0.0.1-amd64

Obraz Docker dla modułu push

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

  1. Zaloguj się do platformy Docker przy użyciu poświadczeń usługi Azure Container Registry (ACR):

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

    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. W przypadku uwierzytelniania rejestru kontenerów w środowisku produkcyjnym użyj tokenów o zakresie jednostki usługi lub repozytorium zamiast poświadczeń administratora. Aby uzyskać więcej informacji, zobacz Zarządzanie dostępem do rejestru kontenerów i referencję do docker login.

  2. Zaloguj się do Azure Container Registry. Musisz install Azure CLI aby użyć polecenia az. 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 <ACR registry name>

    Wskazówka

    Jeśli w dowolnym momencie tego samouczka zostaniesz wylogowany, powtórz kroki logowania do Docker i Azure Container Registry, aby kontynuować.

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

    docker push <ImageName>

    Na przykład:

    # Push the Docker image to the local registry

docker push localhost:5000/filtermodule:0.0.1-amd64

# Or push the Docker image to an Azure Container Registry. Replace myacr with your Azure Container Registry name.

az acr login --name myacr
docker push myacr.azurecr.io/filtermodule:0.0.1-amd64

Aktualizowanie szablonu wdrożenia

Zaktualizuj szablon wdrożeniowy deployment.template.json, korzystając z lokalizacji obrazu rejestru kontenerów. Jeśli na przykład używasz Azure Container Registry myacr.azurecr.io, a obraz jest filtermodule:0.0.1-amd64, zaktualizuj konfigurację filtermodule:

"filtermodule": {
    "version": "1.0",
    "type": "docker",
    "status": "running",
    "restartPolicy": "always",
    "settings": {
        "image": "myacr.azurecr.io/filtermodule:0.0.1-amd64",
        "createOptions": "{\"HostConfig\":{\"PortBindings\":{\"5671/tcp\":[{\"HostPort\":\"5671\"}],\"8883/tcp\":[{\"HostPort\":\"8883\"}],\"443/tcp\":[{\"HostPort\":\"443\"}]}}}"
    }
}

W eksploratorze Visual Studio Code kliknij prawym przyciskiem myszy plik deployment.template.json i wybierz pozycję Build and Push IoT Edge Solution.

Polecenie kompilacji i wysyłania uruchamia trzy operacje. Najpierw tworzy nowy folder w rozwiązaniu o nazwie config , który zawiera pełny manifest wdrożenia, utworzony z informacji w szablonie wdrożenia i innych plikach rozwiązań. Po drugie, uruchamia docker build w celu skompilowania obrazu kontenera na podstawie odpowiedniego pliku dockerfile dla architektury docelowej. Następnie zostanie uruchomione polecenie docker push, aby przesłać repozytorium obrazów do rejestru kontenerów.

Ten proces może potrwać kilka minut po raz pierwszy, ale jest szybszy przy następnym uruchomieniu poleceń.

Opcjonalnie: aktualizowanie modułu i obrazu

Jeśli wprowadzisz zmiany w kodzie modułu, musisz skompilować ponownie i przesłać obraz modułu do rejestru kontenerów. Wykonaj kroki opisane w tej sekcji, aby zaktualizować obraz kompilacji i kontenera. Możesz pominąć tę sekcję, jeśli nie wprowadzono żadnych zmian w kodzie modułu.

Otwórz plik deployment.amd64.json w nowo utworzonym folderze konfiguracji. Nazwa pliku odzwierciedla architekturę docelową, więc różni się, jeśli wybrano inną architekturę.

Zwróć uwagę, że dwa parametry, które miały symbole zastępcze, zawierają teraz odpowiednie wartości. Sekcja registryCredentials zawiera nazwę użytkownika rejestru i hasło pobrane z pliku env . Plik filtermodule zawiera pełne repozytorium obrazów o nazwie, wersji i tagu architektury z pliku module.json .

  1. Otwórz plik module.json w folderze filtermodule.

  2. Zmień numer wersji obrazu modułu. Na przykład zwiększ numer wersji poprawki tak "version": "0.0.2" , jakby wprowadzono niewielką poprawkę w kodzie modułu.

    Wskazówka

    Wersje modułów umożliwiają kontrolę wersji i umożliwiają testowanie zmian na małym zestawie urządzeń przed wdrożeniem aktualizacji w środowisku produkcyjnym. Jeśli nie zwiększysz wersji modułu przed zbudowaniem i wypchnięciem, nadpiszesz repozytorium w rejestrze kontenerów.

  3. Zapisz zmiany w pliku module.json .

Skompiluj i wypchnij zaktualizowany obraz z tagiem wersji 0.0.2 . Aby na przykład skompilować i wypchnąć obraz dla rejestru lokalnego lub rejestru kontenerów Azure, użyj następujących poleceń:

# Build the container image for Linux and amd64 architecture.

dotnet publish --os linux --arch x64

# For local registry:
# Tag the image with version 0.0.2, x64 architecture, and the local registry.

docker tag filtermodule localhost:5000/filtermodule:0.0.2-amd64

# For Azure Container Registry:
# Tag the image with version 0.0.2, x64 architecture, and your container registry information. Replace **myacr** with your own registry name.

docker tag filtermodule myacr.azurecr.io/filtermodule:0.0.2-amd64

Kliknij prawym przyciskiem myszy plik deployment.template.json i ponownie wybierz Build and Push IoT Edge Solution.

Otwórz ponownie plik deployment.amd64.json. Zwróć uwagę, że system budowania nie tworzy nowego pliku podczas ponownego wykonania polecenia budowania i wypychania. Zamiast tego ten sam plik jest aktualizowany, aby odzwierciedlić zmiany. Obraz filtermodule wskazuje teraz wersję 0.0.2 kontenera.

Aby dokładniej zweryfikować, co zrobiło polecenie kompilacji i wypychania, przejdź do portalu Azure i zlokalizuj swój rejestr kontenerów. W rejestrze kontenerów wybierz pozycję Repozytoria, a następnie filtermodule. Sprawdź, czy obie wersje obrazu są wypychane do rejestru.

Zrzut ekranu przedstawiający lokalizację wyświetlania obu wersji obrazów w rejestrze kontenerów.

Rozwiązywanie problemów

Jeśli podczas kompilowania i wypychania obrazu modułu wystąpią błędy, często trzeba to zrobić z konfiguracją platformy Docker na maszynie dewelopera. Aby przejrzeć konfigurację, wykonaj następujące testy:

  • Czy uruchomiłeś polecenie docker login przy użyciu poświadczeń skopiowanych z rejestru kontenerów? Te dane uwierzytelniające różnią się od tych, których używasz do logowania się do Azure.
  • Czy używasz właściwego repozytorium kontenerów? Czy ma poprawną nazwę rejestru kontenerów i poprawną nazwę Twojego modułu? Otwórz plik module.json w folderze filtermodule, aby sprawdzić. Wartość repozytorium powinna być podobna do <nazwa rejestru>.azurecr.io/filtermodule.
  • Jeśli dla modułu użyto innej nazwy niż filtermodule , czy nazwa jest spójna w całym rozwiązaniu?
  • Czy maszyna korzysta z tego samego typu kontenerów, które tworzysz? Ten samouczek dotyczy urządzeń z systemem Linux IoT Edge, dlatego Visual Studio Code powinien powiedzieć amd64 lub arm32v7 na pasku bocznym, a na pulpicie platformy Docker powinny być uruchomione kontenery systemu Linux.

Wdrażanie modułów na urządzeniu

Sprawdzono, że istnieją wbudowane obrazy kontenerów przechowywane w rejestrze kontenerów, więc nadszedł czas, aby wdrożyć je na urządzeniu. Upewnij się, że urządzenie IoT Edge jest uruchomione.

Użyj polecenia IoT Edge Azure CLI set-modules, aby wdrożyć moduły w Azure IoT Hub. Aby na przykład wdrożyć moduły zdefiniowane w pliku deployment.template.json do pliku IoT Hub my-iot-hub dla urządzenia IoT Edge my-device użyj następującego polecenia. Zastąp wartości hub-namedevice-id i login IoT Hub connection string własnymi wartościami.

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

Wskazówka

Znajdź IoT Hub connection string, w tym klucz dostępu współdzielonego, w portalu Azure. Przejdź do IoT Hub i wybierz pozycję Ustawienia zabezpieczeń > Zasady dostępu współdzielonego > iothubowner.

  1. W eksploratorze Visual Studio Code w sekcji Azure IoT Hub rozwiń Urządzenia, aby zobaczyć listę urządzeń IoT.

  2. Kliknij prawym przyciskiem myszy urządzenie IoT Edge, do którego chcesz wdrożyć, a następnie wybierz pozycję Utwórz wdrożenie dla pojedynczego urządzenia.

  3. W Eksploratorze plików przejdź do folderu config , a następnie wybierz plik deployment.amd64.json .

    Nie używaj pliku deployment.template.json, który nie zawiera poświadczeń rejestru kontenerów ani wartości obrazu modułu. Jeśli docelowe jest urządzenie z systemem Linux ARM32, nazwa manifestu wdrożenia jest deployment.arm32v7.json.

  4. Pod swoim urządzeniem rozwiń węzeł Moduły, aby wyświetlić listę wdrożonych i uruchomionych modułów. Wybierz przycisk odświeżenia. Na urządzeniu powinny zostać wyświetlone nowe moduły tempSensor i filtermodule .

    Uruchomienie modułów może potrwać kilka minut. Środowisko uruchomieniowe IoT Edge odbiera nowy manifest wdrożenia, pobiera obrazy modułów ze środowiska uruchomieniowego kontenera, a następnie uruchamia każdy nowy moduł.

Wyświetlanie komunikatów z urządzenia

Przykładowy kod modułu pobiera komunikaty za pośrednictwem kolejki wejściowej i wysyła je za pośrednictwem kolejki wyjściowej. Manifest wdrożenia konfiguruje trasy, które wysyłają komunikaty do filtermodule z tempSensor, a następnie przesyłają dalej komunikaty z filtermodule do IoT Hub. Rozszerzenia Azure IoT Edge i Azure IoT Hub umożliwiają wyświetlanie komunikatów w miarę ich docierania do IoT Hub z urządzenia.

  1. W eksploratorze Visual Studio Code wybierz urządzenie IoT Edge, które chcesz monitorować, a następnie wybierz pozycję Rozpocznij monitorowanie wbudowanego punktu końcowego zdarzeń.

  2. Obejrzyj okno danych wyjściowych w Visual Studio Code, aby zobaczyć komunikaty docierające do IoT Hub.

    Zrzut ekranu przedstawiający okno danych wyjściowych Visual Studio Code z przychodzącymi komunikatami z urządzenia do chmury.

Wyświetlanie zmian na urządzeniu

Aby zobaczyć, co się dzieje na urządzeniu, użyj poleceń w tej sekcji, aby sprawdzić środowisko uruchomieniowe i moduły IoT Edge uruchomione na urządzeniu.

Te polecenia są przeznaczone dla urządzenia IoT Edge, a nie maszyny dewelopera. Jeśli używasz maszyny wirtualnej dla urządzenia IoT Edge, połącz się z nim teraz. W Azure przejdź do strony przeglądu maszyny wirtualnej i wybierz Połącz w celu uzyskania dostępu do połączenia SSH.

  • Wyświetl wszystkie moduły wdrożone na urządzeniu i sprawdź ich stan:

    iotedge list

    Zobaczysz cztery moduły: dwa moduły środowiska uruchomieniowego IoT Edge, tempSensor i filtermodule. Wszystkie cztery powinny być wyświetlane jako uruchomione.

  • Sprawdź dzienniki dla określonego modułu:

    iotedge logs <module name>

    W nazwach modułów jest rozróżniana wielkość liter.

    Dzienniki tempSensor i filtermodule pokazują komunikaty, które przetwarzają. Moduł edgeAgent uruchamia inne moduły, więc jego dzienniki zawierają informacje o manifeście wdrożenia. Jeśli moduł nie znajduje się na liście lub nie jest uruchomiony, sprawdź dzienniki edgeAgent pod kątem błędów. Moduł edgeHub zarządza komunikacją między modułami a IoT Hub. Jeśli moduły są uruchomione, ale komunikaty nie docierają do IoT Hub, sprawdź dzienniki edgeHub pod kątem błędów.

Czyszczenie zasobów

Jeśli chcesz przejść do następnego zalecanego artykułu, zachowaj utworzone zasoby i konfiguracje i użyj ich ponownie. Możesz również nadal używać tego samego urządzenia IoT Edge co urządzenie testowe. W przeciwnym razie, aby uniknąć opłat, usuń konfigurację lokalną i zasoby Azure użyte w tym artykule.

Usuwanie zasobów Azure

Nie można cofnąć usuwania Azure zasobów i grup zasobów. Uważaj, aby nie usunąć przypadkowo niewłaściwych zasobów lub niewłaściwej grupy zasobów. Jeśli utworzono IoT Hub wewnątrz istniejącej grupy zasobów zawierającej zasoby, które chcesz zachować, usuń tylko zasób IoT Hub, a nie grupę zasobów.

Aby usunąć zasoby:

  1. Zaloguj się do portalu Azure, a następnie wybierz pozycję Grupy zasobów.
  2. Wybierz nazwę grupy zasobów zawierającej zasoby testowe IoT Edge.
  3. 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, wybierz każdy zasób, aby usunąć je indywidualnie.

Następne kroki

W tym samouczku skonfigurujesz Visual Studio Code na komputerze deweloperskim i wdrożysz swój pierwszy moduł IoT Edge, korzystając z kodu filtrującego dane nieprzetworzone, które są generowane przez twoje urządzenie IoT Edge.

Przejdź do następnych samouczków, aby dowiedzieć się, jak Azure IoT Edge umożliwia wdrażanie Azure usług w chmurze w celu przetwarzania i analizowania danych na brzegu sieci.

Debugowanie modułów Azure IoT EdgeFunctionsStream AnalyticsCustom Vision Service

  • Last updated on