Partilhar via


Tutorial: Crie um aplicativo orientado a eventos com o Dapr e o corretor MQTT

Nesta explicação passo a passo, você implanta um aplicativo Dapr no cluster. O aplicativo Dapr consome dados MQTT simulados publicados no broker MQTT, aplica uma função de janela e, em seguida, publica o resultado de volta no broker 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 monitoração de estado e usa o armazenamento de estado do broker MQTT para armazenar em cache valores passados necessários para os cálculos de janela.

O aplicativo Dapr executa as seguintes etapas:

  1. Subscreve o tópico para dados do sensor/data sensor.
  2. Quando os dados são recebidos sobre o tópico, eles são publicados no repositório de estado do broker MQTT.
  3. A cada 10 segundos, ele busca os dados do armazenamento de estado e calcula os valores mínimo, máximo, médio, mediana e percentil 75 em qualquer data de data e hora do sensor marcada com a hora nos últimos 30 segundos.
  4. Os dados com mais de 30 segundos expiraram do armazenamento de estado.
  5. O resultado é publicado para o sensor/window_data tópico no formato JSON.

Nota

Este tutorial desativa o Dapr CloudEvents , que permite publicar e assinar usando MQTT bruto.

Pré-requisitos

Implantar o aplicativo Dapr

Neste ponto, você pode implantar o aplicativo Dapr. O registro dos 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êiner e os dois componentes juntos.

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

Componente Description
volumes.mqtt-client-token O SAT usado para autenticar os componentes conectáveis do Dapr com o broker MQTT e o State Store
volumes.aio-internal-ca-cert-chain A cadeia de confiança para validar o certificado TLS do broker MQTT
containers.mq-event-driven O contêiner de aplicativo Dapr pré-construído.
  1. Salve o seguinte yaml de implantação 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
    
  2. Implante o aplicativo executando o seguinte comando:

    kubectl apply -f app.yaml
    
  3. Confirme se o aplicativo foi implantado com êxito. O pod deve informar 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

Simule 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 broker MQTT usando um cliente MQTT sobre o sensor/data tópico.

  1. Implante o simulador a partir do repositório Explore IoT Operations :

    kubectl apply -f https://raw.githubusercontent.com/Azure-Samples/explore-iot-operations/main/tutorials/mq-event-driven-dapr/simulate-data.yaml    
    
  2. Confirme se o simulador está funcionando 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.

  1. 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
    
  2. Aplique o arquivo de implantação com kubectl:

    kubectl apply -f client.yaml
    

    Verifique a saída:

    pod/mqtt-client created
    

Verificar a saída do aplicativo Dapr

  1. Abra um shell para o pod do cliente Mosquitto:

    kubectl exec --stdin --tty mqtt-client -n azure-iot-operations -- sh
    
  2. Inscreva-se no sensor/window_data tópico para observar a saída publicada do aplicativo Dapr:

    mosquitto_sub -L mqtt://aio-broker/sensor/window_data
    
  3. Verifique se o aplicativo está emitindo um cálculo de janelas deslizantes 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

Este 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

  1. Docker - para criar o contêiner de aplicativos
  2. Um registro de contêiner - para hospedar o contêiner de aplicativo

Criar a aplicação

  1. Clone o repositório Explore IoT Operations :

    git clone https://github.com/Azure-Samples/explore-iot-operations
    
  2. Mude para o diretório tutorial do Dapr:

    cd explore-iot-operations/tutorials/mq-event-driven-dapr/src
    
  3. Crie a imagem do docker:

    docker build docker build . -t mq-event-driven-dapr
    
  4. Para consumir o aplicativo em seu cluster 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>
    
  5. Atualize o seu app.yaml para puxar sua imagem recém-criada.

Resolução de Problemas

Se o aplicativo não iniciar ou se você vir os contêineres no CrashLoopBackoff, o log de daprd contêineres geralmente contém 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óximos passos