Condividi tramite

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

  • Articolo

In questa esercitazione vengono usati i comandi dell'interfaccia della riga di comando di Azure per creare una gerarchia a due livelli dei dispositivi Azure IoT Edge e distribuire un registro 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 l'elemento padre del registro connesso nel livello superiore.

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

Prerequisiti

  • Hub IoT di Azure. Per la procedura di distribuzione, vedere Creare un hub IoT con il portale di Azure.

  • Due risorse del registro connesso in Azure. Per la procedura di distribuzione, vedere le guide introduttive con l'interfaccia della riga di comando di Azure o il portale di Azure.

    • Per il livello superiore: il registro connesso può essere impostato in modalità ReadWrite o ReadOnly. Questo articolo presuppone che sia impostata la modalità ReadWrite e che il nome del registro connesso sia archiviato nella variabile di ambiente $CONNECTED_REGISTRY_RW.
    • Per il livello inferiore: il registro connesso deve essere impostato in modalità ReadOnly. Questo articolo presuppone che il nome del registro connesso sia archiviato nella variabile di ambiente $CONNECTED_REGISTRY_RO.

Importare immagini nel registro cloud

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

Immagine del registro connesso

Per supportare scenari IoT Edge annidati, l'immagine del contenitore per il runtime del registro connesso deve essere disponibile nel Registro Azure Container privato. Usare il comando az acr import per importare l'immagine del registro 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

Immagini proxy dell'API e di IoT Edge

Per supportare il registro connesso in IoT Edge annidato, è necessario implementare moduli per il proxy dell'API e IoT Edge. Importare queste immagini nel registro privato.

Il modulo proxy dell'API IoT Edge consente a un dispositivo 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 testare il registro connesso, importare l'immagine hello-world. Questo repository verrà sincronizzato con il registro connesso ed eseguito il pull dai client del registro connesso.

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

Recuperare la configurazione del registro connesso

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

Per impostazione predefinita, le informazioni sulle impostazioni non includono la password del token di sincronizzazione, necessaria anche per implementare il registro connesso. Facoltativamente, generare una delle password passando il parametro --generate-password 1 o --generate-password 2. Salvare la password generata in un percorso sicuro. Non può essere recuperato 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 del comando include la stringa di connessione del registro e le impostazioni correlate. L'output di esempio seguente mostra la stringa di connessione per il registro connesso denominato myconnectedregistry con il registro padre contosoregistry:

{
  "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 della distribuzione è un documento JSON che descrive i moduli da implementare ln un dispositivo IoT Edge. Per altre informazioni, vedere Informazioni sull'uso, la configurazione e il riutilizzo dei moduli IoT Edge.

Per distribuire il modulo del registro connesso in ogni dispositivo IoT Edge tramite l'interfaccia della riga di comando di Azure, salvare i manifesti della 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 file riportati nella sezione successiva quando si esegue il comando per applicare la configurazione al dispositivo.

Manifesto della distribuzione per il livello superiore

Per il dispositivo nel livello superiore, creare un file manifesto della distribuzione deploymentTopLayer.json con il contenuto seguente. Questo manifesto è simile a quello usato in Guida introduttiva: Distribuire un registro connesso in un dispositivo IoT Edge.

Nota

Se un registro connesso è già stato distribuito a un dispositivo IoT Edge nel livello superiore usando la guida introduttiva, è possibile usarlo nel livello superiore di una gerarchia annidata. Modificare la procedura di distribuzione in questa esercitazione per eseguire la configurazione nella gerarchia (non visualizzato).

Impostazioni del modulo del registro connesso

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

  • Nel nodo env sono facoltative le variabili di ambiente seguenti:

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

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

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

    Questo percorso deve corrispondere all'associazione di volumi per il contenitore.

    Importante

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

  • Se il modulo del proxy API non viene usato, è necessario impostare un'associazione HostPort per il registro connesso. Esempio:

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

Impostazioni del modulo del 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 di 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 nel livello inferiore, creare un file manifesto della distribuzione deploymentLowerLayer.json con il contenuto seguente.

In generale, il file della distribuzione nel livello inferiore è simile a quello nel livello superiore. Le differenze sono le seguenti:

  • Esegue il pull delle immagini necessarie dal registro connesso nel livello superiore anziché dal registro cloud.

    Quando si configura il registro connesso nel livello superiore, assicurarsi che sincronizzi tutte le immagini necessarie in locale, tra cui azureiotedge-agent, azureiotedge-hub azureiotedge-api-proxy e acr/connected-registry. Il dispositivo IoT nel livello inferiore deve eseguire il pull di queste immagini dal registro connesso nel livello superiore.

  • Usa il token di sincronizzazione configurato nel livello inferiore per l'autenticazione con il registro connesso nel livello superiore.

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

Importante

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

Nel IoT Edge annidato è presente una variabile di ambiente $IOTEDGE_PARENTHOSTNAME nel livello inferiore che corrisponde all'indirizzo IP o al nome di dominio completo del dispositivo padre. Sostituire manualmente la variabile di ambiente come valore di ParentGatewayEndpoint nella stringa di connessione per evitare di specificare a livello di codice l'indirizzo IP o il nome di dominio completo padre. Poiché il dispositivo padre in questo esempio esegue 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 i moduli del registro connesso

La procedura seguente è stata adattata da Esercitazione: Creare una gerarchia di dispositivi IoT Edge e si riferisce in modo specifico alla distribuzione di moduli del registro connesso nella gerarchia di IoT Edge. Vedere questa esercitazione per informazioni dettagliate sui singoli passaggi.

Creare dispositivi nei livelli superiore e inferiore

Creare macchine virtuali nei livelli superiore e inferiore usando un modello di Azure Resource Manager esistente. Il modello installa anche l'agente di IoT Edge. Per eseguire invece la distribuzione dai propri dispositivi, vedere Esercitazione: Installare o disinstallare Azure IoT Edge per Linux per informazioni su come configurare manualmente il dispositivo.

Importante

Per un accesso successivo ai moduli distribuiti nel dispositivo nel livello superiore, assicurarsi di aprire le porte in ingresso seguenti: 8000, 443, 5671, 8883. Per la procedura di configurazione, vedere Come aprire le porte a una macchina virtuale con il portale di Azure.

Creare e configurare la gerarchia

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

  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

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

  2. Modificare iotedge_config.yaml con le informazioni personali. Modificare iothub_hostname, iot_name, i nomi file del manifesto della distribuzione per i livelli superiore e inferiore e le credenziali del token client create per eseguire il pull delle immagini da ogni livello upstream. L'esempio seguente mostra 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 della distribuzione per i livelli superiore e inferiore: deploymentTopLayer.json e deploymentLowerLayer.json. Copiare i file manifesto della 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 parametro --output, lo strumento crea i certificati dei dispositivi, i bundle di certificati e un file di log in una directory di propria scelta. Con il parametro -f, lo strumento cerca automaticamente i dispositivi IoT Edge esistenti nell'hub IoT e li rimuove per evitare errori e mantenere pulito l'hub.

    L’esecuzione dello strumento potrebbe proseguire per alcuni minuti.

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

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

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

    1. Decomprimere il bundle di configurazione. È prima necessario installare il file .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 nel livello inferiore per installare il bundle di configurazione.

    1. Decomprimere il bundle di configurazione. È prima necessario installare il file .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 padre e del dispositivo o i 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 della distribuzione non valido nel dispositivo nel livello superiore o inferiore, distribuire manualmente i moduli. Vedere la sezione seguente.

Distribuire manualmente il modulo del registro connesso

Usare il comando seguente per distribuire manualmente il modulo del registro 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 Implementare moduli di Azure IoT Edge con l'interfaccia della riga di comando di Azure.

Dopo la corretta distribuzione, il registro connesso mostra lo stato Online.

Per controllare lo stato del registro 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 connesso.

Dopo la corretta distribuzione, il registro connesso mostra lo stato Online.

Per risolvere i problemi relativi a una distribuzione, eseguire iotedge check nel dispositivo interessato. Per ulteriori informazioni, vedere Risoluzione dei problemi.

Passaggi successivi

In questa guida introduttiva si è appreso come implementare un registro connesso in un dispositivo 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 connesso