Tutorial: Desenvolver IoT Edge módulos com contêineres do Linux usando IoT Edge para Linux em Windows

  • Artigo

Aplica-se a:IoT Edge 1.4 checkmark IoT Edge 1.4

Importante

A versão com suporte é a IoT Edge 1.4. Se você estiver em uma versão anterior, confira Atualizar o IoT Edge.

Este tutorial orienta o desenvolvimento, depuração e implantação de seu próprio código em um dispositivo IoT Edge usando o IoT Edge para Linux no Windows e no Visual Studio 2022. Você aprenderá o cenário de desenvolvedor mais comum para soluções do IoT Edge implantando um módulo C# em um dispositivo Linux. Você implantará e depurará um módulo personalizado do Azure IoT Edge em execução em um contêiner Linux no Windows (EFLOW). Mesmo se você planeja usar um idioma diferente ou implantar um serviço do Azure, o tutorial ainda será útil para saber mais sobre os conceitos e as ferramentas de desenvolvimento.

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

  • A interface de linha de comando (CLI) é a ferramenta preferida para o desenvolvimento.
  • Ferramentas do Azure IoT Edge para extensão do Visual Studio . A extensão está no modo de manutenção.

Use o botão seletor de ferramentas no início deste artigo para selecionar a versão da ferramenta.

Neste tutorial, você aprenderá como:

  • Configurar seu computador de desenvolvimento.
  • Usar as ferramentas do IoT Edge para o Visual Studio Code para criar um projeto.
  • Criar seu projeto como um contêiner e armazená-lo em um Registro de Contêiner do Azure.
  • Implantar seu código em um dispositivo IoT Edge.

Pré-requisitos

Este artigo presume que você esteja usando uma máquina Windows como seu computador de desenvolvimento. Em computadores Windows, você pode desenvolver módulos do Windows ou do Linux. Este tutorial orienta você pelo desenvolvimento de contêineres Linux, usando o IoT Edge para Linux no Windows para criar e implantar os módulos.

Depois que o Visual Studio 2022 estiver pronto, você também precisará das seguintes ferramentas e componentes:

  • 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 criar sua solução do IoT Edge. A ferramenta de desenvolvimento preferencial é a Ferramenta de Desenvolvimento do Azure IoT Edge de 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 que você usa.

    Importante

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

    Dica

    Se você estiver usando o Visual Studio 2019, baixe e instale o Azure IoT Edge Tools for VS 2019 no mercado do Visual Studio.

Recursos de nuvem:

  • Um hub IoT gratuito ou de camada padrão no Azure.

Caso você não tenha uma assinatura do Azure, crie uma conta gratuita do Azure antes de começar.

Principais conceitos

Este tutorial explica o desenvolvimento de um módulo do IoT Edge. Um módulo do IoT Edge ou, às vezes, apenas módulo de maneira abreviada, é um contêiner com código executável. É possível implantar um ou mais módulos em um dispositivo IoT Edge. Módulos executam tarefas específicas, como ingerir dados de sensores, limpar e analisar dados ou enviar mensagens a um hub IoT. Para saber mais, confira Understand Azure IoT Edge modules (Noções básicas sobre módulos do Azure IoT Edge).

Ao desenvolver módulos do IoT Edge, é importante entender as diferenças entre o computador de desenvolvimento e o dispositivo IoT Edge de destino em que o módulo será implantado eventualmente. O contêiner que você criar para armazenar seu código de módulo deverá corresponder ao SO (sistema operacional) do dispositivo de destino. Por exemplo, o cenário mais comum é alguém desenvolver um módulo em um computador Windows com a intenção de direcionar um dispositivo Linux que executa o IoT Edge. Nesse caso, o sistema operacional do contêiner seria Linux. Ao percorrer este tutorial, lembre-se a diferença entre o sistema operacional do computador de desenvolvimento e o sistema operacional do contêiner. Para este tutorial, você estará usando o host Windows para desenvolvimento e o IoT Edge para Linux na VM Windows (EFLOW) para criar e implantar os módulos.

Este tutorial tem como destino dispositivos que executam o IoT Edge com contêineres Linux. É possível usar o sistema operacional de sua preferência, contanto que o computador de desenvolvimento execute contêineres do Linux. Recomendamos usar o Visual Studio para desenvolver com contêineres Linux, então é isso que este tutorial usa. É possível usar o Visual Studio Code também, embora haja diferenças no suporte entre as duas ferramentas. Para obter mais informações, consulte Desenvolver módulos do Azure IoT Edge usando o Visual Studio Code.

Configurar o docker-cli e a conexão remota do mecanismo do Docker

Os módulos do IoT Edge são empacotados como contêineres, portanto, você precisa de um mecanismo de contêiner no computador de desenvolvimento para criar e gerenciá-los. A máquina virtual EFLOW já contém uma instância do mecanismo do Docker, portanto, este tutorial mostra como se conectar remotamente da máquina do desenvolvedor do Windows à instância do Docker da VM EFLOW. Usando isso, removemos a dependência do Docker Desktop para Windows.

A primeira etapa é configurar o docker-cli no computador Windows desenvolvimento para poder se conectar ao mecanismo remoto do Docker.

  1. Baixe a versão de docker.exedo docker.exedocker-cli do docker-cli Chocolatey. Você também pode baixar o projeto oficial da CLI do docker/cli GitHub compilá-lo seguindo as instruções do repo.
  2. Extraia o docker.exe para um diretório em seu computador de desenvolvimento. Por exemplo, C:\Docker\bin
  3. Abrir Sobre o computador ->Informações do Sistema ->Configurações avançadas do sistema
  4. Selecione Avançado ->Variáveis de ambiente -> em Variáveis de usuário, marque Caminho
  5. Edite a variável Path e adicione o local do docker.exe
  6. Abra uma sessão do PowerShell elevada
  7. Verifique se a CLI do Docker está acessível usando o comando 
    docker --version

Se tudo tiver sido configurado com êxito, o comando anterior deverá ter a versão do docker, algo como Docker versão 20.10.12, build e91ed57.

A segunda etapa é configurar o mecanismo do Docker da máquina virtual EFLOW para aceitar conexões externas e adicionar as regras de firewall apropriadas.

Aviso

Expor o mecanismo do Docker a conexões externas pode aumentar os riscos de segurança. Essa configuração só deve ser usada para fins de desenvolvimento. Certifique-se de reverter a configuração para as configurações padrão depois que o desenvolvimento for concluído.

  1. Abra uma sessão do PowerShell com privilégios elevados e execute os seguintes comandos.

    # Configure the EFLOW virtual machine Docker engine to accept external connections, and add the appropriate firewall rules.
Invoke-EflowVmCommand "sudo iptables -A INPUT -p tcp --dport 2375 -j ACCEPT"

# Create a copy of the EFLOW VM _docker.service_ in the system folder.
Invoke-EflowVmCommand "sudo cp /lib/systemd/system/docker.service /etc/systemd/system/docker.service"

# Replace the service execution line to listen for external connections.
Invoke-EflowVmCommand "sudo sed -i 's/-H fd:\/\// -H fd:\/\/ -H tcp:\/\/0.0.0.0:2375/g'  /etc/systemd/system/docker.service"

# Reload the EFLOW VM services configurations.
Invoke-EflowVmCommand "sudo systemctl daemon-reload"

# Reload the Docker engine service.
Invoke-EflowVmCommand "sudo systemctl restart docker.service"

# Check that the Docker engine is listening to external connections.
Invoke-EflowVmCommand "sudo netstat -lntp | grep dockerd"

    A seguir está a saída de exemplo:

    PS C:\> # Configure the EFLOW virtual machine Docker engine to accept external connections, and add the appropriate firewall rules.
PS C:\> Invoke-EflowVmCommand "sudo iptables -A INPUT -p tcp --dport 2375 -j ACCEPT"
PS C:\>
PS C:\> # Create a copy of the EFLOW VM docker.service in the system folder.
PS C:\> Invoke-EflowVmCommand "sudo cp /lib/systemd/system/docker.service /etc/systemd/system/docker.service"
PS C:\>
PS C:\> # Replace the service execution line to listen for external connections.
PS C:\> Invoke-EflowVmCommand "sudo sed -i 's/-H fd:\/\// -H fd:\/\/ -H tcp:\/\/0.0.0.0:2375/g' /etc/systemd/system/docker.service"
PS C:\>
PS C:\> # Reload the EFLOW VM services configurations.
PS C:\> Invoke-EflowVmCommand "sudo systemctl daemon-reload"
PS C:\>
PS C:\> # Reload the Docker engine service.
PS C:\> Invoke-EflowVmCommand "sudo systemctl restart docker.service"
PS C:\>
PS C:\> # Check that the Docker engine is listening to external connections.
PS C:\> Invoke-EflowVmCommand "sudo netstat -lntp | grep dockerd"
tcp6       0      0 :::2375                 :::*                    LISTEN      2790/dockerd

  2. A etapa final é testar a conexão do Docker com o mecanismo do Docker da VM do EFLOW. Primeiro, você precisa do endereço IP da VM do Eflow.

    Get-EflowVmAddr

    Dica

    Se a VM do EFLOW tiver sido implantada sem IP Estático, o endereço IP poderá ser Windows reinicializações do sistema operacional do host ou alterações de rede. Certifique-se de que você está usando o endereço IP correto da VM do EFLOW sempre que quiser estabelecer uma conexão remota do mecanismo do Docker.

    A seguir está a saída de exemplo:

    PS C:\> Get-EflowVmAddr
[03/15/2022 15:22:30] Querying IP and MAC addresses from virtual machine (DESKTOP-J1842A1-EFLOW)
 - Virtual machine MAC: 00:15:5d:6f:da:78
 - Virtual machine IP : 172.31.24.105 retrieved directly from virtual machine
00:15:5d:6f:da:78
172.31.24.105

  3. Usando o endereço IP obtido, conecte-se ao mecanismo Docker da VM EFLOW e execute o contêiner de amostra Hello-World. Substitua <EFLOW-VM-IP> pelo endereço IP da VM EFLOW obtido na etapa anterior.

    docker -H tcp://<EFLOW-VM-IP>:2375 run --rm hello-world

    Você deve ver que o contêiner está sendo baixado e, depois, executará e executará o seguinte.

    PS C:\> docker -H tcp://172.31.24.105:2375 run --rm hello-world
Unable to find image 'hello-world:latest' locally
latest: Pulling from library/hello-world
2db29710123e: Pull complete
Digest: sha256:4c5f3db4f8a54eb1e017c385f683a2de6e06f75be442dc32698c9bbe6c861edd
Status: Downloaded newer image for hello-world:latest

Hello from Docker!
This message shows that your installation appears to be working correctly.

To generate this message, Docker took the following steps:
 1. The Docker client contacted the Docker daemon.
 2. The Docker daemon pulled the "hello-world" image from the Docker Hub.
    (amd64)
 3. The Docker daemon created a new container from that image which runs the
    executable that produces the output you are currently reading.
 4. The Docker daemon streamed that output to the Docker client, which sent it
    to your terminal.

To try something more ambitious, you can run an Ubuntu container with:
 $ docker run -it ubuntu bash

Share images, automate workflows, and more with a free Docker ID:
 https://hub.docker.com/

For more examples and ideas, visit:
 https://docs.docker.com/get-started/

Criar um projeto do Azure IoT Edge

O modelo de projeto do Azure IoT Edge no Visual Studio cria uma solução que pode ser implantada em dispositivos do Azure IoT Edge. Primeiro, crie uma solução do Azure IoT Edge e gere o primeiro módulo nessa solução. Cada solução do IoT Edge pode conter mais de um módulo.

Importante

A estrutura do projeto 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 oferece 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.

  1. No Visual Studio, crie um novo projeto.

  2. Na página Criar um novo projeto, procure Azure IoT Edge. Selecione o projeto que corresponde à plataforma (módulo do IoT Edge do Linux) e à arquitetura de seu dispositivo IoT Edge e clique em Próximo.

    Create New Project

  3. Na janela Configurar novo projeto, insira um nome para o projeto, especifique o local e selecione Criar.

  4. Na janela Adicionar módulo, selecione o tipo de módulo que você deseja desenvolver. Você também pode selecionar Módulo existente para adicionar um módulo do IoT Edge existente à sua implantação. Especifique o nome do módulo e o repositório de imagens do módulo.

  5. 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>.

  6. Selecione Adicionar para adicionar o módulo ao projeto.

    Screenshot of adding how to add an application and module to Visual Studio solution

    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 de módulo contém um arquivo para o código do módulo, chamado Program.cs ou main.c a depender 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 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 editado é denominado 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.4. 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.

  1. 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.

    Screenshot of how to find and select the menu item named 'Set IoT Edge Runtime version'.

  2. 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.4, altere as seguintes linhas no arquivo de manifesto de implantação:

    "systemModules": {
   "edgeAgent": {
    //...
      "image": "mcr.microsoft.com/azureiotedge-agent:1.4"
    //...
   "edgeHub": {
   //...
      "image": "mcr.microsoft.com/azureiotedge-hub:1.4",
   //...

  3. 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 em seu modelo de implantação e aparece na pasta config do seu projeto do Visual Studio.

  1. 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.

  2. 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.4, altere as seguintes linhas no arquivo de manifesto de implantação:

    "systemModules": {
    "edgeAgent": {
    //...
        "image": "mcr.microsoft.com/azureiotedge-agent:1.4",
    //...
    "edgeHub": {
    //...
        "image": "mcr.microsoft.com/azureiotedge-hub:1.4",
    //...

Configurar a instância remota do mecanismo do Docker do Visual Studio 2022

Use a extensão de ferramentas do Azure IoT Edge e configure-a para usar o mecanismo Docker remoto em execução dentro da máquina virtual EFLOW.

  1. Selecione Ferramentas ->ferramentas do Azure IoT Edge ->Configurações de ferramentas do Iot Edge...

  2. Substitua o DOCKER_HOST localhost pelo endereço IP da VM do EFLOW. Se você não se lembrar do endereço IP, use o cmdlet Get-EflowVmAddr do PowerShell do EFLOW para obter isso. Por exemplo, se o endereço IP da VM do EFLOW for 172.20.1.100, o novo valor deverá ser tcp://172.20.1.100:2375.

    Screenshot of IoT Edge Tools settings

  3. Selecione OK

Desenvolver seu módulo

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 outros módulos que atendam às principais necessidades de soluções de IoT, como segurança, gerenciamento de dispositivos e confiabilidade.

Criar e efetuar push de um único módulo

Normalmente, queremos testar/depurar cada módulo antes de colocá-lo em execução dentro de uma solução com vários módulos. Como a solução será compilada ou depura usando o mecanismo do Docker em execução dentro da VM EFLOW, a primeira etapa é criar e publicar o módulo para habilitar a depuração remota.

  1. No Gerenciador de Soluções, selecione e realce a pasta do projeto do módulo (por exemplo, myIotEdgeModule). Defina o módulo personalizado como o projeto de inicialização. Selecione Projeto>Definir como Projeto de Inicialização no menu.

  2. Para depurar o módulo C# Linux, precisamos atualizar o arquivo Dockerfile.amd64.debug para habilitar o serviço SSH. Atualize o arquivo Dockerfile.amd64.debug para usar o seguinte modelo: Dockerfile para o módulo C# AMD64 do Azure IoT Edge com suporte a depuração remota.

    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.

    Aviso

    Certifique-se de que a última linha do modelo ENTRYPOINT ["dotnet", "IotEdgeModule1.dll"] o nome da DLL corresponde ao nome do seu projeto IoT Edge módulo.

    Screenshot of setting the Dockerfile template

  3. Para estabelecer uma conexão SSH com o módulo do Linux, precisamos criar uma chave RSA. Abra uma sessão do PowerShell com privilégios elevados e execute os seguintes comandos para criar uma chave RSA. Salve a chave RSA na mesma pasta IoT Edge módulo e se o nome da chave é id_rsa.

    ssh-keygen -t RSA -b 4096 -m PEM

    Screenshot of how to create an SSH key

  4. 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. Se estiver usando o registro local, você poderá executar um registro local.

    docker -H tcp://<EFLOW-VM-IP>:2375 login -u <ACR username> -p <ACR password> <ACR login server>

  1. No Gerenciador de Soluções, clique com o botão direito na pasta do projeto e selecione Compilar e efetuar push de módulos do IoT Edge para compilar e efetuar push da imagem Docker para cada módulo.

  2. Se você estiver usando um registro privado como o Registro de Contêiner do Azure, é necessário adicionar informações de login do registro para as configurações de runtime encontradas no arquivo deployment.template.json. Substitua os espaços reservados com o nome real de nome de usuário do administrador ACR, senha e registro.

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

  3. É necessário expor a porta 22 para acessar o serviço SSH do módulo. Este tutorial usa 10022 como a porta do host, mas você pode especificar uma porta diferente, que será usada como uma porta SSH para se conectar ao módulo C# do Linux. Você precisa adicionar as informações de porta SSH às "createOptions" desta configuração de módulo do Linux encontrada no arquivo deployment.debug.template.json.

         "createOptions": {
        "HostConfig": {
           "Privileged": true,
           "PortBindings": {
                 "22/tcp": [
                    {
                       "HostPort": "10022"
                    }
                 ]
           }
        }
     }

  4. No Gerenciador de Soluções, clique com o botão direito do mouse na pasta do projeto e selecione Gerar implantação para IoT Edge para criar o novo json de IoT Edge implantação.

  5. Abra Cloud Explorer clicando em Exibir>Cloud Explorer. Verifique se está conectado no Visual Studio 2019.

  6. No Cloud Explorer, expanda sua assinatura, localize o Hub IoT do Azure e o dispositivo Azure IoT Edge que você deseja implantar.

  7. Clique com o botão direito do mouse no IoT Edge e escolha Criar implantação. Navegue até o manifesto de implantação configurado para sua plataforma localizado na pasta config na solução do Visual Studio, como deployment.amd64.json.

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.

  1. Se você estiver usando um Registro de Contêiner do Azure para armazenar sua imagem de módulo, precisará adicionar suas 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"
          }
        }
      }
    },
//...

  2. 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.

  3. Adicione ou substitua o valor createOptions por conteúdo stringificado 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.

  1. No Cloud Explorer, clique com o botão direito do mouse no dispositivo de borda e atualize para ver o novo módulo em execução junto com os módulos $edgeAgent e$edgeHub.

Depurar a solução

  1. Em uma sessão do PowerShell com privilégios elevados, execute os seguintes comandos:

    1. Obtenha o moduleId com base no nome usado para o módulo C# do Linux. Substitua o espaço reservado <iot-edge-module-name> pelo nome do módulo.

      $moduleId = Invoke-EflowVmCommand "sudo docker ps -aqf name=<iot-edge-module-name>"

    2. Verifique se o $moduleId está correto – se a variável estiver vazia, verifique se você está usando o nome correto do módulo

    3. Iniciar o serviço SSH dentro do contêiner do Linux

      Invoke-EflowVmCommand "sudo docker exec -it -d $moduleId service ssh start"

    4. Abra a porta SSH do módulo na VM do EFLOW (este tutorial usa a porta 10022)

      Invoke-EflowVmCommand "sudo iptables -A INPUT -p tcp --dport 10022 -j ACCEPT"

    Aviso

    Por motivos de segurança, sempre que a VM do EFLOW for reinicializada, a regra da tabela IP excluirá e voltará para as configurações originais. Além disso, o serviço SSH do módulo terá que ser iniciado novamente manualmente.

  2. Depois de iniciar o serviço SSH com êxito, selecione Depurar ->Anexar ao Processo, definir Tipo de Conexão como SSH e Destino de conexão para o endereço IP da VM do EFLOW. Se você não conhece o IP da VM do EFLOW, pode usar o cmdlet Get-EflowVmAddr do PowerShell. Primeiro, digite o IP e pressione Enter. Na janela pop-up, insira as seguintes configurações:

    Campo Valor
    Nome do host Usar o IP da VM EFLOW
    Porta 10022 (ou aquele que você usou em sua configuração de implantação)
    Nome de usuário root
    Tipo de autenticação Chave privada
    Arquivo de chave privada Caminho completo para o id_rsa criado em uma etapa anterior
    Frase secreta Senha usada para a chave criada em uma etapa anterior

    Screenshot of how to connect to a remote system

  3. Depois de se conectar com êxito ao módulo usando SSH, você pode escolher o processo e selecionar anexar. Para o módulo C#, você precisa escolher o processo dotnet e Anexá-lo a gerenciado (CoreCLR). Pode levar de 10 a 20 segundos na primeira vez.

    Screenshot of how to attach an edge module process.

  4. 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 InputQueue1Callback().

  5. A saída do SimulatedTemperatureSensor deve ser redirecionada para entrada1 do módulo personalizado do Linux C#. O ponto de interrupção deve ser disparado. Você pode assistir as variáveis na janela Locais do Visual Studio.

    Screenshot of how to debug a single module

  6. Pressione Ctrl + F5 ou clique no botão Parar para parar a depuração.

Limpar os recursos

Se você pretende continuar no próximo artigo recomendado, pode manter os recursos e as configurações já criados e reutilizá-los. Você também pode continuar usando o mesmo dispositivo IoT Edge como um dispositivo de teste.

Caso contrário, é possível excluir as configurações locais e os recursos do Azure usados neste artigo para evitar encargos.

Excluir recursos do Azure

A exclusão de recursos do Azure e dos grupos de recursos é irreversível. Não exclua acidentalmente grupo de recursos ou recursos incorretos. Se você criou o hub IoT em um grupo de recursos existente que contém recursos que deseja manter, exclua apenas o recurso do hub IoT, não o grupo de recursos.

Para excluir os recursos:

  1. Entre no portal do Azure e selecione Grupos de recursos.

  2. Selecione o nome do grupo de recursos que contém os recursos de teste do IoT Edge.

  3. Examine a lista de recursos contidos no grupo de recursos. Se você deseja excluir todos eles, selecione Excluir grupo de recursos. Se você quiser excluir apenas alguns deles, clique em cada recurso para excluí-los individualmente.

Próximas etapas

Neste tutorial, você configurou o Visual Studio em seu computador de desenvolvimento e depurou seu primeiro módulo do IoT Edge dele. Agora que você conhece os conceitos básicos, experimente adicionar uma funcionalidade a um módulo para que ele possa analisar os dados que são passados por ele.

Desenvolver módulos do Azure IoT Edge usando o Visual Studio Code