{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Effect": "Allow",
      "Action": [
        "iot:Connect"
      ],
      "Resource": "arn:aws:iot:ap-northeast-2:YOUR_ACCOUNT_ID:client/MyRaspberryPi"
    },
    {
      "Effect": "Allow",
      "Action": [
        "iot:Publish",
        "iot:Receive"
      ],
      "Resource": "arn:aws:iot:ap-northeast-2:YOUR_ACCOUNT_ID:topic/*"
    },
    {
      "Effect": "Allow",
      "Action": [
        "iot:Subscribe"
      ],
      "Resource": "arn:aws:iot:ap-northeast-2:YOUR_ACCOUNT_ID:topicfilter/*"
    }
  ]
}

# 시스템 패키지 업데이트
sudo apt-get update
sudo apt-get upgrade -y

# Python3 및 pip 설치 확인
python3 --version
pip3 --version

# 필요한 경우 pip 업그레이드
sudo pip3 install --upgrade pip

# AWS IoT Python SDK 설치
pip3 install AWSIoTPythonSDK

# 추가로 유용한 라이브러리들
pip3 install boto3
pip3 install paho-mqtt

# 라즈베리파이에 certs 디렉토리 생성
mkdir -p ~/aws-iot/certs
cd ~/aws-iot/certs

# 로컬 PC에서 SCP로 파일 전송 (로컬 PC 터미널에서 실행)
scp /path/to/certificate.pem.crt pi@raspberrypi.local:~/aws-iot/certs/
scp /path/to/private.pem.key pi@raspberrypi.local:~/aws-iot/certs/
scp /path/to/AmazonRootCA1.pem pi@raspberrypi.local:~/aws-iot/certs/

# 파일 권한 설정 (라즈베리파이에서)
chmod 644 ~/aws-iot/certs/*.crt
chmod 600 ~/aws-iot/certs/*.key

#!/usr/bin/env python3
# -*- coding: utf-8 -*-

"""
AWS IoT Core 기본 연결 예제
라즈베리파이에서 AWS IoT Core에 연결하고 메시지를 발행합니다.
"""

from AWSIoTPythonSDK.MQTTLib import AWSIoTMQTTClient
import json
import time
import random

# AWS IoT Core 설정
IOT_ENDPOINT = "xxxxx.iot.ap-northeast-2.amazonaws.com"  # 여기에 실제 엔드포인트 입력
CLIENT_ID = "MyRaspberryPi"
TOPIC = "raspberry/data"

# 인증서 파일 경로
ROOT_CA = "/home/pi/aws-iot/certs/AmazonRootCA1.pem"
PRIVATE_KEY = "/home/pi/aws-iot/certs/private.pem.key"
CERTIFICATE = "/home/pi/aws-iot/certs/certificate.pem.crt"

def init_mqtt_client():
    """
    MQTT 클라이언트 초기화 및 설정
    """
    # MQTT 클라이언트 생성
    mqtt_client = AWSIoTMQTTClient(CLIENT_ID)
    mqtt_client.configureEndpoint(IOT_ENDPOINT, 8883)
    
    # 인증서 설정
    mqtt_client.configureCredentials(ROOT_CA, PRIVATE_KEY, CERTIFICATE)
    
    # MQTT 연결 설정
    mqtt_client.configureAutoReconnectBackoffTime(1, 32, 20)
    mqtt_client.configureOfflinePublishQueueing(-1)  # 무제한 큐잉
    mqtt_client.configureDrainingFrequency(2)  # 2Hz로 드레이닝
    mqtt_client.configureConnectDisconnectTimeout(10)  # 10초
    mqtt_client.configureMQTTOperationTimeout(5)  # 5초
    
    return mqtt_client

def publish_message(client, topic, message):
    """
    메시지 발행 함수
    """
    try:
        message_json = json.dumps(message)
        client.publish(topic, message_json, 1)
        print(f"✅ 메시지 발행 성공: {message_json}")
        return True
    except Exception as e:
        print(f"❌ 메시지 발행 실패: {str(e)}")
        return False

def main():
    """
    메인 실행 함수
    """
    print("🚀 AWS IoT Core 연결 시작...")
    
    # MQTT 클라이언트 초기화
    mqtt_client = init_mqtt_client()
    
    # AWS IoT Core에 연결
    try:
        mqtt_client.connect()
        print("✅ AWS IoT Core 연결 성공!")
    except Exception as e:
        print(f"❌ 연결 실패: {str(e)}")
        return
    
    # 메시지 발행 루프
    message_count = 0
    
    try:
        while True:
            message_count += 1
            
            # 센서 데이터 시뮬레이션 (실제로는 센서에서 읽어옴)
            temperature = round(random.uniform(20.0, 30.0), 2)
            humidity = round(random.uniform(40.0, 70.0), 2)
            
            # 메시지 생성
            message = {
                "device_id": CLIENT_ID,
                "timestamp": int(time.time()),
                "message_id": message_count,
                "data": {
                    "temperature": temperature,
                    "humidity": humidity
                }
            }
            
            # 메시지 발행
            publish_message(mqtt_client, TOPIC, message)
            
            # 5초 대기
            time.sleep(5)
            
    except KeyboardInterrupt:
        print("\n⏹️ 프로그램 종료 중...")
    
    finally:
        # 연결 해제
        mqtt_client.disconnect()
        print("👋 AWS IoT Core 연결 해제 완료")

if __name__ == "__main__":
    main()

# 파일 실행 권한 부여
chmod +x basic_connection.py

# 프로그램 실행
python3 basic_connection.py

#!/usr/bin/env python3
# -*- coding: utf-8 -*-

"""
AWS IoT Core 양방향 통신 예제
메시지를 발행하고 구독하여 원격 제어를 구현합니다.
"""

from AWSIoTPythonSDK.MQTTLib import AWSIoTMQTTClient
import json
import time
import random
import threading

# AWS IoT Core 설정
IOT_ENDPOINT = "xxxxx.iot.ap-northeast-2.amazonaws.com"
CLIENT_ID = "MyRaspberryPi"
PUBLISH_TOPIC = "raspberry/telemetry"
SUBSCRIBE_TOPIC = "raspberry/command"

# 인증서 파일 경로
ROOT_CA = "/home/pi/aws-iot/certs/AmazonRootCA1.pem"
PRIVATE_KEY = "/home/pi/aws-iot/certs/private.pem.key"
CERTIFICATE = "/home/pi/aws-iot/certs/certificate.pem.crt"

# 디바이스 상태
device_state = {
    "led_status": "OFF",
    "reporting_interval": 5,
    "active": True
}

def custom_callback(client, userdata, message):
    """
    메시지 수신 콜백 함수
    클라우드에서 명령을 받으면 실행됩니다.
    """
    try:
        payload = json.loads(message.payload.decode('utf-8'))
        print(f"\n📨 명령 수신: {json.dumps(payload, indent=2)}")
        
        # 명령 타입에 따라 처리
        command_type = payload.get("command")
        
        if command_type == "LED_CONTROL":
            # LED 제어 명령
            led_action = payload.get("action")
            if led_action in ["ON", "OFF"]:
                device_state["led_status"] = led_action
                print(f"💡 LED 상태 변경: {led_action}")
                
                # 실제로는 GPIO를 제어하는 코드가 들어감
                # import RPi.GPIO as GPIO
                # GPIO.output(LED_PIN, GPIO.HIGH if led_action == "ON" else GPIO.LOW)
                
        elif command_type == "SET_INTERVAL":
            # 보고 주기 변경 명령
            new_interval = payload.get("interval", 5)
            if 1 <= new_interval <= 60:
                device_state["reporting_interval"] = new_interval
                print(f"⏱️ 보고 주기 변경: {new_interval}초")
                
        elif command_type == "GET_STATUS":
            # 상태 조회 명령
            print("📊 현재 상태 전송 요청")
            publish_status(client)
            
        elif command_type == "REBOOT":
            # 재부팅 명령
            print("🔄 재부팅 명령 수신")
            device_state["active"] = False
            
        else:
            print(f"⚠️ 알 수 없는 명령: {command_type}")
            
    except Exception as e:
        print(f"❌ 콜백 처리 오류: {str(e)}")

def init_mqtt_client():
    """
    MQTT 클라이언트 초기화
    """
    mqtt_client = AWSIoTMQTTClient(CLIENT_ID)
    mqtt_client.configureEndpoint(IOT_ENDPOINT, 8883)
    mqtt_client.configureCredentials(ROOT_CA, PRIVATE_KEY, CERTIFICATE)
    
    # 연결 설정
    mqtt_client.configureAutoReconnectBackoffTime(1, 32, 20)
    mqtt_client.configureOfflinePublishQueueing(-1)
    mqtt_client.configureDrainingFrequency(2)
    mqtt_client.configureConnectDisconnectTimeout(10)
    mqtt_client.configureMQTTOperationTimeout(5)
    
    return mqtt_client

def publish_telemetry(client):
    """
    텔레메트리 데이터 발행
    """
    # 센서 데이터 시뮬레이션
    temperature = round(random.uniform(20.0, 30.0), 2)
    humidity = round(random.uniform(40.0, 70.0), 2)
    cpu_temp = round(random.uniform(40.0, 60.0), 2)
    
    message = {
        "device_id": CLIENT_ID,
        "timestamp": int(time.time()),
        "telemetry": {
            "temperature": temperature,
            "humidity": humidity,
            "cpu_temperature": cpu_temp
        },
        "state": {
            "led_status": device_state["led_status"],
            "reporting_interval": device_state["reporting_interval"]
        }
    }
    
    try:
        message_json = json.dumps(message)
        client.publish(PUBLISH_TOPIC, message_json, 1)
        print(f"📤 텔레메트리 전송: 온도={temperature}°C, 습도={humidity}%")
    except Exception as e:
        print(f"❌ 전송 실패: {str(e)}")

def publish_status(client):
    """
    디바이스 상태 발행
    """
    status_message = {
        "device_id": CLIENT_ID,
        "timestamp": int(time.time()),
        "type": "status_report",
        "status": device_state
    }
    
    try:
        client.publish(PUBLISH_TOPIC, json.dumps(status_message), 1)
        print("📊 상태 보고 전송 완료")
    except Exception as e:
        print(f"❌ 상태 전송 실패: {str(e)}")

def main():
    """
    메인 실행 함수
    """
    print("🚀 AWS IoT Core 양방향 통신 시작...")
    
    # MQTT 클라이언트 초기화
    mqtt_client = init_mqtt_client()
    
    # 연결
    try:
        mqtt_client.connect()
        print("✅ AWS IoT Core 연결 성공!")
    except Exception as e:
        print(f"❌ 연결 실패: {str(e)}")
        return
    
    # 명령 토픽 구독
    try:
        mqtt_client.subscribe(SUBSCRIBE_TOPIC, 1, custom_callback)
        print(f"✅ 토픽 구독 성공: {SUBSCRIBE_TOPIC}")
    except Exception as e:
        print(f"❌ 구독 실패: {str(e)}")
        return
    
    # 초기 상태 전송
    time.sleep(2)
    publish_status(mqtt_client)
    
    # 메인 루프
    try:
        while device_state["active"]:
            # 텔레메트리 데이터 전송
            publish_telemetry(mqtt_client)
            
            # 설정된 주기만큼 대기
            time.sleep(device_state["reporting_interval"])
            
    except KeyboardInterrupt:
        print("\n⏹️ 프로그램 종료 중...")
    
    finally:
        mqtt_client.disconnect()
        print("👋 AWS IoT Core 연결 해제 완료")

if __name__ == "__main__":
    main()

// LED 켜기
{
  "command": "LED_CONTROL",
  "action": "ON"
}

// 보고 주기 변경 (10초로)
{
  "command": "SET_INTERVAL",
  "interval": 10
}

// 상태 조회
{
  "command": "GET_STATUS"
}

#!/usr/bin/env python3
# -*- coding: utf-8 -*-

"""
실제 센서 연동 예제 (DHT22 온습도 센서)
"""

from AWSIoTPythonSDK.MQTTLib import AWSIoTMQTTClient
import json
import time
import sys

# DHT22 센서 라이브러리 (설치 필요: pip3 install Adafruit_DHT)
try:
    import Adafruit_DHT
    SENSOR_AVAILABLE = True
except ImportError:
    print("⚠️ Adafruit_DHT 라이브러리가 없습니다. 시뮬레이션 모드로 실행됩니다.")
    SENSOR_AVAILABLE = False
    import random

# AWS IoT Core 설정
IOT_ENDPOINT = "xxxxx.iot.ap-northeast-2.amazonaws.com"
CLIENT_ID = "RaspberryPi_Sensor"
TOPIC = "home/environment"

# 인증서 파일 경로
ROOT_CA = "/home/pi/aws-iot/certs/AmazonRootCA1.pem"
PRIVATE_KEY = "/home/pi/aws-iot/certs/private.pem.key"
CERTIFICATE = "/home/pi/aws-iot/certs/certificate.pem.crt"

# 센서 설정
DHT_SENSOR = Adafruit_DHT.DHT22 if SENSOR_AVAILABLE else None
DHT_PIN = 4  # GPIO 4번 핀

class SensorReader:
    """
    센서 데이터 읽기 클래스
    """
    def __init__(self):
        self.last_temperature = None
        self.last_humidity = None
        self.error_count = 0
        
    def read_sensor(self):
        """
        센서에서 데이터 읽기
        """
        if SENSOR_AVAILABLE:
            try:
                humidity, temperature = Adafruit_DHT.read_retry(DHT_SENSOR, DHT_PIN)
                
                if humidity is not None and temperature is not None:
                    self.last_temperature = round(temperature, 2)
                    self.last_humidity = round(humidity, 2)
                    self.error_count = 0
                    return True
                else:
                    self.error_count += 1
                    print(f"⚠️ 센서 읽기 실패 (시도 {self.error_count}회)")
                    return False
                    
            except Exception as e:
                self.error_count += 1
                print(f"❌ 센서 오류: {str(e)}")
                return False
        else:
            # 시뮬레이션 모드
            self.last_temperature = round(random.uniform(20.0, 30.0), 2)
            self.last_humidity = round(random.uniform(40.0, 70.0), 2)
            return True
    
    def get_data(self):
        """
        마지막으로 읽은 데이터 반환
        """
        return {
            "temperature": self.last_temperature,
            "humidity": self.last_humidity
        }
    
    def is_healthy(self):
        """
        센서 상태 확인
        """
        return self.error_count < 5

def calculate_heat_index(temperature, humidity):
    """
    체감온도(Heat Index) 계산
    """
    if temperature < 27:
        return temperature
    
    # 간단한 체감온도 공식
    hi = -8.78469475556 + \
         1.61139411 * temperature + \
         2.33854883889 * humidity + \
         -0.14611605 * temperature * humidity + \
         -0.012308094 * temperature**2 + \
         -0.0164248277778 * humidity**2 + \
         0.002211732 * temperature**2 * humidity + \
         0.00072546 * temperature * humidity**2 + \
         -0.000003582 * temperature**2 * humidity**2
    
    return round(hi, 2)

def init_mqtt_client():
    """
    MQTT 클라이언트 초기화
    """
    mqtt_client = AWSIoTMQTTClient(CLIENT_ID)
    mqtt_client.configureEndpoint(IOT_ENDPOINT, 8883)
    mqtt_client.configureCredentials(ROOT_CA, PRIVATE_KEY, CERTIFICATE)
    
    mqtt_client.configureAutoReconnectBackoffTime(1, 32, 20)
    mqtt_client.configureOfflinePublishQueueing(-1)
    mqtt_client.configureDrainingFrequency(2)
    mqtt_client.configureConnectDisconnectTimeout(10)
    mqtt_client.configureMQTTOperationTimeout(5)
    
    return mqtt_client

def publish_sensor_data(client, sensor_reader):
    """
    센서 데이터 발행
    """
    # 센서 읽기
    if not sensor_reader.read_sensor():
        print("⚠️ 센서 데이터를 읽을 수 없습니다.")
        return False
    
    # 데이터 가져오기
    data = sensor_reader.get_data()
    temperature = data["temperature"]
    humidity = data["humidity"]
    
    # 체감온도 계산
    heat_index = calculate_heat_index(temperature, humidity)
    
    # 쾌적도 판단
    comfort_level = "comfortable"
    if temperature > 28 or temperature < 18:
        comfort_level = "uncomfortable"
    elif humidity > 70 or humidity < 30:
        comfort_level = "uncomfortable"
    
    # 메시지 생성
    message = {
        "device_id": CLIENT_ID,
        "timestamp": int(time.time()),
        "location": "living_room",
        "sensor_data": {
            "temperature": temperature,
            "humidity": humidity,
            "heat_index": heat_index
        },
        "analysis": {
            "comfort_level": comfort_level,
            "sensor_health": "healthy" if sensor_reader.is_healthy() else "warning"
        },
        "metadata": {
            "sensor_type": "DHT22",
            "gpio_pin": DHT_PIN,
            "simulation_mode": not SENSOR_AVAILABLE
        }
    }
    
    try:
        message_json = json.dumps(message, indent=2)
        client.publish(TOPIC, message_json, 1)
        
        print(f"\n📊 센서 데이터 전송:")
        print(f"   🌡️  온도: {temperature}°C")
        print(f"   💧 습도: {humidity}%")
        print(f"   🔥 체감온도: {heat_index}°C")
        print(f"   😊 쾌적도: {comfort_level}")
        
        return True
        
    except Exception as e:
        print(f"❌ 데이터 전송 실패: {str(e)}")
        return False

def main():
    """
    메인 실행 함수
    """
    print("🌡️ 센서 모니터링 시스템 시작...")
    
    if not SENSOR_AVAILABLE:
        print("⚠️ 시뮬레이션 모드로 실행됩니다.")
    
    # 센서 리더 초기화
    sensor_reader = SensorReader()
    
    # MQTT 클라이언트 초기화
    mqtt_client = init_mqtt_client()
    
    # AWS IoT Core 연결
    try:
        mqtt_client.connect()
        print("✅ AWS IoT Core 연결 성공!")
    except Exception as e:
        print(f"❌ 연결 실패: {str(e)}")
        return
    
    # 메인 루프
    consecutive_failures = 0
    
    try:
        while True:
            # 센서 데이터 발행
            success = publish_sensor_data(mqtt_client, sensor_reader)
            
            if success:
                consecutive_failures = 0
            else:
                consecutive_failures += 1
                
            # 연속 실패 시 경고
            if consecutive_failures >= 3:
                print("⚠️ 연속 3회 실패! 센서 또는 연결을 확인하세요.")
                
            # 30초 대기
            time.sleep(30)
            
    except KeyboardInterrupt:
        print("\n⏹️ 프로그램 종료 중...")
    
    finally:
        mqtt_client.disconnect()
        print("👋 모니터링 시스템 종료")

if __name__ == "__main__":
    main()

-- SQL 쿼리
SELECT 
    device_id,
    timestamp,
    sensor_data.temperature as temperature,
    sensor_data.humidity as humidity
FROM 'home/environment'
WHERE sensor_data.temperature > 28

-- SQL 쿼리
SELECT 
    device_id,
    timestamp,
    sensor_data,
    analysis
FROM 'home/environment'

# Lambda 함수 예제 (Python 3.9)
import json
import boto3
from datetime import datetime

dynamodb = boto3.resource('dynamodb')
sns = boto3.client('sns')

def lambda_handler(event, context):
    """
    IoT 데이터 처리 Lambda 함수
    """
    print(f"수신된 이벤트: {json.dumps(event)}")
    
    # 데이터 추출
    device_id = event.get('device_id')
    sensor_data = event.get('sensor_data', {})
    temperature = sensor_data.get('temperature')
    humidity = sensor_data.get('humidity')
    
    # DynamoDB에 저장
    table = dynamodb.Table('IoTSensorData')
    
    try:
        table.put_item(
            Item={
                'device_id': device_id,
                'timestamp': int(event.get('timestamp')),
                'temperature': str(temperature),
                'humidity': str(humidity),
                'processed_at': datetime.now().isoformat()
            }
        )
        print("✅ DynamoDB 저장 성공")
    except Exception as e:
        print(f"❌ DynamoDB 저장 실패: {str(e)}")
    
    # 고온 알림
    if temperature and temperature > 30:
        try:
            sns.publish(
                TopicArn='arn:aws:sns:ap-northeast-2:123456789:HighTemperatureAlert',
                Subject='🔥 고온 경고!',
                Message=f'디바이스 {device_id}의 온도가 {temperature}°C입니다!'
            )
            print("✅ SNS 알림 전송 성공")
        except Exception as e:
            print(f"❌ SNS 전송 실패: {str(e)}")
    
    return {
        'statusCode': 200,
        'body': json.dumps('처리 완료')
    }

{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Effect": "Allow",
      "Action": "iot:Connect",
      "Resource": "arn:aws:iot:ap-northeast-2:ACCOUNT_ID:client/${iot:ClientId}"
    },
    {
      "Effect": "Allow",
      "Action": "iot:Publish",
      "Resource": [
        "arn:aws:iot:ap-northeast-2:ACCOUNT_ID:topic/home/environment",
        "arn:aws:iot:ap-northeast-2:ACCOUNT_ID:topic/home/status"
      ]
    },
    {
      "Effect": "Allow",
      "Action": "iot:Subscribe",
      "Resource": "arn:aws:iot:ap-northeast-2:ACCOUNT_ID:topicfilter/home/command/${iot:ClientId}"
    },
    {
      "Effect": "Allow",
      "Action": "iot:Receive",
      "Resource": "arn:aws:iot:ap-northeast-2:ACCOUNT_ID:topic/home/command/${iot:ClientId}"
    }
  ]
}

#!/usr/bin/env python3
# -*- coding: utf-8 -*-

"""
보안이 강화된 IoT 클라이언트
"""

import os
import sys
from pathlib import Path

class SecureConfig:
    """
    보안 설정 관리 클래스
    """
    def __init__(self):
        self.config_dir = Path.home() / '.aws-iot'
        self.certs_dir = self.config_dir / 'certs'
        
    def validate_certificates(self):
        """
        인증서 파일 검증
        """
        required_files = [
            'certificate.pem.crt',
            'private.pem.key',
            'AmazonRootCA1.pem'
        ]
        
        for filename in required_files:
            filepath = self.certs_dir / filename
            
            # 파일 존재 확인
            if not filepath.exists():
                raise FileNotFoundError(f"인증서 파일이 없습니다: {filename}")
            
            # 권한 확인 (Unix 계열만)
            if sys.platform != 'win32':
                stat_info = filepath.stat()
                mode = oct(stat_info.st_mode)[-3:]
                
                if filename.endswith('.key'):
                    # 프라이빗 키는 600 또는 400이어야 함
                    if mode not in ['600', '400']:
                        raise PermissionError(
                            f"프라이빗 키 권한이 안전하지 않습니다: {mode}\n"
                            f"다음 명령어를 실행하세요: chmod 600 {filepath}"
                        )
        
        print("✅ 인증서 검증 완료")
        return True
    
    def get_cert_paths(self):
        """
        인증서 경로 반환
        """
        return {
            'root_ca': str(self.certs_dir / 'AmazonRootCA1.pem'),
            'certificate': str(self.certs_dir / 'certificate.pem.crt'),
            'private_key': str(self.certs_dir / 'private.pem.key')
        }

# 사용 예제
if __name__ == "__main__":
    config = SecureConfig()
    
    try:
        config.validate_certificates()
        cert_paths = config.get_cert_paths()
        print("인증서 경로:", cert_paths)
    except Exception as e:
        print(f"❌ 보안 검증 실패: {str(e)}")
        sys.exit(1)

#!/usr/bin/env python3
# -*- coding: utf-8 -*-

"""
디버깅 기능이 강화된 IoT 클라이언트
"""

import logging
import sys
from AWSIoTPythonSDK.MQTTLib import AWSIoTMQTTClient

# 로깅 설정
logging.basicConfig(
    level=logging.DEBUG,
    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
    handlers=[
        logging.FileHandler('iot_client.log'),
        logging.StreamHandler(sys.stdout)
    ]
)

logger = logging.getLogger(__name__)

class DebugMQTTClient:
    """
    디버깅 기능이 추가된 MQTT 클라이언트
    """
    def __init__(self, client_id, endpoint):
        self.client_id = client_id
        self.endpoint = endpoint
        self.client = None
        self.connection_status = False
        self.publish_count = 0
        self.error_count = 0
        
    def init_client(self, root_ca, private_key, certificate):
        """
        클라이언트 초기화
        """
        logger.info(f"클라이언트 초기화 시작: {self.client_id}")
        
        try:
            self.client = AWSIoTMQTTClient(self.client_id)
            self.client.configureEndpoint(self.endpoint, 8883)
            self.client.configureCredentials(root_ca, private_key, certificate)
            
            # 디버그 로깅 활성화
            self.client.configureLogging(
                AWSIoTPythonSDK.core.util.loggers.LOG_LEVEL_DEBUG,
                'aws_iot_sdk.log'
            )
            
            logger.info("✅ 클라이언트 초기화 완료")
            return True
            
        except Exception as e:
            logger.error(f"❌ 클라이언트 초기화 실패: {str(e)}", exc_info=True)
            return False
    
    def connect(self):
        """
        연결 시도
        """
        logger.info(f"연결 시도: {self.endpoint}")
        
        try:
            self.client.connect()
            self.connection_status = True
            logger.info("✅ 연결 성공")
            return True
            
        except Exception as e:
            self.connection_status = False
            self.error_count += 1
            logger.error(f"❌ 연결 실패 (시도 {self.error_count}회): {str(e)}", exc_info=True)
            return False
    
    def publish(self, topic, payload, qos=1):
        """
        메시지 발행
        """
        if not self.connection_status:
            logger.warning("⚠️ 연결되지 않은 상태에서 발행 시도")
            return False
        
        try:
            logger.debug(f"메시지 발행 시도 - 토픽: {topic}, QoS: {qos}")
            logger.debug(f"페이로드: {payload[:100]}...")  # 처음 100자만 로깅
            
            self.client.publish(topic, payload, qos)
            self.publish_count += 1
            
            logger.info(f"✅ 메시지 발행 성공 (총 {self.publish_count}건)")
            return True
            
        except Exception as e:
            self.error_count += 1
            logger.error(f"❌ 메시지 발행 실패: {str(e)}", exc_info=True)
            return False
    
    def get_stats(self):
        """
        통계 정보 반환
        """
        return {
            'client_id': self.client_id,
            'connected': self.connection_status,
            'publish_count': self.publish_count,
            'error_count': self.error_count
        }

# 사용 예제
if __name__ == "__main__":
    client = DebugMQTTClient("TestDevice", "xxxxx.iot.ap-northeast-2.amazonaws.com")
    
    if client.init_client(
        "/path/to/root-ca.pem",
        "/path/to/private.key",
        "/path/to/certificate.crt"
    ):
        if client.connect():
            # 테스트 메시지 발행
            import json
            test_message = json.dumps({"test": "data"})
            client.publish("test/topic", test_message)
            
            # 통계 출력
            stats = client.get_stats()
            logger.info(f"통계: {stats}")

#!/usr/bin/env python3
# -*- coding: utf-8 -*-

"""
메시지 전송 최적화 예제
"""

import json
import time
from collections import deque

class OptimizedPublisher:
    """
    비용 최적화된 메시지 발행 클래스
    """
    def __init__(self, client, topic):
        self.client = client
        self.topic = topic
        self.last_values = {}
        self.message_count = 0
        self.bytes_sent = 0
        self.history = deque(maxlen=100)
        
    def should_publish(self, key, value, threshold=0.5):
        """
        값이 충분히 변경되었는지 확인 (델타 전송)
        """
        if key not in self.last_values:
            return True
        
        last_value = self.last_values[key]
        change_percent = abs(value - last_value) / last_value * 100
        
        return change_percent >= threshold
    
    def publish_optimized(self, data):
        """
        최적화된 메시지 발행
        """
        # 변경된 데이터만 필터링
        filtered_data = {}
        
        for key, value in data.items():
            if self.should_publish(key, value):
                filtered_data[key] = value
                self.last_values[key] = value
        
        # 변경사항이 없으면 발행하지 않음
        if not filtered_data:
            print("📊 변경사항 없음 - 메시지 발행 생략")
            return False
        
        # 메시지 생성 (최소화된 형식)
        message = {
            "t": int(time.time()),  # timestamp 축약
            "d": filtered_data       # data 축약
        }
        
        message_json = json.dumps(message, separators=(',', ':'))  # 공백 제거
        message_size = len(message_json.encode('utf-8'))
        
        # 통계 업데이트
        self.message_count += 1
        self.bytes_sent += message_size
        self.history.append({
            'timestamp': time.time(),
            'size': message_size,
            'keys': list(filtered_data.keys())
        })
        
        # 발행
        self.client.publish(self.topic, message_json, 1)
        
        print(f"📤 메시지 발행: {message_size} bytes")
        return True
    
    def get_statistics(self):
        """
        통계 정보 반환
        """
        avg_size = self.bytes_sent / self.message_count if self.message_count > 0 else 0
        
        return {
            'total_messages': self.message_count,
            'total_bytes': self.bytes_sent,
            'average_size': round(avg_size, 2),
            'estimated_monthly_messages': self.message_count * 30 * 24,  # 1시간 기준
            'within_free_tier': self.message_count * 30 * 24 < 500000
        }

# 사용 예제
if __name__ == "__main__":
    # 가상의 클라이언트 (실제로는 MQTT 클라이언트 사용)
    class DummyClient:
        def publish(self, topic, message, qos):
            pass
    
    client = DummyClient()
    publisher = OptimizedPublisher(client, "sensor/data")
    
    # 시뮬레이션
    for i in range(10):
        data = {
            "temperature": 25.0 + (i % 3) * 0.1,  # 작은 변화
            "humidity": 60.0 + (i % 5) * 2.0      # 큰 변화
        }
        
        publisher.publish_optimized(data)
        time.sleep(1)
    
    # 통계 출력
    stats = publisher.get_statistics()
    print(f"\n📊 통계:")
    print(f"   총 메시지: {stats['total_messages']}건")
    print(f"   총 데이터: {stats['total_bytes']} bytes")
    print(f"   평균 크기: {stats['average_size']} bytes")
    print(f"   월 예상: {stats['estimated_monthly_messages']}건")
    print(f"   프리티어: {'✅ 범위 내' if stats['within_free_tier'] else '❌ 초과'}")