Udostępnij za pomocą

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

Dotyczy:Znacznik wyboru usługi IoT Edge 1.5 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.

W tym samouczku pokazano, jak tworzyć i wdrażać kod na urządzeniu IoT Edge. Moduły usługi Azure IoT Edge umożliwiają wdrażanie kodu, który uruchamia logikę biznesową bezpośrednio na urządzeniu usługi IoT Edge. W przewodniku Szybki start: Wdrażanie kodu na urządzeniu z systemem Linux skonfigurujesz urządzenie IoT Edge i wdrożysz moduł z Azure Marketplace.

W tym artykule opisano kroki dwóch narzędzi deweloperskich usługi IoT Edge:

  • Narzędzie developerskie Azure IoT Edge wiersza poleceń (CLI), które jest preferowane do tworzenia oprogramowania.
  • Narzędzia usługi Azure IoT Edge dla rozszerzenia programu Visual Studio Code , które jest 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 usługi IoT Edge
  • Tworzenie projektu jako kontenera platformy Docker i przechowywanie go w rejestrze kontenerów platformy Azure
  • Wdróż swój kod na urządzenie IoT Edge

Moduł usługi 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.
  • Możesz użyć większości systemów operacyjnych, które obsługują silnik kontenerów, do tworzenia modułów IoT Edge dla urządzeń z systemem Linux. W tym poradniku został użyty komputer z systemem Windows, ale także zwraca uwagę na znane różnice na systemach macOS i Linux.
  • Instalacja programu Visual Studio Code
  • Zainstaluj interfejs wiersza polecenia platformy Azure.

Urządzenie usługi Azure IoT Edge:

Zasoby w chmurze:

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

Napiwek

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

W tym samouczku opisano kroki programistyczne dla programu Visual Studio Code.

Najważniejsze pojęcia

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

Podczas tworzenia modułów usługi IoT Edge należy zrozumieć różnicę między maszyną deweloperską a docelowym urządzeniem usługi IoT Edge, na którym wdraża 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 z systemem Windows przeznaczonego dla urządzenia z systemem Linux z uruchomioną usługą 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.

Napiwek

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

Ten samouczek dotyczy urządzeń z usługą IoT Edge z kontenerami systemu Linux. Użyj preferowanego systemu operacyjnego, o ile maszyna programowa uruchamia kontenery systemu Linux. Program Visual Studio Code jest zalecany do opracowywania za pomocą kontenerów systemu Linux, więc w tym samouczku jest używany. Można również użyć programu Visual Studio, chociaż istnieją różnice w obsłudze między dwoma narzędziami.

W poniższej tabeli wymieniono obsługiwane scenariusze programistyczne dla kontenerów systemu Linux w programach 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
Usługi platformy Azure Funkcje Azure
Azure Stream Analytics
Azure Machine Learning
Języki C
C#
Jawa
Node.js
Python		 C
C#
Więcej informacji Usługa Azure IoT Edge dla programu Visual Studio Code Azure IoT Edge Tools for Visual Studio 2019
Azure IoT Edge Tools for Visual Studio 2022

Instalowanie aparatu kontenera

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

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

Konfigurowanie narzędzi

Zainstaluj narzędzie deweloperskie usługi Azure IoT Edge oparte na języku Python, aby utworzyć rozwiązanie usługi IoT Edge. Dostępne są dwie opcje:

Ważne

Rozszerzenia usługi Azure IoT Edge dla programu Visual Studio Code są w trybie konserwacji. Preferowane narzędzie programistyczne to narzędzie wiersza polecenia (CLI) usługi Azure IoT Edge Dev Tool.

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

  1. Zainstaluj rozszerzenie usługi Azure IoT Edge .
  2. Zainstaluj rozszerzenie usługi 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 pozycję IoT Hub. Postępuj zgodnie z monitami, aby wybrać subskrypcję platformy Azure i usługę IoT Hub.
  5. Otwórz sekcję eksploratora programu Visual Studio Code, wybierając ikonę na pasku działań lub wybierając pozycję Eksplorator widoków>.
  6. W dolnej części sekcji eksploratora rozwiń zwinięte menu Usługi Azure IoT Hub/Urządzenia . Zostaną wyświetlone urządzenia i urządzenia usługi IoT Edge skojarzone z usługą IoT Hub wybraną 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ń usług Azure IoT Edge i Azure IoT Hub do skompilowania 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 obraz zostanie wdrożony z rejestru w celu uruchomienia na urządzeniu usługi IoT Edge.

Ważne

Rozszerzenie programu Visual Studio Code usługi Azure IoT Edge 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 Docker to Azure Container Registry i Docker Hub. W tym samouczku używana jest usługa Azure Container Registry.

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

  1. W witrynie Azure Portal wybierz kolejno pozycje Utwórz zasób>Kontenery>Container Registry.

  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, które tworzysz podczas szybkich startów i samouczków usługi IoT Edge, na przykład IoTEdgeResources.
    Nazwa rejestru Podaj unikatową nazwę.
    Lokalizacja Wybierz bliską lokalizację.
    SKU Wybierz pozycję Podstawowa.

  3. Wybierz pozycję Przejrzyj i utwórz, a następnie pozycję Utwórz.

  4. Wybierz nowy rejestr kontenerów w sekcji Zasoby na stronie głównej witryny Azure Portal, 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. Te wartości są używane w tym samouczku, aby zapewnić dostęp do rejestru kontenerów.

Tworzenie nowego projektu modułu

Rozszerzenie usługi Azure IoT Edge oferuje szablony projektów dla wszystkich obsługiwanych języków modułów usługi IoT Edge w programie Visual Studio Code. Te szablony obejmują wszystkie pliki i kod, które należy wdrożyć w module roboczym w celu przetestowania usługi IoT Edge, lub umożliwiają rozpoczęcie dostosowywania szablonu przy użyciu własnej logiki biznesowej.

Tworzenie szablonu projektu

Narzędzie deweloperskie usługi IoT Edge upraszcza programowanie usługi Azure IoT Edge za pomocą poleceń sterowanych zmiennymi środowiskowymi. Pomaga rozpocząć tworzenie aplikacji IoT Edge przy użyciu deweloperskiego kontenera IoT Edge i tworzenia szkieletu rozwiązania IoT Edge, który zawiera domyślny moduł i wszystkie potrzebne pliki konfiguracyjne.

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

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

  2. iotedgedev solution init Użyj polecenia , aby utworzyć rozwiązanie i skonfigurować usługę 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 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

Użyj programu Visual Studio Code i rozszerzenia usługi 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: nowe rozwiązanie usługi IoT Edge.
  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. Program Visual Studio Code automatycznie wypełnia nazwę modułu nazwą localhost:5000/<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 usługi Azure Container Registry, użyj serwera logowania 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>.

Program Visual Studio Code pobiera podane informacje, tworzy rozwiązanie usługi 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 systemowe usługi 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 usługi IoT Edge

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

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

  2. Zmień wersję środowiska uruchomieniowego dla obrazów modułów edgeAgent środowiska uruchomieniowego systemu i edgeHub. Jeśli na przykład chcesz użyć środowiska uruchomieniowego usługi 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 usługi IoT Edge

W pliku środowiska przechowywane są poświadczenia rejestru kontenerów udostępniane środowisku uruchomieniowemu usługi IoT Edge. Środowisko uruchomieniowe wymaga tych poświadczeń do pobrania obrazów kontenerów na urządzenie IoT Edge.

Rozszerzenie usługi IoT Edge próbuje ściągnąć poświadczenia rejestru kontenerów z platformy 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 usługa Azure Container Registry jest rejestrem, ustaw nazwę użytkownika i hasło usługi Azure Container Registry. Pobierz te wartości z menu Ustawieniakontenerów w witrynie Azure Portal.

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

  3. Dodaj wartości nazwy użytkownika i hasła skopiowane z rejestru kontenerów platformy 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 usługi Azure Container Registry, które są praktyczne w scenariuszach deweloperskich i testowych. 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ądzenie 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 pozycję Azure IoT Edge: ustaw domyślną platformę docelową rozwiązania Edge lub wybierz ikonę skrótu na pasku bocznym w dolnej części 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 usługi IoT Hub. Przykładowy moduł odbiera komunikaty i przekazuje je dalej. Funkcja potok przedstawia ważną koncepcję w usłudze IoT Edge: jak moduły porozumiewają się między sobą.

Każdy moduł może mieć wiele kolejek wejściowych i wyjściowych zadeklarowanych w kodzie. Centrum usługi 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 usługi IoT Hub dla platformy .NET.

  1. W eksploratorze programu Visual Studio Code otwórz moduły > 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 usługi 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 ModuleClient obiekt, który umożliwia modułowi łączenie się z lokalnym środowiskiem uruchomieniowym usługi 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 usługi 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 bliźniacze reprezentacje, 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 usługi IoT Edge. Odfiltrowuje ona komunikaty zgłaszające temperatury nie przekraczające wartości progowej temperatury ustawionej za pomocą bliźniaczej reprezentacji modułu. 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 programu Visual Studio Code otwórz plik deployment.template.json w obszarze roboczym rozwiązania usługi 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 wypychanie 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 skompilować obraz kontenera modułu i wypchnąć go do rejestru kontenerów.

W programie Visual Studio Code otwórz plik manifestu wdrożenia deployment.template.json . Manifest wdrożenia opisuje moduły do skonfigurowania na docelowym urządzeniu usługi IoT Edge. Przed wdrożeniem należy zaktualizować poświadczenia rejestru Azure Container Registry i obrazy modułów na właściwe wartości createOptions. Aby uzyskać więcej informacji na temat createOptions wartości, zobacz How to configure container create options for IoT Edge modules (Jak skonfigurować opcje tworzenia kontenera dla modułów usługi IoT Edge).

Jeśli używasz usługi Azure Container Registry do przechowywania obrazu modułu, dodaj poświadczenia do modulesContent > edgeAgent > settings > registryCredentials sekcji 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\"}]}}}"
}

Kompilowanie obrazu platformy Docker modułu

Otwórz zintegrowany terminal programu Visual Studio Code, wybierając pozycję 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 przeznaczony dla platformy .NET 7.0. Jeśli chcesz określić inną wersję platformy .NET, możesz edytować plik filtermodule.csproj i zmienić wartości TargetFramework i PackageReference. Na przykład w celu kierowania pliku .NET 8.0 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 platformy Docker informacjami, wersją i architekturą rejestru kontenerów. Zastąp myacr własną nazwą rejestru.

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

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.

  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. Aby uzyskać więcej informacji, zobacz dokumentację logowania platformy Docker.

  2. Zaloguj się do usługi Azure Container Registry. Aby użyć polecenia, musisz zainstalować Azure CLIaz. 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>

    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ć.

  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żenia deployment.template.json za pomocą lokalizacji obrazu rejestru kontenerów. Jeśli na przykład używasz rejestru kontenerów Azure myacr.azurecr.io, a twój obraz to filtermodule:0.0.1-amd64, zaktualizuj konfigurację filtermodule na:

"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 programu Visual Studio Code kliknij prawym przyciskiem myszy plik deployment.template.json i wybierz polecenie Kompiluj i wypychaj rozwiązanie usługi IoT Edge.

Polecenie kompilacji i wypychania 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 polecenie w celu skompilowania obrazu kontenera na podstawie odpowiedniego pliku dockerfile dla architektury docelowej. Następnie zostanie uruchomione polecenie docker push , aby wypchnąć 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.

    Napiwek

    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ększasz wersji modułu przed utworzeniem i wypchnięciem, zastąpisz 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 platformy 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

Ponownie kliknij prawym przyciskiem myszy plik deployment.template.json , a następnie ponownie wybierz pozycję Kompiluj i wypychaj rozwiązanie usługi IoT Edge .

Otwórz ponownie plik deployment.amd64.json. Zwróć uwagę, że system kompilacji nie tworzy nowego pliku podczas ponownego uruchamiania polecenia kompilacji i wypychania. Zamiast tego te same aktualizacje plików odzwierciedlają zmiany. Obraz filtermodule wskazuje teraz wersję 0.0.2 kontenera.

Aby dokładniej sprawdzić, co zrobiło polecenie kompilacji i wypychania, przejdź do witryny Azure Portal i przejdź do rejestru kontenerów. W rejestrze kontenerów wybierz pozycję Repozytoria , a następnie filtrujmodule. 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 uruchomiono docker login polecenie przy użyciu poświadczeń skopiowanych z rejestru kontenerów? Te poświadczenia różnią się od tych, których używasz do logowania się na platformie Azure.
  • Czy używasz właściwego repozytorium kontenerów? Czy ma poprawną nazwę rejestru kontenerów i poprawną nazwę 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ń usługi IoT Edge z systemem Linux, więc program Visual Studio Code powinien powiedzieć amd64 lub arm32v7 na pasku bocznym, a program Docker Desktop powinien uruchamiać 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 usługi IoT Edge jest uruchomione.

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

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

Napiwek

Znajdź parametry połączenia usługi IoT Hub, w tym klucz dostępu współdzielonego, w witrynie Azure Portal. Przejdź do usługi IoT Hub i wybierz opcję Zabezpieczenia > zasady dostępu współdzielonego > iothubowner.

  1. W eksploratorze programu Visual Studio Code w sekcji Azure IoT Hub rozwiń węzeł Urządzenia , aby wyświetlić listę urządzeń IoT.

  2. Kliknij prawym przyciskiem myszy urządzenie usługi 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. W obszarze urządzenia 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 usługi 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 modułu filtermodule z tempSensor, a następnie przesyłają dalej komunikaty z modułu filtermodule do usługi IoT Hub. Rozszerzenia usługi Azure IoT Edge i Azure IoT Hub umożliwiają wyświetlanie komunikatów podczas ich docierania do usługi IoT Hub z urządzenia.

  1. W Eksploratorze programu Visual Studio Code wybierz urządzenie usługi 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 programie Visual Studio Code, aby zobaczyć komunikaty docierające do usługi IoT Hub.

    Zrzut ekranu przedstawiający okno danych wyjściowych programu 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 usługi IoT Edge uruchomione na urządzeniu.

Te komendy są przeznaczone dla urządzenia IoT Edge, a nie maszyny deweloperskiej. Jeśli używasz maszyny wirtualnej dla urządzenia usługi IoT Edge, połącz się z nim teraz. Na platformie Azure przejdź do strony przeglądu maszyny wirtualnej i wybierz pozycję Połącz , aby uzyskać dostęp do połączenia bezpiecznego powłoki.

  • 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 usługi 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 i usługą IoT Hub. Jeśli moduły są uruchomione, ale komunikaty nie docierają do usługi 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 także nadal używać tego samego urządzenia usługi IoT Edge jako urządzenia testowego. W przeciwnym razie, aby uniknąć opłat, usuń konfigurację lokalną i zasoby platformy Azure użyte w tym artykule.

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:

  1. Zaloguj się do witryny Azure Portal, a następnie wybierz pozycję Grupy zasobów.
  2. Wybierz nazwę grupy zasobów, która zawiera zasoby testowe usługi 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, możesz wybrać każdy zasób, aby usunąć je indywidualnie.

Następne kroki

W tym samouczku skonfigurujesz Visual Studio Code na komputerze deweloperskim i wdrożysz pierwszy moduł IoT Edge z kodem, który filtruje nieprzetworzone dane generowane przez urządzenie IoT Edge.

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

Debugowanie modułówusługi Azure IoT Edge usługiStream AnalyticsCustom Vision Service

  • Last updated on