మేము ఈ కథనంలో వివిధ కుబెర్నెట్స్ రీస్టార్ట్ విధానాల గురించి ప్రత్యేకంగా మాట్లాడుతాము. కుబెర్నెట్‌లను పునఃప్రారంభించవలసి వచ్చినప్పుడు ఉపయోగించే వివిధ విధానాలను ముందుగా చర్చిద్దాం. క్లస్టర్‌లో నిర్దిష్ట పనిభారాన్ని అమలు చేయకుండా ఆపడానికి మీరు ఈ విధానాలను ఉపయోగించవచ్చు. క్లస్టర్‌లో కఠినమైన ప్రమాణాలను విధించడం సాధారణంగా సమ్మతిని నిర్ధారించడానికి చేయబడుతుంది, క్లస్టర్ నిర్వాహకులు సూచించిన అనేక ఉత్తమ పద్ధతులను కూడా అనుసరించాలి.
కుబెర్నెట్స్ పునఃప్రారంభ విధానం అంటే ఏమిటి?
ప్రతి కుబెర్నెటెస్ పాడ్ ఒక నిర్దిష్ట జీవితచక్రానికి కట్టుబడి ఉంటుంది. ఇది 'పెండింగ్' దశలో ప్రారంభమవుతుంది మరియు ఒకటి లేదా అంతకంటే ఎక్కువ ప్రాథమిక కంటైనర్లు విజయవంతంగా ప్రారంభించబడితే, 'రన్నింగ్' దశకు మారుతుంది. పాడ్‌లోని కంటైనర్లు విజయవంతమయ్యాయా లేదా విఫలమైనా అనేదానిపై ఆధారపడి, ప్రక్రియ 'విజయవంతం' లేదా 'విఫలమైంది' దశకు వెళుతుంది.
దరఖాస్తు చేసిన కంటైనర్‌ల స్థాయిలో విధానాన్ని పునఃప్రారంభించడానికి, మూడు ఎంపికలను ఉపయోగించవచ్చు:
ఎల్లప్పుడూ
కంటైనర్‌ను ముగించిన ప్రతిసారీ, పాడ్ అన్ని సమయాల్లో యాక్టివ్‌గా ఉండాలి కాబట్టి కుబెర్నెటెస్ కొత్తదాన్ని ఉత్పత్తి చేస్తుంది.
వైఫల్యంపై
కంటైనర్ 0 కాకుండా ఇతర రిటర్న్ కోడ్‌తో నిష్క్రమిస్తే, అది ఒక్కసారి మాత్రమే రీస్టార్ట్ అవుతుంది. 0 (విజయం)ని అందించే కంటైనర్‌ల కోసం పునఃప్రారంభించడం అవసరం లేదు.
ఎప్పుడూ
కంటైనర్ పునఃప్రారంభించడంలో విఫలమైంది.
ఇప్పుడు, కింది విభాగంలో, మీరు పాడ్‌ను ఎలా పునఃప్రారంభించవచ్చో మేము చర్చిస్తాము.
కుబెర్నెటెస్‌లో పాడ్‌ని రీస్టార్ట్ చేయడం ఎలా?
Kubernetes పాడ్‌ని రీస్టార్ట్ చేయడానికి, kubectl టూల్‌ని ఉపయోగించి ఆదేశాలను జారీ చేయండి. ఇది KubeAPI సర్వర్‌తో కనెక్ట్ అవుతుంది. అందుబాటులో ఉన్న ఎంపికలను అన్వేషిద్దాం:
పాడ్‌లో కంటైనర్‌ను పునఃప్రారంభించడం
ఒక పాడ్ అనేక కంటైనర్లను కలిగి ఉండవచ్చు. మరోవైపు, మీరు పాడ్‌కి కనెక్ట్ చేసినప్పుడు దానిలోని ప్రాథమిక కంటైనర్‌కు తప్పనిసరిగా కనెక్ట్ అవ్వండి. మీరు ఒకటి కంటే ఎక్కువ నిర్వచించినట్లయితే, మీరు ఒక సందర్భంలో నిర్వచించిన ప్రతి కంటైనర్‌కు కనెక్ట్ చేయవచ్చు.
మీరు బహుళ-కంటైనర్ పాడ్ స్పెసిఫికేషన్ ఉదాహరణను క్రింద చూడవచ్చు:
ఇది షేర్డ్ వాల్యూమ్ మరియు రెండు కంటైనర్లను వివరిస్తుంది. HTML ఫైల్ NGINX కంటైనర్ ద్వారా అందించబడుతుంది మరియు ప్రతి సెకను ఉబుంటు కంటైనర్ HTML ఫైల్‌కి తేదీ స్టాంప్‌ను జోడిస్తుంది.
ఏ కంటైనర్‌కు కనెక్ట్ చేయాలో మీరు పేర్కొనలేదు కాబట్టి, మీరు ఆ పాడ్‌కి కనెక్ట్ చేయడానికి ప్రయత్నించినప్పుడు అది స్వయంచాలకంగా మొదటిదాన్ని (NGINX) ఎంచుకుంటుంది. స్క్రీన్‌షాట్ దిగువన జోడించబడింది:
మీరు ఇప్పుడు ప్రస్తుతం యాక్టివ్‌గా ఉన్న కంటైనర్‌లో PID 1 ప్రక్రియను ముగించడానికి ప్రయత్నించవచ్చు. దీన్ని సాధించడానికి కింది ఆదేశాలను రూట్‌గా అమలు చేయండి:
మీరు క్రింద వివరించిన kubectl సాధనాన్ని కూడా ఉపయోగించవచ్చు:
పాడ్ స్పెసిఫికేషన్ ప్రకారం, K8s ఇప్పుడు ధ్వంసమైన కంటైనర్‌ను రీస్టార్ట్ చేయడానికి ప్రయత్నిస్తాయి. దాని కోసం, 'వర్ణించు' ఆదేశం క్రింది విధంగా ఉపయోగించబడుతుంది:
పై ఆదేశం యొక్క ఫలితం ఇక్కడ ఉంది:
ప్రస్తుత స్థితి 'వెళ్తుంది' అయితే మునుపటి స్థితి 'ముగిసిపోయింది.' దీని ప్రకారం కంటైనర్ పునఃప్రారంభించబడిందని దీని అర్థం. అయినప్పటికీ, అన్ని కంటైనర్లు రూట్ ఆధారాలను యాక్సెస్ చేయలేవు. అందుకే ఈ పద్ధతి చాలా ఉపయోగకరంగా ఉండకపోవచ్చు.
స్కేలింగ్ ద్వారా పాడ్‌ని పునఃప్రారంభించడం
పాడ్ యొక్క ప్రతిరూప గణనను 0కి స్కేల్ చేసి, ఆపై దానిని 1కి పెంచడం అనేది పునఃప్రారంభించడానికి సులభమైన మార్గం. పాడ్‌లలో స్కేల్ కమాండ్ ఉపయోగించబడదు కాబట్టి మీరు తప్పనిసరిగా డిప్లాయ్‌మెంట్‌ని నిర్మించాలి. దీన్ని సాధించడానికి సులభమైన మార్గం ఇక్కడ ఉంది:
ఆ తర్వాత 0కి ఆపై 1కి స్కేల్ చేయండి. ఇలా చేయడం ద్వారా, పాడ్ రద్దు చేయబడుతుంది మరియు క్లస్టర్‌కు మళ్లీ అమర్చబడుతుంది:
మీరు ఈ చిత్రంలో చూడగలిగే విధంగా ప్రతిరూపాలు 1కి సెట్ చేయబడ్డాయి.
విస్తరణ వివరాలను వీక్షించడానికి, మేము ఇప్పుడు “kubectl get deployments”ని ఉపయోగించాము. కిందిది ఆదేశం మరియు ఫలితం రెండింటి జాబితా:
పాడ్‌ను తొలగించడం మరియు మళ్లీ అమర్చడం ద్వారా దాన్ని పునఃప్రారంభించడం
“kubectl delete” ఆదేశాన్ని ఉపయోగించి, మీరు ఒక పాడ్‌ను తొలగించి, ఆపై దాన్ని మళ్లీ అమర్చవచ్చు. అయితే, ఈ విధానం చాలా విఘాతం కలిగిస్తుంది, కాబట్టి ఇది సిఫారసు చేయబడలేదు.
రోల్‌అవుట్‌ని ఉపయోగించి పాడ్‌ని పునఃప్రారంభించడం
పైన వివరించిన పద్ధతిని ఉపయోగించి పాడ్‌ను పునఃప్రారంభించడానికి, మీరు ఇప్పటికే ఉన్న పాడ్‌ను నాశనం చేసి, ఆపై కొత్తదాన్ని సృష్టించాలి లేదా ప్రతిరూపాన్ని తగ్గించి ఆపై పైకి స్కేల్ చేయాలి. Kubernetes వెర్షన్ 1.15తో, మీరు రోలింగ్ పద్ధతిలో విస్తరణను పునఃప్రారంభించవచ్చు. పాడ్‌ను పునఃప్రారంభించడానికి ఇది సూచించబడిన విధానం. ప్రారంభించడానికి కింది ఆదేశాన్ని నమోదు చేయండి:
ఇప్పుడు, మీరు వేరే టెర్మినల్‌లో విస్తరణ స్థితిని గమనిస్తే, మీరు ఈ క్రింది విధంగా ఈవెంట్‌ల ప్రవాహాన్ని గమనించవచ్చు:
ఇది ఆరోగ్యంగా ఉంటే, ఇది డిప్లాయ్‌మెంట్ యొక్క మునుపటి ప్రతిరూపాన్ని తగ్గించి, పాడ్ యొక్క కొత్త ప్రతిరూపాన్ని స్పిన్ అప్ చేస్తుంది. ఫలితం ఒకే విధంగా ఉంటుంది, ఈ విధానంలో తప్ప, అంతర్లీన ఆర్కెస్ట్రేషన్‌ను కుబెర్నెట్స్ నిర్వహించింది.
కుబెర్నెటెస్ పాడ్‌లను వివిధ మార్గాల్లో ఎలా పునఃప్రారంభించవచ్చు?
మొదట డాకర్ కంటైనర్‌తో ప్రారంభిద్దాం. కింది ఆదేశంతో, డాకర్ కంటైనర్లను పునఃప్రారంభించవచ్చు:
> డాకర్ రీస్టార్ట్ కంటైనర్_ఐడి
కానీ కుబెర్నెటెస్‌లో, పాడ్‌లను రీస్టార్ట్ చేయడానికి పోల్చదగిన కమాండ్ లేదు, ప్రత్యేకించి పేర్కొన్న YAML ఫైల్ లేనట్లయితే. ప్రత్యామ్నాయంగా, మీరు kubectl ఆదేశాలను ఉపయోగించి Kubernetes పాడ్‌లను పునఃప్రారంభించవచ్చు. కింది ఆదేశాలు జాబితా చేయబడ్డాయి:
కుబెక్ట్ల్ సెట్ ఎన్వి కమాండ్
kubectl స్కేల్ కమాండ్‌ని ఉపయోగించడం ఒక పద్ధతి. ఇది పునఃప్రారంభించవలసిన పాడ్ యొక్క ప్రతిరూపాల సంఖ్యను సవరిస్తుంది. పాడ్‌లోని ప్రతిరూపాలను రెండుగా ఎలా సెట్ చేయాలనే దానిపై ఒక ఉదాహరణ ఆదేశం క్రింద ఉంది:
> kubectl స్కేల్ విస్తరణ మొదటి విస్తరణ --ప్రతిరూపాలు = 2
రోల్అవుట్ పునఃప్రారంభ కమాండ్
ఇక్కడ, మేము Kubernetes పాడ్‌లను పునఃప్రారంభించడానికి రోల్అవుట్ పునఃప్రారంభ కమాండ్‌ను ఎలా ఉపయోగించాలో ప్రదర్శిస్తాము:
> kubectl రోల్అవుట్ రీస్టార్ట్ డిప్లాయ్‌మెంట్ మొదటి-డిప్లాయ్‌మెంట్ -ఎన్ డెమో-నేమ్‌స్పేస్
కమాండ్ ద్వారా ప్రతి పాడ్‌ని ఒక్కొక్కటిగా నిర్మూలించమని కంట్రోలర్‌కు చెప్పబడింది. ఇది రెప్లికాసెట్‌ని ఉపయోగించి కొత్త పాడ్‌లను స్కేల్ చేస్తుంది. కంట్రోలర్ పునఃప్రారంభించినప్పుడు ప్రతి కొత్త పాడ్ ప్రతి ప్రస్తుత పాడ్ కంటే ఇటీవలి వరకు, ఈ ప్రక్రియ కొనసాగుతుంది.
తొలగించు పాడ్ కమాండ్
ఈ విభాగం Kubernetes పాడ్‌లను పునఃప్రారంభించడానికి తొలగించు ఆదేశాన్ని ఎలా ఉపయోగించాలో తెలియజేస్తుంది. ఈ చిత్రంలో పాడ్ API ఆబ్జెక్ట్‌ను వదిలించుకోవడానికి మేము తదుపరి ఆదేశాన్ని ఉపయోగించినట్లు మీరు గమనించవచ్చు:
. > kubectl పాడ్ ఫస్ట్-పాడ్‌ను తొలగించండి -ఎన్ డెమో_నేమ్‌స్పేస్
కుబెర్నెటెస్ API డిక్లరేటివ్‌గా ఉన్నందున పాడ్ ఆబ్జెక్ట్‌ను తొలగించడం ద్వారా ఊహించినది విరుద్ధంగా ఉంది. ఊహించిన దానితో స్థిరంగా ఉండటానికి, పాడ్ పునఃసృష్టి చేయబడుతుంది.
మునుపటి ఆదేశాన్ని ఉపయోగించి ఒక సమయంలో ఒక పాడ్‌ని పునఃప్రారంభించవచ్చు. అనేక పాడ్‌లను పునఃప్రారంభించడానికి జోడించిన ఆదేశాన్ని చూడండి:
> kubectl replicaset pods-multiple-n demo_namespaceని తొలగించండి
పైన పేర్కొన్న కమాండ్ పాడ్‌ల యొక్క మొత్తం రెప్లికాసెట్‌ను తొలగించడం ద్వారా ప్రతి పాడ్‌ను పునఃప్రారంభిస్తుంది మరియు దానిని మొదటి నుండి సృష్టించడం.
ముగింపు
ఈ పోస్ట్ వివిధ కుబెర్నెట్స్ రీస్టార్ట్ విధానాలపై సమాచారాన్ని అందించింది. మేము నమూనా ఉదాహరణల సహాయంతో ప్రతి దశను వివరించాము. అలాగే, ఈ ఆదేశాలను ప్రయత్నించండి మరియు అవి ఉత్పత్తి చేసే అవుట్‌పుట్‌ను చూడండి.