Share via

Esercitazione: Distribuire un Registro di sistema connesso in una gerarchia di IoT Edge annidata

  • Articolo

In questa esercitazione si usano i comandi dell'interfaccia della riga di comando di Azure per creare una gerarchia a due livelli di dispositivi di Azure IoT Edge e distribuire un Registro di sistema connesso come modulo a ogni livello. In questo scenario un dispositivo nel livello superiore comunica con un registro cloud. Un dispositivo nel livello inferiore comunica con il relativo padre del Registro di sistema connesso nel livello superiore.

Per una panoramica dell'uso di un Registro di sistema connesso con IoT Edge, vedere Uso del Registro di sistema connesso con Azure IoT Edge.

Prerequisiti

  • Hub IoT di Azure. Per i passaggi di distribuzione, vedere Creare un hub IoT usando la portale di Azure.

  • Due risorse del Registro di sistema connesse in Azure. Per la procedura di distribuzione, vedere Avvio rapido tramite l'interfaccia della riga di comando di Azure o portale di Azure.

    • Per il livello superiore, il Registro di sistema connesso può essere in modalità ReadWrite o ReadOnly. Questo articolo presuppone la modalità ReadWrite e il nome del Registro di sistema connesso viene archiviato nella variabile $CONNECTED_REGISTRY_RWdi ambiente .
    • Per il livello inferiore, il Registro di sistema connesso deve essere in modalità ReadOnly. Questo articolo presuppone che il nome del Registro di sistema connesso sia archiviato nella variabile $CONNECTED_REGISTRY_ROdi ambiente .

Importare immagini nel registro cloud

Importare le immagini del contenitore seguenti nel registro cloud usando il comando az acr import . Ignorare questo passaggio se queste immagini sono già state importate.

Immagine del Registro di sistema connessa

Per supportare scenari di IoT Edge annidati, l'immagine del contenitore per il runtime del Registro di sistema connesso deve essere disponibile nel registro Azure Container privato. Usare il comando az acr import per importare l'immagine del Registro di sistema connessa nel registro privato.

# 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 immagini proxy API

Per supportare il Registro di sistema connesso in IoT Edge annidati, è necessario distribuire moduli per il proxy di IoT Edge e API. Importare queste immagini nel registro privato.

Il modulo proxy API IoT Edge consente a un dispositivo di IoT Edge di esporre più servizi usando il protocollo HTTPS sulla stessa porta, ad esempio 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

Immagine hello-world

Per il test del Registro di sistema connesso, importare l'immagine hello-world . Questo repository verrà sincronizzato con il Registro di sistema connesso e eseguito il pull dai client del Registro di sistema connessi.

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

Recuperare la configurazione del Registro di sistema connessa

Per distribuire ogni Registro di sistema connesso al dispositivo IoT Edge nella gerarchia, è necessario recuperare le impostazioni di configurazione dalla risorsa del Registro di sistema connesso in Azure. Se necessario, eseguire il comando az acr connected-registry get-settings per ogni Registro di sistema connesso per recuperare la configurazione.

Per impostazione predefinita, le informazioni sulle impostazioni non includono la password del token di sincronizzazione , necessaria anche per distribuire il Registro di sistema connesso. Facoltativamente, generare una delle password passando il --generate-password 1 parametro o --generate-password 2 . Salvare la password generata in una posizione sicura. Non è possibile recuperare di nuovo.

Avviso

La rigenerazione di una password ruota le credenziali del token di sincronizzazione. Se è stato configurato un dispositivo usando la password precedente, è necessario aggiornare la configurazione.

# 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

L'output dei comandi include la stringa di connessione del Registro di sistema e le impostazioni correlate. L'output di esempio seguente mostra la stringa di connessione per il Registro di sistema connesso denominato myconnectedregistry con contosoregistry del Registro di sistema padre:

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

Configurare i manifesti della distribuzione

Un manifesto di distribuzione è un documento JSON che descrive i moduli da distribuire in un dispositivo IoT Edge. Per altre informazioni, vedere Informazioni su come usare, configurare e riutilizzare i moduli IoT Edge.

Per distribuire il modulo del Registro di sistema connesso in ogni dispositivo IoT Edge usando l'interfaccia della riga di comando di Azure, salvare i manifesti di distribuzione seguenti in locale come file JSON. Usare le informazioni delle sezioni precedenti per aggiornare i valori JSON pertinenti in ogni manifesto. Usare i percorsi dei file nella sezione successiva quando si esegue il comando per applicare la configurazione al dispositivo.

Manifesto della distribuzione per il livello superiore

Per il dispositivo al livello superiore, creare un file deploymentTopLayer.json manifesto di distribuzione con il contenuto seguente. Questo manifesto è simile a quello usato in Avvio rapido: distribuire un Registro di sistema connesso a un dispositivo IoT Edge.

Nota

Se è già stato distribuito un Registro di sistema connesso a un dispositivo di livello superiore IoT Edge usando la guida introduttiva, è possibile usarlo al livello superiore di una gerarchia annidata. Modificare i passaggi di distribuzione in questa esercitazione per configurarla nella gerarchia (non visualizzata).

Impostazioni del modulo del Registro di sistema connesse

  • Usare le credenziali del token e la stringa di connessione dalle sezioni precedenti per aggiornare i valori JSON pertinenti nel env nodo.

  • Le variabili di ambiente seguenti sono facoltative nel env nodo:

    Variabile Descrizione
    ACR_REGISTRY_LOGIN_SERVER Specifica un nome host univoco o un nome di dominio completo. Se usato, il Registro di sistema connesso accetta solo le richieste effettuate a questo valore del server di accesso.

    Se non viene fornito alcun valore, è possibile accedere al Registro di sistema connesso con qualsiasi valore del server di accesso.
    ACR_REGISTRY_CERTIFICATE_VOLUME Se il Registro di sistema connesso sarà accessibile tramite HTTPS, punta al volume in cui vengono archiviati i certificati HTTPS.

    Se non è impostato, il percorso predefinito è /var/acr/certs.
    ACR_REGISTRY_DATA_VOLUME Sovrascrive la posizione /var/acr/data predefinita in cui le immagini verranno archiviate dal Registro di sistema connesso.

    Questa posizione deve corrispondere all'associazione del volume per il contenitore.

    Importante

    Se il Registro di sistema connesso è in ascolto su una porta diversa da 80 e 443, il ACR_REGISTRY_LOGIN_SERVER valore (se specificato) deve includere la porta. Esempio: 192.168.0.100:8080.

  • Un'associazione HostPort per il Registro di sistema connesso deve essere impostata se il modulo proxy API non viene usato. Esempio:

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

Impostazioni del modulo proxy API

  • Il proxy API sarà in ascolto sulla porta 8000 configurata come NGINX_DEFAULT_PORT. Per altre informazioni sulle impostazioni del proxy API, vedere il repository 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
                }
            }
        }
    }
}

Manifesto della distribuzione per il livello inferiore

Per il dispositivo a livello inferiore, creare una distribuzione del file manifesto di distribuzioneLowerLayer.json con il contenuto seguente.

In generale, il file di distribuzione del livello inferiore è simile al file di distribuzione di livello superiore. Le differenze sono le seguenti:

  • Esegue il pull delle immagini necessarie dal Registro di sistema connesso al livello superiore anziché dal Registro di sistema cloud.

    Quando si configura il Registro di sistema connesso al livello superiore, assicurarsi di sincronizzare tutte le immagini necessarie in locale, tra cui azureiotedge-agent, azureiotedge-hubazureiotedge-api-proxy, e acr/connected-registry. Il dispositivo IoT di livello inferiore deve eseguire il pull di queste immagini dal Registro di sistema connesso al livello superiore.

  • Usa il token di sincronizzazione configurato al livello inferiore per eseguire l'autenticazione con il Registro di sistema connesso al livello superiore.

  • Configura l'endpoint gateway padre con l'indirizzo IP o il nome di dominio completo del Registro di sistema connesso superiore anziché con il nome di dominio completo del Registro di sistema cloud.

Importante

Nel manifesto $upstream di distribuzione seguente viene usato come indirizzo IP o FQDN del dispositivo che ospita il Registro di sistema connesso padre. Tuttavia, $upstream non è supportato in una variabile di ambiente. Il Registro di sistema connesso deve leggere la variabile ACR_PARENT_GATEWAY_ENDPOINT di ambiente per ottenere l'endpoint gateway padre. Anziché usare $upstream, il Registro di sistema connesso supporta la risoluzione dinamica dell'indirizzo IP o del nome di dominio completo da un'altra variabile di ambiente.

Nella IoT Edge annidata è presente una variabile $IOTEDGE_PARENTHOSTNAME di ambiente nel livello inferiore uguale all'indirizzo IP o al nome di dominio completo del dispositivo padre. Sostituire manualmente la variabile di ambiente come valore della stringa di ParentGatewayEndpoint connessione per evitare il codice rigido dell'indirizzo IP padre o il nome di dominio completo. Poiché il dispositivo padre in questo esempio è in esecuzione nginx sulla porta 8000, passare $IOTEDGE_PARENTHOSTNAME:8000. È anche necessario selezionare il protocollo appropriato in 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
                }
            }
        }
    }
}

Configurare e distribuire moduli del Registro di sistema connessi

I passaggi seguenti vengono adattati da Esercitazione: Creare una gerarchia di dispositivi IoT Edge e sono specifici per distribuire i moduli del Registro di sistema connessi nella gerarchia di IoT Edge. Per informazioni dettagliate sui singoli passaggi, vedere l'esercitazione.

Creare dispositivi di livello superiore e livello inferiore

Creare macchine virtuali di livello superiore e livello inferiore usando un modello di Resource Manager esistente. Il modello installa anche l'agente di IoT Edge. Se si vuole distribuire dai propri dispositivi, vedere Esercitazione: Installare o disinstallare Azure IoT Edge per Linux per informazioni su come configurare manualmente il dispositivo.

Importante

Per accedere in un secondo momento ai moduli distribuiti nel dispositivo di livello superiore, assicurarsi di aprire le porte in ingresso seguenti: 8000, 443, 5671, 8883. Per i passaggi di configurazione, vedere Come aprire le porte a una macchina virtuale con la portale di Azure.

Creare e configurare la gerarchia

Usare lo strumento per creare e configurare la iotedge-config gerarchia seguendo questa procedura nell'interfaccia della riga di comando di Azure o nel Cloud Shell di Azure:

  1. Scaricare lo strumento di configurazione.

     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

    Questo passaggio crea la cartella nella directory dell'esercitazione iotedge_config_cli_release . Il file modello usato per creare la gerarchia del dispositivo è il iotedge_config.yaml file trovato in ~/nested_iot_edge_tutorial/iotedge_config_cli_release/templates/tutorial. Nella stessa directory sono presenti due manifesti di distribuzione per i livelli superiore e inferiore: deploymentTopLayer.json e deploymentLowerLayer.json i file.

  2. Modificare iotedge_config.yaml con le informazioni. Modificare i iothub_hostnameiot_namenomi dei file del manifesto di distribuzione per il livello superiore e il livello inferiore e le credenziali del token client create per eseguire il pull delle immagini da upstream da ogni livello. L'esempio seguente è un file di configurazione di esempio:

    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. Preparare i file di distribuzione di livello superiore e inferiore: deploymentTopLayer.json e deploymentLowerLayer.json. Copiare i file manifesto di distribuzione creati in precedenza in questo articolo nella cartella seguente: ~/nestedIotEdgeTutorial/iotedge_config_cli_release/templates/tutorial.

  4. Passare alla directory iotedge_config_cli_release ed eseguire lo strumento per creare la gerarchia dei dispositivi 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 il --output parametro, lo strumento crea i certificati del dispositivo, i bundle di certificati e un file di log in una directory di propria scelta. Con il parametro, lo -f strumento cerca automaticamente i dispositivi esistenti IoT Edge nel hub IoT e li rimuove, per evitare errori e mantenere l'hub pulito.

    Lo strumento può essere eseguito per diversi minuti.

  5. Copiare i file top-layer.zipgenerati e lower-layer.zip generati nel passaggio precedente nelle macchine virtuali top e inferiore corrispondenti usando scp:

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

  6. Connettersi al dispositivo livello superiore per installare il bundle di configurazione.

    1. Decomprimere il bundle di configurazione. Per prima cosa è necessario installare zip.

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

    2. Eseguire sudo ./install.sh. Immettere l'indirizzo IP o il nome host. È consigliabile usare l'indirizzo IP.

    3. Eseguire sudo iotedge list per verificare che tutti i moduli siano in esecuzione.

  7. Connettersi al dispositivo livello inferiore per installare il bundle di configurazione.

    1. Decomprimere il bundle di configurazione. Per prima cosa è necessario installare zip.

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

    2. Eseguire sudo ./install.sh. Immettere gli indirizzi IP del dispositivo e padre o nomi host. È consigliabile usare gli indirizzi IP.

    3. Eseguire sudo iotedge list per verificare che tutti i moduli siano in esecuzione.

Se non è stato specificato un file di distribuzione per la configurazione del dispositivo o se si verificano problemi di distribuzione, ad esempio un manifesto di distribuzione non valido nel dispositivo superiore o inferiore, distribuire manualmente i moduli. Vedere la sezione seguente.

Distribuire manualmente il modulo del Registro di sistema connesso

Usare il comando seguente per distribuire manualmente il modulo del Registro di sistema connesso in un dispositivo IoT Edge:

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

Per informazioni dettagliate, vedere Distribuire moduli di Azure IoT Edge con l'interfaccia della riga di comando di Azure.

Dopo aver completato la distribuzione, il Registro di sistema connesso mostra uno stato di Online.

Per controllare lo stato del Registro di sistema connesso, usare il comando az acr connected-registry show seguente:

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

Potrebbe essere necessario attendere alcuni minuti fino al completamento della distribuzione del Registro di sistema connesso.

Dopo aver completato la distribuzione, il Registro di sistema connesso mostra uno stato di Online.

Per risolvere i problemi di una distribuzione, eseguire iotedge check nel dispositivo interessato. Per altre informazioni, vedere Risoluzione dei problemi.

Passaggi successivi

In questa guida introduttiva si è appreso come distribuire un Registro di sistema connesso a un dispositivo annidato IoT Edge. Continuare con la guida successiva per informazioni su come eseguire il pull delle immagini dal registro connesso appena distribuito.

Eseguire il pull di immagini da un Registro di sistema connesso