Kubernetes క్లస్టర్‌ను సృష్టించేటప్పుడు, ప్రశ్నలు తలెత్తవచ్చు: ఎన్ని వర్కర్ నోడ్‌లను కాన్ఫిగర్ చేయాలి మరియు ఏ రకం? ఆన్-ప్రిమిస్ క్లస్టర్‌కు ఏది మంచిది: అనేక శక్తివంతమైన సర్వర్‌లను కొనుగోలు చేయాలా లేదా మీ డేటా సెంటర్‌లో డజను పాత మెషీన్‌లను ఉపయోగించాలా? క్లౌడ్లో ఎనిమిది సింగిల్-కోర్ లేదా రెండు క్వాడ్-కోర్ ఉదంతాలు తీసుకోవడం మంచిదా?
ఈ ప్రశ్నలకు సమాధానాలు వ్యాసంలో ఉన్నాయి. ఆదేశం యొక్క అనువాదంలో .
క్లస్టర్ సామర్థ్యం
సాధారణంగా, కుబెర్నెటీస్ క్లస్టర్‌ను పెద్ద "సూపర్‌నోడ్"గా భావించవచ్చు. దాని మొత్తం కంప్యూటింగ్ పవర్ అనేది దాని అన్ని కాన్‌స్టిట్యూయెంట్ నోడ్‌ల శక్తుల మొత్తం.
మీరు కోరుకున్న క్లస్టర్ సామర్థ్య లక్ష్యాన్ని సాధించడానికి అనేక మార్గాలు ఉన్నాయి. ఉదాహరణకు, మనకు 8 ప్రాసెసర్ కోర్ల మొత్తం సామర్థ్యం మరియు 32 GB RAMతో కూడిన క్లస్టర్ అవసరం ఎందుకంటే అప్లికేషన్‌ల సమితికి చాలా వనరులు అవసరం. అప్పుడు మీరు 16 GB మెమరీతో రెండు నోడ్లు లేదా 8 GB మెమరీతో నాలుగు నోడ్లు, రెండు క్వాడ్-కోర్ ప్రాసెసర్‌లు లేదా నాలుగు డ్యూయల్ కోర్ వాటిని ఇన్‌స్టాల్ చేయవచ్చు.
క్లస్టర్‌ను సృష్టించడానికి ఇక్కడ కేవలం రెండు మార్గాలు ఉన్నాయి:
రెండు ఎంపికలు ఒకే సామర్థ్యంతో క్లస్టర్‌ను ఉత్పత్తి చేస్తాయి, అయితే దిగువ కాన్ఫిగరేషన్‌లో నాలుగు చిన్న నోడ్లు ఉన్నాయి మరియు ఎగువ కాన్ఫిగరేషన్‌లో రెండు పెద్ద నోడ్లు ఉంటాయి.
ఏ ఎంపిక మంచిది?
ఈ ప్రశ్నకు సమాధానమివ్వడానికి, రెండు ఎంపికల ప్రయోజనాలను చూద్దాం. మేము వాటిని పట్టికలో సంగ్రహించాము.
అనేక పెద్ద నోడ్స్
చాలా చిన్న నోడ్స్
సులభమైన క్లస్టర్ నిర్వహణ (ఇది ఆవరణలో ఉంటే)
స్మూత్ ఆటోస్కేలింగ్
తక్కువ ధర (ఆవరణలో ఉంటే)
ధర కొద్దిగా భిన్నంగా ఉంటుంది (క్లౌడ్లో)
రిసోర్స్-ఇంటెన్సివ్ అప్లికేషన్‌లను అమలు చేయగలదు
పూర్తి ప్రతిరూపం
వనరులు మరింత సమర్థవంతంగా ఉపయోగించబడతాయి (సిస్టమ్ డెమోన్‌లపై తక్కువ ఓవర్‌హెడ్
అధిక క్లస్టర్ ఫాల్ట్ టాలరెన్స్
మేము వర్కర్ నోడ్స్ గురించి మాత్రమే మాట్లాడుతున్నామని దయచేసి గమనించండి. ప్రధాన నోడ్‌ల సంఖ్య మరియు పరిమాణాన్ని ఎంచుకోవడం పూర్తిగా భిన్నమైన అంశం.
కాబట్టి, పట్టిక నుండి ప్రతి అంశాన్ని మరింత వివరంగా చర్చిద్దాం.
మొదటి ఎంపిక: అనేక పెద్ద నోడ్స్
అత్యంత తీవ్రమైన ఎంపిక మొత్తం క్లస్టర్ సామర్థ్యం కోసం ఒక వర్కర్ నోడ్. ఎగువ ఉదాహరణలో, ఇది 16 CPU కోర్లు మరియు 16 GB RAMతో ఒకే వర్కర్ నోడ్ అవుతుంది.
Плюсы
ప్లస్ నం. 1. సులభమైన నిర్వహణ
మొత్తం ఫ్లీట్ కంటే కొన్ని యంత్రాలను నిర్వహించడం సులభం. అప్‌డేట్‌లు మరియు పరిష్కారాలను రూపొందించడం చాలా వేగంగా ఉంటుంది మరియు సింక్రొనైజ్ చేయడం సులభం. సంపూర్ణ సంఖ్యలో వైఫల్యాల సంఖ్య కూడా తక్కువ.
దయచేసి పైన పేర్కొన్నవన్నీ మీ హార్డ్వేర్, మీ సర్వర్‌లకు వర్తిస్తాయని మరియు క్లౌడ్ ఇన్‌స్టాన్స్‌లకు కాదని దయచేసి గమనించండి.
క్లౌడ్లో పరిస్థితి భిన్నంగా ఉంది. అక్కడ, నిర్వహణ క్లౌడ్ సర్వీస్ ప్రొవైడర్ ద్వారా నిర్వహించబడుతుంది. అందువల్ల, క్లౌడ్లో పది నోడ్‌లను నిర్వహించడం అనేది ఒక నోడ్‌ను నిర్వహించడం కంటే చాలా భిన్నంగా లేదు.
క్లౌడ్‌లోని పాడ్‌ల మధ్య ట్రాఫిక్ రూటింగ్ మరియు లోడ్ పంపిణీ : ఇంటర్నెట్ నుండి వచ్చే ట్రాఫిక్ ప్రధాన లోడ్ బ్యాలెన్సర్‌కు పంపబడుతుంది, ఇది ట్రాఫిక్‌ను నోడ్లలో ఒకదాని యొక్క పోర్ట్‌కు ఫార్వార్డ్ చేస్తుంది (నోడ్‌పోర్ట్ సేవ ప్రతి క్లస్టర్ నోడ్‌లో పోర్ట్‌ను 30000-32767 పరిధిలో సెట్ చేస్తుంది). kube-proxy ద్వారా సెట్ చేయబడిన నియమాలు నోడ్ నుండి పాడ్‌కు ట్రాఫిక్‌ను దారి మళ్లిస్తాయి. రెండు నోడ్లలో పది పాడ్‌ల కోసం ఇది ఎలా ఉంటుందో ఇక్కడ ఉంది:
ప్రో #2: ఒక్కో నోడ్‌కి తక్కువ ధర
శక్తివంతమైన కారు ఖరీదైనది, కానీ ధర పెరుగుదల తప్పనిసరిగా సరళంగా ఉండదు. మరో మాటలో చెప్పాలంటే, 10 GB మెమరీతో ఒక పది-కోర్ సర్వర్ సాధారణంగా అదే మొత్తంలో మెమరీని కలిగి ఉన్న పది సింగిల్-కోర్ సర్వర్‌ల కంటే చౌకగా ఉంటుంది.
కానీ ఈ నియమం సాధారణంగా క్లౌడ్ సేవల్లో పని చేయదని గమనించండి. అన్ని ప్రధాన క్లౌడ్ ప్రొవైడర్‌ల ప్రస్తుత ధరల పథకాలలో, ధరలు సామర్థ్యంతో సరళంగా పెరుగుతాయి.
అందువలన, క్లౌడ్లో మీరు సాధారణంగా మరింత శక్తివంతమైన సర్వర్లలో సేవ్ చేయలేరు.
ప్రో #3: మీరు రిసోర్స్-ఇంటెన్సివ్ అప్లికేషన్‌లను అమలు చేయవచ్చు
కొన్ని అనువర్తనాలకు క్లస్టర్‌లో శక్తివంతమైన సర్వర్లు అవసరం. ఉదాహరణకు, మెషీన్ లెర్నింగ్ సిస్టమ్‌కు 8 GB మెమరీ అవసరమైతే, మీరు దానిని 1 GB నోడ్లలో అమలు చేయలేరు, కానీ కనీసం ఒక పెద్ద వర్కర్ నోడ్‌తో మాత్రమే.
Минусы
ప్రతికూలత సంఖ్య 1. నోడ్‌కు అనేక పాడ్‌లు
అదే పనిని తక్కువ నోడ్లలో నిర్వహిస్తే, వాటిలో ప్రతి ఒక్కటి సహజంగా ఎక్కువ పాడ్‌లను కలిగి ఉంటాయి.
ఇది సమస్య కావచ్చు.
కారణం ఏమిటంటే, ప్రతి మాడ్యూల్ కంటైనర్ రన్‌టైమ్‌కు కొంత ఓవర్‌హెడ్‌ను పరిచయం చేస్తుంది (ఉదా. డాకర్), అలాగే కుబెలెట్ మరియు cAdvisor.
ఉదాహరణకు, ఒక kubelet సర్వైబిలిటీ కోసం నోడ్‌లోని అన్ని కంటైనర్‌లను క్రమం తప్పకుండా పరిశీలిస్తుంది-ఎక్కువ కంటైనర్లు, kubelet ఎక్కువ పని చేయాల్సి ఉంటుంది.
CAdvisor నోడ్‌లోని అన్ని కంటైనర్‌ల కోసం వనరుల వినియోగ గణాంకాలను సేకరిస్తుంది మరియు kubelet క్రమం తప్పకుండా ఈ సమాచారాన్ని ప్రశ్నిస్తుంది మరియు API ద్వారా అందిస్తుంది. మళ్ళీ, ఎక్కువ కంటైనర్లు అంటే cAdvisor మరియు kubelet రెండింటికీ ఎక్కువ పని.
మాడ్యూల్స్ సంఖ్య పెరిగితే, అది సిస్టమ్‌ను నెమ్మదిస్తుంది మరియు దాని విశ్వసనీయతను కూడా బలహీనపరుస్తుంది.
కుబెర్నెట్స్ రిపోజిటరీలో కొన్ని నోడ్లు రెడీ/నాట్‌రెడీ స్టేటస్‌ల మధ్య జంప్ అవుతాయి ఎందుకంటే నోడ్‌లోని అన్ని కంటైనర్‌ల సాధారణ క్యూబెలెట్ తనిఖీలు చాలా సమయం తీసుకుంటాయి.
ఈ కారణంగా కుబెర్నెట్స్ . నోడ్ పనితీరుపై ఆధారపడి, మీరు ఒక్కో నోడ్‌కు మరిన్ని పాడ్‌లను అమలు చేయవచ్చు, అయితే సమస్యలు ఉంటాయా లేదా ప్రతిదీ సరిగ్గా పని చేస్తుందా అని అంచనా వేయడం కష్టం. ఇది ముందుగానే పనిని పరీక్షించడం విలువ.
ప్రతికూలత సంఖ్య 2. ప్రతిరూపణపై పరిమితి
చాలా తక్కువ నోడ్లు అప్లికేషన్ రెప్లికేషన్ యొక్క ప్రభావవంతమైన పరిధిని పరిమితం చేస్తాయి. ఉదాహరణకు, మీరు ఐదు ప్రతిరూపాలతో అధిక లభ్యత అప్లికేషన్‌ను కలిగి ఉంటే కానీ కేవలం రెండు నోడ్లు మాత్రమే ఉంటే, అప్లికేషన్ యొక్క ప్రభావవంతమైన రెప్లికేషన్ డిగ్రీ రెండుకి తగ్గించబడుతుంది.
ఐదు ప్రతిరూపాలు రెండు నోడ్లలో మాత్రమే పంపిణీ చేయబడతాయి మరియు వాటిలో ఒకటి విఫలమైతే, అది ఒకేసారి బహుళ ప్రతిరూపాలను తీసివేస్తుంది.
మీకు ఐదు నోడ్లు లేదా అంతకంటే ఎక్కువ ఉన్నట్లయితే, ప్రతి ప్రతిరూపం ప్రత్యేక నోడ్‌లో రన్ అవుతుంది మరియు ఒక నోడ్ వైఫల్యం గరిష్టంగా ఒక ప్రతిరూపాన్ని తొలగిస్తుంది.
అందువల్ల, అధిక లభ్యత అవసరాలకు క్లస్టర్‌లో నిర్దిష్ట కనీస సంఖ్యలో నోడ్లు అవసరం కావచ్చు.
ప్రతికూలత సంఖ్య 3. వైఫల్యం యొక్క అధ్వాన్నమైన పరిణామాలు
తక్కువ సంఖ్యలో నోడ్‌లతో, ప్రతి వైఫల్యం మరింత తీవ్రమైన పరిణామాలను కలిగి ఉంటుంది. ఉదాహరణకు, మీకు రెండు నోడ్లు మాత్రమే ఉంటే మరియు వాటిలో ఒకటి విఫలమైతే, మీ మాడ్యూళ్ళలో సగం వెంటనే అదృశ్యమవుతుంది.
వాస్తవానికి, కుబెర్నెటెస్ పనిభారాన్ని విఫలమైన నోడ్ నుండి ఇతరులకు తరలిస్తారు. కానీ వాటిలో కొన్ని ఉంటే, అప్పుడు తగినంత ఉచిత సామర్థ్యం ఉండకపోవచ్చు. ఫలితంగా, మీరు విఫలమైన నోడ్‌ను తీసుకువచ్చే వరకు మీ అప్లికేషన్‌లలో కొన్ని అందుబాటులో ఉండవు.
అందువలన, ఎక్కువ నోడ్స్, హార్డ్వేర్ వైఫల్యాల ప్రభావం తక్కువగా ఉంటుంది.
ప్రతికూలత #4: మరిన్ని ఆటోస్కేలింగ్ దశలు
Kubernetes క్లౌడ్ ఇన్‌ఫ్రాస్ట్రక్చర్ కోసం క్లస్టర్ ఆటో-స్కేలింగ్ సిస్టమ్‌ను కలిగి ఉంది, ఇది మీ ప్రస్తుత అవసరాలను బట్టి స్వయంచాలకంగా నోడ్‌లను జోడించడానికి లేదా తీసివేయడానికి మిమ్మల్ని అనుమతిస్తుంది. పెద్ద నోడ్‌లతో, ఆటోస్కేలింగ్ మరింత ఆకస్మికంగా మరియు గజిబిజిగా మారుతుంది. ఉదాహరణకు, రెండు నోడ్లలో, అదనపు నోడ్‌ను జోడించడం వలన క్లస్టర్ సామర్థ్యాన్ని వెంటనే 50% పెంచుతుంది. మీకు అవసరం లేకపోయినా, ఆ వనరుల కోసం మీరు చెల్లించాల్సి ఉంటుంది.
అందువల్ల, మీరు ఆటోమేటిక్ క్లస్టర్ స్కేలింగ్‌ని ఉపయోగించాలని ప్లాన్ చేస్తే, చిన్న నోడ్లు, మీరు మరింత సౌకర్యవంతమైన మరియు తక్కువ ఖర్చుతో కూడిన స్కేలింగ్‌ని పొందుతారు.
ఇప్పుడు పెద్ద సంఖ్యలో చిన్న నోడ్స్ యొక్క ప్రయోజనాలు మరియు అప్రయోజనాలు చూద్దాం.
రెండవ ఎంపిక: అనేక చిన్న నోడ్స్
ఈ విధానం యొక్క ప్రయోజనాలు తప్పనిసరిగా అనేక పెద్ద నోడ్‌లతో వ్యతిరేక ఎంపిక యొక్క ప్రతికూలతల నుండి ఉత్పన్నమవుతాయి.
Плюсы
ప్రో #1: వైఫల్యం యొక్క తక్కువ ప్రభావం
ఎక్కువ నోడ్లు, ప్రతి నోడ్‌లో తక్కువ పాడ్‌లు. ఉదాహరణకు, మీరు పది నోడ్‌లకు వంద మాడ్యూల్‌లను కలిగి ఉంటే, ప్రతి నోడ్‌కు సగటున పది మాడ్యూల్స్ ఉంటాయి.
ఈ విధంగా, నోడ్లలో ఒకటి విఫలమైతే, మీరు పనిభారంలో 10% మాత్రమే కోల్పోతారు. తక్కువ సంఖ్యలో ప్రతిరూపాలు మాత్రమే ప్రభావితమయ్యే అవకాశాలు ఉన్నాయి మరియు మొత్తం అప్లికేషన్ పని చేస్తూనే ఉంటుంది.
అదనంగా, విఫలమైన నోడ్ యొక్క పనిభారాన్ని నిర్వహించడానికి మిగిలిన నోడ్లు తగినంత ఉచిత వనరులను కలిగి ఉంటాయి, కాబట్టి కుబెర్నెట్స్ పాడ్‌లను స్వేచ్ఛగా రీషెడ్యూల్ చేయవచ్చు మరియు మీ అప్లికేషన్‌లు సాపేక్షంగా త్వరగా క్రియాత్మక స్థితికి తిరిగి వస్తాయి.
ప్రో #2: మంచి ప్రతిరూపం
తగినంత నోడ్లు ఉంటే, కుబెర్నెట్స్ షెడ్యూలర్ అన్ని ప్రతిరూపాలకు వేర్వేరు నోడ్‌లను కేటాయించవచ్చు. ఈ విధంగా, నోడ్ విఫలమైతే, ఒక ప్రతిరూపం మాత్రమే ప్రభావితమవుతుంది మరియు అప్లికేషన్ అందుబాటులో ఉంటుంది.
Минусы
ప్రతికూలత సంఖ్య 1. నియంత్రించడం కష్టం
పెద్ద సంఖ్యలో నోడ్‌లను నిర్వహించడం చాలా కష్టం. ఉదాహరణకు, ప్రతి కుబెర్నెటెస్ నోడ్ తప్పనిసరిగా మిగతా వాటితో కమ్యూనికేట్ చేయాలి, అంటే కనెక్షన్‌ల సంఖ్య చతుర్భుజంగా పెరుగుతుంది మరియు ఈ కనెక్షన్‌లన్నింటినీ ట్రాక్ చేయాలి.
Kubernetes కంట్రోలర్ మేనేజర్‌లోని నోడ్ కంట్రోలర్ ఆరోగ్యాన్ని తనిఖీ చేయడానికి క్లస్టర్‌లోని అన్ని నోడ్‌ల ద్వారా క్రమం తప్పకుండా నడుస్తుంది - ఎక్కువ నోడ్లు, కంట్రోలర్‌పై ఎక్కువ లోడ్ అవుతుంది.
etcd డేటాబేస్‌పై లోడ్ కూడా పెరుగుతోంది - ప్రతి kubelet మరియు kube-proxy కాల్‌లు etcd కోసం (API ద్వారా), etcd ఆబ్జెక్ట్ అప్‌డేట్‌లను ప్రసారం చేయాలి.
సాధారణంగా, ప్రతి వర్కర్ నోడ్ మాస్టర్ నోడ్‌ల సిస్టమ్ భాగాలపై అదనపు లోడ్‌ను విధిస్తుంది.
Kubernetes అధికారికంగా క్లస్టర్‌లకు మద్దతు ఇస్తుంది . అయితే, ఆచరణలో ఇప్పటికే 500 నోడ్స్ ఉన్నాయి .
పెద్ద సంఖ్యలో వర్కర్ నోడ్‌లను నిర్వహించడానికి, మీరు మరింత శక్తివంతమైన మాస్టర్ నోడ్‌లను ఎంచుకోవాలి. ఉదాహరణకు, kube-up వర్కర్ నోడ్‌ల సంఖ్యను బట్టి మాస్టర్ నోడ్‌కు సరైన VM పరిమాణం. అంటే, ఎక్కువ వర్కర్ నోడ్లు, మాస్టర్ నోడ్లు మరింత ఉత్పాదకతను కలిగి ఉండాలి.
ఈ నిర్దిష్ట సమస్యలను పరిష్కరించడానికి ప్రత్యేక పరిణామాలు ఉన్నాయి . ఈ వ్యవస్థ పరిమితులను దాటవేయడానికి మరియు భారీ సంఖ్యలో వర్కర్ నోడ్‌లతో క్లస్టర్‌లను నిర్మించడానికి మిమ్మల్ని అనుమతిస్తుంది.
ప్రతికూలత #2: మరిన్ని ఓవర్‌హెడ్ ఖర్చులు.
ప్రతి వర్కర్ నోడ్‌లో, కుబెర్నెటెస్ సిస్టమ్ డెమోన్‌ల సమితిని నడుపుతుంది - వీటిలో cAdvisorతో సహా కంటైనర్ రన్‌టైమ్ (డాకర్ వంటివి), kube-proxy మరియు kubelet ఉన్నాయి. వారు కలిసి నిర్దిష్ట స్థిరమైన వనరులను వినియోగిస్తారు.
మీరు చాలా చిన్న నోడ్‌లను కలిగి ఉంటే, ప్రతి నోడ్‌పై ఈ ఓవర్‌హెడ్ నిష్పత్తి పెద్దదిగా ఉంటుంది. ఉదాహరణకు, ఒకే నోడ్‌లోని అన్ని సిస్టమ్ డెమన్‌లు కలిసి 0,1 CPU కోర్లను మరియు 0,1 GB మెమరీని ఉపయోగిస్తాయని ఊహించండి. మీరు 10 GB మెమరీతో ఒక పది-కోర్ నోడ్‌ని కలిగి ఉంటే, అప్పుడు డెమోన్‌లు క్లస్టర్ సామర్థ్యంలో 1% వినియోగిస్తాయి. మరోవైపు, 1 GB మెమరీతో పది సింగిల్-కోర్ నోడ్లలో, డెమోన్‌లు క్లస్టర్ సామర్థ్యంలో 10% తీసుకుంటాయి.
అందువలన, తక్కువ నోడ్లు, మరింత సమర్థవంతంగా మౌలిక సదుపాయాలు ఉపయోగించబడుతుంది.
ప్రతికూలత సంఖ్య 3. వనరుల అసమర్థ వినియోగం
చిన్న నోడ్లలో, మిగిలిన రిసోర్స్ భాగాలు ఏ పనిభారాన్ని కేటాయించలేనంత చిన్నవిగా ఉండవచ్చు, కాబట్టి అవి ఉపయోగించబడవు.
ఉదాహరణకు, ప్రతి పాడ్‌కు 0,75 GB మెమరీ అవసరం. మీరు పది నోడ్‌లను కలిగి ఉంటే, ప్రతి ఒక్కటి 1GB మెమరీతో, మీరు పది పాడ్‌లను అమలు చేయవచ్చు, ప్రతి నోడ్‌ను 0,25GB ఉపయోగించని మెమరీతో వదిలివేయవచ్చు.
అంటే మొత్తం క్లస్టర్ మెమరీలో 25% వృధా అవుతుంది.
10 GB మెమరీ ఉన్న పెద్ద నోడ్‌లో, మీరు ఈ మాడ్యూళ్లలో 13ని అమలు చేయవచ్చు - మరియు 0,25 GB మాత్రమే ఉపయోగించని ఒక భాగం మాత్రమే ఉంటుంది.
ఈ సందర్భంలో, మెమరీలో 2,5% మాత్రమే వృధా అవుతుంది.
అందువలన, వనరులు పెద్ద నోడ్లలో మరింత ఉత్తమంగా ఉపయోగించబడతాయి.
అనేక పెద్ద నోడ్లు లేదా చాలా చిన్నవి?
కాబట్టి, ఏది మంచిది: క్లస్టర్‌లో కొన్ని పెద్ద నోడ్లు లేదా చాలా చిన్నవి? ఎప్పటిలాగే, స్పష్టమైన సమాధానం లేదు. చాలా అప్లికేషన్ రకం మీద ఆధారపడి ఉంటుంది.
ఉదాహరణకు, ఒక అప్లికేషన్‌కు 10 GB మెమరీ అవసరమైతే, పెద్ద నోడ్లు స్పష్టమైన ఎంపిక. మరియు అధిక లభ్యత కోసం అప్లికేషన్‌కు పదిరెట్లు రెప్లికేషన్ అవసరమైతే, కేవలం రెండు నోడ్‌లపై ప్రతిరూపాలను ఉంచడం వల్ల వచ్చే ప్రమాదం చాలా తక్కువ - క్లస్టర్‌లో కనీసం పది నోడ్లు ఉండాలి.
ఇంటర్మీడియట్ పరిస్థితుల్లో, ప్రతి ఎంపిక యొక్క ప్రయోజనాలు మరియు అప్రయోజనాలు ఆధారంగా ఎంపిక చేసుకోండి. బహుశా కొన్ని వాదనలు ఇతరుల కంటే మీ పరిస్థితికి మరింత సంబంధితంగా ఉండవచ్చు.
మరియు అన్ని నోడ్‌లను ఒకే పరిమాణంలో చేయడం అస్సలు అవసరం లేదు. అదే పరిమాణంలోని నోడ్‌లతో మొదట ప్రయోగాలు చేయకుండా, ఆపై వాటికి వేరే పరిమాణంలోని నోడ్‌లను జోడించి, వాటిని క్లస్టర్‌లో కలపడం నుండి ఏదీ మిమ్మల్ని నిరోధించదు. కుబెర్నెటెస్ క్లస్టర్‌లోని వర్కర్ నోడ్లు పూర్తిగా భిన్నమైనవి. కాబట్టి మీరు రెండు విధానాల ప్రయోజనాలను కలపడానికి ప్రయత్నించవచ్చు.
ఒకే రెసిపీ లేదు, మరియు ప్రతి పరిస్థితికి దాని స్వంత సూక్ష్మ నైపుణ్యాలు ఉన్నాయి మరియు ఉత్పత్తి మాత్రమే సత్యాన్ని చూపుతుంది.
క్లౌడ్ ప్లాట్‌ఫారమ్ బృందం ద్వారా అనువాదం సిద్ధం చేయబడింది .
Kubernetes గురించి మరింత: .
మూలం: www.habr.com