# Mosquitto 브로커 설치
sudo apt-get update
sudo apt-get install mosquitto mosquitto-clients

# 서비스 시작
sudo systemctl start mosquitto

# 부팅 시 자동 시작 설정
sudo systemctl enable mosquitto

# 상태 확인
sudo systemctl status mosquitto

# Mosquitto 브로커 실행
mosquitto -v

# 설정 파일과 함께 실행
mosquitto -c mosquitto.conf -v

# Homebrew를 사용한 설치
brew install mosquitto

# 서비스 시작
brew services start mosquitto

# 또는 직접 실행
/usr/local/sbin/mosquitto -c /usr/local/etc/mosquitto/mosquitto.conf

# mosquitto.conf 기본 설정 예제

# 리스너 포트 설정 (기본값: 1883)
listener 1883
listener 9001
protocol websockets

# 익명 접속 허용 여부 (개발 환경에서만 true 권장)
allow_anonymous false

# 패스워드 파일 경로
password_file /etc/mosquitto/passwd

# 로그 설정
log_dest file /var/log/mosquitto/mosquitto.log
log_type all

# 최대 연결 수
max_connections 1000

# 메시지 큐 크기
max_queued_messages 1000

# 지속 연결 설정
persistence true
persistence_location /var/lib/mosquitto/

# 자동 저장 간격 (초)
autosave_interval 1800

# 패스워드 파일 생성 및 사용자 추가
sudo mosquitto_passwd -c /etc/mosquitto/passwd username1

# 추가 사용자 등록 (-c 옵션 제외)
sudo mosquitto_passwd /etc/mosquitto/passwd username2

# 사용자 삭제
sudo mosquitto_passwd -D /etc/mosquitto/passwd username1

# 브로커 재시작
sudo systemctl restart mosquitto

# pip를 사용한 설치
pip install paho-mqtt

# 또는 특정 버전 설치
pip install paho-mqtt==1.6.1

import paho.mqtt.client as mqtt
import time
import json
import random

# MQTT 브로커 설정
BROKER_ADDRESS = "localhost"  # 또는 브로커 IP 주소
BROKER_PORT = 1883
TOPIC = "sensors/temperature"
CLIENT_ID = "temperature_sensor_01"

# 사용자 인증 정보 (필요한 경우)
USERNAME = "your_username"
PASSWORD = "your_password"

# 콜백 함수: 연결 성공 시
def on_connect(client, userdata, flags, rc):
    if rc == 0:
        print("✅ 브로커에 성공적으로 연결되었습니다!")
    else:
        print(f"❌ 연결 실패. 반환 코드: {rc}")

# 콜백 함수: 메시지 발행 완료 시
def on_publish(client, userdata, mid):
    print(f"📤 메시지 발행 완료 (Message ID: {mid})")

# 클라이언트 생성
client = mqtt.Client(CLIENT_ID)

# 콜백 함수 등록
client.on_connect = on_connect
client.on_publish = on_publish

# 사용자 인증 설정 (필요한 경우)
client.username_pw_set(USERNAME, PASSWORD)

# 브로커 연결
try:
    client.connect(BROKER_ADDRESS, BROKER_PORT, keepalive=60)
    client.loop_start()  # 백그라운드 스레드 시작
    
    # 온도 데이터 주기적 발행
    for i in range(10):
        # 센서 데이터 생성 (시뮬레이션)
        temperature = round(20 + random.uniform(-5, 5), 2)
        humidity = round(50 + random.uniform(-10, 10), 2)
        
        # JSON 형식으로 데이터 구성
        payload = {
            "sensor_id": CLIENT_ID,
            "timestamp": time.time(),
            "temperature": temperature,
            "humidity": humidity,
            "unit": "celsius"
        }
        
        # 메시지 발행 (QoS 1)
        result = client.publish(
            TOPIC,
            json.dumps(payload),
            qos=1,
            retain=False
        )
        
        # 발행 결과 확인
        if result.rc == mqtt.MQTT_ERR_SUCCESS:
            print(f"🌡️  온도: {temperature}°C, 습도: {humidity}% 발행")
        else:
            print(f"⚠️  발행 실패: {result.rc}")
        
        time.sleep(2)  # 2초 대기
    
    # 정리
    client.loop_stop()
    client.disconnect()
    print("🔌 연결 종료")
    
except Exception as e:
    print(f"❌ 오류 발생: {e}")

import paho.mqtt.client as mqtt
import json
from datetime import datetime

# MQTT 브로커 설정
BROKER_ADDRESS = "localhost"
BROKER_PORT = 1883
TOPIC = "sensors/#"  # 와일드카드로 모든 센서 구독
CLIENT_ID = "data_receiver_01"

USERNAME = "your_username"
PASSWORD = "your_password"

# 콜백 함수: 연결 성공 시
def on_connect(client, userdata, flags, rc):
    if rc == 0:
        print("✅ 브로커에 연결되었습니다!")
        # 토픽 구독
        client.subscribe(TOPIC, qos=1)
        print(f"📡 토픽 구독 시작: {TOPIC}")
    else:
        print(f"❌ 연결 실패. 코드: {rc}")

# 콜백 함수: 메시지 수신 시
def on_message(client, userdata, message):
    try:
        # 메시지 디코딩
        payload = message.payload.decode('utf-8')
        topic = message.topic
        
        print(f"\n{'='*50}")
        print(f"📬 새 메시지 수신!")
        print(f"📍 토픽: {topic}")
        print(f"🔢 QoS: {message.qos}")
        
        # JSON 파싱
        data = json.loads(payload)
        
        # 타임스탬프 변환
        timestamp = datetime.fromtimestamp(data['timestamp'])
        
        # 데이터 출력
        print(f"🆔 센서 ID: {data['sensor_id']}")
        print(f"⏰ 시간: {timestamp.strftime('%Y-%m-%d %H:%M:%S')}")
        print(f"🌡️  온도: {data['temperature']}°C")
        print(f"💧 습도: {data['humidity']}%")
        print(f"{'='*50}\n")
        
        # 여기서 데이터베이스 저장, 알림 전송 등 추가 처리 가능
        process_sensor_data(data)
        
    except json.JSONDecodeError:
        print(f"⚠️  JSON 파싱 실패: {payload}")
    except Exception as e:
        print(f"❌ 메시지 처리 오류: {e}")

# 콜백 함수: 구독 완료 시
def on_subscribe(client, userdata, mid, granted_qos):
    print(f"✅ 구독 완료! (QoS: {granted_qos[0]})")

# 센서 데이터 처리 함수
def process_sensor_data(data):
    """
    수신한 센서 데이터를 처리하는 함수
    실제 애플리케이션에서는 여기서 DB 저장, 알림 등을 수행
    """
    # 온도 임계값 체크
    if data['temperature'] > 30:
        print("🔥 경고: 온도가 너무 높습니다!")
    elif data['temperature'] < 10:
        print("❄️  경고: 온도가 너무 낮습니다!")
    
    # 습도 임계값 체크
    if data['humidity'] > 70:
        print("💦 경고: 습도가 너무 높습니다!")
    elif data['humidity'] < 30:
        print("🏜️  경고: 습도가 너무 낮습니다!")

# 클라이언트 생성
client = mqtt.Client(CLIENT_ID)

# 콜백 함수 등록
client.on_connect = on_connect
client.on_message = on_message
client.on_subscribe = on_subscribe

# 사용자 인증
client.username_pw_set(USERNAME, PASSWORD)

# 브로커 연결 및 루프 시작
try:
    client.connect(BROKER_ADDRESS, BROKER_PORT, keepalive=60)
    print("🔄 메시지 수신 대기 중... (Ctrl+C로 종료)")
    client.loop_forever()  # 무한 루프로 메시지 수신
    
except KeyboardInterrupt:
    print("\n⏹️  사용자에 의해 종료되었습니다.")
    client.disconnect()
except Exception as e:
    print(f"❌ 오류 발생: {e}")

<dependency>
    <groupId>org.eclipse.paho</groupId>
    <artifactId>org.eclipse.paho.client.mqttv3</artifactId>
    <version>1.2.5</version>
</dependency>

import org.eclipse.paho.client.mqttv3.*;
import org.json.JSONObject;
import java.util.Random;

public class MqttPublisher {
    
    private static final String BROKER = "tcp://localhost:1883";
    private static final String CLIENT_ID = "JavaPublisher";
    private static final String TOPIC = "sensors/temperature";
    private static final String USERNAME = "your_username";
    private static final String PASSWORD = "your_password";
    
    public static void main(String[] args) {
        try {
            // MQTT 클라이언트 생성
            MqttClient client = new MqttClient(BROKER, CLIENT_ID);
            
            // 연결 옵션 설정
            MqttConnectOptions options = new MqttConnectOptions();
            options.setUserName(USERNAME);
            options.setPassword(PASSWORD.toCharArray());
            options.setCleanSession(true);
            options.setKeepAliveInterval(60);
            options.setAutomaticReconnect(true);
            
            // 콜백 설정
            client.setCallback(new MqttCallback() {
                @Override
                public void connectionLost(Throwable cause) {
                    System.out.println("❌ 연결 끊김: " + cause.getMessage());
                }
                
                @Override
                public void messageArrived(String topic, MqttMessage message) {
                    // Publisher는 메시지를 받지 않음
                }
                
                @Override
                public void deliveryComplete(IMqttDeliveryToken token) {
                    System.out.println("✅ 메시지 전달 완료");
                }
            });
            
            // 브로커 연결
            System.out.println("🔌 브로커 연결 중...");
            client.connect(options);
            System.out.println("✅ 연결 성공!");
            
            Random random = new Random();
            
            // 10번 메시지 발행
            for (int i = 0; i < 10; i++) {
                // 센서 데이터 생성
                double temperature = 20 + (random.nextDouble() * 10 - 5);
                double humidity = 50 + (random.nextDouble() * 20 - 10);
                
                // JSON 객체 생성
                JSONObject payload = new JSONObject();
                payload.put("sensor_id", CLIENT_ID);
                payload.put("timestamp", System.currentTimeMillis() / 1000.0);
                payload.put("temperature", Math.round(temperature * 100.0) / 100.0);
                payload.put("humidity", Math.round(humidity * 100.0) / 100.0);
                payload.put("unit", "celsius");
                
                // MQTT 메시지 생성
                MqttMessage message = new MqttMessage(payload.toString().getBytes());
                message.setQos(1);
                message.setRetained(false);
                
                // 메시지 발행
                client.publish(TOPIC, message);
                System.out.println("📤 발행: " + payload.toString());
                
                Thread.sleep(2000);  // 2초 대기
            }
            
            // 연결 종료
            client.disconnect();
            System.out.println("🔌 연결 종료");
            
        } catch (MqttException e) {
            System.err.println("❌ MQTT 오류: " + e.getMessage());
            e.printStackTrace();
        } catch (InterruptedException e) {
            System.err.println("❌ 인터럽트 오류: " + e.getMessage());
        }
    }
}

import org.eclipse.paho.client.mqttv3.*;
import org.json.JSONObject;
import java.text.SimpleDateFormat;
import java.util.Date;

public class MqttSubscriber {
    
    private static final String BROKER = "tcp://localhost:1883";
    private static final String CLIENT_ID = "JavaSubscriber";
    private static final String TOPIC = "sensors/#";
    private static final String USERNAME = "your_username";
    private static final String PASSWORD = "your_password";
    
    public static void main(String[] args) {
        try {
            // MQTT 클라이언트 생성
            MqttClient client = new MqttClient(BROKER, CLIENT_ID);
            
            // 연결 옵션 설정
            MqttConnectOptions options = new MqttConnectOptions();
            options.setUserName(USERNAME);
            options.setPassword(PASSWORD.toCharArray());
            options.setCleanSession(true);
            options.setKeepAliveInterval(60);
            options.setAutomaticReconnect(true);
            
            // 콜백 설정
            client.setCallback(new MqttCallback() {
                @Override
                public void connectionLost(Throwable cause) {
                    System.out.println("❌ 연결 끊김: " + cause.getMessage());
                    System.out.println("🔄 자동 재연결 시도 중...");
                }
                
                @Override
                public void messageArrived(String topic, MqttMessage message) {
                    try {
                        String payload = new String(message.getPayload());
                        
                        System.out.println("\n" + "=".repeat(50));
                        System.out.println("📬 새 메시지 수신!");
                        System.out.println("📍 토픽: " + topic);
                        System.out.println("🔢 QoS: " + message.getQos());
                        
                        // JSON 파싱
                        JSONObject data = new JSONObject(payload);
                        
                        // 타임스탬프 변환
                        long timestamp = (long)(data.getDouble("timestamp") * 1000);
                        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
                        String dateTime = sdf.format(new Date(timestamp));
                        
                        // 데이터 출력
                        System.out.println("🆔 센서 ID: " + data.getString("sensor_id"));
                        System.out.println("⏰ 시간: " + dateTime);
                        System.out.println("🌡️  온도: " + data.getDouble("temperature") + "°C");
                        System.out.println("💧 습도: " + data.getDouble("humidity") + "%");
                        System.out.println("=".repeat(50) + "\n");
                        
                        // 데이터 처리
                        processSensorData(data);
                        
                    } catch (Exception e) {
                        System.err.println("⚠️  메시지 처리 오류: " + e.getMessage());
                    }
                }
                
                @Override
                public void deliveryComplete(IMqttDeliveryToken token) {
                    // Subscriber는 메시지를 보내지 않음
                }
            });
            
            // 브로커 연결
            System.out.println("🔌 브로커 연결 중...");
            client.connect(options);
            System.out.println("✅ 연결 성공!");
            
            // 토픽 구독
            client.subscribe(TOPIC, 1);
            System.out.println("📡 토픽 구독: " + TOPIC);
            System.out.println("🔄 메시지 수신 대기 중...\n");
            
            // 프로그램 계속 실행
            while (true) {
                Thread.sleep(1000);
            }
            
        } catch (MqttException e) {
            System.err.println("❌ MQTT 오류: " + e.getMessage());
            e.printStackTrace();
        } catch (InterruptedException e) {
            System.err.println("❌ 인터럽트 오류: " + e.getMessage());
        }
    }
    
    private static void processSensorData(JSONObject data) {
        double temperature = data.getDouble("temperature");
        double humidity = data.getDouble("humidity");
        
        // 온도 임계값 체크
        if (temperature > 30) {
            System.out.println("🔥 경고: 온도가 너무 높습니다!");
        } else if (temperature < 10) {
            System.out.println("❄️  경고: 온도가 너무 낮습니다!");
        }
        
        // 습도 임계값 체크
        if (humidity > 70) {
            System.out.println("💦 경고: 습도가 너무 높습니다!");
        } else if (humidity < 30) {
            System.out.println("🏜️  경고: 습도가 너무 낮습니다!");
        }
    }
}

# npm을 사용한 설치
npm install mqtt

# 또는 yarn 사용
yarn add mqtt

const mqtt = require('mqtt');

// MQTT 브로커 설정
const BROKER_URL = 'mqtt://localhost:1883';
const CLIENT_ID = 'NodePublisher_' + Math.random().toString(16).substr(2, 8);
const TOPIC = 'sensors/temperature';

// 연결 옵션
const options = {
    clientId: CLIENT_ID,
    username: 'your_username',
    password: 'your_password',
    clean: true,
    keepalive: 60,
    reconnectPeriod: 1000
};

// 브로커 연결
console.log('🔌 브로커 연결 중...');
const client = mqtt.connect(BROKER_URL, options);

// 이벤트 핸들러: 연결 성공
client.on('connect', () => {
    console.log('✅ 브로커 연결 성공!');
    console.log(`🆔 클라이언트 ID: ${CLIENT_ID}`);
    
    let count = 0;
    const maxCount = 10;
    
    // 2초마다 센서 데이터 발행
    const interval = setInterval(() => {
        // 센서 데이터 생성
        const temperature = (20 + (Math.random() * 10 - 5)).toFixed(2);
        const humidity = (50 + (Math.random() * 20 - 10)).toFixed(2);
        
        // JSON 페이로드 생성
        const payload = JSON.stringify({
            sensor_id: CLIENT_ID,
            timestamp: Date.now() / 1000,
            temperature: parseFloat(temperature),
            humidity: parseFloat(humidity),
            unit: 'celsius'
        });
        
        // 메시지 발행
        client.publish(TOPIC, payload, { qos: 1, retain: false }, (error) => {
            if (error) {
                console.error('❌ 발행 실패:', error);
            } else {
                console.log(`📤 발행 [${count + 1}/${maxCount}]: 온도 ${temperature}°C, 습도 ${humidity}%`);
            }
        });
        
        count++;
        
        // 10번 발행 후 종료
        if (count >= maxCount) {
            clearInterval(interval);
            setTimeout(() => {
                client.end();
                console.log('🔌 연결 종료');
            }, 1000);
        }
    }, 2000);
});

// 이벤트 핸들러: 오류 발생
client.on('error', (error) => {
    console.error('❌ 오류 발생:', error);
});

// 이벤트 핸들러: 연결 끊김
client.on('close', () => {
    console.log('🔌 연결이 종료되었습니다.');
});

// 이벤트 핸들러: 재연결 시도
client.on('reconnect', () => {
    console.log('🔄 재연결 시도 중...');
});

const mqtt = require('mqtt');

// MQTT 브로커 설정
const BROKER_URL = 'mqtt://localhost:1883';
const CLIENT_ID = 'NodeSubscriber_' + Math.random().toString(16).substr(2, 8);
const TOPIC = 'sensors/#';

// 연결 옵션
const options = {
    clientId: CLIENT_ID,
    username: 'your_username',
    password: 'your_password',
    clean: true,
    keepalive: 60,
    reconnectPeriod: 1000
};

// 브로커 연결
console.log('🔌 브로커 연결 중...');
const client = mqtt.connect(BROKER_URL, options);

// 이벤트 핸들러: 연결 성공
client.on('connect', () => {
    console.log('✅ 브로커 연결 성공!');
    console.log(`🆔 클라이언트 ID: ${CLIENT_ID}`);
    
    // 토픽 구독
    client.subscribe(TOPIC, { qos: 1 }, (error) => {
        if (error) {
            console.error('❌ 구독 실패:', error);
        } else {
            console.log(`📡 토픽 구독: ${TOPIC}`);
            console.log('🔄 메시지 수신 대기 중...\n');
        }
    });
});

// 이벤트 핸들러: 메시지 수신
client.on('message', (topic, message) => {
    try {
        const payload = message.toString();
        
        console.log('\n' + '='.repeat(50));
        console.log('📬 새 메시지 수신!');
        console.log(`📍 토픽: ${topic}`);
        
        // JSON 파싱
        const data = JSON.parse(payload);
        
        // 타임스탬프 변환
        const date = new Date(data.timestamp * 1000);
        const dateTime = date.toLocaleString('ko-KR', {
            year: 'numeric',
            month: '2-digit',
            day: '2-digit',
            hour: '2-digit',
            minute: '2-digit',
            second: '2-digit'
        });
        
        // 데이터 출력
        console.log(`🆔 센서 ID: ${data.sensor_id}`);
        console.log(`⏰ 시간: ${dateTime}`);
        console.log(`🌡️  온도: ${data.temperature}°C`);
        console.log(`💧 습도: ${data.humidity}%`);
        console.log('='.repeat(50) + '\n');
        
        // 데이터 처리
        processSensorData(data);
        
    } catch (error) {
        console.error('⚠️  메시지 처리 오류:', error.message);
    }
});

// 센서 데이터 처리 함수
function processSensorData(data) {
    const { temperature, humidity } = data;
    
    // 온도 임계값 체크
    if (temperature > 30) {
        console.log('🔥 경고: 온도가 너무 높습니다!');
        // 여기서 알림 전송, 로그 기록 등 수행
    } else if (temperature < 10) {
        console.log('❄️  경고: 온도가 너무 낮습니다!');
    }
    
    // 습도 임계값 체크
    if (humidity > 70) {
        console.log('💦 경고: 습도가 너무 높습니다!');
    } else if (humidity < 30) {
        console.log('🏜️  경고: 습도가 너무 낮습니다!');
    }
}

// 이벤트 핸들러: 오류 발생
client.on('error', (error) => {
    console.error('❌ 오류 발생:', error);
});

// 이벤트 핸들러: 연결 끊김
client.on('close', () => {
    console.log('🔌 연결이 종료되었습니다.');
});

// 이벤트 핸들러: 재연결 시도
client.on('reconnect', () => {
    console.log('🔄 재연결 시도 중...');
});

// 프로세스 종료 처리
process.on('SIGINT', () => {
    console.log('\n⏹️  프로그램 종료 중...');
    client.end();
    process.exit();
});

<!DOCTYPE html>
<html lang="ko">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>MQTT 실시간 모니터링</title>
    <script src="https://unpkg.com/mqtt/dist/mqtt.min.js"></script>
    <style>
        body {
            font-family: 'Segoe UI', sans-serif;
            max-width: 800px;
            margin: 50px auto;
            padding: 20px;
            background: #f5f6fa;
        }
        .container {
            background: white;
            padding: 30px;
            border-radius: 15px;
            box-shadow: 0 5px 15px rgba(0,0,0,0.1);
        }
        .status {
            padding: 15px;
            border-radius: 8px;
            margin: 15px 0;
            font-weight: bold;
        }
        .connected {
            background: #d4edda;
            color: #155724;
        }
        .disconnected {
            background: #f8d7da;
            color: #721c24;
        }
        .data-box {
            background: #e3f2fd;
            padding: 20px;
            border-radius: 10px;
            margin: 15px 0;
        }
        .temperature {
            font-size: 48px;
            color: #ff6b6b;
            font-weight: bold;
        }
        .humidity {
            font-size: 48px;
            color: #4ecdc4;
            font-weight: bold;
        }
        button {
            background: #6c5ce7;
            color: white;
            border: none;
            padding: 12px 24px;
            border-radius: 8px;
            cursor: pointer;
            font-size: 16px;
            margin: 5px;
        }
        button:hover {
            background: #5f4dd1;
        }
        #log {
            background: #2d3436;
            color: #dfe6e9;
            padding: 15px;
            border-radius: 8px;
            max-height: 300px;
            overflow-y: auto;
            font-family: 'Courier New', monospace;
            font-size: 13px;
        }
    </style>
</head>
<body>
    <div class="container">
        <h1 style="text-align:center; color:#6c5ce7;">🌡️ MQTT 실시간 센서 모니터링</h1>
        
        <div id="status" class="status disconnected">
            ❌ 연결 안됨
        </div>
        
        <div style="text-align:center;">
            <button onclick="connect()">🔌 연결</button>
            <button onclick="disconnect()">🔌 연결 해제</button>
        </div>
        
        <div class="data-box">
            <h3>📊 최신 센서 데이터</h3>
            <div style="display:flex; justify-content:space-around;">
                <div style="text-align:center;">
                    <div>🌡️ 온도</div>
                    <div class="temperature" id="temperature">--</div>
                    <div>°C</div>
                </div>
                <div style="text-align:center;">
                    <div>💧 습도</div>
                    <div class="humidity" id="humidity">--</div>
                    <div>%</div>
                </div>
            </div>
            <div style="margin-top:15px; font-size:14px; color:#666;">
                <div>🆔 센서: <span id="sensorId">-</span></div>
                <div>⏰ 시간: <span id="timestamp">-</span></div>
            </div>
        </div>
        
        <h3>📝 로그</h3>
        <div id="log"></div>
    </div>

    <script>
        let client = null;
        const BROKER_URL = 'ws://localhost:9001';  // WebSocket 포트
        const TOPIC = 'sensors/#';
        
        function addLog(message) {
            const log = document.getElementById('log');
            const time = new Date().toLocaleTimeString();
            log.innerHTML += `[${time}] ${message}<br>`;
            log.scrollTop = log.scrollHeight;
        }
        
        function connect() {
            if (client && client.connected) {
                addLog('⚠️  이미 연결되어 있습니다.');
                return;
            }
            
            const clientId = 'WebClient_' + Math.random().toString(16).substr(2, 8);
            
            addLog('🔌 브로커 연결 중...');
            
            client = mqtt.connect(BROKER_URL, {
                clientId: clientId,
                username: 'your_username',
                password: 'your_password',
                clean: true,
                keepalive: 60
            });
            
            client.on('connect', () => {
                addLog('✅ 브로커 연결 성공!');
                document.getElementById('status').className = 'status connected';
                document.getElementById('status').textContent = '✅ 연결됨';
                
                client.subscribe(TOPIC, { qos: 1 }, (error) => {
                    if (error) {
                        addLog('❌ 구독 실패: ' + error);
                    } else {
                        addLog('📡 토픽 구독: ' + TOPIC);
                    }
                });
            });
            
            client.on('message', (topic, message) => {
                try {
                    const data = JSON.parse(message.toString());
                    
                    // UI 업데이트
                    document.getElementById('temperature').textContent = 
                        data.temperature.toFixed(1);
                    document.getElementById('humidity').textContent = 
                        data.humidity.toFixed(1);
                    document.getElementById('sensorId').textContent = 
                        data.sensor_id;
                    
                    const date = new Date(data.timestamp * 1000);
                    document.getElementById('timestamp').textContent = 
                        date.toLocaleString('ko-KR');
                    
                    addLog(`📬 메시지 수신: 온도 ${data.temperature.toFixed(1)}°C, ` +
                           `습도 ${data.humidity.toFixed(1)}%`);
                    
                    // 경고 체크
                    if (data.temperature > 30) {
                        addLog('🔥 경고: 온도가 너무 높습니다!');
                    } else if (data.temperature < 10) {
                        addLog('❄️  경고: 온도가 너무 낮습니다!');
                    }
                    
                } catch (error) {
                    addLog('⚠️  메시지 파싱 오류: ' + error.message);
                }
            });
            
            client.on('error', (error) => {
                addLog('❌ 오류: ' + error.message);
            });
            
            client.on('close', () => {
                addLog('🔌 연결 종료');
                document.getElementById('status').className = 'status disconnected';
                document.getElementById('status').textContent = '❌ 연결 안됨';
            });
        }
        
        function disconnect() {
            if (client && client.connected) {
                client.end();
                addLog('🔌 연결 해제 요청');
            } else {
                addLog('⚠️  연결되어 있지 않습니다.');
            }
        }
        
        // 페이지 로드 시 자동 연결
        window.addEventListener('load', () => {
            addLog('🌐 페이지 로드 완료');
        });
    </script>
</body>
</html>

# OpenSSL을 사용한 자체 서명 인증서 생성

# 1. CA(Certificate Authority) 키 생성
openssl genrsa -out ca.key 2048

# 2. CA 인증서 생성 (10년 유효)
openssl req -new -x509 -days 3650 -key ca.key -out ca.crt

# 3. 서버 키 생성
openssl genrsa -out server.key 2048

# 4. 서버 인증서 서명 요청(CSR) 생성
openssl req -new -key server.key -out server.csr

# 5. CA로 서버 인증서 서명
openssl x509 -req -in server.csr -CA ca.crt -CAkey ca.key \
    -CAcreateserial -out server.crt -days 3650

# 파일 권한 설정
chmod 600 *.key
chmod 644 *.crt

# mosquitto.conf에 TLS 설정 추가

# 일반 포트 비활성화
#listener 1883

# TLS 포트 활성화
listener 8883
protocol mqtt

# 인증서 경로 설정
cafile /etc/mosquitto/certs/ca.crt
certfile /etc/mosquitto/certs/server.crt
keyfile /etc/mosquitto/certs/server.key

# TLS 버전 설정
tls_version tlsv1.2

# 클라이언트 인증 요구 (선택사항)
require_certificate false

# 사용자 인증 필수
allow_anonymous false
password_file /etc/mosquitto/passwd

import paho.mqtt.client as mqtt
import ssl

BROKER_ADDRESS = "your-broker.com"
BROKER_PORT = 8883
CLIENT_ID = "SecureClient"

# TLS 설정
def on_connect(client, userdata, flags, rc):
    if rc == 0:
        print("✅ 보안 연결 성공!")
    else:
        print(f"❌ 연결 실패: {rc}")

client = mqtt.Client(CLIENT_ID)
client.on_connect = on_connect

# 사용자 인증
client.username_pw_set("username", "password")

# TLS/SSL 설정
client.tls_set(
    ca_certs="/path/to/ca.crt",
    certfile="/path/to/client.crt",  # 클라이언트 인증서 (선택)
    keyfile="/path/to/client.key",   # 클라이언트 키 (선택)
    cert_reqs=ssl.CERT_REQUIRED,
    tls_version=ssl.PROTOCOL_TLSv1_2,
    ciphers=None
)

# 인증서 검증 비활성화 (개발 환경에서만!)
# client.tls_insecure_set(True)

# 연결
client.connect(BROKER_ADDRESS, BROKER_PORT, keepalive=60)
client.loop_forever()

import paho.mqtt.client as mqtt
import json
import gzip

def compress_payload(data):
    """JSON 데이터를 압축"""
    json_str = json.dumps(data)
    compressed = gzip.compress(json_str.encode('utf-8'))
    return compressed

def decompress_payload(compressed_data):
    """압축된 데이터를 해제"""
    decompressed = gzip.decompress(compressed_data)
    json_str = decompressed.decode('utf-8')
    return json.loads(json_str)

# Publisher
client = mqtt.Client("CompressedPublisher")
client.connect("localhost", 1883)

data = {
    "sensor_id": "sensor_001",
    "timestamp": 1234567890,
    "readings": [
        {"temp": 25.5, "humidity": 60.2},
        {"temp": 25.6, "humidity": 60.1},
        # ... 많은 데이터
    ]
}

# 압축 전후 크기 비교
original = json.dumps(data).encode('utf-8')
compressed = compress_payload(data)

print(f"원본 크기: {len(original)} bytes")
print(f"압축 크기: {len(compressed)} bytes")
print(f"압축률: {(1 - len(compressed)/len(original)) * 100:.1f}%")

# 압축된 데이터 발행
client.publish("sensors/compressed", compressed)

# Subscriber
def on_message(client, userdata, message):
    compressed_data = message.payload
    data = decompress_payload(compressed_data)
    print(f"수신 데이터: {data}")

# 메시지 구독 (모든 토픽)
mosquitto_sub -h localhost -t '#' -v

# 특정 토픽 구독
mosquitto_sub -h localhost -t 'sensors/temperature' -v

# 사용자 인증과 함께 구독
mosquitto_sub -h localhost -t '#' -u username -P password -v

# 메시지 발행
mosquitto_pub -h localhost -t 'test/topic' -m 'Hello MQTT!'

# JSON 메시지 발행
mosquitto_pub -h localhost -t 'sensors/temp' \
    -m '{"temperature": 25.5, "unit": "celsius"}'

# QoS 설정과 함께 발행
mosquitto_pub -h localhost -t 'important/data' -m 'Critical' -q 2

# Retain 플래그와 함께 발행
mosquitto_pub -h localhost -t 'status/online' -m 'true' -r

# mosquitto.conf 로깅 설정

# 로그 출력 위치
log_dest file /var/log/mosquitto/mosquitto.log
log_dest stdout

# 로그 타입 (여러 개 지정 가능)
log_type error
log_type warning
log_type notice
log_type information
log_type all

# 연결 메시지 로깅
connection_messages true

# 타임스탬프 포함
log_timestamp true

# 로그 파일 크기 제한 (bytes)
# log_file_size 10485760  # 10MB

import paho.mqtt.client as mqtt
import json
import time
from datetime import datetime

class SmartHomeController:
    def __init__(self, broker_address, username, password):
        self.broker = broker_address
        self.client = mqtt.Client("SmartHomeController")
        self.client.username_pw_set(username, password)
        self.client.on_connect = self.on_connect
        self.client.on_message = self.on_message
        
        # 디바이스 상태 저장
        self.devices = {
            "lights": {},
            "temperature": {},
            "security": {}
        }
    
    def on_connect(self, client, userdata, flags, rc):
        if rc == 0:
            print("✅ 스마트홈 컨트롤러 연결 성공!")
            # 모든 디바이스 토픽 구독
            self.client.subscribe("home/#", qos=1)
        else:
            print(f"❌ 연결 실패: {rc}")
    
    def on_message(self, client, userdata, message):
        topic = message.topic
        payload = json.loads(message.payload.decode())
        
        # 토픽 파싱
        parts = topic.split('/')
        
        if len(parts) >= 3:
            category = parts[1]  # lights, temperature, security
            room = parts[2]      # living-room, bedroom, etc.
            
            # 상태 업데이트
            if category in self.devices:
                self.devices[category][room] = payload
                self.process_device_update(category, room, payload)
    
    def process_device_update(self, category, room, data):
        """디바이스 업데이트 처리"""
        timestamp = datetime.now().strftime("%H:%M:%S")
        
        if category == "temperature":
            temp = data.get("temperature")
            print(f"[{timestamp}] 🌡️  {room}: {temp}°C")
            
            # 자동 온도 조절
            if temp > 28:
                self.control_ac(room, "on", 24)
            elif temp < 18:
                self.control_heater(room, "on", 22)
        
        elif category == "lights":
            status = data.get("status")
            brightness = data.get("brightness", 0)
            print(f"[{timestamp}] 💡 {room}: {status} ({brightness}%)")
        
        elif category == "security":
            motion = data.get("motion_detected")
            if motion:
                print(f"[{timestamp}] 🚨 {room}: 움직임 감지!")
                self.send_alert(room)
    
    def control_light(self, room, status, brightness=100):
        """조명 제어"""
        payload = {
            "command": "set",
            "status": status,
            "brightness": brightness,
            "timestamp": time.time()
        }
        topic = f"home/lights/{room}/control"
        self.client.publish(topic, json.dumps(payload), qos=1)
        print(f"💡 {room} 조명 {status} (밝기: {brightness}%)")
    
    def control_ac(self, room, status, temperature):
        """에어컨 제어"""
        payload = {
            "command": "set",
            "status": status,
            "temperature": temperature,
            "mode": "cool",
            "timestamp": time.time()
        }
        topic = f"home/climate/{room}/control"
        self.client.publish(topic, json.dumps(payload), qos=1)
        print(f"❄️  {room} 에어컨 {status} (설정: {temperature}°C)")
    
    def control_heater(self, room, status, temperature):
        """히터 제어"""
        payload = {
            "command": "set",
            "status": status,
            "temperature": temperature,
            "mode": "heat",
            "timestamp": time.time()
        }
        topic = f"home/climate/{room}/control"
        self.client.publish(topic, json.dumps(payload), qos=1)
        print(f"🔥 {room} 히터 {status} (설정: {temperature}°C)")
    
    def send_alert(self, room):
        """보안 알림 전송"""
        payload = {
            "type": "security_alert",
            "room": room,
            "message": f"{room}에서 움직임이 감지되었습니다.",
            "timestamp": time.time()
        }
        topic = "home/alerts"
        self.client.publish(topic, json.dumps(payload), qos=2)
        print(f"📱 보안 알림 전송: {room}")
    
    def get_status_report(self):
        """전체 상태 리포트"""
        print("\n" + "="*60)
        print("🏠 스마트홈 상태 리포트")
        print("="*60)
        
        for category, rooms in self.devices.items():
            if rooms:
                print(f"\n📊 {category.upper()}")
                for room, data in rooms.items():
                    print(f"  • {room}: {data}")
        
        print("="*60 + "\n")
    
    def start(self):
        """컨트롤러 시작"""
        self.client.connect(self.broker, 1883, keepalive=60)
        self.client.loop_start()
    
    def stop(self):
        """컨트롤러 종료"""
        self.client.loop_stop()
        self.client.disconnect()

# 사용 예제
if __name__ == "__main__":
    controller = SmartHomeController(
        broker_address="localhost",
        username="smarthome",
        password="password123"
    )
    
    controller.start()
    
    try:
        # 초기 설정
        time.sleep(2)
        
        # 거실 조명 켜기
        controller.control_light("living-room", "on", 80)
        
        # 침실 조명 끄기
        controller.control_light("bedroom", "off", 0)
        
        # 상태 리포트 주기적 출력
        while True:
            time.sleep(30)
            controller.get_status_report()
    
    except KeyboardInterrupt:
        print("\n⏹️  컨트롤러 종료 중...")
        controller.stop()