Visual Studio 2022 gebruiken om modules te ontwikkelen en fouten op te sporen voor Azure IoT Edge

Artikel
04/11/2024

Van toepassing op: IoT Edge 1.4

Belangrijk

IoT Edge 1.4 is de ondersteunde release. Raadpleeg IoT Edge bijwerken als u een eerdere versie hebt.

In dit artikel leest u hoe u Visual Studio 2022 gebruikt om aangepaste Azure IoT Edge-modules te ontwikkelen, fouten op te sporen en te implementeren. Visual Studio 2022 biedt sjablonen voor IoT Edge-modules die zijn geschreven in C en C#. De ondersteunde apparaatarchitecturen zijn Windows x64, Linux x64, ARM32 en ARM64 (preview). Zie taal- en architectuurondersteuning voor meer informatie over ondersteunde besturingssystemen, talen en architecturen.

Dit artikel bevat stappen voor twee IoT Edge-ontwikkelhulpprogramma's.

Opdrachtregelinterface (CLI) is het favoriete hulpprogramma voor ontwikkeling.
Azure IoT Edge-hulpprogramma's voor Visual Studio-extensie . De extensie bevindt zich in de onderhoudsmodus.

Gebruik de knop toolkiezer aan het begin om de optie voor het hulpprogramma voor dit artikel te kiezen. Beide hulpprogramma's bieden de volgende voordelen:

IoT Edge-oplossingen en -modules maken, bewerken, bouwen, uitvoeren en fouten opsporen op uw lokale ontwikkelcomputer.
Codeer uw Azure IoT-modules in C of C# met de voordelen van Visual Studio-ontwikkeling.
Implementeer uw IoT Edge-oplossing op een IoT Edge-apparaat via Azure IoT Hub.

Vereisten

In dit artikel wordt ervan uitgegaan dat u een computer met Windows gebruikt als uw ontwikkelcomputer.

Installeer of wijzig Visual Studio 2022 op uw ontwikkelcomputer. Kies de Azure-ontwikkeling en desktopontwikkeling met opties voor C++ -workloads.
Download en installeer Azure IoT Edge Tools vanuit Visual Studio Marketplace. U kunt de Azure IoT Edge Tools-extensie gebruiken om uw IoT Edge-oplossing te maken en te bouwen. Het favoriete ontwikkelhulpprogramma is de opdrachtregel (CLI) Azure IoT Edge Dev Tool. De extensie bevat de Azure IoT Edge-projectsjablonen die worden gebruikt om het Visual Studio-project te maken. Op dit moment moet de extensie zijn geïnstalleerd, ongeacht het ontwikkelprogramma dat u gebruikt.

Belangrijk

De Azure IoT Edge Tools for VS 2022-extensie bevindt zich in de onderhoudsmodus. Het favoriete ontwikkelhulpprogramma is de opdrachtregel (CLI) Azure IoT Edge Dev Tool.

Tip

Als u Visual Studio 2019 gebruikt, downloadt en installeert u Azure IoT Edge Tools voor VS 2019 vanuit de Visual Studio Marketplace.

Vcpkg-bibliotheekbeheer installeren

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

Het pakket azure-iot-sdk-c voor Windows installeren

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

Download en installeer een docker-compatibel containerbeheersysteem op uw ontwikkelcomputer om uw moduleinstallatiekopieën te bouwen en uit te voeren. Installeer bijvoorbeeld Docker Community Edition.
Als u modules met Linux-containers wilt ontwikkelen, gebruikt u een Windows-computer die voldoet aan de vereisten voor Docker Desktop.
Maak een Azure Container Registry of Docker Hub om uw moduleinstallatiekopieën op te slaan.

Tip

U kunt een lokaal Docker-register gebruiken voor prototype- en testdoeleinden in plaats van een cloudregister.
Installeer de Azure CLI.
Als u uw module op een apparaat wilt testen, hebt u een actieve IoT Hub met ten minste één IoT Edge-apparaat nodig. Als u een IoT Edge-apparaat wilt maken voor testen, kunt u er een maken in Azure Portal of met de CLI:
- Het maken van een exemplaar in Azure Portal is het snelste. Ga vanuit Azure Portal naar uw IoT Hub-resource. Selecteer Apparaten in het menu Apparaatbeheer en selecteer vervolgens Apparaat toevoegen.
  
  In Een apparaat maken, geef uw apparaat een naam met behulp van apparaat-id, controleert u Het IoT Edge-apparaat en selecteert u Opslaan in de linkerbenedenhoek.
  
  Controleer ten slotte of uw nieuwe apparaat bestaat in uw IoT Hub, in het menu Apparaatbeheerapparaten>. Lees Een IoT Edge-apparaat maken en inrichten in Linux met behulp van symmetrische sleutels voor meer informatie over het maken van een IoT Edge-apparaat via Azure Portal.
- Als u een IoT Edge-apparaat wilt maken met de CLI, volgt u de stappen in de quickstart voor Linux of Windows. Tijdens het registreren van een IoT Edge-apparaat maakt u een IoT Edge-apparaat.
Als u de IoT Edge-daemon uitvoert op uw ontwikkelcomputer, moet u EdgeHub en EdgeAgent mogelijk stoppen voordat u begint met ontwikkelen in Visual Studio.

Een Azure IoT Edge-project maken

Met de IoT Edge-projectsjabloon in Visual Studio wordt een oplossing gemaakt voor implementatie op IoT Edge-apparaten. Eerst maakt u een Azure IoT Edge-oplossing. Vervolgens maakt u een module in die oplossing. Elke IoT Edge-oplossing kan meer dan één module bevatten.

In onze oplossing gaan we drie projecten bouwen. De hoofdmodule die EdgeAgent en EdgeHub bevat, naast de temperatuursensormodule. Vervolgens voegt u nog twee IoT Edge-modules toe.

Belangrijk

De IoT Edge-projectstructuur die door Visual Studio is gemaakt, is niet hetzelfde als de structuur in Visual Studio Code.

Momenteel biedt de Azure IoT Edge Dev Tool CLI geen ondersteuning voor het maken van het Visual Studio-projecttype. U moet de Visual Studio IoT Edge-extensie gebruiken om het Visual Studio-project te maken.

Maak een nieuw project in Visual Studio.
Zoek in Een nieuw project maken naar Azure IoT Edge. Selecteer het project dat overeenkomt met het platform en de architectuur voor uw IoT Edge-apparaat en selecteer Volgende.
Voer in Het nieuwe project configureren een naam in voor uw project, geef de locatie op en selecteer Maken.
Selecteer in Module toevoegen het type module dat u wilt ontwikkelen. Als u een bestaande module hebt die u aan uw implementatie wilt toevoegen, selecteert u Bestaande module.
Voer in Modulenaam een naam in voor uw module. Kies een naam die uniek is in uw containerregister.
Geef in opslagplaats-URL de naam op van de opslagplaats voor de installatiekopieën van de module. Visual Studio vult de modulenaam automatisch in met localhost:5000/<uw modulenaam>. Vervang deze door uw eigen registergegevens. Gebruik localhost als u een lokaal Docker-register gebruikt om te testen. Als u Azure Container Registry gebruikt, gebruikt u de aanmeldingsserver vanuit de instellingen van uw register. De aanmeldingsserver ziet eruit als <registernaam.azurecr.io.> Vervang alleen het gedeelte localhost:5000 van de tekenreeks, zodat het uiteindelijke resultaat eruitziet als <registernaam.azurecr.io/<> naam van de module.>
Selecteer Toevoegen om uw module toe te voegen aan het project.

Notitie

Als u een bestaand IoT Edge-project hebt, kunt u de URL van de opslagplaats wijzigen door het bestand module.json te openen. De URL van de opslagplaats bevindt zich in de opslagplaatseigenschap van het JSON-bestand.

U hebt nu een IoT Edge-project en een IoT Edge-module in uw Visual Studio-oplossing.

Projectstructuur

In uw oplossing zijn er twee mappen op projectniveau, waaronder een hoofdprojectmap en één modulemap. U hebt bijvoorbeeld een hoofdprojectmap met de naam AzureIotEdgeApp1 en een modulemap met de naam IotEdgeModule1. De hoofdprojectmap bevat uw implementatiemanifest.

De moduleprojectmap bevat een bestand voor de modulecode met de naam of Program.csmain.c afhankelijk van de taal die u hebt gekozen. Deze map bevat ook een bestand met de naam module.json waarmee de metagegevens van uw module worden beschreven. Verschillende Docker-bestanden die hier worden opgenomen, bieden de informatie die nodig is om uw module te bouwen als een Windows- of Linux-container.

Implementatiemanifest van uw project

Het implementatiemanifest dat u bewerkt, heeft de naam deployment.debug.template.json. Dit bestand is een sjabloon van een IoT Edge-implementatiemanifest dat alle modules definieert die op een apparaat worden uitgevoerd, samen met de communicatie met elkaar. Zie Meer informatie over het implementeren van modules en het tot stand brengen van routes voor meer informatie over implementatiemanifesten.

Als u deze implementatiesjabloon opent, ziet u dat de twee runtimemodules edgeAgenten edgeHub zijn opgenomen, samen met de aangepaste module die u in dit Visual Studio-project hebt gemaakt. Er is ook een vierde module met de naam SimulatedTemperatureSensor opgenomen. Met deze standaardmodule worden gesimuleerde gegevens gegenereerd die u kunt gebruiken om uw modules te testen of te verwijderen als dit niet nodig is. Bekijk de broncode SimulatedTemperatureSensor.csproj om te zien hoe de gesimuleerde temperatuursensor werkt.

Runtimeversie van IoT Edge instellen

Momenteel is de nieuwste stabiele runtimeversie 1.4. Werk de IoT Edge-runtimeversie bij naar de meest recente stabiele versie of de versie waarop u zich wilt richten voor uw apparaten.

Klik in Solution Explorer met de rechtermuisknop op de naam van uw hoofdproject en selecteer IoT Edge-runtimeversie instellen.
Gebruik de vervolgkeuzelijst om de runtimeversie te kiezen waarop uw IoT Edge-apparaten worden uitgevoerd en selecteer VERVOLGENS OK om uw wijzigingen op te slaan. Als er geen wijziging is aangebracht, selecteert u Annuleren om af te sluiten.

Momenteel bevat de extensie geen selectie voor de nieuwste runtimeversies. Als u de runtimeversie hoger dan 1.2 wilt instellen, opent u het manifestbestand deployment.debug.template.json deployment. Wijzig de runtimeversie voor de installatiekopieën van de system Runtime-module edgeAgent en edgeHub. Als u bijvoorbeeld de IoT Edge-runtimeversie 1.4 wilt gebruiken, wijzigt u de volgende regels in het distributiemanifestbestand:
```
"systemModules": {
   "edgeAgent": {
    //...
      "image": "mcr.microsoft.com/azureiotedge-agent:1.4"
    //...
   "edgeHub": {
   //...
      "image": "mcr.microsoft.com/azureiotedge-hub:1.4",
   //...
```
Als u de versie hebt gewijzigd, genereert u het implementatiemanifest opnieuw door met de rechtermuisknop op de naam van uw project te klikken en implementatie genereren voor IoT Edge te selecteren. Hiermee wordt een implementatiemanifest gegenereerd op basis van uw implementatiesjabloon en wordt deze weergegeven in de configuratiemap van uw Visual Studio-project.

Open het manifestbestand deployment.debug.template.json-implementatie . Het implementatiemanifest is een JSON-document waarin de modules worden beschreven die moeten worden geconfigureerd op het beoogde IoT Edge-apparaat.
Wijzig de runtimeversie voor de installatiekopieën van de system Runtime-module edgeAgent en edgeHub. Als u bijvoorbeeld de IoT Edge-runtimeversie 1.4 wilt gebruiken, wijzigt u de volgende regels in het distributiemanifestbestand:
```
"systemModules": {
    "edgeAgent": {
    //...
        "image": "mcr.microsoft.com/azureiotedge-agent:1.4",
    //...
    "edgeHub": {
    //...
        "image": "mcr.microsoft.com/azureiotedge-hub:1.4",
    //...
```

Opties voor module-infrastructuur en ontwikkeling

Wanneer u een nieuwe module toevoegt, wordt deze geleverd met standaardcode die klaar is om te worden gebouwd en geïmplementeerd op een apparaat, zodat u kunt beginnen met testen zonder code aan te raken. De modulecode bevindt zich in de modulemap in een bestand met de naam Program.cs (voor C#) of main.c (voor C).

De standaardoplossing is zo gebouwd dat de gesimuleerde gegevens van de Module SimulatedTemperatureSensor worden gerouteerd naar uw module, die de invoer neemt en deze vervolgens naar IoT Hub verzendt.

Wanneer u klaar bent om de modulesjabloon aan te passen met uw eigen code, gebruikt u de Azure IoT Hub SDK's om modules te bouwen die voldoen aan de belangrijkste behoeften voor IoT-oplossingen, zoals beveiliging, apparaatbeheer en betrouwbaarheid.

Fouten opsporen met behulp van de simulator

Het Azure IoT EdgeHub Dev Tool biedt een lokale ontwikkel- en foutopsporingservaring. Het hulpprogramma helpt IoT Edge-modules te starten zonder de IoT Edge-runtime, zodat u lokaal IoT Edge-modules en -oplossingen kunt maken, ontwikkelen, testen, uitvoeren en fouten kunt opsporen. U hoeft installatiekopieën niet naar een containerregister te pushen en deze te implementeren op een apparaat om te testen.

Zie Azure IoT EdgeHub Dev Tool voor meer informatie.

Het hulpprogramma initialiseren in Visual Studio:

Haal de verbindingsreeks van uw IoT Edge-apparaat (gevonden in uw IoT Hub) op uit de Azure-portal of vanuit de Azure CLI.

Als u de CLI gebruikt om uw verbindingsreeks op te halen, gebruikt u deze opdracht, waarbij u [device_id] en [hub_name] vervangt door uw eigen waarden:
```
az iot hub device-identity connection-string show --device-id [device_id] --hub-name [hub_name]
```
Selecteer in het menu Extra in Visual Studio de optie Azure IoT Edge Tools>Setup IoT Edge Simulator.
Plak de verbindingsreeks en selecteer OK.

Notitie

U moet deze stappen slechts eenmaal uitvoeren op uw ontwikkelcomputer, omdat de resultaten automatisch worden toegepast op alle volgende Azure IoT Edge-oplossingen. Deze procedure kan opnieuw worden gevolgd als u wilt overschakelen naar een andere verbindingsreeks.

Een enkele module bouwen en fouten opsporen

Normaal gesproken wilt u elke module testen en fouten opsporen voordat u deze uitvoert in een volledige oplossing met meerdere modules. Met het ioT Edge-simulatorhulpprogramma kunt u één module afzonderlijk uitvoeren voor het verzenden van berichten via poort 53000.

Selecteer en markeer in Solution Explorer de projectmap van de module (bijvoorbeeld IotEdgeModule1). Stel de aangepaste module in als het opstartproject. Selecteer Projectset>als Opstartproject in het menu.
Druk op F5 of selecteer de werkbalkknop Uitvoeren om de IoT Edge-simulator voor één module te starten. Het kan in eerste instantie 10 tot 20 seconden duren.
Er wordt nu een .NET Core-console-appvenster weergegeven als de module is geïnitialiseerd.
Stel een onderbrekingspunt in om de module te inspecteren.
- Als u in C# ontwikkelt, stelt u een onderbrekingspunt in de PipeMessage() functie in ModuleBackgroundService.cs in.
- Als u C gebruikt, stelt u een onderbrekingspunt in de InputQueue1Callback() functie in main.c.
Test de module door een bericht te verzenden. Wanneer u fouten in één module opspoort, luistert de simulator op de standaardpoort 53000 voor berichten. Als u een bericht naar uw module wilt verzenden, voert u de volgende curl-opdracht uit vanuit een opdrachtshell zoals Git Bash of WSL Bash.
```
curl --header "Content-Type: application/json" --request POST --data '{"inputName": "input1","data":"hello world"}' http://localhost:53000/api/v1/messages
```
Als de fout niet-overeenkomende accolade/haakje sluiten in URL wordt weergegeven, probeert u in plaats daarvan de volgende opdracht:
```
curl --header "Content-Type: application/json" --request POST --data "{\"inputName\": \"input1\", \"data\", \"hello world\"}"  http://localhost:53000/api/v1/messages
```
Het onderbrekingspunt moet worden geactiveerd. U kunt variabelen bekijken in het visual Studio Locals-venster , gevonden wanneer het foutopsporingsprogramma wordt uitgevoerd. Ga naar Fouten opsporen in>Windows>Locals.

In uw Bash of shell ziet u een {"message":"accepted"} bevestiging.

In uw .NET-console ziet u het volgende:
```
IoT Hub module client initialized.
Received message: 1, Body: [hello world]
```
Tip

U kunt ook PostMan of andere API-hulpprogramma's gebruiken om berichten te verzenden in plaats van curl.
Druk op Ctrl+F5 of selecteer de stopknop om de foutopsporing te stoppen.

Meerdere modules bouwen en fouten opsporen

Nadat u klaar bent met het ontwikkelen van één module, kunt u een volledige oplossing met meerdere modules uitvoeren en er fouten in opsporen. Met het hulpprogramma ioT Edge-simulator kunt u alle modules uitvoeren die zijn gedefinieerd in het implementatiemanifest, inclusief een gesimuleerde edgeHub voor berichtroutering. In dit voorbeeld voert u twee aangepaste modules en de module voor de gesimuleerde temperatuursensor uit. Berichten van de gesimuleerde temperatuursensormodule worden doorgestuurd naar elke aangepaste module.

Voeg in Solution Explorer een tweede module toe aan de oplossing door met de rechtermuisknop op de hoofdprojectmap te klikken. Selecteer In het menu de optie Nieuwe IoT Edge-module toevoegen>.
Geef in het Add module venster uw nieuwe module een naam en vervang het localhost:5000 gedeelte van de opslagplaats-URL door uw Azure Container Registry-aanmeldingsserver, zoals u eerder hebt gedaan.
Open het bestand deployment.debug.template.json om te zien dat de nieuwe module is toegevoegd in de sectie modules . Er is ook een nieuwe route toegevoegd aan de sectie Routes om EdgeHub berichten van de nieuwe module naar IoT Hub te verzenden. Als u gegevens van de gesimuleerde temperatuursensor naar de nieuwe module wilt verzenden, voegt u een andere route toe met de volgende regel JSON. Vervang <NewModuleName> (op twee plaatsen) door uw eigen modulenaam.
```
"sensorTo<NewModuleName>": "FROM /messages/modules/SimulatedTemperatureSensor/outputs/temperatureOutput INTO BrokeredEndpoint(\"/modules/<NewModuleName>/inputs/input1\")"
```
Klik met de rechtermuisknop op het hoofdproject (bijvoorbeeld AzureIotEdgeApp1) en selecteer Instellen als opstartproject. Door het hoofdproject in te stellen als opstartproject, worden alle modules in de oplossing uitgevoerd. Dit omvat beide modules die u hebt toegevoegd aan de oplossing, de module voor de gesimuleerde temperatuursensor en de gesimuleerde Edge-hub.
Druk op F5 of selecteer de knop Werkbalk uitvoeren om de oplossing uit te voeren. Het kan in eerste instantie 10 tot 20 seconden duren. Zorg ervoor dat er geen andere Docker-containers worden uitgevoerd die mogelijk de poort binden die u nodig hebt voor dit project.
U ziet dat er twee .NET Core-console-appvensters voor elke module worden weergegeven.
Stel een onderbrekingspunt in om de modules te controleren.
- Als u in C# ontwikkelt, stelt u een onderbrekingspunt in de PipeMessage() functie in ModuleBackgroundService.cs in.
- Als u C gebruikt, stelt u een onderbrekingspunt in de InputQueue1Callback() functie in main.c.
Maak onderbrekingspunten in elke module en druk vervolgens op F5 om meerdere modules tegelijk uit te voeren en fouten op te sporen. U ziet nu meerdere .NET Core-console-appvensters, waarbij elk venster een andere module vertegenwoordigt.
Druk op Ctrl+F5 of selecteer de stopknop om de foutopsporing te stoppen.

Installatiekopieën bouwen en pushen naar het register

Nadat u de module hebt ontwikkeld en fouten hebt opgespoord, kunt u de moduleinstallatiekopieën bouwen en pushen naar uw Azure Container Registry. Vervolgens kunt u de module implementeren op uw IoT Edge-apparaat.

Stel het belangrijkste IoT Edge-project in als het opstartproject, niet als een van de afzonderlijke modules.
Selecteer Fouten opsporen of Vrijgeven als de configuratie die u wilt bouwen voor uw module-installatiekopieën.

Notitie

Wanneer u Fouten opsporen kiest, gebruikt Dockerfile.(amd64|windows-amd64).debug Visual Studio om Docker-installatiekopieën te bouwen. Dit omvat het .NET Core-opdrachtregeldebugger VSDBG in uw containerinstallatiekopie tijdens het bouwen ervan. Voor IoT Edge-modules die gereed zijn voor productie, raden we u aan de releaseconfiguratie te gebruiken, die zonder VSDBG wordt gebruikt Dockerfile.(amd64|windows-amd64) .
Als u een privéregister zoals Azure Container Registry (ACR) gebruikt, gebruikt u de volgende Docker-opdracht om u aan te melden. U kunt de gebruikersnaam en het wachtwoord ophalen op de pagina Toegangssleutels van uw register in Azure Portal.
```
docker login <ACR login server>
```
Laten we de aanmeldingsgegevens van Azure Container Registry toevoegen aan de runtime-instellingen in het bestand deployment.debug.template.json. Er zijn twee manieren om dit te doen. U kunt uw registerreferenties toevoegen aan uw .env bestand (meest veilig) of deze rechtstreeks toevoegen aan uw deployment.debug.template.json bestand.

Referenties toevoegen aan uw .env bestand:

Selecteer in Solution Explorer de knop Alle bestanden weergeven. Het .env bestand wordt weergegeven. Voeg uw Azure Container Registry-gebruikersnaam en -wachtwoord toe aan uw .env bestand. Deze referenties vindt u op de pagina Toegangssleutels van uw Azure Container Registry in Azure Portal.
```
    DEFAULT_RT_IMAGE=1.2
    CONTAINER_REGISTRY_USERNAME_myregistry=<my-registry-name>
    CONTAINER_REGISTRY_PASSWORD_myregistry=<my-registry-password>
```
Referenties rechtstreeks toevoegen aan deployment.debug.template.json

Als u uw referenties liever rechtstreeks aan uw implementatiesjabloon wilt toevoegen, vervangt u de tijdelijke aanduidingen door de gebruikersnaam, het wachtwoord en de registernaam van uw ACR-beheerder.
```
      "settings": {
        "minDockerVersion": "v1.25",
        "loggingOptions": "",
        "registryCredentials": {
          "registry1": {
            "username": "<username>",
            "password": "<password>",
            "address": "<registry name>.azurecr.io"
          }
        }
      }
```
Notitie

In dit artikel worden aanmeldingsreferenties voor beheerders gebruikt voor Azure Container Registry, wat handig is voor ontwikkelings- en testscenario's. Wanneer u klaar bent voor productiescenario's, wordt u aangeraden een optie voor verificatie met minimale bevoegdheden, zoals service-principals. Zie Toegang tot uw containerregister beheren voor meer informatie.
Als u een lokaal register gebruikt, kunt u een lokaal register uitvoeren.
Klik ten slotte in Solution Explorer met de rechtermuisknop op de hoofdprojectmap en selecteer Build- en Push IoT Edge-modules om de Docker-installatiekopieën voor elke module te bouwen en te pushen. Dit kan even duren. Wanneer u in de uitvoerconsole van Visual Studio ziet Finished Build and Push IoT Edge Modules. , bent u klaar.

De oplossing implementeren

Nu u uw moduleinstallatiekopieën hebt gebouwd en gepusht naar uw Azure Container Registry, kunt u de oplossing implementeren op uw IoT Edge-apparaat. U hebt al een implementatiemanifestsjabloon die u in deze zelfstudie hebt waargenomen. Laten we een implementatiemanifest genereren en vervolgens een Azure CLI-opdracht gebruiken om uw modules te implementeren op uw IoT Edge-apparaat in Azure.

Klik met de rechtermuisknop op uw hoofdproject in Visual Studio Solution Explorer en kies Implementatie genereren voor IoT Edge.
Ga naar de lokale hoofdprojectmap van Visual Studio en zoek in de config map. Het bestandspad kan er als volgt uitzien: C:\Users\<YOUR-USER-NAME>\source\repos\<YOUR-IOT-EDGE-PROJECT-NAME>\config. Hier vindt u het gegenereerde implementatiemanifest, zoals deployment.amd64.debug.json.
Controleer het deployment.amd64.debug.json bestand om te controleren of de edgeHub schemaversie is ingesteld op 1.2.
```
 "$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
       }
     }
   }
```
Tip

Voor de implementatiesjabloon voor Visual Studio 2022 is de schemaversie 1.2 vereist. Als u wilt dat deze 1.1 of 1.0 is, wacht u totdat de implementatie is gegenereerd (wijzig deze niet in deployment.debug.template.json). Als u een implementatie genereert, wordt standaard een 1.2-schema gemaakt. U kunt het gegenereerde manifest echter handmatig wijzigen deployment.amd64.debug.json, indien nodig voordat u het implementeert in Azure.

Belangrijk

Zodra uw IoT Edge-apparaat is geïmplementeerd, wordt het momenteel niet correct weergegeven in Azure Portal met schemaversie 1.2 (versie 1.1 is prima). Dit is een bekende fout en wordt binnenkort opgelost. Dit heeft echter geen invloed op uw apparaat, omdat het nog steeds is verbonden in IoT Hub en op elk gewenst moment kan worden gecommuniceerd met behulp van de Azure CLI.
Nu gaan we ons manifest implementeren met een Azure CLI-opdracht. Open de opdrachtprompt voor Visual Studio Developer en ga naar de configuratiemap.
```
    cd config
```
Implementeer het manifest voor uw IoT Edge-apparaat in IoT Hub. Met de opdracht configureert u het apparaat voor het gebruik van modules die in uw oplossing zijn ontwikkeld. Het implementatiemanifest is gemaakt in de vorige stap en opgeslagen in de configuratiemap . Voer vanuit de configuratiemap de volgende implementatieopdracht uit. Vervang de [device id], [hub name]en [file path] door uw waarden. Als de IoT Edge-apparaat-id niet bestaat in de IoT Hub, moet deze worden gemaakt.
```
    az iot edge set-modules --device-id [device id] --hub-name [hub name] --content [file path]
```
Uw opdracht kan er bijvoorbeeld als volgt uitzien:
```
az iot edge set-modules --device-id my-device-name --hub-name my-iot-hub-name --content deployment.amd64.debug.json
```
Nadat u de opdracht hebt uitgevoerd, ziet u een bevestiging van de implementatie in JSON de opdrachtprompt.

Docker-installatiekopieën bouwen

Zodra u uw module hebt ontwikkeld, kunt u de module-installatiekopieën bouwen om op te slaan in een containerregister voor implementatie op uw IoT Edge-apparaat.

Gebruik het Dockerfile van de module om de Docker-moduleinstallatiekopieën te bouwen.

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

Stel dat de opdrachtshell zich in de projectmap bevindt en dat de modulenaam IotEdgeModule1 is. Gebruik de volgende opdrachten om de installatiekopieën voor het lokale register of een Azure-containerregister te maken:

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

Docker-installatiekopieën van pushmodule

Push de module-installatiekopieën naar het lokale register of een containerregister.

docker push <ImageName>

Voorbeeld:

# 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

Implementeer de module op het IoT Edge-apparaat.

Open in Visual Studio het manifestbestand deployment.debug.template.json-implementatie in het hoofdproject. Het implementatiemanifest is een JSON-document waarin de modules worden beschreven die moeten worden geconfigureerd op het beoogde IoT Edge-apparaat. Voordat u gaat implementeren, moet u uw Azure Container Registry-referenties, uw moduleinstallatiekopieën en de juiste createOptions waarden bijwerken. Zie Opties voor het maken van containers configureren voor IoT Edge-modules voor meer informatie over createOption-waarden.

Als u een Azure Container Registry gebruikt om uw moduleinstallatiekopieën op te slaan, moet u uw referenties toevoegen aan deployment.debug.template.json in de edgeAgent-instellingen . Bijvoorbeeld:

"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"
          }
        }
      }
    },
//...

Vervang de waarde van de afbeeldingseigenschap door de naam van de module-installatiekopieën die u naar het register hebt gepusht. Als u bijvoorbeeld een afbeelding hebt gepusht die is getagd myacr.azurecr.io/iotedgemodule1:0.0.1-amd64 voor aangepaste module IotEdgeModule1, vervangt u de waarde van de afbeeldingseigenschap door de tagwaarde.

Voeg de waarde createOptions toe of vervang deze door tekenreeksinhoud voor elk systeem en elke aangepaste module in de implementatiesjabloon.

De installatiekopieën van IotEdgeModule1 en createOptions zijn bijvoorbeeld vergelijkbaar met het volgende:

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

Gebruik de opdracht Azure CLI-setmodules voor IoT Edge om de modules te implementeren in de Azure IoT Hub. Als u bijvoorbeeld de modules wilt implementeren die zijn gedefinieerd in het bestand deployment.debug.amd64.json in IoT Hub my-iot-hub voor het IoT Edge-apparaat, gebruikt u de volgende opdracht:

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

Tip

U vindt uw IoT Hub-verbindingsreeks in Azure Portal onder Azure IoT Hub-beveiligingsinstellingen >>voor gedeeld toegangsbeleid.

De implementatie op uw apparaat bevestigen

Als u wilt controleren of uw IoT Edge-modules zijn geïmplementeerd in Azure, meldt u zich aan bij uw apparaat (of virtuele machine), bijvoorbeeld via SSH of Azure Bastion, en voert u de ioT Edge-lijstopdracht uit.

   iotedge list

U ziet nu een lijst met uw modules die worden uitgevoerd op uw apparaat of virtuele machine.

   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

Fouten opsporen met behulp van Docker Remote SSH

De Docker- en Moby-engines ondersteunen SSH-verbindingen met containers, zodat u code op een extern apparaat kunt koppelen en fouten kunt opsporen met behulp van Visual Studio.

voor Verbinding maken extern naar Docker zijn bevoegdheden op hoofdniveau vereist. Volg de stappen in Docker beheren als een niet-hoofdgebruiker om verbinding met de Docker-daemon op het externe apparaat toe te staan. Wanneer u klaar bent met foutopsporing, wilt u mogelijk uw gebruiker verwijderen uit de Docker-groep.
Volg de stappen om Visual Studio te gebruiken om een proces te koppelen dat wordt uitgevoerd op een Docker-container op uw externe apparaat.
Stel in Visual Studio onderbrekingspunten in uw aangepaste module in.
Wanneer een onderbrekingspunt wordt bereikt, kunt u variabelen inspecteren, code doorlopen en fouten opsporen in uw module.

Volgende stappen

Als u aangepaste modules wilt ontwikkelen voor uw IoT Edge-apparaten, moet u Azure IoT Hub SDK's begrijpen en gebruiken.
Als u de D2C-berichten (device-to-cloud) voor een specifiek IoT Edge-apparaat wilt bewaken, raadpleegt u de zelfstudie: IoT Edge-apparaten bewaken om aan de slag te gaan.