Laboratório: Orquestração de Aplicação IoT Urbana com Kubernetes e MQTT

Duração estimada

120 min

Passos

12

Validações

5

Versões da documentação consultada

Kubernetes a versão estável atual · kubectl a versão estável atual · Eclipse Mosquitto a versão estável atual · mosquitto-clients a versão estável atual · Docker a versão estável atual

Topologia

Três máquinas virtuais ou hosts: uma como master do Kubernetes, duas como workers. O cluster executa um broker MQTT (Eclipse Mosquitto) e múltiplos pods simulando sensores IoT, todos na mesma rede privada (exemplo: 192.168.56.0/24). Os sensores enviam dados ao broker, que pode ser acessado externamente.

    [sensor1 pod]   [sensor2 pod]   [sensorN pod]
         |              |               |
         +--------------+---------------+
                        |
              [Mosquitto broker pod]
                        |
               [Kubernetes Cluster]
          /                               \
 [worker1 VM]                        [worker2 VM]
                        |
                  [master VM]

Equipamentos e software

Roteiro

1. Preparar as máquinas virtuais

   Instale Ubuntu 22.04 ou similar nas três VMs. Configure rede NAT ou bridge para comunicação entre elas.

   O que você deve ver: As três VMs se comunicam entre si via ping.

2. Instalar Docker em todas as VMs

   Kubernetes depende do container runtime. Docker é o mais usado em laboratórios.

   sudo apt update && sudo apt install -y docker.io
   sudo systemctl enable docker && sudo systemctl start dockerCopiar

   O que você deve ver: docker --version retorna a versão instalada.

3. Instalar Kubernetes (kubeadm, kubelet, kubectl)

   Kubeadm simplifica a criação do cluster. Instale em todas as VMs.

   sudo apt update && sudo apt install -y apt-transport-https ca-certificates curl
   sudo curl -fsSLo /usr/share/keyrings/kubernetes-archive-keyring.gpg https://packages.cloud.google.com/apt/doc/apt-key.gpg
   echo "deb [signed-by=/usr/share/keyrings/kubernetes-archive-keyring.gpg] https://apt.kubernetes.io/ kubernetes-xenial main" | sudo tee /etc/apt/sources.list.d/kubernetes.list
   sudo apt update && sudo apt install -y kubelet kubeadm kubectl
   sudo apt-mark hold kubelet kubeadm kubectlCopiar

   O que você deve ver: kubeadm version retorna a versão instalada.

4. Inicializar o cluster Kubernetes no master

   O master gerencia o cluster. Inicialize o cluster e anote o token de join.

   sudo kubeadm init --pod-network-cidr=10.244.0.0/16Copiar

   O que você deve ver: Mensagem com kubeadm join e token.

5. Configurar kubectl no master

   kubectl precisa de acesso ao kubeconfig para operar o cluster.

   mkdir -p $HOME/.kube
   sudo cp -i /etc/kubernetes/admin.conf $HOME/.kube/config
   sudo chown $(id -u):$(id -g) $HOME/.kube/configCopiar

   O que você deve ver: kubectl get nodes mostra apenas o master (NotReady).

6. Instalar rede de pods (CNI Flannel)

   Kubernetes exige um plugin de rede para comunicação entre pods.

   kubectl apply -f https://raw.githubusercontent.com/coreos/flannel/master/Documentation/kube-flannel.ymlCopiar

   O que você deve ver: kubectl get pods -n kube-system mostra pods flannel Running.

7. Ingressar os workers no cluster

   Execute o comando kubeadm join nas VMs worker, usando o token gerado.

   sudo kubeadm join <master-ip>:6443 --token <token> --discovery-token-ca-cert-hash sha256:<hash>Copiar

   O que você deve ver: kubectl get nodes mostra master e dois workers Ready.

8. Implantar o broker MQTT (Mosquitto) via Deployment

   Mosquitto será o ponto central de mensagens IoT. Use um Deployment para garantir resiliência.

   kubectl create deployment mosquitto --image= eclipse-mosquitto:2.0
   kubectl expose deployment mosquitto --port=1883 --type=NodePortCopiar

   O que você deve ver: kubectl get pods mostra o pod mosquitto Running.

9. Criar simuladores de sensores IoT

   Simule sensores como pods que publicam mensagens MQTT periodicamente.

   kubectl run sensor-sim-1 --image= eclipse-mosquitto:2.0 --restart=Never -- /bin/sh -c 'while true; do mosquitto_pub -h mosquitto -t cidade/temperatura -m "temp:$(date +%s)"; sleep 5; done'
   kubectl run sensor-sim-2 --image= eclipse-mosquitto:2.0 --restart=Never -- /bin/sh -c 'while true; do mosquitto_pub -h mosquitto -t cidade/umidade -m "umid:$(date +%s)"; sleep 5; done'Copiar

   O que você deve ver: kubectl get pods mostra os pods sensor-sim-1 e sensor-sim-2 Running.

10. Expor o broker MQTT para acesso externo

    O tipo NodePort permite acessar o Mosquitto de fora do cluster.

    kubectl get service mosquittoCopiar

    O que você deve ver: Porta NodePort (ex: 30000-32767) listada para o serviço mosquitto.

11. Testar recebimento de dados MQTT externamente

    Use o mosquitto_sub em qualquer VM para verificar se as mensagens chegam ao broker.

    mosquitto_sub -h <worker-ip> -p <nodeport> -t cidade/#Copiar

    O que você deve ver: Mensagens de temperatura e umidade aparecem a cada 5 segundos.

12. Escalar simuladores de sensores

    Mostre a facilidade de escalar pods no Kubernetes.

    kubectl scale --replicas=5 deployment/sensor-sim-1Copiar

    O que você deve ver: kubectl get pods mostra 5 pods sensor-sim-1.

Como saber que funcionou

Troubleshooting

Segurança e hardening

• Nunca exponha o NodePort do Mosquitto em ambientes reais sem autenticação e TLS
• Restrinja acesso à API do Kubernetes apenas a administradores
• Remova pods de teste e simuladores após o laboratório
• Use namespaces separados para aplicações reais

Checklist final

• Cluster Kubernetes com 1 master e 2 workers criado
• Mosquitto rodando como Deployment e exposto via NodePort
• Simuladores de sensores publicando dados MQTT
• Mensagens recebidas externamente via mosquitto_sub
• Escalabilidade dos pods de sensores testada