Python สำหรับ IoT: คู่มือฉบับสมบูรณ์เกี่ยวกับการใช้งาน MQTT

โลกแห่งการเชื่อมต่อ: ทำไมโปรโตคอล IoT จึงสำคัญ

เราอยู่ในยุคแห่งการเชื่อมต่อที่ไม่เคยมีมาก่อน Internet of Things (IoT) ไม่ใช่แนวคิดในอนาคตอีกต่อไป แต่เป็นความจริงระดับโลก ที่ถักทอเครือข่ายอุปกรณ์อัจฉริยะนับพันล้านชิ้นอย่างเงียบ ๆ ซึ่งคอยตรวจสอบสภาพแวดล้อมของเรา ทำให้บ้านเป็นอัตโนมัติ เพิ่มประสิทธิภาพอุตสาหกรรมของเรา และปรับปรุงเมืองของเราให้ทันสมัย ตั้งแต่เทอร์โมสตัทอัจฉริยะในบ้านที่โซล ไปจนถึงเซ็นเซอร์การเกษตรในทุ่งชนบทของเคนยา อุปกรณ์เหล่านี้กำลังสร้างข้อมูลจำนวนมหาศาล แต่พวกมันสื่อสารกันและสื่อสารกับคลาวด์ได้อย่างไร โดยเฉพาะอย่างยิ่งเมื่ออุปกรณ์เหล่านี้มักมีขนาดเล็ก ใช้พลังงานต่ำ และทำงานบนเครือข่ายที่ไม่น่าเชื่อถือ? คำตอบอยู่ที่โปรโตคอลการสื่อสารเฉพาะทาง

ในขณะที่โปรโตคอล HTTP ขับเคลื่อนเว็บส่วนใหญ่ที่เราใช้ในชีวิตประจำวัน แต่มันมักจะหนักเกินไปและกินพลังงานมากเกินไปสำหรับโลกของ IoT ที่มีข้อจำกัด นี่คือที่ซึ่งโปรโตคอลที่ออกแบบมาสำหรับการสื่อสารแบบเครื่องต่อเครื่อง (M2M) โดยเฉพาะมีความโดดเด่น ในบรรดาโปรโตคอลเหล่านี้ มีโปรโตคอลหนึ่งที่ได้กลายเป็นแรงขับเคลื่อนหลัก: MQTT

คู่มือฉบับสมบูรณ์นี้ออกแบบมาสำหรับนักพัฒนา วิศวกร และนักอดิเรกทั่วโลกที่ต้องการใช้ประโยชน์จากพลังของ MQTT โดยใช้ Python ซึ่งเป็นหนึ่งในภาษาโปรแกรมที่หลากหลายและได้รับความนิยมมากที่สุดในวงการ IoT เราจะเดินทางตั้งแต่แนวคิดพื้นฐานของ MQTT ไปจนถึงการสร้างแอปพลิเคชัน IoT ที่ปลอดภัย แข็งแกร่ง และปรับขนาดได้

MQTT คืออะไร? โปรโตคอลที่สร้างขึ้นเพื่อข้อจำกัด

MQTT ย่อมาจาก Message Queuing Telemetry Transport ถูกคิดค้นขึ้นในปี 1999 โดย Dr. Andy Stanford-Clark จาก IBM และ Arlen Nipper จาก Arcom (ปัจจุบันคือ Cirrus Link) สำหรับการตรวจสอบท่อส่งน้ำมันผ่านเครือข่ายดาวเทียมที่ไม่น่าเชื่อถือ เรื่องราวต้นกำเนิดของมันสะท้อนถึงจุดประสงค์ได้อย่างสมบูรณ์แบบ: เพื่อเป็นโปรโตคอลการส่งข้อความที่มีน้ำหนักเบา เชื่อถือได้ และมีประสิทธิภาพสำหรับอุปกรณ์ที่ทำงานภายใต้ข้อจำกัดที่สำคัญ

อธิบายโมเดล Publish/Subscribe (Pub/Sub)

หัวใจของ MQTT คือรูปแบบสถาปัตยกรรม publish/subscribe ที่สง่างาม นี่เป็นการเปลี่ยนแปลงพื้นฐานจากโมเดล request/response ของ HTTP ที่นักพัฒนาหลายคนคุ้นเคย แทนที่ไคลเอนต์จะร้องขอข้อมูลจากเซิร์ฟเวอร์โดยตรง การสื่อสารจะถูกแยกออกจากกัน

ลองนึกภาพสำนักข่าวระดับโลก นักข่าว (ผู้เผยแพร่) ไม่ได้ส่งเรื่องราวของตนโดยตรงไปยังผู้อ่านทุกคน แต่พวกเขาส่งเรื่องราวของตนไปยังศูนย์กลางของสำนักข่าว (โบรกเกอร์) และจัดหมวดหมู่ภายใต้หัวข้อเฉพาะ เช่น "การเมืองโลก" หรือ "เทคโนโลยี" ผู้อ่าน (ผู้สมัครรับข้อมูล) ไม่จำเป็นต้องขอการอัปเดตจากนักข่าว พวกเขาเพียงแค่บอกสำนักข่าวว่าหัวข้อใดที่พวกเขาสนใจ จากนั้นสำนักข่าวจะส่งต่อเรื่องราวใหม่ ๆ ในหัวข้อเหล่านั้นไปยังผู้อ่านที่สนใจโดยอัตโนมัติ นักข่าวและผู้อ่านไม่จำเป็นต้องรู้เกี่ยวกับการมีอยู่ ที่อยู่ หรือสถานะของกันและกัน

ใน MQTT โมเดลนี้จะแยกอุปกรณ์ที่ส่งข้อมูล (ผู้เผยแพร่) ออกจากอุปกรณ์หรือแอปพลิเคชันที่รับข้อมูล (ผู้สมัครรับข้อมูล) ซึ่งทรงพลังอย่างยิ่งสำหรับ IoT เพราะ:

• การแยกพื้นที่ (Space Decoupling): ผู้เผยแพร่และผู้สมัครรับข้อมูลไม่จำเป็นต้องทราบที่อยู่ IP หรือตำแหน่งของกันและกัน
• การแยกเวลา (Time Decoupling): ไม่จำเป็นต้องทำงานพร้อมกัน เซ็นเซอร์สามารถเผยแพร่การอ่านค่า และแอปพลิเคชันสามารถรับได้ในอีกหลายชั่วโมงต่อมา หากระบบถูกออกแบบมาให้ทำเช่นนั้น
• การแยกการซิงโครไนซ์ (Synchronization Decoupling): การดำเนินการทั้งสองฝั่งไม่จำเป็นต้องหยุดรอให้อีกฝั่งเสร็จสิ้นการแลกเปลี่ยนข้อความ

ส่วนประกอบหลักของระบบนิเวศ MQTT

สถาปัตยกรรม MQTT สร้างขึ้นจากส่วนประกอบหลักไม่กี่อย่าง:

• โบรกเกอร์ (Broker): ศูนย์กลางหรือเซิร์ฟเวอร์ เป็นที่ทำการไปรษณีย์ของโลก MQTT โบรกเกอร์มีหน้าที่รับข้อความทั้งหมดจากผู้เผยแพร่ กรองตามหัวข้อ และส่งไปยังผู้สมัครรับข้อมูลที่เหมาะสม โบรกเกอร์ยอดนิยม ได้แก่ ตัวเลือกโอเพนซอร์ส เช่น Mosquitto และ VerneMQ และบริการคลาวด์ที่มีการจัดการ เช่น AWS IoT Core, Azure IoT Hub และ Google Cloud IoT Core
• ไคลเอนต์ (Client): อุปกรณ์หรือแอปพลิเคชันใดๆ ที่เชื่อมต่อกับโบรกเกอร์ ไคลเอนต์สามารถเป็นผู้เผยแพร่ ผู้สมัครรับข้อมูล หรือทั้งสองอย่าง เซ็นเซอร์ IoT คือไคลเอนต์ และแอปพลิเคชันเซิร์ฟเวอร์ที่ประมวลผลข้อมูลเซ็นเซอร์ก็เป็นไคลเอนต์เช่นกัน
• หัวข้อ (Topic): สตริง UTF-8 ที่ทำหน้าที่เป็นที่อยู่หรือป้ายกำกับสำหรับข้อความ โบรกเกอร์ใช้หัวข้อเพื่อส่งข้อความ หัวข้อมีการจัดลำดับชั้น โดยใช้เครื่องหมายทับ (/) เป็นตัวคั่น เหมือนกับเส้นทางในระบบไฟล์ ตัวอย่างเช่น หัวข้อที่ดีสำหรับเซ็นเซอร์วัดอุณหภูมิในห้องนั่งเล่นในอาคารในลอนดอน อาจเป็น: UK/London/Building-A/Floor-1/LivingRoom/Temperature
• เพย์โหลด (Payload): นี่คือเนื้อหาข้อมูลจริงของข้อความ MQTT เป็นแบบอิสระจากข้อมูล (data-agnostic) ซึ่งหมายความว่าเพย์โหลดสามารถเป็นอะไรก็ได้: สตริงธรรมดา, จำนวนเต็ม, JSON, XML หรือแม้แต่ข้อมูลไบนารีที่เข้ารหัส JSON เป็นตัวเลือกที่พบบ่อยมาก เนื่องจากความยืดหยุ่นและความสามารถในการอ่าน

ทำไม MQTT จึงครองการสื่อสาร IoT

หลักการออกแบบของ MQTT ทำให้เหมาะสมอย่างยิ่งสำหรับความท้าทายของ IoT:

• น้ำหนักเบา (Lightweight): ข้อความ MQTT มีส่วนหัวขนาดเล็กมาก (ตั้งแต่ 2 ไบต์) ช่วยลดการใช้แบนด์วิดท์เครือข่าย สิ่งนี้สำคัญอย่างยิ่งสำหรับอุปกรณ์ที่ใช้แผนบริการเซลลูลาร์ที่มีค่าใช้จ่ายสูงหรือเครือข่ายแบนด์วิดท์ต่ำ เช่น LoRaWAN
• มีประสิทธิภาพ (Efficient): โอเวอร์เฮดต่ำของโปรโตคอลส่งผลโดยตรงต่อการใช้พลังงานที่ลดลง ทำให้อุปกรณ์ที่ใช้แบตเตอรี่สามารถทำงานได้นานหลายเดือนหรือหลายปี
• เชื่อถือได้ (Reliable): มีคุณสมบัติที่ช่วยให้มั่นใจในการส่งข้อความ แม้ในเครือข่ายที่มีสัญญาณรบกวนและมีความหน่วงสูง สิ่งนี้ได้รับการจัดการผ่านระดับ Quality of Service
• ปรับขนาดได้ (Scalable): โบรกเกอร์เดียวสามารถจัดการการเชื่อมต่อจากไคลเอนต์หลายพันหรือหลายล้านเครื่องพร้อมกัน ทำให้เหมาะสำหรับการใช้งานขนาดใหญ่
• สองทาง (Bidirectional): MQTT อนุญาตให้สื่อสารจากอุปกรณ์ไปยังคลาวด์ (telemetry) และจากคลาวด์ไปยังอุปกรณ์ (commands) ซึ่งเป็นข้อกำหนดที่จำเป็นสำหรับการควบคุมอุปกรณ์จากระยะไกล

ทำความเข้าใจ Quality of Service (QoS)

MQTT มีระดับ Quality of Service (QoS) สามระดับ เพื่อให้นักพัฒนาสามารถเลือกระดับความสมดุลที่เหมาะสมระหว่างความน่าเชื่อถือและโอเวอร์เฮดสำหรับกรณีการใช้งานเฉพาะของตน

• QoS 0 (At most once): นี่คือระดับ "ส่งแล้วลืม" (fire and forget) ข้อความจะถูกส่งเพียงครั้งเดียว โดยไม่มีการยืนยันการรับจากโบรกเกอร์หรือผู้สมัครรับข้อมูลสุดท้าย เป็นวิธีที่เร็วที่สุด แต่ไม่มีการรับประกันการส่ง กรณีการใช้งาน: ข้อมูลเซ็นเซอร์ที่ไม่สำคัญและมีความถี่สูง เช่น การอ่านค่าอุณหภูมิห้องโดยรอบที่ส่งทุกๆ 10 วินาที การสูญเสียการอ่านค่าหนึ่งครั้งไม่ใช่ปัญหา
• QoS 1 (At least once): ระดับนี้รับประกันว่าข้อความจะถูกส่งอย่างน้อยหนึ่งครั้ง ผู้ส่งจะเก็บข้อความไว้จนกว่าจะได้รับการยอมรับ (แพ็กเก็ต PUBACK) จากผู้รับ หากไม่ได้รับการยอมรับ ข้อความจะถูกส่งซ้ำ ซึ่งอาจทำให้เกิดข้อความซ้ำซ้อนได้หากการยอมรับสูญหาย กรณีการใช้งาน: คำสั่งเปิดไฟอัจฉริยะ คุณต้องการให้แน่ใจว่าคำสั่งได้รับการรับ และการได้รับคำสั่งซ้ำจะไม่ก่อให้เกิดอันตราย
• QoS 2 (Exactly once): นี่คือระดับที่น่าเชื่อถือที่สุด แต่ก็ช้าที่สุดเช่นกัน ใช้การจับมือสี่ครั้งเพื่อให้แน่ใจว่าข้อความถูกส่งเพียงครั้งเดียวโดยไม่มีข้อความซ้ำ กรณีการใช้งาน: การดำเนินการที่สำคัญซึ่งการส่งซ้ำอาจก่อให้เกิดหายนะ เช่น การทำธุรกรรมทางการเงิน คำสั่งจ่ายยาในปริมาณที่แม่นยำ หรือการควบคุมแขนหุ่นยนต์ในโรงงาน

การตั้งค่าสภาพแวดล้อม MQTT Python ของคุณ

ตอนนี้ มาลงมือปฏิบัติกัน ในการเริ่มสร้างแอปพลิเคชัน MQTT ด้วย Python คุณต้องมีสองสิ่ง: ไลบรารี Python สำหรับไคลเอนต์ MQTT และโบรกเกอร์ MQTT เพื่อสื่อสารด้วย

การเลือกไลบรารี Python MQTT: Paho-MQTT

ไลบรารี MQTT ที่ใช้กันอย่างแพร่หลายและสมบูรณ์ที่สุดสำหรับ Python คือ Paho-MQTT จาก Eclipse Foundation เป็นไลบรารีที่แข็งแกร่งและมีคุณสมบัติครบถ้วน ซึ่งมีคลาสไคลเอนต์สำหรับเชื่อมต่อกับโบรกเกอร์ และเผยแพร่หรือสมัครรับหัวข้อ การติดตั้งนั้นง่ายมากโดยใช้ pip ตัวจัดการแพ็กเกจของ Python

เปิดเทอร์มินัลหรือ Command Prompt ของคุณ แล้วรัน:

pip install paho-mqtt

คำสั่งเดียวนี้จะติดตั้งทุกสิ่งที่คุณต้องการเพื่อเริ่มเขียนไคลเอนต์ MQTT ใน Python

การตั้งค่าโบรกเกอร์ MQTT

คุณมีตัวเลือกหลายอย่างสำหรับโบรกเกอร์ ตั้งแต่การรันบนเครื่องของคุณสำหรับการพัฒนา ไปจนถึงการใช้บริการคลาวด์ที่มีประสิทธิภาพสำหรับการใช้งานจริง

• โบรกเกอร์ในเครื่อง (สำหรับการพัฒนาและเรียนรู้): ตัวเลือกยอดนิยมที่สุดสำหรับโบรกเกอร์ในเครื่องคือ Mosquitto ซึ่งเป็นโปรเจกต์ของ Eclipse เช่นกัน มีน้ำหนักเบา เป็นโอเพนซอร์ส และติดตั้งง่าย
  • บน Linux ที่ใช้ Debian (เช่น Ubuntu, Raspberry Pi OS): sudo apt-get update && sudo apt-get install mosquitto mosquitto-clients
  • บน macOS (ใช้ Homebrew): brew install mosquitto
  • บน Windows: ดาวน์โหลดตัวติดตั้งแบบเนทีฟจากเว็บไซต์ Mosquitto
  เมื่อติดตั้งแล้ว โบรกเกอร์มักจะเริ่มทำงานโดยอัตโนมัติในฐานะบริการ คุณสามารถใช้งานได้โดยชี้ไคลเอนต์ของคุณไปยังที่อยู่ IP ในเครื่องของคุณ (127.0.0.1 หรือ localhost)
• โบรกเกอร์สาธารณะ/คลาวด์ (สำหรับการทดสอบอย่างรวดเร็ว): สำหรับการทดลองเบื้องต้นโดยไม่ต้องติดตั้งอะไร คุณสามารถใช้โบรกเกอร์สาธารณะฟรี สองตัวที่ได้รับความนิยมคือ test.mosquitto.org และ broker.hivemq.com สำคัญ: เหล่านี้เป็นบริการสาธารณะและไม่เข้ารหัส อย่าส่งข้อมูลที่ละเอียดอ่อนหรือเป็นส่วนตัวใดๆ ไปยังบริการเหล่านี้ ใช้เพื่อการเรียนรู้และทดสอบเท่านั้น

ลงมือปฏิบัติ: การเผยแพร่และสมัครรับข้อมูลด้วย Python

เรามาเขียนแอปพลิเคชัน MQTT Python ตัวแรกกัน เราจะสร้างสคริปต์แยกสองสคริปต์: สคริปต์เผยแพร่ที่จะส่งข้อความ และสคริปต์สมัครรับที่จะรับข้อความ สำหรับตัวอย่างนี้ เราจะสมมติว่าคุณกำลังรันโบรกเกอร์ Mosquitto ในเครื่อง

การสร้าง Publisher MQTT อย่างง่าย (publisher.py)

สคริปต์นี้จะเชื่อมต่อกับโบรกเกอร์และเผยแพร่ข้อความ "Hello, MQTT!" ไปยังหัวข้อ `python/mqtt/test` ทุกๆ สองวินาที

สร้างไฟล์ชื่อ `publisher.py` และเพิ่มโค้ดต่อไปนี้:

import paho.mqtt.client as mqtt

import time

# --- การตั้งค่า ---

BROKER_ADDRESS = "localhost" # ใช้ 'test.mosquitto.org' สำหรับโบรกเกอร์สาธารณะ

PORT = 1883

TOPIC = "python/mqtt/test"

# --- Callback สำหรับการเชื่อมต่อ ---

def on_connect(client, userdata, flags, rc):

if rc == 0:

print("Connected to MQTT Broker!")

else:

print(f"Failed to connect, return code {rc}")

# --- สคริปต์หลัก ---

# 1. สร้างอินสแตนซ์ไคลเอนต์

client = mqtt.Client("PublisherClient")

# 2. กำหนดค่า callback on_connect

client.on_connect = on_connect

# 3. เชื่อมต่อกับโบรกเกอร์

client.connect(BROKER_ADDRESS, PORT, 60)

# 4. เริ่มเธรดพื้นหลังสำหรับ network loop

client.loop_start()

try:

count = 0

while True:

count += 1

message = f"Hello, MQTT! Message #{count}"

# 5. เผยแพร่ข้อความ

result = client.publish(TOPIC, message)

# ตรวจสอบว่าการเผยแพร่สำเร็จหรือไม่

status = result[0]

if status == 0:

print(f"Sent `{message}` to topic `{TOPIC}`")

else:

print(f"Failed to send message to topic {TOPIC}")

time.sleep(2)

except KeyboardInterrupt:

print("Publication stopped.")

finally:

# 6. หยุด network loop และตัดการเชื่อมต่อ

client.loop_stop()

client.disconnect()

print("Disconnected from the broker.")

การสร้าง Subscriber MQTT อย่างง่าย (subscriber.py)

สคริปต์นี้จะเชื่อมต่อกับโบรกเกอร์เดียวกัน สมัครรับหัวข้อ `python/mqtt/test` และพิมพ์ข้อความใดๆ ที่ได้รับ

สร้างไฟล์อื่นชื่อ `subscriber.py`:

import paho.mqtt.client as mqtt

# --- การตั้งค่า ---

BROKER_ADDRESS = "localhost"

PORT = 1883

TOPIC = "python/mqtt/test"

# --- ฟังก์ชัน Callback ---

def on_connect(client, userdata, flags, rc):

if rc == 0:

print("Connected to MQTT Broker!")

# สมัครรับหัวข้อเมื่อเชื่อมต่อสำเร็จ

client.subscribe(TOPIC)

else:

print(f"Failed to connect, return code {rc}")

def on_message(client, userdata, msg):

# ถอดรหัสเพย์โหลดข้อความจาก bytes เป็น string

payload = msg.payload.decode()

print(f"Received message: `{payload}` on topic `{msg.topic}`")

# --- สคริปต์หลัก ---

# 1. สร้างอินสแตนซ์ไคลเอนต์

client = mqtt.Client("SubscriberClient")

# 2. กำหนดค่า callbacks

client.on_connect = on_connect

client.on_message = on_message

# 3. เชื่อมต่อกับโบรกเกอร์

client.connect(BROKER_ADDRESS, PORT, 60)

# 4. เริ่ม network loop (เรียกใช้แบบ blocking)

# ฟังก์ชันนี้จะจัดการการเชื่อมต่อใหม่และการประมวลผลข้อความโดยอัตโนมัติ

print("Subscriber is listening...")

client.loop_forever()

การรันตัวอย่าง

1. เปิดหน้าต่างเทอร์มินัลแยกกันสองหน้าต่าง
2. ในเทอร์มินัลแรก รันสคริปต์ subscriber: python subscriber.py
3. คุณควรเห็นข้อความ "Subscriber is listening...". ตอนนี้กำลังรอรับข้อความ
4. ในเทอร์มินัลที่สอง รันสคริปต์ publisher: python publisher.py
5. คุณจะเห็น publisher ส่งข้อความทุกๆ สองวินาที ในขณะเดียวกัน ข้อความเหล่านี้จะปรากฏในหน้าต่างเทอร์มินัลของ subscriber

ขอแสดงความยินดี! คุณได้สร้างระบบการสื่อสาร MQTT ที่ทำงานได้อย่างสมบูรณ์โดยใช้ Python แล้ว

นอกเหนือจากพื้นฐาน: คุณสมบัติขั้นสูงของ Paho-MQTT

ระบบ IoT ในโลกจริงต้องการความแข็งแกร่งมากกว่าตัวอย่างง่ายๆ ของเรา มาสำรวจคุณสมบัติ MQTT ขั้นสูงบางอย่างที่จำเป็นสำหรับการสร้างแอปพลิเคชันที่พร้อมใช้งานจริง

Last Will and Testament (LWT)

จะเกิดอะไรขึ้นหากอุปกรณ์ที่สำคัญ เช่น กล้องวงจรปิด หรือเครื่องตรวจหัวใจ ขาดการเชื่อมต่ออย่างไม่คาดคิดเนื่องจากไฟฟ้าดับหรือเครือข่ายล่ม? คุณสมบัติ LWT คือโซลูชันของ MQTT เมื่อไคลเอนต์เชื่อมต่อ มันสามารถลงทะเบียน "เจตนาสุดท้าย" (last will) กับโบรกเกอร์ หากไคลเอนต์ตัดการเชื่อมต่ออย่างไม่ถูกต้อง (โดยไม่ส่งแพ็กเก็ต DISCONNECT) โบรกเกอร์จะเผยแพร่ข้อความเจตนาสุดท้ายนี้ในนามของมันไปยังหัวข้อที่ระบุโดยอัตโนมัติ

นี่มีคุณค่าอย่างยิ่งสำหรับการตรวจสอบสถานะอุปกรณ์ คุณสามารถให้อุปกรณ์เผยแพร่ข้อความ `devices/device-123/status` พร้อมเพย์โหลด "online" เมื่อเชื่อมต่อ และลงทะเบียนข้อความ LWT ด้วยหัวข้อเดียวกันแต่มีเพย์โหลด "offline" บริการตรวจสอบใดๆ ที่สมัครรับหัวข้อนี้จะทราบสถานะของอุปกรณ์ทันที

ในการใช้งาน LWT ใน Paho-MQTT คุณต้องตั้งค่าก่อนเชื่อมต่อ:

client.will_set('devices/device-123/status', payload='offline', qos=1, retain=True)

client.connect(BROKER_ADDRESS, PORT, 60)

ข้อความที่ถูกเก็บรักษา (Retained Messages)

โดยปกติ หากผู้สมัครรับข้อมูลเชื่อมต่อกับหัวข้อ มันจะได้รับเฉพาะข้อความที่ถูกเผยแพร่หลังจากที่มันสมัครรับไปแล้ว แต่จะเกิดอะไรขึ้นหากคุณต้องการค่าล่าสุดทันที? นี่คือสิ่งที่ข้อความที่ถูกเก็บรักษาไว้ทำ เมื่อข้อความถูกเผยแพร่พร้อมกับตั้งค่าแฟล็ก `retain` เป็น `True` โบรกเกอร์จะจัดเก็บข้อความนั้นสำหรับหัวข้อนั้นๆ เมื่อใดก็ตามที่ไคลเอนต์ใหม่สมัครรับหัวข้อนั้น มันจะได้รับข้อความที่ถูกเก็บรักษาล่าสุดทันที

นี่เหมาะสำหรับข้อมูลสถานะ อุปกรณ์สามารถเผยแพร่สถานะของตน (เช่น `{"state": "ON"}`) ด้วย `retain=True` แอปพลิเคชันใดๆ ที่เริ่มทำงานและสมัครรับข้อมูลจะทราบสถานะปัจจุบันของอุปกรณ์ทันทีโดยไม่ต้องรอการอัปเดตครั้งต่อไป

ใน Paho-MQTT คุณเพียงแค่เพิ่มแฟล็ก `retain` ในการเรียกใช้ publish ของคุณ:

client.publish(TOPIC, payload, qos=1, retain=True)

Persistent Sessions และ Clean Sessions

แฟล็ก `clean_session` ในคำขอเชื่อมต่อของไคลเอนต์จะควบคุมว่าโบรกเกอร์จัดการเซสชันของไคลเอนต์อย่างไร

• Clean Session (clean_session=True, ค่าเริ่มต้น): เมื่อไคลเอนต์ตัดการเชื่อมต่อ โบรกเกอร์จะทิ้งข้อมูลทั้งหมดเกี่ยวกับมัน รวมถึงการสมัครรับข้อมูลและข้อความ QoS 1 หรือ 2 ที่ถูกจัดคิวไว้ เมื่อเชื่อมต่อใหม่ มันเหมือนกับไคลเอนต์ใหม่เอี่ยม
• Persistent Session (clean_session=False): เมื่อไคลเอนต์ที่มี Client ID ที่ไม่ซ้ำกันเชื่อมต่อด้วยวิธีนี้ โบรกเกอร์จะรักษาเซสชันของมันไว้หลังจากที่ตัดการเชื่อมต่อ รวมถึงการสมัครรับข้อมูลและข้อความ QoS 1 หรือ 2 ที่ถูกเผยแพร่ขณะที่มันออฟไลน์ เมื่อไคลเอนต์เชื่อมต่อใหม่ โบรกเกอร์จะส่งข้อความที่พลาดไปทั้งหมด สิ่งนี้จำเป็นอย่างยิ่งสำหรับอุปกรณ์บนเครือข่ายที่ไม่น่าเชื่อถือซึ่งไม่สามารถยอมเสียคำสั่งที่สำคัญได้

ในการสร้าง Persistent Session คุณต้องระบุ Client ID ที่เสถียรและไม่ซ้ำกัน และตั้งค่า `clean_session=False` เมื่อสร้างอินสแตนซ์ไคลเอนต์:

client = mqtt.Client(client_id="my-persistent-device-001", clean_session=False)

ความปลอดภัยไม่ใช่ทางเลือก: การรักษาความปลอดภัย MQTT ด้วย Python

ในการใช้งานจริงทุกประเภท ความปลอดภัยเป็นสิ่งสำคัญยิ่ง โบรกเกอร์ MQTT ที่ไม่ปลอดภัยคือคำเชิญเปิดกว้างสำหรับผู้ประสงค์ร้ายในการดักฟังข้อมูลของคุณ ส่งคำสั่งปลอมไปยังอุปกรณ์ของคุณ หรือโจมตีแบบปฏิเสธการให้บริการ (denial-of-service) การรักษาความปลอดภัย MQTT เกี่ยวข้องกับเสาหลักที่สำคัญสามประการ: การยืนยันตัวตน (Authentication), การเข้ารหัส (Encryption) และการอนุญาต (Authorization)

การยืนยันตัวตน: คุณคือใคร?

การยืนยันตัวตนจะตรวจสอบตัวตนของไคลเอนต์ที่เชื่อมต่อกับโบรกเกอร์ วิธีที่ง่ายที่สุดคือการใช้ชื่อผู้ใช้และรหัสผ่าน คุณสามารถกำหนดค่าโบรกเกอร์ Mosquitto ของคุณให้ต้องการข้อมูลประจำตัวและจากนั้นระบุข้อมูลเหล่านั้นในไคลเอนต์ Python ของคุณ

ในไคลเอนต์ Python ของคุณ ให้ใช้เมธอด `username_pw_set()`:

client.username_pw_set(username="myuser", password="mypassword")

client.connect(BROKER_ADDRESS, PORT, 60)

การเข้ารหัส: การปกป้องข้อมูลระหว่างการส่งด้วย TLS/SSL

ชื่อผู้ใช้และรหัสผ่านแทบไม่มีประโยชน์หากส่งเป็นข้อความธรรมดาผ่านเครือข่าย การเข้ารหัสจะรับประกันว่าการสื่อสารทั้งหมดระหว่างไคลเอนต์และโบรกเกอร์จะถูกทำให้สับสนและไม่สามารถอ่านได้โดยผู้ที่ดักฟังเครือข่าย สิ่งนี้ทำได้โดยใช้ Transport Layer Security (TLS) เทคโนโลยีเดียวกันที่ทำให้เว็บไซต์ปลอดภัย (HTTPS)

ในการใช้ TLS กับ MQTT (ซึ่งมักเรียกว่า MQTTS) คุณต้องกำหนดค่าโบรกเกอร์ของคุณให้รองรับ (โดยปกติคือพอร์ต 8883) และจัดเตรียมใบรับรองที่จำเป็นให้กับไคลเอนต์ของคุณ ซึ่งโดยทั่วไปจะเกี่ยวข้องกับใบรับรอง Certificate Authority (CA) เพื่อตรวจสอบตัวตนของโบรกเกอร์

ใน Paho-MQTT คุณใช้เมธอด `tls_set()`:

client.tls_set(ca_certs="path/to/ca.crt")

client.connect(BROKER_ADDRESS, 8883, 60)

การอนุญาต: คุณได้รับอนุญาตให้ทำอะไร?

เมื่อไคลเอนต์ได้รับการยืนยันตัวตนแล้ว การอนุญาตจะกำหนดว่าไคลเอนต์ได้รับอนุญาตให้ทำอะไร ตัวอย่างเช่น เซ็นเซอร์วัดอุณหภูมิควรได้รับอนุญาตให้เผยแพร่เฉพาะหัวข้อของตนเองเท่านั้น (เช่น `sensors/temp-A/data`) แต่ไม่ใช่ไปยังหัวข้อที่ใช้ควบคุมเครื่องจักรของโรงงาน (เช่น `factory/floor-1/robot-arm/command`) โดยทั่วไปแล้วสิ่งนี้จะถูกจัดการบนโบรกเกอร์โดยใช้ Access Control Lists (ACLs) คุณกำหนดค่าโบรกเกอร์ด้วยกฎที่กำหนดว่าผู้ใช้คนใดสามารถ `อ่าน` (subscribe) หรือ `เขียน` (publish) ไปยังรูปแบบหัวข้อเฉพาะได้

นำทุกอย่างมารวมกัน: โปรเจกต์ตรวจสอบสภาพแวดล้อมอัจฉริยะอย่างง่าย

เรามาสร้างโปรเจกต์ที่สมจริงขึ้นเล็กน้อยเพื่อเสริมแนวคิดเหล่านี้ เราจะจำลองอุปกรณ์เซ็นเซอร์ที่เผยแพร่ข้อมูลสิ่งแวดล้อมเป็นอ็อบเจกต์ JSON และแอปพลิเคชันตรวจสอบที่สมัครรับข้อมูลไปยังข้อมูลนี้และแสดงผล

ภาพรวมโปรเจกต์

• เซ็นเซอร์ (Publisher): สคริปต์ Python ที่จำลองการอ่านค่าอุณหภูมิและความชื้น มันจะจัดแพ็กเก็ตข้อมูลนี้เป็นเพย์โหลด JSON และเผยแพร่ไปยังหัวข้อ `smart_env/device01/telemetry` ทุกๆ 5 วินาที
• ตัวตรวจสอบ (Subscriber): สคริปต์ Python ที่สมัครรับข้อมูล `smart_env/device01/telemetry` รับข้อมูล JSON แยกวิเคราะห์ และพิมพ์การอัปเดตสถานะที่เป็นมิตรต่อผู้ใช้

โค้ดเซ็นเซอร์ (sensor_publisher.py)

import paho.mqtt.client as mqtt

import time

import json

import random

BROKER_ADDRESS = "localhost"

PORT = 1883

TOPIC = "smart_env/device01/telemetry"

client = mqtt.Client("SensorDevice01")

client.connect(BROKER_ADDRESS, PORT, 60)

client.loop_start()

print("Sensor publisher started...")

try:

while True:

# จำลองการอ่านค่าเซ็นเซอร์

temperature = round(random.uniform(20.0, 30.0), 2)

humidity = round(random.uniform(40.0, 60.0), 2)

# สร้างเพย์โหลด JSON

payload = {

"timestamp": time.time(),

"temperature": temperature,

"humidity": humidity

}

payload_str = json.dumps(payload)

# เผยแพร่ข้อความด้วย QoS 1

result = client.publish(TOPIC, payload_str, qos=1)

result.wait_for_publish() # รอจนกว่าการเผยแพร่จะได้รับการยืนยัน

print(f"Published: {payload_str}")

time.sleep(5)

except KeyboardInterrupt:

print("Stopping sensor publisher...")

finally:

client.loop_stop()

client.disconnect()

โค้ดแดชบอร์ดตรวจสอบ (monitor_subscriber.py)

import paho.mqtt.client as mqtt

import json

import datetime

BROKER_ADDRESS = "localhost"

PORT = 1883

TOPIC = "smart_env/device01/telemetry"

def on_connect(client, userdata, flags, rc):

print(f"Connected with result code {rc}")

client.subscribe(TOPIC)

def on_message(client, userdata, msg):

print("--- New Message Received ---")

try:

# ถอดรหัสสตริงเพย์โหลดและแยกวิเคราะห์เป็น JSON

payload = json.loads(msg.payload.decode())

timestamp = datetime.datetime.fromtimestamp(payload.get('timestamp'))

temperature = payload.get('temperature')

humidity = payload.get('humidity')

print(f"Device: {msg.topic}")

print(f"Time: {timestamp.strftime('%Y-%m-%d %H:%M:%S')}")

print(f"Temperature: {temperature}°C")

print(f"Humidity: {humidity}%")

except json.JSONDecodeError:

print("Error decoding JSON payload.")

except Exception as e:

print(f"An error occurred: {e}")

client = mqtt.Client("MonitoringDashboard")

client.on_connect = on_connect

client.on_message = on_message

client.connect(BROKER_ADDRESS, PORT, 60)

print("Monitoring dashboard is running...")

client.loop_forever()

จากต้นแบบสู่การใช้งานจริง: แนวทางปฏิบัติที่ดีที่สุดของ MQTT

การย้ายโปรเจกต์ของคุณจากสคริปต์อย่างง่ายไปสู่ระบบการผลิตที่แข็งแกร่งและปรับขนาดได้นั้นต้องอาศัยการวางแผนอย่างรอบคอบ นี่คือแนวทางปฏิบัติที่ดีที่สุดที่จำเป็น:

• ออกแบบลำดับชั้นหัวข้อที่ชัดเจน: วางแผนโครงสร้างหัวข้อของคุณอย่างระมัดระวังตั้งแต่เริ่มต้น ลำดับชั้นที่ดีมีความชัดเจน ปรับขนาดได้ และอนุญาตให้สมัครรับข้อมูลได้อย่างยืดหยุ่นโดยใช้ wildcards รูปแบบทั่วไปคือ <site>/<area>/<device_type>/<device_id>/<measurement>
• จัดการการตัดการเชื่อมต่อเครือข่ายอย่างสง่างาม: เครือข่ายไม่น่าเชื่อถือ รหัสไคลเอนต์ของคุณควรมีการดำเนินการเชื่อมต่อใหม่ที่แข็งแกร่ง Callback `on_disconnect` ใน Paho-MQTT เป็นจุดเริ่มต้นที่สมบูรณ์แบบ โดยใช้กลยุทธ์เช่น exponential backoff เพื่อหลีกเลี่ยงการทำให้เครือข่ายเต็มไปด้วยความพยายามในการเชื่อมต่อใหม่
• ใช้เพย์โหลดข้อมูลที่มีโครงสร้าง: ใช้รูปแบบข้อมูลที่มีโครงสร้างเสมอ เช่น JSON หรือ Protocol Buffers สำหรับเพย์โหลดข้อความของคุณ สิ่งนี้ทำให้ข้อมูลของคุณอธิบายตัวเองได้ สามารถจัดการเวอร์ชันได้ และง่ายสำหรับแอปพลิเคชันต่างๆ (ที่เขียนด้วยภาษาใดก็ได้) ในการแยกวิเคราะห์
• รักษาความปลอดภัยทุกอย่างโดยค่าเริ่มต้น: อย่าติดตั้งระบบ IoT โดยไม่มีความปลอดภัย อย่างน้อยที่สุด ให้ใช้การยืนยันตัวตนด้วยชื่อผู้ใช้/รหัสผ่านและการเข้ารหัส TLS สำหรับความต้องการด้านความปลอดภัยที่สูงขึ้น ให้สำรวจการยืนยันตัวตนแบบใบรับรองไคลเอนต์
• ตรวจสอบโบรกเกอร์ของคุณ: ในสภาพแวดล้อมการผลิต โบรกเกอร์ MQTT ของคุณเป็นส่วนสำคัญของโครงสร้างพื้นฐาน ใช้เครื่องมือตรวจสอบเพื่อติดตามสุขภาพ รวมถึงการใช้งาน CPU/หน่วยความจำ จำนวนไคลเอนต์ที่เชื่อมต่อ อัตราข้อความ และข้อความที่ถูกทิ้ง โบรกเกอร์หลายแห่งมีลำดับชั้นหัวข้อ `$SYS` พิเศษที่ให้ข้อมูลสถานะนี้

สรุป: การเดินทางของคุณกับ Python และ MQTT

เราได้เดินทางตั้งแต่ "ทำไม" พื้นฐานของ MQTT ไปจนถึง "อย่างไร" ที่ใช้งานได้จริงในการนำไปใช้ คุณได้เรียนรู้เกี่ยวกับพลังของโมเดล publish/subscribe ความสำคัญของ QoS และบทบาทที่สำคัญของความปลอดภัย คุณได้เห็นว่าไลบรารี Paho-MQTT ทำให้การสร้างไคลเอนต์ที่ซับซ้อนซึ่งสามารถเผยแพร่ข้อมูลเซ็นเซอร์และสมัครรับคำสั่งได้อย่างง่ายดายเพียงใด

MQTT เป็นมากกว่าแค่โปรโตคอล แต่เป็นเทคโนโลยีพื้นฐานสำหรับ Internet of Things ลักษณะน้ำหนักเบาและคุณสมบัติที่แข็งแกร่งทำให้เป็นตัวเลือกที่ได้รับความนิยมสำหรับอุปกรณ์หลายล้านเครื่องทั่วโลก ตั้งแต่เมืองอัจฉริยะไปจนถึงการเกษตรที่เชื่อมต่อและระบบอัตโนมัติในอุตสาหกรรม

การเดินทางไม่ได้สิ้นสุดที่นี่ ขั้นตอนต่อไปคือการนำแนวคิดเหล่านี้ไปใช้กับฮาร์ดแวร์จริง ทดลองใช้ Raspberry Pi, ESP32 หรือไมโครคอนโทรลเลอร์อื่นๆ เชื่อมต่อเซ็นเซอร์จริง ผสานรวมกับแพลตฟอร์ม IoT บนคลาวด์ และสร้างแอปพลิเคชันที่โต้ตอบกับโลกทางกายภาพ ด้วย Python และ MQTT คุณมีชุดเครื่องมืออันทรงพลังในการสร้างโซลูชันที่เชื่อมต่อในยุคต่อไป