IoT-യ്‌ക്കായുള്ള പൈത്തൺ: MQTT നടപ്പാക്കലിനായുള്ള ഒരു സമഗ്ര ഗൈഡ്

ബന്ധിത ലോകം: എന്തുകൊണ്ടാണ് IoT പ്രോട്ടോക്കോളുകൾക്ക് പ്രാധാന്യം?

അഭൂതപൂർവമായ കണക്റ്റിവിറ്റിയുടെ കാലഘട്ടത്തിലാണ് നമ്മൾ ജീവിക്കുന്നത്. ഇന്റർനെറ്റ് ഓഫ് തിങ്സ് (IoT) ഇനി ഒരു ഭാവനാത്മക ആശയം മാത്രമല്ല; അത് ഒരു ആഗോള യാഥാർത്ഥ്യമാണ്. നമ്മുടെ പരിസ്ഥിതിയെ നിരീക്ഷിക്കുകയും വീടുകൾ ഓട്ടോമേറ്റ് ചെയ്യുകയും വ്യവസായങ്ങളെ ഒപ്റ്റിമൈസ് ചെയ്യുകയും നഗരങ്ങളെ കാര്യക്ഷമമാക്കുകയും ചെയ്യുന്ന കോടിക്കണക്കിന് സ്മാർട്ട് ഉപകരണങ്ങളുടെ ഒരു ശൃംഖല ഇത് നിശ്ശബ്ദമായി നെയ്തെടുക്കുന്നു. സോളിലെ ഒരു വീട്ടിലെ സ്മാർട്ട് തെർമോസ്റ്റാറ്റ് മുതൽ കെനിയയിലെ ഗ്രാമപ്രദേശങ്ങളിലെ ഒരു വയലിലെ കാർഷിക സെൻസർ വരെ, ഈ ഉപകരണങ്ങൾ വൻതോതിൽ ഡാറ്റ ഉൽപ്പാദിപ്പിക്കുന്നു. എന്നാൽ അവയെല്ലാം എങ്ങനെ പരസ്പരം സംസാരിക്കുന്നു, ക്ലൗഡുമായി എങ്ങനെ ബന്ധപ്പെടുന്നു, പ്രത്യേകിച്ചും അവ പലപ്പോഴും ചെറുതും കുറഞ്ഞ പവറിൽ പ്രവർത്തിക്കുന്നതും വിശ്വസനീയമല്ലാത്ത നെറ്റ്‌വർക്കുകളിൽ പ്രവർത്തിക്കുന്നതുമാകുമ്പോൾ? പ്രത്യേക ആശയവിനിമയ പ്രോട്ടോക്കോളുകളിലാണ് ഇതിനുള്ള ഉത്തരം.

നമ്മൾ ദിവസവും ഉപയോഗിക്കുന്ന വെബിന്റെ ഭൂരിഭാഗവും HTTP പ്രോട്ടോക്കോൾ ഉപയോഗിച്ച് പ്രവർത്തിക്കുമ്പോൾ, IoT-യുടെ പരിമിതമായ ലോകത്തിന് ഇത് പലപ്പോഴും ഭാരമേറിയതും കൂടുതൽ വൈദ്യുതി ആവശ്യമുള്ളതുമാണ്. മെഷീൻ-ടു-മെഷീൻ (M2M) ആശയവിനിമയത്തിനായി പ്രത്യേകം രൂപകൽപ്പന ചെയ്ത പ്രോട്ടോക്കോളുകളാണ് ഇവിടെ പ്രധാനമാകുന്നത്. അവയിൽ, ഒന്ന് ഒരു പ്രബല ശക്തിയായി ഉയർന്നിട്ടുണ്ട്: MQTT.

IoT മേഖലയിലെ ഏറ്റവും വൈവിധ്യമാർന്നതും ജനപ്രിയവുമായ പ്രോഗ്രാമിംഗ് ഭാഷകളിൽ ഒന്നായ പൈത്തൺ ഉപയോഗിച്ച് MQTT-യുടെ ശക്തി പ്രയോജനപ്പെടുത്താൻ ആഗ്രഹിക്കുന്ന ലോകമെമ്പാടുമുള്ള ഡെവലപ്പർമാർക്കും എഞ്ചിനീയർമാർക്കും ഹോബിയിസ്റ്റുകൾക്കുമായി ഈ സമഗ്ര ഗൈഡ് രൂപകൽപ്പന ചെയ്തിരിക്കുന്നു. MQTT-യുടെ അടിസ്ഥാന ആശയങ്ങൾ മുതൽ സുരക്ഷിതവും ശക്തവും വികസിപ്പിക്കാവുന്നതുമായ IoT ആപ്ലിക്കേഷനുകൾ നിർമ്മിക്കുന്നത് വരെയുള്ള ഒരു യാത്രയായിരിക്കും ഇത്.

എന്താണ് MQTT? പരിമിതികൾക്കായി നിർമ്മിച്ച ഒരു പ്രോട്ടോക്കോൾ

MQTT എന്നാൽ മെസ്സേജ് ക്യൂയിംഗ് ടെലിമെട്രി ട്രാൻസ്പോർട്ട് എന്നാണ്. വിശ്വസനീയമല്ലാത്ത ഉപഗ്രഹ ശൃംഖലകളിലൂടെ എണ്ണ പൈപ്പ് ലൈനുകൾ നിരീക്ഷിക്കുന്നതിനായി 1999-ൽ IBM-ലെ ഡോ. ആൻഡി സ്റ്റാൻഫോർഡ്-ക്ലാർക്കും ആർകോമിലെ (ഇപ്പോൾ സിറസ് ലിങ്ക്) ആർലെൻ നിപ്പറും ചേർന്നാണ് ഇത് കണ്ടുപിടിച്ചത്. അതിന്റെ ഉത്ഭവ കഥ അതിന്റെ ഉദ്ദേശ്യം പൂർണ്ണമായി ഉൾക്കൊള്ളുന്നു: കാര്യമായ പരിമിതികളിൽ പ്രവർത്തിക്കുന്ന ഉപകരണങ്ങൾക്കായി ഭാരം കുറഞ്ഞതും വിശ്വസനീയവും കാര്യക്ഷമവുമായ ഒരു മെസ്സേജിംഗ് പ്രോട്ടോക്കോൾ ആയിരിക്കുക.

പബ്ലിഷ്/സബ്സ്ക്രൈബ് (Pub/Sub) മോഡൽ വിശദീകരിക്കുന്നു

MQTT-യുടെ ഹൃദയം മനോഹരമായ പബ്ലിഷ്/സബ്സ്ക്രൈബ് ആർക്കിടെക്ചറൽ പാറ്റേൺ ആണ്. ഇത് പല ഡെവലപ്പർമാർക്കും പരിചിതമായ HTTP-യുടെ റിക്വസ്റ്റ്/റെസ്പോൺസ് മോഡലിൽ നിന്നുള്ള ഒരു അടിസ്ഥാന വ്യതിയാനമാണ്. ഒരു ക്ലയന്റ് ഒരു സെർവറിൽ നിന്ന് നേരിട്ട് വിവരങ്ങൾ ആവശ്യപ്പെടുന്നതിന് പകരം, ആശയവിനിമയം ഡീകപ്പിൾ ചെയ്തിരിക്കുന്നു.

ഒരു ആഗോള വാർത്താ ഏജൻസിയെക്കുറിച്ച് സങ്കൽപ്പിക്കുക. പത്രപ്രവർത്തകർ (പ്രസാധകർ) അവരുടെ വാർത്തകൾ ഓരോ വായനക്കാരനും നേരിട്ട് അയയ്ക്കുന്നില്ല. പകരം, അവർ തങ്ങളുടെ വാർത്തകൾ ഏജൻസിയുടെ കേന്ദ്ര ഹബിലേക്ക് (ബ്രോക്കർ) അയയ്ക്കുകയും "ലോക രാഷ്ട്രീയം" അല്ലെങ്കിൽ "സാങ്കേതികവിദ്യ" പോലുള്ള പ്രത്യേക വിഷയങ്ങളിൽ അവയെ തരംതിരിക്കുകയും ചെയ്യുന്നു. വായനക്കാർ (സബ്സ്ക്രൈബർമാർ) പത്രപ്രവർത്തകരോട് അപ്‌ഡേറ്റുകൾ ചോദിക്കേണ്ടതില്ല; അവർക്ക് താൽപ്പര്യമുള്ള വിഷയങ്ങൾ ഏജൻസിയോട് പറഞ്ഞാൽ മതി. ഏജൻസി പിന്നീട് ആ വിഷയങ്ങളിലെ ഏതെങ്കിലും പുതിയ വാർത്തകൾ താൽപ്പര്യമുള്ള വായനക്കാർക്ക് സ്വയമേവ കൈമാറുന്നു. പത്രപ്രവർത്തകർക്കും വായനക്കാർക്കും പരസ്പരം നിലനിൽപ്പോ സ്ഥാനമോ നിലയോ അറിയേണ്ട ആവശ്യമില്ല.

MQTT-യിൽ, ഈ മോഡൽ ഡാറ്റ അയയ്ക്കുന്ന ഉപകരണത്തെ (പ്രസാധകൻ) ഡാറ്റ സ്വീകരിക്കുന്ന ഉപകരണത്തിൽ നിന്നോ ആപ്ലിക്കേഷനിൽ നിന്നോ (സബ്സ്ക്രൈബർ) വേർതിരിക്കുന്നു. ഇത് IoT-ക്ക് അവിശ്വസനീയമാംവിധം ശക്തമാണ്, കാരണം:

• സ്ഥലപരമായ വിഘടനം (Space Decoupling): പ്രസാധകനും സബ്സ്ക്രൈബറിനും പരസ്പരം IP വിലാസമോ സ്ഥലമോ അറിയേണ്ട ആവശ്യമില്ല.
• സമയപരമായ വിഘടനം (Time Decoupling): അവ ഒരേ സമയം പ്രവർത്തിക്കേണ്ടതില്ല. ഒരു സെൻസറിന് ഒരു റീഡിംഗ് പ്രസിദ്ധീകരിക്കാൻ കഴിയും, സിസ്റ്റം അങ്ങനെ രൂപകൽപ്പന ചെയ്തിട്ടുണ്ടെങ്കിൽ ഒരു ആപ്ലിക്കേഷന് മണിക്കൂറുകൾക്ക് ശേഷം അത് സ്വീകരിക്കാൻ കഴിയും.
• സമന്വയ വിഘടനം (Synchronization Decoupling): ഒരു മെസ്സേജ് കൈമാറ്റം പൂർത്തിയാക്കാൻ മറ്റേയാൾക്കായി കാത്തിരിക്കാൻ ഇരുവശത്തുമുള്ള പ്രവർത്തനങ്ങൾ നിർത്തേണ്ടതില്ല.

MQTT ഇക്കോസിസ്റ്റത്തിലെ പ്രധാന ഘടകങ്ങൾ

MQTT ആർക്കിടെക്ചർ ചില പ്രധാന ഘടകങ്ങളെ അടിസ്ഥാനമാക്കിയുള്ളതാണ്:

• ബ്രോക്കർ (Broker): കേന്ദ്ര ഹബ് അല്ലെങ്കിൽ സെർവർ. ഇത് MQTT ലോകത്തിലെ തപാൽ ഓഫീസ് ആണ്. പ്രസാധകരിൽ നിന്നുള്ള എല്ലാ സന്ദേശങ്ങളും സ്വീകരിക്കുക, വിഷയം അനുസരിച്ച് അവയെ ഫിൽട്ടർ ചെയ്യുക, ഉചിതമായ വരിക്കാർക്ക് അയയ്ക്കുക എന്നിവയുടെ ഉത്തരവാദിത്തം ബ്രോക്കർക്കാണ്. മോസ്കിറ്റോ (Mosquitto), വെർനെഎംക്യു (VerneMQ) പോലുള്ള ഓപ്പൺ സോഴ്സ് ഓപ്ഷനുകളും AWS IoT കോർ, അസൂർ IoT ഹബ്, Google ക്ലൗഡ് IoT കോർ പോലുള്ള ക്ലൗഡ് സേവനങ്ങളും ജനപ്രിയ ബ്രോക്കറുകളിൽ ഉൾപ്പെടുന്നു.
• ക്ലയന്റ് (Client): ബ്രോക്കറുമായി ബന്ധിപ്പിക്കുന്ന ഏതൊരു ഉപകരണമോ ആപ്ലിക്കേഷനോ. ഒരു ക്ലയന്റ് പ്രസാധകനോ, സബ്സ്ക്രൈബറോ, അല്ലെങ്കിൽ രണ്ടും ആകാം. ഒരു IoT സെൻസർ ഒരു ക്ലയന്റ് ആണ്, സെൻസർ ഡാറ്റ പ്രോസസ്സ് ചെയ്യുന്ന ഒരു സെർവർ ആപ്ലിക്കേഷനും ഒരു ക്ലയന്റ് ആണ്.
• വിഷയം (Topic): സന്ദേശങ്ങൾക്കുള്ള വിലാസമായോ ലേബലായോ പ്രവർത്തിക്കുന്ന ഒരു UTF-8 സ്ട്രിംഗ്. സന്ദേശങ്ങൾ റൂട്ട് ചെയ്യാൻ ബ്രോക്കർ വിഷയങ്ങൾ ഉപയോഗിക്കുന്നു. ഒരു ഫയൽ സിസ്റ്റം പാത്ത് പോലെ ഫോർവേഡ് സ്ലാഷുകൾ ഡിലിമിറ്ററുകളായി ഉപയോഗിച്ച് വിഷയങ്ങൾ ശ്രേണീബദ്ധമാണ്. ഉദാഹരണത്തിന്, ലണ്ടനിലെ ഒരു കെട്ടിടത്തിലെ സ്വീകരണമുറിയിലെ താപനില സെൻസറിനായുള്ള ഒരു നല്ല വിഷയം ഇതായിരിക്കാം: UK/London/Building-A/Floor-1/LivingRoom/Temperature.
• പേലോഡ് (Payload): ഇത് സന്ദേശത്തിന്റെ യഥാർത്ഥ ഡാറ്റാ ഉള്ളടക്കമാണ്. MQTT ഡാറ്റാ-അജ്ഞേയമാണ്, അതായത് പേലോഡ് എന്തും ആകാം: ഒരു ലളിതമായ സ്ട്രിംഗ്, ഒരു പൂർണ്ണസംഖ്യ, JSON, XML, അല്ലെങ്കിൽ എൻക്രിപ്റ്റ് ചെയ്ത ബൈനറി ഡാറ്റ പോലും. അതിന്റെ വഴക്കവും വായിക്കാനുള്ള എളുപ്പവും കാരണം JSON ഒരു സാധാരണ തിരഞ്ഞെടുപ്പാണ്.

MQTT എന്തുകൊണ്ട് IoT ആശയവിനിമയത്തിൽ ആധിപത്യം സ്ഥാപിക്കുന്നു

MQTT-യുടെ രൂപകൽപ്പന തത്വങ്ങൾ IoT-യുടെ വെല്ലുവിളികൾക്ക് ഇത് അസാധാരണമാംവിധം അനുയോജ്യമാക്കുന്നു:

• ഭാരം കുറഞ്ഞത് (Lightweight): MQTT സന്ദേശങ്ങൾക്ക് വളരെ ചെറിയ ഒരു ഹെഡർ (രണ്ട് ബൈറ്റുകൾ മാത്രം) ഉണ്ട്, ഇത് നെറ്റ്‌വർക്ക് ബാൻഡ്‌വിഡ്ത്ത് ഉപയോഗം കുറയ്ക്കുന്നു. ചെലവേറിയ സെല്ലുലാർ പ്ലാനുകളിലോ LoRaWAN പോലുള്ള കുറഞ്ഞ ബാൻഡ്‌വിഡ്ത്ത് നെറ്റ്‌വർക്കുകളിലോ ഉള്ള ഉപകരണങ്ങൾക്ക് ഇത് നിർണായകമാണ്.
• കാര്യക്ഷമമായത് (Efficient): പ്രോട്ടോക്കോളിന്റെ കുറഞ്ഞ ഓവർഹെഡ് കുറഞ്ഞ വൈദ്യുതി ഉപഭോഗത്തിലേക്ക് നേരിട്ട് നയിക്കുന്നു, ഇത് ബാറ്ററിയിൽ പ്രവർത്തിക്കുന്ന ഉപകരണങ്ങൾക്ക് മാസങ്ങളോ വർഷങ്ങളോ പ്രവർത്തിക്കാൻ അനുവദിക്കുന്നു.
• വിശ്വസനീയമായത് (Reliable): അസ്ഥിരവും ഉയർന്ന ലേറ്റൻസിയുമുള്ള നെറ്റ്‌വർക്കുകളിൽ പോലും സന്ദേശങ്ങൾ എത്തുന്നുവെന്ന് ഉറപ്പാക്കാൻ ഇതിൽ സവിശേഷതകൾ ഉൾപ്പെടുന്നു. ഇത് ക്വാളിറ്റി ഓഫ് സർവീസ് ലെവലുകൾ വഴി നിയന്ത്രിക്കപ്പെടുന്നു.
• വികസിപ്പിക്കാവുന്നത് (Scalable): ഒരു ബ്രോക്കറിന് ഒരേസമയം ആയിരക്കണക്കിന് അല്ലെങ്കിൽ ദശലക്ഷക്കണക്കിന് ക്ലയന്റുകളിൽ നിന്നുള്ള കണക്ഷനുകൾ കൈകാര്യം ചെയ്യാൻ കഴിയും, ഇത് വലിയ തോതിലുള്ള വിന്യാസങ്ങൾക്ക് അനുയോജ്യമാക്കുന്നു.
• ദ്വിദിശാത്മകമായത് (Bidirectional): MQTT ഉപകരണത്തിൽ നിന്ന് ക്ലൗഡിലേക്കും (ടെലിമെട്രി) ക്ലൗഡിൽ നിന്ന് ഉപകരണത്തിലേക്കും (കമാൻഡുകൾ) ആശയവിനിമയം അനുവദിക്കുന്നു, വിദൂരമായി ഉപകരണങ്ങൾ നിയന്ത്രിക്കുന്നതിന് ഇത് അത്യാവശ്യമായ ഒരു ആവശ്യകതയാണ്.

ക്വാളിറ്റി ഓഫ് സർവീസ് (QoS) മനസ്സിലാക്കുന്നു

ഡെവലപ്പർമാർക്ക് അവരുടെ പ്രത്യേക ഉപയോഗത്തിന് വിശ്വാസ്യതയും ഓവർഹെഡും തമ്മിലുള്ള ശരിയായ സന്തുലിതാവസ്ഥ തിരഞ്ഞെടുക്കാൻ MQTT മൂന്ന് തലത്തിലുള്ള ക്വാളിറ്റി ഓഫ് സർവീസ് (QoS) നൽകുന്നു.

• QoS 0 (ഏകദേശം ഒരു തവണ): ഇത് ഒരു "അയച്ച് മറക്കുക" നിലവാരമാണ്. ബ്രോക്കറിൽ നിന്നോ അന്തിമ സബ്സ്ക്രൈബറിൽ നിന്നോ ലഭിച്ചതായി സ്ഥിരീകരണമില്ലാതെ സന്ദേശം ഒരു തവണ അയയ്ക്കുന്നു. ഇത് ഏറ്റവും വേഗതയേറിയ രീതിയാണ്, പക്ഷേ ഡെലിവറിക്ക് യാതൊരു ഉറപ്പുമില്ല. ഉപയോഗം: പ്രധാനമല്ലാത്ത, ഉയർന്ന ആവൃത്തിയിലുള്ള സെൻസർ ഡാറ്റ, ഉദാഹരണത്തിന്, ഓരോ 10 സെക്കൻഡിലും അയയ്ക്കുന്ന ഒരു മുറിയിലെ അന്തരീക്ഷ താപനില റീഡിംഗ്. ഒരു റീഡിംഗ് നഷ്ടപ്പെടുന്നത് ഒരു പ്രശ്നമല്ല.
• QoS 1 (കുറഞ്ഞത് ഒരു തവണ): സന്ദേശം കുറഞ്ഞത് ഒരു തവണയെങ്കിലും എത്തുമെന്ന് ഈ നില ഉറപ്പ് നൽകുന്നു. സ്വീകർത്താവിൽ നിന്ന് ഒരു അംഗീകാരം (ഒരു PUBACK പാക്കറ്റ്) ലഭിക്കുന്നതുവരെ അയച്ചയാൾ സന്ദേശം സംഭരിക്കുന്നു. അംഗീകാരം ലഭിച്ചില്ലെങ്കിൽ, സന്ദേശം വീണ്ടും അയയ്ക്കുന്നു. അംഗീകാരം നഷ്ടപ്പെട്ടാൽ ഇത് ചിലപ്പോൾ സന്ദേശങ്ങൾ തനിപ്പകർപ്പായി മാറുന്നതിന് കാരണമായേക്കാം. ഉപയോഗം: ഒരു സ്മാർട്ട് ലൈറ്റ് ഓൺ ചെയ്യാനുള്ള കമാൻഡ്. കമാൻഡ് ലഭിച്ചുവെന്ന് ഉറപ്പാക്കേണ്ടതുണ്ട്, അത് രണ്ടുതവണ ലഭിക്കുന്നത് ദോഷകരമല്ല.
• QoS 2 (കൃത്യമായി ഒരു തവണ): ഇത് ഏറ്റവും വിശ്വസനീയമായതും എന്നാൽ ഏറ്റവും വേഗത കുറഞ്ഞതുമായ നിലവാരമാണ്. സന്ദേശം കൃത്യമായി ഒരു തവണയും തനിപ്പകർപ്പുകളില്ലാതെയും എത്തുന്നുവെന്ന് ഉറപ്പാക്കാൻ ഇത് നാല് ഭാഗങ്ങളുള്ള ഒരു ഹാൻഡ്‌ഷേക്ക് ഉപയോഗിക്കുന്നു. ഉപയോഗം: സാമ്പത്തിക ഇടപാടുകൾ, മരുന്നിന്റെ കൃത്യമായ അളവ് നൽകാനുള്ള കമാൻഡ്, അല്ലെങ്കിൽ ഒരു ഫാക്ടറിയിലെ റോബോട്ടിക് ആം നിയന്ത്രിക്കുന്നത് പോലുള്ള, തനിപ്പകർപ്പുകൾ വിനാശകരമാകുന്ന നിർണായക പ്രവർത്തനങ്ങൾ.

നിങ്ങളുടെ പൈത്തൺ MQTT എൻവയോൺമെന്റ് സജ്ജീകരിക്കുന്നു

ഇപ്പോൾ, നമുക്ക് പ്രായോഗിക കാര്യങ്ങളിലേക്ക് കടക്കാം. പൈത്തൺ ഉപയോഗിച്ച് MQTT ആപ്ലിക്കേഷനുകൾ നിർമ്മിക്കാൻ തുടങ്ങുന്നതിന്, നിങ്ങൾക്ക് രണ്ട് കാര്യങ്ങൾ ആവശ്യമാണ്: MQTT ക്ലയന്റിനായുള്ള ഒരു പൈത്തൺ ലൈബ്രറിയും ആശയവിനിമയം നടത്താൻ ഒരു MQTT ബ്രോക്കറും.

ഒരു പൈത്തൺ MQTT ലൈബ്രറി തിരഞ്ഞെടുക്കുന്നു: Paho-MQTT

പൈത്തണിനായുള്ള ഏറ്റവും വ്യാപകമായി ഉപയോഗിക്കുന്നതും പക്വതയുള്ളതുമായ MQTT ലൈബ്രറി എക്ലിപ്സ് ഫൗണ്ടേഷന്റെ Paho-MQTT ആണ്. ഒരു ബ്രോക്കറുമായി ബന്ധിപ്പിക്കുന്നതിനും വിഷയങ്ങൾ പ്രസിദ്ധീകരിക്കുന്നതിനും സബ്സ്ക്രൈബ് ചെയ്യുന്നതിനും ഒരു ക്ലയന്റ് ക്ലാസ് നൽകുന്ന ശക്തവും ഫീച്ചർ സമ്പന്നവുമായ ഒരു ലൈബ്രറിയാണിത്. പൈത്തണിന്റെ പാക്കേജ് മാനേജരായ pip ഉപയോഗിച്ച് ഇത് ഇൻസ്റ്റാൾ ചെയ്യുന്നത് വളരെ ലളിതമാണ്.

നിങ്ങളുടെ ടെർമിനലോ കമാൻഡ് പ്രോംപ്റ്റോ തുറന്ന് പ്രവർത്തിപ്പിക്കുക:

pip install paho-mqtt

ഈ ഒറ്റ കമാൻഡ് പൈത്തണിൽ MQTT ക്ലയന്റുകൾ എഴുതാൻ ആവശ്യമായതെല്ലാം ഇൻസ്റ്റാൾ ചെയ്യുന്നു.

ഒരു MQTT ബ്രോക്കർ സജ്ജീകരിക്കുന്നു

ഒരു ബ്രോക്കറിനായി നിങ്ങൾക്ക് നിരവധി ഓപ്ഷനുകൾ ഉണ്ട്, നിങ്ങളുടെ ലോക്കൽ മെഷീനിൽ വികസിപ്പിക്കുന്നതിന് ഒന്ന് പ്രവർത്തിപ്പിക്കുന്നത് മുതൽ ഉൽപ്പാദനത്തിനായി ഒരു ശക്തമായ ക്ലൗഡ് സേവനം ഉപയോഗിക്കുന്നത് വരെ.

• ലോക്കൽ ബ്രോക്കർ (വികസനത്തിനും പഠനത്തിനും): ഒരു ലോക്കൽ ബ്രോക്കറിനായുള്ള ഏറ്റവും ജനപ്രിയമായ തിരഞ്ഞെടുപ്പ് മോസ്കിറ്റോ (Mosquitto) ആണ്, ഇത് മറ്റൊരു എക്ലിപ്സ് പ്രോജക്റ്റാണ്. ഇത് ഭാരം കുറഞ്ഞതും ഓപ്പൺ സോഴ്സും ഇൻസ്റ്റാൾ ചെയ്യാൻ എളുപ്പവുമാണ്.
  • ഡെബിയൻ അടിസ്ഥാനമാക്കിയുള്ള ലിനക്സിൽ (ഉബുണ്ടു, റാസ്ബെറി പൈ OS പോലുള്ളവ): sudo apt-get update && sudo apt-get install mosquitto mosquitto-clients
  • macOS-ൽ (Homebrew ഉപയോഗിച്ച്): brew install mosquitto
  • വിൻഡോസിൽ: മോസ്കിറ്റോ വെബ്സൈറ്റിൽ നിന്ന് നേറ്റീവ് ഇൻസ്റ്റാളർ ഡൗൺലോഡ് ചെയ്യുക.
  ഇൻസ്റ്റാൾ ചെയ്തുകഴിഞ്ഞാൽ, ബ്രോക്കർ സാധാരണയായി ഒരു സേവനമായി സ്വയമേവ ആരംഭിക്കുന്നു. നിങ്ങളുടെ ക്ലയന്റുകളെ നിങ്ങളുടെ ലോക്കൽ IP വിലാസത്തിലേക്ക് (127.0.0.1 അല്ലെങ്കിൽ localhost) നയിച്ച് ഇത് ഉപയോഗിക്കാം.
• പബ്ലിക്/ക്ലൗഡ് ബ്രോക്കർ (വേഗത്തിലുള്ള പരിശോധനയ്ക്ക്): ഒന്നും ഇൻസ്റ്റാൾ ചെയ്യാതെ ആദ്യകാല പരീക്ഷണങ്ങൾക്കായി, നിങ്ങൾക്ക് ഒരു സൗജന്യ, പൊതു ബ്രോക്കർ ഉപയോഗിക്കാം. test.mosquitto.org, broker.hivemq.com എന്നിവയാണ് ജനപ്രിയമായ രണ്ടെണ്ണം. പ്രധാനപ്പെട്ടത്: ഇവ പൊതുവായതും എൻക്രിപ്റ്റ് ചെയ്യാത്തതുമാണ്. അവയിലേക്ക് സെൻസിറ്റീവായതോ സ്വകാര്യമായതോ ആയ ഡാറ്റ അയയ്ക്കരുത്. അവ പഠനത്തിനും പരിശോധനയ്ക്കും മാത്രമുള്ളതാണ്.

പ്രായോഗിക പരിശീലനം: പൈത്തൺ ഉപയോഗിച്ച് പബ്ലിഷിംഗും സബ്സ്ക്രൈബിംഗും

നമുക്ക് നമ്മുടെ ആദ്യത്തെ പൈത്തൺ MQTT ആപ്ലിക്കേഷൻ എഴുതാം. സന്ദേശങ്ങൾ അയയ്ക്കുന്ന ഒരു പ്രസാധകനും അവ സ്വീകരിക്കുന്ന ഒരു സബ്സ്ക്രൈബറും എന്നിങ്ങനെ രണ്ട് സ്ക്രിപ്റ്റുകൾ നമ്മൾ ഉണ്ടാക്കും. ഈ ഉദാഹരണത്തിനായി, നിങ്ങൾ ഒരു ലോക്കൽ മോസ്കിറ്റോ ബ്രോക്കർ പ്രവർത്തിപ്പിക്കുന്നു എന്ന് നമ്മൾ അനുമാനിക്കുന്നു.

ഒരു ലളിതമായ 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"

# --- കണക്ഷനായുള്ള കോൾബാക്ക് ---

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

if rc == 0:

print("MQTT ബ്രോക്കറുമായി ബന്ധിപ്പിച്ചു!")

else:

print(f"ബന്ധിപ്പിക്കുന്നതിൽ പരാജയപ്പെട്ടു, റിട്ടേൺ കോഡ് {rc}")

# --- പ്രധാന സ്ക്രിപ്റ്റ് ---

# 1. ഒരു ക്ലയന്റ് ഇൻസ്റ്റൻസ് ഉണ്ടാക്കുക

client = mqtt.Client("PublisherClient")

# 2. on_connect കോൾബാക്ക് നൽകുക

client.on_connect = on_connect

# 3. ബ്രോക്കറുമായി ബന്ധിപ്പിക്കുക

client.connect(BROKER_ADDRESS, PORT, 60)

# 4. നെറ്റ്‌വർക്ക് ലൂപ്പിനായി ഒരു ബാക്ക്ഗ്രൗണ്ട് ത്രെഡ് ആരംഭിക്കുക

client.loop_start()

try:

count = 0

while True:

count += 1

message = f"ഹലോ, MQTT! സന്ദേശം #{count}"

# 5. ഒരു സന്ദേശം പ്രസിദ്ധീകരിക്കുക

result = client.publish(TOPIC, message)

# പ്രസിദ്ധീകരണം വിജയകരമായിരുന്നോ എന്ന് പരിശോധിക്കുക

status = result[0]

if status == 0:

print(f"`{message}` എന്ന സന്ദേശം `{TOPIC}` വിഷയത്തിലേക്ക് അയച്ചു")

else:

print(f"{TOPIC} എന്ന വിഷയത്തിലേക്ക് സന്ദേശം അയയ്ക്കുന്നതിൽ പരാജയപ്പെട്ടു")

time.sleep(2)

except KeyboardInterrupt:

print("പ്രസിദ്ധീകരണം നിർത്തി.")

finally:

# 6. നെറ്റ്‌വർക്ക് ലൂപ്പ് നിർത്തി വിച്ഛേദിക്കുക

client.loop_stop()

client.disconnect()

print("ബ്രോക്കറിൽ നിന്ന് വിച്ഛേദിച്ചു.")

ഒരു ലളിതമായ MQTT സബ്സ്ക്രൈബറെ നിർമ്മിക്കുന്നു (subscriber.py)

ഈ സ്ക്രിപ്റ്റ് അതേ ബ്രോക്കറുമായി ബന്ധിപ്പിക്കുകയും `python/mqtt/test` എന്ന വിഷയത്തിലേക്ക് സബ്സ്ക്രൈബ് ചെയ്യുകയും അത് ലഭിക്കുന്ന ഏതൊരു സന്ദേശങ്ങളും പ്രിന്റ് ചെയ്യുകയും ചെയ്യും.

subscriber.py എന്ന പേരിൽ മറ്റൊരു ഫയൽ ഉണ്ടാക്കുക:

import paho.mqtt.client as mqtt

# --- കോൺഫിഗറേഷൻ ---

BROKER_ADDRESS = "localhost"

PORT = 1883

TOPIC = "python/mqtt/test"

# --- കോൾബാക്ക് ഫംഗ്ഷനുകൾ ---

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

if rc == 0:

print("MQTT ബ്രോക്കറുമായി ബന്ധിപ്പിച്ചു!")

# വിജയകരമായ കണക്ഷനിൽ വിഷയത്തിലേക്ക് സബ്സ്ക്രൈബ് ചെയ്യുക

client.subscribe(TOPIC)

else:

print(f"ബന്ധിപ്പിക്കുന്നതിൽ പരാജയപ്പെട്ടു, റിട്ടേൺ കോഡ് {rc}")

def on_message(client, userdata, msg):

# സന്ദേശ പേലോഡ് ബൈറ്റുകളിൽ നിന്ന് സ്ട്രിംഗിലേക്ക് ഡീകോഡ് ചെയ്യുക

payload = msg.payload.decode()

print(f"സന്ദേശം ലഭിച്ചു: `{payload}` `{msg.topic}` എന്ന വിഷയത്തിൽ")

# --- പ്രധാന സ്ക്രിപ്റ്റ് ---

# 1. ഒരു ക്ലയന്റ് ഇൻസ്റ്റൻസ് ഉണ്ടാക്കുക

client = mqtt.Client("SubscriberClient")

# 2. കോൾബാക്കുകൾ നൽകുക

client.on_connect = on_connect

client.on_message = on_message

# 3. ബ്രോക്കറുമായി ബന്ധിപ്പിക്കുക

client.connect(BROKER_ADDRESS, PORT, 60)

# 4. നെറ്റ്‌വർക്ക് ലൂപ്പ് ആരംഭിക്കുക (തടസ്സപ്പെടുത്തുന്ന കോൾ)

# ഈ ഫംഗ്ഷൻ സ്വയമേവ റീകണക്റ്റിംഗും സന്ദേശങ്ങൾ പ്രോസസ്സ് ചെയ്യുന്നതും കൈകാര്യം ചെയ്യുന്നു.

print("സബ്സ്ക്രൈബർ ശ്രദ്ധിച്ചുകൊണ്ടിരിക്കുന്നു...")

client.loop_forever()

ഉദാഹരണം പ്രവർത്തിപ്പിക്കുന്നു

1. രണ്ട് വ്യത്യസ്ത ടെർമിനൽ വിൻഡോകൾ തുറക്കുക.
2. ആദ്യത്തെ ടെർമിനലിൽ, സബ്സ്ക്രൈബർ സ്ക്രിപ്റ്റ് പ്രവർത്തിപ്പിക്കുക: python subscriber.py
3. "സബ്സ്ക്രൈബർ ശ്രദ്ധിച്ചുകൊണ്ടിരിക്കുന്നു..." എന്ന സന്ദേശം നിങ്ങൾ കാണണം. ഇത് ഇപ്പോൾ സന്ദേശങ്ങൾക്കായി കാത്തിരിക്കുകയാണ്.
4. രണ്ടാമത്തെ ടെർമിനലിൽ, പബ്ലിഷർ സ്ക്രിപ്റ്റ് പ്രവർത്തിപ്പിക്കുക: python publisher.py
5. ഓരോ രണ്ട് സെക്കൻഡിലും പബ്ലിഷർ സന്ദേശങ്ങൾ അയയ്ക്കുന്നത് നിങ്ങൾ കാണും. അതേ സമയം, ഈ സന്ദേശങ്ങൾ സബ്സ്ക്രൈബറുടെ ടെർമിനൽ വിൻഡോയിൽ പ്രത്യക്ഷപ്പെടും.

അഭിനന്ദനങ്ങൾ! നിങ്ങൾ ഇപ്പോൾ പൈത്തൺ ഉപയോഗിച്ച് പൂർണ്ണവും പ്രവർത്തനക്ഷമവുമായ ഒരു MQTT ആശയവിനിമയ സംവിധാനം സൃഷ്ടിച്ചു.

അടിസ്ഥാന കാര്യങ്ങൾക്കപ്പുറം: വിപുലമായ Paho-MQTT സവിശേഷതകൾ

യഥാർത്ഥ ലോകത്തിലെ IoT സിസ്റ്റങ്ങൾക്ക് നമ്മുടെ ലളിതമായ ഉദാഹരണത്തേക്കാൾ കൂടുതൽ കരുത്ത് ആവശ്യമാണ്. പ്രൊഡക്ഷൻ-റെഡി ആപ്ലിക്കേഷനുകൾ നിർമ്മിക്കുന്നതിന് അത്യാവശ്യമായ ചില വിപുലമായ MQTT സവിശേഷതകൾ നമുക്ക് പരിശോധിക്കാം.

അവസാന വിൽപ്പത്രവും വാഗ്ദാനവും (Last Will and Testament - LWT)

ഒരു സുരക്ഷാ ക്യാമറയോ ഹൃദയമിടിപ്പ് നിരീക്ഷിക്കുന്ന ഉപകരണമോ പോലുള്ള ഒരു നിർണായക ഉപകരണം വൈദ്യുതി തകരാർ കാരണമോ നെറ്റ്‌വർക്ക് നഷ്ടം കാരണമോ അപ്രതീക്ഷിതമായി വിച്ഛേദിക്കപ്പെട്ടാൽ എന്ത് സംഭവിക്കും? LWT സവിശേഷതയാണ് MQTT-യുടെ പരിഹാരം. ഒരു ക്ലയന്റ് കണക്റ്റുചെയ്യുമ്പോൾ, ബ്രോക്കറുമായി ഒരു "അവസാന വിൽപ്പത്രം" സന്ദേശം രജിസ്റ്റർ ചെയ്യാൻ കഴിയും. ക്ലയന്റ് മര്യാദയില്ലാതെ വിച്ഛേദിക്കപ്പെട്ടാൽ (ഒരു DISCONNECT പാക്കറ്റ് അയയ്ക്കാതെ), ബ്രോക്കർ ഈ അവസാന വിൽപ്പത്ര സന്ദേശം അതിന്റെ പേരിൽ ഒരു നിശ്ചിത വിഷയത്തിലേക്ക് സ്വയമേവ പ്രസിദ്ധീകരിക്കും.

ഉപകരണ നില നിരീക്ഷിക്കുന്നതിന് ഇത് വിലമതിക്കാനാവാത്തതാണ്. ഒരു ഉപകരണത്തിന് `devices/device-123/status` എന്ന വിഷയത്തിലേക്ക് "online" എന്ന പേലോഡ് സഹിതം ഒരു സന്ദേശം കണക്റ്റുചെയ്യുമ്പോൾ പ്രസിദ്ധീകരിക്കാനും, അതേ വിഷയത്തിലേക്ക് "offline" എന്ന പേലോഡ് സഹിതം ഒരു LWT സന്ദേശം രജിസ്റ്റർ ചെയ്യാനും കഴിയും. ഈ വിഷയത്തിലേക്ക് സബ്സ്ക്രൈബ് ചെയ്യുന്ന ഏതൊരു നിരീക്ഷണ സേവനത്തിനും ഉപകരണത്തിന്റെ നില തൽക്ഷണം അറിയാൻ കഴിയും.

Paho-MQTT-യിൽ LWT നടപ്പിലാക്കാൻ, കണക്റ്റുചെയ്യുന്നതിന് മുമ്പ് ഇത് സജ്ജീകരിക്കുക:

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

client.connect(BROKER_ADDRESS, PORT, 60)

നിലനിർത്തുന്ന സന്ദേശങ്ങൾ (Retained Messages)

സാധാരണയായി, ഒരു സബ്സ്ക്രൈബർ ഒരു വിഷയത്തിലേക്ക് കണക്റ്റുചെയ്യുകയാണെങ്കിൽ, അത് സബ്സ്ക്രൈബ് ചെയ്തതിന് ശേഷം പ്രസിദ്ധീകരിക്കുന്ന സന്ദേശങ്ങൾ മാത്രമേ ലഭിക്കൂ. എന്നാൽ നിങ്ങൾക്ക് ഏറ്റവും പുതിയ മൂല്യം ഉടനടി ആവശ്യമാണെങ്കിലോ? ഇതിനാണ് നിലനിർത്തുന്ന സന്ദേശങ്ങൾ (retained messages) ഉപയോഗിക്കുന്നത്. `retain` ഫ്ലാഗ് `True` ആയി സജ്ജീകരിച്ച് ഒരു സന്ദേശം പ്രസിദ്ധീകരിക്കുമ്പോൾ, ബ്രോക്കർ ആ സന്ദേശം ആ പ്രത്യേക വിഷയത്തിനായി സംഭരിക്കുന്നു. ഒരു പുതിയ ക്ലയന്റ് ആ വിഷയത്തിലേക്ക് സബ്സ്ക്രൈബ് ചെയ്യുമ്പോൾ, അത് അവസാനമായി നിലനിർത്തിയ സന്ദേശം ഉടനടി സ്വീകരിക്കും.

നിലവിലെ വിവരങ്ങൾക്ക് ഇത് മികച്ചതാണ്. ഒരു ഉപകരണത്തിന് അതിന്റെ നില (ഉദാഹരണത്തിന്, `{"state": "ON"}`) `retain=True` ഉപയോഗിച്ച് പ്രസിദ്ധീകരിക്കാൻ കഴിയും. ആരംഭിക്കുകയും സബ്സ്ക്രൈബ് ചെയ്യുകയും ചെയ്യുന്ന ഏതൊരു ആപ്ലിക്കേഷനും അടുത്ത അപ്‌ഡേറ്റിനായി കാത്തിരിക്കാതെ ഉപകരണത്തിന്റെ നിലവിലെ അവസ്ഥ ഉടനടി അറിയാൻ കഴിയും.

Paho-MQTT-യിൽ, നിങ്ങളുടെ പബ്ലിഷ് കോളിലേക്ക് `retain` ഫ്ലാഗ് ചേർത്താൽ മതി:

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

സ്ഥിരമായ സെഷനുകളും ക്ലീൻ സെഷനുകളും

ക്ലയന്റിന്റെ കണക്ഷൻ അഭ്യർത്ഥനയിലെ `clean_session` ഫ്ലാഗ് ബ്രോക്കർ ക്ലയന്റിന്റെ സെഷൻ എങ്ങനെ കൈകാര്യം ചെയ്യുന്നു എന്ന് നിയന്ത്രിക്കുന്നു.

• ക്ലീൻ സെഷൻ (clean_session=True, ഡിഫോൾട്ട്): ക്ലയന്റ് വിച്ഛേദിക്കുമ്പോൾ, അതിന്റെ സബ്സ്ക്രിപ്ഷനുകളും ക്യൂവിലുള്ള QoS 1 അല്ലെങ്കിൽ 2 സന്ദേശങ്ങളും ഉൾപ്പെടെ അതിനെക്കുറിച്ചുള്ള എല്ലാ വിവരങ്ങളും ബ്രോക്കർ ഉപേക്ഷിക്കുന്നു. ഇത് വീണ്ടും കണക്റ്റുചെയ്യുമ്പോൾ, ഒരു പുതിയ ക്ലയന്റിനെപ്പോലെയാണ്.
• സ്ഥിരമായ സെഷൻ (clean_session=False): ഒരു അദ്വിതീയ ക്ലയന്റ് ID ഉള്ള ഒരു ക്ലയന്റ് ഈ രീതിയിൽ കണക്റ്റുചെയ്യുമ്പോൾ, വിച്ഛേദിക്കപ്പെട്ടതിന് ശേഷവും ബ്രോക്കർ അതിന്റെ സെഷൻ നിലനിർത്തുന്നു. ഇതിൽ അതിന്റെ സബ്സ്ക്രിപ്ഷനുകളും ഓഫ്‌ലൈനിലായിരിക്കുമ്പോൾ പ്രസിദ്ധീകരിച്ച QoS 1 അല്ലെങ്കിൽ 2 സന്ദേശങ്ങളും ഉൾപ്പെടുന്നു. ക്ലയന്റ് വീണ്ടും കണക്റ്റുചെയ്യുമ്പോൾ, ബ്രോക്കർ നഷ്ടപ്പെട്ട എല്ലാ സന്ദേശങ്ങളും അയയ്ക്കുന്നു. വിശ്വസനീയമല്ലാത്ത നെറ്റ്‌വർക്കുകളിൽ നിർണായക കമാൻഡുകൾ നഷ്ടപ്പെടുത്താൻ കഴിയാത്ത ഉപകരണങ്ങൾക്ക് ഇത് വളരെ പ്രധാനമാണ്.

ഒരു സ്ഥിരമായ സെഷൻ സ്ഥാപിക്കുന്നതിന്, നിങ്ങൾ ഒരു സ്ഥിരവും അദ്വിതീയവുമായ ക്ലയന്റ് ID നൽകുകയും ക്ലയന്റ് ഇൻസ്റ്റൻസ് ഉണ്ടാക്കുമ്പോൾ `clean_session=False` എന്ന് സജ്ജീകരിക്കുകയും വേണം:

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

സുരക്ഷ ഒരു ഓപ്ഷനല്ല: പൈത്തൺ ഉപയോഗിച്ച് MQTT സുരക്ഷിതമാക്കുന്നു

ഏതൊരു യഥാർത്ഥ ലോക ആപ്ലിക്കേഷനിലും സുരക്ഷ പരമപ്രധാനമാണ്. സുരക്ഷിതമല്ലാത്ത ഒരു MQTT ബ്രോക്കർ ദുരുദ്ദേശ്യമുള്ള ആളുകൾക്ക് നിങ്ങളുടെ ഡാറ്റ ചോർത്താനും നിങ്ങളുടെ ഉപകരണങ്ങളിലേക്ക് തെറ്റായ കമാൻഡുകൾ അയയ്ക്കാനും അല്ലെങ്കിൽ സേവനനിഷേധ ആക്രമണങ്ങൾ നടത്താനുമുള്ള ഒരു തുറന്ന ക്ഷണം നൽകുന്നു. MQTT സുരക്ഷിതമാക്കുന്നതിൽ മൂന്ന് പ്രധാന തൂണുകൾ ഉൾപ്പെടുന്നു: പ്രാമാണീകരണം (Authentication), എൻക്രിപ്ഷൻ (Encryption), അംഗീകാരം (Authorization).

പ്രാമാണീകരണം: നിങ്ങൾ ആരാണ്?

ബ്രോക്കറുമായി ബന്ധിപ്പിക്കുന്ന ക്ലയന്റിന്റെ ഐഡന്റിറ്റി പ്രാമാണീകരണം സ്ഥിരീകരിക്കുന്നു. ഏറ്റവും ലളിതമായ രീതി ഒരു ഉപയോക്തൃനാമവും പാസ്‌വേഡും ഉപയോഗിക്കുന്നതാണ്. നിങ്ങളുടെ മോസ്കിറ്റോ ബ്രോക്കർക്ക് ക്രെഡൻഷ്യലുകൾ ആവശ്യമാണെന്ന് കോൺഫിഗർ ചെയ്യാനും തുടർന്ന് നിങ്ങളുടെ പൈത്തൺ ക്ലയന്റിൽ അവ നൽകാനും കഴിയും.

നിങ്ങളുടെ പൈത്തൺ ക്ലയന്റിൽ, `username_pw_set()` രീതി ഉപയോഗിക്കുക:

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

client.connect(BROKER_ADDRESS, PORT, 60)

എൻക്രിപ്ഷൻ: TLS/SSL ഉപയോഗിച്ച് ട്രാൻസിറ്റിലുള്ള ഡാറ്റ സംരക്ഷിക്കുന്നു

ഉപയോക്തൃനാമവും പാസ്‌വേഡും നെറ്റ്‌വർക്കിലൂടെ പ്ലെയിൻ ടെക്സ്റ്റായി അയയ്ക്കുകയാണെങ്കിൽ അവയ്ക്ക് വലിയ ഉപയോഗമില്ല. ക്ലയന്റും ബ്രോക്കറും തമ്മിലുള്ള എല്ലാ ആശയവിനിമയങ്ങളും എൻക്രിപ്ഷൻ വഴി സുരക്ഷിതമാക്കുകയും നെറ്റ്‌വർക്കിൽ വിവരങ്ങൾ ചോർത്താൻ ശ്രമിക്കുന്ന ആർക്കും വായിക്കാൻ കഴിയാത്തതാക്കുകയും ചെയ്യുന്നു. വെബ്സൈറ്റുകൾ സുരക്ഷിതമാക്കുന്ന അതേ സാങ്കേതികവിദ്യയായ ട്രാൻസ്പോർട്ട് ലെയർ സെക്യൂരിറ്റി (TLS) ഉപയോഗിച്ചാണ് ഇത് നേടുന്നത് (HTTPS).

MQTT-യിൽ TLS (പലപ്പോഴും MQTTS എന്ന് വിളിക്കപ്പെടുന്നു) ഉപയോഗിക്കുന്നതിന്, നിങ്ങളുടെ ബ്രോക്കർ അതിനെ പിന്തുണയ്ക്കാൻ (സാധാരണയായി പോർട്ട് 8883-ൽ) കോൺഫിഗർ ചെയ്യുകയും നിങ്ങളുടെ ക്ലയന്റിന് ആവശ്യമായ സർട്ടിഫിക്കറ്റുകൾ നൽകുകയും വേണം. ഒരു ബ്രോക്കറിന്റെ ഐഡന്റിറ്റി പരിശോധിക്കാൻ ഒരു സർട്ടിഫിക്കറ്റ് അതോറിറ്റി (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`) പാടില്ല. ഇത് സാധാരണയായി ബ്രോക്കറിൽ ആക്സസ് കൺട്രോൾ ലിസ്റ്റുകൾ (ACLs) ഉപയോഗിച്ചാണ് കൈകാര്യം ചെയ്യുന്നത്. ഏതൊക്കെ ഉപയോക്താക്കൾക്ക് പ്രത്യേക വിഷയ പാറ്റേണുകളിലേക്ക് `വായിക്കാനും` (സബ്സ്ക്രൈബ് ചെയ്യാനും) `എഴുതാനും` (പ്രസിദ്ധീകരിക്കാനും) കഴിയുമെന്ന് നിർവചിക്കുന്ന നിയമങ്ങൾ ഉപയോഗിച്ച് നിങ്ങൾ ബ്രോക്കർ കോൺഫിഗർ ചെയ്യുന്നു.

എല്ലാം ഒരുമിച്ച് ചേർക്കുന്നു: ഒരു ലളിതമായ സ്മാർട്ട് എൻവയോൺമെന്റ് മോണിറ്റർ പ്രോജക്റ്റ്

ഈ ആശയങ്ങൾ ഉറപ്പിക്കുന്നതിനായി അല്പം കൂടി യാഥാർത്ഥ്യബോധമുള്ള ഒരു പ്രോജക്റ്റ് നമുക്ക് നിർമ്മിക്കാം. പാരിസ്ഥിതിക ഡാറ്റ ഒരു JSON ഒബ്ജക്റ്റായി പ്രസിദ്ധീകരിക്കുന്ന ഒരു സെൻസർ ഉപകരണത്തെയും ഈ ഡാറ്റ സബ്സ്ക്രൈബ് ചെയ്ത് പ്രദർശിപ്പിക്കുന്ന ഒരു നിരീക്ഷണ ആപ്ലിക്കേഷനെയും നമ്മൾ അനുകരിക്കും.

പ്രോജക്റ്റ് അവലോകനം

• സെൻസർ (പ്രസാധകൻ): താപനിലയും ഈർപ്പവും വായിക്കുന്ന ഒരു സെൻസറിനെ അനുകരിക്കുന്ന ഒരു പൈത്തൺ സ്ക്രിപ്റ്റ്. ഇത് ഈ ഡാറ്റ ഒരു JSON പേലോഡായി പാക്കേജ് ചെയ്യുകയും ഓരോ 5 സെക്കൻഡിലും smart_env/device01/telemetry എന്ന വിഷയത്തിലേക്ക് പ്രസിദ്ധീകരിക്കുകയും ചെയ്യും.
• മോണിറ്റർ (സബ്സ്ക്രൈബർ): `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("സെൻസർ പ്രസാധകൻ ആരംഭിച്ചു...")

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"പ്രസിദ്ധീകരിച്ചത്: {payload_str}")

time.sleep(5)

except KeyboardInterrupt:

print("സെൻസർ പ്രസാധകനെ നിർത്തുന്നു...")

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"ഫലം കോഡ് {rc} ഉപയോഗിച്ച് ബന്ധിപ്പിച്ചു")

client.subscribe(TOPIC)

def on_message(client, userdata, msg):

print("--- പുതിയ സന്ദേശം ലഭിച്ചു ---")

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"ഉപകരണം: {msg.topic}")

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

print(f"താപനില: {temperature}°C")

print(f"ഈർപ്പം: {humidity}%")

except json.JSONDecodeError:

print("JSON പേലോഡ് ഡീകോഡ് ചെയ്യുന്നതിൽ പിശക്.")

except Exception as e:

print(f"ഒരു പിശക് സംഭവിച്ചു: {e}")

client = mqtt.Client("MonitoringDashboard")

client.on_connect = on_connect

client.on_message = on_message

client.connect(BROKER_ADDRESS, PORT, 60)

print("മോണിറ്ററിംഗ് ഡാഷ്‌ബോർഡ് പ്രവർത്തിക്കുന്നു...")

client.loop_forever()

പ്രോട്ടോടൈപ്പ് മുതൽ പ്രൊഡക്ഷൻ വരെ: MQTT മികച്ച രീതികൾ

നിങ്ങളുടെ പ്രോജക്റ്റിനെ ഒരു ലളിതമായ സ്ക്രിപ്റ്റിൽ നിന്ന് ശക്തവും വികസിപ്പിക്കാവുന്നതുമായ ഒരു പ്രൊഡക്ഷൻ സിസ്റ്റത്തിലേക്ക് മാറ്റുന്നതിന് ശ്രദ്ധാപൂർവമായ ആസൂത്രണം ആവശ്യമാണ്. ചില പ്രധാന മികച്ച രീതികൾ ഇതാ:

• വ്യക്തമായ ഒരു വിഷയ ശ്രേണി രൂപകൽപ്പന ചെയ്യുക: തുടക്കം മുതൽ നിങ്ങളുടെ വിഷയ ഘടന ശ്രദ്ധാപൂർവ്വം ആസൂത്രണം ചെയ്യുക. ഒരു നല്ല ശ്രേണി വിവരണാത്മകവും, വികസിപ്പിക്കാവുന്നതും, വൈൽഡ്കാർഡുകൾ ഉപയോഗിച്ച് വഴക്കമുള്ള സബ്സ്ക്രിപ്ഷനുകൾ അനുവദിക്കുന്നതുമാണ്. ഒരു സാധാരണ പാറ്റേൺ ആണ് <site>/<area>/<device_type>/<device_id>/<measurement>.
• നെറ്റ്‌വർക്ക് വിച്ഛേദനങ്ങൾ മനോഹരമായി കൈകാര്യം ചെയ്യുക: നെറ്റ്‌വർക്കുകൾ വിശ്വസനീയമല്ല. നിങ്ങളുടെ ക്ലയന്റ് കോഡ് ശക്തമായ റീകണക്ഷൻ ലോജിക് നടപ്പിലാക്കണം. Paho-MQTT-യിലെ `on_disconnect` കോൾബാക്ക് ഇതിന് അനുയോജ്യമായ സ്ഥലമാണ്, നെറ്റ്‌വർക്കിൽ വീണ്ടും കണക്റ്റുചെയ്യാൻ ശ്രമിക്കുന്നതിലൂടെയുള്ള ഭാരം ഒഴിവാക്കാൻ എക്സ്പോണൻഷ്യൽ ബാക്ക്ഓഫ് പോലുള്ള ഒരു തന്ത്രം നടപ്പിലാക്കുക.
• ഘടനയുള്ള ഡാറ്റ പേലോഡുകൾ ഉപയോഗിക്കുക: നിങ്ങളുടെ സന്ദേശ പേലോഡുകൾക്കായി JSON അല്ലെങ്കിൽ പ്രോട്ടോക്കോൾ ബഫറുകൾ പോലുള്ള ഘടനയുള്ള ഡാറ്റാ ഫോർമാറ്റ് എല്ലായ്പ്പോഴും ഉപയോഗിക്കുക. ഇത് നിങ്ങളുടെ ഡാറ്റയെ സ്വയം വിവരണമുള്ളതും, വേർഷൻ ചെയ്യാവുന്നതും, വ്യത്യസ്ത ആപ്ലിക്കേഷനുകൾക്ക് (ഏത് ഭാഷയിലും എഴുതിയത്) പാഴ്സ് ചെയ്യാൻ എളുപ്പമുള്ളതാക്കുകയും ചെയ്യുന്നു.
• എല്ലാം സ്ഥിരസ്ഥിതിയായി സുരക്ഷിതമാക്കുക: സുരക്ഷയില്ലാതെ ഒരു IoT സിസ്റ്റം വിന്യസിക്കരുത്. കുറഞ്ഞത്, ഉപയോക്തൃനാമം/പാസ്‌വേഡ് പ്രാമാണീകരണവും TLS എൻക്രിപ്ഷനും ഉപയോഗിക്കുക. ഉയർന്ന സുരക്ഷാ ആവശ്യങ്ങൾക്കായി, ക്ലയന്റ് സർട്ടിഫിക്കറ്റ് അടിസ്ഥാനമാക്കിയുള്ള പ്രാമാണീകരണം പര്യവേക്ഷണം ചെയ്യുക.
• നിങ്ങളുടെ ബ്രോക്കർ നിരീക്ഷിക്കുക: ഒരു പ്രൊഡക്ഷൻ എൻവയോൺമെന്റിൽ, നിങ്ങളുടെ MQTT ബ്രോക്കർ അടിസ്ഥാന സൗകര്യങ്ങളുടെ ഒരു നിർണായക ഭാഗമാണ്. അതിന്റെ ആരോഗ്യം, CPU/മെമ്മറി ഉപയോഗം, കണക്റ്റുചെയ്ത ക്ലയന്റുകളുടെ എണ്ണം, സന്ദേശ നിരക്കുകൾ, നഷ്ടപ്പെട്ട സന്ദേശങ്ങൾ എന്നിവ ട്രാക്കുചെയ്യാൻ നിരീക്ഷണ ടൂളുകൾ ഉപയോഗിക്കുക. പല ബ്രോക്കറുകളും ഈ സ്റ്റാറ്റസ് വിവരങ്ങൾ നൽകുന്ന ഒരു പ്രത്യേക `$SYS` വിഷയ ശ്രേണി തുറന്നുകാട്ടുന്നു.

ഉപസംഹാരം: പൈത്തണും MQTT-യും ഉപയോഗിച്ചുള്ള നിങ്ങളുടെ യാത്ര

MQTT-യുടെ അടിസ്ഥാനപരമായ "എന്തുകൊണ്ട്" എന്നതിൽ നിന്ന് പൈത്തൺ ഉപയോഗിച്ച് ഇത് നടപ്പിലാക്കുന്നതിനുള്ള പ്രായോഗികമായ "എങ്ങനെ" എന്നതിലേക്ക് നമ്മൾ യാത്ര ചെയ്തു. പബ്ലിഷ്/സബ്സ്ക്രൈബ് മോഡലിന്റെ ശക്തി, QoS-ന്റെ പ്രാധാന്യം, സുരക്ഷയുടെ നിർണായക പങ്ക് എന്നിവയെക്കുറിച്ച് നിങ്ങൾ പഠിച്ചു. സെൻസർ ഡാറ്റ പ്രസിദ്ധീകരിക്കാനും കമാൻഡുകൾ സബ്സ്ക്രൈബ് ചെയ്യാനും കഴിയുന്ന സങ്കീർണ്ണമായ ക്ലയന്റുകളെ നിർമ്മിക്കാൻ Paho-MQTT ലൈബ്രറി എത്രത്തോളം ലളിതമാക്കുന്നു എന്ന് നിങ്ങൾ കണ്ടു.

MQTT ഒരു പ്രോട്ടോക്കോൾ എന്നതിലുപരിയാണ്; ഇത് ഇന്റർനെറ്റ് ഓഫ് തിങ്സിനായുള്ള ഒരു അടിസ്ഥാന സാങ്കേതികവിദ്യയാണ്. ഇതിന്റെ ഭാരം കുറഞ്ഞ സ്വഭാവവും ശക്തമായ സവിശേഷതകളും ലോകമെമ്പാടുമുള്ള ദശലക്ഷക്കണക്കിന് ഉപകരണങ്ങൾക്ക്, സ്മാർട്ട് സിറ്റികൾ മുതൽ ബന്ധിത കൃഷി വരെയുള്ള വ്യവസായ ഓട്ടോമേഷൻ വരെ, തിരഞ്ഞെടുക്കാനുള്ള ഒരു പ്രധാന ഘടകമാക്കി മാറ്റിയിരിക്കുന്നു.

ഈ യാത്ര ഇവിടെ അവസാനിക്കുന്നില്ല. അടുത്ത ഘട്ടം ഈ ആശയങ്ങൾ യഥാർത്ഥ ഹാർഡ്‌വെയറിൽ പ്രയോഗിക്കുക എന്നതാണ്. ഒരു റാസ്ബെറി പൈ, ഒരു ESP32, അല്ലെങ്കിൽ മറ്റ് മൈക്രോകൺട്രോളറുകൾ എന്നിവ ഉപയോഗിച്ച് പരീക്ഷിക്കുക. ഭൗതിക സെൻസറുകൾ ബന്ധിപ്പിക്കുക, ക്ലൗഡ് IoT പ്ലാറ്റ്‌ഫോമുകളുമായി സംയോജിപ്പിക്കുക, ഭൗതിക ലോകവുമായി സംവദിക്കുന്ന ആപ്ലിക്കേഷനുകൾ നിർമ്മിക്കുക. പൈത്തണും MQTT-യും ഉപയോഗിച്ച്, അടുത്ത തലമുറയിലെ കണക്റ്റുചെയ്ത പരിഹാരങ്ങൾ നിർമ്മിക്കാൻ നിങ്ങൾക്ക് ശക്തമായ ഒരു ടൂൾകിറ്റ് ഉണ്ട്.