ఒకే ఒక కంటైనర్ను డిప్లాయ్ చేయడం సులభం. పది కంటైనర్లను డిప్లాయ్ చేయడం మేనేజబుల్. కానీ డజన్ల కొద్దీ మెషీన్ల మీద వందల కొద్దీ కంటైనర్లను నడుపుతున్నప్పుడు, మాన్యువల్ మేనేజ్మెంట్ కష్టంగా మారడమే కాకుండా అసాధ్యంగా మారుతుంది. ఏ కంటైనర్ ఎక్కడ ఉందో మీకు తెలియదు. ఒక సర్వర్ ఆగిపోతే, ఎవరైనా దానిని రీస్టార్ట్ చేసే వరకు మీ అప్లికేషన్ కనిపించకుండా పోతుంది. కొత్త ఇన్స్టాన్స్లను సిద్ధం చేసేలోపే ట్రాఫిక్ పెరిగి మీ సెటప్ను దెబ్బతీస్తుంది. సరిగ్గా ఇక్కడే Kubernetes రంగంలోకి వస్తుంది. ఇది కేవలం మరొక DevOps టూల్ మాత్రమే కాదు. ఇది కంటైనర్ మేనేజ్మెంట్ను ఒక స్క్రిప్టింగ్ వ్యాయామంలా కాకుండా, ఒక కంట్రోల్ ప్రాబ్లమ్గా పరిగణించే ఆర్కెస్ట్రేషన్ లేయర్.
స్క్రిప్ట్లు ఎందుకు విఫలమవుతాయి
చాలా టీమ్లు షెల్ స్క్రిప్ట్లు లేదా బేసిక్ ఆటోమేషన్తో ప్రారంభిస్తాయి. ఇమేజ్లను పుల్ చేయడానికి, కంటైనర్లను ప్రారంభించడానికి, లాగ్లను గమనించడానికి మరియు ఫెయిల్ అయిన ప్రాసెస్లను రీస్టార్ట్ చేయడానికి వారు కమాండ్లను రాస్తారు. ఆ విధానం ఒక ప్రూఫ్ ఆఫ్ కాన్సెప్ట్ (proof of concept) కోసం పనిచేస్తుంది. కానీ వాస్తవ ప్రపంచ లోడ్ కింద అది కుప్పకూలుతుంది. మైక్రోసర్వీసెస్ వేర్వేరు హోస్ట్ల మధ్య ఒకదానితో ఒకటి మాట్లాడుకుంటాయి, నిర్దిష్ట ఎన్విరాన్మెంట్ వేరియబుల్స్పై ఆధారపడతాయి, కంటైనర్ రీస్టార్ట్ల తర్వాత కూడా ఉండే పర్సిస్టెంట్ స్టోరేజ్ అవసరం అవుతుంది మరియు వెర్షన్ల మధ్య స్థిరమైన నెట్వర్కింగ్ను ఆశిస్తాయి. ఒక వర్చువల్ మెషీన్ కనిపించకుండా పోయినప్పుడు, ఒక స్క్రిప్ట్ ఆటోమేటిక్గా వర్క్లోడ్ను రీషెడ్యూల్ చేయలేదు. క్రాష్ లూప్లో ఉన్న వాటిని వదిలేసి, ఆరోగ్యంగా ఉన్న ఇన్స్టాన్స్ల మధ్య నెట్వర్క్ ట్రాఫిక్ను పంపిణీ చేయలేదు. క్లస్టర్ను స్వయంగా ఆ నిర్ణయాలకు బాధ్యుని చేయడం ద్వారా Kubernetes దీనిని పరిష్కరిస్తుంది. మీరు ఏమి కావాలో వివరిస్తే, సిస్టమ్ నిరంతరం ఆ స్థితిని అమలు చేస్తుంది.
ఇది మీకు అందించే మూడు ముఖ్యమైన అంశాలు
మాన్యువల్ ఫైర్ఫైటింగ్కు బదులుగా ఆటోమేటెడ్ విశ్వసనీయతను అందించే మూడు ప్రధాన సామర్థ్యాలను Kubernetes అందిస్తుంది.
High availability అంటే మీ ఇన్ఫ్రాస్ట్రక్చర్ లోని భాగాలు విఫలమైనప్పటికీ మీ అప్లికేషన్లు ఆన్లైన్లోనే ఉంటాయి. ఒక కంటైనర్ క్రాష్ అయితే, Kubernetes దానిని సెకన్ల వ్యవధిలో రీప్లేస్ చేస్తుంది. ఒకవేళ మొత్తం వర్కర్ నోడ్ ఆగిపోతే, షెడ్యూలర్ ఆ మిస్సింగ్ హార్ట్బీట్ను గమనించి, ప్రభావితమైన వర్క్లోడ్లను క్లస్టర్లోని ఇతర ఆరోగ్యకరమైన మెషీన్లకు మారుస్తుంది. మీరు నిర్వచించిన కావలసిన స్థితిని (desired state) సిస్టమ్ నిరంతరం పర్యవేక్షిస్తుంది మరియు మానవ జోక్యం లేకుండా తేడాలను సరిచేస్తుంది.
Scalability అంటే మీ వినియోగదారులతో పాటు మీ అప్లికేషన్లు కూడా పెరుగుతాయి. కేవలం రెండు గంటల ట్రాఫిక్ పీక్ కోసం ఇరవై సర్వర్లను సిద్ధం చేసే బదులు, మీరు CPU వినియోగం లేదా రిక్వెస్ట్ లేటెన్సీ వంటి ముఖ్యమైన మెట్రిక్స్ను నిర్వచిస్తారు మరియు థ్రెషోల్డ్లు దాటినప్పుడు క్లస్టర్ మరిన్ని కంటైనర్ ఇన్స్టాన్స్లను జోడించేలా చేస్తారు. డిమాండ్ తగ్గినప్పుడు, రీప్లికా కౌంట్ మళ్ళీ తగ్గుతుంది. మీకు అవసరమైనప్పుడు, ఎంత అవసరమో అంతే చెల్లిస్తారు.
Disaster recovery అంటే క్రాష్ తర్వాత మీ డేటా మరియు కాన్ఫిగరేషన్ తిరిగి వస్తాయి. Kubernetes క్లస్టర్ స్థితి మొత్తాన్ని డిస్ట్రిబ్యూటెడ్ కీ-వాల్యూ స్టోర్లో నిల్వ చేస్తుంది. ఒక విపత్కర వైఫల్యం వల్ల వర్కర్ నోడ్లు లేదా కంట్రోల్ ప్లేన్ లోని కొంత భాగం కూడా తుడిచిపెట్టుకుపోయినా, ఆ నిల్వ చేయబడిన స్థితి వల్ల సిస్టమ్ మీ వర్క్లోడ్లను అవి ఎలా కాన్ఫిగర్ చేయబడ్డాయో సరిగ్గా అలాగే తిరిగి నిర్మించగలదు. ఆర్కెస్ట్రేటర్ దాని రూపం ఎలా ఉండాలో గుర్తుంచుకోవడం వల్ల మీ డేటా తిరిగి వస్తుంది.
సెటప్: బ్రెయిన్స్ అండ్ మజిల్ (Brains and Muscle)
Kubernetes క్లస్టర్కు రెండు ప్రాథమిక పాత్రలు ఉన్నాయి, వీటిని డ్రాఫ్ట్ బ్రెయిన్ మరియు మజిల్ అని వర్ణిస్తుంది, మరియు ఈ పోలిక వాస్తవంలో బాగా సరిపోతుంది.
Master Node అనేది బ్రెయిన్. ఇది మీ కస్టమర్-ఫేసింగ్ అప్లికేషన్లను నడపదు. బదులుగా, ఇది టాస్క్లను షెడ్యూల్ చేసే, క్లస్టర్ స్థితిని నిర్వహించే మరియు మార్పులకు ప్రతిస్పందించే కంట్రోల్ ప్లేన్ భాగాలను హోస్ట్ చేస్తుంది. మీరు ఒక కమాండ్ను జారీ చేసినప్పుడు లేదా కాన్ఫిగరేషన్ ఫైల్ను సబ్మిట్ చేసినప్పుడు, వర్క్లోడ్ ఎక్కడ ఉండాలి, అది ఆరోగ్యంగా ఉందా లేదా మరియు అది సరిగ్గా లేనప్పుడు ఏమి చేయాలి అనేది మాస్టర్ నోడ్ నిర్ణయిస్తుంది.
Worker Nodes అనేవి మజిల్. ప్రతి వర్కర్ మాస్టర్తో కమ్యూనికేట్ చేసే ఒక లైట్వెయిట్ ఏజెంట్ను నడుపుతుంది మరియు అసలు పాడ్లను (pods) అమలు చేయడానికి కంటైనర్ రన్టైమ్ను
Pods అనేవి Kubernetesలో అత్యంత చిన్నగా విస్తరించగలిగే (deployable) యూనిట్లు. వనరులను (resources) పంచుకోవాల్సిన ఒకటి లేదా అంతకంటే ఎక్కువ కంటైనర్లను ఒక Pod చుట్టూ ఉంచుతుంది. ఇవి ఒకే నెట్వర్క్ నేమ్స్పేస్ను పంచుకుంటాయి మరియు ఒకే లోకల్ స్టోరేజ్ వాల్యూమ్స్ను యాక్సెస్ చేయగలవు. ఇది ముఖ్యమైన విషయం: మీరు నేరుగా ఒక కంటైనర్ను డిప్లాయ్ చేయరు. దాన్ని కలిగి ఉన్న ఒక Podను డిప్లాయ్ చేస్తారు. Pods కావాలనే తాత్కాలికమైనవి (ephemeral). పరిస్థితులు మారినప్పుడు అవి సృష్టించబడతాయి, నాశనం చేయబడతాయి మరియు భర్తీ చేయబడతాయి. వాటి జీవితకాలం డిజైన్ పరంగానే డైనమిక్గా ఉంటుంది.
Services అనేవి Pods తాత్కాలికమైనవి కాబట్టే అవసరం అవుతాయి. ప్రతిసారి ఒక Pod రీస్టార్ట్ అయినప్పుడు, దానికి కొత్త ఇంటర్నల్ IP అడ్రస్ వచ్చే అవకాశం ఉంది. మీ అప్లికేషన్లోని ఇతర భాగాలు నేరుగా ఆ మారుతున్న అడ్రస్లకు కనెక్ట్ అవ్వడానికి ప్రయత్నిస్తే, అవి నిరంతరం విఫలమవుతాయి. ఒక సర్వీస్ మీ Podలకు స్థిరమైన IP అడ్రస్ మరియు DNS పేరును అందిస్తుంది. ఇది ఒక స్థిరమైన ఫ్రంట్ డోర్లా పనిచేస్తుంది, తన సెలెక్టర్ (selector) కు సరిపోయే అన్ని ఆరోగ్యకరమైన (healthy) Podల మధ్య వచ్చే రిక్వెస్ట్లను లోడ్-బ్యాలెన్స్ చేస్తుంది. ఇది మీ క్లయింట్లను వ్యక్తిగత కంటైనర్ లైఫ్ సైకిల్స్ వల్ల కలిగే గందరగోళం నుండి వేరు చేస్తుంది.
భారీ స్థాయిలో Kubernetes: Netflix ఉదాహరణ
Netflix తన కంటెంట్ డెలివరీ నెట్వర్క్ను నిర్వహించడానికి Kubernetesను ఉపయోగిస్తుంది. ఈ మౌలిక సదుపాయం ప్రపంచవ్యాప్తంగా మిలియన్ల మంది వీక్షకులకు ఒకేసారి వీడియో స్ట్రీమ్లను అందిస్తుంది. ఒక పాపులర్ షో విడుదలైనప్పుడు మరియు డిమాండ్ పెరిగినప్పుడు, క్లస్టర్ వినియోగదారులకు దగ్గరగా వీడియో సెగ్మెంట్లను నిల్వ చేసే క్యాచీ నోడ్స్ (cache nodes) సామర్థ్యాన్ని పెంచుతుంది (scales out). ఒకవేళ ఏదైనా రీజినల్ నోడ్ విఫలమైతే, ట్రాఫిక్ ఆటోమేటిక్గా వేరే మార్గంలోకి మళ్లుతుంది. దీని ఫలితంగా, ఇంజనీర్కు మాన్యువల్గా ఎమర్జెన్సీ అలర్ట్ పంపాల్సిన అవసరం లేకుండానే, లక్షలాది మంది ప్రజలకు సినిమాలు నిరంతరాయంగా అందుతాయి. ఆర్కెస్ట్రేటర్ (orchestrator) స్కేల్ మరియు వైఫల్యాలను నిర్వహిస్తుంది, తద్వారా సర్వీస్ ఎటువంటి అంతరాయం లేకుండా కొనసాగుతుంది.
ప్రారంభించడం: YAML, JSON, మరియు API Server
Kubernetesతో ప్రారంభించడం అంటే 'imperative click-ops' పద్ధతిని వదిలివేసి, 'declarative configuration'ను స్వీకరించడం. మీకు కావాల్సిన దానిని YAML లేదా JSON ఫైళ్లలో రాస్తారు. ఈ మానిఫెస్ట్లు (manifests) కంటైనర్ ఇమేజ్ నుండి రిప్లికా సంఖ్య, ఎక్స్పోజ్డ్ పోర్ట్లు, ఎన్విరాన్మెంట్ వేరియబుల్స్ మరియు స్టోరేజ్ మౌంట్ల వరకు అన్నింటినీ వివరిస్తాయి. మీ ఫైల్ సిద్ధమైన తర్వాత, దానిని మాస్టర్ నోడ్లోని API సర్వర్కు పంపుతారు. కంట్రోల్ ప్లేన్ ఆ డిక్లరేషన్ను స్వీకరించి, దానిని క్లస్టర్ స్టేట్ డేటాబేస్లో నిల్వ చేస్తుంది, ఆపై మీ వివరణకు అనుగుణంగా వాస్తవ పరిస్థితులను మార్చడానికి పని ప్రారంభిస్తుంది. Kubernetes తన పనిని ఎలా చేయాలో మీరు ఖచ్చితంగా చెప్పరు. తుది ఫలితం (end result) ఎలా ఉండాలో చెబితే చాలు, అది కావాల్సిన దశలను (steps) స్వయంగా నిర్ణయించుకుంటుంది.
అసలైన సారాంశం
Kubernetes నేర్చుకోవడం కొంచెం కష్టంగా అనిపించవచ్చు. మొదట్లో సాంకేతిక పదజాలం (terminology) చాలా క్లిష్టంగా అనిపిస్తుంది. ఇందులో చాలా అంశాలు కలిసి పనిచేస్తాయి, మరియు ఒక సింగిల్ సర్వర్ను డీబగ్ చేయడం కంటే డిస్ట్రిబ్యూటెడ్ సిస్టమ్ను డీబగ్ చేయడం సహజంగానే కష్టం. కానీ దీని వల్ల కలిగే ప్రయోజనం ఏమిటంటే 'ఆపరేషనల్ కమ్' (operational calm). మీరు ప్రతి మెషిన్ను వ్యక్తిగతంగా పర్యవేక్షించాల్సిన అవసరం ఉండదు. తెల్లవారుజామున 3 గంటల సమయంలో సర్వర్ డౌన్ అయినప్పుడు, మీ స్టార్టప్ స్క్రిప్ట్లు పనిచేస్తాయని మీరు ప్రార్థించాల్సిన అవసరం ఉండదు. నోడ్స్ విఫలమవుతాయని ఊహిస్తూ, డిఫాల్ట్గా వైఫల్యాలను తట్టుకునేలా (designing for failure) మీరు ప్లాన్ చేయడం ప్రారంభిస్తారు మరియు మీ అప్లికేషన్ను క్షేమంగా ఉంచడానికి ఆర్కెస్ట్రేటర్ను నమ్ముతారు. ఏదీ విఫలం కాకూడదని ఆశించడం నుండి, వ్యవస్థ విఫలమైనా దాన్ని తట్టుకోగలదని తెలుసుకోవడం వరకు కలిగే ఆ మానసిక మార్పు (mindset shift) ఈ ప్రయత్నాన్ని స