Samouczek: tworzenie modułów usługi IoT Edge z kontenerami systemu Linux przy użyciu usługi IoT Edge dla systemu Linux w systemie Windows

Artykuł
04/11/2024

Dotyczy: IoT Edge 1.4

Ważne

Azure IoT Edge1.4 jest obsługiwaną wersją. Jeśli korzystasz z wcześniejszej wersji, zobacz aktualizację Azure IoT Edge.

W tym samouczku przedstawiono tworzenie, debugowanie i wdrażanie własnego kodu na urządzeniu usługi IoT Edge przy użyciu usługi IoT Edge dla systemu Linux w systemach Windows i Visual Studio 2022. Poznasz najbardziej typowy scenariusz dla deweloperów rozwiązań usługi IoT Edge, wdrażając moduł języka C# na urządzeniu z systemem Linux. Wdrożysz i debugujesz niestandardowy moduł usługi Azure IoT Edge uruchomiony w kontenerze systemu Linux w systemie Windows (EFLOW). Nawet jeśli planujesz używać innego języka lub wdrażania usługi platformy Azure, ten samouczek jest nadal przydatny do poznania narzędzi i pojęć związanych z programowaniem.

Ten artykuł zawiera kroki dotyczące dwóch narzędzi deweloperskich usługi IoT Edge:

Interfejs wiersza polecenia (CLI) jest preferowanym narzędziem do programowania.
Narzędzia usługi Azure IoT Edge dla rozszerzenia programu Visual Studio . Rozszerzenie jest w trybie konserwacji.

Użyj przycisku selektora narzędzi na początku tego artykułu, aby wybrać wersję narzędzia.

Z tego samouczka dowiesz się, jak wykonywać następujące czynności:

Skonfiguruj maszynę dewelopera.
Użyj narzędzi usługi IoT Edge dla programu Visual Studio Code, aby utworzyć nowy projekt.
Skompiluj projekt jako kontener i zapisz go w rejestrze kontenerów platformy Azure.
Wdróż kod na urządzeniu usługi IoT Edge.

Wymagania wstępne

W tym artykule założono, że używasz maszyny z systemem Windows jako maszyny programistycznej. Na komputerach z systemem Windows można opracowywać moduły systemu Windows lub Linux. Ten samouczek przeprowadzi Cię przez proces tworzenia kontenerów systemu Linux przy użyciu usługi IoT Edge dla systemu Linux w systemie Windows w celu kompilowania i wdrażania modułów.

Instalowanie usługi IoT Edge dla systemu Linux w systemie Windows (EFLOW)
Szybki start: wdrażanie pierwszego modułu usługi IoT Edge na urządzeniu z systemem Windows
Zestaw .NET Core SDK.
Zainstaluj lub zmodyfikuj program Visual Studio 2022 na komputerze deweloperskim. Wybierz opcje Programowanie na platformie Azure i programowanie aplikacji klasycznych przy użyciu obciążeń języka C++.

Gdy program Visual Studio 2022 będzie gotowy, potrzebne są również następujące narzędzia i składniki:

Pobierz i zainstaluj narzędzia usługi Azure IoT Edge z witryny Visual Studio Marketplace. Aby utworzyć i skompilować rozwiązanie usługi IoT Edge, możesz użyć rozszerzenia Azure IoT Edge Tools. Preferowane narzędzie programistyczne to narzędzie wiersza polecenia (CLI) usługi Azure IoT Edge Dev Tool. Rozszerzenie zawiera szablony projektów usługi Azure IoT Edge użyte do utworzenia projektu programu Visual Studio. Obecnie wymagane jest zainstalowanie rozszerzenia niezależnie od używanego narzędzia programistycznego.

Ważne

Rozszerzenie Azure IoT Edge Tools for VS 2022 jest w trybie konserwacji. Preferowane narzędzie programistyczne to narzędzie wiersza polecenia (CLI) usługi Azure IoT Edge Dev Tool.

Napiwek

Jeśli używasz programu Visual Studio 2019, pobierz i zainstaluj narzędzia Azure IoT Edge Tools for VS 2019 z witryny Visual Studio Marketplace.

Zainstaluj interfejs wiersza polecenia platformy Azure.

Zasoby w chmurze:

Bezpłatne lub standardowe centrum IoT Na platformie Azure.

Jeśli nie masz subskrypcji platformy Azure, przed rozpoczęciem utwórz bezpłatne konto platformy Azure.

Najważniejsze pojęcia

Ten samouczek przeprowadzi Cię przez proces tworzenia modułu usługi IoT Edge. Moduł usługi IoT Edge, a czasami tylko krótki moduł, jest kontenerem z kodem wykonywalnym. Możesz wdrożyć jeden lub więcej modułów na urządzeniu usługi IoT Edge. Moduły wykonują określone zadania, takie jak pozyskiwanie danych z czujników, czyszczenie i analizowanie danych lub wysyłanie komunikatów do centrum IoT. Aby uzyskać więcej informacji, zobacz Omówienie modułów usługi Azure IoT Edge.

Podczas tworzenia modułów usługi IoT Edge należy zrozumieć różnicę między maszyną deweloperską a docelowym urządzeniem usługi IoT Edge, na którym moduł zostanie ostatecznie wdrożony. Kontener, który jest kompilowalny do przechowywania kodu modułu, musi być zgodny z systemem operacyjnym urządzenia docelowego. Na przykład najbardziej typowym scenariuszem jest utworzenie modułu na komputerze z systemem Windows, które ma być przeznaczone dla urządzenia z systemem Linux z uruchomioną usługą IoT Edge. W takim przypadku system operacyjny kontenera to Linux. Podczas pracy z tym samouczkiem należy pamiętać o różnicy między systemem operacyjnym maszyny dewelopera i systemem operacyjnym kontenera. Na potrzeby tego samouczka będziesz używać hosta systemu Windows do programowania i maszyny wirtualnej usługi IoT Edge dla systemu Linux w systemie Windows (EFLOW) do kompilowania i wdrażania modułów.

Ten samouczek dotyczy urządzeń z usługą IoT Edge z kontenerami systemu Linux. Możesz użyć preferowanego systemu operacyjnego, o ile maszyna programistyjna uruchamia kontenery systemu Linux. Zalecamy używanie programu Visual Studio do tworzenia aplikacji za pomocą kontenerów systemu Linux, aby użyć tego samouczka. Można również użyć programu Visual Studio Code, chociaż istnieją różnice w obsłudze między dwoma narzędziami. Aby uzyskać więcej informacji, zobacz Tworzenie modułów usługi Azure IoT Edge przy użyciu programu Visual Studio Code.

Konfigurowanie połączenia zdalnego aparatu platformy Docker i platformy Docker

Moduły usługi IoT Edge są pakowane jako kontenery, więc do ich kompilowania i zarządzania potrzebny jest aparat kontenera na maszynie deweloperów. Maszyna wirtualna EFLOW zawiera już wystąpienie aparatu platformy Docker, więc w tym samouczku pokazano, jak zdalnie nawiązać połączenie z maszyny dewelopera z systemem Windows z wystąpieniem platformy Docker maszyny wirtualnej EFLOW. W tym celu usuniemy zależność od programu Docker Desktop dla systemu Windows.

Pierwszym krokiem jest skonfigurowanie interfejsu wiersza polecenia platformy Docker na maszynie deweloperów z systemem Windows w celu nawiązania połączenia z zdalnym aparatem platformy Docker.

Pobierz wstępnie skompilowaną wersję pliku docker.exe interfejsu wiersza polecenia platformy docker-cli z witryny docker-cli Chocolatey. Możesz również pobrać oficjalny projekt interfejsu wiersza polecenia z witryny Docker/cli w witrynie GitHub i skompilować go zgodnie z instrukcjami repozytorium.
Wyodrębnij plik docker.exe do katalogu na komputerze deweloperskim. Na przykład C:\Docker\bin
Otwórz pozycję Informacje o komputerze -> Informacje o systemie -> Zaawansowane ustawienia systemu
Wybierz pozycję Zaawansowane -> Zmienne środowiskowe —> w obszarze Zmienne użytkownika zaznacz ścieżkę
Edytuj zmienną Path i dodaj lokalizację pliku docker.exe
Otwieranie sesji programu PowerShell z podwyższonym poziomem uprawnień
Sprawdź, czy interfejs wiersza polecenia platformy Docker jest dostępny przy użyciu polecenia
```
docker --version
```

Jeśli wszystko zostało pomyślnie skonfigurowane, poprzednie polecenie powinno wyświetlić wersję platformy Docker, taką jak Docker w wersji 20.10.12, kompilacja e91ed57.

Drugim krokiem jest skonfigurowanie aparatu platformy Docker maszyny wirtualnej EFLOW w celu akceptowania połączeń zewnętrznych i dodawania odpowiednich reguł zapory.

Ostrzeżenie

Uwidacznianie aparatu platformy Docker do połączeń zewnętrznych może zwiększyć ryzyko bezpieczeństwa. Ta konfiguracja powinna być używana tylko do celów programistycznych. Pamiętaj, aby przywrócić konfigurację do domyślnych ustawień po zakończeniu programowania.

Otwórz sesję programu PowerShell z podwyższonym poziomem uprawnień i uruchom następujące polecenia

# Configure the EFLOW virtual machine Docker engine to accept external connections, and add the appropriate firewall rules.
Invoke-EflowVmCommand "sudo iptables -A INPUT -p tcp --dport 2375 -j ACCEPT"

# Create a copy of the EFLOW VM _docker.service_ in the system folder.
Invoke-EflowVmCommand "sudo cp /lib/systemd/system/docker.service /etc/systemd/system/docker.service"

# Replace the service execution line to listen for external connections.
Invoke-EflowVmCommand "sudo sed -i 's/-H fd:\/\// -H fd:\/\/ -H tcp:\/\/0.0.0.0:2375/g'  /etc/systemd/system/docker.service"

# Reload the EFLOW VM services configurations.
Invoke-EflowVmCommand "sudo systemctl daemon-reload"

# Reload the Docker engine service.
Invoke-EflowVmCommand "sudo systemctl restart docker.service"

# Check that the Docker engine is listening to external connections.
Invoke-EflowVmCommand "sudo netstat -lntp | grep dockerd"

Poniżej przedstawiono przykładowe dane wyjściowe.

PS C:\> # Configure the EFLOW virtual machine Docker engine to accept external connections, and add the appropriate firewall rules.
PS C:\> Invoke-EflowVmCommand "sudo iptables -A INPUT -p tcp --dport 2375 -j ACCEPT"
PS C:\>
PS C:\> # Create a copy of the EFLOW VM docker.service in the system folder.
PS C:\> Invoke-EflowVmCommand "sudo cp /lib/systemd/system/docker.service /etc/systemd/system/docker.service"
PS C:\>
PS C:\> # Replace the service execution line to listen for external connections.
PS C:\> Invoke-EflowVmCommand "sudo sed -i 's/-H fd:\/\// -H fd:\/\/ -H tcp:\/\/0.0.0.0:2375/g' /etc/systemd/system/docker.service"
PS C:\>
PS C:\> # Reload the EFLOW VM services configurations.
PS C:\> Invoke-EflowVmCommand "sudo systemctl daemon-reload"
PS C:\>
PS C:\> # Reload the Docker engine service.
PS C:\> Invoke-EflowVmCommand "sudo systemctl restart docker.service"
PS C:\>
PS C:\> # Check that the Docker engine is listening to external connections.
PS C:\> Invoke-EflowVmCommand "sudo netstat -lntp | grep dockerd"
tcp6       0      0 :::2375                 :::*                    LISTEN      2790/dockerd

Ostatnim krokiem jest przetestowanie połączenia platformy Docker z aparatem platformy Docker maszyny wirtualnej EFLOW. Najpierw potrzebny jest adres IP maszyny wirtualnej EFLOW.
```
Get-EflowVmAddr
```
Napiwek

Jeśli maszyna wirtualna EFLOW została wdrożona bez statycznego adresu IP, adres IP może ulec zmianie w systemach operacyjnych hosta systemu Windows lub zmiany sieci. Upewnij się, że używasz poprawnego adresu IP maszyny wirtualnej EFLOW za każdym razem, gdy chcesz ustanowić zdalne połączenie aparatu platformy Docker.

Poniżej przedstawiono przykładowe dane wyjściowe.
```
PS C:\> Get-EflowVmAddr
[03/15/2022 15:22:30] Querying IP and MAC addresses from virtual machine (DESKTOP-J1842A1-EFLOW)
 - Virtual machine MAC: 00:15:5d:6f:da:78
 - Virtual machine IP : 172.31.24.105 retrieved directly from virtual machine
00:15:5d:6f:da:78
172.31.24.105 
```

Korzystając z uzyskanego adresu IP, połącz się z aparatem platformy Docker maszyny wirtualnej EFLOW i uruchom przykładowy kontener Hello-World. Zastąp wartość <EFLOW-VM-IP> adresem IP maszyny wirtualnej EFLOW uzyskanym w poprzednim kroku.

docker -H tcp://<EFLOW-VM-IP>:2375 run --rm hello-world

Powinien zostać wyświetlony komunikat, że kontener jest pobierany, a po uruchomieniu i wyświetleniu poniższych danych wyjściowych.

PS C:\> docker -H tcp://172.31.24.105:2375 run --rm hello-world
Unable to find image 'hello-world:latest' locally
latest: Pulling from library/hello-world
2db29710123e: Pull complete
Digest: sha256:4c5f3db4f8a54eb1e017c385f683a2de6e06f75be442dc32698c9bbe6c861edd
Status: Downloaded newer image for hello-world:latest

Hello from Docker!
This message shows that your installation appears to be working correctly.

To generate this message, Docker took the following steps:
 1. The Docker client contacted the Docker daemon.
 2. The Docker daemon pulled the "hello-world" image from the Docker Hub.
    (amd64)
 3. The Docker daemon created a new container from that image which runs the
    executable that produces the output you are currently reading.
 4. The Docker daemon streamed that output to the Docker client, which sent it
    to your terminal.

To try something more ambitious, you can run an Ubuntu container with:
 $ docker run -it ubuntu bash

Share images, automate workflows, and more with a free Docker ID:
 https://hub.docker.com/

For more examples and ideas, visit:
 https://docs.docker.com/get-started/

Tworzenie projektu usługi Azure IoT Edge

Szablon projektu usługi IoT Edge w programie Visual Studio tworzy rozwiązanie, które można wdrożyć na urządzeniach usługi IoT Edge. Najpierw utworzysz rozwiązanie usługi Azure IoT Edge, a następnie wygenerujesz pierwszy moduł w tym rozwiązaniu. Każde rozwiązanie usługi IoT Edge może zawierać więcej niż jeden moduł.

Ważne

Struktura projektu usługi IoT Edge utworzona przez program Visual Studio nie jest taka sama jak w programie Visual Studio Code.

Obecnie interfejs wiersza polecenia narzędzia deweloperskiego usługi Azure IoT Edge nie obsługuje tworzenia typu projektu programu Visual Studio. Aby utworzyć projekt programu Visual Studio, musisz użyć rozszerzenia usługi IoT Edge programu Visual Studio.

Utwórz nowy projekt w programie Visual Studio.
Na stronie Tworzenie nowego projektu wyszukaj pozycję Azure IoT Edge. Wybierz projekt zgodny z platformą (moduł usługi Linux IoT Edge) i architekturą urządzenia usługi IoT Edge, a następnie wybierz pozycję Dalej.
Na stronie Konfigurowanie nowego projektu wprowadź nazwę projektu i określ lokalizację, a następnie wybierz pozycję Utwórz.
W oknie Dodawanie modułu wybierz typ modułu, który chcesz opracować. Możesz również wybrać pozycję Istniejący moduł, aby dodać istniejący moduł usługi IoT Edge do wdrożenia. Określ nazwę modułu i repozytorium obrazów modułu.
W polu Adres URL repozytorium podaj nazwę repozytorium obrazów modułu. Program Visual Studio automatycznie wypełnia nazwę modułu nazwą localhost:5000/<nazwa modułu>. Zastąp je własnymi informacjami rejestru. Użyj hosta lokalnego , jeśli używasz lokalnego rejestru platformy Docker do testowania. Jeśli używasz usługi Azure Container Registry, użyj serwera logowania z ustawień rejestru. Serwer logowania wygląda jak <nazwa> rejestru.azurecr.io. Zastąp tylko część ciągu localhost:5000, tak aby wynik końcowy wyglądał następująco:< nazwa> rejestru.azurecr.io/< nazwa> modułu.
Wybierz pozycję Dodaj , aby dodać moduł do projektu.

Uwaga

Jeśli masz istniejący projekt usługi IoT Edge, możesz zmienić adres URL repozytorium, otwierając plik module.json . Adres URL repozytorium znajduje się we właściwości repozytorium pliku JSON.

Teraz masz projekt usługi IoT Edge i moduł usługi IoT Edge w rozwiązaniu programu Visual Studio.

Struktura projektu

W rozwiązaniu istnieją dwa foldery na poziomie projektu, w tym główny folder projektu i jeden folder modułu. Na przykład może istnieć główny folder projektu o nazwie AzureIotEdgeApp1 i folder modułu o nazwie IotEdgeModule1. Główny folder projektu zawiera manifest wdrożenia.

Folder modułu zawiera plik dla kodu modułu o nazwie Program.cs lub main.c w zależności od wybranego języka. Ten folder zawiera również plik o nazwie module.json opisujący metadane modułu. Różne pliki platformy Docker zawierają informacje potrzebne do skompilowania modułu jako kontenera systemu Windows lub Linux.

Manifest wdrożenia projektu

Edytowany manifest wdrożenia nosi nazwę deployment.debug.template.json. Ten plik jest szablonem manifestu wdrożenia usługi IoT Edge, który definiuje wszystkie moduły uruchamiane na urządzeniu wraz ze sposobem komunikowania się ze sobą. Aby uzyskać więcej informacji na temat manifestów wdrażania, zobacz Dowiedz się, jak wdrażać moduły i ustanawiać trasy.

Jeśli otworzysz ten szablon wdrażania, zobaczysz, że zostaną uwzględnione dwa moduły środowiska uruchomieniowego edgeAgent i edgeHub wraz z modułem niestandardowym utworzonym w tym projekcie programu Visual Studio. Dostępny jest również czwarty moduł o nazwie SimulatedTemperatureSensor . Ten moduł domyślny generuje symulowane dane, których można użyć do testowania modułów lub usunięcia, jeśli nie jest to konieczne. Aby zobaczyć, jak działa symulowany czujnik temperatury, wyświetl kod źródłowy SimulatedTemperatureSensor.csproj.

Ustawianie wersji środowiska uruchomieniowego usługi IoT Edge

Obecnie najnowsza stabilna wersja środowiska uruchomieniowego to 1.4. Należy zaktualizować wersję środowiska uruchomieniowego usługi IoT Edge do najnowszej stabilnej wersji lub wersji docelowej dla urządzeń.

W Eksplorator rozwiązań kliknij prawym przyciskiem myszy nazwę głównego projektu i wybierz pozycję Ustaw wersję środowiska uruchomieniowego usługi IoT Edge.
Użyj menu rozwijanego, aby wybrać wersję środowiska uruchomieniowego uruchomioną na urządzeniach usługi IoT Edge, a następnie wybierz przycisk OK , aby zapisać zmiany. Jeśli nie wprowadzono żadnych zmian, wybierz pozycję Anuluj , aby zakończyć.

Obecnie rozszerzenie nie zawiera wyboru dla najnowszych wersji środowiska uruchomieniowego. Jeśli chcesz ustawić wersję środowiska uruchomieniowego wyższą niż 1.2, otwórz plik manifestu wdrożenia deployment.debug.template.json . Zmień wersję środowiska uruchomieniowego dla obrazów modułu środowiska uruchomieniowego systemu edgeAgent i edgeHub. Jeśli na przykład chcesz użyć środowiska uruchomieniowego usługi IoT Edge w wersji 1.4, zmień następujące wiersze w pliku manifestu wdrożenia:
```
"systemModules": {
   "edgeAgent": {
    //...
      "image": "mcr.microsoft.com/azureiotedge-agent:1.4"
    //...
   "edgeHub": {
   //...
      "image": "mcr.microsoft.com/azureiotedge-hub:1.4",
   //...
```
Jeśli zmieniono wersję, ponownie wygeneruj manifest wdrożenia, klikając prawym przyciskiem myszy nazwę projektu i wybierając pozycję Generuj wdrożenie dla usługi IoT Edge. Spowoduje to wygenerowanie manifestu wdrożenia na podstawie szablonu wdrożenia i pojawi się w folderze konfiguracji projektu programu Visual Studio.

Otwórz plik manifestu wdrożenia deployment.debug.template.json . Manifest wdrożenia to dokument JSON opisujący moduły do skonfigurowania na docelowym urządzeniu usługi IoT Edge.
Zmień wersję środowiska uruchomieniowego dla obrazów modułu środowiska uruchomieniowego systemu edgeAgent i edgeHub. Jeśli na przykład chcesz użyć środowiska uruchomieniowego usługi IoT Edge w wersji 1.4, zmień następujące wiersze w pliku manifestu wdrożenia:
```
"systemModules": {
    "edgeAgent": {
    //...
        "image": "mcr.microsoft.com/azureiotedge-agent:1.4",
    //...
    "edgeHub": {
    //...
        "image": "mcr.microsoft.com/azureiotedge-hub:1.4",
    //...
```

Konfigurowanie zdalnego wystąpienia aparatu platformy Docker programu Visual Studio 2022

Użyj rozszerzenia narzędzi usługi Azure IoT Edge i skonfiguruj je do używania zdalnego aparatu platformy Docker działającego wewnątrz maszyny wirtualnej EFLOW.

Wybierz pozycję Narzędzia ->Narzędzia usługi Azure IoT Edge ->Ustawienia narzędzi usługi IoT Edge...
Zastąp wartość DOCKER_HOST localhost adresem IP maszyny wirtualnej EFLOW. Jeśli nie pamiętasz adresu IP, użyj polecenia cmdlet Get-EflowVmAddr programu PowerShell EFLOW, aby go uzyskać. W przypadku exmaple, jeśli adres IP maszyny wirtualnej EFLOW to 172.20.1.100, nowa wartość powinna być tcp://172.20.1.100:2375.
Wybierz OK

Opracowywanie modułu

Po dodaniu nowego modułu jest on dostarczany z domyślnym kodem gotowym do skompilowania i wdrożenia na urządzeniu, dzięki czemu można rozpocząć testowanie bez dotykania żadnego kodu. Kod modułu znajduje się w folderze modułu w pliku o nazwie Program.cs (dla języka C#) lub main.c (dla języka C).

Domyślne rozwiązanie zostało skompilowane tak, aby symulowane dane z modułu SimulatedTemperatureSensor zostały kierowane do modułu, który pobiera dane wejściowe, a następnie wysyła je do usługi IoT Hub.

Gdy wszystko będzie gotowe do dostosowania szablonu modułu przy użyciu własnego kodu, użyj zestawów SDK usługi Azure IoT Hub, aby utworzyć inne moduły, które odpowiadają kluczowym potrzebom rozwiązań IoT, takich jak zabezpieczenia, zarządzanie urządzeniami i niezawodność.

Kompilowanie i wypychanie pojedynczego modułu

Zazwyczaj należy przetestować i debugować każdy moduł przed uruchomieniem go w całym rozwiązaniu z wieloma modułami. Ponieważ rozwiązanie będzie kompilować lub debugować przy użyciu aparatu platformy Docker działającego wewnątrz maszyny wirtualnej EFLOW, pierwszym krokiem jest kompilowanie i publikowanie modułu w celu włączenia zdalnego debugowania.

W Eksplorator rozwiązań wybierz i wyróżnij folder projektu modułu (na przykład myIotEdgeModule). Ustaw moduł niestandardowy jako projekt startowy. Wybierz pozycję Project Set (Zestaw projektów) jako StartUp Project (Projekt> startowy) z menu.
Aby debugować moduł C# Linux, musimy zaktualizować plik Dockerfile.amd64.debug , aby włączyć usługę SSH. Zaktualizuj plik Dockerfile.amd64.debug, aby użyć następującego szablonu: Dockerfile for Azure IoT Edge AMD64 C# Module with Remote Debug Support (Obsługa zdalnego debugowania).

Uwaga

Podczas wybierania opcji Debuguj program Visual Studio używa Dockerfile.(amd64|windows-amd64).debug do kompilowania obrazów platformy Docker. Obejmuje to debuger vsDBG wiersza polecenia platformy .NET Core w obrazie kontenera podczas jego kompilowania. W przypadku modułów usługi IoT Edge gotowych do produkcji zalecamy użycie konfiguracji wydania, która jest używana Dockerfile.(amd64|windows-amd64) bez usługi VSDBG.

Ostrzeżenie

Upewnij się, że ostatni wiersz szablonu ENTRYPOINT ["dotnet", "IotEdgeModule1.dll"] nazwa biblioteki DLL jest zgodna z nazwą projektu modułu usługi IoT Edge.
Aby ustanowić połączenie SSH z modułem systemu Linux, musimy utworzyć klucz RSA. Otwórz sesję programu PowerShell z podwyższonym poziomem uprawnień i uruchom następujące polecenia, aby utworzyć nowy klucz RSA. Upewnij się, że klucz RSA został zapisany w tym samym folderze modułu usługi IoT Edge, a nazwa klucza to id_rsa.
```
ssh-keygen -t RSA -b 4096 -m PEM
```
Jeśli używasz rejestru prywatnego, takiego jak Azure Container Registry (ACR), użyj następującego polecenia platformy Docker, aby się do niego zalogować. Nazwę użytkownika i hasło można uzyskać na stronie Klucze dostępu rejestru w witrynie Azure Portal. Jeśli używasz rejestru lokalnego, możesz uruchomić rejestr lokalny.
```
docker -H tcp://<EFLOW-VM-IP>:2375 login -u <ACR username> -p <ACR password> <ACR login server>
```

W Eksplorator rozwiązań kliknij prawym przyciskiem myszy folder projektu i wybierz polecenie Kompiluj i wypychaj moduły usługi IoT Edge, aby skompilować i wypchnąć obraz platformy Docker dla każdego modułu.
Jeśli używasz rejestru prywatnego, takiego jak Usługa Azure Container Registry, musisz dodać informacje logowania rejestru do ustawień środowiska uruchomieniowego znajdujących się w pliku deployment.template.json. Zastąp symbole zastępcze rzeczywistą nazwą użytkownika, hasłem i nazwą rejestru administratora usługi ACR.
```
      "settings": {
        "minDockerVersion": "v1.25",
        "loggingOptions": "",
        "registryCredentials": {
          "registry1": {
            "username": "<username>",
            "password": "<password>",
            "address": "<registry name>.azurecr.io"
          }
        }
      }
```
Uwaga

W tym artykule są używane poświadczenia logowania administratora dla usługi Azure Container Registry, które są wygodne w scenariuszach tworzenia i testowania. Gdy wszystko będzie gotowe do scenariuszy produkcyjnych, zalecamy opcję uwierzytelniania z najmniejszymi uprawnieniami, taką jak jednostki usługi. Aby uzyskać więcej informacji, zobacz Zarządzanie dostępem do rejestru kontenerów.
Aby uzyskać dostęp do usługi SSH modułu, należy uwidocznić port 22. W tym samouczku jako port hosta jest używany port 10022, ale można określić inny port, który będzie używany jako port SSH do nawiązania połączenia z modułem języka C# systemu Linux. Musisz dodać informacje o porcie SSH do ustawienia "createOptions" tego modułu systemu Linux znajdującego się w pliku deployment.debug.template.json.
```
     "createOptions": {
        "HostConfig": {
           "Privileged": true,
           "PortBindings": {
                 "22/tcp": [
                    {
                       "HostPort": "10022"
                    }
                 ]
           }
        }
     }
```
W Eksplorator rozwiązań kliknij prawym przyciskiem myszy folder projektu i wybierz polecenie Generuj wdrożenie dla usługi IoT Edge, aby skompilować nowy plik json wdrożenia usługi IoT Edge.
Otwórz eksploratora chmury, klikając pozycję Wyświetl>Eksplorator chmury. Upewnij się, że zalogowano się do programu Visual Studio 2019.
W eksploratorze chmury rozwiń swoją subskrypcję, znajdź swoje centrum Azure IoT Hub i urządzenie usługi Azure IoT Edge, które chcesz wdrożyć.
Kliknij prawym przyciskiem myszy urządzenie usługi IoT Edge i wybierz pozycję Utwórz wdrożenie. Przejdź do manifestu wdrożenia debugowania skonfigurowanego dla platformy znajdującego się w folderze konfiguracji w rozwiązaniu programu Visual Studio, takim jak deployment.amd64.json.

Kompilowanie obrazu platformy Docker modułu

Po utworzeniu modułu możesz skompilować obraz modułu do przechowywania w rejestrze kontenerów na potrzeby wdrożenia na urządzeniu usługi IoT Edge.

Użyj pliku Dockerfile modułu, aby skompilować obraz platformy Docker modułu.

docker build --rm -f "<DockerFilePath>" -t <ImageNameAndTag> "<ContextPath>"

Załóżmy na przykład, że powłoka poleceń znajduje się w katalogu projektu, a nazwa modułu to IotEdgeModule1. Aby skompilować obraz dla rejestru lokalnego lub rejestru kontenerów platformy Azure, użyj następujących poleceń:

# Build the image for the local registry

docker build --rm -f "./IotEdgeModule1/Dockerfile.amd64.debug" -t localhost:5000/iotedgemodule1:0.0.1-amd64 "./IotEdgeModule1"

# Or build the image for an Azure Container Registry

docker build --rm -f "./IotEdgeModule1/Dockerfile.amd64.debug" -t myacr.azurecr.io/iotedgemodule1:0.0.1-amd64 "./IotEdgeModule1"

Obraz platformy Docker modułu wypychania

Wypchnij obraz modułu do rejestru lokalnego lub rejestru kontenerów.

docker push <ImageName>

Na przykład:

# Push the Docker image to the local registry

docker push localhost:5000/iotedgemodule1:0.0.1-amd64

# Or push the Docker image to an Azure Container Registry
az acr login --name myacr
docker push myacr.azurecr.io/iotedgemodule1:0.0.1-amd64

Wdróż moduł na urządzeniu usługi IoT Edge.

W programie Visual Studio otwórz plik manifestu wdrożenia deployment.debug.template.json w głównym projekcie. Manifest wdrożenia to dokument JSON opisujący moduły do skonfigurowania na docelowym urządzeniu usługi IoT Edge. Przed wdrożeniem należy zaktualizować poświadczenia usługi Azure Container Registry, obrazy modułu i odpowiednie createOptions wartości. Aby uzyskać więcej informacji na temat wartości createOption, zobacz How to configure container create options for IoT Edge modules (Jak skonfigurować opcje tworzenia kontenera dla modułów usługi IoT Edge).

Jeśli używasz usługi Azure Container Registry do przechowywania obrazu modułu, musisz dodać poświadczenia do pliku deployment.debug.template.json w ustawieniach edgeAgent . Przykład:

"modulesContent": {
"$edgeAgent": {
  "properties.desired": {
    "schemaVersion": "1.1",
    "runtime": {
      "type": "docker",
      "settings": {
        "minDockerVersion": "v1.25",
        "loggingOptions": "",
        "registryCredentials": {
          "myacr": {
            "username": "myacr",
            "password": "<your_acr_password>",
            "address": "myacr.azurecr.io"
          }
        }
      }
    },
//...

Zastąp wartość właściwości obrazu nazwą obrazu modułu wypchniętą do rejestru. Jeśli na przykład wypchnięliśmy obraz oznaczony jako myacr.azurecr.io/iotedgemodule1:0.0.1-amd64 niestandardowy moduł IotEdgeModule1, zastąp wartość właściwości obrazu wartością tagu.

Dodaj lub zastąp wartość createOptions ciągową zawartością dla każdego systemu i modułu niestandardowego w szablonie wdrożenia.

Na przykład obraz IotEdgeModule1 i ustawienia createOptions będą podobne do następujących:

"IotEdgeModule1": {
"version": "1.0.0",
"type": "docker",
"status": "running",
"restartPolicy": "always",
"settings": {
    "image": "myacr.azurecr.io/iotedgemodule1:0.0.1-amd64",
    "createOptions": "{\"HostConfig\":{\"PortBindings\":{\"5671/tcp\":[{\"HostPort\":\"5671\"}],\"8883/tcp\":[{\"HostPort\":\"8883\"}],\"443/tcp\":[{\"HostPort\":\"443\"}]}}}"
}

Użyj polecenia set-modules interfejsu wiersza polecenia platformy Azure usługi IoT Edge, aby wdrożyć moduły w usłudze Azure IoT Hub. Aby na przykład wdrożyć moduły zdefiniowane w pliku deployment.debug.amd64.json w usłudze IoT Hub my-iot-hub dla urządzenia usługi IoT Edge my-device, użyj następującego polecenia:

az iot edge set-modules --hub-name my-iot-hub --device-id my-device --content ./deployment.debug.template.json --login "HostName=my-iot-hub.azure-devices.net;SharedAccessKeyName=iothubowner;SharedAccessKey=<SharedAccessKey>"

Napiwek

Parametry połączenia usługi IoT Hub można znaleźć w witrynie Azure Portal w obszarze Zasady dostępu współdzielonego ustawień>zabezpieczeń usługi Azure IoT Hub.>

W eksploratorze chmury kliknij prawym przyciskiem myszy urządzenie brzegowe i odśwież, aby wyświetlić nowy moduł uruchomiony wraz z modułami $edgeAgent i $edgeHub .

Debugowanie rozwiązania

Przy użyciu sesji programu PowerShell z podwyższonym poziomem uprawnień uruchom następujące polecenia
1. Pobierz identyfikator moduleId na podstawie nazwy używanej dla modułu języka C# systemu Linux. Pamiętaj, aby zastąpić <symbol zastępczy iot-edge-module-name> nazwą modułu.
```
$moduleId = Invoke-EflowVmCommand "sudo docker ps -aqf name=<iot-edge-module-name>"
```
2. Sprawdź, czy $moduleId jest poprawna — jeśli zmienna jest pusta, upewnij się, że używasz poprawnej nazwy modułu
3. Uruchamianie usługi SSH wewnątrz kontenera systemu Linux
```
Invoke-EflowVmCommand "sudo docker exec -it -d $moduleId service ssh start"
```
4. Otwórz port SSH modułu na maszynie wirtualnej EFLOW (w tym samouczku jest używany port 10022)
```
Invoke-EflowVmCommand "sudo iptables -A INPUT -p tcp --dport 10022 -j ACCEPT"
```
Ostrzeżenie

Ze względów bezpieczeństwa za każdym razem, gdy maszyna wirtualna EFLOW zostanie ponownie uruchomiona, reguła tabeli adresów IP usunie i wróci do oryginalnych ustawień. Ponadto usługa SSH modułu będzie musiała zostać ponownie uruchomiona ręcznie.

Po pomyślnym uruchomieniu usługi SSH wybierz pozycję Debuguj —> dołączanie do procesu, ustaw typ Połączenie ion na SSH i Połączenie ion docelowy adres IP maszyny wirtualnej EFLOW. Jeśli nie znasz adresu IP maszyny wirtualnej EFLOW, możesz użyć Get-EflowVmAddr polecenia cmdlet programu PowerShell. Najpierw wpisz adres IP, a następnie naciśnij klawisz Enter. W oknie podręcznym wprowadź następujące konfiguracje:

Pole	Wartość
Nazwa hosta	Używanie adresu IP maszyny wirtualnej EFLOW
Port	10022 (lub użyta w konfiguracji wdrożenia)
Nazwa użytkownika	root
Authentication type (Typ uwierzytelniania)	Klucz prywatny
Plik klucza prywatnego	Pełna ścieżka do id_rsa utworzonej w poprzednim kroku
Hasło	Hasło używane dla klucza utworzonego w poprzednim kroku

Screenshot of how to connect to a remote system

Po pomyślnym nawiązaniu połączenia z modułem przy użyciu protokołu SSH możesz wybrać proces i wybrać pozycję Dołącz. W przypadku modułu języka C# należy wybrać pozycję dotnet procesu i dołączyć do zarządzanego (CoreCLR). Po raz pierwszy może upłynąć od 10 do 20 sekund.
Ustaw punkt przerwania, aby sprawdzić moduł.
- W przypadku programowania w języku C#ustaw punkt przerwania w PipeMessage() funkcji ModuleBackgroundService.cs.
- W przypadku używania języka C ustaw punkt przerwania w InputQueue1Callback() funkcji main.c.
Dane wyjściowe modułu SimulatedTemperatureSensor powinny być przekierowywane do danych wejściowych1 niestandardowego modułu języka C# systemu Linux. Punkt przerwania powinien zostać wyzwolony. Zmienne można obserwować w oknie Ustawienia lokalne programu Visual Studio.
Naciśnij klawisze Ctrl + F5 lub naciśnij przycisk zatrzymania, aby zatrzymać debugowanie.

Czyszczenie zasobów

Jeśli zamierzasz przejść do kolejnego zalecanego artykułu, możesz zachować utworzone zasoby oraz konfiguracje i użyć ich ponownie. Możesz także nadal używać tego samego urządzenia usługi IoT Edge jako urządzenia testowego.

W przeciwnym razie możesz usunąć konfiguracje lokalne i zasoby platformy Azure użyte w tym artykule, aby uniknąć naliczania opłat.

Usuwanie zasobów platformy Azure

Usuwanie zasobów i grup zasobów platformy Azure jest nieodwracalne. Uważaj, aby nie usunąć przypadkowo niewłaściwych zasobów lub niewłaściwej grupy zasobów. Jeśli centrum IoT zostało utworzone w istniejącej grupie zasobów zawierającej zasoby, które chcesz zachować, usuń tylko sam zasób centrum IoT, a nie grupę zasobów.

Aby usunąć zasoby:

Zaloguj się do witryny Azure Portal, a następnie wybierz pozycję Grupy zasobów.
Wybierz nazwę grupy zasobów, która zawiera zasoby testowe usługi IoT Edge.
Przejrzyj listę zasobów zawartych w grupie zasobów. Jeśli chcesz usunąć je wszystkie, możesz wybrać pozycję Usuń grupę zasobów. Jeśli chcesz usunąć tylko niektóre z nich, możesz kliknąć poszczególne zasoby, aby usunąć je pojedynczo.

Następne kroki

W tym samouczku skonfigurujesz program Visual Studio na komputerze deweloperskim i wdrożono i debugujesz z niego pierwszy moduł usługi IoT Edge. Teraz, gdy znasz podstawowe pojęcia, spróbuj dodać funkcje do modułu, aby umożliwić analizowanie danych przekazywanych przez nie.

Tworzenie modułów usługi Azure IoT Edge przy użyciu programu Visual Studio Code