Tutorial: Criar um aplicativo controlado por eventos com o Dapr e o agente MQTT

Artigo
11/21/2024

Neste passo a passo, você implantará um aplicativo Dapr no cluster. O aplicativo Dapr consome dados MQTT simulados publicados no agente MQTT, aplica uma função de janela e, em seguida, publica o resultado novamente no agente MQTT. A saída publicada representa como os dados de alto volume podem ser agregados na borda para reduzir a frequência e o tamanho da mensagem. O aplicativo Dapr é sem estado e usa o repositório de estado do agente MQTT para armazenar em cache valores transmitidos necessários para os cálculos de janela.

O aplicativo Dapr executa as seguintes etapas:

Assinar o tópico sensor/data para dados do sensor.
Quando os dados são recebidos no tópico, eles são publicados na loja de estado do agente MQTT.
A cada 10 segundos, ele busca os dados do repositório de estado e calcula os valores mínimo, máximo, médio, mediano e 75º percentil em qualquer data/hora dos dados do sensor nos últimos 30 segundos.
Os dados com mais de 30 segundos expiram do repositório de estado.
O resultado é publicado no tópico sensor/window_data no formato JSON.

Observação

Este tutorial desabilita o Dapr CloudEvents, que permite que ele publique e assine eventos MQTT brutos.

Pré-requisitos

Operações do Azure IoT implantadas — Início Rápido: Executar Operações do Azure IoT em GitHub Codespaces com K3s
Componentes Dapr do agente MQTT instalados – Instalar componentes Dapr do agente MQTT

Implantar o aplicativo Dapr

Neste ponto, você pode implantar o aplicativo Dapr. Registrar os componentes não implanta o binário associado que é empacotado em um contêiner. Para implantar o binário junto com seu aplicativo, você pode usar uma Implantação para agrupar o aplicativo Dapr em contêineres e os dois componentes juntos.

Para começar, crie um arquivo yaml que use as seguintes definições:

Componente	Descrição
`volumes.mqtt-client-token`	O SAT usado para autenticar os componentes conectáveis da Dapr com o agente MQTT e o Armazenamento de Estado
`volumes.aio-internal-ca-cert-chain`	A cadeia de confiança para validar o certificado TLS do agente MQTT
`containers.mq-event-driven`	O contêiner de aplicativo Dapr predefinido.

Salve o yaml de implantação a seguir em um arquivo chamado 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

Implante o aplicativo executando o seguinte comando:
```
kubectl apply -f app.yaml
```

Confirme se o aplicativo foi implantado com êxito. O pod deve relatar que todos os contêineres estão prontos após um curto intervalo, conforme mostrado com o seguinte comando:

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

Com a seguinte saída:

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

Implantar o simulador

Simular dados de teste implantando uma carga de trabalho do Kubernetes. Ele simula um sensor enviando leituras de temperatura, vibração e pressão de amostra periodicamente para o agente MQTT usando um cliente MQTT no tópico sensor/data.

Implante o simulador no repositório Explorar Operações de IoT:

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

Confirme se o simulador está em execução corretamente:

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

Com a seguinte saída:

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

Implantar um cliente MQTT

Para verificar se a ponte MQTT está funcionando, implante um cliente MQTT no cluster.

Em um novo arquivo chamado client.yaml, especifique a implantação do cliente:

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

Aplique o arquivo de implantação com kubectl:
```
kubectl apply -f client.yaml
```
Verificar a saída:
```
pod/mqtt-client created
```

Verificar a saída do aplicativo Dapr

Abra um shell para o pod do cliente Mosquitto:

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

Assine o tópico sensor/window_data para observar a saída publicada do aplicativo Dapr:
```
mosquitto_sub -L mqtt://aio-broker/sensor/window_data
```

Verifique se o aplicativo está gerando um cálculo deslizante de janelas para os vários sensores a cada 10 segundos:

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

Opcional – Criar o aplicativo Dapr

Esse tutorial usa um contêiner pré-construído do aplicativo Dapr. Se você quiser modificar e criar o código por conta própria, siga estas etapas:

Pré-requisitos

Docker – para compilar o contêiner do aplicativo
Um registro de contêiner – para hospedar o contêiner do aplicativo

Compilar o aplicativo

Clone o repositório Explorar Operações IoT:

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

Mude para o diretório do tutorial do Dapr:

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

Crie a imagem do Docker:

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

Para consumir o aplicativo no cluster do Kubernetes, você precisa enviar a imagem por push para um registro de contêiner, como o Registro de Contêiner do Azure. Você também pode enviar por push para um registro de contêiner local, como minikube ou Docker.
```
docker tag mq-event-driven-dapr <container-alias>
docker push <container-alias>
```
atualize o app.yaml para efetuar pull da imagem recém-criada.

Solução de problemas

Se o aplicativo não iniciar ou se você vir os contêineres em CrashLoopBackoff, o log do contêiner daprd frequentemente conterá informações úteis.

Execute o seguinte comando para exibir os logs do componente daprd:

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

Próximas etapas

Fazer a ponte de dados MQTT entre o Agente MQTT e a Grade de Eventos do Azure

Compartilhar via

Tutorial: Criar um aplicativo controlado por eventos com o Dapr e o agente MQTT

Pré-requisitos

Implantar o aplicativo Dapr

Implantar o simulador

Implantar um cliente MQTT

Verificar a saída do aplicativo Dapr

Opcional – Criar o aplicativo Dapr

Pré-requisitos

Compilar o aplicativo

Solução de problemas

Próximas etapas

Comentários

Recursos adicionais