Samouczek: tworzenie aplikacji opartej na zdarzeniach za pomocą brokera Dapr i MQTT

Artykuł
11/20/2024

W tym przewodniku wdrożysz aplikację dapr w klastrze. Aplikacja Dapr używa symulowanych danych MQTT opublikowanych w brokerze MQTT, stosuje funkcję okien, a następnie publikuje wynik z powrotem do brokera MQTT. Opublikowane dane wyjściowe przedstawiają, jak duże ilości danych można agregować na krawędzi, aby zmniejszyć częstotliwość i rozmiar komunikatów. Aplikacja Dapr jest bezstanowa i używa magazynu stanów brokera MQTT do buforowania poprzednich wartości wymaganych do obliczeń okna.

Aplikacja Dapr wykonuje następujące kroki:

Subskrybuje temat dotyczący sensor/data danych czujnika.
Gdy dane są odbierane w temacie, są publikowane w magazynie stanu brokera MQTT.
Co 10 sekund pobiera dane z magazynu stanów i oblicza wartości min, maksimum, średnie, mediany i 75. percentyla dla dowolnego znacznika czasu danych czujnika w ciągu ostatnich 30 sekund.
Dane starsze niż 30 sekund wygasły z magazynu stanów.
Wynik jest publikowany w temacie sensor/window_data w formacie JSON.

Uwaga

W tym samouczku jest wyłączana usługa Dapr CloudEvents , która umożliwia publikowanie i subskrybowanie przy użyciu nieprzetworzonego MQTT.

Wymagania wstępne

Zainstalowane operacje usługi Azure IoT — Szybki start: uruchamianie operacji usługi Azure IoT w usłudze GitHub Codespaces przy użyciu platformy K3s
Zainstalowane składniki języka Dapr brokera MQTT — instalowanie składników języka Dapr brokera MQTT

Wdrażanie aplikacji Dapr

W tym momencie można wdrożyć aplikację Dapr. Zarejestrowanie składników nie powoduje wdrożenia skojarzonego pliku binarnego spakowanego w kontenerze. Aby wdrożyć plik binarny wraz z aplikacją, możesz użyć wdrożenia, aby zgrupować konteneryzowaną aplikację Dapr i dwa składniki.

Aby rozpocząć, utwórz plik yaml, który używa następujących definicji:

Składnik	opis
`volumes.mqtt-client-token`	Sat używany do uwierzytelniania składników podłączanych przez język Dapr za pomocą brokera MQTT i magazynu stanów
`volumes.aio-internal-ca-cert-chain`	Łańcuch zaufania w celu zweryfikowania certyfikatu TLS brokera MQTT
`containers.mq-event-driven`	Wstępnie utworzony kontener aplikacji Dapr.

Zapisz następujący plik yaml wdrożenia w pliku o nazwie 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

Wdróż aplikację, uruchamiając następujące polecenie:
```
kubectl apply -f app.yaml
```
Upewnij się, że aplikacja została pomyślnie wdrożona. Zasobnik powinien zgłaszać, że wszystkie kontenery są gotowe po krótkim interwale, jak pokazano za pomocą następującego polecenia:
```
kubectl get pods -l app=mq-event-driven-dapr -n azure-iot-operations
```
Z następującymi danymi wyjściowymi:
```
NAME                         READY   STATUS              RESTARTS   AGE
mq-event-driven-dapr         3/3     Running             0          30s
```

Wdrażanie symulatora

Symulowanie danych testowych przez wdrożenie obciążenia Kubernetes. Symuluje czujnik, wysyłając okresowo odczyty temperatury, drgań i ciśnienia do brokera MQTT przy użyciu klienta MQTT w sensor/data temacie.

Wdróż symulator z repozytorium Eksploruj operacje IoT:

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

Upewnij się, że symulator działa poprawnie:

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

Z następującymi danymi wyjściowymi:

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

Wdrażanie klienta MQTT

Aby sprawdzić, czy mostek MQTT działa, wdróż klienta MQTT w klastrze.

W nowym pliku o nazwie client.yamlokreśl wdrożenie klienta:

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

Zastosuj plik wdrożenia za pomocą narzędzia kubectl:
```
kubectl apply -f client.yaml
```
Sprawdź dane wyjściowe:
```
pod/mqtt-client created
```

Weryfikowanie danych wyjściowych aplikacji Dapr

Otwórz powłokę w zasobniku klienta Mosquitto:

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

Zasubskrybuj temat, sensor/window_data aby obserwować opublikowane dane wyjściowe z aplikacji Dapr:
```
mosquitto_sub -L mqtt://aio-broker/sensor/window_data
```

Sprawdź, czy aplikacja generuje obliczenia okien przesuwnych dla różnych czujników co 10 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
    }
}

Opcjonalnie — tworzenie aplikacji Dapr

W tym samouczku jest używany wstępnie utworzony kontener aplikacji Dapr. Jeśli chcesz zmodyfikować i skompilować kod samodzielnie, wykonaj następujące kroki:

Wymagania wstępne

Docker — do kompilowania kontenera aplikacji
Rejestr kontenerów — do hostowania kontenera aplikacji

Kompilowanie aplikacji

Sklonuj repozytorium Eksplorowanie operacji IoT:

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

Przejdź do katalogu samouczka języka Dapr:

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

Skompiluj obraz platformy Docker:

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

Aby korzystać z aplikacji w klastrze Kubernetes, należy wypchnąć obraz do rejestru kontenerów, takiego jak usługa Azure Container Registry. Możesz również wypchnąć do lokalnego rejestru kontenerów, takiego jak minikube lub Docker.
```
docker tag mq-event-driven-dapr <container-alias>
docker push <container-alias>
```
Zaktualizuj plik app.yaml , aby ściągnąć nowo utworzony obraz.

Rozwiązywanie problemów

Jeśli aplikacja nie zostanie uruchomiona lub zobaczysz kontenery w CrashLoopBackoffpliku , daprd dziennik kontenera często zawiera przydatne informacje.

Uruchom następujące polecenie, aby wyświetlić dzienniki dla składnika daprd:

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

Następne kroki

Łączenie danych MQTT między brokerem MQTT i usługą Azure Event Grid

Udostępnij za pośrednictwem

Samouczek: tworzenie aplikacji opartej na zdarzeniach za pomocą brokera Dapr i MQTT

Wymagania wstępne

Wdrażanie aplikacji Dapr

Wdrażanie symulatora

Wdrażanie klienta MQTT

Weryfikowanie danych wyjściowych aplikacji Dapr

Opcjonalnie — tworzenie aplikacji Dapr

Wymagania wstępne

Kompilowanie aplikacji

Rozwiązywanie problemów

Następne kroki

Opinia

Dodatkowe zasoby