Share via

Tutorial: Implementar um registo ligado numa hierarquia de IoT Edge aninhada

  • Artigo

Neste tutorial, vai utilizar comandos da CLI do Azure para criar uma hierarquia de duas camadas do Azure IoT Edge dispositivos e implementar um registo ligado como um módulo em cada camada. Neste cenário, um dispositivo na camada superior comunica com um registo na cloud. Um dispositivo na camada inferior comunica com o respetivo elemento principal de registo ligado na camada superior.

Para obter uma descrição geral da utilização de um registo ligado com IoT Edge, veja Utilizar o registo ligado com o Azure IoT Edge.

Pré-requisitos

  • Hub IoT do Azure. Para obter os passos de implementação, veja Criar um hub IoT com o portal do Azure.

  • Dois recursos de registo ligados no Azure. Para obter os passos de implementação, veja inícios rápidos com a CLI do Azure ou portal do Azure.

    • Para a camada superior, o registo ligado pode estar no modo ReadWrite ou ReadOnly. Este artigo assume o modo ReadWrite e o nome do registo ligado é armazenado na variável $CONNECTED_REGISTRY_RWde ambiente .
    • Para a camada inferior, o registo ligado tem de estar no modo ReadOnly. Este artigo pressupõe que o nome do registo ligado está armazenado na variável $CONNECTED_REGISTRY_ROde ambiente .

Importar imagens para o seu registo na cloud

Importe as seguintes imagens de contentor para o seu registo na cloud com o comando az acr import . Ignore este passo se já tiver importado estas imagens.

Imagem do registo ligado

Para suportar cenários de IoT Edge aninhados, a imagem de contentor do runtime de registo ligado tem de estar disponível no seu registo de contentor privado do Azure. Utilize o comando az acr import para importar a imagem do registo ligado para o seu registo 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

IoT Edge e imagens de proxy de API

Para suportar o registo ligado em IoT Edge aninhadas, tem de implementar 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 IoT Edge permite que um dispositivo IoT Edge exponha vários serviços através do 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 registo ligado, importe a hello-world imagem. Este repositório será sincronizado com o registo ligado e solicitado pelos clientes de registo ligados.

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

Obter a configuração do registo ligado

Para implementar cada registo ligado no IoT Edge dispositivo na hierarquia, tem de obter as definições de configuração do recurso de registo ligado no Azure. Se necessário, execute o comando az acr connected-registry get-settings para cada registo ligado para obter a configuração.

Por predefinição, as informações de definições não incluem a palavra-passe do token de sincronização , que também é necessária para implementar o registo ligado. Opcionalmente, gere uma das palavras-passe ao transmitir o --generate-password 1 parâmetro ou --generate-password 2 . Guarde a palavra-passe gerada numa localização segura. Não é possível recuperá-la novamente.

Aviso

Regenerar uma palavra-passe roda as credenciais do token de sincronização. Se tiver configurado um dispositivo com a palavra-passe anterior, terá de 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 ligação do registo e as definições relacionadas. O resultado de exemplo seguinte mostra a cadeia de ligação do registo ligado com o nome myconnectedregistry com o registo principal contosoregistry:

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

Configurar manifestos de implementação

Um manifesto de implementação é um documento JSON que descreve os módulos a implementar num dispositivo IoT Edge. Para obter mais informações, veja Compreender como IoT Edge módulos podem ser utilizados, configurados e reutilizados.

Para implementar o módulo de registo ligado em cada IoT Edge dispositivo com a CLI do Azure, guarde os seguintes manifestos de implementação localmente como ficheiros JSON. Utilize as informações das secções anteriores para atualizar os valores JSON relevantes em cada manifesto. Utilize os caminhos de ficheiro na secção seguinte quando executar o comando para aplicar a configuração ao seu dispositivo.

Manifesto de implementação para a camada superior

Para o dispositivo na camada superior, crie um ficheiro deploymentTopLayer.json de manifesto de implementação com o seguinte conteúdo. Este manifesto é semelhante ao utilizado no Início Rápido: Implementar um registo ligado num dispositivo IoT Edge.

Nota

Se já tiver implementado um registo ligado numa camada superior IoT Edge dispositivo com o início rápido, pode utilizá-lo na camada superior de uma hierarquia aninhada. Modifique os passos de implementação neste tutorial para configurá-lo na hierarquia (não mostrado).

Definições do módulo de registo ligado

  • Utilize as credenciais do token e a cadeia de ligação das secçõ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 Descrição
    ACR_REGISTRY_LOGIN_SERVER Especifica um nome de anfitrião ou FQDN exclusivo. Se for utilizado, o registo ligado só aceita pedidos feitos a este valor de servidor de início de sessão.

    Se não for fornecido nenhum valor, o registo ligado pode ser acedido com qualquer valor de servidor de início de sessão.
    ACR_REGISTRY_CERTIFICATE_VOLUME Se o seu registo ligado estiver acessível através de HTTPS, aponta para o volume onde os certificados HTTPS estão armazenados.

    Se não estiver definida, a localização predefinida é /var/acr/certs.
    ACR_REGISTRY_DATA_VOLUME Substitui a localização /var/acr/data predefinida onde as imagens serão armazenadas pelo registo ligado.

    Esta localização tem de corresponder ao enlace de volume do contentor.

    Importante

    Se o registo ligado escutar numa porta diferente de 80 e 443, o ACR_REGISTRY_LOGIN_SERVER valor (se especificado) tem de incluir a porta. Exemplo: 192.168.0.100:8080.

  • Um HostPort enlace para o registo ligado deve ser definido se o módulo de proxy de API não for utilizado. Exemplo:

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

Definiçõ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 definições de proxy de API, veja o repositório IoT Edge GitHub.
{
    "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 implementação para a camada inferior

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

No geral, o ficheiro de implementação de camada inferior é semelhante ao ficheiro de implementação de camada superior. As diferenças são:

  • Extrai as imagens necessárias do registo ligado da camada superior em vez de do registo na cloud.

    Quando configurar o registo ligado de camada superior, certifique-se de que sincroniza todas as imagens necessárias localmente, incluindo azureiotedge-agent, azureiotedge-hub, e acr/connected-registryazureiotedge-api-proxy. O dispositivo IoT de camada inferior tem de extrair estas imagens do registo ligado da camada superior.

  • Utiliza o token de sincronização configurado na camada inferior para autenticar com o registo ligado de camada superior.

  • Configura o ponto final do gateway principal com o endereço IP do registo ligado de camada superior ou fQDN em vez de com o FQDN do registo na cloud.

Importante

No seguinte manifesto de implementação, $upstream é utilizado como o endereço IP ou FQDN do dispositivo que aloja o registo ligado principal. No entanto, $upstream não é suportado numa variável de ambiente. O registo ligado tem de ler a variável ACR_PARENT_GATEWAY_ENDPOINT de ambiente para obter o ponto final do gateway principal. Em vez de utilizar $upstreamo , o registo ligado suporta a resolução dinâmica do endereço IP ou do FQDN a partir de outra variável de ambiente.

Na IoT Edge aninhada, existe uma variável $IOTEDGE_PARENTHOSTNAME de ambiente na camada inferior que é igual ao endereço IP ou FQDN do dispositivo principal. Substitua manualmente a variável de ambiente como o valor de na cadeia de ParentGatewayEndpoint ligação para evitar codificar o endereço IP principal ou o FQDN. Uma vez que o dispositivo principal neste exemplo está em execução nginx na porta 8000, transmita $IOTEDGE_PARENTHOSTNAME:8000. Também tem de 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 implementar módulos de registo ligados

Os passos seguintes são adaptados a partir do Tutorial: Criar uma hierarquia de dispositivos IoT Edge e são específicos para implementar módulos de registo ligados na hierarquia de IoT Edge. Veja esse tutorial para obter detalhes sobre os passos individuais.

Criar dispositivos de camada superior e inferior

Crie máquinas virtuais de camada superior e inferior com um modelo arm existente. O modelo também instala o agente IoT Edge. Se quiser 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 aceder mais tarde aos módulos implementados no dispositivo de camada superior, certifique-se de que abre as seguintes portas de entrada: 8000, 443, 5671, 8883. Para obter os passos de configuração, veja Como abrir portas numa máquina virtual com o portal do Azure.

Criar e configurar a hierarquia

Utilize a iotedge-config ferramenta para criar e configurar a hierarquia ao seguir estes passos na CLI do Azure ou no Azure Cloud Shell:

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

    Este passo cria a iotedge_config_cli_release pasta no seu diretório de tutorial. O ficheiro de modelo utilizado para criar a hierarquia de dispositivos é o iotedge_config.yaml ficheiro encontrado em ~/nested_iot_edge_tutorial/iotedge_config_cli_release/templates/tutorial. No mesmo diretório, existem dois manifestos de implementação para camadas superiores e inferiores: deploymentTopLayer.json e deploymentLowerLayer.json ficheiros.

  2. Edite iotedge_config.yaml com as suas informações. Edite os iothub_hostnameiot_namenomes de ficheiro do manifesto de implementação para a camada superior e inferior e as credenciais de token de cliente que criou para extrair imagens a partir de cada camada a montante. O exemplo seguinte é um ficheiro 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 ficheiros de implementação de camada superior e inferior: deploymentTopLayer.json e deploymentLowerLayer.json. Copie os ficheiros de manifesto de implementação que criou anteriormente neste artigo para a seguinte pasta: ~/nestedIotEdgeTutorial/iotedge_config_cli_release/templates/tutorial.

  4. Navegue para o diretório iotedge_config_cli_release e execute a ferramenta para criar a 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, os pacotes de certificados e um ficheiro de registo num diretório à sua escolha. Com o -f parâmetro, a ferramenta procura automaticamente dispositivos IoT Edge existentes no seu Hub IoT e remove-os, para evitar erros e manter o hub limpo.

    A ferramenta pode ser executada durante vários minutos.

  5. Copie os ficheiros top-layer.zipe lower-layer.zip gerados no passo anterior para as máquinas virtuais de camada superior e inferior correspondentes com scp:

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

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

    1. Deszipe o pacote de configuração. Terá de 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. Introduza o endereço IP ou o nome do anfitrião. Recomendamos que utilize o endereço IP.

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

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

    1. Deszipe o pacote de configuração. Terá de 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. Introduza o dispositivo e os endereços IP principais ou os nomes de anfitrião. Recomendamos que utilize os endereços IP.

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

Se não especificou um ficheiro de implementação para a configuração do dispositivo ou se ocorrerem problemas de implementação, como um manifesto de implementação inválido no dispositivo de camada superior ou inferior, implemente manualmente os módulos. Veja a secção seguinte.

Implementar manualmente o módulo de registo ligado

Utilize o seguinte comando para implementar manualmente o módulo de registo ligado num dispositivo IoT Edge:

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

Para obter detalhes, veja Implementar módulos do Azure IoT Edge com a CLI do Azure.

Após a implementação com êxito, o registo ligado mostra o estado de Online.

Para verificar o estado do registo ligado, utilize o seguinte comando az acr connected-registry show :

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

Poderá ter de aguardar alguns minutos até que a implementação do registo ligado seja concluída.

Após a implementação com êxito, o registo ligado mostra o estado de Online.

Para resolver problemas de implementação, execute iotedge check no dispositivo afetado. Para obter mais informações, consulte Resolução de problemas.

Passos seguintes

Neste início rápido, aprendeu a implementar um registo ligado num dispositivo aninhado IoT Edge. Avance para o guia seguinte para saber como extrair imagens do registo ligado recentemente implementado.

Extrair imagens de um registo ligado