IoT માટે પાયથોન: MQTT અમલીકરણ માટે એક વિસ્તૃત માર્ગદર્શિકા

જોડાયેલું વિશ્વ: શા માટે IoT પ્રોટોકોલ્સ મહત્વના છે

આપણે અભૂતપૂર્વ કનેક્ટિવિટીના યુગમાં જીવીએ છીએ. ઇન્ટરનેટ ઓફ થિંગ્સ (IoT) હવે ભવિષ્યનો ખ્યાલ નથી; તે એક વૈશ્વિક વાસ્તવિકતા છે, જે અબજો સ્માર્ટ ઉપકરણોનું નેટવર્ક શાંતિપૂર્વક ગૂંથે છે જે આપણા પર્યાવરણનું નિરીક્ષણ કરે છે, આપણા ઘરોને સ્વચાલિત કરે છે, આપણા ઉદ્યોગોને ઑપ્ટિમાઇઝ કરે છે અને આપણા શહેરોને સુવ્યવસ્થિત કરે છે. સિઓલના ઘરમાં સ્માર્ટ થર્મોસ્ટેટથી લઈને ગ્રામીણ કેન્યાના ખેતરમાં કૃષિ સેન્સર સુધી, આ ઉપકરણો જબરદસ્ત માત્રામાં ડેટા ઉત્પન્ન કરી રહ્યા છે. પરંતુ, ખાસ કરીને જ્યારે તેઓ ઘણીવાર નાના, ઓછી શક્તિવાળા અને અવિશ્વસનીય નેટવર્ક્સ પર કાર્યરત હોય ત્યારે તેઓ એકબીજા સાથે અને ક્લાઉડ સાથે કેવી રીતે વાતચીત કરે છે? જવાબ વિશિષ્ટ સંચાર પ્રોટોકોલ્સમાં રહેલો છે.

જ્યારે HTTP પ્રોટોકોલ આપણે દૈનિક ધોરણે ઉપયોગ કરીએ છીએ તે મોટાભાગની વેબને શક્તિ આપે છે, તે IoT ના મર્યાદિત વિશ્વ માટે ઘણીવાર ખૂબ ભારે અને પાવર-વપરાશી હોય છે. આ તે છે જ્યાં ખાસ કરીને મશીન-ટુ-મશીન (M2M) સંચાર માટે રચાયેલ પ્રોટોકોલ્સ ચમકે છે. તેમાંથી, એક પ્રભાવશાળી શક્તિ તરીકે ઉભરી આવ્યું છે: MQTT.

આ વિસ્તૃત માર્ગદર્શિકા વિશ્વભરના વિકાસકર્તાઓ, ઇજનેરો અને શોખીનો માટે રચાયેલ છે જેઓ IoT ક્ષેત્રમાં સૌથી બહુમુખી અને લોકપ્રિય પ્રોગ્રામિંગ ભાષાઓમાંની એક, પાયથોનનો ઉપયોગ કરીને MQTT ની શક્તિનો ઉપયોગ કરવા માંગે છે. અમે MQTT ના મૂળભૂત ખ્યાલોથી લઈને સુરક્ષિત, મજબૂત અને માપી શકાય તેવી IoT એપ્લિકેશનો બનાવવા સુધીની યાત્રા કરીશું.

MQTT શું છે? મર્યાદાઓ માટે બનાવેલ એક પ્રોટોકોલ

MQTT નો અર્થ છે મેસેજ ક્યુઇંગ ટેલિમેટ્રી ટ્રાન્સપોર્ટ. તેની શોધ 1999 માં IBM ના ડો. એન્ડી સ્ટેનફોર્ડ-ક્લાર્ક અને આર્કોમ (હવે સિરરસ લિંક) ના આર્લેન નિપર દ્વારા અવિશ્વસનીય સેટેલાઇટ નેટવર્ક્સ પર ઓઇલ પાઇપલાઇન્સનું નિરીક્ષણ કરવા માટે કરવામાં આવી હતી. તેની ઉત્પત્તિની વાર્તા તેના હેતુને સંપૂર્ણ રીતે સમાવે છે: નોંધપાત્ર મર્યાદાઓ હેઠળ કાર્યરત ઉપકરણો માટે એક હલકો, વિશ્વસનીય અને કાર્યક્ષમ મેસેજિંગ પ્રોટોકોલ બનવું.

પબ્લિશ/સબસ્ક્રાઇબ (Pub/Sub) મોડેલ સમજાવ્યું

MQTT ના હૃદયમાં ભવ્ય પબ્લિશ/સબસ્ક્રાઇબ આર્કિટેક્ચરલ પેટર્ન છે. આ HTTP ના વિનંતી/પ્રતિસાદ મોડેલથી એક મૂળભૂત પ્રસ્થાન છે જેનાથી ઘણા વિકાસકર્તાઓ પરિચિત છે. ક્લાયંટ સર્વર પાસેથી સીધી માહિતીની વિનંતી કરવાને બદલે, સંચાર ડીકપલ થાય છે.

એક વૈશ્વિક સમાચાર એજન્સીની કલ્પના કરો. પત્રકારો (પ્રકાશકો) તેમની વાર્તાઓ સીધા દરેક વાચકને મોકલતા નથી. તેના બદલે, તેઓ તેમની વાર્તાઓ એજન્સીના કેન્દ્રીય હબ (બ્રોકર) ને મોકલે છે અને તેમને "વર્લ્ડ પોલિટિક્સ" અથવા "ટેકનોલોજી" જેવા ચોક્કસ વિષયો હેઠળ વર્ગીકૃત કરે છે. વાચકો (સબ્સ્ક્રાઇબર્સ) ને પત્રકારો પાસેથી અપડેટ્સ માંગવાની જરૂર નથી; તેઓ ફક્ત એજન્સીને જણાવે છે કે તેમને કયા વિષયોમાં રસ છે. એજન્સી પછી આપમેળે તે વિષયો પરની કોઈપણ નવી વાર્તાઓ રસ ધરાવતા વાચકોને ફોરવર્ડ કરે છે. પત્રકારો અને વાચકોને ક્યારેય એકબીજાના અસ્તિત્વ, સ્થાન અથવા સ્થિતિ વિશે જાણવાની જરૂર નથી.

In MQTT, this model decouples the device sending data (publisher) from the device or application receiving it (subscriber). This is incredibly powerful for IoT because:

• સ્પેસ ડીકપલિંગ: પ્રકાશક અને સબ્સ્ક્રાઇબરને એકબીજાના IP સરનામાં અથવા સ્થાન વિશે જાણવાની જરૂર નથી.
• સમય ડીકપલિંગ: તેમને એક જ સમયે ચાલવાની જરૂર નથી. એક સેન્સર એક રીડિંગ પ્રકાશિત કરી શકે છે, અને જો સિસ્ટમ તે રીતે ડિઝાઇન કરવામાં આવી હોય તો એપ્લિકેશન તેને કલાકો પછી પ્રાપ્ત કરી શકે છે.
• સિંક્રોનાઇઝેશન ડીકપલિંગ: સંદેશા વિનિમય પૂર્ણ કરવા માટે એકબીજાની રાહ જોવા માટે બંને બાજુની કામગીરી અટકાવવાની જરૂર નથી.

MQTT ઇકોસિસ્ટમના મુખ્ય ઘટકો

MQTT આર્કિટેક્ચર કેટલાક મુખ્ય ઘટકો પર આધારિત છે:

• બ્રોકર: કેન્દ્રીય હબ અથવા સર્વર. તે MQTT વિશ્વની પોસ્ટ ઓફિસ છે. બ્રોકર પ્રકાશકો પાસેથી તમામ સંદેશા પ્રાપ્ત કરવા, તેમને વિષય દ્વારા ફિલ્ટર કરવા અને યોગ્ય સબ્સ્ક્રાઇબર્સને મોકલવા માટે જવાબદાર છે. લોકપ્રિય બ્રોકર્સમાં Mosquitto અને VerneMQ જેવા ઓપન-સોર્સ વિકલ્પો અને AWS IoT Core, Azure IoT Hub અને Google Cloud IoT Core જેવી સંચાલિત ક્લાઉડ સેવાઓ શામેલ છે.
• ક્લાયંટ: કોઈપણ ઉપકરણ અથવા એપ્લિકેશન જે બ્રોકર સાથે કનેક્ટ થાય છે. એક ક્લાયંટ પ્રકાશક, સબ્સ્ક્રાઇબર અથવા બંને હોઈ શકે છે. એક IoT સેન્સર એક ક્લાયંટ છે, અને સેન્સર ડેટા પર પ્રક્રિયા કરતી સર્વર એપ્લિકેશન પણ એક ક્લાયંટ છે.
• ટોપિક: એક UTF-8 સ્ટ્રિંગ જે સંદેશાઓ માટે સરનામું અથવા લેબલ તરીકે કાર્ય કરે છે. બ્રોકર સંદેશાઓને રૂટ કરવા માટે ટોપિક્સનો ઉપયોગ કરે છે. ટોપિક્સ વંશવેલો હોય છે, જેમાં ફોરવર્ડ સ્લેશને ડિલિમિટર તરીકે ઉપયોગમાં લેવાય છે, જેમ કે ફાઇલ સિસ્ટમ પાથ. ઉદાહરણ તરીકે, લંડનની ઇમારતમાં લિવિંગ રૂમમાં તાપમાન સેન્સર માટે એક સારો ટોપિક આ હોઈ શકે છે: UK/London/Building-A/Floor-1/LivingRoom/Temperature.
• પેલોડ: આ સંદેશાની વાસ્તવિક ડેટા સામગ્રી છે. MQTT ડેટા-એગ્નોસ્ટિક છે, એટલે કે પેલોડ કંઈપણ હોઈ શકે છે: એક સરળ સ્ટ્રિંગ, એક પૂર્ણાંક, JSON, XML, અથવા તો એન્ક્રિપ્ટેડ બાઈનરી ડેટા. JSON તેની સુગમતા અને વાંચનક્ષમતા માટે ખૂબ જ સામાન્ય પસંદગી છે.

શા માટે MQTT IoT સંચાર પર પ્રભુત્વ ધરાવે છે

MQTT ના ડિઝાઇન સિદ્ધાંતો તેને IoT ના પડકારો માટે અપવાદરૂપે યોગ્ય બનાવે છે:

• હલકું: MQTT સંદેશાઓમાં ખૂબ જ નાનું હેડર હોય છે (ઓછામાં ઓછું 2 બાઈટ), નેટવર્ક બેન્ડવિડ્થ વપરાશ ઘટાડે છે. આ મોંઘા સેલ્યુલર પ્લાન અથવા LoRaWAN જેવા ઓછા બેન્ડવિડ્થ નેટવર્ક્સ પરના ઉપકરણો માટે નિર્ણાયક છે.
• કાર્યક્ષમ: પ્રોટોકોલનો ઓછો ઓવરહેડ સીધો ઓછી પાવર વપરાશમાં પરિણમે છે, જે બેટરી સંચાલિત ઉપકરણોને મહિનાઓ અથવા વર્ષો સુધી કાર્ય કરવા દે છે.
• વિશ્વસનીય: તેમાં ફ્લૅકી, ઉચ્ચ-લેટન્સી નેટવર્ક્સ પર પણ સંદેશા વિતરણ સુનિશ્ચિત કરવા માટેની સુવિધાઓ શામેલ છે. આ સર્વિસ ગુણવત્તા સ્તરો દ્વારા સંચાલિત થાય છે.
• સ્કેલેબલ: એક જ બ્રોકર હજારો કે લાખો ક્લાયંટ્સ પાસેથી એકસાથે કનેક્શન હેન્ડલ કરી શકે છે, જે તેને મોટા પાયે જમાવટ માટે યોગ્ય બનાવે છે.
• દ્વિદિશીય: MQTT ઉપકરણ-થી-ક્લાઉડ (ટેલિમેટ્રી) અને ક્લાઉડ-થી-ઉપકરણ (કમાન્ડ્સ) સંચાર માટે પરવાનગી આપે છે, જે ઉપકરણોને દૂરસ્થ રીતે નિયંત્રિત કરવા માટેની એક મહત્વપૂર્ણ જરૂરિયાત છે.

ક્વોલિટી ઓફ સર્વિસ (QoS) સમજવું

MQTT ત્રણ સ્તરની ક્વોલિટી ઓફ સર્વિસ (QoS) પ્રદાન કરે છે જેથી વિકાસકર્તાઓ તેમના ચોક્કસ ઉપયોગના કિસ્સા માટે વિશ્વસનીયતા અને ઓવરહેડ વચ્ચે યોગ્ય સંતુલન પસંદ કરી શકે.

• QoS 0 (વધુમાં વધુ એક વાર): આ "ફાયર એન્ડ ફર્ગેટ" સ્તર છે. સંદેશા એકવાર મોકલવામાં આવે છે, જેમાં બ્રોકર અથવા અંતિમ સબ્સ્ક્રાઇબર પાસેથી પ્રાપ્ત થયાની કોઈ પુષ્ટિ હોતી નથી. તે સૌથી ઝડપી પદ્ધતિ છે પરંતુ ડિલિવરીની કોઈ ગેરંટી આપતી નથી. ઉપયોગનો કિસ્સો: બિન-નિર્ણાયક, ઉચ્ચ-આવર્તન સેન્સર ડેટા, જેમ કે દર 10 સેકન્ડે મોકલવામાં આવતું આસપાસના ઓરડાના તાપમાનનું રીડિંગ. એક રીડિંગ ગુમાવવું એ સમસ્યા નથી.
• QoS 1 (ઓછામાં ઓછું એક વાર): આ સ્તર ગેરંટી આપે છે કે સંદેશા ઓછામાં ઓછો એક વાર પહોંચાડવામાં આવશે. પ્રેષક સંદેશાને ત્યાં સુધી સંગ્રહિત કરે છે જ્યાં સુધી તેને રીસીવર પાસેથી પુષ્ટિ (એક PUBACK પેકેટ) ન મળે. જો કોઈ પુષ્ટિ ન મળે, તો સંદેશા ફરીથી મોકલવામાં આવે છે. જો પુષ્ટિ ખોવાઈ જાય તો આ ક્યારેક ડુપ્લિકેટ સંદેશાઓમાં પરિણમી શકે છે. ઉપયોગનો કિસ્સો: સ્માર્ટ લાઇટ ચાલુ કરવાનો આદેશ. તમારે ખાતરી કરવાની જરૂર છે કે આદેશ પ્રાપ્ત થયો છે, અને તેને બે વાર પ્રાપ્ત કરવાથી નુકસાન થતું નથી.
• QoS 2 (ચોક્કસ એક વાર): આ સૌથી વિશ્વસનીય પરંતુ સૌથી ધીમું સ્તર પણ છે. તે ચાર-ભાગનો હેન્ડશેકનો ઉપયોગ કરે છે તેની ખાતરી કરવા માટે કે સંદેશા બરાબર એક વાર પહોંચાડવામાં આવે છે, જેમાં કોઈ ડુપ્લિકેટ્સ નથી. ઉપયોગનો કિસ્સો: નિર્ણાયક કામગીરી જ્યાં ડુપ્લિકેટ્સ વિનાશક હોઈ શકે છે, જેમ કે નાણાકીય વ્યવહાર, દવાઓની ચોક્કસ માત્રા વિતરિત કરવાનો આદેશ, અથવા ફેક્ટરીમાં રોબોટિક આર્મ્સનું નિયંત્રણ.

તમારું પાયથોન MQTT પર્યાવરણ સેટ કરવું

હવે, ચાલો વ્યવહારુ બનીએ. પાયથોન સાથે MQTT એપ્લિકેશન બનાવવાનું શરૂ કરવા માટે, તમને બે વસ્તુઓની જરૂર છે: MQTT ક્લાયંટ માટે પાયથોન લાઇબ્રેરી અને વાતચીત કરવા માટે MQTT બ્રોકર.

પાયથોન MQTT લાઇબ્રેરી પસંદ કરવી: Paho-MQTT

પાયથોન માટે સૌથી વધુ વ્યાપકપણે ઉપયોગમાં લેવાતી અને પરિપક્વ MQTT લાઇબ્રેરી એ Eclipse Foundation માંથી Paho-MQTT છે. તે એક મજબૂત, સુવિધા-સમૃદ્ધ લાઇબ્રેરી છે જે બ્રોકર સાથે કનેક્ટ થવા અને વિષયો પર પ્રકાશિત કરવા અથવા સબ્સ્ક્રાઇબ કરવા માટે ક્લાયંટ ક્લાસ પ્રદાન કરે છે. પાયથોનના પેકેજ મેનેજર, પીપનો ઉપયોગ કરીને તેને ઇન્સ્ટોલ કરવું સરળ છે.

તમારું ટર્મિનલ અથવા કમાન્ડ પ્રોમ્પ્ટ ખોલો અને ચલાવો:

pip install paho-mqtt

આ એક જ આદેશ તમને પાયથોનમાં MQTT ક્લાયંટ લખવાનું શરૂ કરવા માટે જરૂરી બધું ઇન્સ્ટોલ કરે છે.

MQTT બ્રોકર સેટ કરવું

તમારી પાસે બ્રોકર માટે ઘણા વિકલ્પો છે, જેમાં વિકાસ માટે તમારા સ્થાનિક મશીન પર એક ચલાવવાથી લઈને ઉત્પાદન માટે શક્તિશાળી ક્લાઉડ સેવાનો ઉપયોગ કરવા સુધીનો સમાવેશ થાય છે.

• સ્થાનિક બ્રોકર (વિકાસ અને શીખવા માટે): સ્થાનિક બ્રોકર માટે સૌથી લોકપ્રિય પસંદગી Mosquitto છે, જે અન્ય Eclipse પ્રોજેક્ટ છે. તે હલકો, ઓપન-સોર્સ અને ઇન્સ્ટોલ કરવા માટે સરળ છે.
  • ડેબિયન-આધારિત લિનક્સ પર (જેમ કે ઉબુન્ટુ, રાસ્પબેરી પાઇ OS): sudo apt-get update && sudo apt-get install mosquitto mosquitto-clients
  • macOS પર (હોમબ્રુનો ઉપયોગ કરીને): brew install mosquitto
  • વિન્ડોઝ પર: Mosquitto વેબસાઇટ પરથી નેટિવ ઇન્સ્ટોલર ડાઉનલોડ કરો.
  એકવાર ઇન્સ્ટોલ થઈ જાય, બ્રોકર સામાન્ય રીતે સેવા તરીકે આપમેળે શરૂ થાય છે. તમે તમારા ક્લાયંટને તમારા સ્થાનિક IP સરનામાં (127.0.0.1 અથવા localhost) પર નિર્દેશ કરીને તેનો ઉપયોગ કરી શકો છો.
• જાહેર/ક્લાઉડ બ્રોકર (ઝડપી પરીક્ષણ માટે): કંઈપણ ઇન્સ્ટોલ કર્યા વિના પ્રારંભિક પ્રયોગો માટે, તમે મફત, જાહેર બ્રોકરનો ઉપયોગ કરી શકો છો. બે લોકપ્રિય બ્રોકર્સ છે test.mosquitto.org અને broker.hivemq.com. મહત્વપૂર્ણ: આ જાહેર અને અનએન્ક્રિપ્ટેડ છે. તેમને કોઈ સંવેદનશીલ અથવા ખાનગી ડેટા મોકલશો નહીં. તેઓ ફક્ત શીખવા અને પરીક્ષણ હેતુઓ માટે છે.

પ્રેક્ટિકલ: પાયથોન સાથે પ્રકાશિત કરવું અને સબ્સ્ક્રાઇબ કરવું

ચાલો આપણી પ્રથમ પાયથોન MQTT એપ્લિકેશન લખીએ. આપણે બે અલગ સ્ક્રિપ્ટો બનાવીશું: એક પ્રકાશક જે સંદેશા મોકલે છે અને એક સબ્સ્ક્રાઇબર જે તેમને પ્રાપ્ત કરે છે. આ ઉદાહરણ માટે, અમે ધારીશું કે તમે સ્થાનિક Mosquitto બ્રોકર ચલાવી રહ્યા છો.

એક સરળ MQTT પ્રકાશક બનાવવું (publisher.py)

આ સ્ક્રિપ્ટ બ્રોકર સાથે કનેક્ટ થશે અને દર બે સેકન્ડે `python/mqtt/test` ટોપિક પર "હેલો, MQTT!" સંદેશ પ્રકાશિત કરશે.

`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"ટોપિક `{TOPIC}` પર `{message}` મોકલ્યો")

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 સુવિધાઓનું અન્વેષણ કરીએ જે ઉત્પાદન-તૈયાર એપ્લિકેશનો બનાવવા માટે આવશ્યક છે.

લાસ્ટ વિલ એન્ડ ટેસ્ટામેન્ટ (LWT)

જો કોઈ મહત્વપૂર્ણ ઉપકરણ, જેમ કે સુરક્ષા કેમેરા અથવા હાર્ટ મોનિટર, પાવર નિષ્ફળતા અથવા નેટવર્ક નુકસાનને કારણે અચાનક ડિસ્કનેક્ટ થઈ જાય તો શું થાય? LWT સુવિધા MQTT નો ઉકેલ છે. જ્યારે ક્લાયંટ કનેક્ટ થાય છે, ત્યારે તે બ્રોકર સાથે "છેલ્લો વસિયતનામું" સંદેશ રજીસ્ટર કરી શકે છે. જો ક્લાયંટ અયોગ્ય રીતે ડિસ્કનેક્ટ થાય છે (ડિસ્કનેક્ટ પેકેટ મોકલ્યા વિના), તો બ્રોકર આપમેળે આ છેલ્લો વસિયતનામું સંદેશ તેના વતી નિર્દિષ્ટ વિષય પર પ્રકાશિત કરશે.

ઉપકરણ સ્થિતિ નિરીક્ષણ માટે આ અમૂલ્ય છે. તમે એક ઉપકરણને કનેક્ટ થાય ત્યારે પેલોડ `"online"` સાથે `devices/device-123/status` સંદેશ પ્રકાશિત કરાવી શકો છો, અને સમાન વિષય સાથે પરંતુ પેલોડ `"offline"` સાથે LWT સંદેશ રજીસ્ટર કરાવી શકો છો. આ વિષય પર સબ્સ્ક્રાઇબ કરેલી કોઈપણ મોનિટરિંગ સેવા તરત જ ઉપકરણની સ્થિતિ જાણશે.

Paho-MQTT માં LWT અમલમાં મૂકવા માટે, તમે કનેક્ટ કરતા પહેલા તેને સેટ કરો છો:

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

client.connect(BROKER_ADDRESS, PORT, 60)

રીટેઈન્ડ સંદેશાઓ

સામાન્ય રીતે, જો કોઈ સબ્સ્ક્રાઇબર કોઈ વિષય સાથે કનેક્ટ થાય છે, તો તે ફક્ત તે સંદેશા પ્રાપ્ત કરશે જે તેને સબ્સ્ક્રાઇબ કર્યા પછી પ્રકાશિત થયા હોય. પરંતુ જો તમને તાત્કાલિક નવીનતમ મૂલ્યની જરૂર હોય તો શું? આ તે છે જેના માટે રીટેઈન્ડ સંદેશાઓ છે. જ્યારે `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 ને સુરક્ષિત કરવામાં ત્રણ મુખ્ય આધારસ્તંભ શામેલ છે: પ્રમાણીકરણ, એન્ક્રિપ્શન અને અધિકૃતતા.

પ્રમાણીકરણ: તમે કોણ છો?

પ્રમાણીકરણ બ્રોકર સાથે કનેક્ટ થતા ક્લાયંટની ઓળખને ચકાસે છે. સૌથી સરળ પદ્ધતિ વપરાશકર્તાનામ અને પાસવર્ડનો ઉપયોગ કરવાની છે. તમે તમારા Mosquitto બ્રોકરને ઓળખપત્રોની જરૂરિયાત માટે કન્ફિગર કરી શકો છો અને પછી તમારા પાયથોન ક્લાયંટમાં તેમને પ્રદાન કરી શકો છો.

તમારા પાયથોન ક્લાયંટમાં, `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) નો ઉપયોગ કરીને બ્રોકર પર હેન્ડલ થાય છે. તમે બ્રોકરને નિયમો સાથે કન્ફિગર કરો છો જે વ્યાખ્યાયિત કરે છે કે કયા વપરાશકર્તાઓ ચોક્કસ વિષય પેટર્ન પર `read` (સબ્સ્ક્રાઇબ) અથવા `write` (પ્રકાશિત) કરી શકે છે.

બધું એકસાથે મૂકવું: એક સરળ સ્માર્ટ એન્વાયર્નમેન્ટ મોનિટર પ્રોજેક્ટ

ચાલો આ ખ્યાલોને મજબૂત કરવા માટે થોડો વધુ વાસ્તવિક પ્રોજેક્ટ બનાવીએ. આપણે એક સેન્સર ઉપકરણનું અનુકરણ કરીશું જે 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()

print("બ્રોકરથી ડિસ્કનેક્ટ થયું.")

મોનિટરિંગ ડેશબોર્ડ કોડ (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 શ્રેષ્ઠ પ્રથાઓ

તમારા પ્રોજેક્ટને એક સરળ સ્ક્રિપ્ટમાંથી મજબૂત, માપી શકાય તેવી ઉત્પાદન સિસ્ટમમાં ખસેડવા માટે સાવચેતીપૂર્વક આયોજનની જરૂર છે. અહીં કેટલીક આવશ્યક શ્રેષ્ઠ પ્રથાઓ છે:

• સ્પષ્ટ વિષય વંશવેલો ડિઝાઇન કરો: શરૂઆતથી જ તમારી વિષય રચનાનું કાળજીપૂર્વક આયોજન કરો. એક સારી વંશવેલો વર્ણનાત્મક, માપી શકાય તેવી અને વાઇલ્ડકાર્ડનો ઉપયોગ કરીને લવચીક સબ્સ્ક્રિપ્શન્સ માટે પરવાનગી આપે છે. એક સામાન્ય પેટર્ન છે ////.
• નેટવર્ક ડિસ્કનેક્શનને સહેલાઈથી હેન્ડલ કરો: નેટવર્ક્સ અવિશ્વસનીય હોય છે. તમારા ક્લાયંટ કોડે મજબૂત રીકનેક્શન લોજિક અમલમાં મૂકવો જોઈએ. Paho-MQTT માં `on_disconnect` કોલબેક આ શરૂ કરવા માટે યોગ્ય સ્થળ છે, જે રીકનેક્શન પ્રયાસોથી નેટવર્કને છલકાવી દેવાનું ટાળવા માટે ઘાતાંકીય બેકઓફ જેવી વ્યૂહરચનાનો અમલ કરે છે.
• સ્ટ્રક્ચર્ડ ડેટા પેલોડ્સનો ઉપયોગ કરો: તમારા સંદેશાના પેલોડ્સ માટે હંમેશા JSON અથવા પ્રોટોકોલ બફર્સ જેવા સ્ટ્રક્ચર્ડ ડેટા ફોર્મેટનો ઉપયોગ કરો. આ તમારા ડેટાને સ્વ-વર્ણનાત્મક, સંસ્કરણ કરી શકાય તેવા અને વિવિધ એપ્લિકેશનો (કોઈપણ ભાષામાં લખાયેલ) માટે પાર્સ કરવા માટે સરળ બનાવે છે.
• ડિફોલ્ટ રૂપે બધું સુરક્ષિત કરો: સુરક્ષા વિના IoT સિસ્ટમ જમાવશો નહીં. ઓછામાં ઓછા, વપરાશકર્તાનામ/પાસવર્ડ પ્રમાણીકરણ અને TLS એન્ક્રિપ્શનનો ઉપયોગ કરો. ઉચ્ચ સુરક્ષા જરૂરિયાતો માટે, ક્લાયંટ પ્રમાણપત્ર-આધારિત પ્રમાણીકરણનું અન્વેષણ કરો.
• તમારા બ્રોકરનું નિરીક્ષણ કરો: ઉત્પાદન વાતાવરણમાં, તમારું MQTT બ્રોકર ઇન્ફ્રાસ્ટ્રક્ચરનો એક નિર્ણાયક ભાગ છે. તેની તંદુરસ્તીને ટ્રૅક કરવા માટે મોનિટરિંગ ટૂલ્સનો ઉપયોગ કરો, જેમાં CPU/મેમરી વપરાશ, કનેક્ટેડ ક્લાયંટ્સની સંખ્યા, સંદેશા દરો અને ડ્રોપ થયેલા સંદેશાઓનો સમાવેશ થાય છે. ઘણા બ્રોકર્સ એક વિશિષ્ટ `$SYS` ટોપિક વંશવેલો પ્રગટ કરે છે જે આ સ્થિતિ માહિતી પ્રદાન કરે છે.

નિષ્કર્ષ: પાયથોન અને MQTT સાથે તમારી યાત્રા

આપણે MQTT ના મૂળભૂત "શા માટે" થી લઈને પાયથોન સાથે તેને અમલમાં મૂકવાની વ્યવહારુ "કેવી રીતે" સુધીની યાત્રા કરી છે. તમે પબ્લિશ/સબસ્ક્રાઇબ મોડેલની શક્તિ, QoS નું મહત્વ અને સુરક્ષાની નિર્ણાયક ભૂમિકા વિશે શીખ્યા છો. તમે જોયું છે કે Paho-MQTT લાઇબ્રેરી સેન્સર ડેટા પ્રકાશિત કરી શકે અને આદેશો પર સબ્સ્ક્રાઇબ કરી શકે તેવા અત્યાધુનિક ક્લાયંટ્સ બનાવવા માટે તેને કેટલી સરળ બનાવે છે.

MQTT ફક્ત એક પ્રોટોકોલ કરતાં વધુ છે; તે ઇન્ટરનેટ ઑફ થિંગ્સ માટે એક પાયાની તકનીક છે. તેની હલકી પ્રકૃતિ અને મજબૂત સુવિધાઓએ તેને વિશ્વભરના લાખો ઉપકરણો માટે પસંદગીનો વિકલ્પ બનાવ્યો છે, સ્માર્ટ શહેરોથી લઈને કનેક્ટેડ કૃષિથી ઔદ્યોગિક ઓટોમેશન સુધી.

યાત્રા અહીં સમાપ્ત થતી નથી. આગલું પગલું આ ખ્યાલોને લેવાનું અને તેમને વાસ્તવિક હાર્ડવેર પર લાગુ કરવાનું છે. રાસ્પબેરી પાઇ, ESP32 અથવા અન્ય માઇક્રોકન્ટ્રોલર્સ સાથે પ્રયોગ કરો. ભૌતિક સેન્સરને કનેક્ટ કરો, ક્લાઉડ IoT પ્લેટફોર્મ સાથે એકીકૃત કરો અને ભૌતિક વિશ્વ સાથે ક્રિયાપ્રતિક્રિયા કરતી એપ્લિકેશનો બનાવો. પાયથોન અને MQTT સાથે, તમારી પાસે કનેક્ટેડ સોલ્યુશન્સની આગામી પેઢી બનાવવા માટે એક શક્તિશાળી ટૂલકિટ છે.