పృథ్వీరాజ్ బోస్ సహకారం అందించారు
స్పార్క్ స్థితిస్థాపక పంపిణీ డేటాసెట్‌లు (ప్రోగ్రామింగ్ నైరూప్యత) సోమరితనం మరియు మూల్యాంకనాలు డైరెక్ట్ ఎసిక్లిక్ గ్రాఫ్స్ (DAG) గా నిల్వ చేయబడతాయి. కాబట్టి RDD పై ప్రతి చర్య స్పార్క్ DAG ని తిరిగి కంప్యూట్ చేస్తుంది. స్పార్క్లో స్థితిస్థాపకత ఈ విధంగా ఉంటుంది, ఎందుకంటే ఏదైనా వర్కర్ నోడ్ విఫలమైతే, DAG ను తిరిగి కంప్యూట్ చేయాలి.
అది కుడా కాష్ చేయడానికి తప్పనిసరి (తగిన నిల్వ స్థాయితో కొనసాగండి) RDD పై తరచూ చేసే చర్యలు DAG ని తిరిగి కంప్యూట్ చేయమని స్పార్క్ను బలవంతం చేయవు.ఈ బ్లాగులో కవర్ చేయబడిన అంశాలు తప్పనిసరిగా అపాచీ స్పార్క్ మరియు స్కాలా సర్టిఫికేషన్ కోసం అవసరం. ఈ బ్లాగులో కవర్ చేయబడిన అంశాలు తప్పనిసరిగా అవసరం .
విభజనను ఎందుకు ఉపయోగించాలి?
క్లస్టర్ కంప్యూటింగ్‌లో, నెట్‌వర్క్ ట్రాఫిక్‌ను తగ్గించడం కేంద్ర సవాలు. డేటా కీ-విలువ ఆధారితమైనప్పుడు, విభజన తప్పనిసరి అవుతుంది ఎందుకంటే RDD లో తదుపరి పరివర్తనల కోసం, నెట్‌వర్క్ అంతటా డేటాను మార్చడం చాలా సరైంది. ఒకే విభజనలో ఒకే విధమైన కీలు లేదా కీల శ్రేణి నిల్వ చేయబడితే, అప్పుడు షఫ్లింగ్ కనిష్టీకరించబడుతుంది మరియు ప్రాసెసింగ్ గణనీయంగా వేగంగా మారుతుంది.
వర్కర్ నోడ్స్‌లో డేటాను మార్చాల్సిన పరివర్తనాలు విభజన నుండి ఎంతో ప్రయోజనం పొందుతాయి. ఇటువంటి పరివర్తనాలు cogroup, groupWith, join, leftOuterJoin, rightOuterJoin, groupByKey, తగ్గించుByKey, combByKey మరియు పైకి చూడు .
RDD కీ-విలువ ఆధారితమైతే విభజనలు కాన్ఫిగర్ చేయబడతాయి.విభజన యొక్క లక్షణాలు
- ఒకే విభజనలోని టుపుల్స్ ఒకే యంత్రంలో ఉంటాయని హామీ ఇవ్వబడింది.
- క్లస్టర్‌లోని ప్రతి నోడ్‌లో ఒకటి కంటే ఎక్కువ విభజనలు ఉంటాయి.
- మొత్తం విభజనల సంఖ్య కాన్ఫిగర్ చేయదగినది, అప్రమేయంగా ఇది అన్ని ఎగ్జిక్యూటర్ నోడ్‌లలోని మొత్తం కోర్ల సంఖ్యకు సెట్ చేయబడుతుంది.
స్పార్క్లో విభజన రకాలు
స్పార్క్ రెండు రకాల విభజనకు మద్దతు ఇస్తుంది,
- హాష్ విభజన : జావా ఉపయోగిస్తుంది ఆబ్జెక్ట్.హాష్కోడ్ విభజనను నిర్ణయించే పద్ధతి partition = key.hashCode ()% numPartitions.
- పరిధి విభజన : సంబంధిత విభజనలకు ఒక పరిధిలోకి వచ్చే కీలను పంపిణీ చేయడానికి పరిధిని ఉపయోగిస్తుంది. కీలలో సహజ క్రమం ఉన్న చోట ఈ పద్ధతి అనుకూలంగా ఉంటుంది మరియు కీలు ప్రతికూలంగా ఉండవు. దిగువ కోడ్ స్నిప్పెట్ పరిధి విభజన యొక్క వాడకాన్ని చూపుతుంది.
వస్తువుల శ్రేణిని ఎలా సృష్టించాలి
కోడ్ ఉదాహరణ
వర్కర్ నోడ్‌లలో డేటాను ఎలా విభజించాలో ఒక ఉదాహరణ చూద్దాం. పూర్తి స్కాలా కోడ్ అందుబాటులో ఉంది ఇక్కడ .
12 కోఆర్డినేట్ల యొక్క కొన్ని పరీక్ష డేటా ఇక్కడ ఉంది (టుపుల్స్ గా),
ఒక సృష్టించండి org.apache.spark.HashPartitioner పరిమాణం 2 యొక్క, ఇక్కడ కీల యొక్క హాష్ కోడ్ ఆధారంగా ఈ రెండు విభజనలలో కీలు విభజించబడతాయి.
జావాలో స్కానర్ ఏమి చేస్తుంది
అప్పుడు మేము జతలను తనిఖీ చేయవచ్చు మరియు వివిధ కీ ఆధారిత పరివర్తనాలు చేయవచ్చు foldByKey మరియు తగ్గించుబైకే.
సంగ్రహంగా, విభజన అనేది కీ ఆధారిత పరివర్తనాల కోసం అమలు వేగాన్ని బాగా మెరుగుపరుస్తుంది.
మాకు ప్రశ్న ఉందా? దయచేసి దీన్ని వ్యాఖ్యల విభాగంలో పేర్కొనండి మరియు మేము మిమ్మల్ని సంప్రదిస్తాము.
సంబంధిత పోస్ట్లు:
హడూప్ మాస్టరింగ్ తర్వాత మీరు ఎందుకు స్పార్క్ నేర్చుకోవాలి