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ł
10/23/2024

Dotyczy: IoT Edge 1.4

Ważne

Obsługiwane są wersje usługi Azure IoT Edge 1.5 LTS i IoT Edge 1.4. Usługa IoT Edge 1.4 LTS zbliża się do końca usługi 12 listopada 2024 r. Jeśli korzystasz z wcześniejszej wersji, zobacz Aktualizacja usługi IoT Edge.

Ten samouczek przeprowadzi Cię przez proces tworzenia, debugowania i wdrażania własnego kodu na urządzeniu usługi Azure 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 IoT Edge uruchomiony w kontenerze systemu Linux w systemie Windows. Nawet jeśli planujesz użyć innego języka lub wdrożyć usługę platformy Azure, ten samouczek jest nadal przydatny do poznawania narzędzi programistycznych i pojęć.

Ten samouczek zawiera kroki dwóch narzędzi deweloperskich usługi IoT Edge:

Interfejs wiersza polecenia (CLI) narzędzia deweloperskiego usługi Azure IoT Edge, który jest preferowanym narzędziem do programowania
Rozszerzenie Narzędzi usługi Azure IoT Edge dla programu Visual Studio, które jest w trybie konserwacji

Użyj przycisku selektora na początku tego samouczka, aby wybrać wersję narzędzia.

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

Skonfiguruj maszynę dewelopera.
Użyj narzędzi programistycznych usługi IoT Edge, 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 samouczku 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 na potrzeby kompilowania i wdrażania modułów.

Przed rozpoczęciem:

Zainstaluj usługę IoT Edge dla systemu Linux w systemie Windows.
Przeczytaj przewodnik Szybki start Wdrażanie pierwszego modułu usługi IoT Edge na urządzeniu z systemem Windows.
Pobierz 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 opcji obciążeń języka C++.
Po zakończeniu instalacji programu Visual Studio 2022 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. Preferowanym narzędziem programistycznym jest interfejs wiersza polecenia narzędzia deweloperskiego usługi Azure IoT Edge. Rozszerzenie zawiera szablony projektów usługi Azure IoT Edge, których używasz do tworzenia projektu programu Visual Studio. Obecnie należy zainstalować rozszerzenie niezależnie od używanego narzędzia programistycznego.

Napiwek

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

Zainstaluj interfejs wiersza polecenia platformy Azure.

Utwórz bezpłatne lub standardowe centrum IoT hub na platformie Azure jako zasób w chmurze.

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 to kontener, który ma kod wykonywalny. 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óry zamierza kierować urządzenie 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. W tym samouczku użyjesz hosta systemu Windows do programowania i usługi IoT Edge dla systemu Linux na maszynie wirtualnej z systemem Windows do kompilowania i wdrażania modułów.

Ten samouczek dotyczy urządzeń z uruchomioną 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 interfejsu wiersza polecenia platformy Docker i aparatu platformy Docker na potrzeby połączenia zdalnego

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.

Usługa IoT Edge dla systemu Linux na maszynie wirtualnej z systemem Windows zawiera już wystąpienie aparatu platformy Docker. W tym samouczku pokazano, jak zdalnie nawiązać połączenie z komputera dewelopera z systemem Windows z usługą IoT Edge dla systemu Linux w wystąpieniu platformy Docker maszyny wirtualnej z systemem Windows. Korzystając z tego połączenia zdalnego, usuwasz zależność od programu Docker Desktop dla systemu Windows.

Konfigurowanie interfejsu wiersza polecenia platformy Docker

Pierwszym krokiem jest skonfigurowanie interfejsu wiersza polecenia platformy Docker na komputerze deweloperskim z systemem Windows w celu nawiązania połączenia z zdalnym aparatem platformy Docker:

Pobierz wstępnie skompilowaną docker.exe wersję interfejsu wiersza polecenia platformy Docker z witryny Chocolatey. Możesz również pobrać oficjalny projekt interfejsu wiersza polecenia z usługi GitHub i skompilować go, postępując zgodnie z instrukcjami repozytorium.
Wyodrębnij docker.exe do katalogu na komputerze deweloperskim, na przykład C:\Docker\bin.
Otwórz pozycję Informacje o systemie>komputera>Zaawansowane ustawienia systemu.
Wybierz pozycję Zaawansowane>zmienne środowiskowe. W obszarze Zmienne użytkownika wybierz pozycję Ścieżka.
Edytuj zmienną Path i dodaj lokalizację .docker.exe
Otwórz sesję programu PowerShell z podwyższonym poziomem uprawnień.
Sprawdź, czy interfejs wiersza polecenia platformy Docker jest dostępny za pomocą tego polecenia:
```
docker --version
```
Jeśli wszystko zostało pomyślnie skonfigurowane, dane wyjściowe polecenia powinny zawierać wersję platformy Docker. Powinien wyglądać mniej więcej tak: Docker version 20.10.12, build e91ed57.

Konfigurowanie aparatu platformy Docker

Drugim krokiem jest skonfigurowanie usługi IoT Edge dla systemu Linux na maszynie wirtualnej z systemem Windows docker pod kątem 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 IoT Edge for Linux on Windows VM 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 IoT Edge for Linux on Windows 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 IoT Edge for Linux on Windows 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"

Oto przykładowe dane wyjściowe:

PS C:\> # Configure the IoT Edge for Linux on Windows 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 IoT Edge for Linux on Windows 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 IoT Edge for Linux on Windows 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

Testowanie połączenia

Ostatnim krokiem konfiguracji jest przetestowanie połączenia platformy Docker z usługą IoT Edge dla systemu Linux na maszynie wirtualnej z systemem Windows Docker:

Uzyskaj adres IP usługi IoT Edge dla systemu Linux na maszynie wirtualnej z systemem Windows:
```
Get-EflowVmAddr
```
Napiwek

Jeśli usługa IoT Edge dla systemu Linux na maszynie wirtualnej z systemem Windows została wdrożona bez statycznego adresu IP, adres IP może ulec zmianie w systemie operacyjnym hosta systemu Windows i zmianie sieci. Upewnij się, że używasz poprawnego adresu IP dla usługi IoT Edge dla systemu Linux na maszynie wirtualnej z systemem Windows za każdym razem, gdy chcesz ustanowić połączenie zdalne z aparatem platformy Docker.

Oto 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 
```

Połącz się z usługą IoT Edge dla systemu Linux na maszynie wirtualnej z systemem Windows docker i uruchom hello-world przykładowy kontener. Zastąp element <EFLOW-VM-IP> adresem IP usługi IoT Edge dla systemu Linux na maszynie wirtualnej z systemem Windows uzyskanym w poprzednim kroku.

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

Po zakończeniu pobierania kontenera kontener jest uruchamiany i generuje następujące dane wyjściowe:

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're 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. Wykonaj poniższe kroki, aby utworzyć rozwiązanie usługi Azure IoT Edge, a następnie wygenerować 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 tworzona 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 Azure IoT Edge Tools.

W programie Visual Studio utwórz nowy projekt, wybierając pozycję Utwórz nowy projekt na stronie początkowej lub wybierając przycisk Nowy projekt na pasku narzędzi.
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 przycisk Dalej.
Na stronie Konfigurowanie nowego projektu wprowadź nazwę projektu i określ lokalizację, a następnie wybierz pozycję Utwórz.
W oknie dialogowym 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.
W polu Nazwa modułu określ nazwę 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, 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 module.json plik. Adres URL repozytorium znajduje się we repository właściwości pliku JSON.

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

Struktura projektu

Rozwiązanie ma dwa foldery na poziomie projektu: główny folder projektu i 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. Manifest wdrożenia to dokument JSON opisujący moduły do skonfigurowania na docelowym urządzeniu usługi IoT Edge.

Folder modułu zawiera plik dla kodu modułu. Nazwa to 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 niezbędne 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. Plik definiuje również sposób, w jaki moduły komunikują 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.

Szablon wdrożenia zawiera następujące elementy:

Dwa moduły edgeAgent środowiska uruchomieniowego i edgeHub.
Moduł niestandardowy utworzony w tym projekcie programu Visual Studio.
Moduł o nazwie SimulatedTemperatureSensor. Ten moduł domyślny generuje symulowane dane, których można użyć do przetestowania 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. Zaktualizuj wersję środowiska uruchomieniowego usługi IoT Edge do najnowszej stabilnej wersji lub wersji, która ma być docelowa 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. Następnie wybierz przycisk OK , aby zapisać zmiany. Jeśli nie wprowadzono żadnych zmian, wybierz pozycję Anuluj.

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 deployment.debug.template.json wdrożenia. Zmień wersję środowiska uruchomieniowego dla obrazów modułów edgeAgent środowiska uruchomieniowego systemu 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. Ten krok generuje manifest wdrożenia na podstawie szablonu wdrożenia. Manifest zostanie wyświetlony w config folderze projektu programu Visual Studio.

Otwórz plik manifestu deployment.debug.template.json wdrożenia.
Zmień wersję środowiska uruchomieniowego dla obrazów modułów edgeAgent środowiska uruchomieniowego systemu 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

Skonfiguruj rozszerzenie Azure IoT Edge Tools, aby używać zdalnego aparatu platformy Docker działającego wewnątrz usługi IoT Edge dla systemu Linux na maszynie wirtualnej z systemem Windows:

Wybierz pozycję Narzędzia usługi Azure IoT Edge Tools IoT Edge tools IoT Edge tools settings (Narzędzia>usługi Azure IoT Edge tools>IoT Edge tools IoT Edge tools).
Zastąp wartość DOCKER_HOST localhost adresem IP usługi IoT Edge dla systemu Linux na maszynie wirtualnej z systemem Windows. Jeśli nie pamiętasz adresu IP, użyj polecenia cmdlet Get-EflowVmAddr usługi IoT Edge dla systemu Linux w programie Windows PowerShell, aby go uzyskać. Jeśli na przykład adres IP usługi IoT Edge dla systemu Linux na maszynie wirtualnej z systemem Windows to 172.20.1.100, nowa wartość powinna być tcp://172.20.1.100:2375.
Wybierz przycisk 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 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).

W domyślnym rozwiązaniu symulowane dane z modułu są kierowane do modułu SimulatedTemperatureSensor . Moduł pobiera dane wejściowe, a następnie wysyła je do usługi Azure 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. Te potrzeby mogą obejmować zabezpieczenia, zarządzanie urządzeniami i niezawodność.

Kompilowanie i wypychanie pojedynczego modułu

Zazwyczaj chcesz przetestować i debugować każdy moduł przed uruchomieniem go w całym rozwiązaniu z wieloma modułami. Ponieważ rozwiązanie zostanie skompilowane lub debugowane przy użyciu aparatu platformy Docker działającego wewnątrz usługi IoT Edge dla systemu Linux na maszynie wirtualnej z systemem Windows, pierwszym krokiem jest kompilowanie i publikowanie modułu w celu włączenia zdalnego debugowania:

W Eksplorator rozwiązań wybierz folder projektu modułu (na przykład myIotEdgeModule).
Ustaw moduł niestandardowy jako projekt startowy. W menu wybierz pozycję Project Set (Zestaw projektów) jako StartUp Project (Projekt>startowy).
Aby debugować moduł C# Linux, należy zaktualizować Dockerfile.amd64.debug plik, aby włączyć usługę SSH. Zaktualizuj plik, Dockerfile.amd64.debug aby używał następującego szablonu: Plik Dockerfile dla modułu AMD64 C# usługi Azure IoT Edge z obsługą zdalnego debugowania.

Uwaga

Po wybraniu pozycji Debuguj program Visual Studio używa Dockerfile.(amd64|windows-amd64).debug do kompilowania obrazów platformy Docker. Ten plik zawiera 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.

Upewnij się, ENTRYPOINT ["dotnet", "IotEdgeModule1.dll"]że w ostatnim wierszu szablonu nazwa biblioteki DLL jest zgodna z nazwą projektu modułu usługi IoT Edge.
Aby nawiązać połączenie SSH z modułem systemu Linux, należy utworzyć klucz RSA. Otwórz sesję programu PowerShell z podwyższonym poziomem uprawnień i uruchom następujące polecenia, aby utworzyć nowy klucz RSA. Zapisz klucz RSA w tym samym folderze modułu usługi IoT Edge i upewnij się, że nazwa klucza to id_rsa.
```
ssh-keygen -t RSA -b 4096 -m PEM
```
Jeśli używasz rejestru prywatnego, takiego jak Usługa Azure Container Registry, 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 <Container Registry username> -p <Container Registry password> <Container Registry login server>
```

W Eksplorator rozwiązań kliknij prawym przyciskiem myszy folder projektu i wybierz polecenie Build and Push IoT Edge Modules (Kompiluj i wypychaj moduły usługi IoT Edge). To polecenie kompiluje i wypycha 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 Container Registry.
```
      "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. Określony port będzie używany jako port SSH w celu nawiązania połączenia z modułem języka C# systemu Linux. Musisz dodać informacje o porcie SSH dla createOptions tego ustawienia modułu systemu Linux 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 pozycję Generuj wdrożenie dla usługi IoT Edge, aby skompilować nowy kod JSON wdrożenia usługi IoT Edge.
Wybierz pozycję Wyświetl>Eksplorator chmury. Upewnij się, że zalogowaliśmy się do programu Visual Studio 2019.
W eksploratorze chmury rozwiń subskrypcję, a następnie znajdź usługę 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. Znajduje się on w folderze w rozwiązaniu config programu Visual Studio, takim jak deployment.amd64.json.

Kompilowanie obrazu platformy Docker modułu

Po opracowaniu 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"

Wypychanie obrazu platformy Docker modułu

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

Wdrażanie modułu na urządzeniu usługi IoT Edge

W programie Visual Studio otwórz plik manifestu deployment.debug.template.json wdrożenia w głównym projekcie.

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 createOption wartości, 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 rejestru kontenerów platformy Azure do przechowywania obrazu modułu, dodaj poświadczenia do deployment.debug.template.json usługi edgeAgent w ustawieniach. Na 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 image wartość właściwości 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 createOptions wartość zawartością ciągową dla każdego systemu i modułu niestandardowego w szablonie wdrożenia.

Na przykład image ustawienia i createOptions dla IotEdgeModule1 będą podobne do następującego przykładu:

"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 centrum Azure IoT Hub. Aby na przykład wdrożyć moduły zdefiniowane w pliku w deployment.debug.amd64.json centrum IoT my-iot-hub dla urządzenia my-deviceusługi IoT Edge, 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 Ustawienia>zabezpieczeń usługi Azure IoT Hub>Zasady dostępu współdzielonego.
W eksploratorze chmury kliknij prawym przyciskiem myszy urządzenie brzegowe i odśwież, aby potwierdzić, że nowy moduł jest uruchomiony wraz z modułami $edgeAgent i $edgeHub .

Debugowanie rozwiązania

W sesji programu PowerShell z podwyższonym poziomem uprawnień uruchom następujące polecenia:
1. moduleId Pobierz wartość na podstawie nazwy modułu języka C# dla systemu Linux. Zastąp <iot-edge-module-name> symbol zastępczy nazwą modułu.
```
$moduleId = Invoke-EflowVmCommand "sudo docker ps -aqf name=<iot-edge-module-name>"
```
2. Sprawdź, czy $moduleId jest to poprawne. Jeśli zmienna jest pusta, upewnij się, że używasz poprawnej nazwy modułu.
3. Uruchom usługę SSH wewnątrz kontenera systemu Linux:
```
Invoke-EflowVmCommand "sudo docker exec -it -d $moduleId service ssh start"
```
4. Otwórz port SSH modułu w usłudze IoT Edge dla systemu Linux na maszynie wirtualnej z systemem Windows. (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 przy każdym ponownym uruchomieniu usługi IoT Edge dla systemu Linux na maszynie wirtualnej z systemem Windows reguła tabeli IP jest usuwana i wraca do oryginalnych ustawień. Ponadto musisz ponownie uruchomić usługę SSH modułu ręcznie.

Po pomyślnym uruchomieniu usługi SSH wybierz pozycję Debuguj>dołączanie do procesu, ustaw wartość Typ połączenia na SSH i ustaw pozycję Cel połączenia na adres IP usługi IoT Edge dla systemu Linux na maszynie wirtualnej z systemem Windows. Jeśli nie znasz adresu IP usługi IoT Edge dla systemu Linux na maszynie wirtualnej z systemem Windows, możesz użyć Get-EflowVmAddr polecenia cmdlet programu PowerShell.

Wpisz adres IP, a następnie wybierz Enter. W oknie podręcznym wprowadź następujące konfiguracje:

Pole	Wartość
Nazwa hosta	Adres IP usługi IoT Edge dla systemu Linux na maszynie wirtualnej z systemem Windows
Port	10022 (lub ten, który został użyty w konfiguracji wdrożenia)
Nazwa użytkownika	korzeń
Authentication type (Typ uwierzytelniania)	Klucz prywatny
Plik klucza prywatnego	Pełna ścieżka do `id_rsa` wartości utworzonej w poprzednim kroku
Hasło	Hasło używane dla klucza utworzonego w poprzednim kroku

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ł:
- Jeśli programujesz w języku C#, ustaw punkt przerwania w PipeMessage() funkcji w pliku ModuleBackgroundService.cs.
- Jeśli używasz języka C, ustaw punkt przerwania w InputQueue1Callback() funkcji w pliku main.c.
Dane wyjściowe polecenia SimulatedTemperatureSensor powinny zostać przekierowane do input1 niestandardowego modułu języka C# systemu Linux. Punkt przerwania powinien zostać wyzwolony. Zmienne można obserwować w oknie Ustawienia lokalne programu Visual Studio.
Aby zatrzymać debugowanie, wybierz Ctrl+F5 lub wybierz przycisk Zatrzymaj.

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 usuń 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, które zawiera grupa 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 wybrać każdy zasób, aby usunąć je indywidualnie.

Następny krok

W tym samouczku skonfigurujesz program Visual Studio na komputerze deweloperskim, a następnie 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:

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

Udostępnij za pośrednictwem