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

Gilt für: IoT Edge 1.5

Wichtig

IoT Edge 1.5 LTS ist das unterstützte Release. IoT Edge 1.4 LTS wurde am 12. November 2024 eingestellt. 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. Unterstützte Gerätearchitekturen umfassen Windows x64, Linux x64, ARM32 und ARM64 (Vorschau). 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:

Befehlszeilenschnittstelle (CLI), das bevorzugte Tool für die Entwicklung
Azure IoT Edge-Tools für die Visual Studio-Erweiterung ( 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 folgende 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.
Stellen Sie Ihre IoT Edge-Lösung über Azure IoT Hub auf einem IoT Edge-Gerät bereit.

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. Verwenden Sie die Azure IoT Edge Tools-Erweiterung, um Ihre IoT Edge-Lösung zu erstellen und zu entwickeln. 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. Sie benötigen die Erweiterung unabhängig vom verwendeten Entwicklungstool installiert.

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 Azure IoT Edge Tools für VS 2019 aus dem Visual Studio Marketplace herunter, und installieren Sie es.

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

Verwenden Sie eine lokale Docker-Registrierung zum Erstellen und Testen anstelle einer Cloudregistrierung.
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, erstellen Sie ein Gerät im Azure-Portal oder mit der CLI:
- Das Erstellen eines im Azure-Portal ist die schnellste Methode. Wechseln 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.
  
  Geben Sie unter 'Gerät erstellen' Ihrem Gerät einen Namen mit der Geräte-ID, aktivieren Sie 'IoT Edge Gerät', und wählen Sie dann 'Speichern' unten links aus.
  
  Vergewissern Sie sich, dass Ihr neues Gerät im IoT Hub im Menü "Geräteverwaltungsgeräte>" 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 symmetrischer Schlüssel.
- 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. 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 der in Visual Studio Code nicht identisch.

Derzeit unterstützt die IoT Edge Dev Tool-CLI das Erstellen des Visual Studio-Projekttyps nicht. Verwenden Sie die Visual Studio IoT Edge-Erweiterung, 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 mit der Plattform und Architektur für Ihr IoT Edge-Gerät übereinstimmt, und wählen Sie dann "Weiter" aus.
Geben Sie unter "Neues Projekt konfigurieren" einen Namen für Ihr Projekt ein, geben Sie den Speicherort an, 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

Um die Repository-URL in einem vorhandenen IoT Edge-Projekt zu ändern, öffnen Sie die module.json Datei. Die Repository-URL befindet sich in der Repositoryeigenschaft der JSON-Datei.

Sie verfügen jetzt über ein IoT Edge-Projekt und ein IoT Edge-Modul in Ihrer Visual Studio-Projektmappe.

Projektstruktur

Ihre Lösung verfügt über zwei Ordner auf Projektebene: einen Hauptprojektordner und einen einzelnen Modulordner. Sie können beispielsweise einen Hauptprojektordner namens AzureIotEdgeApp1 und einen Modulordner namens "IotEdgeModule1" haben. Der Hauptprojektordner verfügt über Ihr Bereitstellungsmanifest.

Der Projektordner des Moduls enthält eine Datei für den Modulcode, die je nach gewählter Sprache entweder Program.cs oder main.c benannt ist. Dieser Ordner enthält auch eine Datei mit dem Namen module.json , die die Metadaten Ihres Moduls beschreibt. Hier finden Sie verschiedene Docker-Dateien, die zum Erstellen Ihres Moduls als Windows- oder Linux-Container erforderlich sind.

Bereitstellungsmanifest Ihres Projekts

Bearbeiten Sie das Bereitstellungsmanifest mit dem Namen deployment.debug.template.json. Diese Datei ist eine Vorlage eines IoT Edge-Bereitstellungsmanifests, das alle Module definiert, die auf einem Gerät ausgeführt werden und 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 Laufzeitmodule 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 deren Hilfe Sie Ihre Module testen oder löschen können, wenn es nicht benötigt wird. Informationen zur Funktionsweise des simulierten Temperatursensors finden Sie im Quellcode "SimulatedTemperatureSensor.csproj".

Festlegen der IoT Edge-Runtimeversion

Die neueste stabile Laufzeitversion ist 1.5. Aktualisieren Sie die IoT Edge-Laufzeitversion auf die neueste stabile Version oder die Version, auf die Sie für Ihre Geräte abzielen möchten.

Klicken Sie im Projektmappen-Explorer mit der rechten Maustaste auf den Namen Ihres Hauptprojekts, und wählen Sie dann "IoT Edge-Laufzeitversion 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.

Die Erweiterung enthält keine Auswahl für die neuesten Laufzeitversionen. Um die Laufzeitversion höher als 1.2 festzulegen, öffnen Sie die deployment.debug.template.json Bereitstellungsmanifestdatei. Ändern Sie die Runtimeversion für die Systemruntime-Modulimages edgeAgent und edgeHub. Wenn Sie beispielsweise Die IoT Edge-Laufzeitversion 1.5 verwenden möchten, ändern Sie die folgenden Zeilen in der Bereitstellungsmanifestdatei:
```
"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 neu, indem Sie mit der rechten Maustaste auf den Namen Ihres Projekts klicken, und wählen Sie dann "Bereitstellung für IoT Edge generieren" aus. Dadurch wird ein Bereitstellungsmanifest basierend auf Ihrer Bereitstellungsvorlage generiert und in den Konfigurationsordner Ihres Visual Studio-Projekts versetzt.

Öffnen Sie die deployment.debug.template.json Bereitstellungsmanifestdatei. Das Bereitstellungsmanifest ist ein JSON-Dokument, das die Module beschreibt, die auf dem zielbezogenen IoT Edge-Gerät konfiguriert werden sollen.
Ändern Sie die Runtimeversion für die Systemruntime-Modulimages edgeAgent und edgeHub. Wenn Sie beispielsweise Die IoT Edge-Laufzeitversion 1.5 verwenden möchten, ändern Sie die folgenden Zeilen in der Bereitstellungsmanifestdatei:
```
"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 PipeMessage() einen Haltepunkt in der -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 PipeMessage() einen Haltepunkt in der -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, erstellen Sie das Modulimage, und übertragen Sie es an Ihre Azure Container Registry. Stellen Sie dann das Modul auf Ihrem IoT Edge-Gerät bereit.

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

Wenn Sie "Debuggen" auswählen, verwendet Dockerfile.(amd64|windows-amd64).debug Visual Studio zum Erstellen von Docker-Images. Dies bindet den .NET Core-Befehlszeilendebugger VSDBG in Ihr Containerimage ein. Verwenden Sie für produktionsbereite IoT Edge-Module die Konfiguration Version, die Dockerfile.(amd64|windows-amd64) ohne VSDBG verwendet.
Wenn Sie eine private Registrierung wie Azure Container Registry (ACR) verwenden, verwenden Sie den folgenden Docker-Befehl, um sich anzumelden. Rufen Sie den Benutzernamen und das Kennwort über die Seite "Zugriffstasten " Ihrer Registrierung im Azure-Portal ab.
```
docker login <ACR login server>
```
Fügen Sie die Anmeldeinformationen der Azure-Containerregistrierung zu den Laufzeiteinstellungen in der deployment.debug.template.json Datei hinzu. Sie können Ihre Registrierungsanmeldeinformationen zu Ihrer .env Datei (am sichersten) hinzufügen oder sie direkt zu Ihrer deployment.debug.template.json Datei 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. Suchen Sie diese Anmeldeinformationen auf der Seite Zugriffsschlüssel Ihrer Azure-Containerregistrierung im Azure-Portal.
```
    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 direkt zu Ihrer Bereitstellungsvorlage hinzufügen möchten, ersetzen Sie die Platzhalter durch Ihren ACR-Administratorbenutzernamen, Das Kennwort und den 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, führen Sie eine lokale Registrierung aus.
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 nun Ihre Modulimages erstellt und an Ihre Azure-Containerregistrierung übertragen haben, stellen Sie die Lösung auf Ihrem IoT Edge-Gerät bereit. Sie verfügen bereits über eine Bereitstellungsmanifestvorlage in diesem Lernprogramm. Generieren Sie ein Bereitstellungsmanifest daraus, 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.
Öffnen Sie Ihre deployment.amd64.debug.json Datei, und bestätigen Sie, dass die edgeHub Schemaversion auf 1.2 festgelegt ist.
```
 "$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). Das Erstellen einer Bereitstellung erzeugt automatisch ein Schema der Version 1.2. Falls erforderlich, können Sie jedoch das generierte Manifest deployment.amd64.debug.json manuell ändern, bevor Sie es in Azure bereitstellen.

Wichtig

Nachdem Ihr IoT Edge-Gerät bereitgestellt wurde, wird es derzeit nicht ordnungsgemäß im Azure-Portal mit Schemaversion 1.2 angezeigt (Version 1.1 ist in Ordnung). Dies wirkt sich jedoch nicht auf Ihr Gerät aus, da es weiterhin im IoT Hub verbunden ist und jederzeit über die Azure CLI 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
```
Nachdem Sie den Befehl ausgeführt haben, wird in der Eingabeaufforderung eine Bestätigung der Bereitstellung angezeigt, die im JSON-Format gedruckt wurde.

Erstellen des Moduls „Docker-Image“

Nachdem Sie Ihr Modul entwickelt haben, erstellen Sie das Modulimage, 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>"

Wenn sich ihre Befehlsshell beispielsweise in Ihrem Projektverzeichnis befindet und der Modulname "IotEdgeModule1" lautet, 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 createOptionsfü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 ", um die Module auf Azure IoT Hub bereitzustellen. Um beispielsweise die Module bereitzustellen, die in der Dateideployment.debug.amd64.json für den IoT-Hub my-iot-hub definiert sind, und diese auf das IoT Edge-Gerät my-device zu übertragen, führen Sie den folgenden Befehl aus:

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

Suchen Sie Ihre IoT Hub-Verbindungszeichenfolge im Azure-Portal unter Azure IoT Hub >Sicherheitseinstellungen>Gemeinsame 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 mit dem Debuggen fertig sind, sollten Sie 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.

Feedback

War diese Seite hilfreich?

Last updated on 2025-06-10