Usar o Visual Studio 2022 para desenvolver e depurar módulos do Azure IoT Edge

2025-06-04

Aplica-se a: IoT Edge 1.5

Importante

O IoT Edge 1.5 LTS é a versão com suporte. O IoT Edge 1.4 LTS atingirá o fim da vida útil em 12 de novembro de 2024. Se você estiver em uma versão anterior, confira Atualizar o IoT Edge.

Este artigo mostra como usar o Visual Studio 2022 para desenvolver, depurar e implantar módulos do Azure IoT Edge personalizados. O Visual Studio 2022 fornece modelos para módulos do IoT Edge escritos em C e C#. As arquiteturas de dispositivo com suporte incluem Windows x64, Linux x64, ARM32 e ARM64 (versão prévia). Para obter mais informações sobre sistemas operacionais, linguagens e arquiteturas com suporte, veja Suporte a linguagens e arquiteturas.

Este artigo inclui etapas para duas ferramentas de desenvolvimento do IoT Edge:

CLI (interface de linha de comando), a ferramenta preferencial para desenvolvimento
Ferramentas do Azure IoT Edge para extensão do Visual Studio (no modo de manutenção)

Use o botão seletor de ferramentas no início para escolher a sua opção de ferramenta para este artigo. Ambas as ferramentas oferecem estes benefícios:

Criar, editar, compilar, executar e depurar soluções e módulos do Azure IoT Edge e no seu computador de desenvolvimento local.
Codifique os módulos da Internet das Coisas do Azure em C ou C# com os benefícios de desenvolvimento do Visual Studio.
Implante sua solução do IoT Edge em um dispositivo IoT Edge por meio do Hub IoT do Azure.

Pré-requisitos

Este artigo presume que você esteja usando uma máquina Windows como seu computador de desenvolvimento.

Instale ou modifique o Visual Studio 2022 no seu computador de desenvolvimento. Escolha as opções de carga de trabalho Desenvolvimento do Azure e Desenvolvimento de área de trabalho com C++.
Baixe e instale o Azure IoT Edge Tools no Visual Studio Marketplace. Use a extensão Ferramentas do Azure IoT Edge para criar e construir sua solução do IoT Edge. A ferramenta de desenvolvimento recomendada é a Ferramenta de Desenvolvimento do Azure IoT Edge para linha de comando (CLI). A extensão inclui os modelos de projeto do Azure IoT Edge usados para criar o projeto do Visual Studio. Você precisa da extensão instalada independentemente da ferramenta de desenvolvimento usada.

Importante

A extensão Azure IoT Edge Tools para VS 2022 está no modo de manutenção. A ferramenta de desenvolvimento recomendada é a Ferramenta de Desenvolvimento do Azure IoT Edge para linha de comando (CLI).

Dica

Se você estiver usando o Visual Studio 2019, baixe e instale as Ferramentas do Azure IoT Edge para VS 2019 no Marketplace do Visual Studio.

Instale o gerenciador de bibliotecas Vcpkg

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

Instale o pacote azure-iot-sdk-c para Windows

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

Baixe e instale um sistema de gerenciamento de contêineres compatível com o Docker em seu computador de desenvolvimento para criar e executar as imagens do módulo. Por exemplo, instale o Docker Community Edition.
Para desenvolver módulos com contêineres do Linux, use um computador Windows que atenda aos requisitos de Desktop do Docker.
Crie um Registro de Contêiner do Azure ou Docker Hub para armazenar as suas imagens de módulo.

Dica

Use um registro local do Docker para protótipos e testes em vez de um registro de nuvem.
Instale a CLI do Azure.
Para testar o módulo em um dispositivo, é necessário um Hub IoT ativo com pelo menos um dispositivo do IoT Edge. Para criar um dispositivo do IoT Edge para teste, crie um no portal do Azure ou com a CLI:
- Criar um no portal do Azure é a maneira mais rápida. No portal do Azure, acesse o recurso do Hub IoT. Selecione Dispositivos no menu Gerenciamento de dispositivos e, em seguida, selecione Adicionar Dispositivo.
  
  Em Criar um dispositivo, nomeie seu dispositivo usando a ID do Dispositivo, verifique o Dispositivo IoT Edge e, em seguida, selecione Salvar no canto inferior esquerdo.
  
  Confirme se o novo dispositivo existe no Hub IoT no menu Dispositivos de gerenciamento > de dispositivos . Para obter mais informações sobre como criar um dispositivo IoT Edge por meio do portal do Azure, consulte Criar e provisionar um dispositivo IoT Edge no Linux usando chaves simétricas.
- Para criar um dispositivo IoT Edge com a CLI, siga as etapas no início rápido para Linux ou Windows. No processo de registro de um dispositivo IoT Edge, crie um dispositivo IoT Edge.
Se estiver executando o daemon do IoT Edge no computador de desenvolvimento, talvez seja necessário interromper o EdgeHub e o EdgeAgent antes de iniciar o desenvolvimento no Visual Studio.

Criar um projeto do Azure IoT Edge

O modelo de projeto do IoT Edge no Visual Studio cria uma solução a ser implantada em dispositivos do IoT Edge. Primeiro, você cria uma solução do Azure IoT Edge. Em seguida, você cria um módulo nessa solução. Cada solução do IoT Edge pode conter mais de um módulo.

Aviso

As ferramentas do Azure IoT Edge para extensão do Visual Studio não têm os modelos de projeto para módulos em C e C#. Se você não puder criar módulos do IoT Edge usando a extensão, use a solução alternativa a seguir.

Baixe os seguintes arquivos e coloque-os no diretório de modelo do Visual Studio listado:

Arquivo de modelo	Adicionar ao diretório
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`

Na nossa solução, vamos criar três projetos. O módulo principal que contém o EdgeAgent e o EdgeHub, além do módulo do sensor de temperatura. Em seguida, você adiciona mais dois módulos do IoT Edge.

Importante

A estrutura do projeto do IoT Edge criada pelo Visual Studio não é a mesma do Visual Studio Code.

Atualmente, a CLI da Ferramenta de Desenvolvimento do Azure IoT Edge não dá suporte à criação do tipo de projeto do Visual Studio. Use a extensão do Visual Studio IoT Edge para criar o projeto do Visual Studio.

No Visual Studio, crie um novo projeto.
Em Criar um novo projeto, procure Azure IoT Edge. Selecione o projeto que corresponde à plataforma e à arquitetura do dispositivo IoT Edge e selecione Avançar.
Em Configurar seu novo projeto, insira um nome para o projeto, especifique o local e selecione Criar.
Em Adicionar Módulo, selecione o tipo de módulo que você deseja desenvolver. Se você tiver um módulo existente que deseja adicionar à sua implantação, selecione Módulo existente.
Em Nome do Módulo, insira um nome para o seu módulo. Escolha um nome exclusivo no registro de contêiner.
Em URL do Repositório, forneça o nome do repositório de imagens do módulo. O Visual Studio preenche automaticamente o nome do módulo com localhost:5000/<nome do seu módulo>. Substitua-o pelas informações de seu registro. Use localhost se você usa um registro local do Docker para testes. Se usar o Registro de Contêiner do Azure, utilize o servidor de início de sessão nas configurações do registro. O servidor de início de seção é semelhante a <nome do registro>.azurecr.io. Apenas substitua a parte da cadeia de caracteres localhost:5000 para que o resultado final se pareça com *<nome do registro>.azurecr.io/<nome do seu módulo>.
Selecione Adicionar para adicionar o módulo ao projeto.

Observação

Para alterar a URL do repositório em um projeto existente do IoT Edge, abra o arquivo module.json . A URL do repositório está na propriedade do repositório do arquivo JSON.

Agora você tem um projeto do IoT Edge e um módulo do IoT Edge em sua solução do Visual Studio.

Estrutura do projeto

Sua solução tem duas pastas no nível do projeto: uma pasta de projeto principal e uma única pasta de módulo. Por exemplo, você pode ter uma pasta de projeto principal chamada AzureIotEdgeApp1 e uma pasta de módulo chamada IotEdgeModule1. A pasta principal do projeto contém o manifesto de implantação.

A pasta de projeto do módulo contém um arquivo de código do módulo, chamado Program.cs ou main.c, dependendo do idioma escolhido. Essa pasta também tem um arquivo chamado module.json que descreve os metadados do módulo. Arquivos diferentes do Docker aqui fornecem as informações necessárias para criar seu módulo como um contêiner do Windows ou do Linux.

Manifesto de implantação do seu projeto

Edite o manifesto de implantação chamado deployment.debug.template.json. Esse arquivo é um modelo de um manifesto de implantação do IoT Edge que define todos os módulos executados em um dispositivo e como eles se comunicam entre si. Para obter mais informações sobre a criação de manifestos de implantação, confira o artigo Saiba como implantar módulos e estabelecer rotas.

Ao abrir esse modelo de implantação, você verá que os dois módulos de runtime, edgeAgent e edgeHub, estão incluídos, juntamente com o módulo personalizado criado neste projeto do Visual Studio. Também está incluído um quarto módulo, chamado SimulatedTemperatureSensor. Este módulo padrão gera dados simulados que você pode usar para testar seus módulos ou excluir se não forem necessários. Para saber como o sensor de temperatura simulado funciona, consulte o código-fonte SimulatedTemperatureSensor.csproj.

Definir versão de runtime do IoT Edge

A versão de runtime estável mais recente é a 1.5. Atualize a versão de runtime do IoT Edge para a versão estável mais recente ou a versão que você deseja direcionar para seus dispositivos.

No Gerenciador de Soluções, clique com o botão direito do mouse no nome do projeto principal e selecione Definir versão de runtime do IoT Edge.
Use o menu suspenso para escolher a versão de runtime que os dispositivos IoT Edge estão executando e, em seguida, selecione OK para salvar as alterações. Se nenhuma alteração foi feita, selecione Cancelar para sair.

A extensão não inclui uma seleção para as versões de runtime mais recentes. Para definir a versão de tempo de execução acima de 1.2, abra o arquivo de manifesto de implantação deployment.debug.template.json. Altere a versão de runtime das imagens do módulo de runtime do sistema edgeAgent e edgeHub. Por exemplo, para usar o runtime do IoT Edge versão 1.5, altere as seguintes linhas no arquivo de manifesto de implantação:
```
"systemModules": {
   "edgeAgent": {
    //...
      "image": "mcr.microsoft.com/azureiotedge-agent:1.5"
    //...
   "edgeHub": {
   //...
      "image": "mcr.microsoft.com/azureiotedge-hub:1.5",
   //...
```
Se você alterou a versão, regenere o manifesto de implantação clicando com o botão direito do mouse no nome do projeto e selecione Gerar implantação para o IoT Edge. Isso gera um manifesto de implantação com base no modelo de implantação e o coloca na pasta de configuração do seu projeto do Visual Studio.

Abra o arquivo de manifesto de implantação deployment.debug.template.json . O manifesto de implantação é um documento JSON que descreve os módulos a serem configurados no dispositivo IoT Edge de destino.
Altere a versão de runtime das imagens do módulo de runtime do sistema edgeAgent e edgeHub. Por exemplo, para usar o runtime do IoT Edge versão 1.5, altere as seguintes linhas no arquivo de manifesto de implantação:
```
"systemModules": {
    "edgeAgent": {
    //...
        "image": "mcr.microsoft.com/azureiotedge-agent:1.5",
    //...
    "edgeHub": {
    //...
        "image": "mcr.microsoft.com/azureiotedge-hub:1.5",
    //...
```

Infraestrutura de módulo e opções de desenvolvimento

Quando você adiciona um novo módulo, ele vem com o código padrão que está pronto para ser compilado e implantado em um dispositivo para que você possa começar a testar sem precisar mexer em códigos. O código do módulo está localizado na pasta do módulo em um arquivo chamado Program.cs (para C#) ou main.c (para C).

A solução padrão é criada de forma que os dados simulados do módulo SimulatedTemperatureSensor sejam roteados para o seu módulo, que usa a entrada e a envia ao Hub IoT.

Quando você estiver pronto para personalizar o modelo de módulo com seu próprio código, use os SDKs do Hub IoT do Azure para criar módulos que atendam às principais necessidades de soluções de IoT, como segurança, gerenciamento de dispositivos e confiabilidade.

Depurar usando o simulador

A ferramenta de desenvolvimento do Azure IoT EdgeHub fornece uma experiência de desenvolvimento e depuração local. A ferramenta ajuda a iniciar módulos do IoT Edge sem o runtime do IoT Edge para que você possa criar, desenvolver, testar, executar e depurar os módulos IoT Edge e soluções localmente. Você não precisa enviar imagens por push para um registro de contêiner e implantá-las em um dispositivo para teste.

Para obter mais informações, consulte a Ferramenta de Desenvolvimento do Azure IoT EdgeHub.

Para inicializar a ferramenta no Visual Studio:

Recupere a cadeia de conexão do dispositivo IoT Edge (encontrada em seu Hub IoT) no portal do Azure ou na CLI do Azure.

Se estiver usando a CLI para recuperar sua cadeia de conexão, use este comando, substituindo "[device_id]" e "[hub_name]" por seus próprios valores:
```
az iot hub device-identity connection-string show --device-id [device_id] --hub-name [hub_name]
```
No menu Ferramentas do Visual Studio, selecione Azure IoT Edge Tools>Configurar o Simulador do IoT Edge.
Cole a cadeia de conexão e selecione OK.

Observação

Siga estas etapas apenas uma vez no computador de desenvolvimento e os resultados serão automaticamente aplicados a todas as soluções do Azure IoT Edge subsequentes. Esse procedimento pode ser seguido novamente se for necessário alterar para uma cadeia de caracteres de conexão diferente.

Compilar e depurar um módulo único

Normalmente, queremos testar/depurar cada módulo antes de colocá-lo em execução dentro de uma solução com vários módulos. A ferramenta simulador de IoT Edge permite que você execute um único módulo isoladamente e envie mensagens pela porta 53000.

Em Gerenciador de Soluções, selecione e realce a pasta do projeto do módulo (por exemplo, IotEdgeModule1). Defina o módulo personalizado como o projeto de inicialização. Selecione Projeto>Definir como Projeto de Inicialização no menu.
Pressione F5 ou selecione o botão Executar na barra de ferramentas para iniciar o simulador do IoT Edge para um único módulo. Pode levar de 10 a 20 segundos inicialmente.
Você deverá ver uma janela de aplicativo de console .NET Core se o módulo tiver sido inicializado com êxito.
Defina um ponto de interrupção para inspecionar o módulo.
- Se estiver desenvolvendo em C#, defina um ponto de interrupção na função PipeMessage() em ModuleBackgroundService.cs.
- Se estiver usando C, defina um ponto de interrupção na InputQueue1Callback() função em main.c.
Teste o módulo enviando uma mensagem. Quando você depura um único módulo, o simulador escuta na porta padrão 53000 em busca de mensagens. Para enviar uma mensagem para o módulo, execute o seguinte comando curl de um shell de comando como Git Bash ou WSL Bash.
```
curl --header "Content-Type: application/json" --request POST --data '{"inputName": "input1","data":"hello world"}' http://localhost:53000/api/v1/messages
```
Se você receber o erro chave/colchete de fechamento sem correspondência na URL, tente usar o seguinte comando como alternativa:
```
curl --header "Content-Type: application/json" --request POST --data "{\"inputName\": \"input1\", \"data\", \"hello world\"}"  http://localhost:53000/api/v1/messages
```
O ponto de interrupção deve ser disparado. Você pode observar variáveis na janela Locais do Visual Studio, encontradas quando o depurador está em execução. Acesse Depurar>Windows>Locais.

Em seu Bash ou shell, você deve ver uma confirmação {"message":"accepted"}.

No console do .NET, você deve ver:
```
IoT Hub module client initialized.
Received message: 1, Body: [hello world]
```
Pressione Ctrl + F5 ou clique no botão Parar para parar a depuração.

Compilar e depurar vários módulos

Após concluir o desenvolvimento de módulo único, pode-se executar e depurar a solução inteira com vários módulos. A ferramenta simulador de IoT Edge permite que você execute todos os módulos definidos no manifesto de implantação, incluindo um edgeHub simulado para roteamento de mensagens. Neste exemplo, você executa dois módulos personalizados e o módulo simulado do sensor de temperatura. As mensagens do módulo simulado do sensor de temperatura são roteadas para cada módulo personalizado.

Em Gerenciador de Soluções, adicione um segundo módulo à solução clicando com o botão direito do mouse na pasta do projeto principal. No menu, selecione Adicionar>Novo módulo do IoT Edge.
Na janela Add module, dê um nome ao novo módulo e substitua a parte localhost:5000 da URL do repositório pelo servidor de logon do Registro de Contêiner do Azure, como você fez antes.
Abra o arquivo deployment.debug.template.json para verificar se foi adicionado o novo módulo na seção de módulos. Também foi adicionada uma nova rota à seção de rotas em EdgeHub para enviar mensagens do novo módulo para o Hub IoT. Para enviar dados do sensor de temperatura simulada para o novo módulo, adicione outra rota com a seguinte linha de JSON. Substitua <NewModuleName> (em dois locais) pelo seu próprio nome de módulo.
```
"sensorTo<NewModuleName>": "FROM /messages/modules/SimulatedTemperatureSensor/outputs/temperatureOutput INTO BrokeredEndpoint(\"/modules/<NewModuleName>/inputs/input1\")"
```
Clique com o botão direito do mouse no projeto principal (por exemplo, AzureIotEdgeApp1) e selecione Definir como Projeto de Inicialização. Definindo o projeto principal como o projeto de inicialização, todos os módulos na solução são executados. Isso inclui os dois módulos que você adicionou à solução, o módulo simulado do sensor de temperatura e o hub simulado do Edge.
Pressione F5 ou selecione o botão Executar na barra de ferramentas para executar a solução. Pode levar de 10 a 20 segundos inicialmente. Verifique se você não tem outros contêineres do Docker em execução que possam associar a porta necessária deste projeto.
Você verá duas janelas do aplicativo de console do .NET Core aparecerem, uma para cada módulo.
Defina um ponto de interrupção para inspecionar os módulos.
- Se estiver desenvolvendo em C#, defina um ponto de interrupção na função PipeMessage() em ModuleBackgroundService.cs.
- Se estiver usando C, defina um ponto de interrupção na InputQueue1Callback() função em main.c.
Crie pontos de interrupção em cada módulo e pressione F5 para executar e depurar vários módulos simultaneamente. Você deve ver as janelas do aplicativo do console .NET Core, com cada janela representando um módulo diferente.
Pressione Ctrl + F5 ou clique no botão Parar para parar a depuração.

Criar e enviar imagens por push para o Registro

Depois de desenvolver e depurar o módulo, compile e envie a imagem do módulo por push para o Registro de Contêiner do Azure. Em seguida, implante o módulo em seu dispositivo IoT Edge.

Defina o projeto principal do IoT Edge como projeto de inicialização, e não um dos módulos individuais.
Selecione a configuração Depurar ou Versão para suas imagens de módulo serem construídas.

Observação

Quando você escolhe Depurar, o Visual Studio usa Dockerfile.(amd64|windows-amd64).debug para criar imagens do Docker. Isso inclui o VSDBG do depurador de linha de comando do .NET Core em sua imagem de contêiner. Para módulos do IoT Edge prontos para produção, use a configuração Release, que utiliza Dockerfile.(amd64|windows-amd64) sem VSDBG.
Se você usar um registro privado como o ACR (Registro de Contêiner do Azure), use o seguinte comando do Docker para entrar. Obtenha o nome de usuário e a senha na página de Access keys do seu registro no portal do Azure.
```
docker login <ACR login server>
```
Adicione as informações de logon do Registro de Contêiner do Azure às configurações de runtime no deployment.debug.template.json arquivo. Você pode adicionar suas credenciais do Registro ao .env arquivo (mais seguro) ou adicioná-las diretamente ao seu deployment.debug.template.json arquivo.

Adicionar credenciais ao arquivo .env:

No Gerenciador de Soluções, selecione o botão da barra de ferramentas Mostrar Todos os Arquivos. O arquivo .env é exibido. Adicione o nome de usuário e a senha do Registro de Contêiner do Azure ao arquivo .env. Encontre essas credenciais na página Chaves de Acesso do Registro de Contêiner do Azure no portal do Azure.
```
    DEFAULT_RT_IMAGE=1.2
    CONTAINER_REGISTRY_USERNAME_myregistry=<my-registry-name>
    CONTAINER_REGISTRY_PASSWORD_myregistry=<my-registry-password>
```
Adicione as credenciais diretamente a deployment.debug.template.json

Se você quiser adicionar suas credenciais diretamente ao modelo de implantação, substitua os espaços reservados pelo nome de usuário, senha e nome do registro do administrador do ACR.
```
      "settings": {
        "minDockerVersion": "v1.25",
        "loggingOptions": "",
        "registryCredentials": {
          "registry1": {
            "username": "<username>",
            "password": "<password>",
            "address": "<registry name>.azurecr.io"
          }
        }
      }
```
Observação

Este artigo usa as credenciais de logon do administrador do Registro de Contêiner do Azure, que são convenientes em cenários de desenvolvimento e teste. Se você está pronto para cenários de produção, recomendamos uma opção de autenticação de privilégios mínimos, como entidades de serviço. Para obter mais informações, confira Gerenciar o acesso ao registro de contêiner.
Se você usar um registro local, execute um registro local.
Por fim, no Gerenciador de Soluções, clique com o botão direito do mouse na pasta do projeto principal e selecione Compilar e Efetuar Push de Módulos do IoT Edge para compilar e efetuar push da imagem Docker para cada módulo. Isto pode demorar um minuto. Quando aparecer Finished Build and Push IoT Edge Modules. no seu console de Saída do Visual Studio, você estará pronto.

Implantar a solução

Agora que você criou e enviou as imagens do módulo para o Azure Container Registry, implante a solução em seu dispositivo IoT Edge. Você já tem um modelo de manifesto de implantação neste tutorial. Gere um manifesto de implantação dele e use um comando da CLI do Azure para implantar seus módulos em seu dispositivo IoT Edge no Azure.

Clique com o botão direito do mouse no projeto principal no Gerenciador de Soluções do Visual Studio e escolha Gerar Implantação para IoT Edge.
Acesse a pasta do projeto principal do Visual Studio local e examine a pasta config. O caminho completo pode ter a seguinte aparência: C:\Users\<YOUR-USER-NAME>\source\repos\<YOUR-IOT-EDGE-PROJECT-NAME>\config. Aqui, você encontrará o manifesto de implantação gerado, como deployment.amd64.debug.json.
Abra o deployment.amd64.debug.json arquivo e confirme se a versão do edgeHub esquema está definida como 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
       }
     }
   }
```
Dica

O modelo de implantação para Visual Studio 2022 requer a versão do esquema 1.2. Se você precisar que seja 1.1 ou 1.0, aguarde até que a implantação seja gerada (não a altere no deployment.debug.template.json). A geração de uma implantação cria um esquema 1.2 por padrão. No entanto, você pode alterar deployment.amd64.debug.json manualmente, o manifesto gerado, se necessário antes de implantá-lo no Azure.

Importante

Depois que o dispositivo IoT Edge for implantado, ele não será exibido corretamente no portal do Azure com o esquema versão 1.2 (a versão 1.1 está bem). No entanto, isso não afetará seu dispositivo, pois ele ainda está conectado no Hub IoT e pode ser comunicado a qualquer momento usando a CLI do Azure.
Agora, vamos implantar nosso manifesto com um comando da CLI do Azure. Abra o Prompt de Comando do Desenvolvedor do Visual Studio e altere para o diretório config.
```
    cd config
```
Implante o manifesto do dispositivo IoT Edge no Hub IoT. O comando configura o dispositivo para usar módulos desenvolvidos em sua solução. O manifesto de implantação foi criado na etapa anterior e armazenado na pasta config. Na pasta config, execute o comando de implantação a seguir. Substitua [device id], [hub name] e [file path] pelos seus valores. Se a ID do dispositivo do IoT Edge não existir no Hub IoT, deverá ser criada.
```
    az iot edge set-modules --device-id [device id] --hub-name [hub name] --content [file path]
```
Por exemplo, o comando pode ter esta aparência:
```
az iot edge set-modules --device-id my-device-name --hub-name my-iot-hub-name --content deployment.amd64.debug.json
```
Depois de executar o comando, você verá uma confirmação da implantação impressa no JSON no prompt de comando.

Criar imagem do Docker do módulo

Depois de desenvolver o módulo, crie a imagem do módulo para armazenar em um registro de contêiner para implantação em seu dispositivo IoT Edge.

Use o Dockerfile do módulo para criar a imagem do Docker do módulo.

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

Por exemplo, se o shell de comando estiver no diretório do projeto e o nome do módulo for IotEdgeModule1, use os seguintes comandos para criar a imagem para o registro local ou um Registro de Contêiner do Azure:

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

Enviar por push a imagem do Docker do módulo

Envie a imagem do módulo por push para o registro local ou para um registro de contêiner.

docker push <ImageName>

Por exemplo:

# 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

Implante o módulo no dispositivo IoT Edge.

No Visual Studio, abra o arquivo de manifesto de implantação deployment.debug.template.json no projeto principal. O manifesto de implantação é um documento JSON que descreve os módulos a serem configurados nos dispositivos IoT Edge de destino. Antes da implantação, você precisa atualizar as credenciais do Registro de Contêiner do Azure e as imagens do seu módulo com os valores de createOptions adequados. Para obter mais informações sobre os valores de createOption, confira Como configurar opções de criação de contêiner para módulos do IoT Edge.

Se você estiver usando um Registro de Contêiner do Azure para armazenar a imagem do módulo, precisará adicionar as credenciais a deployment.debug.template.json nas configurações do edgeAgent. Por exemplo,

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

Substitua o valor da propriedade da imagem pelo nome da imagem do módulo enviado por push para o Registro. Por exemplo, se você efetuou push de uma imagem marcada com myacr.azurecr.io/iotedgemodule1:0.0.1-amd64 para o módulo personalizado IotEdgeModule1, substitua o valor da propriedade da imagem pelo valor da marca.

Adicione ou substitua o valor createOptions pelo conteúdo em cadeia de caracteres para cada sistema e módulo personalizado no modelo de implantação.

Por exemplo, as configurações de imagem e createOptions do IotEdgeModule1 seriam semelhantes às seguintes:

"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 o comando set-modules da CLI do Azure IoT Edge para implantar os módulos no Azure IoT Hub. Por exemplo, para implantar os módulos definidos no arquivo deployment.debug.amd64.json no Hub IoT my-iot-hub para o dispositivo IoT Edge my-device, execute o seguinte 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>"

Dica

Localize a cadeia de conexão do Hub IoT no portal do Azure, sob a seção de configurações de segurança do Azure IoT Hub >Configurações de segurança>Políticas de acesso compartilhado.

Confirmar a implantação no dispositivo

Para verificar se os módulos do IoT Edge foram implantados no Azure, conecte-se ao dispositivo (ou à máquina virtual), por exemplo, por meio do SSH ou do Azure Bastion, e execute o comando de lista do IoT Edge.

   iotedge list

Você deve ver uma lista dos módulos em execução no dispositivo ou na 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

Depurar usando o SSH remoto do Docker

Os mecanismos do Docker e do Moby dão suporte a conexões SSH com contêineres, permitindo que você anexe e depure o código em um dispositivo remoto usando o Visual Studio.

A conexão remota com o Docker exige privilégios de nível raiz. Siga as etapas em Gerenciar o Docker como usuário não raiz para permitir a conexão com o daemon do Docker no dispositivo remoto. Quando terminar a depuração, talvez você queira remover seu usuário do grupo do Docker.
Siga as etapas para usar o Visual Studio para Anexar a um processo em execução em um contêiner do Docker no seu dispositivo remoto.
No Visual Studio, defina pontos de interrupção no seu módulo personalizado.
Quando um ponto de interrupção é atingido, você pode inspecionar variáveis, percorrer o código e depurar o seu módulo.

Próximas etapas

Para desenvolver módulos padronizados para seus dispositivos do IoT Edge, consulte Entender e usar os SDKs de Hub IoT do Azure.
Para monitorar as mensagens D2C (dispositivo para nuvem) de um dispositivo IoT Edge específico, examine o Tutorial: monitorar dispositivos IoT Edge para começar.