Entwickeln und Debuggen von Modulen für Azure IoT Edge mithilfe von Visual Studio 2022

Artikel
07/17/2024

Gilt für: IoT Edge 1.5 IoT Edge 1.4

Wichtig

IoT Edge 1.5 LTS und IoT Edge 1.4 LTS sind unterstützte Releases. Das Ende der Lebensdauer von IoT Edge 1.4 LTS wird am 12. November 2024 erreicht. Wenn Sie ein früheres Release verwenden, finden Sie weitere Informationen unter Aktualisieren von IoT Edge.

In diesem Artikel erfahren Sie, wie Sie Visual Studio 2022 zum Entwickeln, Debuggen und Bereitstellen von Azure IoT Edge-Modulen verwenden. Visual Studio 2022 bietet Unterstützung für IoT Edge-Module, die in C und C# geschrieben wurden. Die unterstützten Gerätearchitekturen sind Windows x64, Linux x64, ARM32 und ARM64 (Vorschauversion). Weitere Informationen zu unterstützten Betriebssystemen, Sprachen und Architekturen finden Sie unter Sprach- und Architekturunterstützung.

Dieser Artikel enthält Schritte für zwei IoT Edge Entwicklungstools.

Die Befehlszeilenschnittstelle (CLI) ist das bevorzugte Tool für die Entwicklung.
Erweiterung Azure IoT Edge Tools für Visual Studio. Die Erweiterung befindet sich im Wartungsmodus.

Verwenden Sie die Schaltfläche für die Toolauswahl am Anfang des Artikels, um Ihre Tooloption für diesen Artikel auszuwählen. Beide Tools bieten die folgenden Vorteile:

Sie können IoT Edge-Lösungen und -Module auf Ihrem lokalen Entwicklungscomputer erstellen, bearbeiten, kompilieren, ausführen und debuggen.
Sie können Ihre Azure IoT-Module in C oder C# programmieren und dabei von den Vorteilen der Entwicklung mit Visual Studio profitieren.
Sie können Ihre IoT Edge-Lösung über den Azure IoT Hub auf einem IoT Edge-Gerät bereitstellen.

Voraussetzungen

In diesem Artikel wird davon ausgegangen, dass Sie einen Windows-Computer als Entwicklungscomputer verwenden.

Installieren oder ändern Sie Visual Studio 2022 auf Ihrem Entwicklungscomputer. Wählen Sie die Workloadoptionen Azure-Entwicklung und Desktopentwicklung mit C++ aus.
Laden Sie Azure IoT Edge Tools aus dem Visual Studio Marketplace herunter, und installieren Sie sie. Sie können die Azure IoT Edge Tools-Erweiterung verwenden, um Ihre IoT Edge-Lösung zu erstellen und kompilieren. Das bevorzugte Entwicklungstool ist die Befehlszeile (CLI) Azure IoT Edge Dev Tool. Die Erweiterung enthält die Azure IoT Edge-Projektvorlagen, die zum Erstellen des Visual Studio-Projekts verwendet werden. Derzeit müssen Sie die Erweiterung unabhängig von dem von Ihnen verwendeten Entwicklungstool installieren.

Wichtig

Die Erweiterung Azure IoT Edge Tools für VS 2022 befindet sich im Wartungsmodus. Das bevorzugte Entwicklungstool ist die Befehlszeile (CLI) Azure IoT Edge Dev Tool.

Tipp

Wenn Sie Visual Studio 2019 verwenden, laden Sie die Azure IoT Edge Tools für VS 2019 aus dem Visual Studio Marketplace herunter, und installieren Sie sie.

Installieren des Vcpkg-Bibliotheks-Managers

git clone https://github.com/Microsoft/vcpkg
cd vcpkg
bootstrap-vcpkg.bat

Installieren des azure-iot-sdk-c-Pakets für Windows

vcpkg.exe install azure-iot-sdk-c:x64-windows
vcpkg.exe --triplet x64-windows integrate install

Laden Sie ein mit Docker kompatibles Containerverwaltungssystem auf Ihren Entwicklungscomputer herunter, und installieren Sie es, um Ihre Modulbilder zu erstellen und auszuführen. Installieren Sie etwa Docker Community Edition.
Verwenden Sie zum Entwickeln von Modulen mit Linux-Containern einen Windows-Computer, der die Anforderungen für Docker Desktop erfüllt.
Erstellen Sie eine Instanz von Azure Container Registry oder Docker Hub, um Ihre Modulimages zu speichern.

Tipp

Sie können anstelle einer Cloudregistrierung auch eine lokale Docker-Registrierung für Prototyp- bzw. Testzwecke verwenden.
Installieren Sie die Azure CLI.
Um das Modul auf einem Gerät zu testen, benötigen Sie einen aktiven IoT Hub mit mindestens einem IoT Edge-Gerät. Um ein IoT Edge-Gerät zum Testen zu erstellen, können Sie eines im Azure-Portal oder mit der CLI erstellen:
- Das Erstellen eines IoT Edge-Geräts im Azure-Portal ist das schnellste Verfahren. Navigieren Sie im Azure-Portal zu Ihrer IoT Hub-Ressource. Wählen Sie Geräte im Menü Geräteverwaltung und dann Gerät hinzufügen aus.
  
  Benennen Sie Ihr Gerät in Gerät erstellen mit der Geräte-ID um, aktivieren Sie IoT Edge-Gerät und wählen Sie dann unten links Speichern aus.
  
  Vergewissern Sie sich schließlich über das Menü Geräteverwaltung > Geräte, dass Ihr neues Gerät in Ihrem IoT Hub vorhanden ist. Weitere Informationen zum Erstellen eines IoT Edge-Geräts über das Azure-Portal finden Sie unter Erstellen und Bereitstellen eines IoT Edge-Geräts unter Linux mithilfe von symmetrischen Schlüsseln.
- Führen Sie zum Erstellen eines IoT Edge-Geräts mit der Befehlszeilenschnittstelle (CLI) die Schritte im Schnellstart für Linux oder Windows aus. Beim Registrieren eines IoT Edge-Geräts erstellen Sie ein IoT Edge-Gerät.
Wenn Sie den IoT Edge-Daemon auf Ihrem Entwicklungscomputer ausführen, müssen Sie möglicherweise EdgeHub und EdgeAgent beenden, bevor Sie mit der Entwicklung in Visual Studio beginnen.

Erstellen eines Azure IoT Edge-Projekts

Die IoT Edge-Projektvorlage in Visual Studio erstellt eine Projektmappe für die Bereitstellung auf IoT Edge-Geräten. Zunächst erstellen Sie eine Azure IoT Edge-Projektmappe. Anschließend erstellen Sie ein Modul in dieser Projektmappe. Jede IoT Edge-Lösung kann mehrere Module enthalten.

Warnung

Bei den Azure IoT Edge-Tools für die Visual Studio-Erweiterung fehlen die Projektvorlagen für C- und C#-Module. An der Behebung dieses Problems wird bereits gearbeitet. Wenn Sie IoT Edge-Module nicht mithilfe der Erweiterung erstellen können, verwenden Sie die folgende Problemumgehung.

Laden Sie die folgenden Dateien herunter, und speichern Sie sie im aufgeführten Visual Studio-Vorlagenverzeichnis:

Vorlagendatei	Hinzufügen zum Verzeichnis
azureiotedgemodule-v0.0.4.zip	`%userprofile%\Documents\Visual Studio 2022\Templates\ProjectTemplates\Visual C#`
azureiotedgevcmodulevs17-v0.0.9.zip	`%userprofile%\Documents\Visual Studio 2022\Templates\ProjectTemplates\Visual C++ Project`

Sie werden drei Projekte in Ihrer Projektmappe erstellen. Das Hauptmodul, das zusätzlich zum Temperatursensormodul EdgeAgent und EdgeHub enthält. Dann fügen Sie zwei weitere IoT Edge-Module hinzu.

Wichtig

Die von Visual Studio erstellte Struktur eines IoT Edge-Projekts ist mit derjenigen in Visual Studio Code nicht identisch.

Derzeit unterstützt die IoT Edge Dev Tool-CLI das Erstellen des Visual Studio-Projekttyps nicht. Sie müssen die Visual Studio IoT Edge-Erweiterung verwenden, um das Visual Studio-Projekt zu erstellen.

Erstellen Sie in Visual Studio ein neues Projekt.
Suchen Sie unter Neues Projekt erstellen nach Azure IoT Edge. Wählen Sie das Projekt aus, das der Plattform und Architektur für Ihr IoT Edge-Gerät entspricht, und wählen Sie Weiter aus.
Geben Sie unter Konfigurieren Ihres neuen Projekts einen Namen und den Speicherort für Ihr Projekt ein, und wählen Sie dann Erstellen aus.
Wählen Sie unter Modul hinzufügen den Typ des Moduls aus, das Sie entwickeln möchten. Wenn Sie über ein vorhandenes Modul verfügen, das Sie Ihrer Bereitstellung hinzufügen möchten, wählen Sie Vorhandenes Modul aus.
Geben Sie unter Modulname einen Namen für Ihr Modul ein. Wählen Sie einen Namen, der in der Containerregistrierung eindeutig ist.
Geben Sie unter Repository-URL den Namen des Imagerepositorys des Moduls an. Visual Studio füllt den Modulnamen automatisch mit localhost:5000/<Name Ihres Moduls> aus. Ersetzen Sie ihn durch Ihre eigenen Registrierungsinformationen. Wenn Sie eine lokale Docker-Registrierung zum Testen verwenden, können Sie localhost nutzen. Nutzen Sie den Anmeldeserver aus Ihren Registrierungseinstellungen, wenn Sie Azure Container Registry verwenden. Der Anmeldeserver hat die Form <Registrierungsname>.azurecr.io. Ersetzen Sie nur den Teil localhost:5000 der Zeichenfolge, damit das endgültige Ergebnis die folgende Form hat: <Registrierungsname>.azurecr.io/ <Name Ihres Moduls> .
Wählen Sie Hinzufügen aus, um Ihr Modul dem Projekt hinzuzufügen.

Hinweis

Wenn Sie bereits ein IoT Edge-Projekt haben, können Sie die Repository-URL ändern, indem Sie die Datei module.json öffnen. Die Repository-URL ist in der Eigenschaft repository der JSON-Datei zu finden.

Nun enthält Ihre Visual Studio-Projektmappe ein IoT Edge-Projekt und ein IoT Edge-Modul.

Projektstruktur

In Ihrer Projektmappe gibt es zwei Ordner auf Projektebene: einen Hauptprojektordner und einen einzelnen Modulordner. Beispielsweise verfügen Sie möglicherweise über einen Hauptprojektordner namens AzureIotEdgeApp1 und einen Modulordner mit dem Namen IotEdgeModule1. Der Hauptprojektordner enthält Ihr Bereitstellungsmanifest.

Der Modulprojektordner enthält je nach der von Ihnen ausgewählten Sprache eine Datei für Ihren Modulcode mit dem Namen Program.cs oder main.c. Dieser Ordner enthält auch eine Datei mit dem Namen module.json, die die Metadaten Ihres Moduls beschreibt. Verschiedene hier einbezogene Docker-Dateien stellen die Informationen bereit, die zum Erstellen Ihres Moduls als Windows- oder Linux-Container erforderlich sind.

Bereitstellungsmanifest Ihres Projekts

Das Bereitstellungsmanifest, das Sie bearbeiten, heißt deployment.debug.template.json. Diese Datei ist eine Vorlage eines IoT Edge-Bereitstellungsmanifests, das alle auf einem Gerät ausgeführten Module sowie die Art und Weise definiert, wie sie miteinander kommunizieren. Weitere Informationen zu Bereitstellungsmanifesten finden Sie unter Bereitstellen von Modulen und Einrichten von Routen in IoT Edge.

Wenn Sie diese Bereitstellungsvorlage öffnen, sehen Sie, dass die beiden Runtimemodule edgeAgent und edgeHub zusammen mit dem benutzerdefinierten Modul enthalten sind, das Sie in diesem Visual Studio-Projekt erstellt haben. Ein viertes Modul mit dem Namen SimulatedTemperatureSensor ist ebenfalls enthalten. Dieses Standardmodul generiert simulierte Daten, mit denen Sie Ihre Module testen können, oder löschen, wenn dies nicht erforderlich ist. Der Quellcode „SimulatedTemperatureSensor.csproj“ veranschaulicht die Funktionsweise des simulierten Temperatursensors.

Festlegen der IoT Edge-Runtimeversion

Zurzeit ist Version 1.5 die neueste stabile Runtimeversion. Sie sollten die IoT Edge-Runtimeversion auf die neueste stabile Version oder die Zielversion für Ihre Geräte aktualisieren.

Klicken Sie im Projektmappen-Explorer mit der rechten Maustaste auf den Namen Ihres Hauptprojekts, und wählen Sie IoT Edge-Runtimeversion festlegen aus.
Wählen Sie mithilfe des Dropdownmenüs die auf Ihren IoT Edge-Geräten ausgeführte Runtimeversion und dann OK aus, um Ihre Änderungen zu speichern. Wenn keine Änderung vorgenommen wurde, wählen Sie Abbrechen aus, um den Vorgang zu beenden.

Derzeit enthält die Erweiterung keine Auswahl für die neuesten Runtimeversionen. Wenn Sie die Runtimeversion auf eine höhere Version als 1.2 festlegen möchten, öffnen Sie die Bereitstellungsmanifestdatei deployment.debug.template.json. Ändern Sie die Runtimeversion für die Systemruntime-Modulimages edgeAgent und edgeHub. Wenn Sie beispielsweise die IoT Edge-Runtimeversion 1.5 verwenden möchten, ändern Sie in der Bereitstellungsmanifestdatei die folgenden Zeilen:
```
"systemModules": {
   "edgeAgent": {
    //...
      "image": "mcr.microsoft.com/azureiotedge-agent:1.5"
    //...
   "edgeHub": {
   //...
      "image": "mcr.microsoft.com/azureiotedge-hub:1.5",
   //...
```
Wenn Sie die Version geändert haben, generieren Sie Ihr Bereitstellungsmanifest erneut, indem Sie mit der rechten Maustaste auf den Namen Ihres Projekts klicken und Bereitstellung für IoT Edge generieren auswählen. Dadurch wird ein Bereitstellungsmanifest basierend auf Ihrer Bereitstellungsvorlage generiert und im Ordner config Ihres Visual Studio-Projekts angezeigt.

Öffnen Sie die Bereitstellungsmanifestdatei deployment.debug.template.json. Das Bereitstellungsmanifest ist ein JSON-Dokument, in dem die Module beschrieben werden, die auf dem IoT Edge-Zielgerät konfiguriert werden sollen.
Ändern Sie die Runtimeversion für die Systemruntime-Modulimages edgeAgent und edgeHub. Wenn Sie beispielsweise die IoT Edge-Runtimeversion 1.5 verwenden möchten, ändern Sie in der Bereitstellungsmanifestdatei die folgenden Zeilen:
```
"systemModules": {
    "edgeAgent": {
    //...
        "image": "mcr.microsoft.com/azureiotedge-agent:1.5",
    //...
    "edgeHub": {
    //...
        "image": "mcr.microsoft.com/azureiotedge-hub:1.5",
    //...
```

Optionen für die Modulinfrastruktur und -entwicklung

Wenn Sie ein neues Modul hinzufügen, enthält es Standardcode, der sofort genutzt und auf einem Gerät bereitgestellt werden kann, sodass Sie mit dem Testen beginnen können, ohne Code zu berühren. Der Modulcode befindet sich im Modulordner in einer Datei mit dem Namen Program.cs (für C#) oder main.c (für C).

Die Standardlösung ist so aufgebaut, dass die simulierten Daten aus dem SimulatedTemperatureSensor-Modul an Ihr Modul weitergeleitet werden, das die Eingabe entgegennimmt und sie dann an IoT Hub sendet.

Wenn Sie bereit sind, die Modulvorlage mit Ihrem eigenen Code anzupassen, erstellen Sie mit den Azure IoT Hub SDKs Module, die die wesentlichen Anforderungen für IoT-Lösungen wie Sicherheit, Geräteverwaltung und Zuverlässigkeit berücksichtigen.

Debuggen mithilfe des Simulators

Das Azure IoT EdgeHub Dev-Tool stellt eine lokale Entwicklungs- und Debugumgebung bereit. Das Tool ermöglicht das Starten von IoT Edge-Modulen ohne die IoT Edge-Runtime, so dass Sie IoT Edge-Module und -Projektmappen lokal erstellen, entwickeln, testen und debuggen können. Sie brauchen keine Images per Push in eine Containerregistrierung hochzuladen und auf einem Gerät bereitzustellen, um sie zu testen.

Weitere Informationen finden Sie unter Azure IoT EdgeHub Dev Tool (Azure IoT EdgeHub-Entwicklungstool).

So initialisieren Sie das Tool in Visual Studio:

Rufen Sie die Verbindungszeichenfolge Ihres IoT Edge-Geräts (in Ihrem IoT Hub zu finden) über das Azure-Portal oder aus der Azure CLI ab.

Wenn Sie Ihre Verbindungszeichenfolge mithilfe der CLI abrufen, verwenden Sie diesen Befehl, und ersetzen Sie darin "[device_id]" und "[hub_name]" durch Ihre eigenen Werte:
```
az iot hub device-identity connection-string show --device-id [device_id] --hub-name [hub_name]
```
Wählen Sie in Visual Studio im Menü Tools die Option Azure IoT Edge Tools>IoT Edge Simulator einrichten aus.
Fügen Sie die Verbindungszeichenfolge ein, und wählen Sie OK aus.

Hinweis

Sie müssen diese Schritte auf Ihrem Entwicklungscomputer nur einmal ausführen, weil die Ergebnisse auf alle nachfolgenden Azure IoT Edge-Lösungen automatisch angewendet werden. Diese Schritte können erneut ausgeführt werden, wenn Sie in eine andere Verbindungszeichenfolge ändern müssen.

Erstellen und Debuggen eines einzelnen Moduls

In der Regel möchten Sie jedes Modul testen und debuggen, bevor Sie es in einer Gesamtlösung mit mehreren Modulen ausführen. Mit dem IoT Edge-Simulatortool können Sie ein einzelnes Modul isoliert ausführen und Nachrichten über Port 53000 senden.

Wählen Sie im Projektmappen-Explorer den Modulprojektordner (z. B. IotEdgeModule1) aus, und markieren Sie ihn. Legen Sie das benutzerdefinierte Modul als Startprojekt fest. Wählen Sie im Menü Projekt>Als Startprojekt festlegen aus.
Drücken Sie F5, oder wählen Sie die Symbolleistenschaltfläche „Ausführen“ aus, um den IoT Edge-Simulator für ein einzelnes Modul zu starten. Dies kann anfangs 10 bis 20 Sekunden dauern.
Wenn das Modul erfolgreich initialisiert wurde, sollte ein .NET Core-Konsolenanwendungsfenster angezeigt werden.
Legen Sie einen Haltepunkt fest, um das Modul zu überprüfen.
- Legen Sie bei der Entwicklung in C# in ModuleBackgroundService.cs einen Haltepunkt in der PipeMessage()-Funktion fest.
- Wenn Sie C verwenden, legen Sie in InputQueue1Callback() einen Haltepunkt in der InputQueue1Callback()-Funktion fest.
Testen Sie das Modul, indem Sie eine Nachricht senden. Beim Debuggen eines einzelnen Moduls lauscht der Simulator am Standardport 53000 auf Nachrichten. Um eine Nachricht an Ihr Modul zu senden, führen Sie den folgenden cURL-Befehl über eine Befehlsshell wie Git Bash oder WSL Bash aus.
```
curl --header "Content-Type: application/json" --request POST --data '{"inputName": "input1","data":"hello world"}' http://localhost:53000/api/v1/messages
```
Wenn der Fehler Keine Entsprechung für schließende Klammer in URL angezeigt wird, versuchen Sie stattdessen folgenden Befehl:
```
curl --header "Content-Type: application/json" --request POST --data "{\"inputName\": \"input1\", \"data\", \"hello world\"}"  http://localhost:53000/api/v1/messages
```
Es sollte ein Breakpoint ausgelöst werden. Sie können Variablen im Visual Studio-Fenster Lokale Variablen beobachten, das bei der Ausführung des Debuggers angezeigt wird. Navigieren Sie zu Debuggen>Windows>Lokale Variablen.

In Ihrer Bash oder Shell sollte eine {"message":"accepted"}-Bestätigung angezeigt werden.

In Ihrer .NET-Konsole sollte Folgendes angezeigt werden:
```
IoT Hub module client initialized.
Received message: 1, Body: [hello world]
```
Drücken Sie zum Beenden des Debuggens STRG+F5, oder wählen Sie die Schaltfläche „Beenden“ aus.

Erstellen und Debuggen mehrerer Module

Nachdem Sie ein Einzelmodul entwickelt haben, möchten Sie jetzt vielleicht eine Gesamtlösung mit mehreren Modulen ausführen und debuggen. Mit dem IoT Edge-Simulatortool können Sie alle im Bereitstellungsmanifest definierten Module ausführen, einschließlich eines simulierten edgeHub-Moduls für das Nachrichtenrouting. In diesem Beispiel führen Sie zwei benutzerdefinierte Module und das Modul für den simulierten Temperatursensor aus. Nachrichten vom Modul für den simulierten Temperatursensor werden an jedes benutzerdefinierte Modul weitergeleitet.

Fügen Sie im Projektmappen-Explorer der Lösung ein zweites Modul hinzu, indem Sie mit der rechten Maustaste auf den Hauptprojektordner klicken. Wählen Sie im Menü Hinzufügen>Neues IoT Edge-Modul aus.
Geben Sie Ihrem neuen Modul im Fenster Add module einen Namen, und ersetzen Sie den Teil localhost:5000 der Repository-URL durch Ihren Azure Container Registry-Anmeldeserver, wie sie es zuvor getan haben.
Öffnen Sie die Datei deployment.debug.template.json, um nachzusehen, ob das neue Modul im Abschnitt modules hinzugefügt wurde. Dem Abschnitt routes in EdgeHubwurde außerdem eine neue Route hinzugefügt, um Nachrichten aus dem neuen Modul an IoT Hub zu senden. Wenn Sie Daten vom simulierten Temperatursensor an das neue Modul senden möchten, fügen Sie mit der folgenden JSON-Zeile eine weitere Route hinzu. Ersetzen Sie <NewModuleName> (an zwei Stellen) durch Ihren eigenen Modulnamen.
```
"sensorTo<NewModuleName>": "FROM /messages/modules/SimulatedTemperatureSensor/outputs/temperatureOutput INTO BrokeredEndpoint(\"/modules/<NewModuleName>/inputs/input1\")"
```
Klicken Sie mit der rechten Maustaste auf das Hauptprojekt (z. B. AzureIotEdgeApp1), und wählen Sie Als Startprojekt festlegen aus. Durch Festlegen des Hauptprojekts als Startprojekt werden alle Module in der Projektmappe ausgeführt. Dies umfasst beide Module, die Sie der Projektmappe hinzugefügt haben, das Modul für den simulierten Temperatursensor und den simulierten Edge-Hub.
Drücken Sie F5, oder wählen Sie die Symbolleistenschaltfläche „Ausführen“ aus, um die Projektmappe auszuführen. Dies kann anfangs 10 bis 20 Sekunden dauern. Stellen Sie sicher, dass keine anderen Docker-Container ausgeführt werden, die den für dieses Projekt benötigten Port binden könnten.
Für jedes Modul sollten zwei .NET Core-Konsolen-App-Fenster angezeigt werden.
Legen Sie einen Breakpoint fest, um die Module zu überprüfen.
- Legen Sie bei der Entwicklung in C# in ModuleBackgroundService.cs einen Haltepunkt in der PipeMessage()-Funktion fest.
- Wenn Sie C verwenden, legen Sie in InputQueue1Callback() einen Haltepunkt in der InputQueue1Callback()-Funktion fest.
Erstellen Sie in jedem Modul Breakpoints, und drücken Sie dann F5, um mehrere Module gleichzeitig auszuführen und zu debuggen. Daraufhin sollten mehrere .NET Core-Konsolenanwendungsfenster angezeigt werden, wobei jedes Fenster ein anderes Modul darstellt.
Drücken Sie zum Beenden des Debuggens STRG+F5, oder wählen Sie die Schaltfläche „Beenden“ aus.

Erstellen von Images und Pushen der Images in die Registrierung

Nachdem Sie Ihr Modul entwickelt und gedebuggt haben, können Sie das Modulimage erstellen und an Ihre Azure Container Registry-Instanz pushen. Anschließend können Sie das Modul auf Ihrem IoT Edge-Gerät bereitstellen.

Legen Sie das IoT Edge-Hauptprojekt (und nicht eines der einzelnen Module) als Startprojekt fest.
Wählen Sie entweder Debuggen oder Version als Konfiguration zum Kompilieren Ihrer Modulimages aus.

Hinweis

Bei der Auswahl von Debuggen verwendet Visual Studio Dockerfile.(amd64|windows-amd64).debug zum Erstellen von Docker-Images. Dies bindet den .NET Core-Befehlszeilendebugger VSDBG beim Erstellen in Ihr Containerimage ein. Wir empfehlen Ihnen, für produktionsbereite IoT Edge-Module die Konfiguration Version zu verwenden, die Dockerfile.(amd64|windows-amd64) ohne VSDBG verwendet.
Wenn Sie eine private Registrierung wie Azure Container Registry (ACR) verwenden, melden Sie sich dort mit dem folgenden Docker-Befehl an. Sie erhalten den Benutzernamen und das Kennwort über die Seite Zugriffsschlüssel der Registrierung im Azure-Portal.
```
docker login <ACR login server>
```
Fügen Sie jetzt die Azure Container Registry-Anmeldeinformationen den in der Datei deployment.debug.template.json enthaltenen Laufzeiteinstellungen hinzu. Es gibt hierbei zwei Möglichkeiten. Sie können Ihre Registrierungsanmeldeinformationen entweder Ihrer .env-Datei hinzufügen (am sichersten) oder sie Ihrer Datei deployment.debug.template.json direkt hinzufügen.

Hinzufügen von Anmeldeinformationen zu Ihrer .env-Datei

Wählen Sie im Projektmappen-Explorer die Symbolleistenschaltfläche Alle Dateien anzeigen aus. Die .env-Datei wird angezeigt. Fügen Sie Ihrer .env-Datei Ihren Benutzernamen und Ihr Kennwort für Azure Container Registry hinzu. Diese Anmeldeinformationen finden Sie im Azure-Portal auf der Seite Zugriffsschlüssel Ihrer Azure Container Registry.
```
    DEFAULT_RT_IMAGE=1.2
    CONTAINER_REGISTRY_USERNAME_myregistry=<my-registry-name>
    CONTAINER_REGISTRY_PASSWORD_myregistry=<my-registry-password>
```
Direktes Hinzufügen von Anmeldeinformationen zu „deployment.debug.template.json“

Wenn Sie Ihre Anmeldeinformationen lieber direkt in Ihrer Bereitstellungsvorlage hinzufügen möchten, ersetzen Sie die Platzhalter durch Ihren ACR-Administratornamen, Ihr Kennwort und Ihren Registrierungsnamen.
```
      "settings": {
        "minDockerVersion": "v1.25",
        "loggingOptions": "",
        "registryCredentials": {
          "registry1": {
            "username": "<username>",
            "password": "<password>",
            "address": "<registry name>.azurecr.io"
          }
        }
      }
```
Hinweis

In diesem Artikel werden die Administratoranmeldeinformationen für die Azure Container Registry verwendet, die für Entwicklungs- und Testszenarien geeignet sind. Wenn Sie für die Produktionsszenarien bereit sind, empfehlen wir Ihnen, eine Authentifizierungsoption mit den geringstmöglichen Rechten, z. B. Dienstprinzipale, auszuwählen. Weitere Informationen finden Sie unter Verwalten des Zugriffs auf Ihre Azure Container Registry.
Wenn Sie eine lokale Registrierung verwenden, können Sie eine lokale Registrierung durchführen.
Klicken Sie schließlich im Projektmappen-Explorer mit der rechten Maustaste auf den Hauptprojektordner, und wählen Sie IoT Edge-Module erstellen und pushen aus, um das Docker-Image für jedes Modul zu erstellen und zu pushen. Dieser Vorgang kann eine Minute dauern. Wenn in Ihrer Ausgabekonsole von Visual Studio Finished Build and Push IoT Edge Modules. angezeigt wird, sind Sie fertig.

Bereitstellen der Lösung

Nachdem Sie Ihre Modulimages erstellt und in Ihre Azure Container Registry-Instanz gepusht haben, können Sie die Projektmappe auf Ihrem IoT Edge-Gerät bereitstellen. Sie haben bereits eine Vorlage für das Bereitstellungsmanifest, die Sie im gesamten Tutorial beobachtet haben. Generieren Sie jetzt daraus ein Bereitstellungsmanifest, und verwenden Sie dann einen Azure CLI-Befehl, um Ihre Module auf Ihrem IoT Edge-Gerät in Azure bereitzustellen.

Klicken Sie im Visual Studio-Projektmappen-Explorer mit der rechten Maustaste auf Ihr Hauptprojekt, und wählen Sie Bereitstellung für IoT Edge generieren aus.
Wechseln Sie zu Ihrem lokalen Visual Studio-Hauptprojektordner, und zeigen Sie den Ordner config an. Der Dateipfad könnte so aussehen: C:\Users\<YOUR-USER-NAME>\source\repos\<YOUR-IOT-EDGE-PROJECT-NAME>\config. Hier finden Sie das generierte Bereitstellungsmanifest wie z. B. deployment.amd64.debug.json.
Überprüfen Sie Ihre Datei deployment.amd64.debug.json, um sich zu vergewissern, dass die edgeHub-Schemaversion auf „1.2“ festgelegt wurde.
```
 "$edgeHub": {
     "properties.desired": {
       "schemaVersion": "1.2",
       "routes": {
         "IotEdgeModule2022ToIoTHub": "FROM /messages/modules/IotEdgeModule2022/outputs/* INTO $upstream",
         "sensorToIotEdgeModule2022": "FROM /messages/modules/SimulatedTemperatureSensor/outputs/temperatureOutput INTO BrokeredEndpoint(\"/modules/IotEdgeModule2022/inputs/input1\")",
         "IotEdgeModule2022bToIoTHub": "FROM /messages/modules/IotEdgeModule2022b/outputs/* INTO $upstream"
       },
       "storeAndForwardConfiguration": {
         "timeToLiveSecs": 7200
       }
     }
   }
```
Tipp

Die Bereitstellungsvorlage für Visual Studio 2022 erfordert die Schemaversion „1.2“. Wenn Sie die Version „1.1“ oder „1.0“ benötigen, warten Sie, bis die Bereitstellung generiert wurde (ändern Sie sie nicht in deployment.debug.template.json). Durch das Generieren einer Bereitstellung wird standardmäßig ein „1.2“-Schema erstellt. Falls erforderlich, können Sie jedoch das generierte Manifest deployment.amd64.debug.json manuell ändern, bevor Sie es in Azure bereitstellen.

Wichtig

Sobald Ihr IoT Edge-Gerät bereitgestellt wurde, wird es im Azure-Portal mit Schemaversion 1.2 zurzeit nicht ordnungsgemäß angezeigt (Version 1.1 geht in Ordnung). Dies ist ein bekanntes Problem, das bald behoben wird. Es wird sich aber nicht auf Ihr Gerät auswirken, da es weiterhin in IoT Hub verbunden ist und mithilfe der Azure CLI jederzeit kommuniziert werden kann.
Stellen Sie jetzt Ihr Manifest mit einem Azure CLI-Befehl bereit. Öffnen Sie die Developer-Eingabeaufforderung von Visual Studio, und wechseln Sie zum Verzeichnis config.
```
    cd config
```
Stellen Sie das Manifest für Ihr IoT Edge-Gerät in IoT Hub bereit. Der Befehl konfiguriert das Gerät für die Verwendung von Modulen, die in Ihrer Lösung entwickelt wurden. Das Bereitstellungsmanifest wurde im vorherigen Schritt erstellt und im Ordner config gespeichert. Führen Sie in Ihrem Ordner config den folgenden Bereitstellungsbefehl aus. Ersetzen Sie [device id], [hub name] und [file path] durch Ihre Werte. Wenn die IoT Edge-Geräte-ID in IoT Hub nicht vorhanden ist, muss sie erstellt werden.
```
    az iot edge set-modules --device-id [device id] --hub-name [hub name] --content [file path]
```
Ihr Befehl könnte beispielsweise wie dieser aussehen:
```
az iot edge set-modules --device-id my-device-name --hub-name my-iot-hub-name --content deployment.amd64.debug.json
```
Nach Ausführung des Befehls wird in Ihrer Eingabeaufforderung eine Bestätigung der Bereitstellung in JSON angezeigt.

Erstellen des Moduls „Docker-Image“

Nachdem Sie Ihr Modul entwickelt haben, können Sie das Modulimage erstellen, um es in einer Containerregistrierung für die Bereitstellung auf Ihrem IoT Edge-Gerät zu speichern.

Verwenden Sie die Dockerfile des Moduls, um das Docker-Modulimage zu erstellen.

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

Angenommen, Ihre Befehlsshell befindet sich in Ihrem Projektverzeichnis und der Modulname lautet IotEdgeModule1. Verwenden Sie die folgenden Befehle, um das Image für die lokale Registrierung oder eine Azure-Containerregistrierung zu erstellen:

# Build the image for the local registry

docker build --rm -f "./IotEdgeModule1/Dockerfile.amd64.debug" -t localhost:5000/iotedgemodule1:0.0.1-amd64 "./IotEdgeModule1"

# Or build the image for an Azure Container Registry

docker build --rm -f "./IotEdgeModule1/Dockerfile.amd64.debug" -t myacr.azurecr.io/iotedgemodule1:0.0.1-amd64 "./IotEdgeModule1"

Pushen des Moduls „Docker-Image“

Pushen Sie Ihr Modulimage in die lokale Registrierung oder eine Containerregistrierung.

docker push <ImageName>

Zum Beispiel:

# Push the Docker image to the local registry

docker push localhost:5000/iotedgemodule1:0.0.1-amd64

# Or push the Docker image to an Azure Container Registry
az acr login --name myacr
docker push myacr.azurecr.io/iotedgemodule1:0.0.1-amd64

Stellen Sie das Modul auf dem IoT Edge-Gerät bereit.

Öffnen Sie in Visual Studio die Bereitstellungsmanifestdatei deployment.debug.template.json im Hauptprojekt. Das Bereitstellungsmanifest ist ein JSON-Dokument, in dem die Module beschrieben werden, die auf dem IoT Edge-Zielgerät konfiguriert werden sollen. Vor der Bereitstellung müssen Sie Ihre Azure Container Registry-Anmeldeinformationen, die Modulimages und die richtigen createOptions-Werte aktualisieren. Weitere Informationen zu „createOption“-Werten finden Sie unter Konfigurieren von Erstellungsoptionen für Container für IoT Edge-Module.

Wenn Sie Azure Container Registry zum Speichern Ihres Modulimages verwenden, müssen Sie Ihre Anmeldeinformationen in den edgeAgent-Einstellungen zu deployment.debug.template.json hinzufügen. Beispiel:

"modulesContent": {
"$edgeAgent": {
  "properties.desired": {
    "schemaVersion": "1.1",
    "runtime": {
      "type": "docker",
      "settings": {
        "minDockerVersion": "v1.25",
        "loggingOptions": "",
        "registryCredentials": {
          "myacr": {
            "username": "myacr",
            "password": "<your_acr_password>",
            "address": "myacr.azurecr.io"
          }
        }
      }
    },
//...

Ersetzen Sie den Eigenschaftswert image durch den Namen des Modulimages, den Sie an die Registrierung gepusht haben. Wenn Sie beispielsweise ein Image mit dem Tag myacr.azurecr.io/iotedgemodule1:0.0.1-amd64 für das benutzerdefinierte Modul IotEdgeModule1 gepusht haben, ersetzen Sie den Eigenschaftswert „image“ durch den Tagwert.

Fügen Sie den Wert createOptions für jedes System und jedes benutzerdefinierte Modul in der Bereitstellungsvorlage hinzu, oder ersetzen Sie diesen Wert darin durch den Zeichenfolgeninhalt.

Die Einstellungen image und createOptions von IotEdgeModule1 sehen beispielsweise etwa wie folgt aus:

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

Verwenden Sie den Befehl IoT Edge Azure CLI set-modules zum Bereitstellen der Module für den Azure IoT Hub. Verwenden Sie beispielsweise den folgenden Befehl, um die in der Datei deployment.debug.amd64.json definierten Module für den IoT Hub my-iot-hub und das IoT Edge-Gerät my-device bereitzustellen:

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

Tipp

Sie finden Ihre IoT Hub-Verbindungszeichenfolge im Azure-Portal unter „Azure IoT Hub“ >Sicherheitseinstellungen> Freigegebene Zugriffsrichtlinien.

Bestätigen der Bereitstellung auf Ihrem Gerät

Wenn Sie überprüfen möchten, ob Ihre IoT Edge-Module auf Azure bereitgestellt wurden, melden Sie sich bei Ihrem Gerät (oder virtuellen Computer) an, z. B. über SSH oder Azure Bastion, und führen Sie den IoT Edge-Befehl „list“ aus.

   iotedge list

Eine Liste der auf Ihrem Gerät oder virtuellen Computer gerade ausgeführten Module sollte angezeigt werden.

   NAME                        STATUS           DESCRIPTION      CONFIG
   SimulatedTemperatureSensor  running          Up a minute      mcr.microsoft.com/azureiotedge-simulated-temperature-sensor:1.0
   edgeAgent                   running          Up a minute      mcr.microsoft.com/azureiotedge-agent:1.2
   edgeHub                     running          Up a minute      mcr.microsoft.com/azureiotedge-hub:1.2
   IotEdgeModule1              running          Up a minute      myacr.azurecr.io/iotedgemodule1:0.0.1-amd64.debug
   myIotEdgeModule2            running          Up a minute      myacr.azurecr.io/myiotedgemodule2:0.0.1-amd64.debug

Debuggen mithilfe von Docker Remote SSH

Die Docker- und Moby-Engines unterstützen SSH-Verbindungen mit Containern, sodass Sie Code auf einem Remotegerät mithilfe von Visual Studio anfügen und debuggen können.

Für die Remoteverbindung mit Docker sind Berechtigungen auf Stammebene erforderlich. Führen Sie die Schritte in Manage docker as a non-root user (Verwalten von Docker als Nicht-Stammbenutzer) aus, um eine Verbindung mit dem Docker-Daemon auf dem Remotegerät zu ermöglichen. Wenn Sie das Debuggen abgeschlossen haben, möchten Sie möglicherweise Ihren Benutzer aus der Docker-Gruppe entfernen.
Führen Sie die Schritte aus, um Visual Studio zum Anfügen an einen in einem Docker-Container ausgeführten Prozess auf Ihrem Remotegerät zu verwenden.
Legen Sie in Visual Studio Breakpoints in Ihrem benutzerdefinierten Modul fest.
Wenn ein Breakpoint erreicht wird, können Sie Variablen überprüfen, Code schrittweise durchlaufen und Ihr Modul debuggen.

Nächste Schritte

Weitere Informationen zum Entwickeln von benutzerdefinierten Modulen für Ihre IoT Edge-Geräte finden Sie unter Verstehen und Verwenden von Azure IoT Hub SDKs.
Wenn Sie die D2C-Nachrichten (Device-to-Cloud) für ein bestimmtes IoT Edge-Gerät überwachen möchten, lesen Sie das Tutorial: Überwachen von IoT Edge-Geräten, um zu beginnen.

Teilen über