పైథాన్ ఉపయోగించి IoT కోసం MQTT ప్రోటోకాల్‌పై పట్టు సాధించండి. ఈ లోతైన గైడ్ సూత్రాలు, పాహో-MQTT లైబ్రరీ, భద్రత, మరియు వాస్తవ-ప్రపంచ ప్రాజెక్ట్ అమలును వివరిస్తుంది.
IoT కోసం పైథాన్: MQTT అమలుకు ఒక సమగ్ర గైడ్
కనెక్ట్ చేయబడిన ప్రపంచం: ఐఓటి ప్రోటోకాల్స్ ఎందుకు ముఖ్యమైనవి
మనం అపూర్వమైన కనెక్టివిటీ యుగంలో జీవిస్తున్నాము. ఇంటర్నెట్ ఆఫ్ థింగ్స్ (IoT) ఇకపై భవిష్యత్ భావన కాదు; ఇది ఒక ప్రపంచ వాస్తవికత, నిశ్శబ్దంగా బిలియన్ల కొద్దీ స్మార్ట్ పరికరాల నెట్‌వర్క్‌ను అల్లుతోంది, ఇవి మన పర్యావరణాన్ని పర్యవేక్షిస్తాయి, మన ఇళ్లను ఆటోమేట్ చేస్తాయి, మన పరిశ్రమలను ఆప్టిమైజ్ చేస్తాయి మరియు మన నగరాలను క్రమబద్ధీకరిస్తాయి. సియోల్‌లోని ఒక ఇంట్లో ఉన్న స్మార్ట్ థర్మోస్టాట్ నుండి కెన్యా గ్రామీణ ప్రాంతంలోని ఒక వ్యవసాయ సెన్సార్ వరకు, ఈ పరికరాలు అపారమైన డేటాను ఉత్పత్తి చేస్తున్నాయి. కానీ అవి అన్నీ ఒకదానితో ఒకటి మరియు క్లౌడ్‌తో ఎలా మాట్లాడుకుంటాయి, ముఖ్యంగా అవి తరచుగా చిన్నవిగా, తక్కువ శక్తితో మరియు నమ్మదగని నెట్‌వర్క్‌లపై పనిచేస్తున్నప్పుడు? దీనికి సమాధానం ప్రత్యేకమైన కమ్యూనికేషన్ ప్రోటోకాల్స్‌లో ఉంది.
మనం రోజువారీ ఉపయోగించే వెబ్‌లో అధిక భాగం HTTP ప్రోటోకాల్‌పై ఆధారపడి ఉన్నప్పటికీ, ఇది IoT యొక్క పరిమిత ప్రపంచానికి తరచుగా చాలా బరువుగా మరియు ఎక్కువ శక్తిని వినియోగించేదిగా ఉంటుంది. ఇక్కడే మెషిన్-టు-మెషిన్ (M2M) కమ్యూనికేషన్ కోసం ప్రత్యేకంగా రూపొందించిన ప్రోటోకాల్స్ ప్రకాశిస్తాయి. వాటిలో ఒకటి ఒక ప్రముఖ శక్తిగా ఉద్భవించింది: MQTT.
ఈ సమగ్ర గైడ్ ప్రపంచవ్యాప్తంగా ఉన్న డెవలపర్లు, ఇంజనీర్లు మరియు హాబీయిస్ట్‌ల కోసం రూపొందించబడింది, వీరు IoT స్పేస్‌లో అత్యంత బహుముఖ మరియు ప్రసిద్ధ ప్రోగ్రామింగ్ భాషలలో ఒకటైన పైథాన్‌ను ఉపయోగించి MQTT యొక్క శక్తిని ఉపయోగించుకోవాలని కోరుకుంటారు. మనం MQTT యొక్క ప్రాథమిక భావనల నుండి సురక్షితమైన, దృఢమైన మరియు స్కేలబుల్ IoT అప్లికేషన్‌లను నిర్మించడం వరకు ప్రయాణిస్తాము.
MQTT అంటే ఏమిటి? పరిమితుల కోసం నిర్మించిన ప్రోటోకాల్
MQTT అంటే మెసేజ్ క్యూయింగ్ టెలిమెట్రీ ట్రాన్స్‌పోర్ట్. ఇది 1999లో IBMకి చెందిన డాక్టర్ ఆండీ స్టాన్‌ఫోర్డ్-క్లార్క్ మరియు ఆర్కామ్ (ఇప్పుడు సిర్రస్ లింక్)కి చెందిన ఆర్లెన్ నిప్పర్ ద్వారా నమ్మదగని ఉపగ్రహ నెట్‌వర్క్‌ల ద్వారా చమురు పైప్‌లైన్‌లను పర్యవేక్షించడానికి కనుగొనబడింది. దీని మూల కథ దాని ఉద్దేశ్యాన్ని సంపూర్ణంగా సంగ్రహిస్తుంది: ముఖ్యమైన పరిమితుల కింద పనిచేసే పరికరాల కోసం తేలికపాటి, నమ్మదగిన మరియు సమర్థవంతమైన సందేశ ప్రోటోకాల్‌గా ఉండటం.
పబ్లిష్/సబ్‌స్క్రైబ్ (పబ్/సబ్) మోడల్ వివరణ
MQTT యొక్క గుండెకాయ సొగసైన పబ్లిష్/సబ్‌స్క్రైబ్ ఆర్కిటెక్చరల్ నమూనా. ఇది చాలా మంది డెవలపర్‌లకు తెలిసిన HTTP యొక్క రిక్వెస్ట్/రెస్పాన్స్ మోడల్ నుండి ప్రాథమికంగా భిన్నమైనది. క్లయింట్ నేరుగా సర్వర్ నుండి సమాచారాన్ని అభ్యర్థించే బదులు, కమ్యూనికేషన్ వేరు చేయబడుతుంది (decoupled).
ఒక ప్రపంచ వార్తా సంస్థను ఊహించుకోండి. జర్నలిస్టులు (పబ్లిషర్లు) తమ కథలను నేరుగా ప్రతి ఒక్క పాఠకుడికి పంపరు. బదులుగా, వారు తమ కథలను ఏజెన్సీ యొక్క కేంద్ర హబ్ (బ్రోకర్)కు పంపుతారు మరియు వాటిని "ప్రపంచ రాజకీయాలు" లేదా "టెక్నాలజీ" వంటి నిర్దిష్ట అంశాల (టాపిక్స్) క్రింద వర్గీకరిస్తారు. పాఠకులు (సబ్‌స్క్రైబర్లు) అప్‌డేట్‌ల కోసం జర్నలిస్టులను అడగాల్సిన అవసరం లేదు; వారు కేవలం ఏజెన్సీకి తమకు ఏ అంశాలపై ఆసక్తి ఉందో తెలియజేస్తారు. అప్పుడు ఏజెన్సీ ఆ అంశాలపై ఏదైనా కొత్త కథనాలను ఆసక్తిగల పాఠకులకు స్వయంచాలకంగా ఫార్వార్డ్ చేస్తుంది. జర్నలిస్టులు మరియు పాఠకులు ఒకరి ఉనికి, ప్రదేశం లేదా స్థితి గురించి తెలుసుకోవాల్సిన అవసరం ఎప్పుడూ ఉండదు.
MQTTలో, ఈ మోడల్ డేటాను పంపే పరికరాన్ని (పబ్లిషర్) దానిని స్వీకరించే పరికరం లేదా అప్లికేషన్ (సబ్‌స్క్రైబర్) నుండి వేరు చేస్తుంది. ఇది IoT కోసం చాలా శక్తివంతమైనది ఎందుకంటే:
- స్థల విభజన: పబ్లిషర్ మరియు సబ్‌స్క్రైబర్ ఒకరి ఐపి చిరునామా లేదా స్థానం తెలుసుకోవలసిన అవసరం లేదు.
- కాల విభజన: అవి ఒకే సమయంలో రన్ అవ్వాల్సిన అవసరం లేదు. ఒక సెన్సార్ ఒక రీడింగ్‌ను ప్రచురించగలదు మరియు ఒక అప్లికేషన్ సిస్టమ్ రూపకల్పన ప్రకారం గంటల తర్వాత దానిని స్వీకరించగలదు.
- సమకాలీకరణ విభజన: సందేశ మార్పిడి పూర్తి చేయడానికి ఒకరి కోసం మరొకరు వేచి ఉండవలసిన అవసరం లేకుండా రెండు వైపులా కార్యకలాపాలు నిలిపివేయబడవు.
MQTT పర్యావరణ వ్యవస్థ యొక్క ముఖ్య భాగాలు
MQTT ఆర్కిటెక్చర్ కొన్ని ముఖ్య భాగాలపై నిర్మించబడింది:
- బ్రోకర్: కేంద్ర హబ్ లేదా సర్వర్. ఇది MQTT ప్రపంచం యొక్క పోస్ట్ ఆఫీస్. బ్రోకర్ పబ్లిషర్‌ల నుండి అన్ని సందేశాలను స్వీకరించడానికి, వాటిని టాపిక్ ద్వారా ఫిల్టర్ చేయడానికి మరియు వాటిని తగిన సబ్‌స్క్రైబర్‌లకు పంపడానికి బాధ్యత వహిస్తుంది. ప్రముఖ బ్రోకర్‌లలో ఓపెన్-సోర్స్ ఎంపికలైన మాస్కిటో మరియు వెర్న్‌ఎమ్‌క్యూ, మరియు AWS IoT కోర్, అజూర్ IoT హబ్, మరియు గూగుల్ క్లౌడ్ IoT కోర్ వంటి నిర్వహించబడే క్లౌడ్ సేవలు ఉన్నాయి.
- క్లయింట్: బ్రోకర్‌కు కనెక్ట్ అయ్యే ఏదైనా పరికరం లేదా అప్లికేషన్. ఒక క్లయింట్ పబ్లిషర్, సబ్‌స్క్రైబర్ లేదా రెండూ కావచ్చు. ఒక IoT సెన్సార్ ఒక క్లయింట్, మరియు సెన్సార్ డేటాను ప్రాసెస్ చేసే సర్వర్ అప్లికేషన్ కూడా ఒక క్లయింట్.
- టాపిక్: సందేశాలకు చిరునామా లేదా లేబుల్‌గా పనిచేసే ఒక UTF-8 స్ట్రింగ్. బ్రోకర్ సందేశాలను రూట్ చేయడానికి టాపిక్‌లను ఉపయోగిస్తుంది. టాపిక్‌లు క్రమానుగతంగా ఉంటాయి, ఫైల్ సిస్టమ్ పాత్ లాగా ఫార్వర్డ్ స్లాష్‌లను డీలిమిటర్‌లుగా ఉపయోగిస్తాయి. ఉదాహరణకు, లండన్‌లోని ఒక భవనంలోని లివింగ్ రూమ్‌లో ఉన్న ఉష్ణోగ్రత సెన్సార్ కోసం ఒక మంచి టాపిక్ ఇలా ఉండవచ్చు:
UK/London/Building-A/Floor-1/LivingRoom/Temperature. - పేలోడ్: ఇది సందేశం యొక్క వాస్తవ డేటా కంటెంట్. MQTT డేటా-అజ్ఞాతమైనది, అంటే పేలోడ్ ఏదైనా కావచ్చు: ఒక సాధారణ స్ట్రింగ్, ఒక పూర్ణాంకం, JSON, XML, లేదా ఎన్‌క్రిప్ట్ చేయబడిన బైనరీ డేటా. JSON దాని సౌలభ్యం మరియు చదవగలిగే గుణం కారణంగా చాలా సాధారణ ఎంపిక.
IoT కమ్యూనికేషన్‌లో MQTT ఎందుకు ఆధిపత్యం చెలాయిస్తుంది
MQTT యొక్క డిజైన్ సూత్రాలు IoT యొక్క సవాళ్లకు అసాధారణంగా సరిపోతాయి:
- తేలికైనది: MQTT సందేశాలకు చాలా చిన్న హెడర్ (2 బైట్ల వరకు) ఉంటుంది, ఇది నెట్‌వర్క్ బ్యాండ్‌విడ్త్ వినియోగాన్ని తగ్గిస్తుంది. ఖరీదైన సెల్యులార్ ప్లాన్‌లు లేదా LoRaWAN వంటి తక్కువ-బ్యాండ్‌విడ్త్ నెట్‌వర్క్‌లలోని పరికరాలకు ఇది కీలకం.
- సమర్థవంతమైనది: ప్రోటోకాల్ యొక్క తక్కువ ఓవర్‌హెడ్ నేరుగా తక్కువ విద్యుత్ వినియోగానికి దారితీస్తుంది, బ్యాటరీతో నడిచే పరికరాలు నెలలు లేదా సంవత్సరాల తరబడి పనిచేయడానికి అనుమతిస్తుంది.
- నమ్మదగినది: ఇది అస్థిరమైన, అధిక-లేటెన్సీ నెట్‌వర్క్‌లలో కూడా సందేశ డెలివరీని నిర్ధారించడానికి ఫీచర్‌లను కలిగి ఉంటుంది. ఇది క్వాలిటీ ఆఫ్ సర్వీస్ స్థాయిల ద్వారా నిర్వహించబడుతుంది.
- స్కేలబుల్: ఒకే బ్రోకర్ వేలాది లేదా లక్షలాది క్లయింట్ల నుండి కనెక్షన్‌లను ఏకకాలంలో నిర్వహించగలదు, ఇది పెద్ద-స్థాయి విస్తరణలకు అనుకూలంగా ఉంటుంది.
- ద్విదిశాత్మకమైనది: MQTT పరికరం-నుండి-క్లౌడ్ (టెలిమెట్రీ) మరియు క్లౌడ్-నుండి-పరికరం (ఆదేశాలు) కమ్యూనికేషన్‌కు అనుమతిస్తుంది, ఇది పరికరాలను రిమోట్‌గా నియంత్రించడానికి ఒక ముఖ్యమైన అవసరం.
క్వాలిటీ ఆఫ్ సర్వీస్ (QoS)ను అర్థం చేసుకోవడం
MQTT మూడు స్థాయిల క్వాలిటీ ఆఫ్ సర్వీస్ (QoS)ను అందిస్తుంది, ఇది డెవలపర్లు వారి నిర్దిష్ట వినియోగ సందర్భానికి విశ్వసనీయత మరియు ఓవర్‌హెడ్ మధ్య సరైన సమతుల్యతను ఎంచుకోవడానికి అనుమతిస్తుంది.
- QoS 0 (అత్యధికంగా ఒకసారి): ఇది "ఫైర్ అండ్ ఫర్గెట్" స్థాయి. సందేశం ఒకసారి పంపబడుతుంది, బ్రోకర్ లేదా చివరి సబ్‌స్క్రైబర్ నుండి రసీదు యొక్క నిర్ధారణ లేకుండా. ఇది వేగవంతమైన పద్ధతి కానీ డెలివరీకి ఎటువంటి హామీ ఇవ్వదు. వినియోగ సందర్భం: ప్రతి 10 సెకన్లకు పంపబడే గది ఉష్ణోగ్రత రీడింగ్ వంటి ప్రాముఖ్యత లేని, అధిక-ఫ్రీక్వెన్సీ సెన్సార్ డేటా. ఒక రీడింగ్ కోల్పోవడం సమస్య కాదు.
- QoS 1 (కనీసం ఒకసారి): ఈ స్థాయి సందేశం కనీసం ఒకసారి డెలివరీ చేయబడుతుందని హామీ ఇస్తుంది. పంపినవారు స్వీకర్త నుండి రసీదు (ఒక PUBACK ప్యాకెట్) అందుకునే వరకు సందేశాన్ని నిల్వ చేస్తారు. రసీదు అందకపోతే, సందేశం మళ్లీ పంపబడుతుంది. రసీదు కోల్పోతే ఇది కొన్నిసార్లు నకిలీ సందేశాలకు దారితీయవచ్చు. వినియోగ సందర్భం: స్మార్ట్ లైట్‌ను ఆన్ చేయడానికి ఒక ఆదేశం. ఆదేశం స్వీకరించబడిందని మీరు నిర్ధారించుకోవాలి మరియు దానిని రెండుసార్లు స్వీకరించడం వల్ల ఎటువంటి హాని జరగదు.
- QoS 2 (సరిగ్గా ఒకసారి): ఇది అత్యంత నమ్మదగినది కానీ నెమ్మదైన స్థాయి. ఇది సందేశం సరిగ్గా ఒకసారి, నకిలీలు లేకుండా డెలివరీ చేయబడిందని నిర్ధారించడానికి నాలుగు-భాగాల హ్యాండ్‌షేక్‌ను ఉపయోగిస్తుంది. వినియోగ సందర్భం: ఆర్థిక లావాదేవీ, ఒక ఖచ్చితమైన మోతాదులో మందును పంపిణీ చేయడానికి ఒక ఆదేశం లేదా ఫ్యాక్టరీలో రోబోటిక్ ఆర్మ్‌ను నియంత్రించడం వంటి నకిలీలు విపత్తుకు దారితీసే క్లిష్టమైన కార్యకలాపాలు.
మీ పైథాన్ MQTT ఎన్విరాన్‌మెంట్‌ను సెటప్ చేయడం
ఇప్పుడు, ఆచరణాత్మకంగా చూద్దాం. పైథాన్‌తో MQTT అప్లికేషన్‌లను నిర్మించడం ప్రారంభించడానికి, మీకు రెండు విషయాలు అవసరం: MQTT క్లయింట్ కోసం ఒక పైథాన్ లైబ్రరీ మరియు కమ్యూనికేట్ చేయడానికి ఒక MQTT బ్రోకర్.
పైథాన్ MQTT లైబ్రరీని ఎంచుకోవడం: పాహో-MQTT
పైథాన్ కోసం అత్యంత విస్తృతంగా ఉపయోగించే మరియు పరిణతి చెందిన MQTT లైబ్రరీ ఎక్లిప్స్ ఫౌండేషన్ నుండి వచ్చిన పాహో-MQTT. ఇది ఒక దృఢమైన, ఫీచర్-రిచ్ లైబ్రరీ, ఇది బ్రోకర్‌కు కనెక్ట్ అవ్వడానికి మరియు టాపిక్‌లకు పబ్లిష్ లేదా సబ్‌స్క్రైబ్ చేయడానికి ఒక క్లయింట్ క్లాస్‌ను అందిస్తుంది. పైథాన్ ప్యాకేజీ మేనేజర్ అయిన పిప్ ఉపయోగించి దీన్ని ఇన్‌స్టాల్ చేయడం చాలా సులభం.
మీ టెర్మినల్ లేదా కమాండ్ ప్రాంప్ట్ తెరిచి, రన్ చేయండి:
pip install paho-mqtt
ఈ ఒక్క ఆదేశం పైథాన్‌లో MQTT క్లయింట్‌లను రాయడం ప్రారంభించడానికి మీకు అవసరమైన ప్రతిదాన్ని ఇన్‌స్టాల్ చేస్తుంది.
ఒక MQTT బ్రోకర్‌ను సెటప్ చేయడం
బ్రోకర్ కోసం మీకు అనేక ఎంపికలు ఉన్నాయి, అభివృద్ధి కోసం మీ స్థానిక మెషీన్‌లో ఒకదాన్ని రన్ చేయడం నుండి ఉత్పత్తి కోసం శక్తివంతమైన క్లౌడ్ సేవను ఉపయోగించడం వరకు.
- స్థానిక బ్రోకర్ (అభివృద్ధి మరియు నేర్చుకోవడం కోసం): స్థానిక బ్రోకర్ కోసం అత్యంత ప్రజాదరణ పొందిన ఎంపిక మాస్కిటో, మరొక ఎక్లిప్స్ ప్రాజెక్ట్. ఇది తేలికైనది, ఓపెన్-సోర్స్, మరియు ఇన్‌స్టాల్ చేయడం సులభం.
- డెబియన్-ఆధారిత లైనక్స్ (ఉబుంటు, రాస్ప్‌బెర్రీ పై OS వంటివి):
sudo apt-get update && sudo apt-get install mosquitto mosquitto-clients - macOS (హోమ్‌బ్రూ ఉపయోగించి):
brew install mosquitto - విండోస్‌లో: మాస్కిటో వెబ్‌సైట్ నుండి నేటివ్ ఇన్‌స్టాలర్‌ను డౌన్‌లోడ్ చేసుకోండి.
127.0.0.1లేదాlocalhost) పాయింట్ చేయడం ద్వారా మీరు దానిని ఉపయోగించవచ్చు. - డెబియన్-ఆధారిత లైనక్స్ (ఉబుంటు, రాస్ప్‌బెర్రీ పై OS వంటివి):
- పబ్లిక్/క్లౌడ్ బ్రోకర్ (త్వరిత పరీక్ష కోసం): ఏమీ ఇన్‌స్టాల్ చేయకుండా ప్రారంభ ప్రయోగాల కోసం, మీరు ఉచిత, పబ్లిక్ బ్రోకర్‌ను ఉపయోగించవచ్చు. రెండు ప్రసిద్ధమైనవి
test.mosquitto.orgమరియుbroker.hivemq.com. ముఖ్యమైనది: ఇవి పబ్లిక్ మరియు గుప్తీకరించబడనివి. వాటికి ఎలాంటి సున్నితమైన లేదా ప్రైవేట్ డేటాను పంపవద్దు. అవి కేవలం నేర్చుకోవడం మరియు పరీక్ష ప్రయోజనాల కోసం మాత్రమే.
స్వయంగా చేయడం: పైథాన్‌తో పబ్లిషింగ్ మరియు సబ్‌స్క్రైబింగ్
మన మొదటి పైథాన్ MQTT అప్లికేషన్‌ను రాద్దాం. మనం రెండు వేర్వేరు స్క్రిప్ట్‌లను సృష్టిస్తాము: సందేశాలను పంపే ఒక పబ్లిషర్ మరియు వాటిని స్వీకరించే ఒక సబ్‌స్క్రైబర్. ఈ ఉదాహరణ కోసం, మీరు స్థానిక మాస్కిటో బ్రోకర్‌ను నడుపుతున్నారని మేము భావిస్తాము.
ఒక సాధారణ MQTT పబ్లిషర్‌ను సృష్టించడం (publisher.py)
ఈ స్క్రిప్ట్ బ్రోకర్‌కు కనెక్ట్ అవుతుంది మరియు ప్రతి రెండు సెకన్లకు python/mqtt/test అనే టాపిక్‌కు "హలో, MQTT!" అనే సందేశాన్ని పబ్లిష్ చేస్తుంది.
publisher.py అనే ఫైల్‌ను సృష్టించి, కింది కోడ్‌ను జోడించండి:
import paho.mqtt.client as mqtt
import time
# --- Configuration ---
BROKER_ADDRESS = "localhost" # Use 'test.mosquitto.org' for a public broker
PORT = 1883
TOPIC = "python/mqtt/test"
# --- Callback for connection ---
def on_connect(client, userdata, flags, rc):
if rc == 0:
print("Connected to MQTT Broker!")
else:
print(f"Failed to connect, return code {rc}")
# --- Main script ---
# 1. Create a client instance
client = mqtt.Client("PublisherClient")
# 2. Assign the on_connect callback
client.on_connect = on_connect
# 3. Connect to the broker
client.connect(BROKER_ADDRESS, PORT, 60)
# 4. Start a background thread for the network loop
client.loop_start()
try:
count = 0
while True:
count += 1
message = f"Hello, MQTT! Message #{count}"
# 5. Publish a message
result = client.publish(TOPIC, message)
# Check if publish was successful
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. Stop the network loop and disconnect
client.loop_stop()
client.disconnect()
print("Disconnected from the broker.")
ఒక సాధారణ MQTT సబ్‌స్క్రైబర్‌ను సృష్టించడం (subscriber.py)
ఈ స్క్రిప్ట్ అదే బ్రోకర్‌కు కనెక్ట్ అవుతుంది, python/mqtt/test టాపిక్‌కు సబ్‌స్క్రైబ్ అవుతుంది మరియు అది స్వీకరించిన ఏవైనా సందేశాలను ప్రింట్ చేస్తుంది.
subscriber.py అనే మరో ఫైల్‌ను సృష్టించండి:
import paho.mqtt.client as mqtt
# --- Configuration ---
BROKER_ADDRESS = "localhost"
PORT = 1883
TOPIC = "python/mqtt/test"
# --- Callback functions ---
def on_connect(client, userdata, flags, rc):
if rc == 0:
print("Connected to MQTT Broker!")
# Subscribe to the topic upon successful connection
client.subscribe(TOPIC)
else:
print(f"Failed to connect, return code {rc}")
def on_message(client, userdata, msg):
# Decode the message payload from bytes to string
payload = msg.payload.decode()
print(f"Received message: `{payload}` on topic `{msg.topic}`")
# --- Main script ---
# 1. Create a client instance
client = mqtt.Client("SubscriberClient")
# 2. Assign callbacks
client.on_connect = on_connect
client.on_message = on_message
# 3. Connect to the broker
client.connect(BROKER_ADDRESS, PORT, 60)
# 4. Start the network loop (blocking call)
# This function handles reconnecting and processing messages automatically.
print("Subscriber is listening...")
client.loop_forever()
ఉదాహరణను రన్ చేయడం
- రెండు వేర్వేరు టెర్మినల్ విండోలను తెరవండి.
- మొదటి టెర్మినల్‌లో, సబ్‌స్క్రైబర్ స్క్రిప్ట్‌ను రన్ చేయండి:
python subscriber.py - మీకు "Subscriber is listening..." అనే సందేశం కనిపిస్తుంది. ఇది ఇప్పుడు సందేశాల కోసం వేచి ఉంది.
- రెండవ టెర్మినల్‌లో, పబ్లిషర్ స్క్రిప్ట్‌ను రన్ చేయండి:
python publisher.py - పబ్లిషర్ ప్రతి రెండు సెకన్లకు సందేశాలు పంపడం మీరు చూస్తారు. అదే సమయంలో, ఈ సందేశాలు సబ్‌స్క్రైబర్ టెర్మినల్ విండోలో కనిపిస్తాయి.
అభినందనలు! మీరు పైథాన్ ఉపయోగించి ఒక పూర్తి, పనిచేసే MQTT కమ్యూనికేషన్ సిస్టమ్‌ను సృష్టించారు.
ప్రాథమికాంశాలకు మించి: అధునాతన పాహో-MQTT ఫీచర్లు
వాస్తవ-ప్రపంచ IoT సిస్టమ్‌లకు మన సాధారణ ఉదాహరణ కంటే ఎక్కువ పటిష్టత అవసరం. ఉత్పత్తి-సిద్ధమైన అప్లికేషన్‌లను నిర్మించడానికి అవసరమైన కొన్ని అధునాతన MQTT ఫీచర్‌లను అన్వేషిద్దాం.
చివరి వీలునామా మరియు ఒడంబడిక (Last Will and Testament - LWT)
ఒక భద్రతా కెమెరా లేదా హార్ట్ మానిటర్ వంటి ఒక క్లిష్టమైన పరికరం విద్యుత్ వైఫల్యం లేదా నెట్‌వర్క్ నష్టం కారణంగా అనుకోకుండా డిస్‌కనెక్ట్ అయితే ఏమి జరుగుతుంది? LWT ఫీచర్ MQTT యొక్క పరిష్కారం. ఒక క్లయింట్ కనెక్ట్ అయినప్పుడు, అది బ్రోకర్‌తో ఒక "చివరి వీలునామా" సందేశాన్ని నమోదు చేయగలదు. క్లయింట్ అనాగరికంగా డిస్‌కనెక్ట్ అయితే (ఒక DISCONNECT ప్యాకెట్‌ను పంపకుండా), బ్రోకర్ ఈ చివరి వీలునామా సందేశాన్ని దాని తరపున ఒక నిర్దిష్ట టాపిక్‌కు స్వయంచాలకంగా ప్రచురిస్తుంది.
పరికరం స్థితిని పర్యవేక్షించడానికి ఇది అమూల్యమైనది. మీరు ఒక పరికరం కనెక్ట్ అయినప్పుడు devices/device-123/status సందేశాన్ని "online" పేలోడ్‌తో ప్రచురించేలా చేయవచ్చు, మరియు అదే టాపిక్‌తో కానీ "offline" పేలోడ్‌తో LWT సందేశాన్ని నమోదు చేయవచ్చు. ఈ టాపిక్‌కు సబ్‌స్క్రైబ్ అయిన ఏదైనా పర్యవేక్షణ సేవ పరికరం స్థితిని తక్షణమే తెలుసుకుంటుంది.
పాహో-MQTTలో LWTని అమలు చేయడానికి, మీరు కనెక్ట్ అయ్యే ముందు దానిని సెట్ చేయాలి:
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తో ప్రచురించగలదు. ప్రారంభమై సబ్‌స్క్రైబ్ అయ్యే ఏదైనా అప్లికేషన్ తదుపరి నవీకరణ కోసం వేచి ఉండకుండా పరికరం యొక్క ప్రస్తుత స్థితిని వెంటనే తెలుసుకుంటుంది.
పాహో-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ని సురక్షితం చేయడంలో మూడు ముఖ్య స్తంభాలు ఉన్నాయి: ప్రామాణీకరణ, గుప్తీకరణ మరియు అధికారికత.
ప్రామాణీకరణ: మీరు ఎవరు?
ప్రామాణీకరణ బ్రోకర్‌కు కనెక్ట్ అవుతున్న క్లయింట్ యొక్క గుర్తింపును ధృవీకరిస్తుంది. సులభమైన పద్ధతి వినియోగదారు పేరు మరియు పాస్‌వర్డ్ ఉపయోగించడం. మీరు మీ మాస్కిటో బ్రోకర్‌ను ఆధారాలను అవసరం అయ్యేలా కాన్ఫిగర్ చేసి, ఆపై వాటిని మీ పైథాన్ క్లయింట్‌లో అందించవచ్చు.
మీ పైథాన్ క్లయింట్‌లో, 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) సర్టిఫికేట్‌ను కలిగి ఉంటుంది.
పాహో-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) కాదు. ఇది సాధారణంగా యాక్సెస్ కంట్రోల్ లిస్ట్స్ (ACLలు) ఉపయోగించి బ్రోకర్‌లో నిర్వహించబడుతుంది. మీరు ఏ వినియోగదారులు నిర్దిష్ట టాపిక్ నమూనాలకు చదవగలరు (సబ్‌స్క్రైబ్) లేదా వ్రాయగలరు (పబ్లిష్) అని నిర్వచించే నిబంధనలతో బ్రోకర్‌ను కాన్ఫిగర్ చేస్తారు.
అన్నింటినీ కలిపి ఉంచడం: ఒక సాధారణ స్మార్ట్ ఎన్విరాన్‌మెంట్ మానిటర్ ప్రాజెక్ట్
ఈ భావనలను పటిష్టం చేయడానికి కొంచెం వాస్తవికమైన ప్రాజెక్ట్‌ను నిర్మిద్దాం. మనం పర్యావరణ డేటాను 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("Sensor publisher started...")
try:
while True:
# Simulate sensor readings
temperature = round(random.uniform(20.0, 30.0), 2)
humidity = round(random.uniform(40.0, 60.0), 2)
# Create a JSON payload
payload = {
"timestamp": time.time(),
"temperature": temperature,
"humidity": humidity
}
payload_str = json.dumps(payload)
# Publish the message with QoS 1
result = client.publish(TOPIC, payload_str, qos=1)
result.wait_for_publish() # Block until publish is confirmed
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:
# Decode the payload string and parse it as 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 ఉత్తమ పద్ధతులు
మీ ప్రాజెక్ట్‌ను ఒక సాధారణ స్క్రిప్ట్ నుండి దృఢమైన, స్కేలబుల్ ఉత్పత్తి వ్యవస్థకు తరలించడానికి జాగ్రత్తగా ప్రణాళిక అవసరం. ఇక్కడ కొన్ని అవసరమైన ఉత్తమ పద్ధతులు ఉన్నాయి:
- స్పష్టమైన టాపిక్ సోపానక్రమాన్ని రూపొందించండి: ప్రారంభం నుండి మీ టాపిక్ నిర్మాణాన్ని జాగ్రత్తగా ప్లాన్ చేయండి. ఒక మంచి సోపానక్రమం వర్ణనాత్మకమైనది, స్కేలబుల్, మరియు వైల్డ్‌కార్డ్‌లను ఉపయోగించి సౌకర్యవంతమైన సబ్‌స్క్రిప్షన్‌లను అనుమతిస్తుంది. ఒక సాధారణ నమూనా
<సైట్>/<ప్రాంతం>/<పరికర_రకం>/<పరికర_ఐడి>/<కొలత>. - నెట్‌వర్క్ డిస్‌కనక్షన్‌లను సునాయాసంగా నిర్వహించండి: నెట్‌వర్క్‌లు నమ్మదగనివి. మీ క్లయింట్ కోడ్ దృఢమైన పునఃకనెక్ట్ తర్కాన్ని అమలు చేయాలి. పాహో-MQTTలోని
on_disconnectకాల్‌బ్యాక్ దీనిని ప్రారంభించడానికి సరైన ప్రదేశం, పునఃకనెక్ట్ ప్రయత్నాలతో నెట్‌వర్క్‌ను ముంచెత్తకుండా ఉండటానికి ఎక్స్‌పోనెన్షియల్ బ్యాక్‌ఆఫ్ వంటి వ్యూహాన్ని అమలు చేస్తుంది. - నిర్మాణాత్మక డేటా పేలోడ్‌లను ఉపయోగించండి: మీ సందేశ పేలోడ్‌ల కోసం ఎల్లప్పుడూ JSON లేదా ప్రోటోకాల్ బఫర్‌ల వంటి నిర్మాణాత్మక డేటా ఆకృతిని ఉపయోగించండి. ఇది మీ డేటాను స్వీయ-వర్ణన, సంస్కరణ మరియు వివిధ అప్లికేషన్‌లు (ఏ భాషలోనైనా వ్రాయబడినవి) సులభంగా పార్స్ చేయడానికి వీలు కల్పిస్తుంది.
- ప్రతిదీ డిఫాల్ట్‌గా సురక్షితం చేయండి: భద్రత లేకుండా IoT వ్యవస్థను అమలు చేయవద్దు. కనీసం, వినియోగదారు పేరు/పాస్‌వర్డ్ ప్రామాణీకరణ మరియు TLS గుప్తీకరణను ఉపయోగించండి. అధిక భద్రతా అవసరాల కోసం, క్లయింట్ సర్టిఫికేట్-ఆధారిత ప్రామాణీకరణను అన్వేషించండి.
- మీ బ్రోకర్‌ను పర్యవేక్షించండి: ఒక ఉత్పత్తి వాతావరణంలో, మీ MQTT బ్రోకర్ ఒక క్లిష్టమైన మౌలిక సదుపాయం. CPU/మెమరీ వినియోగం, కనెక్ట్ చేయబడిన క్లయింట్ల సంఖ్య, సందేశ రేట్లు మరియు వదిలివేసిన సందేశాలతో సహా దాని ఆరోగ్యాన్ని ట్రాక్ చేయడానికి పర్యవేక్షణ సాధనాలను ఉపయోగించండి. చాలా బ్రోకర్లు ఈ స్థితి సమాచారాన్ని అందించే ఒక ప్రత్యేక
$SYSటాపిక్ సోపానక్రమాన్ని బహిర్గతం చేస్తాయి.
ముగింపు: పైథాన్ మరియు MQTTతో మీ ప్రయాణం
మనం MQTT యొక్క ప్రాథమిక "ఎందుకు" నుండి పైథాన్‌తో దానిని అమలు చేసే ఆచరణాత్మక "ఎలా" వరకు ప్రయాణించాము. మీరు పబ్లిష్/సబ్‌స్క్రైబ్ మోడల్ యొక్క శక్తి, QoS యొక్క ప్రాముఖ్యత మరియు భద్రత యొక్క క్లిష్టమైన పాత్ర గురించి నేర్చుకున్నారు. పాహో-MQTT లైబ్రరీ సెన్సార్ డేటాను ప్రచురించగల మరియు ఆదేశాలకు సబ్‌స్క్రైబ్ చేయగల అధునాతన క్లయింట్‌లను నిర్మించడం ఎంత సులభం చేస్తుందో మీరు చూశారు.
MQTT కేవలం ఒక ప్రోటోకాల్ కంటే ఎక్కువ; ఇది ఇంటర్నెట్ ఆఫ్ థింగ్స్ కోసం ఒక పునాది సాంకేతికత. దాని తేలికపాటి స్వభావం మరియు దృఢమైన ఫీచర్లు స్మార్ట్ నగరాల నుండి కనెక్ట్ చేయబడిన వ్యవసాయం నుండి పారిశ్రామిక ఆటోమేషన్ వరకు ప్రపంచవ్యాప్తంగా లక్షలాది పరికరాలకు ఇది ప్రాధాన్యతనిచ్చాయి.
ప్రయాణం ఇక్కడ ముగియదు. తదుపరి దశ ఈ భావనలను తీసుకొని నిజమైన హార్డ్‌వేర్‌కు వర్తింపజేయడం. రాస్ప్‌బెర్రీ పై, ఈఎస్‌పి32, లేదా ఇతర మైక్రోకంట్రోలర్‌లతో ప్రయోగం చేయండి. భౌతిక సెన్సార్‌లను కనెక్ట్ చేయండి, క్లౌడ్ IoT ప్లాట్‌ఫారమ్‌లతో ఏకీకృతం చేయండి మరియు భౌతిక ప్రపంచంతో పరస్పర చర్య చేసే అప్లికేషన్‌లను నిర్మించండి. పైథాన్ మరియు MQTTతో, తదుపరి తరం కనెక్ట్ చేయబడిన పరిష్కారాలను నిర్మించడానికి మీ వద్ద ఒక శక్తివంతమైన టూల్‌కిట్ ఉంది.