Nachdem wir nun erfolgreich einen Azure IoT Hub inkl. Nachrichtenrouting und einem ersten IoT Gerät erstellt haben, ist es nun an der Zeit mit Hilfe einer kleinen C# Konsolenanwendung ein IoT Gerät zu simulieren und Daten an den IoT Hub zu senden.

MQTT und Firewall

Da das simulierte IoT Ger√§t das MQTT Protokoll f√ľr die Kommunikation mit dem IoT Hub verwendet, m√ľssen wir sicherstellen das der Port 8883 in der Firewall freigegeben ist.

MQTT steht f√ľr Message Queuing Telemetry Transport und ist ein offenes Nachrichtenprotokoll f√ľr Machine-to-Machine-Kommunikation. Es erm√∂glicht den Austausch von Nachrichten zwischen Internet of Things-Ger√§ten. Es ist an sich eine leichtgewichtige Publish/Subscribe-L√∂sung.

Die C# Konsolenanwendung um Daten an den IoT Hub zu senden

Wir starten Microsoft Visual Studio 2019 und erstellen eine neue Konsolen-App (.NET Core).

Wir benennen das Projekt IoTGarageSimDevice01 und klicken auf Erstellen.

Bevor wir entwickeln k√∂nnen m√ľssen wir zuerst die Device SDK for Azure IoT Hub dem Projekt hinzuf√ľgen. Dazu √∂ffnen wir die NuGet Package Manager Konsole √ľber Extras > NuGet-Paket-Manager > Paket-Manager-Konsole.

In der Konsole geben wir nachfolgenden Befehl ein um die SDK zu installieren.

PM> Install-Package Microsoft.Azure.Devices.Client

Nachdem das Paket erfolgreich installiert wurde nutzen wir den nachfolgenden Code um folgende Dinge zu tun.

  • Baut eine Verbindung zu IoT Hub auf
  • Simuliert Temperatur und Feuchtigkeit
  • F√ľgt eine Eigenschaft der Nachricht hinzu auf Basis der Gr√∂√üe des Wertes um damit das Nachrichtenrouting steuern zu k√∂nnen
  • Packt diese Informationen als JSON Objekt welches in BASE64 encodiert wurde in den Body der Nachricht
using Microsoft.Azure.Devices.Client;
using Newtonsoft.Json;
using Newtonsoft.Json.Linq;
using System;
using System.Text;
using System.Threading;
using System.Threading.Tasks;

namespace IoTGarageSimDevice01
{

    class Program
    {

        private static DeviceClient s_deviceClient;
        private readonly static string s_myDeviceId = "<Die Geräte-Id des im IoT Hub registrierten Gerätes>"; // simulatedDevice
        private readonly static string s_iotHubUri = "<Hostname des IoT Hubs>"; // iotghub.azure-devices.net
        // Im IoT Hub > Ger√§te > Prim√§rschl√ľssel
        private readonly static string s_deviceKey = "PM2yvQu4/SwEhLZBLTCEqOjrYLWFbnDNf/kFJ0F0vUo=";

        private static async Task Main()
        {
            Console.WriteLine("Routing Tutorial: Simulated device\n");
            s_deviceClient = DeviceClient.Create(s_iotHubUri,
                new DeviceAuthenticationWithRegistrySymmetricKey(s_myDeviceId, s_deviceKey), TransportType.Mqtt);

            using var cts = new CancellationTokenSource();
            var messages = SendDeviceToCloudMessagesAsync(cts.Token);
            Console.WriteLine("Press the Enter key to stop.");
            Console.ReadLine();
            cts.Cancel();
            await messages;
        }

        private static async Task SendDeviceToCloudMessagesAsync(CancellationToken token)
        {
            double minTemperature = 20;
            double minHumidity = 60;
            Random rand = new Random();

            while (!token.IsCancellationRequested)
            {
                double currentTemperature = minTemperature + rand.NextDouble() * 15;
                double currentHumidity = minHumidity + rand.NextDouble() * 20;

                string infoString;
                string levelValue;

                if (rand.NextDouble() > 0.7)
                {
                    if (rand.NextDouble() > 0.5)
                    {
                        levelValue = "critical";
                        infoString = "This is a critical message.";
                    }
                    else
                    {
                        levelValue = "storage";
                        infoString = "This is a storage message.";
                    }
                }
                else
                {
                    levelValue = "normal";
                    infoString = "This is a normal message.";
                }

                var telemetryDataPoint = new
                {
                    deviceId = s_myDeviceId,
                    temperature = currentTemperature,
                    humidity = currentHumidity,
                    pointInfo = infoString
                };

                var telemetryDataString = JsonConvert.SerializeObject(telemetryDataPoint);

                // You can encode this as ASCII, but if you want it to be the body of the message, 
                //  and to be able to search the body, it must be encoded in UTF with base64 encoding.
                using var message = new Message(Encoding.UTF32.GetBytes(telemetryDataString));

                //Add one property to the message.
                message.Properties.Add("target", levelValue);

                // Submit the message to the hub.
                await s_deviceClient.SendEventAsync(message);

                // Print out the message.
                Console.WriteLine("{0} > Sent message: {1}", DateTime.Now, telemetryDataString);

                await Task.Delay(1000);
            }
        }
    }
}

Wenn die Anwendung erfolgreich gestartet ist wird sie Nachrichten generieren und an den IoT Hub senden. Das sieht wie folgt aus.

In dem vorherigen Artikel hatten wir im IoT Hub ein Nachrichtenrouting f√ľr Nachrichten mit der Eigenschaft level = storage erstellt. Diese sollten in den Data Lake geroutet werden. Ob das auch wirklich passiert ist, k√∂nnen wir pr√ľfen in dem wir den Data Lake Explorer starten uns anschauen ob dort Nachrichten weggeschrieben wurden. Dazu wechseln wir im Azure Portal zu unserem Speicherkonto iotgstorage und in der √úbersicht klicken wir auf Container. In der Container √úbersicht w√§hlen wir unseren Data Lake iotgdatalake aus.

Hier klicken wir auf iotgdatalake. Automatisch öffnet sich der Azure Storage Explorer und wir können nun in den Verzeichnissen navigieren. Auf der Root-Ebene befindet sich ein Ordner iotghub. Das heißt dass das Nachrichtenrouting des IoT Hubs Daten in den Data Lake geschrieben hat. Wir drillen weiter runter in der Verzeichnisstruktur bis iotgdatalake / iotghub / 00 / 2021 / 02 / 07 / 15. Dort angekommen sehen wir eine JSON Datei. Das heißt, dass unser simuliertes IoT Gerät Nachrichten mit der Eigenschaft level = storage erzeugt hat. Wir können die Nachricht auch herunterladen und uns beispielsweise den Inhalt im Notepad anschauen oder auf den Abschnitt Bearbeiten klicken.

{"EnqueuedTimeUtc":"2021-02-07T15:01:47.6580000Z","Properties":{"target":"storage"},"SystemProperties":{"connectionDeviceId":"simulatedDevice","connectionAuthMethod":"{\"scope\":\"device\",\"type\":\"sas\",\"issuer\":\"iothub\",\"acceptingIpFilterRule\":null}","connectionDeviceGenerationId":"637480710472027598","enqueuedTime":"2021-02-07T15:01:47.6580000Z"},"Body":"ewAAACIAAABkAAAAZQAAAHYAAABpAAAAYwAAAGUAAABJAAAAZAAAACIAAAA6AAAAIgAAAHMAAABpAAAAbQAAAHUAAABsAAAAYQAAAHQAAABlAAAAZAAAAEQAAABlAAAAdgAAAGkAAABjAAAAZQAAACIAAAAsAAAAIgAAAHQAAABlAAAAbQAAAHAAAABlAAAAcgAAAGEAAAB0AAAAdQAAAHIAAABlAAAAIgAAADoAAAAzAAAAMAAAAC4AAAA0AAAAMAAAADIAAAA3AAAAMAAAADAAAAA0AAAANwAAADIAAAA4AAAAMQAAADAAAAA2AAAAMwAAADMAAAAsAAAAIgAAAGgAAAB1AAAAbQAAAGkAAABkAAAAaQAAAHQAAAB5AAAAIgAAADoAAAA2AAAANwAAAC4AAAA0AAAAOQAAADgAAAA3AAAAMwAAADYAAAAxAAAAOQAAADgAAAA3AAAANQAAADgAAAAxAAAAMgAAACwAAAAiAAAAcAAAAG8AAABpAAAAbgAAAHQAAABJAAAAbgAAAGYAAABvAAAAIgAAADoAAAAiAAAAVAAAAGgAAABpAAAAcwAAACAAAABpAAAAcwAAACAAAABhAAAAIAAAAHMAAAB0AAAAbwAAAHIAAABhAAAAZwAAAGUAAAAgAAAAbQAAAGUAAABzAAAAcwAAAGEAAABnAAAAZQAAAC4AAAAiAAAAfQAAAA=="}
{"EnqueuedTimeUtc":"2021-02-07T15:02:15.6010000Z","Properties":{"target":"storage"},"SystemProperties":{"connectionDeviceId":"simulatedDevice","connectionAuthMethod":"{\"scope\":\"device\",\"type\":\"sas\",\"issuer\":\"iothub\",\"acceptingIpFilterRule\":null}","connectionDeviceGenerationId":"637480710472027598","enqueuedTime":"2021-02-07T15:02:15.6010000Z"},"Body":"ewAAACIAAABkAAAAZQAAAHYAAABpAAAAYwAAAGUAAABJAAAAZAAAACIAAAA6AAAAIgAAAHMAAABpAAAAbQAAAHUAAABsAAAAYQAAAHQAAABlAAAAZAAAAEQAAABlAAAAdgAAAGkAAABjAAAAZQAAACIAAAAsAAAAIgAAAHQAAABlAAAAbQAAAHAAAABlAAAAcgAAAGEAAAB0AAAAdQAAAHIAAABlAAAAIgAAADoAAAAyAAAANgAAAC4AAAAxAAAANQAAADcAAAAzAAAAMgAAADMAAAA5AAAAMQAAADYAAAA1AAAAMQAAADUAAAA5AAAANQAAADMAAAAsAAAAIgAAAGgAAAB1AAAAbQAAAGkAAABkAAAAaQAAAHQAAAB5AAAAIgAAADoAAAA2AAAAOAAAAC4AAAA0AAAAOQAAADIAAAA0AAAAOAAAADMAAAAyAAAANQAAADgAAAA0AAAANwAAADYAAAA3AAAAMQAAACwAAAAiAAAAcAAAAG8AAABpAAAAbgAAAHQAAABJAAAAbgAAAGYAAABvAAAAIgAAADoAAAAiAAAAVAAAAGgAAABpAAAAcwAAACAAAABpAAAAcwAAACAAAABhAAAAIAAAAHMAAAB0AAAAbwAAAHIAAABhAAAAZwAAAGUAAAAgAAAAbQAAAGUAAABzAAAAcwAAAGEAAABnAAAAZQAAAC4AAAAiAAAAfQAAAA=="}
{"EnqueuedTimeUtc":"2021-02-07T15:02:17.9760000Z","Properties":{"target":"storage"},"SystemProperties":{"connectionDeviceId":"simulatedDevice","connectionAuthMethod":"{\"scope\":\"device\",\"type\":\"sas\",\"issuer\":\"iothub\",\"acceptingIpFilterRule\":null}","connectionDeviceGenerationId":"637480710472027598","enqueuedTime":"2021-02-07T15:02:17.9760000Z"},"Body":"ewAAACIAAABkAAAAZQAAAHYAAABpAAAAYwAAAGUAAABJAAAAZAAAACIAAAA6AAAAIgAAAHMAAABpAAAAbQAAAHUAAABsAAAAYQAAAHQAAABlAAAAZAAAAEQAAABlAAAAdgAAAGkAAABjAAAAZQAAACIAAAAsAAAAIgAAAHQAAABlAAAAbQAAAHAAAABlAAAAcgAAAGEAAAB0AAAAdQAAAHIAAABlAAAAIgAAADoAAAAzAAAAMQAAAC4AAAAxAAAAMAAAADcAAAA5AAAAOAAAADEAAAA4AAAANwAAADEAAAAzAAAAOQAAADgAAAAxAAAANgAAACwAAAAiAAAAaAAAAHUAAABtAAAAaQAAAGQAAABpAAAAdAAAAHkAAAAiAAAAOgAAADYAAAAxAAAALgAAADEAAAA5AAAANQAAADcAAAA0AAAAMAAAADcAAAA5AAAAMwAAADQAAAA1AAAANwAAADEAAAAzAAAANAAAACwAAAAiAAAAcAAAAG8AAABpAAAAbgAAAHQAAABJAAAAbgAAAGYAAABvAAAAIgAAADoAAAAiAAAAVAAAAGgAAABpAAAAcwAAACAAAABpAAAAcwAAACAAAABhAAAAIAAAAHMAAAB0AAAAbwAAAHIAAABhAAAAZwAAAGUAAAAgAAAAbQAAAGUAAABzAAAAcwAAAGEAAABnAAAAZQAAAC4AAAAiAAAAfQAAAA=="}
{"EnqueuedTimeUtc":"2021-02-07T15:02:25.0850000Z","Properties":{"target":"storage"},"SystemProperties":{"connectionDeviceId":"simulatedDevice","connectionAuthMethod":"{\"scope\":\"device\",\"type\":\"sas\",\"issuer\":\"iothub\",\"acceptingIpFilterRule\":null}","connectionDeviceGenerationId":"637480710472027598","enqueuedTime":"2021-02-07T15:02:25.0850000Z"},"Body":"ewAAACIAAABkAAAAZQAAAHYAAABpAAAAYwAAAGUAAABJAAAAZAAAACIAAAA6AAAAIgAAAHMAAABpAAAAbQAAAHUAAABsAAAAYQAAAHQAAABlAAAAZAAAAEQAAABlAAAAdgAAAGkAAABjAAAAZQAAACIAAAAsAAAAIgAAAHQAAABlAAAAbQAAAHAAAABlAAAAcgAAAGEAAAB0AAAAdQAAAHIAAABlAAAAIgAAADoAAAAyAAAANAAAAC4AAAAyAAAAMgAAADYAAAA5AAAAMAAAADIAAAA5AAAAOAAAADgAAAAzAAAANwAAADkAAAAzAAAAMAAAADgAAAAsAAAAIgAAAGgAAAB1AAAAbQAAAGkAAABkAAAAaQAAAHQAAAB5AAAAIgAAADoAAAA3AAAAMwAAAC4AAAA1AAAANAAAADAAAAA2AAAANAAAADMAAAA4AAAAMgAAADMAAAAxAAAAMQAAADkAAAAxAAAAOAAAACwAAAAiAAAAcAAAAG8AAABpAAAAbgAAAHQAAABJAAAAbgAAAGYAAABvAAAAIgAAADoAAAAiAAAAVAAAAGgAAABpAAAAcwAAACAAAABpAAAAcwAAACAAAABhAAAAIAAAAHMAAAB0AAAAbwAAAHIAAABhAAAAZwAAAGUAAAAgAAAAbQAAAGUAAABzAAAAcwAAAGEAAABnAAAAZQAAAC4AAAAiAAAAfQAAAA=="}
{"EnqueuedTimeUtc":"2021-02-07T15:02:30.9930000Z","Properties":{"target":"storage"},"SystemProperties":{"connectionDeviceId":"simulatedDevice","connectionAuthMethod":"{\"scope\":\"device\",\"type\":\"sas\",\"issuer\":\"iothub\",\"acceptingIpFilterRule\":null}","connectionDeviceGenerationId":"637480710472027598","enqueuedTime":"2021-02-07T15:02:30.9930000Z"},"Body":"ewAAACIAAABkAAAAZQAAAHYAAABpAAAAYwAAAGUAAABJAAAAZAAAACIAAAA6AAAAIgAAAHMAAABpAAAAbQAAAHUAAABsAAAAYQAAAHQAAABlAAAAZAAAAEQAAABlAAAAdgAAAGkAAABjAAAAZQAAACIAAAAsAAAAIgAAAHQAAABlAAAAbQAAAHAAAABlAAAAcgAAAGEAAAB0AAAAdQAAAHIAAABlAAAAIgAAADoAAAAyAAAAMgAAAC4AAAA4AAAAMgAAADQAAAAyAAAAMAAAADYAAAAxAAAANAAAADYAAAAzAAAAMgAAADkAAAA3AAAAMwAAADYAAAAsAAAAIgAAAGgAAAB1AAAAbQAAAGkAAABkAAAAaQAAAHQAAAB5AAAAIgAAADoAAAA3AAAAOAAAAC4AAAA5AAAANwAAADgAAAAwAAAAMwAAADEAAAAzAAAAMQAAADQAAAA0AAAAMwAAADMAAAA1AAAANwAAACwAAAAiAAAAcAAAAG8AAABpAAAAbgAAAHQAAABJAAAAbgAAAGYAAABvAAAAIgAAADoAAAAiAAAAVAAAAGgAAABpAAAAcwAAACAAAABpAAAAcwAAACAAAABhAAAAIAAAAHMAAAB0AAAAbwAAAHIAAABhAAAAZwAAAGUAAAAgAAAAbQAAAGUAAABzAAAAcwAAAGEAAABnAAAAZQAAAC4AAAAiAAAAfQAAAA=="}

Wenn wir uns den Body der Nachrichten beispielsweise der ersten Nachricht decodiert anschauen, sieht das Ergebnis wie folgt aus.

Base64

ewAAACIAAABkAAAAZQAAAHYAAABpAAAAYwAAAGUAAABJAAAAZAAAACIAAAA6AAAAIgAAAHMAAABpAAAAbQAAAHUAAABsAAAAYQAAAHQAAABlAAAAZAAAAEQAAABlAAAAdgAAAGkAAABjAAAAZQAAACIAAAAsAAAAIgAAAHQAAABlAAAAbQAAAHAAAABlAAAAcgAAAGEAAAB0AAAAdQAAAHIAAABlAAAAIgAAADoAAAAzAAAAMAAAAC4AAAA0AAAAMAAAADIAAAA3AAAAMAAAADAAAAA0AAAANwAAADIAAAA4AAAAMQAAADAAAAA2AAAAMwAAADMAAAAsAAAAIgAAAGgAAAB1AAAAbQAAAGkAAABkAAAAaQAAAHQAAAB5AAAAIgAAADoAAAA2AAAANwAAAC4AAAA0AAAAOQAAADgAAAA3AAAAMwAAADYAAAAxAAAAOQAAADgAAAA3AAAANQAAADgAAAAxAAAAMgAAACwAAAAiAAAAcAAAAG8AAABpAAAAbgAAAHQAAABJAAAAbgAAAGYAAABvAAAAIgAAADoAAAAiAAAAVAAAAGgAAABpAAAAcwAAACAAAABpAAAAcwAAACAAAABhAAAAIAAAAHMAAAB0AAAAbwAAAHIAAABhAAAAZwAAAGUAAAAgAAAAbQAAAGUAAABzAAAAcwAAAGEAAABnAAAAZQAAAC4AAAAiAAAAfQAAAA==

Decodiert

{"deviceId":"simulatedDevice", "temperature":30.402700472810633, "humidity":67.49873619875812, "pointInfo":"This is a storage message."}

Sehr schön! Das sieht doch gut aus. Wir haben ein IoT Gerät simuliert das Nachrichten an den IoT Hub in der Azure Cloud geschickt hat und zudem der IoT Hub auf Basis von Eigenschaften der Nachrichten, diese Nachricht an den Data Lake geroutet hat.

Lesen vom integrierten Endpunkt

Der IoT Hub stellt standardm√§√üig einen integrierten Event Hub kompatiblen Endpunkt unter messages/events zur Verf√ľgung. Nun werden wir zum einen unser zuvor erstelltes simuliertes Ger√§t starten um Nachrichten in den IoT Hub zu stremen und auf der anderen Seite werden wir eine weitere Konsolenanwendung erstellen, welcher vom Endpunkt messages/events die Nachrichten lesen wird.

Wir ben√∂tigen zuerst ein Blob Storage. Der Azure Blog Storage wird als Pr√ľfpunktspeicher verwendet, also erstellen wir im n√§chsten Schritt ein Blob Storage.

Einen Blob Storage f√ľr den Pr√ľfpunktspeicher (Ckeckpoint) erstellen

Dazu gehen wir wieder in das Azure Portal und öffnen und Speicherkonto iotgstorage. Hier klicken wir auf Container und dann auf + Container.

Ich benenne den Blob Storage iotgcheckpointblob und klicke auf Erstellen.

Der Blob Storage wurde erfolgreich erstellt und erscheint in der Liste der Container im Speicherkonto.

C# Client f√ľr das Lesen des integrierten Endpunktes

Wir starten Microsoft Visual Studio 2019 und erstellen eine neue Konsolen-App (.NET Core).

Wir nennen das Projekt IoTGarage-Azure-02-IoTHub-ReadFromInternalEndpoint und klicken auf Erstellen.

Bevor wir entwickeln k√∂nnen, m√ľssen wir zuerst die Bibliothek Azure.Messaging.EventHubs.Processor dem Projekt hinzuf√ľgen. Dazu √∂ffnen wir die NuGet Package Manager Konsole √ľber Extras > NuGet-Paket-Manager > Paket-Manager-Konsole.

In der Konsole geben wir nachfolgenden Befehl ein um die Bibliothek zu installieren.

PM> Install-Package Azure.Messaging.EventHubs.Processor

Nachdem das Paket erfolgreich installiert wurde k√∂nnen wir nun den Client f√ľr das Abrufen der Nachrichten aus den Endpunkt entwickeln.

F√ľr die Verbindung zum Event Hub kompatiblen Endpunkt herzustellen, ben√∂tigen wir vier Informationen:

  • Event Hub Connection String
  • Event Hub Name
  • Blob Storage Connection String
  • Blob Storage Container Name

Der Event Hub Name ist einfach: es ist der Name unseres IoT Hubs. In unserem Fall iotghub. Beim Blob Storage Container Name ist ebenfalls einfach, das ist iotgcheckpointblob (was wir im vorherigen Abschnitt erstellt haben).

Den Connection String f√ľr den Event Hub finden wir wie folgt. Wir √∂ffnen das Azure Portal. Dort √∂ffnen wir die Ressource iotghub (unseren IoT Hub). Klicken im linken Men√ľ unter Einstellungen auf Integrierte Endpunkte. Dort kopieren wir den Eintrag im Feld Event Hub-kompatibler Endpunkt.

Den Blob Storage Connection String finden wir wie folgt. Wir √∂ffnen diesmal die Ressource iotgstorage (unser Speicherkonto). W√§hlen links im Men√ľ unter Einstellungen > Zugriffsschl√ľssel den Eintrag im Abschnitt key1 > Verbindungszeichenfolge. Hinter dem Eintrag in diesem Feld verbirgt sich der Blob Storage Connection String. So, da wir jetzt alle Notwendigen Informationen haben, tragen wir diese im Code in den Konstanten ein und k√∂nnen die Anwendung starten.

using System;
using System.Text;
using System.Threading.Tasks;
using Azure.Storage.Blobs;
using Azure.Messaging.EventHubs;
using Azure.Messaging.EventHubs.Consumer;
using Azure.Messaging.EventHubs.Processor;

namespace IoTGarage_Azure_04_EventHubProcessEvents
{
    class Program
    {

        private const string ehubNamespaceConnectionString = "Endpoint=sb://...";
        private const string eventHubName = "{hubname}";
        private const string blobStorageConnectionString = "DefaultEndpointsProtocol=...";
        private const string blobContainerName = "{blobcontainername}";

        private static Task initializeEventHandler(PartitionInitializingEventArgs arg)
        {
            arg.DefaultStartingPosition = EventPosition.Latest;
            return Task.CompletedTask;
        }

        static async Task ProcessEventHandler(ProcessEventArgs eventArgs)
        {
            Console.WriteLine("\tReceived event: {0}", Encoding.UTF32.GetString(eventArgs.Data.Body.ToArray()));
            await eventArgs.UpdateCheckpointAsync(eventArgs.CancellationToken);
        }

        static Task ProcessErrorHandler(ProcessErrorEventArgs eventArgs)
        {
            Console.WriteLine($"\tPartition '{ eventArgs.PartitionId}': an unhandled exception was encountered.");
            Console.WriteLine(eventArgs.Exception.Message);
            return Task.CompletedTask;
        }

        static async Task Main()
        {
            BlobContainerClient storageClient = new BlobContainerClient(blobStorageConnectionString, blobContainerName);
            EventProcessorClient processor = new EventProcessorClient(storageClient, EventHubConsumerClient.DefaultConsumerGroupName, ehubNamespaceConnectionString, eventHubName);

            processor.PartitionInitializingAsync += initializeEventHandler;
            processor.ProcessEventAsync += ProcessEventHandler;
            processor.ProcessErrorAsync += ProcessErrorHandler;

            await processor.StartProcessingAsync();
            Console.ReadLine();
        }

    }
}

Wenn alles richtig war, so sollten nun die Einträge aus dem Integrierten Event Hub Endpunkt ausgelesen und ausgegeben werden.

Weitere detaillierte Information f√ľr das verarbeiten von Events findet man hier und hier. Das ist eine M√∂glichkeit um die Nachrichten aus dem ioT Hub auszulesen. Alternativ gibt es die M√∂glichkeit Nachrichten via Azure Stream Analytics in Echtzeit zu verarbeiten und in verschiedene Quellen wegzuschreiben sowie mit Power BI ein Echtzeit Dashboard aufzubauen. Oder den Event Grid zu nutzen oder in den Event Hub zu schreiben. Oder den Strom an Nachrichten beispielsweise mit Azure Databricks zu analysieren oder die Nachrichten in einen Blob, Data Lake und anschlie√üend in eine Datenbank zu schreiben oder f√ľr AI Szenarien einzusetzen. Oder oder oder oder … Es gibt also not einige M√∂glichkeiten auf die wir teilweise in dieser Serie eingehen werden.

Weiterf√ľhrende Links