Partager via

Didacticiel : Déployer un registre connecté sur une hiérarchie Azure IoT Edge imbriquée

  • Article

Ce didacticiel explique comment utiliser des commandes Azure CLI pour créer une hiérarchie à deux couches d’appareils Azure IoT Edge et déployer un registre connecté en tant que module sur chaque couche. Dans ce scénario, un appareil de la couche supérieure communique avec un registre cloud. Un appareil de la couche inférieure communique avec son registre connecté parent de la couche supérieure.

Pour obtenir une vue d’ensemble de l’utilisation d’un registre connecté avec IoT Edge, consultez Utilisation d’un registre connecté avec Azure IoT Edge.

Prérequis

  • Azure IoT Hub. Pour découvrir les étapes de déploiement, consultez Créer un hub IoT à l’aide du portail Azure.

  • Deux ressources de registre connecté dans Azure. Pour découvrir les étapes du déploiement, consultez les démarrages rapides à l’aide d’Azure CLI ou du portail Azure.

    • Pour la couche supérieure, le registre connecté peut être en mode ReadWrite ou ReadOnly. Cet article part du principe que le registre connecté est en mode lecture-écriture, et que son nom est stocké dans la variable d’environnement $CONNECTED_REGISTRY_RW.
    • Pour la couche inférieure, le registre connecté doit être en mode lecture seule. Cet article part du principe que le nom du registre connecté est stocké dans la variable d’environnement $CONNECTED_REGISTRY_RO.

Importer des images dans votre registre cloud

Importez les images conteneur suivantes dans votre registre cloud à l’aide de la commande az acr import. Si vous avez déjà importé ces images, ignorez cette étape.

Image de registre connecté

Pour prendre en charge des scénarios IoT Edge imbriqués, l’image de conteneur pour le runtime du registre connecté doit être disponible dans votre registre de conteneurs Azure privé. Utilisez la commande az acr import pour importer l’image du registre connecté dans votre registre privé.

# 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

Images d’IoT Edge et de proxy d’API

Pour prendre en charge le registre connecté sur un IoT Edge imbriqué, vous devez déployer des modules pour l’IoT Edge et le proxy d’API. Importez ces images dans votre registre privé.

Le module proxy d’API IoT Edge permet à un appareil IoT Edge d’exposer plusieurs services à l’aide du protocole HTTPS sur le même port, tel que 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

Image Hello-World

Pour tester le registre connecté, importez l’image hello-world. Ce référentiel sera synchronisé sur le registre connecté et extrait par les clients du registre connecté.

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

Récupérer la configuration de registre connecté

Pour déployer chaque registre connecté sur l’appareil IoT Edge dans la hiérarchie, vous devez récupérer les paramètres de configuration à partir de la ressource de registre connecté dans Azure. Si nécessaire, exécutez la commande az acr connected-registry get-settings pour chaque registre connecté afin de récupérer la configuration.

Par défaut, les informations de paramètres n’incluent pas le mot de passe du jeton de synchronisation qui est également nécessaire pour déployer le registre connecté. Vous pouvez également générer l’un des mots de passe en passant le paramètre --generate-password 1 ou --generate-password 2. Enregistrez le mot de passe généré dans un emplacement sûr. Il ne peut pas être récupéré à nouveau.

Avertissement

La régénération d’un mot de passe déclenche une rotation des informations d’identification du jeton de synchronisation. Si vous avez configuré un appareil à l’aide du mot de passe précédent, vous devez mettre à jour la configuration.

# 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 sortie de commande comprend la chaîne de connexion au registre et les paramètres associés. L’exemple de sortie suivant montre la chaîne de connexion du registre connecté nommé myconnectedregistry, avec le registre parent contosoregistry :

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

Configurer les manifestes de déploiement

Un manifeste de déploiement est un document JSON décrivant les modules à déployer sur un appareil IoT Edge. Pour plus d’informations, consultez Comprendre comment les modules IoT Edge peuvent être utilisés, configurés et réutilisés.

Pour déployer le module de registre connecté sur chaque appareil IoT Edge à l’aide d’Azure CLI, enregistrez les manifestes de déploiement suivants localement en tant que fichiers JSON. Utilisez les informations des sections précédentes pour mettre à jour les valeurs JSON pertinentes dans chaque manifeste. Utilisez les chemins de fichier dans la section suivante quand vous exécutez la commande pour appliquer la configuration à votre appareil.

Manifeste de déploiement pour la couche supérieure

Pour l’appareil dans la couche supérieure, créez un fichier manifeste de déploiement deploymentTopLayer.json avec le contenu suivant. Ce manifeste est similaire à celui utilisé dans Démarrage rapide : Déployer un registre connecté sur un appareil IOT Edge.

Notes

Si vous avez déjà déployé un registre connecté sur un appareil IoT Edge de la couche supérieure en suivant le guide de démarrage rapide, vous pouvez l’utiliser dans la couche supérieure d’une hiérarchie imbriquée. Modifiez les étapes de déploiement de ce tutoriel pour le configurer dans la hiérarchie (non montré).

Paramètres du module de registre connecté

  • Utilisez les informations d’identification du jeton et la chaîne de connexion des sections précédentes pour mettre à jour les valeurs JSON pertinentes dans le nœud env.

  • Les variables d’environnement suivantes sont facultatives dans le nœud env :

    Variable Description
    ACR_REGISTRY_LOGIN_SERVER Spécifie un nom d’hôte unique ou un nom de domaine complet. S’il est utilisé, le registre connecté accepte uniquement les requêtes effectuées à cette valeur de serveur de connexion.

    Si aucune valeur n’est fournie, le registre connecté est accessible avec n’importe quelle valeur de serveur de connexion.
    ACR_REGISTRY_CERTIFICATE_VOLUME Si votre registre connecté est accessible via HTTPS, pointe vers le volume sur lequel les certificats HTTPS sont stockés.

    S’il n’est pas défini, l’emplacement par défaut est /var/acr/certs.
    ACR_REGISTRY_DATA_VOLUME Remplace l’emplacement par défaut /var/acr/data où les images sont stockées par le registre connecté.

    Cet emplacement doit correspondre à la liaison de volume pour le conteneur.

    Important

    Si le registre connecté écoute sur un port différent entre 80 et 443, la valeur ACR_REGISTRY_LOGIN_SERVER (si spécifiée) doit inclure le port. Exemple : 192.168.0.100:8080.

  • Une liaison HostPort pour le registre connecté doit être définie si le module proxy d’API n’est pas utilisé. Exemple :

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

Paramètres du module de proxy d’API

  • Le proxy d’API écoute sur le port 8000 configuré comme NGINX_DEFAULT_PORT. Pour plus d’informations sur les paramètres de proxy d’API, consultez le Référentiel GitHub 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
                }
            }
        }
    }
}

Manifeste de déploiement pour la couche inférieure

Pour l’appareil de la couche inférieure, créez un fichier manifeste de déploiement deploymentLowerLayer.json avec le contenu suivant.

Les fichiers de déploiement de la couche inférieure et de la couche supérieure sont globalement similaires. Les différences sont les suivantes :

  • Il extrait les images requises à partir du registre connecté dans la couche supérieure au lieu du registre cloud.

    Quand vous configurez le registre connecté de la couche supérieure, veillez à ce qu’il synchronise toutes les images requises localement, y compris azureiotedge-agent, azureiotedge-hub, azureiotedge-api-proxy et acr/connected-registry. L’appareil IoT de la couche inférieure doit extraire ces images du registre connecté de la couche supérieure.

  • Il utilise le jeton de synchronisation configuré au niveau de la couche inférieure pour s’authentifier auprès du registre connecté de la couche supérieure.

  • Il configure le point de terminaison de la passerelle parente avec l’adresse IP ou le nom de domaine complet (FQDN) du registre connecté de la couche supérieure au lieu du FQDN du registre cloud.

Important

Dans le manifeste de déploiement suivant, $upstream est utilisé comme adresse IP ou FQDN de l’appareil hébergeant le registre connecté parent. Toutefois, $upstream n’est pas pris en charge dans une variable d’environnement. Le registre connecté doit lire la variable d’environnement ACR_PARENT_GATEWAY_ENDPOINT pour obtenir le point de terminaison de la passerelle parente. Au lieu d’utiliser $upstream, le registre connecté prend en charge la résolution dynamique de l’adresse IP ou du FQDN à partir d’une autre variable d’environnement.

Sur l’IoT Edge imbriqué, il existe une variable d’environnement $IOTEDGE_PARENTHOSTNAME dans la couche inférieure, qui équivaut à l’adresse IP ou au FQDN de l’appareil parent. Remplacez manuellement la variable d’environnement en tant que valeur de ParentGatewayEndpoint dans la chaîne de connexion, afin d’éviter de coder en dur l’adresse IP ou le FQDN de l’appareil parent. Étant donné que l’appareil parent dans ce exemple exécute nginx sur le port 8000, passez $IOTEDGE_PARENTHOSTNAME:8000. Vous devez également sélectionner le protocole approprié dans 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
                }
            }
        }
    }
}

Configurer et déployer des modules de registre connecté

Les étapes suivantes sont adaptées à partir de la procédure décrite dans Didacticiel : Créer une hiérarchie d’appareils IoT Edge. Elles sont spécifiques au déploiement de modules de registre connecté dans la hiérarchie IOT Edge. Pour plus d’informations sur les étapes individuelles, consultez ce didacticiel.

Créer des appareils de couche supérieure et de couche inférieure

Créez des machines virtuelles de couche supérieure et de couche inférieure en utilisant un modèle ARM existant. Le modèle installe également l’agent IoT Edge. Si vous souhaitez plutôt opérer le déploiement à partir de vos propres appareils, consultez Didacticiel : Installer ou désinstaller Azure IoT Edge pour Linux afin de savoir comment configurer l’appareil manuellement.

Important

Pour accéder ultérieurement aux modules déployés sur l’appareil de couche supérieure, veillez à ouvrir les ports entrants suivants : 8000, 443, 5671 et 8883. Pour plus d’informations, consultez Guide d’ouverture de ports vers une machine virtuelle avec le portail Azure.

Créer et configurer la hiérarchie

Servez-vous de l’outil iotedge-config pour créer et configurer votre hiérarchie en procédant comme suit dans Azure CLI ou Azure Cloud Shell :

  1. Téléchargez l’outil de configuration.

     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

    Cette étape crée le dossier iotedge_config_cli_release dans le répertoire de votre didacticiel. Le fichier de modèle utilisé pour créer la hiérarchie d’appareils est le fichier iotedge_config.yaml situé dans ~/nested_iot_edge_tutorial/iotedge_config_cli_release/templates/tutorial. Le même répertoire contient deux manifestes de déploiement pour les couches supérieure et inférieure, à savoir les fichiers deploymentTopLayer.json et deploymentLowerLayer.json.

  2. Modifiez iotedge_config.yaml avec vos informations. Modifiez iothub_hostname et iot_name, les noms des fichiers manifestes de déploiement pour les couches supérieure et inférieure, ainsi que les informations d’identification du jeton client que vous avez créées pour extraire des images en amont de chaque couche. Voici un exemple de fichier de configuration :

    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. Préparez les fichiers de déploiement des couches supérieure et inférieure : deploymentTopLayer.json et deploymentLowerLayer.json. Copiez les fichiers manifestes de déploiement que vous avez créés précédemment dans cet article dans le dossier suivant : ~/nestedIotEdgeTutorial/iotedge_config_cli_release/templates/tutorial.

  4. Accédez à votre répertoire iotedge_config_cli_release et exécutez l’outil pour créer votre hiérarchie d’appareils 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

    Avec le paramètre --output, l’outil crée les certificats d’appareil, les bundles de certificats et un fichier journal dans le répertoire de votre choix. Avec le paramètre -f, l’outil recherche automatiquement les appareils IoT Edge existants dans votre hub IoT, et les supprime pour éviter les erreurs et garder votre hub « propre ».

    L’exécution de l’outil peut prendre plusieurs minutes.

  5. Copiez les fichiers top-layer.zip et lower-layer.zip générés à l’étape précédente sur les machines virtuelles des couches supérieure et inférieure en utilisant la commande scp :

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

  6. Connectez-vous à l’appareil de la couche supérieure pour installer le pack de configuration.

    1. Décompressez le pack de configuration. Vous devez d’abord installer le fichier zip.

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

    2. Exécutez sudo ./install.sh. Entrez l’adresse IP ou le nom d’hôte. Nous vous recommandons d’utiliser l’adresse IP.

    3. Exécutez sudo iotedge list pour vérifier que tous les modules fonctionnent.

  7. Connectez-vous à l’appareil de la couche inférieure pour installer le pack de configuration.

    1. Décompressez le pack de configuration. Vous devez d’abord installer le fichier zip.

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

    2. Exécutez sudo ./install.sh. Entrez les adresses IP ou les noms d’hôte de l’appareil et du parent. Nous vous recommandons d’utiliser les adresses IP.

    3. Exécutez sudo iotedge list pour vérifier que tous les modules fonctionnent.

Si vous n’avez pas spécifié un fichier de déploiement pour la configuration de l’appareil, ou si des problèmes de déploiement se produisent, comme la présence d’un manifeste de déploiement non valide sur l’appareil de la couche supérieure ou inférieure, déployez les modules manuellement. Voir la section suivante.

Déployer manuellement le module de registre connecté

Pour déployer manuellement le module de registre connecté sur un appareil IoT Edge, utilisez la commande suivante :

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

Pour plus d’informations, consultez Déployer des modules Azure IoT Edge avec Azure CLI.

Une fois le déploiement réussi, le registre connecté affiche l’état Online.

Pour vérifier l’état du registre connecté, utilisez la commande az acr connected-registry show suivante :

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

Il peut être nécessaire d’attendre quelques minutes avant que le déploiement du registre connecté soit terminé.

Une fois le déploiement réussi, le registre connecté affiche l’état Online.

Pour résoudre des problèmes de déploiement, exécutez la commande iotedge check sur l’appareil concerné. Pour plus d’informations, consultez la page Dépannage.

Étapes suivantes

Dans ce démarrage rapide, vous avez appris à déployer un registre connecté sur un appareil IoT Edge imbriqué. Passez au guide suivant pour découvrir comment extraire des images du registre connecté nouvellement déployé.

Extraire des images à partir d’un registre connecté