Testar a conectividade com o Agente MQTT com clientes MQTT

Este artigo mostra diferentes maneiras de testar a conectividade com o Agente MQTT com clientes MQTT em um ambiente de não produção.

Por padrão, Agente MQTT:

• Implanta um ouvinte habilitado para TLS na porta 18883 com ClusterIp como o Tipo de serviço. ClusterIp significa que o agente só pode ser acessado de dentro do cluster do Kubernetes. Para acessar o agente estando fora do cluster, você precisa configurar um serviço do tipo LoadBalancer ou NodePort.

• Aceita contas de serviço Kubernetes para autenticação para conexões de dentro do cluster. Para se conectar estando fora do cluster, você precisa configurar um método de autenticação diferente.

Antes de começar, instale ou configure as Operações de IoT. Use as opções a seguir para testar a conectividade com o Agente MQTT com clientes MQTT em um ambiente de não produção.

Conectar-se ao ouvinte padrão dentro do cluster

A primeira opção é se conectar de dentro do cluster. Essa opção usa a configuração padrão e não requer nenhuma atualização adicional. Os exemplos a seguir mostram como se conectar de dentro do cluster usando um Alpine Linux simples e um cliente do MQTT usado frequentemente, com a conta de serviço e o certificado de autoridade de certificação raiz padrão.

Primeiro, crie um arquivo chamado client.yaml com a seguinte configuração:

apiVersion: v1
kind: ServiceAccount
metadata:
  name: mqtt-client
  namespace: azure-iot-operations
---
apiVersion: v1
kind: Pod
metadata:
  name: mqtt-client
  # Namespace must match MQTT broker BrokerListener's namespace
  # Otherwise use the long hostname: aio-broker.azure-iot-operations.svc.cluster.local
  namespace: azure-iot-operations
spec:
  # Use the "mqtt-client" service account created from above
  # Otherwise create it with `kubectl create serviceaccount mqtt-client -n azure-iot-operations`
  serviceAccountName: mqtt-client
  containers:
    # Mosquitto and mqttui on Alpine
  - image: alpine
    name: mqtt-client
    command: ["sh", "-c"]
    args: ["apk add mosquitto-clients mqttui && sleep infinity"]
    volumeMounts:
    - name: broker-sat
      mountPath: /var/run/secrets/tokens
    - name: trust-bundle
      mountPath: /var/run/certs
  volumes:
  - name: broker-sat
    projected:
      sources:
      - serviceAccountToken:
          path: broker-sat
          audience: aio-internal # Must match audience in BrokerAuthentication
          expirationSeconds: 86400
  - name: trust-bundle
    configMap:
      name: azure-iot-operations-aio-ca-trust-bundle # Default root CA cert

Em seguida, use kubectl para implantar a configuração. O processo deve levar apenas alguns segundos para começar.

kubectl apply -f client.yaml

Assim que o pod estiver em execução, use kubectl exec para executar comandos dentro do pod.

Por exemplo, para publicar uma mensagem para o agente, abra um shell dentro do pod:

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

Dentro do shell do pod, execute o seguinte comando para publicar uma mensagem para o agente:

mosquitto_pub --host aio-broker --port 18883 --message "hello" --topic "world" --debug --cafile /var/run/certs/ca.crt -D CONNECT authentication-method 'K8S-SAT' -D CONNECT authentication-data $(cat /var/run/secrets/tokens/broker-sat)

O resultado deve ser semelhante ao seguinte:

Client (null) sending CONNECT
Client (null) received CONNACK (0)
Client (null) sending PUBLISH (d0, q0, r0, m1, 'world', ... (5 bytes))
Client (null) sending DISCONNECT

O cliente do Mosquitto usa o token de conta de serviço montado em /var/run/secrets/tokens/broker-sat para se autenticar junto ao agente. O token é válido por 24 horas. O cliente também usa o certificado de AC raiz padrão montado em /var/run/certs/ca.crt para verificar a cadeia de certificados TLS do agente.

kubectl get configmap azure-iot-operations-aio-ca-trust-bundle -n azure-iot-operations -o jsonpath='{.data.ca\.crt}' > ca.crt

Para fazer uma assinatura do tópico, execute o seguinte comando:

mosquitto_sub --host aio-broker --port 18883 --topic "world" --debug --cafile /var/run/certs/ca.crt -D CONNECT authentication-method 'K8S-SAT' -D CONNECT authentication-data $(cat /var/run/secrets/tokens/broker-sat)

O resultado deve ser semelhante ao seguinte:

Client (null) sending CONNECT
Client (null) received CONNACK (0)
Client (null) sending SUBSCRIBE (Mid: 1, Topic: world, QoS: 0, Options: 0x00)
Client (null) received SUBACK
Subscribed (mid: 1): 0

O cliente do Mosquitto usa o mesmo token de conta de serviço e certificado de AC raiz para se autenticar junto ao agente e fazer uma assinatura do tópico.

Para remover o pod, execute kubectl delete pod mqtt-client -n azure-iot-operations.

Conectar clientes de fora do cluster

Como o ouvinte do agente padrão está definido como o tipo de serviço ClusterIp, não é possível se conectar diretamente ao agente de fora do cluster. Para evitar interrupções não intencionais na comunicação entre os componentes internos de Operações do Azure IoT, recomendamos manter o ouvinte padrão não modificado e dedicado à comunicação interna de AIO. Embora seja possível criar um serviço separado do LoadBalancer no Kubernetes para expor o serviço IP do cluster, é melhor criar um ouvinte separado com configurações diferentes, como as portas MQTT 1883 e 8883 mais comuns, para evitar confusão e possíveis riscos de segurança.

Porta do nó

A maneira mais fácil de testar a conectividade é usar o tipo de serviço NodePort no ouvinte. Com isso, você pode usar <nodeExternalIP>:<NodePort> para se conectar como mostrado na documentação do Kubernetes.

Por exemplo, para criar um ouvinte de agente com o tipo de serviço de porta de nó, o nome de serviço aio-broker-nodeport e a escuta na porta 1884 (porta do nó 31884):

param aioInstanceName string = '<AIO_INSTANCE_NAME>'
param customLocationName string = '<CUSTOM_LOCATION_NAME>'
param listenerName string = 'aio-broker-nodeport'

resource aioInstance 'Microsoft.IoTOperations/instances@2024-11-01' existing = {
  name: aioInstanceName
}

resource customLocation 'Microsoft.ExtendedLocation/customLocations@2021-08-31-preview' existing = {
  name: customLocationName
}

resource defaultBroker 'Microsoft.IoTOperations/instances/brokers@2024-11-01' existing = {
  parent: aioInstance
  name: 'default'
}

resource nodePortListener 'Microsoft.IoTOperations/instances/brokers/listeners@2024-11-01' = {
  parent: defaultBroker
  name: listenerName
  extendedLocation: {
    name: customLocation.id
    type: 'CustomLocation'
  }
  properties: {
    serviceType: 'NodePort'
    ports: [
      {
        port: 1884
        nodePort: 31884 // Must be in the range 30000-32767
        authenticationRef: 'default' // Add BrokerAuthentication reference, omit setting turns off authentication for testing only
        tls: {
          // Add TLS settings
          // Omitting section turns off TLS for testing only
        }
      }
    ]
  }
}

az deployment group create --resource-group <RESOURCE_GROUP> --template-file <FILE>.bicep

apiVersion: mqttbroker.iotoperations.azure.com/v1
kind: BrokerListener
metadata:
  name: aio-broker-nodeport
  namespace: azure-iot-operations
spec:
  brokerRef: default
  serviceType: NodePort
  ports:
    - port: 1883
      nodePort: 31884 # Must be in the range 30000-32767
      authenticationRef: default # Add BrokerAuthentication reference, omit setting turns off authentication for testing only
      tls:
        # Add TLS settings
        # Omitting section turns off TLS for testing only

kubectl apply -f broker-nodeport.yaml

Obtenha o endereço IP externo do nó:

kubectl get nodes -o yaml | grep ExternalIP -C 1

O resultado deve ser semelhante ao seguinte:

    - address: 104.197.41.11
      type: ExternalIP
    allocatable:
--
    - address: 23.251.152.56
      type: ExternalIP
    allocatable:
...

Use o endereço IP externo e a porta do nó para se conectar ao agente. Por exemplo, para publicar uma mensagem para o agente:

mosquitto_pub --host <EXTERNAL_IP> --port 31884 --message "hello" --topic "world" --debug # Add authentication and TLS options matching listener settings

Se não há nenhum IP externo na saída, você pode estar usando uma configuração do Kubernetes que não expõe o endereço IP externo do nó por padrão, como muitas configurações do k3s, do k3d ou do minikube. Nesse caso, você pode acessar o agente com o IP interno junto com a porta do nó de computadores na mesma rede. Por exemplo, para obter o endereço IP interno do nó:

kubectl get nodes -o yaml | grep InternalIP -C 1

O resultado deve ser semelhante ao seguinte:

    - address: 172.19.0.2
      type: InternalIP
    allocatable:

Em seguida, use o endereço IP interno e a porta do nó para se conectar ao agente de um computador dentro do mesmo cluster. Se o Kubernetes estiver em execução em um computador local, como ocorre com os k3s de nó único, muitas vezes você poderá usar localhost em vez do endereço IP interno. Se o Kubernetes estiver em execução em um contêiner do Docker, como ocorre com o k3d, o endereço IP interno corresponderá ao endereço IP do contêiner e deverá ser acessível no computador host.

Balanceador de carga

Outra maneira de expor o agente à Internet é usar o tipo de serviço LoadBalancer. Esse método é mais complexo e pode exigir configurações adicionais, como configurar o encaminhamento de porta.

Por exemplo, para criar um ouvinte de agente com o tipo de serviço de balanceador de carga, o nome de serviço aio-broker-loadbalancer e a escuta na porta 1883:

param aioInstanceName string = '<AIO_INSTANCE_NAME>'
param customLocationName string = '<CUSTOM_LOCATION_NAME>'
param listenerName string = 'aio-broker-loadbalancer'

resource aioInstance 'Microsoft.IoTOperations/instances@2024-11-01' existing = {
  name: aioInstanceName
}

resource customLocation 'Microsoft.ExtendedLocation/customLocations@2021-08-31-preview' existing = {
  name: customLocationName
}

resource defaultBroker 'Microsoft.IoTOperations/instances/brokers@2024-11-01' existing = {
  parent: aioInstance
  name: 'default'
}

resource loadBalancerListener 'Microsoft.IoTOperations/instances/brokers/listeners@2024-11-01' = {
  parent: defaultBroker
  name: listenerName
  extendedLocation: {
    name: customLocation.id
    type: 'CustomLocation'
  }

  properties: {
    serviceType: 'LoadBalancer'
    ports: [
      {
        port: 1883
        authenticationRef: 'default' // Add BrokerAuthentication reference, omit setting turns off authentication for testing only
        tls: {
          // Add TLS settings
          // Omitting section turns off TLS for testing only
        }
      }
    ]
  }
}

az deployment group create --resource-group <RESOURCE_GROUP> --template-file <FILE>.bicep

apiVersion: mqttbroker.iotoperations.azure.com/v1
kind: BrokerListener
metadata:
  name: aio-broker-loadbalancer
  namespace: azure-iot-operations
spec:
  brokerRef: default
  serviceType: LoadBalancer
  ports:
    - port: 1883
      authenticationRef: default # Add BrokerAuthentication reference, omit setting turns off authentication for testing only
      tls:
        # Add TLS settings
        # Omitting section turns off TLS for testing only

kubectl apply -f broker-loadbalancer.yaml

Obtenha o endereço IP externo para o serviço do agente:

kubectl get service aio-broker-loadbalancer --namespace azure-iot-operations

Se a saída for semelhante à seguinte:

NAME                      TYPE           CLUSTER-IP      EXTERNAL-IP   PORT(S)          AGE
aio-broker-loadbalancer   LoadBalancer   10.x.x.x        x.x.x.x       1883:30382/TCP   83s

Isso indicará que um IP externo foi atribuído ao serviço do balanceador de carga e você poderá usar o endereço IP externo e a porta para se conectar ao agente. Por exemplo, para publicar uma mensagem para o agente:

mosquitto_pub --host <EXTERNAL_IP> --port 1883 --message "hello" --topic "world" --debug # Add authentication and TLS options matching listener settings

Se o IP externo não foi atribuído, talvez seja necessário usar o encaminhamento de porta ou um comutador virtual para acessar o agente.

Use encaminhamento de porta

Com o minikube, o kind e outros sistemas de emulação de clusters, um IP externo poderá não ser atribuído automaticamente. Por exemplo, pode aparecer como estando no estado Pendente.

1. Para acessar o agente, avance até porta de ouvinte do agente para o host.

   # Using aio-broker-loadbalancer service name and listener port 1883 as example
   kubectl port-forward --namespace azure-iot-operations service/aio-broker-loadbalancer <HOST_PORT>:1883
   

2. Deixe o comando de encaminhamento de porta em execução no terminal.

3. Conecte-se ao agente na porta do host com a mesma configuração de TLS e autenticação do exemplo sem encaminhamento de porta.

Para obter mais informações sobre o minikube, consulte Usar o Encaminhamento de Porta para Acessar os Aplicativos em um Cluster

Encaminhamento de porta no AKS Edge Essentials

Para o Azure Kubernetes Services Edge Essentials, você precisa executar algumas etapas adicionais. Com o AKS Edge Essentials, obter o endereço IP externo pode não ser suficiente para se conectar ao agente. Talvez seja necessário configurar o encaminhamento de porta e abrir a porta no firewall para permitir o tráfego para o serviço do agente.

1. Primeiro, obtenha o endereço IP externo do ouvinte do balanceador de carga do agente:

   kubectl get service broker-loadbalancer --namespace azure-iot-operations
   

   A saída deve ser semelhante a essa:

   NAME                    TYPE           CLUSTER-IP     EXTERNAL-IP   PORT(S)          AGE
   broker-loadbalancer     LoadBalancer   10.x.x.x       192.168.0.4   1883:30366/TCP   14h
   

2. Configure o encaminhamento de porta para o serviço broker-loadbalancer no endereço de IP externo 192.168.0.4 e na porta 1883:

   netsh interface portproxy add v4tov4 listenport=1883 connectport=1883 connectaddress=192.168.0.4
   

3. Abra a porta no firewall para permitir o tráfego para o serviço do agente:

   New-NetFirewallRule -DisplayName "AIO MQTT Broker" -Direction Inbound -Protocol TCP -LocalPort 1883 -Action Allow
   

4. Use o endereço de IP público do host para se conectar ao agente MQTT.

Para obter mais informações sobre o encaminhamento de porta, consulte Expor os serviços do Kubernetes nos dispositivos externos.

Acesso por meio do localhost

Algumas distribuições do Kubernetes podem expor o Agente MQTT a uma porta no sistema host (localhost) como parte da configuração do cluster. Use essa abordagem para facilitar para os clientes no mesmo host acessarem o Agente MQTT.

Por exemplo, para criar um cluster do K3d mapeando a porta MQTT padrão 1883 do Agente MQTT para localhost:1883:

k3d cluster create --port '1883:1883@loadbalancer'

Ou para atualizar um cluster existente:

k3d cluster edit <CLUSTER_NAME> --port-add '1883:1883@loadbalancer'

Em seguida, use localhost e a porta para se conectar ao agente. Por exemplo, para publicar uma mensagem para o agente:

mosquitto_pub --host localhost --port 1883 --message "hello" --topic "world" --debug # Add authentication and TLS options matching listener settings

Desativar apenas o TLS e a autenticação para teste

O motivo pelo qual o Agente MQTT usa a autenticação de contas de serviço e TLS por padrão é fornecer uma experiência segura por padrão que minimize a exposição inadvertida da sua solução de IoT aos invasores. Você não deve desativar o TLS e a autenticação na produção. Expor o Agente MQTT à Internet sem autenticação e TLS pode levar a acesso não autorizado e até ataques DDOS.

param aioInstanceName string = '<AIO_INSTANCE_NAME>'
param customLocationName string = '<CUSTOM_LOCATION_NAME>'
param listenerName string = '<LISTENER_NAME>'

resource aioInstance 'Microsoft.IoTOperations/instances@2024-11-01' existing = {
  name: aioInstanceName
}

resource customLocation 'Microsoft.ExtendedLocation/customLocations@2021-08-31-preview' existing = {
  name: customLocationName
}

resource defaultBroker 'Microsoft.IoTOperations/instances/brokers@2024-11-01' existing = {
  parent: aioInstance
  name: 'default'
}

resource nodePortListener 'Microsoft.IoTOperations/instances/brokers/listeners@2024-11-01' = {
  parent: defaultBroker
  name: listenerName
  extendedLocation: {
    name: customLocation.id
    type: 'CustomLocation'
  }

  properties: {
    serviceType: <SERVICE_TYPE> // 'LoadBalancer' or 'NodePort'
    ports: [
      {
        port: <PORT_NUMBER>
        nodePort: <PORT_NUMBER_BETWEEN_30000_32767> // If using NodePort
        // Omitting authenticationRef and tls for testing only
      }
    ]
  }
}

az deployment group create --resource-group <RESOURCE_GROUP> --template-file <FILE>.bicep

apiVersion: mqttbroker.iotoperations.azure.com/v1
kind: BrokerListener
metadata:
  name: <LISTENER_NAME>
  namespace: azure-iot-operations
spec:
  brokerRef: default
  serviceType: <SERVICE_TYPE> # LoadBalancer or NodePort
  ports:
    - port: <PORT_NUMBER>
      nodePort: <PORT_NUMBER_BETWEEN_30000_32767> # If using NodePort
      # Omitting authenticationRef and tls for testing only

Conteúdo relacionado

• Configurar o TLS com o gerenciamento manual de certificados para proteger a comunicação por MQTT
• Configurar a autenticação
• Tutorial: autenticação de cliente TLS, X.509 e ABAC (controle de acesso baseado em atributo)