Udostępnij za pośrednictwem

Samouczek: wdrażanie połączonego rejestru w zagnieżdżonej hierarchii usługi IoT Edge

  • Artykuł

W tym samouczku użyjesz poleceń interfejsu wiersza polecenia platformy Azure, aby utworzyć hierarchię dwuwarstwową urządzeń usługi Azure IoT Edge i wdrożyć połączony rejestr jako moduł w każdej warstwie. W tym scenariuszu urządzenie w górnej warstwie komunikuje się z rejestrem w chmurze. Urządzenie w niższej warstwie komunikuje się z połączonym elementem nadrzędnym rejestru w górnej warstwie.

Aby zapoznać się z omówieniem korzystania z połączonego rejestru z usługą IoT Edge, zobacz Używanie połączonego rejestru z usługą Azure IoT Edge.

Wymagania wstępne

  • Azure IoT Hub. Aby uzyskać instrukcje wdrażania, zobacz Tworzenie centrum IoT Hub przy użyciu witryny Azure Portal.

  • Dwa połączone zasoby rejestru na platformie Azure. Aby uzyskać instrukcje wdrażania, zobacz Przewodniki Szybki start przy użyciu interfejsu wiersza polecenia platformy Azure lub witryny Azure Portal.

    • W górnej warstwie połączony rejestr może być w trybie ReadWrite lub ReadOnly. W tym artykule przyjęto założenie, że tryb ReadWrite, a połączona nazwa rejestru jest przechowywana w zmiennej środowiskowej $CONNECTED_REGISTRY_RW.
    • W przypadku niższej warstwy połączony rejestr musi być w trybie ReadOnly. W tym artykule założono, że połączona nazwa rejestru jest przechowywana w zmiennej środowiskowej $CONNECTED_REGISTRY_RO.

Importowanie obrazów do rejestru w chmurze

Zaimportuj następujące obrazy kontenerów do rejestru w chmurze przy użyciu polecenia az acr import . Pomiń ten krok, jeśli te obrazy zostały już zaimportowane.

Obraz połączonego rejestru

Aby obsługiwać zagnieżdżone scenariusze usługi IoT Edge, obraz kontenera dla połączonego środowiska uruchomieniowego rejestru musi być dostępny w prywatnym rejestrze kontenerów platformy Azure. Za pomocą polecenia az acr import zaimportuj połączony obraz rejestru do rejestru prywatnego.

# 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

Obrazy serwera proxy usługi IoT Edge i interfejsu API

Aby obsługiwać połączony rejestr w zagnieżdżonym usłudze IoT Edge, należy wdrożyć moduły dla serwera proxy usługi IoT Edge i interfejsu API. Zaimportuj te obrazy do rejestru prywatnego.

Moduł serwera proxy interfejsu API usługi IoT Edge umożliwia urządzeniu usługi IoT Edge uwidocznienie wielu usług przy użyciu protokołu HTTPS na tym samym porcie, takim jak 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

Obraz hello-world

Aby przetestować połączony rejestr, zaimportuj hello-world obraz. To repozytorium zostanie zsynchronizowane z połączonym rejestrem i pobrane przez połączonych klientów rejestru.

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

Pobieranie konfiguracji połączonego rejestru

Aby wdrożyć każdy połączony rejestr na urządzeniu usługi IoT Edge w hierarchii, należy pobrać ustawienia konfiguracji z połączonego zasobu rejestru na platformie Azure. W razie potrzeby uruchom polecenie az acr connected-registry get-settings dla każdego połączonego rejestru, aby pobrać konfigurację.

Domyślnie informacje o ustawieniach nie zawierają hasła tokenu synchronizacji, które jest również wymagane do wdrożenia połączonego rejestru. Opcjonalnie wygeneruj jedno z haseł, przekazując --generate-password 1 parametr or --generate-password 2 . Zapisz wygenerowane hasło w bezpiecznej lokalizacji. Nie można go pobrać ponownie.

Ostrzeżenie

Ponowne generowanie hasła obraca poświadczenia tokenu synchronizacji. Jeśli urządzenie zostało skonfigurowane przy użyciu poprzedniego hasła, musisz zaktualizować konfigurację.

# 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

Dane wyjściowe polecenia obejmują parametry połączenia rejestru i powiązane ustawienia. W poniższych przykładowych danych wyjściowych przedstawiono parametry połączenia dla połączonego rejestru o nazwie myconnectedregistry z rejestrem nadrzędnym contosoregistry:

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

Konfigurowanie manifestów wdrożenia

Manifest wdrożenia to dokument JSON opisujący moduły do wdrożenia na urządzeniu usługi IoT Edge. Aby uzyskać więcej informacji, zobacz Opis sposobu używania, konfigurowania i ponownego używania modułów usługi IoT Edge.

Aby wdrożyć połączony moduł rejestru na każdym urządzeniu usługi IoT Edge przy użyciu interfejsu wiersza polecenia platformy Azure, zapisz następujące manifesty wdrożenia lokalnie jako pliki JSON. Skorzystaj z informacji z poprzednich sekcji, aby zaktualizować odpowiednie wartości JSON w każdym manifeście. Użyj ścieżek plików w następnej sekcji, gdy uruchomisz polecenie , aby zastosować konfigurację do urządzenia.

Manifest wdrożenia dla górnej warstwy

W przypadku urządzenia w górnej warstwie utwórz plik deploymentTopLayer.json manifestu wdrożenia z następującą zawartością. Ten manifest jest podobny do tego, który był używany w przewodniku Szybki start: wdrażanie połączonego rejestru na urządzeniu usługi IoT Edge.

Uwaga

Jeśli już wdrożono połączony rejestr na urządzeniu usługi IoT Edge w górnej warstwie przy użyciu przewodnika Szybki start, możesz użyć go w górnej warstwie zagnieżdżonej hierarchii. Zmodyfikuj kroki wdrażania w tym samouczku, aby skonfigurować je w hierarchii (nie pokazano).

Ustawienia połączonego modułu rejestru

  • Użyj poświadczeń tokenu i parametry połączenia z poprzednich sekcji, aby zaktualizować odpowiednie wartości JSON w węźleenv.

  • Następujące zmienne środowiskowe są opcjonalne w węźle env :

    Zmienna opis
    ACR_REGISTRY_LOGIN_SERVER Określa unikatową nazwę hosta lub nazwę FQDN. Jeśli jest używany, połączony rejestr akceptuje tylko żądania wysyłane do tej wartości serwera logowania.

    Jeśli nie podano żadnej wartości, można uzyskać dostęp do połączonego rejestru przy użyciu dowolnej wartości serwera logowania.
    ACR_REGISTRY_CERTIFICATE_VOLUME Jeśli połączony rejestr będzie dostępny za pośrednictwem protokołu HTTPS, wskazuje wolumin, w którym są przechowywane certyfikaty HTTPS.

    Jeśli nie zostanie ustawiona, domyślna lokalizacja to /var/acr/certs.
    ACR_REGISTRY_DATA_VOLUME Zastępuje domyślną lokalizację /var/acr/data , w której obrazy będą przechowywane przez połączony rejestr.

    Ta lokalizacja musi być zgodna z powiązaniem woluminu dla kontenera.

    Ważne

    Jeśli połączony rejestr nasłuchuje na porcie innym niż 80 i 443, ACR_REGISTRY_LOGIN_SERVER wartość (jeśli określono) musi zawierać port. Przykład: 192.168.0.100:8080.

  • HostPort Jeśli moduł serwera proxy interfejsu API nie jest używany, należy ustawić powiązanie dla połączonego rejestru. Przykład:

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

Ustawienia modułu proxy interfejsu API

  • Serwer proxy interfejsu API nasłuchuje na porcie 8000 skonfigurowanym jako NGINX_DEFAULT_PORT. Aby uzyskać więcej informacji na temat ustawień serwera proxy interfejsu API, zobacz repozytorium GitHub usługi 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
                }
            }
        }
    }
}

Manifest wdrożenia dla niższej warstwy

W przypadku urządzenia w niższej warstwie utwórz plik manifestu wdrożenia deploymentLowerLayer.json z następującą zawartością.

Ogólnie rzecz biorąc, plik wdrożenia niższej warstwy jest podobny do pliku wdrożenia warstwy najwyższego poziomu. Różnice są następujące:

  • Pobiera wymagane obrazy z rejestru połączonego z górną warstwą zamiast z rejestru w chmurze.

    Podczas konfigurowania rejestru połączonego z górną warstwą upewnij się, że synchronizuje wszystkie wymagane obrazy lokalnie, w tym azureiotedge-agent, azureiotedge-hub, azureiotedge-api-proxyi acr/connected-registry. Urządzenie IoT niższej warstwy musi ściągnąć te obrazy z rejestru połączonego z górną warstwą.

  • Używa tokenu synchronizacji skonfigurowanego w niższej warstwie do uwierzytelniania za pomocą rejestru połączonego z górną warstwą.

  • Konfiguruje punkt końcowy bramy nadrzędnej z adresem IP lub nazwą FQDN rejestru połączonego w górnej warstwie zamiast z nazwą FQDN rejestru w chmurze.

Ważne

W poniższym manifeście $upstream wdrożenia jest używany jako adres IP lub nazwa FQDN urządzenia hostowania nadrzędnego połączonego rejestru. $upstream Nie jest jednak obsługiwane w zmiennej środowiskowej. Połączony rejestr musi odczytać zmienną środowiskową ACR_PARENT_GATEWAY_ENDPOINT , aby uzyskać punkt końcowy bramy nadrzędnej. Zamiast używać $upstream, połączony rejestr obsługuje dynamiczne rozpoznawanie adresu IP lub nazwy FQDN z innej zmiennej środowiskowej.

W zagnieżdżonej usłudze IoT Edge istnieje zmienna środowiskowa $IOTEDGE_PARENTHOSTNAME w niższej warstwie, która jest równa adresowi IP lub nazwie FQDN urządzenia nadrzędnego. Ręcznie zastąp zmienną środowiskową wartością ParentGatewayEndpoint w parametry połączenia, aby uniknąć twardego kodowania nadrzędnego adresu IP lub nazwy FQDN. Ponieważ urządzenie nadrzędne w tym przykładzie jest uruchomione nginx na porcie 8000, przekaż polecenie $IOTEDGE_PARENTHOSTNAME:8000. Należy również wybrać odpowiedni protokół w pliku 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
                }
            }
        }
    }
}

Konfigurowanie i wdrażanie połączonych modułów rejestru

Poniższe kroki są dostosowane z artykułu Samouczek: Tworzenie hierarchii urządzeń usługi IoT Edge i są specyficzne dla wdrażania połączonych modułów rejestru w hierarchii usługi IoT Edge. Zobacz ten samouczek, aby uzyskać szczegółowe informacje o poszczególnych krokach.

Tworzenie urządzeń warstwy górnej i niższej warstwy

Utwórz maszyny wirtualne warstwy górnej i niższej warstwy przy użyciu istniejącego szablonu usługi ARM. Szablon instaluje również agenta usługi IoT Edge. Jeśli zamiast tego chcesz wdrożyć z własnych urządzeń, zobacz Samouczek: instalowanie lub odinstalowywanie usługi Azure IoT Edge dla systemu Linux , aby dowiedzieć się, jak ręcznie skonfigurować urządzenie.

Ważne

Aby uzyskać później dostęp do modułów wdrożonych na urządzeniu warstwy górnej, upewnij się, że otwarto następujące porty przychodzące: 8000, 443, 5671, 8883. Aby uzyskać instrukcje konfiguracji, zobacz Jak otworzyć porty na maszynie wirtualnej za pomocą witryny Azure Portal.

Tworzenie i konfigurowanie hierarchii

iotedge-config Użyj narzędzia , aby utworzyć i skonfigurować hierarchię, wykonując następujące kroki w interfejsie wiersza polecenia platformy Azure lub usłudze Azure Cloud Shell:

  1. Pobierz narzędzie konfiguracji.

     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

    Ten krok powoduje utworzenie iotedge_config_cli_release folderu w katalogu samouczka. Plik szablonu używany do tworzenia hierarchii urządzeń to iotedge_config.yaml plik znajdujący się w ~/nested_iot_edge_tutorial/iotedge_config_cli_release/templates/tutorialpliku . W tym samym katalogu istnieją dwa manifesty wdrożenia dla górnych i niższych warstw: deploymentTopLayer.json i deploymentLowerLayer.json plików.

  2. Edytuj iotedge_config.yaml za pomocą swoich informacji. Zmodyfikuj nazwy plików manifestu iothub_hostnameiot_namewdrożenia dla górnej warstwy i niższej warstwy oraz poświadczenia tokenu klienta utworzone w celu ściągnięcia obrazów z góry z każdej warstwy. Poniższy przykład to przykładowy plik konfiguracji:

    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. Przygotuj pliki wdrożenia warstwy górnej i niższej warstwy: deploymentTopLayer.json i deploymentLowerLayer.json. Skopiuj pliki manifestu wdrożenia utworzone wcześniej w tym artykule do następującego folderu: ~/nestedIotEdgeTutorial/iotedge_config_cli_release/templates/tutorial.

  4. Przejdź do katalogu iotedge_config_cli_release i uruchom narzędzie, aby utworzyć hierarchię urządzeń usługi 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

    Za pomocą parametru --output narzędzie tworzy certyfikaty urządzeń, pakiety certyfikatów i plik dziennika w wybranym katalogu. Za pomocą parametru -f narzędzie automatycznie wyszukuje istniejące urządzenia usługi IoT Edge w usłudze IoT Hub i usuwa je, aby uniknąć błędów i zachować czyste centrum.

    Narzędzie może działać przez kilka minut.

  5. Skopiuj wygenerowane pliki top-layer.zip i lower-layer.zip wygenerowane w poprzednim kroku do odpowiednich maszyn wirtualnych warstwy górnej i niższej przy użyciu polecenia scp:

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

  6. Połącz się z urządzeniem w górnej warstwie, aby zainstalować pakiet konfiguracji.

    1. Rozpakuj pakiet konfiguracji. Najpierw musisz zainstalować plik zip.

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

    2. Uruchom program sudo ./install.sh. Wprowadź adres IP lub nazwę hosta. Zalecamy użycie adresu IP.

    3. Uruchom polecenie sudo iotedge list , aby potwierdzić, że wszystkie moduły są uruchomione.

  7. Połącz się z urządzeniem niższej warstwy, aby zainstalować pakiet konfiguracji.

    1. Rozpakuj pakiet konfiguracji. Najpierw musisz zainstalować plik zip.

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

    2. Uruchom program sudo ./install.sh. Wprowadź urządzenie i nadrzędne adresy IP lub nazwy hostów. Zalecamy używanie adresów IP.

    3. Uruchom polecenie sudo iotedge list , aby potwierdzić, że wszystkie moduły są uruchomione.

Jeśli nie określono pliku wdrożenia dla konfiguracji urządzenia lub jeśli wystąpią problemy z wdrożeniem, takie jak nieprawidłowy manifest wdrożenia na urządzeniu w górnej lub niższej warstwie, ręcznie wdróż moduły. Zobacz następującą sekcję.

Ręczne wdrażanie połączonego modułu rejestru

Użyj następującego polecenia, aby ręcznie wdrożyć połączony moduł rejestru na urządzeniu usługi IoT Edge:

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

Aby uzyskać szczegółowe informacje, zobacz Wdrażanie modułów usługi Azure IoT Edge przy użyciu interfejsu wiersza polecenia platformy Azure.

Po pomyślnym wdrożeniu połączony rejestr wyświetla stan Online.

Aby sprawdzić stan połączonego rejestru, użyj następującego polecenia az acr connected-registry show :

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

Może być konieczne odczekanie kilku minut, aż wdrożenie połączonego rejestru zakończy się.

Po pomyślnym wdrożeniu połączony rejestr wyświetla stan Online.

Aby rozwiązać problemy z wdrożeniem, uruchom polecenie iotedge check na urządzeniu, którego dotyczy problem. Aby uzyskać więcej informacji, zobacz Rozwiązywanie problemów.

Następne kroki

W tym przewodniku Szybki start przedstawiono sposób wdrażania połączonego rejestru na zagnieżdżonym urządzeniu usługi IoT Edge. Przejdź do następnego przewodnika, aby dowiedzieć się, jak ściągać obrazy z nowo wdrożonego połączonego rejestru.

Ściąganie obrazów z połączonego rejestru