HoloLens (1. Generation) und Azure 313: IoT Hub Service

Artikel
07/12/2023

Hinweis

Die Tutorials der Mixed Reality Academy wurden im Hinblick auf HoloLens (1. Gen.) und immersive Mixed Reality-Headsets entworfen. Daher halten wir es für wichtig, diese Tutorials für Entwickler verfügbar zu halten, die noch nach Anleitung beim Entwickeln für diese Geräte suchen. Diese Tutorials werden nicht mit den neuesten Toolsets oder Interaktionen aktualisiert, die für HoloLens 2 verwendet werden. Sie werden gewartet, um weiterhin auf den unterstützten Geräten zu funktionieren. Es wird eine neue Reihe von Tutorials geben, die in Zukunft veröffentlicht werden, die veranschaulichen, wie für HoloLens 2 entwickelt werden kann. Dieser Hinweis wird mit einem Link zu diesen Tutorials aktualisiert, wenn sie veröffentlicht werden.

Kursergebnis

In diesem Kurs erfahren Sie, wie Sie einen Azure IoT Hub-Dienst auf einem virtuellen Computer implementieren, auf dem das Betriebssystem Ubuntu 16.4 ausgeführt wird. Eine Azure-Funktions-App wird dann verwendet, um Nachrichten von Ihrer Ubuntu-VM zu empfangen und das Ergebnis in einem Azure Table Service zu speichern. Sie können diese Daten dann mithilfe von Power BI auf Microsoft HoloLens oder immersivem Headset (VR) anzeigen.

Der Inhalt dieses Kurses gilt für IoT Edge Geräte, obwohl der Fokus für den Zweck dieses Kurses auf einer VM-Umgebung liegt, sodass der Zugriff auf ein physisches Edge-Gerät nicht erforderlich ist.

Wenn Sie diesen Kurs absolvieren, lernen Sie Folgendes:

Stellen Sie ein IoT Edge Modul auf einem virtuellen Computer (Ubuntu 16 OS) bereit, der Ihr IoT-Gerät darstellt.
Fügen Sie dem Edge-Modul ein Azure Custom Vision Tensorflow-Modell mit Code hinzu, der im Container gespeicherte Images analysiert.
Richten Sie das Modul so ein, dass die Analyseergebnisnachricht zurück an Ihren IoT Hub-Dienst gesendet wird.
Verwenden Sie eine Azure-Funktions-App , um die Nachricht in einer Azure-Tabelle zu speichern.
Richten Sie Power BI ein, um die gespeicherte Nachricht zu sammeln und einen Bericht zu erstellen.
Visualisieren Sie Ihre IoT-Nachrichtendaten in Power BI.

Zu den Diensten, die Sie verwenden, gehören:

Azure IoT Hub ist ein Microsoft Azure-Dienst, mit dem Entwickler IoT-Ressourcen verbinden, überwachen und verwalten können. Weitere Informationen finden Sie auf der Seite Azure IoT Hub Service.
Azure Container Registry ist ein Microsoft Azure-Dienst, mit dem Entwickler Containerimages für verschiedene Containertypen speichern können. Weitere Informationen finden Sie auf der Seite Azure Container Registry-Dienst.
Die Azure-Funktions-App ist ein Microsoft Azure-Dienst, mit dem Entwickler kleine Codeelemente (Funktionen) in Azure ausführen können. Dies bietet eine Möglichkeit zum Delegieren von Arbeit an die Cloud anstelle Ihrer lokalen Anwendung, was viele Vorteile haben kann. Azure Functions unterstützt mehrere Entwicklungssprachen, darunter C#, F#, Node.js, Java und PHP. Weitere Informationen finden Sie auf der Seite Azure Functions.
Azure Storage: Tables ist ein Microsoft Azure-Dienst, mit dem Entwickler strukturierte Daten ohne SQL in der Cloud speichern können, sodass sie überall leicht zugänglich sind. Der Dienst verfügt über ein schemaloses Design, das die Entwicklung von Tabellen nach Bedarf ermöglicht und daher sehr flexibel ist. Weitere Informationen finden Sie auf der Seite Azure-Tabellen .

In diesem Kurs erfahren Sie, wie Sie den IoT Hub-Dienst einrichten und verwenden und dann eine Von einem Gerät bereitgestellte Antwort visualisieren. Sie müssen diese Konzepte auf ein benutzerdefiniertes IoT Hub Service-Setup anwenden, das Sie möglicherweise erstellen.

Geräteunterstützung

Kurs	HoloLens	Immersive Headsets
MR und Azure 313: IoT Hub-Dienst	✔️	✔️

Voraussetzungen

Die aktuellsten Voraussetzungen für die Entwicklung mit Mixed Reality, einschließlich der Microsoft HoloLens, finden Sie im Artikel Installieren der Tools.

Hinweis

Dieses Tutorial richtet sich an Entwickler, die über grundlegende Erfahrungen mit Python verfügen. Bitte beachten Sie auch, dass die Voraussetzungen und schriftlichen Anweisungen in diesem Dokument das darstellen, was zum Zeitpunkt der Erstellung (Juli 2018) getestet und überprüft wurde. Sie können die neueste Software verwenden, wie im Artikel Installieren der Tools aufgeführt, aber es sollte nicht davon ausgegangen werden, dass die Informationen in diesem Kurs perfekt mit dem übereinstimmen, was Sie in neuerer Software finden, als die unten aufgeführt.

Die folgende Hardware und Software ist erforderlich:

Windows 10 Fall Creators Update (oder höher), Entwicklermodus aktiviert

Warnung

Sie können einen virtuellen Computer nicht mit Hyper-V auf Windows 10 Home Edition ausführen.
Windows 10 SDK (neueste Version)
HoloLens, Entwicklermodus aktiviert
Visual Studio 2017.15.4 (wird nur für den Zugriff auf die Azure Cloud Explorer verwendet)
Internetzugriff für Azure und für IoT Hub Service. Weitere Informationen finden Sie unter diesem Link zur Seite IoT Hub Service.
Ein Machine Learning-Modell. Wenn Sie kein eigenes Modell für die Verwendung bereit haben, können Sie das in diesem Kurs bereitgestellte Modell verwenden.
Hyper-V-Software, die auf Ihrem Windows 10 Entwicklungscomputer aktiviert ist.
Ein virtueller Computer mit Ubuntu (16.4 oder 18.4), der auf Ihrem Entwicklungscomputer ausgeführt wird, oder Alternativ können Sie einen separaten Computer unter Linux (Ubuntu 16.4 oder 18.4) verwenden. Weitere Informationen zum Erstellen eines virtuellen Computers unter Windows mit Hyper-V finden Sie im Kapitel "Vor dem Start".

Vorbereitung

Richten Sie Ihre HoloLens ein und testen Sie sie. Wenn Sie Unterstützung beim Einrichten Ihrer HoloLens benötigen, lesen Sie den Artikel holoLens-Setup.
Es ist eine gute Idee, Kalibrierung und Sensoroptimierung durchzuführen, wenn Sie mit der Entwicklung einer neuen HoloLens-App beginnen (manchmal kann dies helfen, diese Aufgaben für jeden Benutzer auszuführen).

Hilfe zur Kalibrierung finden Sie unter diesem Link zum Artikel HoloLens-Kalibrierung.

Hilfe zur Sensoroptimierung finden Sie unter diesem Link zum Artikel Zur HoloLens-Sensoroptimierung.

Richten Sie Ihren virtuellen Ubuntu-Computer mithilfe von Hyper-V ein. Die folgenden Ressourcen helfen Ihnen beim Prozess.
1. Folgen Sie zunächst diesem Link, um ubuntu 16.04.4 LTS (Xenial Xerus) ISO herunterzuladen. Wählen Sie das Desktopimage des 64-Bit-PCs (AMD64) aus.
2. Stellen Sie sicher, dass Hyper-V auf Ihrem Windows 10 Computer aktiviert ist. Unter diesem Link finden Sie Anleitungen zum Installieren und Aktivieren von Hyper-V auf Windows 10.
3. Starten Sie Hyper-V, und erstellen Sie eine neue Ubuntu-VM. Unter diesem Link finden Sie eine Schritt-für-Schritt-Anleitung zum Erstellen eines virtuellen Computers mit Hyper-V. Wenn Sie aufgefordert werden, ein Betriebssystem aus einer startbaren Imagedatei zu installieren, wählen Sie die Ubuntu-ISO aus, die Sie zuvor heruntergeladen haben.
Hinweis

Die Verwendung der Hyper-V-Schnellerstellung wird nicht empfohlen.

Kapitel 1: Abrufen des Custom Vision-Modells

In diesem Kurs haben Sie Zugriff auf ein vorgefertigtes Custom Vision Modell, das Tastaturen und Mäuse aus Bildern erkennt. Wenn Sie dies verwenden, fahren Sie mit Kapitel 2 fort.

Sie können jedoch die folgenden Schritte ausführen, wenn Sie Ihr eigenes Custom Vision-Modell verwenden möchten:

Navigieren Sie in Ihrem Custom Vision Project zur Registerkarte Leistung.

Warnung

Ihr Modell muss eine kompakte Domäne verwenden, um das Modell zu exportieren. Sie können ihre Modelldomäne in den Einstellungen für Ihr Projekt ändern.
Wählen Sie die Iteration aus, die Sie exportieren möchten, und klicken Sie auf Exportieren. Ein Blatt wird angezeigt.
Klicken Sie auf dem Blatt auf Docker-Datei.
Klicken Sie im Dropdownmenü auf Linux und dann auf Herunterladen.
Entzippen Sie den Inhalt. Sie werden es später in diesem Kurs verwenden.

Kapitel 2: Der Containerregistrierungsdienst

Der ContainerRegistrierungsdienst ist das Repository, das zum Hosten Ihrer Container verwendet wird.

Der IoT Hub Dienst, den Sie in diesem Kurs erstellen und verwenden, bezieht sich auf den Containerregistrierungsdienst, um die Container abzurufen, die auf Ihrem Edgegerät bereitgestellt werden sollen.

Folgen Sie zunächst diesem Link zum Azure-Portal, und melden Sie sich mit Ihren Anmeldeinformationen an.
Navigieren Sie zu Ressource erstellen , und suchen Sie nach Container Registry.
Klicken Sie auf Erstellen.
Legen Sie die Parameter für die Diensteinrichtung fest:
1. Fügen Sie einen Namen für Ihr Projekt ein. In diesem Beispiel heißt dies IoTCRegistry.
2. Wählen Sie eine Ressourcengruppe aus, oder erstellen Sie eine neue. Eine Ressourcengruppe bietet eine Möglichkeit zum Überwachen, Steuern des Zugriffs, Bereitstellen und Verwalten der Abrechnung für eine Sammlung von Azure-Ressourcen. Es wird empfohlen, alle Azure-Dienste, die einem einzelnen Projekt (z. B. diesen Kursen) zugeordnet sind, unter einer gemeinsamen Ressourcengruppe zu speichern.
3. Legen Sie den Standort des Diensts fest.
4. Legen Sie Admin Benutzer auf Aktivieren fest.
5. Legen Sie SKU auf Basic fest.
Klicken Sie auf Erstellen , und warten Sie, bis die Dienste erstellt werden.
Sobald die Benachrichtigung angezeigt wird, die Sie über die erfolgreiche Erstellung der ContainerRegistrierung informiert, klicken Sie auf Die Seite Zu Ressource wechseln, um zu Ihrem Dienst umgeleitet zu werden.
Klicken Sie auf der Seite Container Registry Service auf Zugriffsschlüssel.
Notieren Sie sich die folgenden Parameter (Sie können Ihren Editor verwenden):
1. Anmeldeserver
2. Benutzername
3. Kennwort

Kapitel 3: Der IoT Hub-Dienst

Nun beginnen Sie mit der Erstellung und Einrichtung Ihres IoT Hub-Diensts.

Wenn Sie noch nicht angemeldet sind, melden Sie sich beim Azure-Portal an.
Klicken Sie nach der Anmeldung in der oberen linken Ecke auf Ressource erstellen, suchen Sie nach IoT Hub, und klicken Sie auf DIE EINGABETASTE.

Screenshot: Geöffnetes Fenster

Die neue Seite enthält eine Beschreibung des Speicherkontodiensts . Klicken Sie unten links neben dieser Eingabeaufforderung auf die Schaltfläche Erstellen, um eine instance dieses Diensts zu erstellen.
Nachdem Sie auf Erstellen geklickt haben, wird ein Bereich angezeigt:
1. Wählen Sie eine Ressourcengruppe aus, oder erstellen Sie eine neue. Eine Ressourcengruppe bietet eine Möglichkeit zum Überwachen, Steuern des Zugriffs, Bereitstellen und Verwalten der Abrechnung für eine Sammlung von Azure-Ressourcen. Es wird empfohlen, alle Azure-Dienste, die einem einzelnen Projekt (z. B. diesen Kursen) zugeordnet sind, unter einer gemeinsamen Ressourcengruppe zu speichern.
  
  Wenn Sie mehr über Azure-Ressourcengruppen erfahren möchten, folgen Sie diesem Link zum Verwalten einer Ressourcengruppe.
2. Wählen Sie einen geeigneten Standort aus (Verwenden Sie denselben Standort für alle Dienste, die Sie in diesem Kurs erstellen).
3. Fügen Sie den gewünschten Namen für diesen Dienst instance ein.
Klicken Sie unten auf der Seite auf Weiter: Größe und Skalierung.
Wählen Sie auf dieser Seite Ihren Tarif und Skalierungstarif aus (wenn dies Ihr erster IoT Hub Service instance ist, sollte ihnen ein kostenloser Tarif zur Verfügung stehen).
Klicken Sie auf Überprüfen + Erstellen.
Überprüfen Sie Ihre Einstellungen, und klicken Sie auf Erstellen.
Sobald die Benachrichtigung angezeigt wird, die Sie über die erfolgreiche Erstellung des IoT Hub-Diensts informiert, klicken Sie auf Zur Ressource wechseln, um zu Ihrem Dienst umgeleitet zu werden.
Scrollen Sie im Seitenbereich auf der linken Seite, bis Automatische Geräteverwaltung angezeigt wird. Klicken Sie auf IoT Edge.
Klicken Sie im angezeigten Fenster auf der rechten Seite auf IoT Edge Gerät hinzufügen. Rechts wird ein Blatt angezeigt.
Geben Sie auf dem Blatt dem neuen Gerät eine Geräte-ID (einen Namen Ihrer Wahl) an. Klicken Sie dann auf Speichern. Der Primärschlüssel und der sekundäre Schlüssel werden automatisch generiert, wenn Die Automatische Generierung aktiviert ist.
Sie navigieren zurück zum Abschnitt IoT Edge Geräte, in dem Ihr neues Gerät aufgeführt wird. Klicken Sie auf Ihr neues Gerät (rot dargestellt in der folgenden Abbildung).
Nehmen Sie auf der angezeigten Seite Gerätedetails eine Kopie der Verbindungszeichenfolge (Primärschlüssel) an.
Zurück zum Bereich auf der linken Seite, und klicken Sie auf Shared Access Policies (Freigegebene Zugriffsrichtlinien), um ihn zu öffnen.
Klicken Sie auf der angezeigten Seite auf iothubowner, und ein Blatt wird rechts neben dem Bildschirm angezeigt.
Notieren Sie sich (auf Ihrem Editor) die Verbindungszeichenfolge (Primärschlüssel), die Sie später verwenden können, wenn Sie die Verbindungszeichenfolge für Ihr Gerät festlegen.

Kapitel 4: Einrichten der Entwicklungsumgebung

Zum Erstellen und Bereitstellen von Modulen für IoT Hub Edge müssen die folgenden Komponenten auf Ihrem Entwicklungscomputer installiert sein, auf dem Windows 10 ausgeführt wird:

Docker für Windows, werden Sie aufgefordert, ein Konto zu erstellen, um herunterladen zu können.

Wichtig

Docker erfordert für die Ausführung Windows 10 PRO, Enterprise 14393 oder Windows Server 2016 RTM. Wenn Sie andere Versionen von Windows 10 ausführen, können Sie versuchen, Docker mithilfe der Docker-Toolbox zu installieren.
Python 3.6.
Visual Studio Code (auch als VS Code bezeichnet)

Nach der Installation der oben genannten Software müssen Sie Ihren Computer neu starten.

Kapitel 5: Einrichten der Ubuntu-Umgebung

Jetzt können Sie mit der Einrichtung Ihres Geräts fortfahren, auf dem Ubuntu OS ausgeführt wird. Führen Sie die folgenden Schritte aus, um die erforderliche Software zu installieren, um Ihre Container auf Ihrem Board bereitzustellen:

Wichtig

Sie sollten den Terminalbefehlen immer sudo vorangehen, um als Administratorbenutzer auszuführen. D. h.:

sudo docker \<option> \<command> \<argument>

Öffnen Sie das Ubuntu-Terminal, und verwenden Sie den folgenden Befehl, um pip zu installieren:

[! TIPP] Sie können das Terminal sehr einfach mit der Tastenkombination öffnen: STRG + ALT + T.
```
    sudo apt-get install python-pip
```
In diesem Kapitel werden Sie möglicherweise vom Terminal aufgefordert, die Berechtigung zur Verwendung Ihres Gerätespeichers einzugeben, und geben Sie y/n (ja oder nein) ein, geben Sie "y" ein, und drücken Sie dann die EINGABETASTE , um zu akzeptieren.
Nachdem dieser Befehl abgeschlossen ist, verwenden Sie den folgenden Befehl, um curl zu installieren:
```
    sudo apt install curl
```

Nachdem pip und curl installiert sind, verwenden Sie den folgenden Befehl, um die IoT Edge Runtime zu installieren. Dies ist erforderlich, um die Module auf Ihrem Board bereitzustellen und zu steuern:

    curl https://packages.microsoft.com/config/ubuntu/16.04/prod.list > ./microsoft-prod.list

    sudo cp ./microsoft-prod.list /etc/apt/sources.list.d/

    curl https://packages.microsoft.com/keys/microsoft.asc | gpg --dearmor > microsoft.gpg

    sudo cp ./microsoft.gpg /etc/apt/trusted.gpg.d/

    sudo apt-get update

    sudo apt-get install moby-engine

    sudo apt-get install moby-cli

    sudo apt-get update

    sudo apt-get install iotedge

An diesem Punkt werden Sie aufgefordert, die Laufzeitkonfigurationsdatei zu öffnen, um die Geräteverbindungszeichenfolge einzufügen, die Sie sich (in Ihrem Editor) notiert haben, wenn Sie den IoT Hub-Dienst erstellen (in Schritt 14 von Kapitel 3). Führen Sie die folgende Zeile im Terminal aus, um diese Datei zu öffnen:
```
    sudo nano /etc/iotedge/config.yaml
```
Die Datei config.yaml wird angezeigt und kann bearbeitet werden:

Warnung

Wenn diese Datei geöffnet wird, kann es etwas verwirrend sein. Sie werden diese Datei im Terminal selbst bearbeiten.
1. Verwenden Sie die Pfeiltasten auf der Tastatur, um nach unten zu scrollen (Sie müssen ein wenig nach unten scrollen), um die Zeile zu erreichen, die enthält":
  
  "<GERÄTEVERBINDUNGSZEICHENFOLGE HIER> HINZUFÜGEN".
2. Ersetzen Sie die Zeile , einschließlich der Klammern, mit der Geräteverbindungszeichenfolge , die Sie zuvor notiert haben.
Wenn Die Verbindungszeichenfolge eingerichtet ist, drücken Sie auf der Tastatur die TASTEN STRG+X , um die Datei zu speichern. Sie werden aufgefordert, dies zu bestätigen, indem Sie Y eingeben. Drücken Sie dann die EINGABETASTE , um dies zu bestätigen. Sie kehren zum regulären Terminal zurück.
Sobald diese Befehle erfolgreich ausgeführt wurden, haben Sie die IoT Edge Runtime installiert. Nach der Initialisierung startet die Runtime jedes Mal, wenn das Gerät eingeschaltet wird, eigenständig und befindet sich im Hintergrund und wartet auf die Bereitstellung von Modulen aus dem IoT Hub-Dienst.
Führen Sie die folgende Befehlszeile aus, um die IoT Edge Runtime zu initialisieren:
```
    sudo systemctl restart iotedge
```
Wichtig

Wenn Sie Änderungen an Ihrer YAML-Datei oder am obigen Setup vornehmen, müssen Sie die obige Neustartzeile erneut im Terminal ausführen.
Überprüfen Sie die IoT Edge Runtime status, indem Sie die folgende Befehlszeile ausführen. Die Laufzeit sollte mit dem aktiven (ausgeführten) status in grünem Text angezeigt werden.
```
    sudo systemctl status iotedge
```
Drücken Sie STRG-C, um die seite status zu beenden. Sie können überprüfen, ob die IoT Edge Runtime die Container ordnungsgemäß pullt, indem Sie den folgenden Befehl eingeben:
```
    sudo docker ps
```
Eine Liste mit zwei (2) Containern sollte angezeigt werden. Dies sind die Standardmodule, die automatisch vom IoT Hub Service (edgeAgent und edgeHub) erstellt werden. Nachdem Sie Ihre eigenen Module erstellt und bereitgestellt haben, werden diese in dieser Liste unter den Standardmodulen angezeigt.

Kapitel 6: Installieren der Erweiterungen

Wichtig

Die nächsten Kapitel (6-9) werden auf Ihrem Windows 10 Computer ausgeführt.

Öffnen Sie VS Code.
Klicken Sie auf die Schaltfläche Erweiterungen (quadratisch) in der linken Leiste von VS Code, um den Bereich Erweiterungen zu öffnen.
Suchen Und installieren Sie die folgenden Erweiterungen (wie in der folgenden Abbildung dargestellt):
1. Azure IoT Edge
2. Azure IoT-Toolkit
3. Docker
Nachdem die Erweiterungen installiert wurden, schließen Sie VS Code, und öffnen Sie sie erneut.
Wenn VS Code erneut geöffnet ist, navigieren Sie zuIntegriertes Terminalanzeigen>.
Sie installieren jetzt Cookiecutter. Führen Sie im Terminal den folgenden bash-Befehl aus:
```
    pip install --upgrade --user cookiecutter
```
[! HINWEIS] Wenn Sie Probleme mit diesem Befehl haben:
1. Starten Sie VS Code und/oder Ihren Computer neu.
2. Es kann erforderlich sein, das VS Code-Terminal auf das zu ändern, das Sie zum Installieren von Python, d. h. PowerShell , verwendet haben (insbesondere, wenn die Python-Umgebung bereits auf Ihrem Computer installiert war). Wenn das Terminal geöffnet ist, finden Sie das Dropdownmenü auf der rechten Seite des Terminals.
3. Stellen Sie sicher, dass der Python-Installationspfad als Umgebungsvariable auf Ihrem Computer hinzugefügt wird. Cookiecutter sollte Teil desselben Speicherortpfads sein. Weitere Informationen zu Umgebungsvariablen finden Sie unter diesem Link.
Nachdem cookiecutter die Installation abgeschlossen hat, sollten Sie Ihren Computer neu starten, damit Cookiecutter innerhalb der Systemumgebung als Befehl erkannt wird.

Kapitel 7: Erstellen Ihrer Containerlösung

An diesem Punkt müssen Sie den Container mit dem Modul erstellen, um in die Containerregistrierung gepusht zu werden. Nachdem Sie Ihren Container per Push übertragen haben, verwenden Sie den IoT Hub Edgedienst, um ihn auf Ihrem Gerät bereitzustellen, auf dem die IoT Edge Runtime ausgeführt wird.

Klicken Sie in VS Code auf Befehlspalette anzeigen>.
Suchen Sie in der Palette nach Azure IoT Edge: Neue Iot Edge-Lösung, und führen Sie sie aus.
Navigieren Sie zu einem Speicherort, an dem Sie Ihre Lösung erstellen möchten. Drücken Sie die EINGABETASTE , um den Speicherort zu akzeptieren.
Geben Sie Ihrer Lösung einen Namen. Drücken Sie die EINGABETASTE , um Ihren angegebenen Namen zu bestätigen.
Nun werden Sie aufgefordert, das Vorlagenframework für Ihre Lösung auszuwählen. Klicken Sie auf Python-Modul. Drücken Sie die EINGABETASTE , um diese Wahl zu bestätigen.
Geben Sie Ihrem Modul einen Namen. Drücken Sie die EINGABETASTE , um den Namen Ihres Moduls zu bestätigen. Notieren Sie sich (mit Ihrem Editor) den Modulnamen, wie er später verwendet wird.
Sie werden feststellen, dass eine vordefinierte Adresse des Docker-Imagerepositorys auf der Palette angezeigt wird. Es sieht wie folgt aus:

localhost:5000/-THE NAME OF YOUR MODULE-.
Löschen Sie localhost:5000, und fügen Sie an ihrer Stelle die Adresse des ContainerRegistry-Anmeldeservers ein, die Sie beim Erstellen des ContainerRegistrierungsdiensts (in Schritt 8 von Kapitel 2) notiert haben. Drücken Sie die EINGABETASTE , um die Adresse zu bestätigen.
An diesem Punkt wird die Lösung mit der Vorlage für Ihr Python-Modul erstellt, und ihre Struktur wird auf der Registerkarte Erkunden von VS Code auf der linken Seite des Bildschirms angezeigt. Wenn die Registerkarte Erkunden nicht geöffnet ist, können Sie sie öffnen, indem Sie in der Leiste auf der linken Seite auf die oberste Schaltfläche klicken.
Der letzte Schritt für dieses Kapitel besteht darin, auf die ENV-Datei zu klicken und von der Registerkarte Erkunden aus zu öffnen, und fügen Sie Ihren Benutzernamen und Ihr Kennwort für Container Registry hinzu. Diese Datei wird von Git ignoriert, aber beim Erstellen des Containers werden die Anmeldeinformationen für den Zugriff auf den ContainerRegistrierungsdienst festgelegt.

Kapitel 8: Bearbeiten Ihrer Containerlösung

Sie schließen nun die Containerlösung ab, indem Sie die folgenden Dateien aktualisieren:

Standard.py Python-Skript.
requirements.txt.
deployment.template.json.
Dockerfile.amd64

Anschließend erstellen Sie den Ordner images, der vom Python-Skript verwendet wird, um zu überprüfen, ob Bilder mit Ihrem Custom Vision-Modell übereinstimmen. Abschließend fügen Sie die Dateilabels.txt hinzu, um Ihr Modell zu lesen, und die Datei model.pb , bei der es sich um Ihr Modell handelt.

Navigieren Sie bei geöffnetem VS Code zu Ihrem Modulordner, und suchen Sie nach dem Skript mit dem Namen Standard.py. Öffnen Sie die Datei, indem Sie darauf doppelklicken.

Löschen Sie den Inhalt der Datei, und fügen Sie den folgenden Code ein:

# Copyright (c) Microsoft. All rights reserved.
# Licensed under the MIT license. See LICENSE file in the project root for
# full license information.

import random
import sched, time
import sys
import iothub_client
from iothub_client import IoTHubModuleClient, IoTHubClientError, IoTHubTransportProvider
from iothub_client import IoTHubMessage, IoTHubMessageDispositionResult, IoTHubError
import json
import os
import tensorflow as tf
import os
from PIL import Image
import numpy as np
import cv2

# messageTimeout - the maximum time in milliseconds until a message times out.
# The timeout period starts at IoTHubModuleClient.send_event_async.
# By default, messages do not expire.
MESSAGE_TIMEOUT = 10000

# global counters
RECEIVE_CALLBACKS = 0
SEND_CALLBACKS = 0

TEMPERATURE_THRESHOLD = 25
TWIN_CALLBACKS = 0

# Choose HTTP, AMQP or MQTT as transport protocol.  Currently only MQTT is supported.
PROTOCOL = IoTHubTransportProvider.MQTT


# Callback received when the message that we're forwarding is processed.
def send_confirmation_callback(message, result, user_context):
    global SEND_CALLBACKS
    print ( "Confirmation[%d] received for message with result = %s" % (user_context, result) )
    map_properties = message.properties()
    key_value_pair = map_properties.get_internals()
    print ( "    Properties: %s" % key_value_pair )
    SEND_CALLBACKS += 1
    print ( "    Total calls confirmed: %d" % SEND_CALLBACKS )


def convert_to_opencv(image):
    # RGB -> BGR conversion is performed as well.
    r,g,b = np.array(image).T
    opencv_image = np.array([b,g,r]).transpose()
    return opencv_image

def crop_center(img,cropx,cropy):
    h, w = img.shape[:2]
    startx = w//2-(cropx//2)
    starty = h//2-(cropy//2)
    return img[starty:starty+cropy, startx:startx+cropx]

def resize_down_to_1600_max_dim(image):
    h, w = image.shape[:2]
    if (h < 1600 and w < 1600):
        return image

    new_size = (1600 * w // h, 1600) if (h > w) else (1600, 1600 * h // w)
    return cv2.resize(image, new_size, interpolation = cv2.INTER_LINEAR)

def resize_to_256_square(image):
    h, w = image.shape[:2]
    return cv2.resize(image, (256, 256), interpolation = cv2.INTER_LINEAR)

def update_orientation(image):
    exif_orientation_tag = 0x0112
    if hasattr(image, '_getexif'):
        exif = image._getexif()
        if (exif != None and exif_orientation_tag in exif):
            orientation = exif.get(exif_orientation_tag, 1)
            # orientation is 1 based, shift to zero based and flip/transpose based on 0-based values
            orientation -= 1
            if orientation >= 4:
                image = image.transpose(Image.TRANSPOSE)
            if orientation == 2 or orientation == 3 or orientation == 6 or orientation == 7:
                image = image.transpose(Image.FLIP_TOP_BOTTOM)
            if orientation == 1 or orientation == 2 or orientation == 5 or orientation == 6:
                image = image.transpose(Image.FLIP_LEFT_RIGHT)
    return image


def analyse(hubManager):

    messages_sent = 0;

    while True:
        #def send_message():
        print ("Load the model into the project")
        # These names are part of the model and cannot be changed.
        output_layer = 'loss:0'
        input_node = 'Placeholder:0'

        graph_def = tf.GraphDef()
        labels = []

        labels_filename = "labels.txt"
        filename = "model.pb"

        # Import the TF graph
        with tf.gfile.FastGFile(filename, 'rb') as f:
            graph_def.ParseFromString(f.read())
            tf.import_graph_def(graph_def, name='')

        # Create a list of labels
        with open(labels_filename, 'rt') as lf:
            for l in lf:
                labels.append(l.strip())
        print ("Model loaded into the project")

        results_dic = dict()

        # create the JSON to be sent as a message
        json_message = ''

        # Iterate through images 
        print ("List of images to analyse:")
        for file in os.listdir('images'):
            print(file)

            image = Image.open("images/" + file)

            # Update orientation based on EXIF tags, if the file has orientation info.
            image = update_orientation(image)

            # Convert to OpenCV format
            image = convert_to_opencv(image)

            # If the image has either w or h greater than 1600 we resize it down respecting
            # aspect ratio such that the largest dimension is 1600
            image = resize_down_to_1600_max_dim(image)

            # We next get the largest center square
            h, w = image.shape[:2]
            min_dim = min(w,h)
            max_square_image = crop_center(image, min_dim, min_dim)

            # Resize that square down to 256x256
            augmented_image = resize_to_256_square(max_square_image)

            # The compact models have a network size of 227x227, the model requires this size.
            network_input_size = 227

            # Crop the center for the specified network_input_Size
            augmented_image = crop_center(augmented_image, network_input_size, network_input_size)

            try:
                with tf.Session() as sess:     
                    prob_tensor = sess.graph.get_tensor_by_name(output_layer)
                    predictions, = sess.run(prob_tensor, {input_node: [augmented_image] })
            except Exception as identifier:
                print ("Identifier error: ", identifier)

            print ("Print the highest probability label")
            highest_probability_index = np.argmax(predictions)
            print('FINAL RESULT! Classified as: ' + labels[highest_probability_index])

            l = labels[highest_probability_index]

            results_dic[file] = l

            # Or you can print out all of the results mapping labels to probabilities.
            label_index = 0
            for p in predictions:
                truncated_probablity = np.float64(round(p,8))
                print (labels[label_index], truncated_probablity)
                label_index += 1

        print("Results dictionary")
        print(results_dic)

        json_message = json.dumps(results_dic)
        print("Json result")
        print(json_message)

        # Initialize a new message
        message = IoTHubMessage(bytearray(json_message, 'utf8'))

        hubManager.send_event_to_output("output1", message, 0)

        messages_sent += 1
        print("Message sent! - Total: " + str(messages_sent))      
        print('----------------------------')

        # This is the wait time before repeating the analysis
        # Currently set to 10 seconds
        time.sleep(10)


class HubManager(object):

    def __init__(
            self,
            protocol=IoTHubTransportProvider.MQTT):
        self.client_protocol = protocol
        self.client = IoTHubModuleClient()
        self.client.create_from_environment(protocol)

        # set the time until a message times out
        self.client.set_option("messageTimeout", MESSAGE_TIMEOUT)

    # Forwards the message received onto the next stage in the process.
    def forward_event_to_output(self, outputQueueName, event, send_context):
        self.client.send_event_async(
            outputQueueName, event, send_confirmation_callback, send_context)

    def send_event_to_output(self, outputQueueName, event, send_context):
        self.client.send_event_async(outputQueueName, event, send_confirmation_callback, send_context)

def main(protocol):
    try:
        hub_manager = HubManager(protocol)
        analyse(hub_manager)
        while True:
            time.sleep(1)

    except IoTHubError as iothub_error:
        print ( "Unexpected error %s from IoTHub" % iothub_error )
        return
    except KeyboardInterrupt:
        print ( "IoTHubModuleClient sample stopped" )

if __name__ == '__main__':
    main(PROTOCOL)

Öffnen Sie die Datei mit dem Namenrequirements.txt, und ersetzen Sie ihren Inhalt durch den folgenden:
```
azure-iothub-device-client==1.4.0.0b3
opencv-python==3.3.1.11
tensorflow==1.8.0
pillow==5.1.0
```
Öffnen Sie die Datei deployment.template.json, und ersetzen Sie den Inhalt gemäß der folgenden Richtlinie:
1. Da Sie über eine eigene, eindeutige JSON-Struktur verfügen, müssen Sie sie manuell bearbeiten (anstatt ein Beispiel zu kopieren). Um dies zu vereinfachen, verwenden Sie das folgende Bild als Leitfaden.
2. Bereiche, die anders aussehen als Ihre, die Sie aber NICHT ändern sollten, sind gelb hervorgehoben.
3. Abschnitte, die Sie löschen müssen, sind rot hervorgehoben.
4. Achten Sie darauf, die richtigen Klammern zu löschen, und entfernen Sie auch die Kommas.
5. Der fertige JSON-Code sollte wie die folgende Abbildung aussehen (allerdings mit Ihren eindeutigen Unterschieden: Benutzername/Kennwort/Modulname/Modulverweise):

Öffnen Sie die Datei Dockerfile.amd64, und ersetzen Sie den Inhalt durch folgendes:

FROM ubuntu:xenial

WORKDIR /app

RUN apt-get update && \
    apt-get install -y --no-install-recommends libcurl4-openssl-dev python-pip libboost-python-dev && \
    rm -rf /var/lib/apt/lists/* 
RUN pip install --upgrade pip
RUN pip install setuptools

COPY requirements.txt ./
RUN pip install -r requirements.txt

RUN pip install pillow
RUN pip install numpy

RUN apt-get update && apt-get install -y \ 
    pkg-config \
    python-dev \ 
    python-opencv \ 
    libopencv-dev \ 
    libav-tools  \ 
    libjpeg-dev \ 
    libpng-dev \ 
    libtiff-dev \ 
    libjasper-dev \ 
    python-numpy \ 
    python-pycurl \ 
    python-opencv


RUN pip install opencv-python
RUN pip install tensorflow
RUN pip install --upgrade tensorflow

COPY . .

RUN useradd -ms /bin/bash moduleuser
USER moduleuser

CMD [ "python", "-u", "./main.py" ]

Klicken Sie mit der rechten Maustaste auf den Ordner unter den Modulen (der Name wird zuvor angegeben; im Beispiel weiter unten heißt er pythonmodule), und klicken Sie auf Neuer Ordner. Nennen Sie die Ordnerimages.
Fügen Sie im Ordner einige Bilder hinzu, die Maus oder Tastatur enthalten. Dies sind die Bilder, die vom Tensorflow-Modell analysiert werden.

Warnung

Wenn Sie Ihr eigenes Modell verwenden, müssen Sie dies ändern, um Ihre eigenen Modelldaten widerzuspiegeln.
Sie müssen nun die Dateienlabels.txt und model.pb aus dem Modellordner abrufen, die Sie zuvor heruntergeladen (oder aus Ihrem eigenen Custom Vision Service erstellt haben) in Kapitel 1. Sobald Sie über die Dateien verfügen, platzieren Sie sie in Ihrer Projektmappe neben den anderen Dateien. Das Endergebnis sollte wie in der folgenden Abbildung aussehen:

Kapitel 9: Packen der Lösung als Container

Jetzt können Sie Ihre Dateien als Container "packen" und per Push an Ihre Azure Container Registry übertragen. Öffnen Sie in VS Code das integrierte Terminal (Integriertes Terminalanzeigen> oder STRG+`) und verwenden Sie die folgende Zeile, um sich bei Docker anzumelden (ersetzen Sie die Werte des Befehls durch die Anmeldeinformationen Ihres Azure Container Registry (ACR)):
```
    docker login -u <ACR username> -p <ACR password> <ACR login server>
```
Klicken Sie mit der rechten Maustaste auf die Datei deployment.template.json, und klicken Sie auf IoT Edge Projektmappe erstellen. Dieser Buildvorgang dauert (abhängig von Ihrem Gerät) einige Zeit, also warten Sie. Nach Abschluss des Buildvorgangs wurde eine Datei deployment.json in einem neuen Ordner namens config erstellt.
Öffnen Sie die Befehlspalette erneut, und suchen Sie nach Azure: Anmelden. Befolgen Sie die Anweisungen unter Verwendung Ihrer Azure-Kontoanmeldeinformationen. VS Code bietet Ihnen eine Option zum Kopieren und Öffnen, wodurch der Gerätecode kopiert wird, den Sie in Kürze benötigen, und Ihren Standardwebbrowser öffnen. Wenn Sie dazu aufgefordert werden, fügen Sie den Gerätecode ein, um Ihren Computer zu authentifizieren.
Nachdem Sie sich angemeldet haben, sehen Sie auf der unteren Seite des Bereichs Erkunden einen neuen Abschnitt mit dem Namen Azure IoT Hub Geräte. Klicken Sie auf diesen Abschnitt, um ihn zu erweitern.
Wenn Ihr Gerät nicht hier ist, müssen Sie mit der rechten Maustaste auf Azure IoT Hub Geräte klicken und dann auf IoT Hub Verbindungszeichenfolge festlegen klicken. Sie werden dann sehen, dass die Befehlspalette (oben in VS Code) Sie zur Eingabe Ihrer Verbindungszeichenfolge auffordert. Dies ist die Verbindungszeichenfolge, die Sie sich am Ende von Kapitel 3 notiert haben. Drücken Sie die EINGABETASTE , nachdem Sie die Zeichenfolge kopiert haben.
Ihr Gerät sollte geladen werden und angezeigt werden. Klicken Sie mit der rechten Maustaste auf den Gerätenamen, und klicken Sie dann auf Bereitstellung für einzelnes Gerät erstellen.
Sie erhalten eine Explorer Eingabeaufforderung, in der Sie zum Ordner config navigieren und dann die Datei deployment.json auswählen können. Klicken Sie bei ausgewählter Datei auf die Schaltfläche Edgebereitstellungsmanifest auswählen .
An diesem Punkt haben Sie Ihrem IoT Hub Service das Manifest bereitgestellt, damit Sie Ihren Container als Modul von Ihrem Azure Container Registry bereitstellen und ihn effektiv auf Ihrem Gerät bereitstellen können.
Um die von Ihrem Gerät an den IoT Hub gesendeten Nachrichten anzuzeigen, klicken Sie im Bereich Explorer im Abschnitt Azure IoT Hub Gerätemit der rechten Maustaste erneut auf Ihren Gerätenamen, und klicken Sie auf Überwachung D2C-Nachricht starten. Die von Ihrem Gerät gesendeten Nachrichten sollten im VS-Terminal angezeigt werden. Seien Sie geduldig, da dies einige Zeit in Anspruch nehmen kann. Informationen zum Debuggen und überprüfen, ob die Bereitstellung erfolgreich war, finden Sie im nächsten Kapitel.

In diesem Modul werden nun die Bilder im Ordner images durchlaufen und mit jeder Iteration analysiert. Dies ist offensichtlich nur eine Demonstration, wie Sie das grundlegende Machine Learning-Modell in einer IoT Edge-Geräteumgebung verwenden können.

Um die Funktionalität dieses Beispiels zu erweitern, können Sie auf verschiedene Arten fortfahren. Eine Möglichkeit besteht darin, Code in den Container aufzunehmen, der Fotos von einer Webcam erfasst, die mit dem Gerät verbunden ist, und die Bilder im Ordner images speichert.

Eine andere Möglichkeit wäre das Kopieren der Images vom IoT-Gerät in den Container. Eine praktische Möglichkeit, dies zu tun, ist die Ausführung des folgenden Befehls im IoT-Geräteterminal (vielleicht eine kleine App, wenn Sie den Prozess automatisieren möchten). Sie können diesen Befehl testen, indem Sie ihn manuell in dem Ordner ausführen, in dem Ihre Dateien gespeichert sind:

    sudo docker cp <filename> <modulename>:/app/images/<a name of your choice>

Kapitel 10: Debuggen der IoT Edge Runtime

Im Folgenden sind eine Liste der Befehlszeilen und Tipps aufgeführt, mit denen Sie die Messagingaktivität der IoT Edge Runtime von Ihrem Ubuntu-Gerät aus überwachen und debuggen können.

Überprüfen Sie die status IoT Edge Runtime, indem Sie die folgende Befehlszeile ausführen:
```
    sudo systemctl status iotedge
```
Hinweis

Denken Sie daran, STRG+C zu drücken, um die Anzeige der status zu beenden.
Listet die container auf, die derzeit bereitgestellt werden. Wenn der IoT Hub Dienst die Container erfolgreich bereitgestellt hat, werden sie durch Ausführen der folgenden Befehlszeile angezeigt:
```
    sudo iotedge list
```
oder
```
    sudo docker ps
```
Hinweis

Die obige Option ist eine gute Möglichkeit, um zu überprüfen, ob Ihr Modul erfolgreich bereitgestellt wurde, da es in der Liste angezeigt wird. Andernfalls werden nuredgeHub und edgeAgent angezeigt.
Führen Sie die folgende Befehlszeile aus, um die Codeprotokolle eines Containers anzuzeigen:
```
    journalctl -u iotedge
```

Nützliche Befehle zum Verwalten der IoT Edge Runtime:

So löschen Sie alle Container auf dem Host:

    sudo docker rm -f $(sudo docker ps -aq)

So beenden Sie die IoT Edge Runtime:
```
    sudo systemctl stop iotedge
```

Kapitel 11: Erstellen eines Tabellendiensts

Navigieren Sie zurück zu Ihrem Azure-Portal, in dem Sie einen Azure Tables-Dienst erstellen, indem Sie eine Speicherressource erstellen.

Wenn Sie noch nicht angemeldet sind, melden Sie sich beim Azure-Portal an.
Klicken Sie nach der Anmeldung in der oberen linken Ecke auf Ressource erstellen, suchen Sie nach Speicherkonto, und drücken Sie die EINGABETASTE , um die Suche zu starten.
Sobald sie angezeigt wurde, klicken Sie in der Liste auf Speicherkonto – Blob, Datei, Tabelle, Warteschlange .
Die neue Seite enthält eine Beschreibung des Speicherkontodiensts . Klicken Sie unten links neben dieser Eingabeaufforderung auf die Schaltfläche Erstellen, um eine instance dieses Diensts zu erstellen.
Nachdem Sie auf Erstellen geklickt haben, wird ein Bereich angezeigt:
1. Fügen Sie den gewünschten Namen für diesen Dienst instance ein (muss nur Kleinbuchstaben sein).
2. Klicken Sie für Bereitstellungsmodell auf Ressourcen-Manager.
3. Klicken Sie unter Kontoart im Dropdownmenü auf Speicher (universell v1).
4. Klicken Sie auf einen geeigneten Speicherort.
5. Klicken Sie im Dropdownmenü Replikation auf Georedundanter Speicher (RA-GRS) mit Lesezugriff.
6. Klicken Sie unter Leistung auf Standard.
7. Klicken Sie im Abschnitt Sichere Übertragung erforderlich auf Deaktiviert.
8. Klicken Sie im Dropdownmenü Abonnement auf ein entsprechendes Abonnement.
9. Wählen Sie eine Ressourcengruppe aus, oder erstellen Sie eine neue. Eine Ressourcengruppe bietet eine Möglichkeit zum Überwachen, Steuern des Zugriffs, Bereitstellen und Verwalten der Abrechnung für eine Sammlung von Azure-Ressourcen. Es wird empfohlen, alle Azure-Dienste, die einem einzelnen Projekt (z. B. diesen Kursen) zugeordnet sind, unter einer gemeinsamen Ressourcengruppe zu speichern.
  
  Wenn Sie mehr über Azure-Ressourcengruppen erfahren möchten, folgen Sie diesem Link zum Verwalten einer Ressourcengruppe.
10. Lassen Sie Virtuelle Netzwerkeals Deaktiviert, wenn dies eine Option für Sie ist.
11. Klicken Sie auf Erstellen.
Nachdem Sie auf Erstellen geklickt haben, müssen Sie warten, bis der Dienst erstellt wurde. Dies kann eine Minute dauern.
Eine Benachrichtigung wird im Portal angezeigt, sobald der Dienst instance erstellt wurde. Klicken Sie auf die Benachrichtigungen, um Ihre neue Dienst-instance zu erkunden.
Klicken Sie in der Benachrichtigung auf die Schaltfläche Zu Ressource wechseln, und Sie gelangen zu Ihrer neuen Übersichtsseite des Speicherdiensts instance.
Klicken Sie auf der Übersichtsseite auf der rechten Seite auf Tabellen.
Der Bereich auf der rechten Seite wird geändert, um die Tabellendienstinformationen anzuzeigen, wobei Sie eine neue Tabelle hinzufügen müssen. Klicken Sie dazu in der oberen linken Ecke auf die Schaltfläche + Tabelle .
Es wird eine neue Seite angezeigt, auf der Sie einen Tabellennamen eingeben müssen. Dies ist der Name, den Sie verwenden, um auf die Daten in Ihrer Anwendung in späteren Kapiteln zu verweisen (Erstellen einer Funktions-App und Power BI). Fügen Sie IoTMessages als Namen ein (Sie können Ihren eigenen Namen auswählen, merken Sie sich dies, wenn sie später in diesem Dokument verwendet wird), und klicken Sie auf OK.
Nachdem die neue Tabelle erstellt wurde, können Sie sie auf der Seite Tabellendienst (unten) anzeigen.
Klicken Sie nun auf Zugriffsschlüssel , und nehmen Sie eine Kopie des Speicherkontonamens und des Schlüssels (mithilfe Ihres Editor) an. Sie verwenden diese Werte später in diesem Kurs, wenn Sie die Azure-Funktions-App erstellen.
Scrollen Sie im Bereich auf der linken Seite erneut zum Abschnitt Tabellendienst , klicken Sie auf Tabellen (oder tabellen durchsuchen in neueren Portalen), und erstellen Sie eine Kopie der Tabellen-URL (in Ihrem Editor). Sie verwenden diesen Wert später in diesem Kurs, wenn Sie Ihre Tabelle mit Ihrer Power BI-Anwendung verknüpfen.

Kapitel 12: Abschließen der Azure-Tabelle

Nachdem Ihr Tabellendienstspeicherkonto eingerichtet wurde, ist es an der Zeit, Daten hinzuzufügen, die zum Speichern und Abrufen von Informationen verwendet werden. Die Bearbeitung Ihrer Tabellen kann über Visual Studio erfolgen.

Öffnen Sie Visual Studio (nicht Visual Studio Code).
Klicken Sie im Menü aufCloud Exploreranzeigen>.
Der Cloud-Explorer wird als angedocktes Element geöffnet (haben Sie Geduld, da das Laden einige Zeit in Anspruch nehmen kann).
Warnung

Wenn das Abonnement, das Sie zum Erstellen Ihrer Speicherkonten verwendet haben, nicht sichtbar ist, stellen Sie sicher, dass Sie über Folgendes verfügen:
- Angemeldet bei demselben Konto wie das Konto, das Sie für das Azure-Portal verwendet haben.
- Wählen Sie Ihr Abonnement auf der Seite Kontoverwaltung aus (möglicherweise müssen Sie einen Filter aus Ihren Kontoeinstellungen anwenden):
Ihre Azure-Clouddienste werden angezeigt. Suchen Sie Nach Speicherkonten , und klicken Sie auf den Pfeil links davon, um Ihre Konten zu erweitern.
Nach der Erweiterung sollte Ihr neu erstelltes Speicherkonto verfügbar sein. Klicken Sie auf den Pfeil links neben Ihrem Speicher, und suchen Sie nach dem Erweitern nach Tabellen , und klicken Sie auf den Pfeil daneben, um die Tabelle anzuzeigen, die Sie im letzten Kapitel erstellt haben. Doppelklicken Sie auf Die Tabelle.
Die Tabelle wird in der Mitte des Visual Studio-Fensters geöffnet. Klicken Sie auf das Tabellensymbol mit dem + (Pluszeichen) darauf.
Es wird ein Fenster angezeigt, in dem Sie aufgefordert werden, Entität hinzuzufügen. Sie erstellen nur eine Entität, die jedoch über drei Eigenschaften verfügt. Sie werden feststellen, dass PartitionKey und RowKey bereits bereitgestellt wurden, da diese von der Tabelle verwendet werden, um Ihre Daten zu finden.
Ändern Sie die folgenden Werte:
- Name: PartitionKey, Value: PK_IoTMessages
- Name: RowKey, Value: RK_1_IoTMessages
Klicken Sie dann auf Eigenschaft hinzufügen (unten links im Fenster Entität hinzufügen ), und fügen Sie die folgende Eigenschaft hinzu:
- MessageContent als Zeichenfolge lassen Den Wert leer.
Ihre Tabelle sollte mit der tabelle in der folgenden Abbildung übereinstimmen:

Hinweis

Der Grund, warum die Entität die Zahl 1 im Zeilenschlüssel hat, ist, dass Sie möglicherweise weitere Nachrichten hinzufügen möchten, wenn Sie mit diesem Kurs weiter experimentieren möchten.
Klicken Sie anschließend auf OK. Ihre Tabelle kann jetzt verwendet werden.

Kapitel 13: Erstellen einer Azure-Funktions-App

Es ist jetzt an der Zeit, eine Azure-Funktions-App zu erstellen, die vom IoT Hub-Dienst aufgerufen wird, um die IoT Edge Gerätenachrichten im Tabellendienst zu speichern, den Sie im vorherigen Kapitel erstellt haben.

Zunächst müssen Sie eine Datei erstellen, die es Ihrer Azure-Funktion ermöglicht, die benötigten Bibliotheken zu laden.

Öffnen Sie Editor (drücken Sie die Windows-TASTE, und geben Sie Editor ein).
Fügen Sie bei geöffnetem Editor die unten stehende JSON-Struktur ein. Nachdem Sie dies getan haben, speichern Sie es auf Ihrem Desktop als project.json. Diese Datei definiert die Bibliotheken, die ihre Funktion verwendet. Wenn Sie NuGet verwendet haben, wird es ihnen bekannt vorkommen.

Warnung

Es ist wichtig, dass die Benennung korrekt ist; Stellen Sie sicher, dass keine .txt Dateierweiterung vorhanden ist. Weitere Informationen finden Sie unten:
```
{
"frameworks": {
    "net46":{
    "dependencies": {
        "WindowsAzure.Storage": "9.2.0"
    }
    }
}
}
```
Melden Sie sich beim Azure-Portal an.
Sobald Sie angemeldet sind, klicken Sie in der oberen linken Ecke auf Ressource erstellen , suchen Sie nach Funktions-App, und drücken Sie die EINGABETASTE , um zu suchen. Klicken Sie in den Ergebnissen auf Funktions-App , um einen neuen Bereich zu öffnen.
Im neuen Bereich wird eine Beschreibung des Funktions-App-Diensts bereitgestellt. Klicken Sie unten links in diesem Bereich auf die Schaltfläche Erstellen , um eine Zuordnung mit diesem Dienst zu erstellen.
Nachdem Sie auf Erstellen geklickt haben, geben Sie Folgendes ein:
1. Fügen Sie unter App-Name den gewünschten Namen für diese Dienst-instance ein.
2. Wählen Sie ein Abonnementaus.
3. Wählen Sie den für Sie geeigneten Tarif aus. Wenn Sie zum ersten Mal eine Funktion App Service erstellen, sollte ihnen ein Kostenloser Tarif zur Verfügung stehen.
4. Wählen Sie eine Ressourcengruppe aus, oder erstellen Sie eine neue. Eine Ressourcengruppe bietet eine Möglichkeit zum Überwachen, Steuern des Zugriffs, Bereitstellen und Verwalten der Abrechnung für eine Sammlung von Azure-Ressourcen. Es wird empfohlen, alle Azure-Dienste, die einem einzelnen Projekt (z. B. diesen Kursen) zugeordnet sind, unter einer gemeinsamen Ressourcengruppe zu speichern.
  
  Wenn Sie mehr über Azure-Ressourcengruppen erfahren möchten, folgen Sie diesem Link zum Verwalten einer Ressourcengruppe.
5. Klicken Sie für das Betriebssystem auf Windows, da dies die beabsichtigte Plattform ist.
6. Wählen Sie einen Hostingplan aus (in diesem Tutorial wird ein Verbrauchsplan verwendet.
7. Wählen Sie einen Speicherort aus (wählen Sie denselben Speicherort wie den Speicher aus, den Sie im vorherigen Schritt erstellt haben)
8. Für den Abschnitt Speichermüssen Sie den Speicherdienst auswählen, den Sie im vorherigen Schritt erstellt haben.
9. Sie benötigen Application Insights in dieser App nicht, also lassen Sie sie aus.
10. Klicken Sie auf Erstellen.
Nachdem Sie auf Erstellen geklickt haben, müssen Sie warten, bis der Dienst erstellt wurde. Dies kann eine Minute dauern.
Eine Benachrichtigung wird im Portal angezeigt, sobald der Dienst instance erstellt wurde.
Klicken Sie auf die Benachrichtigung, sobald die Bereitstellung erfolgreich war (abgeschlossen).
Klicken Sie in der Benachrichtigung auf die Schaltfläche Zu Ressource wechseln, um Ihre neue Dienst-instance zu erkunden.
Klicken Sie links im neuen Bereich auf das + Symbol (Pluszeichen) neben Funktionen, um eine neue Funktion zu erstellen.
Im zentralen Bereich wird das Fenster Funktionserstellung angezeigt. Scrollen Sie weiter nach unten, und klicken Sie auf Benutzerdefinierte Funktion.
Scrollen Sie auf der nächsten Seite nach unten, bis Sie IoT Hub (Event Hub) finden, und klicken Sie dann darauf.
Legen Sie auf dem Blatt IoT Hub (Event Hub) die Sprache auf C# fest, und klicken Sie dann auf Neu.
Stellen Sie im angezeigten Fenster sicher, dass IoT Hub ausgewählt ist und der Name des felds IoT Hub dem Namen Ihres IoT Hub-Diensts entspricht, den Sie zuvor erstellt haben (in Schritt 8 von Kapitel 3). Klicken Sie dann auf die Schaltfläche Auswählen .
Klicken Sie auf dem Blatt IoT Hub (Event Hub) auf Erstellen.
Sie werden zum Funktions-Editor umgeleitet.

Löschen Sie den gesamten Code darin, und ersetzen Sie ihn durch Folgendes:

#r "Microsoft.WindowsAzure.Storage"
#r "NewtonSoft.Json"

using System;
using Microsoft.WindowsAzure.Storage;
using Microsoft.WindowsAzure.Storage.Table;
using Newtonsoft.Json;
using System.Threading.Tasks;

public static async Task Run(string myIoTHubMessage, TraceWriter log)
{
    log.Info($"C# IoT Hub trigger function processed a message: {myIoTHubMessage}");

    //RowKey of the table object to be changed
    string tableName = "IoTMessages";
    string tableURL = "https://iothubmrstorage.table.core.windows.net/IoTMessages";

    // If you did not name your Storage Service as suggested in the course, change the name here with the one you chose.
    string storageAccountName = "iotedgestor"; 

    string storageAccountKey = "<Insert your Storage Key here>";   

    string partitionKey = "PK_IoTMessages";
    string rowKey = "RK_1_IoTMessages";

    Microsoft.WindowsAzure.Storage.Auth.StorageCredentials storageCredentials =
        new Microsoft.WindowsAzure.Storage.Auth.StorageCredentials(storageAccountName, storageAccountKey);

    CloudStorageAccount storageAccount = new CloudStorageAccount(storageCredentials, true);

    // Create the table client.
    CloudTableClient tableClient = storageAccount.CreateCloudTableClient();

    // Get a reference to a table named "IoTMessages"
    CloudTable messageTable = tableClient.GetTableReference(tableName);

    //Retrieve the table object by its RowKey
    TableOperation operation = TableOperation.Retrieve<MessageEntity>(partitionKey, rowKey);
    TableResult result = await messageTable.ExecuteAsync(operation);

    //Create a MessageEntity so to set its parameters
    MessageEntity messageEntity = (MessageEntity)result.Result;

    messageEntity.MessageContent = myIoTHubMessage;
    messageEntity.PartitionKey = partitionKey;
    messageEntity.RowKey = rowKey;

    //Replace the table appropriate table Entity with the value of the MessageEntity Ccass structure.
    operation = TableOperation.Replace(messageEntity);

    // Execute the insert operation.
    await messageTable.ExecuteAsync(operation);
}

// This MessageEntity structure which will represent a Table Entity
public class MessageEntity : TableEntity
{
    public string Type { get; set; }
    public string MessageContent { get; set; }   
}

Ändern Sie die folgenden Variablen, sodass sie den entsprechenden Werten (Tabellen - und Speicherwerte aus Schritt 11 bzw. Schritt 13 von Kapitel 11) entsprechen, die Sie in Ihrem Speicherkonto finden:
- tableName, wobei sich der Name Ihrer Tabelle in Ihrem Speicherkonto befindet.
- tableURL, wobei sich die URL Ihrer Tabelle in Ihrem Speicherkonto befindet.
- storageAccountName mit dem Namen des Werts, der dem Namen Ihres Speicherkontonamens entspricht.
- storageAccountKey mit dem Schlüssel, den Sie im Speicherdienst abgerufen haben, den Sie zuvor erstellt haben.
Klicken Sie auf Speichern, wenn der Code vorhanden ist.
Klicken Sie als Nächstes rechts < auf der Seite auf das Symbol (Pfeil).
Ein Bereich wird von rechts eingeblendt. Klicken Sie in diesem Bereich auf Hochladen, und ein Dateibrowser wird angezeigt.
Navigieren Sie zu der Datei project.json , die Sie zuvor in Editor erstellt haben, und klicken Sie darauf, und klicken Sie dann auf die Schaltfläche Öffnen . Diese Datei definiert die Bibliotheken, die ihre Funktion verwendet.
Wenn die Datei hochgeladen wurde, wird sie im Bereich auf der rechten Seite angezeigt. Wenn Sie darauf klicken, wird sie im Funktions-Editor geöffnet. Es muss genau wie das nächste Bild aussehen.
An diesem Punkt wäre es gut, die Fähigkeit Ihrer Funktion zum Speichern der Nachricht in Ihrer Tabelle zu testen. Klicken Sie rechts oben im Fenster auf Testen.
Fügen Sie eine Meldung im Anforderungstext ein, wie in der Abbildung oben dargestellt, und klicken Sie auf Ausführen.
Die Funktion wird ausgeführt und zeigt das Ergebnis status an (Sie werden den grünen Status 202 Akzeptiert oberhalb des Ausgabefensters sehen, was bedeutet, dass es sich um einen erfolgreichen Aufruf handelt):

Kapitel 14: Anzeigen aktiver Nachrichten

Wenn Sie jetzt Visual Studio (nicht Visual Studio Code) öffnen, können Sie das Testmeldungsergebnis visualisieren, da es im Zeichenfolgenbereich MessageContent gespeichert wird.

Screenshot: Registerkarte

Wenn der Tabellendienst und die Funktions-App vorhanden sind, werden Ihre Ubuntu-Gerätemeldungen in Ihrer IoTMessages-Tabelle angezeigt. Wenn noch nicht ausgeführt wird, starten Sie Ihr Gerät erneut, und Sie können die Ergebnismeldungen von Ihrem Gerät und modul in Ihrer Tabelle anzeigen, indem Sie Visual Studio Cloud Explorer verwenden.

Visualisieren von Daten

Kapitel 15: Power BI-Setup

Um die Daten von Ihrem IOT-Gerät zu visualisieren, richten Sie Power BI (Desktopversion) ein, um die Daten aus dem soeben erstellten Tabellendienst zu sammeln. Die HoloLens-Version von Power BI verwendet diese Daten dann, um das Ergebnis zu visualisieren.

Öffnen Sie die Microsoft Store unter Windows 10, und suchen Sie nach Power BI Desktop.
Laden Sie die Anwendung herunter. Sobald der Download abgeschlossen ist, öffnen Sie es.
Melden Sie sich mit Ihrem Microsoft 365-Konto bei Power BI an. Sie können zu einem Browser weitergeleitet werden, um sich zu registrieren. Nachdem Sie sich registriert haben, wechseln Sie zurück zur Power BI-App, und melden Sie sich erneut an.
Klicken Sie auf Daten abrufen und dann auf Mehr....
Klicken Sie auf Azure, Azure Table Storage und dann auf Verbinden.
Sie werden aufgefordert, die zuvor (in Schritt 13 von Kapitel 11) erfasste Tabellen-URL einzufügen, während Sie Ihren Tabellendienst erstellen. Nachdem Sie die URL eingefügt haben, löschen Sie den Teil des Pfads, der auf den "Unterordner" der Tabelle verweist (in diesem Kurs ioTMessages). Das Endergebnis sollte wie in der folgenden Abbildung dargestellt sein. Klicken Sie dann auf OK.
Sie werden aufgefordert, den Speicherschlüssel einzufügen, den Sie zuvor (in Schritt 11 von Kapitel 11) beim Erstellen ihres Tabellenspeichers notiert haben. Klicken Sie dann auf Verbinden.
Es wird ein Navigatorpanel angezeigt, aktivieren Sie das Kontrollkästchen neben Ihrer Tabelle, und klicken Sie auf Laden.
Ihre Tabelle wurde nun in Power BI geladen, erfordert jedoch eine Abfrage, um die darin aufgeführten Werte anzuzeigen. Klicken Sie dazu mit der rechten Maustaste auf den Tabellennamen, der sich im Bereich FELDER auf der rechten Seite des Bildschirms befindet. Klicken Sie dann auf Abfrage bearbeiten.
Ein Power Query-Editor wird als neues Fenster geöffnet, in dem Ihre Tabelle angezeigt wird. Klicken Sie in der Spalte Inhalt der Tabelle auf das Wort Datensatz, um den gespeicherten Inhalt zu visualisieren.
Klicken Sie oben links im Fenster auf In Tabelle.
Klicken Sie auf Schließen & Übernehmen.
Nachdem das Laden der Abfrage abgeschlossen ist, aktivieren Sie im Bereich FIELDS auf der rechten Seite des Bildschirms die Kontrollkästchen, die den Parametern Name und Wert entsprechen, um den Inhalt der Spalte MessageContent zu visualisieren.
Klicken Sie oben links im Fenster auf das blaue Datenträgersymbol , um Ihre Arbeit in einem Ordner Ihrer Wahl zu speichern.
Sie können jetzt auf die Schaltfläche Veröffentlichen klicken, um Ihre Tabelle in Ihren Arbeitsbereich hochzuladen. Wenn Sie dazu aufgefordert werden, klicken Sie auf Mein Arbeitsbereich und dann auf Auswählen. Warten Sie, bis das erfolgreiche Ergebnis der Übermittlung angezeigt wird.

Warnung

Das folgende Kapitel ist HoloLens-spezifisch. Power BI ist derzeit nicht als immersive Anwendung verfügbar. Sie können die Desktopversion jedoch im Windows Mixed Reality Portal (auch bekannt als Cliff House) über die Desktop-App ausführen.

Kapitel 16: Anzeigen von Power BI-Daten auf HoloLens

Melden Sie sich auf Ihrer HoloLens beim Microsoft Store an, indem Sie in der Anwendungsliste auf das entsprechende Symbol tippen.
Suchen Sie die Power BI-Anwendung , und laden Sie sie herunter.
Starten Sie Power BI über Ihre Anwendungsliste.
Power BI fordert Sie möglicherweise auf, sich bei Ihrem Microsoft 365-Konto anzumelden.
Sobald sie sich in der App befinden, sollte der Arbeitsbereich standardmäßig wie in der folgenden Abbildung dargestellt angezeigt werden. Wenn dies nicht der Fall ist, klicken Sie einfach auf das Arbeitsbereichssymbol auf der linken Seite des Fensters.

Ihre IoT Hub-Anwendung wurde abgeschlossen.

Herzlichen Glückwunsch, Sie haben erfolgreich einen IoT Hub-Dienst mit einem simulierten Virtual Machine Edge-Gerät erstellt. Ihr Gerät kann die Ergebnisse eines Machine Learning-Modells an einen Azure-Tabellendienst übermitteln, der von einer Azure-Funktions-App unterstützt wird, die in Power BI eingelesen und innerhalb eines Microsoft HoloLens visualisiert wird.

Holo Lens-Anzeige, die die Microsoft Power B I-Seite zeigt.

Zusatzübungen

Übung 1

Erweitern Sie die in der Tabelle gespeicherte Messagingstruktur, und zeigen Sie sie als Diagramm an. Möglicherweise möchten Sie weitere Daten sammeln und in derselben Tabelle speichern, um später angezeigt zu werden.

Übung 2

Erstellen Sie ein zusätzliches Kameraaufnahmemodul, das auf dem IoT-Board bereitgestellt werden soll, damit es Bilder über die zu analysierende Kamera erfassen kann.