Configure IOT Fake - Python MQQT - Test IoTCore
Tags: iot, mqqt, iotcore
Published: 2024-07-16 12:52:07

## Configure IOT Fake - Python MQQT - Test IoTCore

---
### 1. Configurar o IoT Core no AWS

#### Criar uma "Thing" no IoT Core:
1. No console do AWS IoT Core, vá para "Manage" e depois "Things".
2. Clique em "Create things" e crie uma "Thing".

#### Criar Certificados:
1. Após criar a "Thing", crie um certificado para ela.
2. Baixe os arquivos de certificado e chave privada.
3. Anexe uma política ao certificado que permita operações de publicação.

---

### 2. Criar o Script Python para Simular o Dispositivo

Instale a biblioteca `paho-mqtt`:
```bash
pip install paho-mqtt
```

Crie um script Python para simular o envio de dados de geolocalização:

```python
import paho.mqtt.client as mqtt
import ssl
import json
import time
import random

# Configurações AWS IoT
client_id = "geolocation_device"
endpoint = "<seu-endpoint-iot>.iot.<sua-regiao>.amazonaws.com"
root_ca = "/path/to/AmazonRootCA1.pem"
certificate = "/path/to/device-certificate.pem.crt"
private_key = "/path/to/private.pem.key"
topic = "geolocation/topic"

# Callback para quando a conexão for estabelecida
def on_connect(client, userdata, flags, rc):
    print("Conectado com o código: " + str(rc))
    client.subscribe(topic)

# Callback para quando uma mensagem for recebida
def on_message(client, userdata, msg):
    print("Mensagem recebida: " + msg.topic + " -> " + msg.payload.decode())

# Inicializa o cliente MQTT
client = mqtt.Client(client_id)
client.tls_set(root_ca, certfile=certificate, keyfile=private_key, tls_version=ssl.PROTOCOL_TLSv1_2)
client.on_connect = on_connect
client.on_message = on_message

# Conecta ao AWS IoT Core
client.connect(endpoint, 8883, 60)

# Função para simular dados de geolocalização
def simulate_geolocation_data():
    data = {
        'latitude': round(random.uniform(-90.0, 90.0), 6),
        'longitude': round(random.uniform(-180.0, 180.0), 6),
        'timestamp': int(time.time())
    }
    return data

# Publica dados de geolocalização em intervalos regulares
while True:
    geolocation_data = simulate_geolocation_data()
    client.publish(topic, json.dumps(geolocation_data))
    print(f"Publicado: {geolocation_data}")
    time.sleep(5)  # Espera 5 segundos antes de enviar novos dados

# Mantém a conexão e espera por mensagens
client.loop_forever()
```

---

### 3. Configurar uma Instância EC2

#### Criar e Configurar a Instância EC2:
1. **Lançar uma instância EC2**:
   - No console do EC2, escolha "Launch Instance".
   - Selecione uma AMI (Amazon Machine Image), como Amazon Linux 2.
   - Escolha o tipo de instância (t2.micro é suficiente para testes).
   - Configure as opções da instância e adicione armazenamento, se necessário.
   - Configure um security group para permitir acesso SSH (porta 22) e saída (outbound) para todos os destinos (por padrão, todas as saídas são permitidas).

2. **Conectar à Instância EC2**:
   - Conecte-se à sua instância EC2 usando SSH.
   ```bash
   ssh -i "seu-par-de-chaves.pem" ec2-user@seu-endereço-ec2
   ```

3. **Instalar Python e Bibliotecas Necessárias**:
   - Atualize os pacotes e instale o Python se não estiver instalado.
   ```bash
   sudo yum update -y
   sudo yum install -y python3
   sudo pip3 install paho-mqtt
   ```

4. **Transferir o Script para a Instância EC2**:
   - Transfira o script Python e os arquivos de certificado para a instância EC2 usando SCP (Secure Copy).
   ```bash
   scp -i "seu-par-de-chaves.pem" /caminho/para/o/script.py ec2-user@seu-endereço-ec2:/home/ec2-user/
   scp -i "seu-par-de-chaves.pem" /caminho/para/AmazonRootCA1.pem ec2-user@seu-endereço-ec2:/home/ec2-user/
   scp -i "seu-par-de-chaves.pem" /caminho/para/device-certificate.pem.crt ec2-user@seu-endereço-ec2:/home/ec2-user/
   scp -i "seu-par-de-chaves.pem" /caminho/para/private.pem.key ec2-user@seu-endereço-ec2:/home/ec2-user/
   ```

5. **Executar o Script na Instância EC2**:
   - Navegue até o diretório onde você transferiu os arquivos e execute o script Python.
   ```bash
   cd /home/ec2-user/
   python3 script.py
   ```

---

### Verificação

- **No console do AWS IoT Core:** Verifique se os dados estão sendo publicados no tópico correto.
- **Logs no EC2:** Verifique a saída no terminal para confirmar que os dados estão sendo enviados corretamente.

Seguindo esses passos, você conseguirá simular um dispositivo IoT que envia dados de geolocalização para o AWS IoT Core a partir de uma instância EC2. Isso permite que você teste e valide o fluxo de dados em um ambiente realista.