Uso de Visual Studio 2022 para desarrollar y depurar módulos para Azure IoT Edge

Artículo
04/11/2024

Se aplica a: IoT Edge 1.5 IoT Edge 1.4

Importante

IoT Edge 1.5 LTS e IoT Edge 1.4 LTS se versiones compatibles. IoT Edge 1.4 LTS finaliza el ciclo de vida el 12 de noviembre de 2024. Si está usando una versión anterior, consulte Actualización de IoT Edge.

En este artículo se explica cómo se usa Visual Studio 2022 para desarrollar, depurar e implementar módulos Azure IoT Edge personalizados. Visual Studio 2022 proporciona plantillas para módulos IoT Edge escritos en C y C#. Las arquitecturas de dispositivo compatibles son Windows x64, Linux x64, ARM32 y ARM64 (versión preliminar). Para obtener más información sobre los sistemas operativos, los lenguajes y las arquitecturas compatibles, consulte Compatibilidad de lenguaje y arquitectura.

En este artículo se incluyen los pasos para dos herramientas de desarrollo de IoT Edge.

La interfaz de la línea de comandos (CLI) es la herramienta preferida para el desarrollo.
Extensión de Herramientas de Azure IoT Edge para Visual Studio. La extensión está en modo de mantenimiento.

Use el botón del selector de la herramienta al principio para elegir la opción de herramienta de este artículo. Las dos herramientas ofrecen las ventajas siguientes:

Creación, edición, compilación y ejecución de soluciones y módulos de IoT Edge en su equipo de desarrollo local.
Programación de los módulos de Azure IoT en C o C# con las ventajas de desarrollo en Visual Studio.
Implementación de la solución de IoT Edge en un dispositivo de IoT Edge mediante Azure IoT Hub.

Requisitos previos

En este artículo se da por hecho que usa una máquina que ejecuta Windows como máquina de desarrollo.

Instalación o modificación de Visual Studio 2022 en la máquina de desarrollo. Elección de las opciones desarrollo de Azure y desarrollo de escritorio con cargas de trabajo de C++.
Descargue e instale Azure IoT Edge Tools desde Visual Studio Marketplace. Puede usar la extensión Azure IoT Edge Tools para crear y compilar la solución de IoT Edge. La herramienta de desarrollo preferida es la línea de comandos (CLI) Azure IoT Edge Dev Tool. La extensión incluye las plantillas de proyecto de Azure IoT Edge que se usan para crear el proyecto de Visual Studio. Actualmente, necesita la extensión instalada independientemente de la herramienta de desarrollo que use.

Importante

La extensión Azure IoT Edge Tools for VS 2022está en modo de mantenimiento. La herramienta de desarrollo preferida es la línea de comandos (CLI) Azure IoT Edge Dev Tool.

Sugerencia

Si usa Visual Studio 2019, descargue e instale Herramientas de Azure IoT Edge Tools for VS 2019 desde Visual Studio Marketplace.

Instale el administrador de bibliotecas Vcpkg

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

Instale el paquete azure-iot-sdk-c para Windows

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

Descargue e instale un sistema de administración de contenedores compatible con Docker en la máquina de desarrollo para implementar y ejecutar las imágenes de los módulos. Por ejemplo, instale Docker Community Edition.
Para desarrollar módulos con contenedores de Linux, use un equipo Windows que cumpla los requisitos de Docker Desktop.
Cree un Azure Container Registry o Docker Hub para almacenar las imágenes de los módulos.

Sugerencia

Puede usar un registro de Docker local con fines de prototipo y prueba en lugar de un registro en la nube.
Instale la CLI de Azure.
Para probar el módulo en un dispositivo, necesita una instancia de IoT Hub activa con al menos un dispositivo IoT Edge. Para crear un dispositivo IoT Edge para realizar pruebas, puede crear uno en Azure Portal o con la CLI:
- La creación de uno en Azure Portal es el método más rápido. En Azure Portal, vaya hasta su recurso de IoT Hub. Seleccione Dispositivos en el menú Administración de dispositivos y, luego, elija Agregar dispositivo.
  
  En Crear un dispositivo, asigne un nombre al dispositivo mediante Id. de dispositivo, active Dispositivo IoT Edge y, luego, elija Guardar en la parte inferior izquierda.
  
  Por último, confirme que el nuevo dispositivo existe en su IoT Hub, en el menú Administración de dispositivos > Dispositivos. Para más información sobre cómo crear un dispositivo IoT Edge a través del Azure Portal, lea Creación y aprovisionamiento de un dispositivo IoT Edge en Linux mediante claves simétricas.
- Para crear un dispositivo IoT Edge con la CLI, siga los pasos descritos en el inicio rápido para Linux o Windows. En el proceso de registrar un dispositivo IoT Edge, se crea un dispositivo IoT Edge.
Si ejecuta el demonio de IoT Edge en una máquina de desarrollo, es posible que deba detener EdgeHub y EdgeAgent para empezar el desarrollo en Visual Studio.

Creación de un proyecto de Azure IoT Edge

La plantilla de proyecto de IoT Edge en Visual Studio crea una solución para que se implemente en dispositivos IoT Edge. En primer lugar, cree una solución de Azure IoT Edge. A continuación, creará un módulo en esa solución. Cada solución de IoT Edge puede contener más de un módulo.

En nuestra solución se van a compilar tres proyectos. El módulo principal que contiene EdgeAgent y EdgeHub, además del módulo del sensor de temperatura. A continuación, agregará dos módulos de IoT Edge más.

Importante

La estructura del proyecto de IoT Edge creada por Visual Studio no es la misma que la de Visual Studio Code.

Actualmente, la CLI de la herramienta de desarrollo de Azure IoT Edge no admite la creación del tipo de proyecto de Visual Studio. Debe usar la extensión de IoT Edge de Visual Studio para crear el proyecto de Visual Studio.

En Visual Studio, cree un nuevo proyecto.
En Crear un proyecto, busque Azure IoT Edge. Seleccione el proyecto que coincida con la plataforma y la arquitectura del dispositivo IoT Edge y seleccione Siguiente.
En Configurar el nuevo proyecto, escriba un nombre para el proyecto, especifique la ubicación y seleccione Crear.
En Agregar módulo, seleccione el tipo de módulo que quiere desarrollar. Si desea agregar un módulo existente a la implementación, seleccione Módulo existente.
En Nombre del módulo, escriba un nombre para el módulo. Elija un nombre que sea único dentro del registro de contenedor.
En Url del repositorio, proporcione el nombre del repositorio de la imagen del módulo. Visual Studio completa automáticamente el nombre del módulo como localhost:5000/< nombre de módulo>. Reemplácelo por su propia información de registro. Utilice localhost si usa un registro de Docker local para realizar pruebas. Si va a usar Azure Container Registry, utilice el servidor de inicio de sesión de la configuración del registro. El servidor de inicio de sesión se parece a <nombre del registro>.azurecr.io. Reemplace solo la sección localhost:5000 de la cadena para que el resultado final se parezca a <nombre del registro>.azurecr.io/ <nombre del módulo> .
Seleccione Agregar para agregar el módulo al proyecto.

Nota:

Si tiene un proyecto de IoT Edge existente, puede cambiar la dirección URL del repositorio al abrir el archivo module.json. La dirección URL del repositorio se encuentra en la propiedad repository del archivo JSON.

Ahora tiene un proyecto y un módulo de IoT Edge en la solución Visual Studio.

Estructura de proyecto

En su solución, hay dos carpetas del nivel de proyecto, entre las que se incluye una carpeta de proyecto principal y una única carpeta de módulo. Por ejemplo, puede tener una carpeta de proyecto principal denominada AzureIotEdgeApp1 y una carpeta de módulo denominada IotEdgeModule1. La carpeta principal del proyecto contiene el manifiesto de implementación.

La carpeta del proyecto del módulo contiene un archivo para el código del módulo, denominado Program.cs o main.c según el lenguaje que haya elegido. Esta carpeta también contiene un archivo denominado module.json que describe los metadatos del módulo. Varios archivos de Docker, que se incluyen aquí, proporcionan la información necesaria para crear el módulo como un contenedor de Windows o Linux.

Manifiesto de implementación del proyecto

El manifiesto de implementación que edita se denomina deployment.debug.template.json. Este archivo es una plantilla de un manifiesto de implementación de IoT Edge, que define todos los módulos que se ejecutan en un dispositivo y cómo se comunican entre sí. Para más información sobre los manifiestos de implementación, consulte Obtenga información sobre cómo implementar módulos y establecer rutas.

Si abre esta plantilla de implementación, podrá ver que los dos módulos del entorno de ejecución, edgeAgent y edgeHub están incluidos, junto con el módulo personalizado que creó en este proyecto de Visual Studio. Un cuarto módulo, denominado SimulatedTemperatureSensor también está incluido. Este módulo predeterminado es el que genera los datos simulados que puede usar para probar los módulos o eliminar si no es necesario. Para ver cómo funciona el sensor de temperatura simulado, vea el código fuente de SimulatedTemperatureSensor.csproj.

Establecimiento de la versión del entorno de ejecución de IoT Edge

Actualmente, la versión del entorno de ejecución estable más reciente es 1.5. Debe actualizar la versión del entorno de ejecución de IoT Edge a la versión estable más reciente o la que desea como destino de los dispositivos.

En el Explorador de soluciones, haga clic con el botón derecho en el nombre del proyecto principal y seleccione Establecer la versión del entorno de ejecución de Azure IoT Edge.
Use el menú desplegable para elegir la versión del entorno de ejecución en la que se ejecutan los dispositivos IoT Edge y, a continuación, seleccione Aceptar para guardar los cambios. Si no se realizó ningún cambio, seleccione Cancelar para salir.

Actualmente, la extensión no incluye una selección para las versiones más recientes del entorno de ejecución. Si desea establecer la versión en tiempo de ejecución superior a la 1.2, abra el archivo de manifiesto de implementación deployment.debug.template.json. Cambie la versión en tiempo de ejecución de las imágenes edgeAgent y edgeHub del módulo en tiempo de ejecución del sistema. Por ejemplo, si quiere usar la versión 1.5 del entorno de ejecución de IoT Edge, cambie las líneas siguientes en el archivo de manifiesto de implementación:
```
"systemModules": {
   "edgeAgent": {
    //...
      "image": "mcr.microsoft.com/azureiotedge-agent:1.5"
    //...
   "edgeHub": {
   //...
      "image": "mcr.microsoft.com/azureiotedge-hub:1.5",
   //...
```
Si ha cambiado la versión, vuelva a generar el manifiesto de implementación; para ello, haga clic con el botón derecho en el nombre del proyecto y seleccione Generar implementación para IoT Edge. Esto genera un manifiesto de implementación basado en la plantilla de implementación y aparece en la carpeta config del proyecto de Visual Studio.

Abra el archivo de manifiesto de implementación deployment.debug.template.json. El manifiesto de implementación es un documento JSON que describe los módulos que se van a configurar en los dispositivos IoT Edge de destino.
Cambie la versión en tiempo de ejecución de las imágenes edgeAgent y edgeHub del módulo en tiempo de ejecución del sistema. Por ejemplo, si quiere usar la versión 1.5 del entorno de ejecución de IoT Edge, cambie las líneas siguientes en el archivo de manifiesto de implementación:
```
"systemModules": {
    "edgeAgent": {
    //...
        "image": "mcr.microsoft.com/azureiotedge-agent:1.5",
    //...
    "edgeHub": {
    //...
        "image": "mcr.microsoft.com/azureiotedge-hub:1.5",
    //...
```

Opciones de infraestructura y desarrollo de módulos

Al agregar un nuevo módulo, este viene con un código predeterminado que está listo para crearse e implementarse en un dispositivo para que pueda empezar a realizar pruebas sin tener que modificar ningún código. El código del módulo se encuentra en la carpeta del módulo en un archivo denominado Program.cs (para C#) o main.c (para C).

La solución predeterminada se ha creado para que los datos simulados del módulo SimulatedTemperatureSensor se enruten hacia el módulo, el cual recibe la entrada y, a continuación, la envía a IoT Hub.

Cuando tenga todo listo para personalizar la plantilla del módulo con su propio código, use los SDK de Azure IoT Hub para compilar módulos que aborden las necesidades principales de las soluciones de IoT, como la seguridad, la administración de dispositivos y la fiabilidad.

Depuración mediante el simulador

La herramienta de desarrollo de Azure IoT EdgeHub proporciona una experiencia de desarrollo y depuración local. La herramienta ayuda a iniciar los módulos IoT Edge sin el runtime de IoT Edge para que pueda crear, desarrollar, probar, ejecutar y depurar módulos y soluciones de IoT Edge de forma local. Para realizar las pruebas, no es necesario insertar imágenes en un registro de contenedor e implementarlas en un dispositivo.

Para más información, consulte el artículo sobre la herramienta de desarrollo de Azure IoT EdgeHub.

Para inicializar la herramienta en Visual Studio:

Recupere la cadena de conexión del dispositivo IoT Edge (que se encuentra en su IoT Hub) desde Azure Portal o desde la CLI de Azure.

Si usa la CLI para recuperar la cadena de conexión, use este comando, reemplazando "[device_id]" y "[hub_name]" por sus propios valores:
```
az iot hub device-identity connection-string show --device-id [device_id] --hub-name [hub_name]
```
Vaya al menú Herramientas en Visual Studio, seleccione Azure IoT Edge Tools>Configurar el simulador de IoT Edge.
Pegue la cadena de conexión y seleccione Aceptar.

Nota:

Debe seguir estos pasos solo una vez en el equipo de desarrollo, ya que los resultados se aplican automáticamente a todas las soluciones de Azure IoT Edge posteriores. Puede realizar nuevamente este procedimiento si necesita cambiar a una cadena de conexión diferente.

Compilación y depuración de un solo módulo

Normalmente, quiere probar y depurar cada módulo antes de ejecutarlo dentro de una solución completa con varios módulos. La herramienta de simulador de IoT Edge permite ejecutar un único módulo de forma aislada y enviar mensajes a través del puerto 53000.

En Explorador de soluciones, seleccione y resalte la carpeta del proyecto del módulo (por ejemplo, IotEdgeModule1). Defina el módulo personalizado como el proyecto de inicio. Seleccione Proyecto>Establecer como proyecto de inicio del menú.
Pulse F5 o seleccione el botón ejecutar barra de herramientas para iniciar el simulador de IoT Edge para un único módulo. Puede tardar inicialmente entre 10 y 20 segundos.
Si el módulo se inicializa correctamente, debe ver que aparece una ventana de la aplicación de consola de .NET Core.
Establezca un punto de interrupción para inspeccionar el módulo.
- Si desarrolla en C#, establezca un punto de interrupción en la función PipeMessage() de ModuleBackgroundService.cs.
- Si usa C, establezca un punto de interrupción en la función InputQueue1Callback() de InputQueue1Callback().
Haga una prueba al módulo enviando un mensaje. Al depurar un solo módulo, el simulador escucha en el puerto predeterminado 53000 para los mensajes. Para enviar un mensaje al módulo, ejecute el siguiente comando curl desde un shell de comandos como Git Bash o WSL Bash.
```
curl --header "Content-Type: application/json" --request POST --data '{"inputName": "input1","data":"hello world"}' http://localhost:53000/api/v1/messages
```
Si recibe el error sin coincidencia de llave o corchete en la dirección URL, en su lugar, pruebe el siguiente comando:
```
curl --header "Content-Type: application/json" --request POST --data "{\"inputName\": \"input1\", \"data\", \"hello world\"}"  http://localhost:53000/api/v1/messages
```
Debe desencadenarse el punto de interrupción. Puede ver las variables en la ventana Variables locales de Visual Studio, que se encuentran cuando se ejecuta el depurador. Vaya a Depurar>Windows>Locales.

En bash o shell, debería ver una confirmación {"message":"accepted"}.

En la consola de .NET debería ver:
```
IoT Hub module client initialized.
Received message: 1, Body: [hello world]
```
Sugerencia

También puede usar PostMan u otras herramientas de API para enviar mensajes en lugar de curl.
Presione Ctrl + F5 o seleccione el botón Detener para detener la depuración.

Creación y depuración de varios módulos

Cuando haya terminado de desarrollar el módulo, querrá ejecutar y depurar una solución completa de varios módulos. Mediante la herramienta de simulador IoT Edge es posible ejecutar todos los módulos definidos en el manifiesto de implementación, entre los que se incluyen un edgeHub simulado para enrutar mensajes. En este ejemplo, ejecutará dos módulos personalizados y el módulo del sensor de temperatura simulado. Los mensajes del módulo del sensor de temperatura simulado se enrutan a cada módulo personalizado.

En el Explorador de soluciones, agregue un segundo módulo a la solución haciendo clic con el botón derecho en la carpeta del proyecto. En el menú, seleccione Agregar>New IoT Edge Module (Nuevo módulo de IoT Edge).
En la ventana Add module, asigne un nombre al nuevo módulo y reemplace la parte localhost:5000 de la dirección URL del repositorio por el servidor de inicio de sesión de Azure Container Registry, como hizo antes.
Abra el archivo deployment.debug.template.json para ver que el nuevo módulo se ha agregado a la sección modules. También se ha agregado una nueva ruta a la sección routes en EdgeHub para enviar mensajes desde el nuevo módulo a IoT Hub. Para enviar datos desde el sensor de temperatura simulado al nuevo módulo, agregue otra ruta con la línea siguiente de JSON. Reemplace <NewModuleName> (en dos lugares) por el nombre de su propio módulo.
```
"sensorTo<NewModuleName>": "FROM /messages/modules/SimulatedTemperatureSensor/outputs/temperatureOutput INTO BrokeredEndpoint(\"/modules/<NewModuleName>/inputs/input1\")"
```
Haga clic con el botón derecho en el proyecto principal, (por ejemplo, AzureIotEdgeApp1) y seleccione Establecer como proyecto de inicio. Al establecer el proyecto principal como el de inicio, se ejecutan todos los módulos de la solución. Esto incluye ambos módulos que ha agregado a la solución, el módulo de sensor de temperatura simulado y el centro simulado de Edge.
Pulse F5 o seleccione el botón de la barra de herramientas de ejecutar para ejecutar la solución. Puede tardar inicialmente entre 10 y 20 segundos. Asegúrese de que no tiene otros contenedores de Docker en ejecución que puedan enlazar el puerto que necesita para este proyecto.
Debería ver dos ventanas de aplicación de .NET Core, una para cada módulo.
Establezca un punto de interrupción para inspeccionar el módulo.
- Si desarrolla en C#, establezca un punto de interrupción en la función PipeMessage() de ModuleBackgroundService.cs.
- Si usa C, establezca un punto de interrupción en la función InputQueue1Callback() de InputQueue1Callback().
Cree puntos de interrupción en cada módulo y luego presione F5 para ejecutar y depurar varios módulos a la vez. Verá varias ventanas de aplicación de consola de .NET Core; cada una de ellas representa un módulo distinto.
Presione Ctrl + F5 o seleccione el botón Detener para detener la depuración.

Compilación e inserción de imágenes en el registro

Después de desarrollar y depurar el módulo, puede compilar e insertar la imagen del módulo en el Azure Container Registry. A continuación puede implementar el módulo en el dispositivo IoT Edge.

Establezca que el proyecto de IoT Edge sea el proyecto de inicio, no uno de los módulos individuales.
Seleccione Depurar o Versión como configuración para compilar las imágenes del módulo.

Nota:

Al elegir Depurar, Visual Studio usará Dockerfile.(amd64|windows-amd64).debug para compilar las imágenes de Docker. Esto incluye el depurador de la línea de comandos de .NET Core VSDBG en la imagen de contenedor al realizar la compilación. Para los módulos de IoT Edge listos para producción, se recomienda usar la configuración de Versión que usa Dockerfile.(amd64|windows-amd64) sin VSDBG.
Si usa un registro privado como Azure Container Registry (ACR), use el siguiente comando de Docker para iniciar sesión en él. Puede obtener el nombre de usuario y la contraseña en la página Claves de acceso del registro en Azure Portal.
```
docker login <ACR login server>
```
Vamos a agregar la información de inicio de sesión de Azure Container Registry a la configuración del entorno de ejecución que se encuentra en el archivo deployment.debug.template.json. Existen dos formas de hacerlo. Puede agregar las credenciales del Registro al archivo .env (más seguro) o agregarlas directamente al archivo deployment.debug.template.json.

Agregue las credenciales al archivo .env:

En Explorador de soluciones,seleccione el botón de la barra de herramientas Mostrar todos los archivos. Aparece el archivo .env. Agregue su nombre de usuario y contraseña de Azure Container Registry al archivo .env. Estas credenciales se pueden encontrar en la página Claves de acceso de Azure Container Registry en Azure Portal.
```
    DEFAULT_RT_IMAGE=1.2
    CONTAINER_REGISTRY_USERNAME_myregistry=<my-registry-name>
    CONTAINER_REGISTRY_PASSWORD_myregistry=<my-registry-password>
```
Adición de credenciales de forma directa a deployment.debug.template.json

Si prefiere agregar las credenciales directamente a la plantilla de implementación, reemplace los marcadores de posición por el nombre de usuario de administrador de ACR, la contraseña y el nombre del registro.
```
      "settings": {
        "minDockerVersion": "v1.25",
        "loggingOptions": "",
        "registryCredentials": {
          "registry1": {
            "username": "<username>",
            "password": "<password>",
            "address": "<registry name>.azurecr.io"
          }
        }
      }
```
Nota:

En este artículo se usan credenciales de inicio de sesión de administrador de Azure Container Registry, que son prácticas para escenarios de desarrollo y pruebas. Cuando esté listo para escenarios de producción, se recomienda una opción de autenticación con privilegios mínimos, como las entidades de servicio. Para obtener más información, vea Administración del acceso al registro de contenedor.
Si usa un registro local, puede ejecutar un registro local.
Por último, en el Explorador de soluciones, haga clic con el botón derecho en la carpeta del proyecto principal y seleccione Compilación e inserción de módulos IoT Edge para compilar e insertar la imagen de Docker para cada módulo. Esta operación puede tardar un minuto. Cuando vea Finished Build and Push IoT Edge Modules. en la consola de salida de Visual Studio, ya habrá terminado.

Implementación de la solución

Ahora que ha creado e insertado las imágenes del módulo en Azure Container Registry, puede implementar la solución en el dispositivo IoT Edge. Ya tiene una plantilla de manifiesto de implementación que ha estado observando en este tutorial. Vamos a generar un manifiesto de implementación a partir de eso y, a continuación, usaremos un comando de la CLI de Azure para implementar los módulos en el dispositivo IoT Edge en Azure.

Haga clic con el botón derecho en el proyecto principal en el Explorador de soluciones de Visual Studio y elija Generar implementación para IoT Edge.
Vaya a la carpeta local del proyecto principal de Visual Studio y busque en la carpeta config. La ruta de acceso del archivo podría tener el aspecto siguiente: C:\Users\<YOUR-USER-NAME>\source\repos\<YOUR-IOT-EDGE-PROJECT-NAME>\config. Aquí encontrará el manifiesto de implementación generado, como deployment.amd64.debug.json.
Compruebe el archivo deployment.amd64.debug.json para confirmar que la versión del esquema edgeHub está establecida en 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
       }
     }
   }
```
Sugerencia

La plantilla de implementación para Visual Studio 2022 requiere la versión 1.2 del esquema. Si necesita que sea 1.1 o 1.0, espere hasta que se genere la implementación (no lo cambie en deployment.debug.template.json). La generación de una implementación creará un esquema 1.2 de forma predeterminada. Sin embargo, puede cambiar manualmente deployment.amd64.debug.json, el manifiesto generado, si es necesario, antes de implementarlo en Azure.

Importante

Una vez implementado el dispositivo IoT Edge, actualmente no se mostrará de forma correcta en Azure Portal con la versión 1.2 del esquema (pero sí con la versión 1.1). Se trata de un error conocido y se corregirá próximamente. Sin embargo, no afectará al dispositivo, ya que todavía está conectado en IoT Hub y se puede establecer comunicación con él en cualquier momento mediante la CLI de Azure.
Ahora vamos a implementar nuestro manifiesto con un comando de la CLI de Azure. Abra el Símbolo del sistema para desarrolladores de Visual Studio y vaya al directorio config.
```
    cd config
```
Implemente el manifiesto del dispositivo IoT Edge en IoT Hub. El comando configura el dispositivo para usar módulos que se desarrollan en la solución. El manifiesto de implementación se creó en el paso anterior y se almacenó en la carpeta config. En la carpeta config, ejecute el siguiente comando de implementación. Reemplace [device id], [hub name] y [file path] con sus propios valores. Si el identificador del dispositivo IoT Edge no existe en IoT Hub, deberá crearse.
```
    az iot edge set-modules --device-id [device id] --hub-name [hub name] --content [file path]
```
Por ejemplo, el comando podría tener el siguiente aspecto:
```
az iot edge set-modules --device-id my-device-name --hub-name my-iot-hub-name --content deployment.amd64.debug.json
```
Después de ejecutar el comando, verá una confirmación de la implementación impresa en JSON en el símbolo del sistema.

Imagen de Docker del módulo de compilación

Después de desarrollar el módulo, puede compilar la imagen del módulo para almacenarla en un registro de contenedor para implementar en el dispositivo IoT Edge.

Use el archivo Dockerfile del módulo para compilar la imagen de Docker del módulo.

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

Por ejemplo, supongamos que el shell de comandos se encuentra en el directorio del proyecto y el nombre del módulo es IotEdgeModule1. Para compilar la imagen del registro local o un registro de contenedor de Azure, use los siguientes comandos:

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

Imagen de Docker del módulo de inserción

Inserte la imagen del módulo en el registro local o en un registro de contenedor.

docker push <ImageName>

Por ejemplo:

# 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

Implemente el módulo en el dispositivo de IoT Edge.

En Visual Studio, abra el archivo de manifiesto de implementacióndeployment.debug.template.json del proyecto principal. El manifiesto de implementación es un documento JSON que describe los módulos que se van a configurar en los dispositivos IoT Edge de destino. Antes de la implementación, debe actualizar las credenciales de Azure Container Registry, las imágenes del módulo y los valores de createOptions adecuados. Para más información sobre los valores de createOption, consulte Configuración de las opciones de creación de contenedores para módulos de IoT Edge.

Si usa una instancia de Azure Container Registry para almacenar la imagen del módulo, debe agregar las credenciales a deployment.debug.template.json en la configuración edgeAgent. Por ejemplo,

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

Reemplace el valor de la propiedad image por el nombre de la imagen del módulo que insertó en el registro. Por ejemplo, si insertó una imagen etiquetada myacr.azurecr.io/iotedgemodule1:0.0.1-amd64 para el módulo personalizado IotEdgeModule1, reemplace el valor de propiedad de la imagen por el valor de la etiqueta.

Agregue o reemplace el valor de createOptions por contenido con cadenas para cada sistema y módulo personalizado de la plantilla de implementación.

Por ejemplo, la imagen de IotEdgeModule1 y la configuración createOptions sería similar a la siguiente:

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

Use el comando IoT Edge Azure CLI set-modules para implementar los módulos en Azure IoT Hub. Por ejemplo, para implementar los módulos definidos en el archivo deployment.debug.amd64.json en el centro de IoT my-iot-hub para el dispositivo de IoT Edge my-device, use el siguiente comando:

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

Sugerencia

Puede encontrar la cadena de conexión de IoT Hub en Azure Portal en Azure IoT Hub >Configuración de seguridad>Directivas de acceso compartido.

Confirmación de la implementación en el dispositivo

Para comprobar que los módulos de IoT Edge se implementaron en Azure, inicie sesión en el dispositivo (o máquina virtual), por ejemplo mediante SSH o Azure Bastion, y ejecute el comando list de IoT Edge.

   iotedge list

Debería ver una lista de los módulos que se ejecutan en el dispositivo o la máquina virtual.

   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

Depuración mediante SSH remoto de Docker

Los motores Docker y Moby admiten conexiones SSH a contenedores, lo que permite adjuntar y depurar código en un dispositivo remoto mediante Visual Studio.

Para la conexión remota a Docker se necesitan privilegios a nivel raíz. Siga los pasos descritos en Administración de Docker como usuario no raíz para permitir la conexión con el demonio de Docker en el dispositivo remoto. Cuando haya terminado de depurar, es posible que quiera quitar el usuario del grupo de Docker.
Siga los pasos para usar Visual Studio para asociar un proceso que se ejecuta en un contenedor de Docker en el dispositivo remoto.
En Visual Studio, establezca puntos de interrupción en el módulo personalizado.
Cuando se alcanza un punto de interrupción, puede inspeccionar variables, recorrer el código y depurar el módulo.

Pasos siguientes

Para desarrollar módulos personalizados para los dispositivos IoT Edge, consulte Información y uso de los SDK de Azure IoT Hub.
Para supervisar los mensajes del dispositivo a la nube (D2C) para un dispositivo IoT Edge específico, revise Tutorial: Supervisión de dispositivos IoT Edge para empezar.