Självstudie: Skapa en händelsedriven app med Dapr och MQTT Broker

2025-08-07

I den här genomgången distribuerar du ett Dapr-program till klustret. Dapr-programmet använder simulerade MQTT-data som publicerats till MQTT-asynkron meddelandekö, tillämpar en fönsterfunktion och publicerar sedan resultatet tillbaka till MQTT-asynkron meddelandekö. Publicerade utdata representerar hur data med hög volym kan aggregeras på gränsen för att minska meddelandefrekvensen och storleken. Dapr-programmet är tillståndslöst och använder MQTT Broker State Store för att cachelagras tidigare värden som behövs för fönsterberäkningarna.

Dapr-programmet utför följande steg:

Prenumererar på ämnet sensor/data för sensordata.
När data tar emot om ämnet publiceras de till MQTT Broker State Store.
Var 10:e sekund hämtar den data från tillståndslagret och beräknar värdena min, max, medelvärde, median och 75:e percentilen på alla tidsstämplar för sensordata under de senaste 30 sekunderna.
Data som är äldre än 30 sekunder har upphört att gälla från tillståndslagret.
Resultatet publiceras till ämnet sensor/window_data i JSON-format.

Anmärkning

Den här självstudien inaktiverar Dapr CloudEvents som gör det möjligt att publicera och prenumerera med rå MQTT.

Förutsättningar

Azure IoT-åtgärder installerade – Snabbstart: Kör Azure IoT-åtgärder i GitHub Codespaces med K3s
MQTT Broker Dapr-komponenter installerade – Installera MQTT Broker Dapr Components

Distribuera Dapr-programmet

Nu kan du distribuera Dapr-programmet. Om du registrerar komponenterna distribueras inte den associerade binärfilen som paketeras i en container. Om du vill distribuera binärfilen tillsammans med ditt program kan du använda en distribution för att gruppera det containerbaserade Dapr-programmet och de två komponenterna tillsammans.

Börja med att skapa en yaml-fil som använder följande definitioner:

Komponent	Beskrivning
`volumes.mqtt-client-token`	SAT som används för att autentisera Dapr-pluggbara komponenter med MQTT-asynkron meddelandekö och state store
`volumes.aio-internal-ca-cert-chain`	Förtroendekedjan för att verifiera TLS-certifikatet för MQTT-koordinator
`containers.mq-event-driven`	Den fördefinierade Dapr-programcontainern.

Spara följande distributions-yaml i en fil med namnet 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

Distribuera programmet genom att köra följande kommando:
```
kubectl apply -f app.yaml
```

Bekräfta att programmet har distribuerats. Podden bör rapportera att alla containrar är klara efter ett kort intervall, vilket visas med följande kommando:

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

Med följande utdata:

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

Distribuera simulatorn

Simulera testdata genom att distribuera en Kubernetes-arbetsbelastning. Den simulerar en sensor genom att skicka provtemperatur, vibrationer och tryckmätningar regelbundet till MQTT-koordinatorn med hjälp av en MQTT-klient i ämnet sensor/data .

Distribuera simulatorn från lagringsplatsen Utforska IoT-åtgärder :

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

Bekräfta att simulatorn körs korrekt:

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

Med följande utdata:

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

Distribuera en MQTT-klient

Om du vill kontrollera att MQTT-bryggan fungerar distribuerar du en MQTT-klient till klustret.

I en ny fil med namnet client.yamlanger du klientdistributionen:

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

Använd distributionsfilen med kubectl:
```
kubectl apply -f client.yaml
```
Verifiera utdata:
```
pod/mqtt-client created
```

Verifiera Dapr-programmets utdata

Öppna ett gränssnitt till Mosquitto-klientpodden:

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

Prenumerera på ämnet sensor/window_data för att se publicerade utdata från Dapr-programmet:
```
mosquitto_sub -L mqtt://aio-broker/sensor/window_data
```

Kontrollera att programmet matar ut en glidande windowsberäkning för de olika sensorerna var 10:e sekund:

{
    "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
    }
}

Valfritt – Skapa Dapr-programmet

I den här självstudien används en fördefinierad container för Dapr-programmet. Följ dessa steg om du vill ändra och skapa koden själv:

Förutsättningar

Docker – för att skapa programcontainern
Ett containerregister – för att vara värd för programcontainern

Skapa programmet

Klona lagringsplatsen Utforska IoT-åtgärder :

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

Ändra till katalogen Dapr-självstudie:

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

Skapa docker-avbildningen:

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

Om du vill använda programmet i kubernetes-klustret måste du skicka avbildningen till ett containerregister, till exempel Azure Container Registry. Du kan också skicka till ett lokalt containerregister, till exempel minikube eller Docker.
```
docker tag mq-event-driven-dapr <container-alias>
docker push <container-alias>
```
Uppdatera din app.yaml för att hämta den nyligen skapade avbildningen.

Felsökning

Om programmet inte startar eller om du ser containrarna i CrashLoopBackoffinnehåller containerloggen daprd ofta användbar information.

Kör följande kommando för att visa loggarna för daprd-komponenten:

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

Nästa steg

Överbrygga MQTT-data mellan MQTT-koordinator och Azure Event Grid

Feedback

Var den här sidan till hjälp?

Dela via

Självstudie: Skapa en händelsedriven app med Dapr och MQTT Broker

Förutsättningar

Distribuera Dapr-programmet

Distribuera simulatorn

Distribuera en MQTT-klient

Verifiera Dapr-programmets utdata

Valfritt – Skapa Dapr-programmet

Förutsättningar

Skapa programmet

Felsökning

Nästa steg

Feedback

Ytterligare resurser