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

In diesem Tutorial bereitest du eine Dapr-Anwendung im Cluster ein. 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 für dieses Topic empfangen werden, werden sie im State-Store des MQTT-Brokers gespeichert.
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

Ein Azure Arc-fähiger Kubernetes-Cluster mit Azure IoT Einsatz im Einsatz. Wenn du keinen hast, kannst du den Anweisungen in Quickstart folgen: Run Azure IoT Einsatz in GitHub Codespaces mit K3s, um schnell einen in GitHub Codespaces zu erstellen.
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, der zur Authentifizierung der erweiterbaren Dapr-Komponenten beim MQTT Vermittler und dem Statusspeicher verwendet wird
`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 nach einem kurzen Intervall anzeigen, dass alle Container bereit sind, wie der folgende Befehl zeigt:

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. Es simuliert einen Sensor, indem es regelmäßig Beispielmesswerte für Temperatur, Vibration und Druck mithilfe eines MQTT-Clients an den MQTT-Broker über das Topic sensor/data sendet.

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 -n azure-iot-operations -f

Mit der folgenden Ausgabe:

(1/4) Installing cjson (1.7.19-r1)
(2/4) Installing c-ares (1.34.8-r0)
(3/4) Installing mosquitto-libs (2.1.2-r1)
(4/4) Installing mosquitto-clients (2.1.2-r1)
Executing busybox-1.37.0-r31.trigger
OK: 8787 KiB in 20 packages
Starting simulator
Published 5 messages
Published 10 messages
Published 15 messages
Published 20 messages
Published 25 messages

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 Deployment-Datei mit kubectl an:

kubectl apply -f client.yaml

Ausgabe überprüfen:

serviceaccount/mqtt-client created
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:
```
TOKEN=$(cat /var/run/secrets/tokens/mqtt-client-token)

mosquitto_sub \
  -h aio-broker \
  -p 18883 \
  --cafile /var/run/certs/aio-internal-ca-cert/ca.crt \
  -u K8S-SAT \
  -P "$TOKEN" \
  -t "sensor/window_data" \
  -v
```
Hinweis

Der vorherige Befehl funktioniert für den Quickstart-Codespace. Wenn du eine andere Umgebung benutzt, musst du vielleicht die Parameter anpassen.

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

{
    "timestamp": "2026-07-09T05:20:39.462675+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

In diesem Tutorial wird ein vorkonfigurierter Container für die 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

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

Feedback

War diese Seite hilfreich?

Last updated on 2026-07-10

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