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

Articolo
11/20/2024

In questa procedura dettagliata si distribuisce 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 rappresenta il modo in cui i dati del volume elevato possono essere aggregati sul bordo per ridurre la frequenza e le dimensioni 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:

Sottoscrive l'argomento sensor/data per i dati del sensore.
Quando i dati ricevono sull'argomento, questi verranno pubblicati nell'archivio di stati 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 sono scaduti dall'archivio stati.
Il risultato viene pubblicato nell'argomento sensor/window_data in formato JSON.

Nota

Questa esercitazione disabilita Dapr CloudEvents che consente di pubblicare e sottoscrivere usando MQTT non elaborato.

Prerequisiti

Operazioni IoT di Azure installate - Guida introduttiva: Eseguire operazioni IoT di Azure in GitHub Codespaces con K3s
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 distribuisce il file binario associato incluso in un contenitore. 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`	SAT usato per autenticare i componenti collegabili Dapr con il broker MQTT e l'archivio stati
`volumes.aio-internal-ca-cert-chain`	Catena di attendibilità per convalidare il certificato TLS del broker MQTT
`containers.mq-event-driven`	Contenitore dell'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.

Distribuire il simulatore dal repository Esplora operazioni IoT:

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

Con l'output seguente:

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

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:
```
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

Sottoscrivere l'argomento sensor/window_data per osservare l'output pubblicato dall'applicazione Dapr:
```
mosquitto_sub -L mqtt://aio-broker/sensor/window_data
```

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

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

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
Registro Contenitori: per l'hosting del contenitore dell'applicazione

Compilare l'applicazione

Clonare il repository Esplora operazioni IoT:

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

Passare alla directory dell'esercitazione su Dapr:

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

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>
```
Aggiornare il app.yaml per eseguire il pull dell'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

Bridge di dati MQTT tra broker MQTT e Griglia di eventi di Azure

Condividi tramite

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