Tutorial: Erstellen einer ereignisgesteuerten App mit Dapr und MQTT-Broker

Artikel
11/20/2024

In dieser Schritt-für-Schritt-Anleitung stellen Sie eine Dapr-Anwendung im Cluster bereit. Die Dapr-Anwendung nutzt simulierte MQTT-Daten, die im MQTT-Broker veröffentlicht werden, wendet eine Windowing-Funktion an und veröffentlicht das Ergebnis dann wieder im MQTT-Broker. Die veröffentlichte Ausgabe zeigt, wie große Datenmengen am Edge aggregiert werden können, um die Häufigkeit und Größe von Nachrichten zu reduzieren. Die Dapr-Anwendung ist zustandslos und verwendet den MQTT-Broker-Zustand, um vergangene Werte, die für die Fensterberechnungen benötigt werden, zwischenzuspeichern.

Die Dapr-Anwendung führt die folgenden Schritte aus:

Abonniert das Thema sensor/data für Sensordaten.
Wenn Daten zu diesem Thema eingehen, werden sie im MQTT-Broker-Status-Speicher veröffentlicht.
Alle 10 Sekunden werden die Daten aus dem Zustandsspeicher abgerufen und die Minimal-, Maximal-, Mittel-, Median- und 75. Perzentilwerte für alle Sensordaten mit Zeitstempel der letzten 30 Sekunden berechnet.
Daten, die älter als 30 Sekunden sind, werden aus dem Zustandsspeicher gelöscht.
Das Ergebnis wird im JSON-Format in das Thema sensor/window_data veröffentlicht.

Hinweis

Dieses Tutorial deaktiviert Dapr CloudEvents, wodurch es unformatierte MQTT-Ereignisse veröffentlichen und abonnieren kann.

Voraussetzungen

Azure IoT Einsatz installiert: Schnellstart: Ausführen von Azure IoT Einsatz in GitHub Codespaces mit K3s
Dapr-Komponenten von MQTT-Broker installiert – Installieren von Dapr-Komponenten von MQTT-Broker

Bereitstellen der Dapr-Anwendung

An diesem Punkt können Sie die Dapr-Anwendung bereitstellen. Wenn Sie die Komponenten registrieren, wird dadurch nicht die zugeordnete Binärdatei bereitgestellt, die in einen Container gepackt ist. Um die Binärdatei zusammen mit Ihrer Anwendung bereitzustellen, können Sie eine Bereitstellung verwenden, um die containerisierte Dapr-Anwendung und die beiden Komponenten zusammen zu gruppieren.

Zunächst erstellen Sie eine YAML-Datei, die folgenden Definitionen verwendet:

Komponente	Beschreibung
`volumes.mqtt-client-token`	Der SAT zur Authentifizierung der austauschbaren Dapr-Komponenten mit dem MQTT-Broker und dem Zustandsspeicher
`volumes.aio-internal-ca-cert-chain`	Die Vertrauenskette zur Überprüfung des MQTT-Broker-TLS-Zertifikats
`containers.mq-event-driven`	Der vordefinierte Dapr-Anwendungscontainer.

Speichern Sie die folgende Bereitstellungs-YAML in einer Datei namens app.yaml:

apiVersion: v1
kind: ServiceAccount
metadata:
  name: dapr-client
  namespace: azure-iot-operations
  annotations:
    aio-broker-auth/group: dapr-workload
---    
apiVersion: apps/v1
kind: Deployment
metadata:
  name: mq-event-driven-dapr
  namespace: azure-iot-operations
spec:
  selector:
    matchLabels:
      app: mq-event-driven-dapr
  template:
    metadata:
      labels:
        app: mq-event-driven-dapr
      annotations:
        dapr.io/enabled: "true"
        dapr.io/inject-pluggable-components: "true"
        dapr.io/app-id: "mq-event-driven-dapr"
        dapr.io/app-port: "6001"
        dapr.io/app-protocol: "grpc"
    spec:
      serviceAccountName: dapr-client

      volumes:
      # SAT token used to authenticate between Dapr and the MQTT broker
      - name: mqtt-client-token
        projected:
          sources:
            - serviceAccountToken:
                path: mqtt-client-token
                audience: aio-internal
                expirationSeconds: 86400

      # Certificate chain for Dapr to validate the MQTT broker
      - name: aio-ca-trust-bundle
        configMap:
          name: azure-iot-operations-aio-ca-trust-bundle

      containers:
      - name: mq-event-driven-dapr
        image: ghcr.io/azure-samples/explore-iot-operations/mq-event-driven-dapr:latest

Führen Sie den folgenden Befehl aus, um die Anwendung bereitzustellen:
```
kubectl apply -f app.yaml
```

Bestätigen Sie, dass die Anwendung erfolgreich bereitgestellt wurde. Der Pod sollte alle Container nach einem kurzen Intervall melden, wie mit dem folgenden Befehl gezeigt:

kubectl get pods -l app=mq-event-driven-dapr -n azure-iot-operations

Mit der folgenden Ausgabe:

NAME                         READY   STATUS              RESTARTS   AGE
mq-event-driven-dapr         3/3     Running             0          30s

Bereitstellen des Simulators

Simulieren Sie Testdaten, indem Sie eine Kubernetes-Workload bereitstellen. Er simuliert einen Sensor, indem er regelmäßig Temperatur-, Vibrations- und Druckmesswerte an den MQTT-Broker sendet, indem er einen MQTT-Client auf dem Thema sensor/data verwendet.

Stellen Sie den Simulator aus dem Repository Explore IoT Operations bereit:

kubectl apply -f https://raw.githubusercontent.com/Azure-Samples/explore-iot-operations/main/tutorials/mq-event-driven-dapr/simulate-data.yaml

Bestätigen Sie, dass der Simulator korrekt ausgeführt wird:

kubectl logs deployment/mqtt-publisher-deployment -n azure-iot-operations -f

Mit der folgenden Ausgabe:

Get:1 http://deb.debian.org/debian stable InRelease [151 kB]
Get:2 http://deb.debian.org/debian stable-updates InRelease [52.1 kB]
Get:3 http://deb.debian.org/debian-security stable-security InRelease [48.0 kB]
Get:4 http://deb.debian.org/debian stable/main amd64 Packages [8780 kB]
Get:5 http://deb.debian.org/debian stable-updates/main amd64 Packages [6668 B]
Get:6 http://deb.debian.org/debian-security stable-security/main amd64 Packages [101 kB]
Fetched 9139 kB in 3s (3570 kB/s)
...
Messages published in the last 10 seconds: 10
Messages published in the last 10 seconds: 10
Messages published in the last 10 seconds: 10

Bereitstellen eines MQTT-Clients

Um zu überprüfen, ob die MQTT-Brücke funktioniert, stellen Sie einen MQTT-Client auf dem Cluster bereit.

Geben Sie in einer neuen Datei mit dem Namen client.yaml die Clientbereitstellung an:

apiVersion: v1
kind: ServiceAccount
metadata:
  name: mqtt-client
  namespace: azure-iot-operations
---
apiVersion: v1
kind: Pod
metadata:
  name: mqtt-client
  namespace: azure-iot-operations
spec:
  serviceAccountName: mqtt-client
  containers:
  - image: alpine
    name: mqtt-client
    command: ["sh", "-c"]
    args: ["apk add mosquitto-clients mqttui && sleep infinity"]
    volumeMounts:
    - name: mqtt-client-token
      mountPath: /var/run/secrets/tokens
    - name: aio-ca-trust-bundle
      mountPath: /var/run/certs/aio-internal-ca-cert/
  volumes:
  - name: mqtt-client-token
    projected:
      sources:
      - serviceAccountToken:
          path: mqtt-client-token
          audience: aio-internal
          expirationSeconds: 86400
  - name: aio-ca-trust-bundle
    configMap:
      name: azure-iot-operations-aio-ca-trust-bundle

Wenden Sie die Bereitstellungsdatei mit kubectl an:
```
kubectl apply -f client.yaml
```
Ausgabe überprüfen:
```
pod/mqtt-client created
```

Überprüfen Sie die Ausgabe der Dapr-Anwendung

Öffnen Sie eine Shell für den Mosquitto-Client-Pod:

kubectl exec --stdin --tty mqtt-client -n azure-iot-operations -- sh

Abonnieren Sie das Thema sensor/window_data, um die Veröffentlichungsausgabe aus der Dapr-Anwendung zu untersuchen:
```
mosquitto_sub -L mqtt://aio-broker/sensor/window_data
```

Überprüfen Sie, ob die Anwendung alle 10 Sekunden eine Gleitfensterberechnung für die verschiedenen Sensoren ausgibt:

{
    "timestamp": "2023-11-16T21:59:53.939690+00:00",
    "window_size": 30,
    "temperature": {
        "min": 553.024,
        "max": 598.907,
        "mean": 576.4647857142858,
        "median": 577.4905,
        "75_per": 585.96125,
        "count": 28
    },
    "pressure": {
        "min": 290.605,
        "max": 299.781,
        "mean": 295.521,
        "median": 295.648,
        "75_per": 297.64050000000003,
        "count": 28
    },
    "vibration": {
        "min": 0.00124192,
        "max": 0.00491257,
        "mean": 0.0031171810714285715,
        "median": 0.003199235,
        "75_per": 0.0038769150000000003,
        "count": 28
    }
}

Optional – Erstellen der Dapr-Anwendung

Dieses Tutorial wird ein vordefinierter Container der Dapr-Anwendung verwendet. Wenn Sie den Code selbst ändern und erstellen möchten, führen Sie die folgenden Schritte aus:

Voraussetzungen

Docker – zum Erstellen des Anwendungscontainers
Eine Containerregistrierung – zum Hosten des Anwendungscontainers

Erstellen der Anwendung

Klonen Sie das Repository Explore IoT Operations:

git clone https://github.com/Azure-Samples/explore-iot-operations

Wechseln zum Dapr-Lernprogrammverzeichnis:

cd explore-iot-operations/tutorials/mq-event-driven-dapr/src

Erstellen Sie das Docker-Image:

docker build docker build . -t mq-event-driven-dapr

Um die Anwendung in Ihrem Kubernetes-Cluster zu nutzen, müssen Sie das Image in eine Containerregistrierung wie z. B. die Azure Container Registry übertragen. Sie können auch per Push auf eine lokale Containerregistrierung wie minikube oder Docker übertragen.
```
docker tag mq-event-driven-dapr <container-alias>
docker push <container-alias>
```
Aktualisieren Sie Ihre app.yaml, um das neu erstellte Image abzurufen.

Problembehandlung

Wenn die Anwendung nicht gestartet wird oder die Container in CrashLoopBackoff angezeigt werden, enthält das daprd Containerprotokoll häufig nützliche Informationen.

Führen Sie den folgenden Befehl aus, um die Protokolle für die daprd-Komponente anzuzeigen:

kubectl logs -l app=mq-event-driven-dapr -n azure-iot-operations -c daprd

Nächste Schritte

Überführen Sie MQTT-Daten zwischen MQTT-Broker und Azure Event Grid

Freigeben über

Tutorial: Erstellen einer ereignisgesteuerten App mit Dapr und MQTT-Broker

Voraussetzungen

Bereitstellen der Dapr-Anwendung

Bereitstellen des Simulators

Bereitstellen eines MQTT-Clients

Überprüfen Sie die Ausgabe der Dapr-Anwendung

Optional – Erstellen der Dapr-Anwendung

Voraussetzungen

Erstellen der Anwendung

Problembehandlung

Nächste Schritte

Feedback

Zusätzliche Ressourcen