Compartilhar via

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

  • Artigo

Neste tutorial, você usará comandos da CLI do Azure para criar uma hierarquia de duas camadas de dispositivos 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 na nuvem. Um dispositivo na camada inferior se comunica com seu registro conectado pai na camada superior.

Para obter uma visão geral do uso de um Registro conectado com o IoT Edge, confira Usar o Registro conectado com o Azure IoT Edge.

Pré-requisitos

  • Hub IoT do Azure. Para saber as etapas de implantação, confira Como criar um Hub IoT usando o portal do Azure.

  • Dois recursos de registro conectados no Azure. Para as etapas de implantação, consulte os inícios rápidos 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 pressupõe o modo ReadWrite e o nome do registro conectado é armazenado na variável de ambiente $CONNECTED_REGISTRY_RW.
    • Para a camada inferior, o registro conectado deve estar no modo ReadOnly. Este artigo pressupõe que nome do registro conectado está armazenado na variável de ambiente $CONNECTED_REGISTRY_RO.

Importar imagens para o registro na nuvem

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

Imagem do registro conectado

Para dar suporte a cenários de IoT Edge aninhados, a imagem de contêiner para o runtime do registro conectado deve estar disponível no registro de contêiner privado do Azure. Use o comando az acr import para importar a imagem de registro conectado para o 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 do proxy de API e IoT Edge

Para dar suporte ao registro conectado no IoT Edge aninhado, é necessário implantar módulos para o proxy de API e IoT Edge. Importe essas imagens para o registro privado.

O módulo de proxy de API do IoT Edge permite que um dispositivo de 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 de olá, mundo

Para testar o registro conectado, importe a imagem hello-world. Esse repositório será sincronizado com o registro conectado e enviado para os clientes do registro conectado.

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

Recuperar a configuração do registro conectado

Para implantar cada registro conectado ao dispositivo de IoT Edge na hierarquia, você precisa recuperar as definições de configuração do recurso de 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 parâmetro --generate-password 1 ou --generate-password 2. Salve a senha gerada em um local seguro. Não será possível realizar novamente a recuperação.

Aviso

A regeneração de uma senha faz a rotação das credenciais do token de sincronização. Se você tiver configurado 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. A seguinte saída de exemplo 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ódulo implantar a um dispositivo IoT Edge. Para obter mais informações, confira Noções básicas sobre como os módulos do IoT Edge podem ser usados, configurados e reutilizados.

Para implantar o módulo do registro conectado em cada dispositivo de 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. Você usará os caminhos do arquivo na próxima seção quando executar o comando para aplicar a configuração ao dispositivo.

Manifesto de implantação para a camada superior

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

Observação

Se você já tiver implantado um registro conectado em um dispositivo IoT Edge de camada superior usando o início rápido, será possível 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 nó env.

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

    Variável Descrição
    ACR_REGISTRY_LOGIN_SERVER Especifica um nome de host ou FQDN exclusivo. Se usado, o Registro conectado só aceita solicitações feitas a esse valor de servidor de logon.

    Se nenhum valor for fornecido, o Registro conectado poderá ser acessado com qualquer valor de servidor de logon.
    ACR_REGISTRY_CERTIFICATE_VOLUME Se o Registro conectado for acessível por HTTPS, apontará para o volume em que 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 padrão /var/acr/data em que as imagens serão armazenadas pelo Registro conectado.

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

    Importante

    Se o Registro conectado escutar em uma porta diferente de 80 e 443, o valor ACR_REGISTRY_LOGIN_SERVER (se especificado) precisará incluir a porta. Exemplo: 192.168.0.100:8080.

  • Uma associação HostPort para o Registro conectado deverá ser definida se o módulo de proxy de 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 de API

  • O proxy de API escutará na porta 8000 configurada como NGINX_DEFAULT_PORT. Para obter mais informações sobre as configurações de proxy de API, confira 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 conteúdo a seguir.

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

  • Ele efetua pull das imagens necessárias do registro conectado da camada superior em vez do registro na nuvem.

    Ao configurar o registro conectado da camada superior, verifique se ele sincronizará todas as imagens necessárias localmente, incluindo azureiotedge-agent, azureiotedge-hub, azureiotedge-api-proxy e acr/connected-registry. O dispositivo IoT de camada inferior precisa efetuar pull dessas 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 da camada superior, em vez de configurar com o FQDN do registro de 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, o $upstream não tem suporte em uma variável de ambiente. O registro conectado precisa ler a variável de ambiente ACR_PARENT_GATEWAY_ENDPOINT para obter o ponto de extremidade do gateway pai. Em vez de usar o $upstream, o registro conectado dá suporte à resolução dinâmica do endereço IP ou FQDN de outra variável de ambiente.

No IoT Edge aninhado, há uma variável de ambiente $IOTEDGE_PARENTHOSTNAME 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 ParentGatewayEndpoint na cadeia de conexão para evitar hard-coding no endereço IP ou FQDN pai. Como o dispositivo pai neste exemplo está executando nginx na porta 8000, transmita $IOTEDGE_PARENTHOSTNAME:8000. Você também precisa selecionar o protocolo adequado no 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 conectado

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

Criar dispositivos de camada superior e de camada inferior

Crie VMs de camada superior e inferior usando um modelo do ARM existente. O modelo também instala o agente do IoT Edge. Se você quiser implantar a partir de seus próprios dispositivos, consulte Tutorial: Instalar ou desinstalar o Azure IoT Edge para Linux para saber como configurar manualmente o dispositivo.

Importante

Para obter 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 saber as etapas de configuração, confira Como abrir as portas de uma máquina virtual com o portal do Azure.

Criar e configurar a hierarquia

Use a ferramenta iotedge-config 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

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

  2. Edite o iotedge_config.yaml com suas informações. Edite os nomes de arquivo de manifesto de implantação iothub_hostname e iot_name para a camada superior e a camada inferior e as credenciais de token de cliente que você criou para efetuar pull de imagens do upstream de cada camada. O seguinte exemplo mostra 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 da camada 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. Acesse 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 parâmetro --output, a ferramenta cria os certificados de dispositivo, os pacotes de certificados e um arquivo de log no diretório de sua preferência. Com o parâmetro -f, a ferramenta procura automaticamente por dispositivos IoT Edge existentes no Hub IoT e os remove para evitar erros e manter o hub limpo.

    A ferramenta pode ficar em execução por vários minutos.

  5. Copie os arquivos top-layer.zip e lower-layer.zip gerados na etapa anterior para as VMs de camada superior e inferior correspondentes usando scp:

    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 sudo ./install.sh. Insira o endereço IP ou o nome de host. É recomendável usar o endereço IP.

    3. Execute sudo iotedge list para confirmar que todos os módulos estejam 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 sudo ./install.sh. Insira os endereços IP ou nomes de host pai e do dispositivo. É recomendável usar os endereços IP.

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

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

Implantar manualmente o módulo de registro conectado

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

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

Para obter os detalhes, confira Implante os módulos do Azure IoT Edge com a CLI do Azure.

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

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

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 mostrará um status de Online.

Para solucionar problemas de implantação, execute iotedge check no dispositivo afetado. Para saber mais, consulte a Solução de problemas.

Próximas etapas

Neste guia de início rápido, você aprendeu a implantar um registro conectado em um dispositivo IoT Edge aninhado. Vá para o próximo guia para saber como efetuar pull de imagens do registro conectado recentemente implantado.

Efetuar pull de imagens de um registro conectado