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

Artigo
07/17/2024

Aplica-se a: IoT Edge 1.5 IoT Edge 1.4

Importante

O IoT Edge 1.5 LTS e o IoT Edge 1.4 LTS são versões com suporte. O IoT Edge 1.4 LTS chegará ao 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 são 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 IoT Edge.

A CLI (interface de linha de comando) é a ferramenta preferencial para desenvolvimento.
Extensão Azure IoT Edge Tools para Visual Studio. A extensão está 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 os seguintes 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.
Implantar a solução do Azure IoT Edge no dispositivo do Azure 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. Você pode usar a extensão Azure IoT Edge Tools para criar e compilar 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. Atualmente, 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 estiver usando o Visual Studio 2019, baixe e instale o Azure IoT Edge Tools 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

Você pode usar um registro do Docker local, em vez de um registro em nuvem, para fins de protótipo e teste.
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 IoT Edge para teste, é possível criar um no portal do Azure ou com a CLI:
- Criar um no portal do Azure é a forma mais rápida. No portal do Azure, acesse o recurso de Hub IoT. Selecione Dispositivos no menu Gerenciamento de dispositivos e selecione Adicionar Dispositivo.
  
  Em Criar um dispositivo, nomeie seu dispositivo usando a ID do Dispositivo, verifique o Dispositivo de IoT Edge e, em seguida, selecione Salvar no canto inferior esquerdo.
  
  Por fim, 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, leia 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#. Estamos trabalhando para resolver o problema. 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. Você precisa usar 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 de seu dispositivo do IoT Edge e selecione Avançar.
Em Configurar novo projeto, insira um nome para o seu 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

Se você tiver um projeto do IoT Edge existente, poderá alterar a URL do repositório abrindo o arquivo module.json. A URL do repositório está localizada na propriedade repositório do arquivo JSON.

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

Estrutura do projeto

Na sua solução, há duas pastas de nível de projeto, incluindo uma pasta de projeto principal e uma pasta de módulo único. 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 do projeto do módulo contém um arquivo para o código do módulo, chamado Program.cs ou main.c, dependendo da linguagem escolhida. Essa pasta também contém um arquivo chamado module.json que descreve os metadados do seu módulo. Diversos arquivos do Docker incluídos 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

O manifesto de implantação que você edita se chama deployment.debug.template.json. Esse arquivo é um modelo de um manifesto de implantação do IoT Edge que define todos os módulos que são 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 o modelo de implantação, você verá que estão incluídos dois módulos de runtime, edgeAgent e edgeHub, bem como o módulo personalizado que você criou no projeto do Visual Studio. Também está incluído um quarto módulo, chamado SimulatedTemperatureSensor. Esse módulo padrão gera dados simulados que você pode usar para testar seus módulos ou excluir se não for necessário. Para ver como o sensor de temperatura simulado funciona, veja o código-fonte do SimulatedTemperatureSensor.csproj.

Definir versão de runtime do IoT Edge

Atualmente, a versão do runtime estável mais recente é a 1.5. Você deve atualizar a versão de runtime do IoT Edge para a versão estável mais recente ou a versão que deseja direcionar para os seus dispositivos.

No Gerenciador de Soluções, clique com o botão direito do mouse no nome do seu 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.

Atualmente, a extensão não inclui uma seleção para as versões de runtime mais recentes. Se você quiser definir a versão de runtime superior a 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, se você quiser 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, gere novamente o manifesto de implantação clicando com o botão direito do mouse no nome do projeto e selecione Gerar implantação para IoT Edge. Isso gera um manifesto de implantação com base no seu modelo de implantação e aparece na pasta config 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 nos dispositivos IoT Edge de destino.
Altere a versão de runtime das imagens do módulo de runtime do sistema edgeAgent e edgeHub. Por exemplo, se você quiser 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, você poderá criar e enviar por push a imagem do módulo para o Registro de Contêiner do Azure. Você poderá então implantar o módulo no seu dispositivo do 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

Ao escolher Depurar, o Visual Studio usará Dockerfile.(amd64|windows-amd64).debug para compilar imagens do Docker. Isso inclui o VSDBG, depurador de linha de comando do .NET Core, na imagem de contêiner durante a criação. É recomendável que você use a configuração Versão que usa o Dockerfile.(amd64|windows-amd64) sem o VSDBG para os módulos do IoT Edge prontos para produção.
Se estiver usando um registro privado, como o ACR (Registro de Contêiner do Azure), use o seguinte comando do Docker para se conectar a ele. Você pode obter o nome de usuário e a senha na página Chaves de acesso do seu registro no portal do Azure.
```
docker login <ACR login server>
```
Vamos adicionar as informações de logon do Registro de Contêiner do Azure às configurações de execução encontradas no arquivo deployment.debug.template.json. Há duas maneiras de fazer isso. Você pode adicionar suas credenciais do registro ao arquivo .env (mais seguro) ou adicioná-las diretamente ao arquivo deployment.debug.template.json.

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. Essas credenciais podem ser encontradas na página Chaves de Acesso do seu 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 preferir adicionar as suas credenciais diretamente ao modelo de implantação, substitua os espaços reservados pelo nome de usuário, senha e nome de 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 estiver usando o registro local, você poderá executar 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 efetuou push das suas imagens de módulo para o seu Registro de Contêiner do Azure, você pode implantar a solução no seu dispositivo do IoT Edge. Você já tem um modelo de manifesto de implantação que tem observado ao longo deste tutorial. Vamos gerar um manifesto de implantação com base nisso e, em seguida, usar um comando da CLI do Azure para implantar seus módulos no 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.
Verifique o arquivo deployment.amd64.debug.json para confirmar se a versão do esquema edgeHub 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 em deployment.debug.template.json). A geração de uma implantação criará 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 será adequada). Esse é um bug conhecido e será corrigido em breve. 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 em JSON no prompt de comando.

Criar imagem do Docker do módulo

Depois de desenvolver o seu módulo, você poderá criar a imagem do módulo para armazenar em um registro de contêiner para implantação no seu dispositivo do 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, vamos supor que o shell de comando esteja no diretório do projeto e o nome do módulo seja IotEdgeModule1. Para criar a imagem do Registro local ou de um Registro de contêiner do Azure, use os seguintes 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"

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

Encontre a cadeia de conexão do Hub IoT no portal do Azure em Hub IoT do Azure >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, você pode remover o 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.

Compartilhar via