Partilhar via

Tutorial: Implantar um registro conectado em uma hierarquia aninhada do IoT Edge

  • Artigo

Neste tutorial, você usa os comandos da CLI do Azure para criar uma hierarquia de duas camadas de dispositivos do Azure IoT Edge e implantar um registro conectado como um módulo em cada camada. Nesse cenário, um dispositivo na camada superior se comunica com um registro de nuvem. Um dispositivo na camada inferior se comunica com seu pai de registro conectado na camada superior.

Para obter uma visão geral do uso de um registro conectado com o IoT Edge, consulte Usando o registro conectado com o Azure IoT Edge.

Pré-requisitos

  • Use o ambiente Bash no Azure Cloud Shell. Para obter mais informações, consulte Guia de início rápido para Bash no Azure Cloud Shell.

  • Se preferir executar comandos de referência da CLI localmente, instale a CLI do Azure. Se estiver a utilizar o Windows ou macOS, considere executar a CLI do Azure num contentor Docker. Para obter mais informações, consulte Como executar a CLI do Azure em um contêiner do Docker.

    • Se estiver a utilizar uma instalação local, inicie sessão no CLI do Azure ao utilizar o comando az login. Para concluir o processo de autenticação, siga os passos apresentados no seu terminal. Para outras opções de entrada, consulte Entrar com a CLI do Azure.

    • Quando solicitado, instale a extensão da CLI do Azure na primeira utilização. Para obter mais informações sobre as extensões, veja Utilizar extensões com o CLI do Azure.

    • Execute o comando az version para localizar a versão e as bibliotecas dependentes instaladas. Para atualizar para a versão mais recente, execute o comando az upgrade.

  • Hub IoT do Azure. Para conhecer as etapas de implantação, consulte Criar um hub IoT usando o portal do Azure.

  • Dois recursos de registro conectados no Azure. Para conhecer as etapas de implantação, consulte guias de início rápido usando a CLI do Azure ou o portal do Azure.

    • Para a camada superior, o registro conectado pode estar no modo ReadWrite ou ReadOnly. Este artigo assume o modo ReadWrite e o nome do Registro conectado é armazenado na variável $CONNECTED_REGISTRY_RWde ambiente .
    • Para a camada inferior, o registro conectado deve estar no modo somente leitura. Este artigo pressupõe que o nome do Registro conectado é armazenado na variável $CONNECTED_REGISTRY_ROde ambiente .

Importar imagens para o seu registo na nuvem

Importe as seguintes imagens de contêiner para seu registro na nuvem usando o comando az acr import . Ignore esta etapa se você já importou essas imagens.

Imagem de registo ligada

Para dar suporte a cenários aninhados do IoT Edge, a imagem do contêiner para o tempo de execução do Registro conectado deve estar disponível em seu registro de contêiner privado do Azure. Use o comando az acr import para importar a imagem do registro conectado para seu registro privado.

# Use the REGISTRY_NAME variable in the following Azure CLI commands to identify the registry
REGISTRY_NAME=<container-registry-name>

az acr import \
  --name $REGISTRY_NAME \
  --source mcr.microsoft.com/acr/connected-registry:0.8.0

Imagens de proxy do IoT Edge e da API

Para dar suporte ao registro conectado no IoT Edge aninhado, você precisa implantar módulos para o IoT Edge e o proxy de API. Importe estas imagens para o seu registo privado.

O módulo de proxy da API do IoT Edge permite que um dispositivo IoT Edge exponha vários serviços usando o protocolo HTTPS na mesma porta, como 443.

az acr import \
  --name $REGISTRY_NAME \
  --source mcr.microsoft.com/azureiotedge-agent:1.2.4

az acr import \
  --name $REGISTRY_NAME \
  --source mcr.microsoft.com/azureiotedge-hub:1.2.4

az acr import \
  --name $REGISTRY_NAME \
  --source mcr.microsoft.com/azureiotedge-api-proxy:1.1.2

az acr import \
  --name $REGISTRY_NAME \
  --source mcr.microsoft.com/azureiotedge-diagnostics:1.2.4

Imagem hello-world

Para testar o registro conectado, importe a hello-world imagem. Este repositório será sincronizado com o registro conectado e puxado pelos clientes de registro conectados.

az acr import \
  --name $REGISTRY_NAME \
  --source mcr.microsoft.com/hello-world:1.1.2

Recuperar configuração do Registro conectado

Para implantar cada registro conectado no dispositivo IoT Edge na hierarquia, você precisa recuperar as definições de configuração do recurso do Registro conectado no Azure. Se necessário, execute o comando az acr connected-registry get-settings para cada registro conectado para recuperar a configuração.

Por padrão, as informações de configurações não incluem a senha do token de sincronização, que também é necessária para implantar o registro conectado. Opcionalmente, gere uma das senhas passando o --generate-password 1 parâmetro ou --generate-password 2 . Guarde a palavra-passe gerada num local seguro. Ele não pode ser recuperado novamente.

Aviso

A regeneração de uma senha gira as credenciais do token de sincronização. Se você configurou um dispositivo usando a senha anterior, precisará atualizar a configuração.

# Use the REGISTRY_NAME variable in the following Azure CLI commands to identify the registry
REGISTRY_NAME=<container-registry-name>

# Run the command for each registry resource in the hierarchy

az acr connected-registry get-settings \
  --registry $REGISTRY_NAME \
  --name $CONNECTED_REGISTRY_RW \
  --parent-protocol https

az acr connected-registry get-settings \
  --registry $REGISTRY_NAME \
  --name $CONNECTED_REGISTRY_RO \
  --parent-protocol https

A saída do comando inclui a cadeia de conexão do Registro e as configurações relacionadas. O exemplo de saída a seguir mostra a cadeia de conexão para o registro conectado chamado myconnectedregistry com o registro pai contosoregistry:

{
  "ACR_REGISTRY_CONNECTION_STRING": "ConnectedRegistryName=myconnectedregistry;SyncTokenName=myconnectedregistry-sync-token;SyncTokenPassword=xxxxxxxxxxxxxxxx;ParentGatewayEndpoint=contosoregistry.eastus.data.azurecr.io;ParentEndpointProtocol=https"
}

Configurar manifestos de implantação

Um manifesto de implantação é um documento JSON que descreve quais módulos implantar em um dispositivo IoT Edge. Para obter mais informações, consulte Compreender como os módulos do IoT Edge podem ser usados, configurados e reutilizados.

Para implantar o módulo de registro conectado em cada dispositivo IoT Edge usando a CLI do Azure, salve os seguintes manifestos de implantação localmente como arquivos JSON. Use as informações das seções anteriores para atualizar os valores JSON relevantes em cada manifesto. Use os caminhos de arquivo na próxima seção quando executar o comando para aplicar a configuração ao seu dispositivo.

Manifesto de implantação para a camada superior

Para o dispositivo na camada superior, crie um arquivo deploymentTopLayer.json de manifesto de implantação com o seguinte conteúdo. Esse manifesto é semelhante ao usado em Guia de início rápido: implantar um registro conectado em um dispositivo IoT Edge.

Nota

Se você já implantou um registro conectado em um dispositivo IoT Edge de camada superior usando o início rápido, poderá usá-lo na camada superior de uma hierarquia aninhada. Modifique as etapas de implantação neste tutorial para configurá-lo na hierarquia (não mostrado).

Configurações do módulo do Registro conectado

  • Use as credenciais de token e a cadeia de conexão das seções anteriores para atualizar os valores JSON relevantes no env nó.

  • As seguintes variáveis de ambiente são opcionais no env nó:

    Variável Description
    ACR_REGISTRY_LOGIN_SERVER Especifica um nome de host exclusivo ou FQDN. Se usado, o registro conectado só aceita solicitações feitas para esse valor de servidor de login.

    Se nenhum valor for fornecido, o registro conectado poderá ser acessado com qualquer valor de servidor de login.
    ACR_REGISTRY_CERTIFICATE_VOLUME Se o seu registro conectado estiver acessível via HTTPS, aponte para o volume onde os certificados HTTPS estão armazenados.

    Se não estiver definido, o local padrão será /var/acr/certs.
    ACR_REGISTRY_DATA_VOLUME Substitui o local /var/acr/data padrão onde as imagens serão armazenadas pelo registro conectado.

    Esse local deve corresponder à associação de volume para o contêiner.

    Importante

    Se o registro conectado escuta em uma porta diferente de 80 e 443, o ACR_REGISTRY_LOGIN_SERVER valor (se especificado) deve incluir a porta. Exemplo: 192.168.0.100:8080.

  • Uma HostPort associação para o registro conectado deve ser definida se o módulo de proxy da API não for usado. Exemplo:

     "createOptions": "{\"HostConfig\":{\"Binds\":[\"/home/azureuser/connected-registry:/var/acr/data\"],\"PortBindings\":{\"8080/tcp\":[{\"HostPort\":\"8080\"}]}}}"

Configurações do módulo de proxy da API

  • O proxy da API escutará na porta 8000 configurada como NGINX_DEFAULT_PORT. Para obter mais informações sobre as configurações de proxy da API, consulte o repositório GitHub do IoT Edge.
{
    "modulesContent": {
        "$edgeAgent": {
            "properties.desired": {
                "modules": {
                    "connected-registry": {
                        "settings": {
                            "image": "<REPLACE_WITH_CLOUD_REGISTRY_NAME>.azurecr.io/acr/connected-registry:0.8.0",
                            "createOptions": "{\"HostConfig\":{\"Binds\":[\"/home/azureuser/connected-registry:/var/acr/data\"]}}"
                        },
                        "type": "docker",
                        "env": {
                            "ACR_REGISTRY_CONNECTION_STRING": {
                                "value": "ConnectedRegistryName=<REPLACE_WITH_CONNECTED_REGISTRY_NAME>;SyncTokenName=<REPLACE_WITH_SYNC_TOKEN_NAME>;SyncTokenPassword=REPLACE_WITH_SYNC_TOKEN_PASSWORD;ParentGatewayEndpoint=<REPLACE_WITH_CLOUD_REGISTRY_NAME>.<REPLACE_WITH_CLOUD_REGISTRY_REGION>.data.azurecr.io;ParentEndpointProtocol=https"
                            }
                        },
                        "status": "running",
                        "restartPolicy": "always",
                        "version": "1.0"
                    },
                    "IoTEdgeAPIProxy": {
                        "settings": {
                            "image": "<REPLACE_WITH_CLOUD_REGISTRY_NAME>.azurecr.io/azureiotedge-api-proxy:1.1.2",
                            "createOptions": "{\"HostConfig\":{\"PortBindings\":{\"8000/tcp\":[{\"HostPort\":\"8000\"}]}}}"
                        },
                        "type": "docker",
                        "env": {
                            "NGINX_DEFAULT_PORT": {
                                "value": "8000"
                            },
                            "CONNECTED_ACR_ROUTE_ADDRESS": {
                                "value": "connected-registry:8080"
                            },
                            "BLOB_UPLOAD_ROUTE_ADDRESS": {
                                "value": "AzureBlobStorageonIoTEdge:11002"
                            }
                        },
                        "status": "running",
                        "restartPolicy": "always",
                        "version": "1.0"
                    }
                },
                "runtime": {
                    "settings": {
                        "minDockerVersion": "v1.25",
                        "registryCredentials": {
                            "cloudregistry": {
                                "address": "<REPLACE_WITH_CLOUD_REGISTRY_NAME>.azurecr.io",
                                "password": "<REPLACE_WITH_SYNC_TOKEN_PASSWORD>",
                                "username": "<REPLACE_WITH_SYNC_TOKEN_NAME>"
                            }
                        }
                    },
                    "type": "docker"
                },
                "schemaVersion": "1.1",
                "systemModules": {
                    "edgeAgent": {
                        "settings": {
                            "image": "<REPLACE_WITH_CLOUD_REGISTRY_NAME>.azurecr.io/azureiotedge-agent:1.2.4",
                            "createOptions": ""
                        },
                        "type": "docker",
                        "env": {
                            "SendRuntimeQualityTelemetry": {
                                "value": "false"
                            }
                        }
                    },
                    "edgeHub": {
                        "settings": {
                            "image": "<REPLACE_WITH_CLOUD_REGISTRY_NAME>.azurecr.io/azureiotedge-hub:1.2.4",
                            "createOptions": "{\"HostConfig\":{\"PortBindings\":{\"443/tcp\":[{\"HostPort\":\"443\"}],\"5671/tcp\":[{\"HostPort\":\"5671\"}],\"8883/tcp\":[{\"HostPort\":\"8883\"}]}}}"
                        },
                        "type": "docker",
                        "status": "running",
                        "restartPolicy": "always"
                    }
                }
            }
        },
        "$edgeHub": {
            "properties.desired": {
                "routes": {
                    "route": "FROM /messages/* INTO $upstream"
                },
                "schemaVersion": "1.1",
                "storeAndForwardConfiguration": {
                    "timeToLiveSecs": 7200
                }
            }
        }
    }
}

Manifesto de implantação para a camada inferior

Para o dispositivo na camada inferior, crie um arquivo de manifesto de implantação deploymentLowerLayer.json com o seguinte conteúdo.

No geral, o arquivo de implantação da camada inferior é semelhante ao arquivo de implantação da camada superior. As diferenças são:

  • Ele extrai as imagens necessárias do registro conectado da camada superior em vez do registro na nuvem.

    Ao configurar o registro conectado à camada superior, certifique-se de que ele sincroniza todas as imagens necessárias localmente, incluindo azureiotedge-agent, azureiotedge-hub, azureiotedge-api-proxye acr/connected-registry. O dispositivo IoT de camada inferior precisa extrair essas imagens do registro conectado da camada superior.

  • Ele usa o token de sincronização configurado na camada inferior para autenticar com o registro conectado da camada superior.

  • Ele configura o ponto de extremidade do gateway pai com o endereço IP ou FQDN do registro conectado à camada superior, em vez de com o FQDN do registro na nuvem.

Importante

No manifesto de implantação a seguir, $upstream é usado como o endereço IP ou FQDN do dispositivo que hospeda o registro conectado pai. No entanto, $upstream não é suportado em uma variável de ambiente. O registro conectado precisa ler a variável ACR_PARENT_GATEWAY_ENDPOINT de ambiente para obter o ponto de extremidade do gateway pai. Em vez de usar $upstreamo , o registro conectado suporta a resolução dinâmica do endereço IP ou FQDN de outra variável de ambiente.

No IoT Edge aninhado, há uma variável $IOTEDGE_PARENTHOSTNAME de ambiente na camada inferior que é igual ao endereço IP ou FQDN do dispositivo pai. Substitua manualmente a variável de ambiente como o valor de na cadeia de ParentGatewayEndpoint conexão para evitar a codificação do endereço IP pai ou FQDN. Como o dispositivo pai neste exemplo está sendo executado nginx na porta 8000, passe $IOTEDGE_PARENTHOSTNAME:8000. Você também precisa selecionar o protocolo adequado em ParentEndpointProtocol.

{
    "modulesContent": {
        "$edgeAgent": {
            "properties.desired": {
                "modules": {
                    "connected-registry": {
                        "settings": {
                            "image": "$upstream:8000/acr/connected-registry:0.8.0",
                            "createOptions": "{\"HostConfig\":{\"Binds\":[\"/home/azureuser/connected-registry:/var/acr/data\"]}}"
                        },
                        "type": "docker",
                        "env": {
                            "ACR_REGISTRY_CONNECTION_STRING": {
                                "value": "ConnectedRegistryName=<REPLACE_WITH_CONNECTED_REGISTRY_NAME>;SyncTokenName=<REPLACE_WITH_SYNC_TOKEN_NAME>;SyncTokenPassword=<REPLACE_WITH_SYNC_TOKEN_PASSWORD>;ParentGatewayEndpoint=$IOTEDGE_PARENTHOSTNAME:8000;ParentEndpointProtocol=https"
                            }
                        },
                        "status": "running",
                        "restartPolicy": "always",
                        "version": "1.0"
                    },
                    "IoTEdgeApiProxy": {
                        "settings": {
                            "image": "$upstream:8000/azureiotedge-api-proxy:1.1.2",
                            "createOptions": "{\"HostConfig\": {\"PortBindings\": {\"8000/tcp\": [{\"HostPort\": \"8000\"}]}}}"
                        },
                        "type": "docker",
                        "version": "1.0",
                        "env": {
                            "NGINX_DEFAULT_PORT": {
                                "value": "8000"
                            },
                            "CONNECTED_ACR_ROUTE_ADDRESS": {
                                "value": "connected-registry:8080"
                            },
                            "NGINX_CONFIG_ENV_VAR_LIST": {
                                    "value": "NGINX_DEFAULT_PORT,BLOB_UPLOAD_ROUTE_ADDRESS,CONNECTED_ACR_ROUTE_ADDRESS,IOTEDGE_PARENTHOSTNAME,DOCKER_REQUEST_ROUTE_ADDRESS"
                            },
                            "BLOB_UPLOAD_ROUTE_ADDRESS": {
                                "value": "AzureBlobStorageonIoTEdge:11002"
                            }
                        },
                        "status": "running",
                        "restartPolicy": "always",
                        "startupOrder": 3
                    }
                },
                "runtime": {
                    "settings": {
                        "minDockerVersion": "v1.25",
                        "registryCredentials": {
                            "connectedregistry": {
                                "address": "$upstream:8000",
                                "password": "<REPLACE_WITH_SYNC_TOKEN_PASSWORD>",
                                "username": "<REPLACE_WITH_SYNC_TOKEN_NAME>"
                            }
                        }
                    },
                    "type": "docker"
                },
                "schemaVersion": "1.1",
                "systemModules": {
                    "edgeAgent": {
                        "settings": {
                            "image": "$upstream:8000/azureiotedge-agent:1.2.4",
                            "createOptions": ""
                        },
                        "type": "docker",
                        "env": {
                            "SendRuntimeQualityTelemetry": {
                                "value": "false"
                            }
                        }
                    },
                    "edgeHub": {
                        "settings": {
                            "image": "$upstream:8000/azureiotedge-hub:1.2.4",
                            "createOptions": "{\"HostConfig\":{\"PortBindings\":{\"443/tcp\":[{\"HostPort\":\"443\"}],\"5671/tcp\":[{\"HostPort\":\"5671\"}],\"8883/tcp\":[{\"HostPort\":\"8883\"}]}}}"
                        },
                        "type": "docker",
                        "status": "running",
                        "restartPolicy": "always"
                    }
                }
            }
        },
        "$edgeHub": {
            "properties.desired": {
                "routes": {
                    "route": "FROM /messages/* INTO $upstream"
                },
                "schemaVersion": "1.1",
                "storeAndForwardConfiguration": {
                    "timeToLiveSecs": 7200
                }
            }
        }
    }
}

Configurar e implantar módulos de registro conectados

As etapas a seguir são adaptadas do Tutorial: Criar uma hierarquia de dispositivos IoT Edge e são específicas para implantar módulos de registro conectados na hierarquia do IoT Edge. Consulte esse tutorial para obter detalhes sobre etapas individuais.

Criar dispositivos de camada superior e inferior

Crie máquinas virtuais de camada superior e inferior usando um modelo ARM existente. O modelo também instala o agente IoT Edge. Se, em vez disso, pretender implementar a partir dos seus próprios dispositivos, consulte Tutorial: Instalar ou desinstalar o Azure IoT Edge para Linux para saber como configurar manualmente o dispositivo.

Importante

Para acesso posterior aos módulos implantados no dispositivo de camada superior, certifique-se de abrir as seguintes portas de entrada: 8000, 443, 5671, 8883. Para obter as etapas de configuração, consulte Como abrir portas para uma máquina virtual com o portal do Azure.

Criar e configurar a hierarquia

Use a iotedge-config ferramenta para criar e configurar sua hierarquia seguindo estas etapas na CLI do Azure ou no Azure Cloud Shell:

  1. Faça o download da ferramenta de configuração.

     mkdir nested_iot_edge_tutorial
 cd ~/nested_iot_edge_tutorial
 wget -O iotedge_config.tar "https://github.com/Azure-Samples/iotedge_config_cli/releases/download/latest/iotedge_config_cli.tar.gz"
 tar -xvf iotedge_config.tar

    Esta etapa cria a pasta no diretório do iotedge_config_cli_release tutorial. O arquivo de modelo usado para criar sua hierarquia de dispositivo é o iotedge_config.yaml arquivo encontrado em ~/nested_iot_edge_tutorial/iotedge_config_cli_release/templates/tutorial. No mesmo diretório, há dois manifestos de implantação para as camadas superior e inferior: deploymentTopLayer.json e deploymentLowerLayer.json arquivos.

  2. Edite iotedge_config.yaml com as suas informações. Edite os nomes de arquivo do manifesto iothub_hostnamede implantação , iot_name, para a camada superior e inferior, e as credenciais de token de cliente que você criou para extrair imagens do upstream de cada camada. O exemplo a seguir é um arquivo de configuração de exemplo:

    config_version: "1.0"

iothub:
    iothub_hostname: <REPLACE_WITH_HUB_NAME>.azure-devices.net
    iothub_name: <REPLACE_WITH_HUB_NAME>
    ## Authentication method used by IoT Edge devices: symmetric_key or x509_certificate
    authentication_method: symmetric_key 

    ## Root certificate used to generate device CA certificates. Optional. If not provided a self-signed CA will be generated
    # certificates:
    #   root_ca_cert_path: ""
    #   root_ca_cert_key_path: ""

    ## IoT Edge configuration template to use
configuration:
    template_config_path: "./templates/tutorial/device_config.toml"
    default_edge_agent: "$upstream:8000/azureiotedge-agent:1.2.4"

    ## Hierarchy of IoT Edge devices to create
edgedevices:
    device_id: top-layer
    edge_agent: "<REPLACE_WITH_REGISTRY_NAME>.azurecr.io/azureiotedge-agent:1.2.4" ## Optional. If not provided, default_edge_agent will be used
    deployment: "./templates/tutorial/deploymentTopLayer.json" ## Optional. If provided, the given deployment file will be applied to the newly created device
        # hostname: "FQDN or IP" ## Optional. If provided, install.sh will not prompt user for this value nor the parent_hostname value
    container_auth: ## The token used to pull the image from cloud registry
        serveraddress: "<REPLACE_WITH_REGISTRY_NAME>.azurecr.io"
        username: "<REPLACE_WITH_SYNC_TOKEN_NAME_FOR_TOP_LAYER>"
        password: "<REPLACE_WITH_SYNC_TOKEN_PASSWORD_FOR_TOP_LAYER>"
    child:
        - device_id: lower-layer
          deployment: "./templates/tutorial/deploymentLowerLayer.json" ## Optional. If provided, the given deployment file will be applied to the newly created device
           # hostname: "FQDN or IP" ## Optional. If provided, install.sh will not prompt user for this value nor the parent_hostname value
          container_auth: ## The token used to pull the image from parent connected registry
            serveraddress: "$upstream:8000"
            username: "<REPLACE_WITH_SYNC_TOKEN_NAME_FOR_LOWER_LAYER>"
            password: "<REPLACE_WITH_SYNC_TOKEN_PASSWORD_FOR_LOWER_LAYER>"

  3. Prepare os arquivos de implantação da camada superior e inferior: deploymentTopLayer.json e deploymentLowerLayer.json. Copie os arquivos de manifesto de implantação criados anteriormente neste artigo para a seguinte pasta: ~/nestedIotEdgeTutorial/iotedge_config_cli_release/templates/tutorial.

  4. Navegue até o diretório iotedge_config_cli_release e execute a ferramenta para criar sua hierarquia de dispositivos IoT Edge.

    cd ~/nestedIotEdgeTutorial/iotedge_config_cli_release
./iotedge_config --config ~/nestedIotEdgeTutorial/iotedge_config_cli_release/templates/tutorial/iotedge_config.yaml --output ~/nestedIotEdgeTutorial/iotedge_config_cli_release/outputs -f

    Com o --output parâmetro, a ferramenta cria os certificados de dispositivo, pacotes de certificados e um arquivo de log em um diretório de sua escolha. Com o -f parâmetro, a ferramenta procura automaticamente dispositivos IoT Edge existentes no seu Hub IoT e os remove, para evitar erros e manter seu hub limpo.

    A ferramenta pode ser executada por vários minutos.

  5. Copie os arquivos de top-layer.zip e lower-layer.zip gerados na etapa anterior para as máquinas virtuais de camada superior e inferior correspondentes usandoscp:

    scp <PATH_TO_CONFIGURATION_BUNDLE>   <USER>@<VM_IP_OR_FQDN>:~

  6. Conecte-se ao dispositivo de camada superior para instalar o pacote de configuração.

    1. Descompacte o pacote de configuração. Você precisará instalar o zip primeiro.

      sudo apt install zip
unzip ~/<PATH_TO_CONFIGURATION_BUNDLE>/<CONFIGURATION_BUNDLE>.zip #unzip top-layer.zip

    2. Execute o sudo ./install.sh. Insira o endereço IP ou o nome do host. Recomendamos o uso do endereço IP.

    3. Execute sudo iotedge list para confirmar se todos os módulos estão em execução.

  7. Conecte-se ao dispositivo de camada inferior para instalar o pacote de configuração.

    1. Descompacte o pacote de configuração. Você precisará instalar o zip primeiro.

      sudo apt install zip
unzip ~/<PATH_TO_CONFIGURATION_BUNDLE>/<CONFIGURATION_BUNDLE>.zip #unzip lower-layer.zip

    2. Execute o sudo ./install.sh. Insira os endereços IP ou nomes de host do dispositivo e do pai. Recomendamos o uso dos endereços IP.

    3. Execute sudo iotedge list para confirmar se todos os módulos estão em execução.

Se você não especificou um arquivo de implantação para a configuração do dispositivo ou se ocorrerem problemas de implantação, como um manifesto de implantação inválido no dispositivo de camada superior ou inferior, implante manualmente os módulos. Consulte a secção seguinte.

Implantar manualmente o módulo do Registro conectado

Use o seguinte comando para implantar o módulo de registro conectado manualmente em um dispositivo IoT Edge:

az iot edge set-modules \
  --device-id <device-id> \
  --hub-name <hub-name> \
  --content <deployment-manifest-filename>

Para obter detalhes, consulte Implantar módulos do Azure IoT Edge com a CLI do Azure.

Após a implantação bem-sucedida, o registro conectado mostra um status de Online.

Para verificar o status do registro conectado, use o seguinte comando az acr connected-registry show :

az acr connected-registry show \
  --registry $REGISTRY_NAME \
  --name $CONNECTED_REGISTRY_RO \
  --output table

Talvez seja necessário aguardar alguns minutos até que a implantação do registro conectado seja concluída.

Após a implantação bem-sucedida, o registro conectado mostra um status de Online.

Para solucionar problemas de uma implantação, execute iotedge check no dispositivo afetado. Para mais informações, consulte Resolução de Problemas.

Próximos passos

Neste início rápido, você aprendeu como implantar um registro conectado em um dispositivo IoT Edge aninhado. Continue para o próximo guia para saber como extrair imagens do registro conectado recém-implantado.

Solicitar imagens de um registo ligado