హబ్ర్, హలో! నిన్న న , రాంబ్లర్&కో కుర్రాళ్ల నుండి, ఈ టూల్‌ను కాన్ఫిగర్ చేయడానికి సంబంధించి పాల్గొనేవారి నుండి చాలా ప్రశ్నలు వచ్చాయి. మేము అతని అడుగుజాడలను అనుసరించాలని మరియు మా అనుభవాన్ని పంచుకోవాలని నిర్ణయించుకున్నాము. అంశం సులభం కాదు - కాబట్టి మేము మీ అనుభవాన్ని వ్యాఖ్యలలో పంచుకోవడానికి మిమ్మల్ని ఆహ్వానిస్తున్నాము, బహుశా మేము కూడా ఏదో తప్పుగా అర్థం చేసుకుని ఉపయోగించుకోవచ్చు.
మేము స్పార్క్‌ని ఎలా ఉపయోగిస్తాము అనే దాని గురించి చిన్న పరిచయం. మాకు మూడు నెలల కార్యక్రమం ఉంది , మరియు రెండవ మాడ్యూల్ అంతటా మా పాల్గొనేవారు ఈ పరికరంలో పని చేస్తారు. దీని ప్రకారం, నిర్వాహకులుగా మా పని అటువంటి సందర్భంలో ఉపయోగం కోసం క్లస్టర్‌ను సిద్ధం చేయడం.
మా ఉపయోగం యొక్క ప్రత్యేకత ఏమిటంటే, స్పార్క్‌లో ఏకకాలంలో పనిచేసే వ్యక్తుల సంఖ్య మొత్తం సమూహానికి సమానంగా ఉంటుంది. ఉదాహరణకు, సెమినార్‌లో, ప్రతి ఒక్కరూ ఒకే సమయంలో ఏదైనా ప్రయత్నించినప్పుడు మరియు మా గురువు తర్వాత పునరావృతం చేసినప్పుడు. మరియు ఇది చాలా కాదు - కొన్నిసార్లు 40 మంది వరకు. అటువంటి వినియోగ కేసును ఎదుర్కొనే అనేక కంపెనీలు బహుశా ప్రపంచంలో లేవు.
తరువాత, మేము నిర్దిష్ట కాన్ఫిగరేషన్ పారామితులను ఎలా మరియు ఎందుకు ఎంచుకున్నామో నేను మీకు చెప్తాను.
చాలా మొదటి నుండి ప్రారంభిద్దాం. స్పార్క్‌కు క్లస్టర్‌పై అమలు చేయడానికి 3 ఎంపికలు ఉన్నాయి: స్వతంత్రంగా, మెసోస్‌ని ఉపయోగించడం మరియు YARNని ఉపయోగించడం. మేము మూడవ ఎంపికను ఎంచుకోవాలని నిర్ణయించుకున్నాము ఎందుకంటే ఇది మాకు అర్ధమైంది. మాకు ఇప్పటికే హడూప్ క్లస్టర్ ఉంది. మా పార్టిసిపెంట్‌లకు దాని నిర్మాణం గురించి ఇప్పటికే బాగా తెలుసు. నూలును ఉపయోగిస్తాము.
spark.master=yarnమరింత ఆసక్తికరంగా. ఈ 3 విస్తరణ ఎంపికలలో ప్రతిదానికి 2 విస్తరణ ఎంపికలు ఉన్నాయి: క్లయింట్ మరియు క్లస్టర్. ఆధారిత మరియు ఇంటర్నెట్‌లోని వివిధ లింక్‌లు, క్లయింట్ ఇంటరాక్టివ్ పనికి తగినదని మేము నిర్ధారించగలము - ఉదాహరణకు, జూపిటర్ నోట్‌బుక్ ద్వారా మరియు క్లస్టర్ ఉత్పత్తి పరిష్కారాలకు మరింత అనుకూలంగా ఉంటుంది. మా విషయంలో, మేము ఇంటరాక్టివ్ పనిపై ఆసక్తి కలిగి ఉన్నాము, కాబట్టి:
spark.deploy-mode=clientసాధారణంగా, ఇప్పటి నుండి స్పార్క్ ఏదో ఒకవిధంగా YARN లో పని చేస్తుంది, కానీ ఇది మాకు సరిపోదు. మేము పెద్ద డేటా గురించి ప్రోగ్రామ్‌ని కలిగి ఉన్నందున, కొన్నిసార్లు పాల్గొనేవారి వద్ద వనరులను సరిదిద్దే ఫ్రేమ్‌వర్క్‌లో పొందబడిన వాటిలో తగినంతగా ఉండదు. ఆపై మేము ఒక ఆసక్తికరమైన విషయాన్ని కనుగొన్నాము - డైనమిక్ వనరుల కేటాయింపు. సంక్షిప్తంగా, పాయింట్ ఇది: మీకు కష్టమైన పని ఉంటే మరియు క్లస్టర్ ఉచితం (ఉదాహరణకు, ఉదయం), అప్పుడు ఈ ఎంపికను ఉపయోగించి స్పార్క్ మీకు అదనపు వనరులను అందిస్తుంది. ఒక మోసపూరిత సూత్రం ప్రకారం అవసరం అక్కడ లెక్కించబడుతుంది. మేము వివరాలలోకి వెళ్ళము - ఇది బాగా పనిచేస్తుంది.
spark.dynamicAllocation.enabled=trueమేము ఈ పరామితిని సెట్ చేసాము మరియు స్టార్టప్‌లో స్పార్క్ క్రాష్ అయ్యింది మరియు ప్రారంభించలేదు. అది నిజం, ఎందుకంటే నేను దానిని చదవవలసి వచ్చింది ఇంకా జాగ్రత్త గా. ప్రతిదీ సరిగ్గా ఉండాలంటే, మీరు అదనపు పరామితిని కూడా ప్రారంభించాలని ఇది పేర్కొంది.
spark.shuffle.service.enabled=trueఅది ఎందుకు అవసరం? మా ఉద్యోగానికి ఎక్కువ వనరులు అవసరం లేనప్పుడు, స్పార్క్ వాటిని సాధారణ పూల్‌కి తిరిగి ఇవ్వాలి. దాదాపు ఏదైనా MapReduce టాస్క్‌లో ఎక్కువ సమయం తీసుకునే దశ షఫుల్ దశ. ఈ దశలో ఉత్పత్తి చేయబడిన డేటాను సేవ్ చేయడానికి మరియు తదనుగుణంగా కార్యనిర్వాహకులను విడుదల చేయడానికి ఈ పరామితి మిమ్మల్ని అనుమతిస్తుంది. మరియు కార్యనిర్వాహకుడు అనేది కార్మికుడిపై ప్రతిదాన్ని లెక్కించే ప్రక్రియ. ఇది నిర్దిష్ట సంఖ్యలో ప్రాసెసర్ కోర్లను మరియు కొంత మెమరీని కలిగి ఉంటుంది.
ఈ పరామితి జోడించబడింది. అంతా పని చేసినట్లు అనిపించింది. పార్టిసిపెంట్‌లకు అవసరమైనప్పుడు ఎక్కువ వనరులు ఇవ్వడం గమనించదగినదిగా మారింది. కానీ మరొక సమస్య తలెత్తింది - ఏదో ఒక సమయంలో ఇతర పాల్గొనేవారు మేల్కొన్నారు మరియు స్పార్క్‌ను ఉపయోగించాలని కూడా కోరుకున్నారు, కానీ అక్కడ ప్రతిదీ బిజీగా ఉంది మరియు వారు సంతోషంగా ఉన్నారు. వాటిని అర్థం చేసుకోవచ్చు. మేము డాక్యుమెంటేషన్ చూడటం ప్రారంభించాము. మీరు ప్రక్రియను ప్రభావితం చేయగల అనేక పారామితులు ఇప్పటికీ ఉన్నాయని తేలింది. ఉదాహరణకు, ఎగ్జిక్యూటర్ స్టాండ్‌బై మోడ్‌లో ఉంటే, దాని నుండి ఏ సమయం తర్వాత వనరులను తీసుకోవచ్చు?
spark.dynamicAllocation.executorIdleTimeout=120sమా విషయంలో, మీ కార్యనిర్వాహకులు రెండు నిమిషాల పాటు ఏమీ చేయకపోతే, దయచేసి వారిని సాధారణ పూల్‌కి తిరిగి ఇవ్వండి. కానీ ఈ పరామితి ఎల్లప్పుడూ సరిపోదు. వ్యక్తి చాలా కాలంగా ఏమీ చేయడం లేదని, వనరులు విడుదల కావడం లేదని స్పష్టమైంది. ఇది ఒక ప్రత్యేక పరామితి కూడా ఉందని తేలింది - కాష్ చేసిన డేటాను కలిగి ఉన్న ఎగ్జిక్యూటర్లను ఎన్నుకునే సమయం తర్వాత. డిఫాల్ట్‌గా, ఈ పరామితి అనంతం! మేము దానిని సరిదిద్దాము.
spark.dynamicAllocation.cachedExecutorIdleTimeout=600sఅంటే, మీ కార్యనిర్వాహకులు 5 నిమిషాలు ఏమీ చేయకపోతే, వాటిని సాధారణ పూల్‌కు ఇవ్వండి. ఈ మోడ్‌లో, అధిక సంఖ్యలో వినియోగదారుల కోసం వనరులను విడుదల చేయడం మరియు జారీ చేయడం యొక్క వేగం మర్యాదగా మారింది. అసంతృప్తి మొత్తం తగ్గింది. కానీ మేము మరింత ముందుకు వెళ్లాలని నిర్ణయించుకున్నాము మరియు ఒక అప్లికేషన్‌కు గరిష్ట సంఖ్యలో ఎగ్జిక్యూటర్‌ల సంఖ్యను పరిమితం చేయాలని నిర్ణయించుకున్నాము - ముఖ్యంగా ప్రోగ్రామ్ పార్టిసిపెంట్‌కు.
spark.dynamicAllocation.maxExecutors=19ఇప్పుడు, వాస్తవానికి, మరొక వైపు అసంతృప్తిగా ఉన్న వ్యక్తులు ఉన్నారు - "క్లస్టర్ పనిలేకుండా ఉంది, మరియు నా దగ్గర కేవలం 19 మంది కార్యనిర్వాహకులు మాత్రమే ఉన్నారు," కానీ మీరు ఏమి చేయగలరు? మాకు సరైన బ్యాలెన్స్ అవసరం. మీరు అందరినీ సంతోషపెట్టలేరు.
మరియు మా కేసు ప్రత్యేకతలకు సంబంధించిన మరో చిన్న కథ. ఏదో ఒకవిధంగా, చాలా మంది వ్యక్తులు ప్రాక్టికల్ పాఠం కోసం ఆలస్యం అయ్యారు మరియు కొన్ని కారణాల వల్ల వారి కోసం స్పార్క్ ప్రారంభించలేదు. మేము ఉచిత వనరుల మొత్తాన్ని చూశాము - అది అక్కడ ఉన్నట్లు అనిపిస్తుంది. స్పార్క్ ప్రారంభం కావాలి. అదృష్టవశాత్తూ, ఆ సమయానికి డాక్యుమెంటేషన్ ఇప్పటికే ఎక్కడో సబ్‌కోర్టెక్స్‌కు జోడించబడింది మరియు ప్రారంభించినప్పుడు, స్పార్క్ ప్రారంభించాల్సిన పోర్ట్ కోసం వెతుకుతుందని మేము గుర్తుంచుకున్నాము. శ్రేణిలో మొదటి పోర్ట్ బిజీగా ఉంటే, అది క్రమంలో తదుపరి దానికి తరలించబడుతుంది. ఇది ఉచితం అయితే, అది సంగ్రహిస్తుంది. మరియు దీని కోసం గరిష్ట సంఖ్యలో ప్రయత్నాలను సూచించే పరామితి ఉంది. డిఫాల్ట్ 16. తరగతిలో మా గుంపులోని వ్యక్తుల సంఖ్య కంటే తక్కువ సంఖ్య. తదనుగుణంగా, 16 ప్రయత్నాల తర్వాత, స్పార్క్ వదులుకున్నాడు మరియు నేను ప్రారంభించలేనని చెప్పాడు. మేము ఈ సెట్టింగ్‌ని సరిదిద్దాము.
spark.port.maxRetries=50తరువాత మా కేసు యొక్క ప్రత్యేకతలకు చాలా సంబంధం లేని కొన్ని సెట్టింగ్‌ల గురించి నేను మీకు చెప్తాను.
స్పార్క్‌ని వేగంగా ప్రారంభించడానికి, SPARK_HOME హోమ్ డైరెక్టరీలో ఉన్న జార్స్ ఫోల్డర్‌ను ఆర్కైవ్ చేసి, దానిని HDFSలో ఉంచాలని సిఫార్సు చేయబడింది. అప్పుడు అతను ఈ జర్నిక్‌లను కార్మికులచే లోడ్ చేయడంలో సమయాన్ని వృథా చేయడు.
spark.yarn.archive=hdfs:///tmp/spark-archive.zipవేగవంతమైన ఆపరేషన్ కోసం క్రియోను సీరియలైజర్‌గా ఉపయోగించాలని కూడా సిఫార్సు చేయబడింది. ఇది డిఫాల్ట్ కంటే ఎక్కువ ఆప్టిమైజ్ చేయబడింది.
spark.serializer=org.apache.spark.serializer.KryoSerializerమరియు స్పార్క్‌తో దీర్ఘకాలిక సమస్య కూడా ఉంది, ఇది తరచుగా మెమరీ నుండి క్రాష్ అవుతుంది. కార్మికులు ప్రతిదీ లెక్కించి, డ్రైవర్‌కు ఫలితాన్ని పంపినప్పుడు తరచుగా ఇది జరుగుతుంది. మేము ఈ పరామితిని మా కోసం పెద్దదిగా చేసాము. డిఫాల్ట్‌గా, ఇది 1GB, మేము దానిని 3గా చేసాము.
spark.driver.maxResultSize=3072మరియు చివరగా, డెజర్ట్‌గా. HortonWorks పంపిణీపై స్పార్క్‌ని వెర్షన్ 2.1కి ఎలా అప్‌డేట్ చేయాలి - HDP 2.5.3.0. HDP యొక్క ఈ సంస్కరణ ముందే ఇన్‌స్టాల్ చేసిన వెర్షన్ 2.0ని కలిగి ఉంది, కానీ స్పార్క్ చాలా చురుకుగా అభివృద్ధి చెందుతోందని మేము ఒకసారి నిర్ణయించుకున్నాము మరియు ప్రతి కొత్త వెర్షన్ కొన్ని బగ్‌లను పరిష్కరిస్తుంది మరియు పైథాన్ APIతో సహా అదనపు ఫీచర్లను అందిస్తుంది, కాబట్టి మేము నిర్ణయించుకున్నాము , ఏమి చేయాలి పూర్తి చేయడం ఒక నవీకరణ.
హడూప్ 2.7 కోసం అధికారిక వెబ్‌సైట్ నుండి సంస్కరణను డౌన్‌లోడ్ చేసారు. దాన్ని అన్‌జిప్ చేసి HDP ఫోల్డర్‌లో ఉంచారు. మేము అవసరమైన విధంగా సిమ్‌లింక్‌లను ఇన్‌స్టాల్ చేసాము. మేము దానిని ప్రారంభిస్తాము - ఇది ప్రారంభించబడదు. చాలా విచిత్రమైన తప్పు రాశారు.
java.lang.NoClassDefFoundError: com/sun/jersey/api/client/config/ClientConfigగూగ్లింగ్ చేసిన తర్వాత, హడూప్ పుట్టే వరకు స్పార్క్ వేచి ఉండకూడదని నిర్ణయించుకున్నట్లు మరియు కొత్త వెర్షన్ జెర్సీని ఉపయోగించాలని నిర్ణయించుకున్నట్లు మేము కనుగొన్నాము. JIRAలో ఈ అంశం గురించి వారే ఒకరితో ఒకరు వాదించుకుంటారు. డౌన్‌లోడ్ చేసుకోవడం పరిష్కారం . దీన్ని SPARK_HOMEలోని జార్స్ ఫోల్డర్‌లో ఉంచండి, మళ్లీ జిప్ చేసి, HDFSకి అప్‌లోడ్ చేయండి.
మేము ఈ లోపాన్ని అధిగమించాము, కానీ కొత్త మరియు క్రమబద్ధీకరించబడిన ఒకటి తలెత్తింది.
org.apache.spark.SparkException: Yarn application has already ended! It might have been killed or unable to launch application masterఅదే సమయంలో, మేము వెర్షన్ 2.0ని అమలు చేయడానికి ప్రయత్నిస్తాము - ప్రతిదీ సరే. ఏమి జరుగుతుందో ఊహించడానికి ప్రయత్నించండి. మేము ఈ అప్లికేషన్ యొక్క లాగ్‌లను పరిశీలించాము మరియు ఇలాంటివి చూశాము:
/usr/hdp/${hdp.version}/hadoop/lib/hadoop-lzo-0.6.0.${hdp.version}.jarసాధారణంగా, కొన్ని కారణాల వలన hdp. వెర్షన్ పరిష్కరించబడలేదు. గూగ్లింగ్ తర్వాత, మేము ఒక పరిష్కారాన్ని కనుగొన్నాము. మీరు అంబారీలోని YARN సెట్టింగ్‌లకు వెళ్లి, అనుకూల నూలు-సైట్‌కి పారామీటర్‌ను జోడించాలి:
hdp.version=2.5.3.0-37ఈ మేజిక్ సహాయపడింది, మరియు స్పార్క్ బయలుదేరింది. మేము మా అనేక జూపిటర్ ల్యాప్‌టాప్‌లను పరీక్షించాము. అంతా పని చేస్తోంది. మేము శనివారం (రేపు) మొదటి స్పార్క్ పాఠానికి సిద్ధంగా ఉన్నాము!
DUP. పాఠం సమయంలో, మరొక సమస్య వెలుగులోకి వచ్చింది. ఏదో ఒక సమయంలో, YARN స్పార్క్ కోసం కంటైనర్‌లను అందించడం ఆపివేసింది. YARNలో పరామితిని సరిచేయడం అవసరం, ఇది డిఫాల్ట్‌గా 0.2:
yarn.scheduler.capacity.maximum-am-resource-percent=0.8
అంటే, వనరుల పంపిణీలో కేవలం 20% వనరులు మాత్రమే పాల్గొన్నాయి. పారామితులను మార్చిన తర్వాత, మేము YARNని మళ్లీ లోడ్ చేసాము. సమస్య పరిష్కరించబడింది మరియు మిగిలిన పాల్గొనేవారు కూడా స్పార్క్ సందర్భాన్ని అమలు చేయగలిగారు.
మూలం: www.habr.com