Esercitazione: creare un'app guidata dagli eventi con Dapr e broker MQTT

In questo tutorial, distribuisci un'applicazione Dapr nel cluster. L'applicazione Dapr utilizza dati MQTT simulati pubblicati nel broker MQTT, applica una funzione di windowing e quindi pubblica il risultato nel broker MQTT. L'output pubblicato mostra come grandi volumi di dati possano essere aggregati all'edge per ridurre la frequenza e la dimensione dei messaggi. L'applicazione Dapr è senza stato e usa l'archivio dello stato del broker MQTT per memorizzare nella cache i valori precedenti necessari per i calcoli della finestra.

Tramite l'applicazione Dapr vengono effettuati i passaggi seguenti:

Si iscrive all'argomento sensor/data per i dati del sensore.
Quando i dati vengono ricevuti sull'argomento, vengono pubblicati nell'archivio di stato del broker MQTT.
Ogni 10 secondi, recupera i dati dall'archivio stati e calcola i valori min, max, medio, mediano e 75° percentile in qualsiasi timestamp dei dati del sensore negli ultimi 30 secondi.
I dati più vecchi di 30 secondi vengono eliminati dall'archivio di stato.
Il risultato viene pubblicato nell'argomento sensor/window_data in formato JSON.

Annotazioni

In questa esercitazione si disabilitano i CloudEvents di Dapr, in modo da consentire la pubblicazione e la sottoscrizione usando MQTT raw.

Prerequisiti

Un cluster Kubernetes con Azure Arc abilitato in cui è distribuito Operazioni di Azure IoT. Se non ne hai uno, puoi seguire le istruzioni di Quickstart: Esegui Operazioni di Azure IoT in GitHub Codespaces con K3 per crearne rapidamente uno in GitHub Codespaces.
Componenti Dapr del broker MQTT installati: Installare i componenti Dapr del broker MQTT

Distribuire l'applicazione Dapr

A questo punto, è possibile distribuire l'applicazione Dapr. La registrazione dei componenti non esegue il deployment del binario associato pacchettizzato in un container. Per distribuire il file binario insieme all'applicazione, è possibile usare una distribuzione per raggruppare l'applicazione Dapr in contenitori e i due componenti.

Per iniziare, creare un file yaml che usa le definizioni seguenti:

Componente	Descrizione
`volumes.mqtt-client-token`	Il SAT utilizzato per autenticare i componenti plug-in di Dapr presso il broker MQTT e l'archivio di stato
`volumes.aio-internal-ca-cert-chain`	Catena di attendibilità per convalidare il certificato TLS del broker MQTT
`containers.mq-event-driven`	Contenitore di applicazione Dapr predefinito.

Salvare il file yaml di distribuzione seguente in un file denominato 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

Distribuire l'applicazione eseguendo il comando seguente:
```
kubectl apply -f app.yaml
```
Verificare che l'applicazione sia stata distribuita correttamente. Il pod dovrebbe segnalare che tutti i contenitori sono pronti dopo un breve intervallo, come illustrato con il comando seguente:
```
kubectl get pods -l app=mq-event-driven-dapr -n azure-iot-operations
```
Con l'output seguente:
```
NAME                         READY   STATUS              RESTARTS   AGE
mq-event-driven-dapr         3/3     Running             0          30s
```

Distribuire il simulatore

Simulare i dati di test distribuendo un carico di lavoro Kubernetes. Simula un sensore inviando periodicamente letture di temperatura, vibrazioni e pressione del campione al broker MQTT usando un client MQTT nell’argomento sensor/data.

Distribuisci il simulatore dal repository Explore IoT Operations:

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

Verificare che il simulatore sia in esecuzione correttamente:

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

Con l'output seguente:

(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

Distribuire un client MQTT

Per verificare che il bridge MQTT funzioni, distribuire un client MQTT nel cluster.

In un nuovo file denominato client.yaml, specificare la distribuzione client:

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

Applicare il file di distribuzione con kubectl:

kubectl apply -f client.yaml

Verificare l'output:

serviceaccount/mqtt-client created
pod/mqtt-client created

Verificare l'output dell'applicazione Dapr

Aprire una shell per il pod client Mosquitto:

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

Iscriversi all'argomento sensor/window_data per monitorare l'output pubblicato dall'applicazione Dapr:
```
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
```
Annotazioni

Il comando precedente funziona per lo spazio di codice di avvio rapido. Se usi un ambiente diverso, potresti dover modificare i parametri.

Verificare che l'applicazione restituisca un calcolo delle finestre scorrevoli per i vari sensori ogni 10 secondi:

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

Facoltativo: creare l'applicazione Dapr

Questa esercitazione usa un contenitore predefinito dell'applicazione Dapr. Se si vuole modificare e compilare manualmente il codice, seguire questa procedura:

Prerequisiti

Docker per la compilazione del contenitore dell'applicazione
Un registro dei container - per ospitare il container applicativo

Compilare l'applicazione

Clona il repository Explore IoT Operations:

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

Passare alla directory del tutorial di Dapr:

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

Compilare l'immagine Docker:

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

Per usare l'applicazione nel cluster Kubernetes, è necessario eseguire il push dell'immagine in un registro contenitori, ad esempio Registro Azure Container. È anche possibile eseguire il push in un registro contenitori locale, ad esempio minikube o Docker.
```
docker tag mq-event-driven-dapr <container-alias>
docker push <container-alias>
```
Aggiornate il app.yaml in modo che recuperi l'immagine appena creata.

Risoluzione dei problemi

Se l'applicazione non viene avviata o i contenitori vengono visualizzati in CrashLoopBackoff, il daprd log del contenitore spesso contiene informazioni utili.

Eseguire il comando seguente per visualizzare i log per il componente daprd:

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

Passaggi successivi

Collegare i dati MQTT tra il broker MQTT e Griglia di eventi di Azure

Commenti e suggerimenti

Questa pagina è stata utile?

Last updated on 2026-07-10

Esercitazione: creare un'app guidata dagli eventi con Dapr e broker MQTT

Prerequisiti

Distribuire l'applicazione Dapr

Distribuire il simulatore

Distribuire un client MQTT

Verificare l'output dell'applicazione Dapr

Facoltativo: creare l'applicazione Dapr

Prerequisiti

Compilare l'applicazione

Risoluzione dei problemi

Passaggi successivi

Commenti e suggerimenti

Risorse aggiuntive