Tutorial: Implementación de un registro conectado a una jerarquía anidada de IoT Edge

En este tutorial, usará los comandos de la CLI de Azure para crear una jerarquía de dos capas de los dispositivos de Azure IoT Edge e implementar un registro conectado como un módulo en cada capa. En este escenario, un dispositivo de la capa superior se comunica con un registro en la nube. Un dispositivo de la capa inferior se comunica con su registro conectado primario de la capa superior.

Para obtener información general sobre el uso de un registro conectado con IoT Edge, consulte Uso del registro conectado con Azure IoT Edge.

Requisitos previos

• Use el entorno de Bash en Azure Cloud Shell. Para más información, consulte Inicio rápido para Bash en Azure Cloud Shell.

  

• Si prefiere ejecutar comandos de referencia de la CLI localmente, instale la CLI de Azure. Si utiliza Windows o macOS, considere la posibilidad de ejecutar la CLI de Azure en un contenedor Docker. Para más información, vea Ejecución de la CLI de Azure en un contenedor de Docker.

  • Si usa una instalación local, inicie sesión en la CLI de Azure mediante el comando az login. Siga los pasos que se muestran en el terminal para completar el proceso de autenticación. Para ver otras opciones de inicio de sesión, consulte Inicio de sesión con la CLI de Azure.

  • En caso de que se le solicite, instale las extensiones de la CLI de Azure la primera vez que la use. Para más información sobre las extensiones, consulte Uso de extensiones con la CLI de Azure.

  • Ejecute az version para buscar cuál es la versión y las bibliotecas dependientes que están instaladas. Para realizar la actualización a la versión más reciente, ejecute az upgrade.

• Azure IoT Hub. Para conocer los pasos de implementación, consulte Creación de un centro de IoT con Azure Portal.

• Dos recursos del Registro conectados en Azure. Para conocer los pasos de implementación, consulte las guías de inicio rápido mediante la CLI de Azure o Azure Portal.

  • Para la capa superior, el registro conectado puede estar en modo ReadWrite o ReadOnly. En este artículo se da por supuesto que el modo ReadWrite y el nombre del registro conectado se almacenan en la variable $CONNECTED_REGISTRY_RW.
  • Para la capa inferior, el registro conectado debe estar en modo ReadOnly. En este artículo se da por supuesto que el nombre del registro conectado se almacena en la variable de entorno $CONNECTED_REGISTRY_RO.

Importación de imágenes en el registro en la nube

Importe las siguientes imágenes de contenedor en el registro en la nube mediante el comando az acr import. Omita este paso si ya ha importado estas imágenes.

Imagen de registro conectado

Para admitir escenarios de IoT Edge, la imagen de contenedor para el entorno de ejecución del registro conectado debe estar disponible en la instancia privada de Azure Container Registry. Use el comando az acr import para importar la imagen del registro conectado en el 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

IoT Edge e imágenes del proxy de API

Para admitir el registro conectado en IoT Edge anidado, debe implementar módulos para IoT Edge y el proxy de API. Importe estas imágenes en el registro privado.

El módulo del proxy de API de IoT Edge permite que un dispositivo IoT Edge exponga varios servicios mediante el protocolo HTTPS en el mismo puerto, 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

Imagen de Hola mundo

Para probar el registro conectado, importe la imagen hello-world. Este repositorio se sincronizará con el registro conectado y lo extraerán los clientes del registro conectado.

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

Recuperación de la configuración del Registro conectado

Para implementar cada registro conectado en el dispositivo de IoT Edge en la jerarquía, debe recuperar los valores de configuración del recurso del registro conectado en Azure. Si es necesario, ejecute el comando az acr connected-registry get-settings para que cada registro conectado recupere la configuración.

De forma predeterminada, la información de configuración no incluye la contraseña del token de sincronización, que también es necesaria para implementar el registro conectado. Opcionalmente, genere una de las contraseñas pasando los parámetros --generate-password 1 o --generate-password 2. Guarde la contraseña generada en una ubicación segura. No se puede recuperar de nuevo.

Advertencia

Al volver a generar una contraseña, se rotan las credenciales del token de sincronización. Si configuró un dispositivo con la contraseña anterior, es preciso que actualice la configuración.

# 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

La salida del comando incluye la cadena de conexión del registro y la configuración relacionada. En la salida de ejemplo siguiente, se muestra la cadena de conexión del registro conectado llamado myconnectedregistry con el registro primario contosoregistry:

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

Configuración de manifiestos de implementación

Un manifiesto de implementación es un documento JSON que describe los módulos que se implementarán en un dispositivo de IoT Edge. Para obtener más información, consulte Descripción de cómo se pueden utilizar, configurar y reutilizar los módulos de IoT Edge.

Para implementar el módulo del Registro conectado en cada dispositivo de IoT Edge mediante la CLI de Azure, guarde los siguientes manifiestos de implementación localmente como archivos JSON. Use la información de las secciones anteriores para actualizar los valores JSON pertinentes en cada manifiesto. Usará las rutas de acceso al archivo en la sección siguiente, al ejecutar el comando para aplicar la configuración al dispositivo.

Manifiesto de implementación para la capa superior

Para el dispositivo de la capa superior, cree un archivo de manifiesto de implementación deploymentTopLayer.json con el siguiente contenido. Este manifiesto es similar al que se usa en Inicio rápido: Implementación de un registro conectado en un dispositivo de IoT Edge.

Nota

Si ya ha implementado un registro conectado en un dispositivo IoT Edge de nivel superior mediante el inicio rápido, puede usarlo en la capa superior de una jerarquía anidada. Modifique los pasos de implementación de este tutorial para configurarlo en la jerarquía (esto no se muestra).

Configuración del módulo de registro conectado

• Use las credenciales del token y la cadena de conexión de las secciones anteriores para actualizar los valores JSON pertinentes en el nodo env.

• Las siguientes variables de entorno son opcionales en el nodo env:

  Variable	Descripción
  ACR_REGISTRY_LOGIN_SERVER	Especifica un nombre de host único o un FQDN. Si se utiliza, el registro conectado solo acepta las solicitudes realizadas a este valor de servidor de inicio de sesión. Si no se proporciona ningún valor, se puede acceder al registro conectado con cualquier valor de servidor de inicio de sesión.
  ACR_REGISTRY_CERTIFICATE_VOLUME	Si el registro conectado va a ser accesible mediante HTTPS, apunta al volumen en el que se almacenan los certificados HTTPS. Si no se establece, la ubicación predeterminada es /var/acr/certs.
  ACR_REGISTRY_DATA_VOLUME	Sobrescribe la ubicación predeterminada /var/acr/data en la que el registro conectado almacenará las imágenes. Esta ubicación debe coincidir con el enlace de volumen del contenedor.

  Importante

  Si el registro conectado escucha en un puerto diferente del 80 y el 443, el valor de ACR_REGISTRY_LOGIN_SERVER (si se especifica) debe incluir el puerto. Ejemplo: 192.168.0.100:8080.

• Se debe establecer un enlace HostPort para el registro conectado si no se usa el módulo de proxy de API. Ejemplo:

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

Configuración del módulo de proxy de API

• El proxy de API escuchará en el puerto 8000 configurado como NGINX_DEFAULT_PORT. Para más información sobre la configuración del proxy de API, consulte el repositorio de GitHub de 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
                }
            }
        }
    }
}

Manifiesto de implementación para la capa inferior

Para el dispositivo de la capa inferior, cree un archivo de manifiesto de implementación deploymentLowerLayer.json con el siguiente contenido.

En general, el archivo de implementación de capa inferior es similar al archivo de implementación de capa superior. Las diferencias son:

• Extrae las imágenes necesarias del registro conectado de nivel superior en lugar del registro en la nube.

  Al configurar el registro conectado de la capa superior, asegúrese de que sincronice todas las imágenes necesarias localmente, incluidas azureiotedge-agent, azureiotedge-hub, azureiotedge-api-proxy y acr/connected-registry. El dispositivo de IoT de capa inferior debe extraer estas imágenes del registro conectado de la capa superior.

• Usa el token de sincronización configurado en la capa inferior para autenticarse con el registro conectado de nivel superior.

• Configura el punto de conexión de puerta de enlace principal con la dirección IP o FQDN del registro conectado de nivel superior, en lugar de usar el FQDN del registro en la nube.

Importante

En el siguiente manifiesto de implementación, $upstream se usa como dirección IP o FQDN del dispositivo que hospeda el registro conectado primario. Sin embargo, $upstream no se admite en una variable de entorno. El registro conectado debe leer la variable de entorno ACR_PARENT_GATEWAY_ENDPOINT para obtener el punto de conexión de la puerta de enlace principal. En lugar de usar $upstream, el registro conectado admite la resolución dinámica de la dirección IP o el FQDN desde otra variable de entorno.

En la instancia de IoT Edge anidada, hay una variable de entorno $IOTEDGE_PARENTHOSTNAME en la capa inferior que es igual a la dirección IP o el FQDN del dispositivo primario. Reemplace manualmente la variable de entorno como el valor de ParentGatewayEndpoint en la cadena de conexión para evitar codificar de forma rígida la dirección IP principal o el FQDN. Dado que el dispositivo primario de este ejemplo ejecuta nginx en el puerto 8000, pase $IOTEDGE_PARENTHOSTNAME:8000. También debe seleccionar el protocolo adecuado en 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
                }
            }
        }
    }
}

Configuración e implementación de módulos de registro conectado

Los pasos siguientes se adaptan a partir del Tutorial: Creación de una jerarquía de dispositivos de IoT Edge y son específicos para implementar módulos del Registro conectados en la jerarquía de IoT Edge. Consulte ese tutorial para obtener más información sobre los pasos individuales.

Creación de dispositivos de capa superior e inferior

Cree las máquinas virtuales de la capa superior y la capa inferior mediante una plantilla de ARM existente. La plantilla también instala el agente de IoT Edge. Si en su lugar quiere realizar la implementación desde sus propios dispositivos, consulte Tutorial: Instalación o desinstalación de Azure IoT Edge para Linux para aprender a configurar manualmente el dispositivo.

Importante

Para obtener acceso posterior a los módulos implementados en el dispositivo de nivel superior, asegúrese de abrir los siguientes puertos entrantes: 8000, 443, 5671, 8883. Para conocer los pasos de configuración, consulte Apertura de puertos en una VM con Azure Portal.

Creación y configuración de la jerarquía

Use la herramienta iotedge-config para crear y configurar la jerarquía siguiendo estos pasos en la CLI de Azure o Azure Cloud Shell:

1. Descargue la herramienta de configuración.

    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
   

   Mediante este paso se crea la carpeta iotedge_config_cli_release en el directorio del tutorial. El archivo de plantilla que se usa para crear la jerarquía de dispositivos es iotedge_config.yaml que se encuentra en ~/nested_iot_edge_tutorial/iotedge_config_cli_release/templates/tutorial. En el mismo directorio, hay dos manifiestos de implementación para las capas superior e inferior y los archivos deploymentTopLayer.json y deploymentLowerLayer.json.

2. Edite iotedge_config.yaml con su información. Edite los nombres de archivo del manifiesto de implementación iothub_hostname e iot_name de la capa superior y la capa inferior, y las credenciales del token de cliente que creó para extraer imágenes del flujo ascendente de cada capa. El ejemplo siguiente es un archivo de configuración de ejemplo:

   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 los archivos de implementación de la capa superior y la capa inferior: deploymentTopLayer.json y deploymentLowerLayer.json. Copie los archivos de manifiesto de implementación que creó anteriormente en este artículo en la carpeta siguiente: ~/nestedIotEdgeTutorial/iotedge_config_cli_release/templates/tutorial.

4. Vaya al directorio iotedge_config_cli_release y ejecute la herramienta para crear la jerarquía 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
   

   Con el parámetro --output, la herramienta crea los certificados de dispositivo, las agrupaciones de certificados y un archivo de registro en el directorio que prefiera. Con el parámetro -f, la herramienta busca automáticamente los dispositivos IoT Edge existentes en el centro de IoT y los quita, para evitar errores y mantener limpio el centro.

   La herramienta podría ejecutarse durante varios minutos.

5. Copie los archivos top-layer.zip y lower-layer.zip generados en el paso anterior en las máquinas virtuales de la capa superior e inferior correspondientes mediante scp:

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

6. Conéctese al dispositivo de capa superior para instalar el conjunto de configuración.

   1. Descomprima la agrupación de la configuración. Primero tendrá que instalar el archivo comprimido.

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

   2. Ejecute sudo ./install.sh. Escriba la dirección IP o el nombre de host. Se recomienda usar la dirección IP.

   3. Ejecute sudo iotedge list para confirmar que todos los módulos se están ejecutando.

7. Conéctese al dispositivo de capa inferior para instalar el conjunto de configuración.

   1. Descomprima la agrupación de la configuración. Primero tendrá que instalar el archivo comprimido.

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

   2. Ejecute sudo ./install.sh. Escriba las direcciones IP primarias o los nombres de host del dispositivo y el elemento primario. Se recomienda usar las direcciones IP.

   3. Ejecute sudo iotedge list para confirmar que todos los módulos se están ejecutando.

Si no especificó un archivo de implementación para la configuración del dispositivo o si se producen problemas de implementación, como un manifiesto de implementación no válido en el dispositivo de la capa superior o inferior, implemente manualmente los módulos. Consulte la sección siguiente.

Implementación manual del módulo del Registro conectado

Use el siguiente comando para implementar manualmente el módulo del Registro conectado en un dispositivo de IoT Edge:

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

Para obtener más detalles, consulte Implementación de módulos de Azure IoT Edge con la CLI de Azure.

Después de una implementación correcta, el registro conectado muestra un estado de Online.

Para comprobar el estado del registro conectado, use el siguiente comando aaz acr connected-registry show:

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

Es posible que tenga que esperar unos minutos hasta que se complete la implementación del registro conectado.

Después de una implementación correcta, el registro conectado muestra un estado de Online.

Para solucionar problemas de una implementación, ejecute iotedge check en el dispositivo afectado. Para más información, consulte Solución de problemas.

Pasos siguientes

En este inicio rápido, ha aprendido a implementar un registro conectado en un dispositivo anidado de IoT Edge. Continúe con la siguiente guía para aprender a extraer imágenes del registro conectado recién implementado.

Extracción de imágenes de un registro conectado