కుబెర్నెట్‌లను విస్తరించడం మరియు పూర్తి చేయడం (సమీక్ష మరియు వీడియో నివేదిక)

ఏప్రిల్ 8 సదస్సులో సెయింట్ హైలోడ్++ 2019, “DevOps మరియు ఆపరేషన్స్” విభాగంలో భాగంగా, “Kubernetesని విస్తరించడం మరియు పూర్తి చేయడం” అనే నివేదిక ఇవ్వబడింది, దీని సృష్టిలో Flant కంపెనీకి చెందిన ముగ్గురు ఉద్యోగులు పాల్గొన్నారు. దీనిలో, మేము కుబెర్నెటెస్ యొక్క సామర్థ్యాలను విస్తరించాలని మరియు పూర్తి చేయాలని కోరుకునే అనేక పరిస్థితుల గురించి మాట్లాడుతాము, కానీ దీని కోసం మేము రెడీమేడ్ మరియు సరళమైన పరిష్కారాన్ని కనుగొనలేదు. మేము ఓపెన్ సోర్స్ ప్రాజెక్ట్‌ల రూపంలో అవసరమైన పరిష్కారాలను కలిగి ఉన్నాము మరియు ఈ ప్రసంగం కూడా వారికి అంకితం చేయబడింది.

సంప్రదాయం ప్రకారం, మేము ప్రదర్శించడానికి సంతోషిస్తున్నాము నివేదిక యొక్క వీడియో (50 నిమిషాలు, వ్యాసం కంటే చాలా ఎక్కువ సమాచారం) మరియు వచన రూపంలో ప్రధాన సారాంశం. వెళ్ళండి!

K8లలో కోర్ మరియు చేర్పులు

కుబెర్నెటెస్ చాలా కాలంగా స్థాపించబడిన పరిశ్రమను మరియు పరిపాలనకు సంబంధించిన విధానాలను మారుస్తున్నాడు:

• అతనికి ధన్యవాదాలు సంగ్రహణలు, మేము ఇకపై కాన్ఫిగరేషన్‌ను సెటప్ చేయడం లేదా ఆదేశాన్ని అమలు చేయడం (చెఫ్, అన్సిబుల్...) వంటి కాన్సెప్ట్‌లతో పనిచేయము, కానీ కంటైనర్‌లు, సేవలు మొదలైన వాటి సమూహాన్ని ఉపయోగిస్తాము.
• యొక్క సూక్ష్మ నైపుణ్యాల గురించి ఆలోచించకుండా మేము అప్లికేషన్‌లను సిద్ధం చేయవచ్చు నిర్దిష్ట సైట్, ఇది ప్రారంభించబడుతుంది: బేర్ మెటల్, ప్రొవైడర్లలో ఒకరి క్లౌడ్ మొదలైనవి.
• K8sతో మీరు ఎన్నడూ మరింత ప్రాప్యత చేయలేరు ఉత్తమ అభ్యాసాలు ఆర్గనైజింగ్ ఇన్‌ఫ్రాస్ట్రక్చర్‌పై: స్కేలింగ్ టెక్నిక్స్, సెల్ఫ్ హీలింగ్, ఫాల్ట్ టాలరెన్స్ మొదలైనవి.

అయితే, వాస్తవానికి, ప్రతిదీ అంత సజావుగా లేదు: కుబెర్నెటెస్ తన స్వంత కొత్త సవాళ్లను కూడా తెచ్చాడు.

Kubernetes కాదు వినియోగదారులందరి సమస్యలను పరిష్కరించే కలయిక. కోర్ ప్రస్తుతం ఉన్న కనీస అవసరమైన ఫంక్షన్‌ల సమితికి మాత్రమే కుబెర్నెటెస్ బాధ్యత వహిస్తాడు ప్రతి క్లస్టర్:

కుబెర్నెటెస్ కోర్ కంటైనర్‌లను సమూహపరచడం, ట్రాఫిక్‌ను నిర్వహించడం మరియు మొదలైన వాటి కోసం ప్రాథమిక సెట్‌ను నిర్వచిస్తుంది. మేము వాటి గురించి మరింత వివరంగా మాట్లాడాము 2 సంవత్సరాల క్రితం నివేదిక.

మరోవైపు, K8s అందుబాటులో ఉన్న ఫంక్షన్‌లను విస్తరించడానికి గొప్ప అవకాశాలను అందిస్తుంది, ఇది ఇతరులను మూసివేయడానికి సహాయపడుతుంది - నిర్దిష్ట - వినియోగదారు అవసరాలు. కుబెర్నెట్స్‌కు చేర్పులు క్లస్టర్ నిర్వాహకుల బాధ్యత, వారు తమ క్లస్టర్‌ను “సరైన ఆకృతిలో” పొందేందుకు [వారి నిర్దిష్ట సమస్యలను పరిష్కరించడానికి] అవసరమైన ప్రతిదాన్ని ఇన్‌స్టాల్ చేసి, కాన్ఫిగర్ చేయాలి. ఇవి ఎలాంటి చేర్పులు? కొన్ని ఉదాహరణలు చూద్దాం.

యాడ్-ఆన్‌ల ఉదాహరణలు

కుబెర్నెట్‌లను ఇన్‌స్టాల్ చేసిన తర్వాత, నోడ్‌లో మరియు నోడ్‌ల మధ్య పాడ్‌ల పరస్పర చర్యకు అవసరమైన నెట్‌వర్కింగ్ దాని స్వంతంగా పని చేయకపోవడం మాకు ఆశ్చర్యం కలిగిస్తుంది. Kubernetes కెర్నల్ అవసరమైన కనెక్షన్‌లకు హామీ ఇవ్వదు; బదులుగా, ఇది నెట్‌వర్క్‌ను నిర్ణయిస్తుంది ఇంటర్ఫేస్ (సిఎన్ఐ) మూడవ పార్టీ యాడ్-ఆన్‌ల కోసం. నెట్‌వర్క్ కాన్ఫిగరేషన్‌కు బాధ్యత వహించే ఈ యాడ్-ఆన్‌లలో ఒకదానిని మనం తప్పనిసరిగా ఇన్‌స్టాల్ చేయాలి.

దగ్గరి ఉదాహరణ డేటా నిల్వ పరిష్కారాలు (స్థానిక డిస్క్, నెట్‌వర్క్ బ్లాక్ పరికరం, Ceph...). ప్రారంభంలో వారు కోర్లో ఉన్నారు, కానీ ఆగమనంతో CSI పరిస్థితి ఇప్పటికే వివరించిన విధంగానే మారుతుంది: ఇంటర్‌ఫేస్ కుబెర్నెట్స్‌లో ఉంది మరియు దాని అమలు మూడవ పక్షం మాడ్యూల్స్‌లో ఉంది.

ఇతర ఉదాహరణలు:

• లోపల ప్రవేశించుట-కంట్రోలర్లు (లో వారి సమీక్షను చూడండి మా ఇటీవలి కథనం).
• సర్టిట్ మేనేజర్:

  

• నిర్వాహకులు యాడ్-ఆన్‌ల యొక్క మొత్తం తరగతి (ఇందులో పేర్కొన్న సర్ట్-మేనేజర్‌ని కలిగి ఉంటుంది), అవి ఆదిమ(లు) మరియు కంట్రోలర్(లు)ని నిర్వచించాయి. వారి పని యొక్క తర్కం మన ఊహ ద్వారా మాత్రమే పరిమితం చేయబడింది మరియు రెడీమేడ్ ఇన్‌ఫ్రాస్ట్రక్చర్ భాగాలను (ఉదాహరణకు, DBMS) ఆదిమాంశాలుగా మార్చడానికి అనుమతిస్తుంది, ఇవి (కంటెయినర్లు మరియు వాటి సెట్టింగ్‌ల సెట్‌తో కాకుండా) పని చేయడం చాలా సులభం. భారీ సంఖ్యలో ఆపరేటర్లు వ్రాయబడ్డారు - వారిలో చాలా మంది ఇంకా ఉత్పత్తికి సిద్ధంగా లేకపోయినా, ఇది సమయం మాత్రమే:

  

• కొలమానాలు - కుబెర్నెటెస్ ఇంటర్‌ఫేస్ (మెట్రిక్స్ API)ని ఇంప్లిమెంటేషన్ నుండి ఎలా వేరు చేసాడు అనేదానికి మరొక ఉదాహరణ (ప్రోమేథియస్ అడాప్టర్, డేటాడాగ్ క్లస్టర్ ఏజెంట్ వంటి థర్డ్-పార్టీ యాడ్-ఆన్‌లు...).
• కోసం పర్యవేక్షణ మరియు గణాంకాలు, ఆచరణలో మాత్రమే అవసరం లేదు ప్రోమేతియస్ మరియు గ్రాఫానా, కానీ kube-state-metrics, node-exporter, etc.

మరియు ఇది జోడింపుల పూర్తి జాబితా కాదు... ఉదాహరణకు, మేము ప్రస్తుతం ఇన్‌స్టాల్ చేసిన ఫ్లాంట్ కంపెనీలో 29 చేర్పులు (ఇవన్నీ మొత్తం 249 కుబెర్నెట్స్ వస్తువులను సృష్టిస్తాయి). సరళంగా చెప్పాలంటే, చేర్పులు లేకుండా క్లస్టర్ జీవితాన్ని మనం చూడలేము.

ఆటోమేషన్

మేము ప్రతిరోజూ ఎదుర్కొనే సాధారణ కార్యకలాపాలను ఆటోమేట్ చేయడానికి ఆపరేటర్‌లు రూపొందించబడ్డారు. ఆపరేటర్‌ను వ్రాయడం అద్భుతమైన పరిష్కారంగా ఉండే నిజ జీవిత ఉదాహరణలు ఇక్కడ ఉన్నాయి:

1. అప్లికేషన్ కోసం చిత్రాలతో ప్రైవేట్ (అంటే లాగిన్ అవసరం) రిజిస్ట్రీ ఉంది. ప్రతి పాడ్‌కు రిజిస్ట్రీలో ప్రామాణీకరణను అనుమతించే ప్రత్యేక రహస్యం కేటాయించబడిందని భావించబడుతుంది. ఈ రహస్యం నేమ్‌స్పేస్‌లో ఉండేలా చూడడం మా పని, తద్వారా పాడ్‌లు చిత్రాలను డౌన్‌లోడ్ చేసుకోవచ్చు. చాలా అప్లికేషన్‌లు ఉండవచ్చు (వీటిలో ప్రతిదానికి ఒక రహస్యం అవసరం), మరియు రహస్యాలను క్రమం తప్పకుండా నవీకరించడం ఉపయోగపడుతుంది, కాబట్టి రహస్యాలను చేతితో వేసే ఎంపిక తొలగించబడుతుంది. ఇక్కడే ఆపరేటర్ రక్షించబడతారు: మేము నేమ్‌స్పేస్ కనిపించే వరకు వేచి ఉండే ఒక కంట్రోలర్‌ను సృష్టిస్తాము మరియు ఈ ఈవెంట్ ఆధారంగా, నేమ్‌స్పేస్‌కు రహస్యాన్ని జోడిస్తుంది.
2. పాడ్‌ల నుండి ఇంటర్నెట్‌కి డిఫాల్ట్ యాక్సెస్ నిషేధించబడింది. కానీ కొన్నిసార్లు ఇది అవసరం కావచ్చు: నిర్దిష్ట నైపుణ్యాలు అవసరం లేకుండా, నేమ్‌స్పేస్‌లో నిర్దిష్ట లేబుల్ ఉండటం ద్వారా యాక్సెస్ పర్మిషన్ మెకానిజం సరళంగా పనిచేయడం తార్కికం. ఇక్కడ ఆపరేటర్ మాకు ఎలా సహాయం చేయవచ్చు? నేమ్‌స్పేస్‌లో లేబుల్ కనిపించే వరకు వేచి ఉండే ఒక కంట్రోలర్ సృష్టించబడింది మరియు ఇంటర్నెట్ యాక్సెస్ కోసం తగిన విధానాన్ని జోడిస్తుంది.
3. ఇదే విధమైన పరిస్థితి: మనం నిర్దిష్టంగా జోడించాల్సిన అవసరం ఉందని అనుకుందాం కళంకం, దానికి సారూప్య లేబుల్ ఉంటే (ఒక రకమైన ఉపసర్గతో). ఆపరేటర్‌తో చర్యలు స్పష్టంగా ఉన్నాయి...

ఏదైనా క్లస్టర్‌లో, సాధారణ పనులు తప్పనిసరిగా పరిష్కరించబడాలి మరియు సరిగ్గా ఇది ఆపరేటర్లను ఉపయోగించి చేయవచ్చు.

వివరించిన అన్ని కథలను సంగ్రహించి, మేము నిర్ణయానికి వచ్చాము కుబెర్నెట్స్‌లో సౌకర్యవంతమైన పని కోసం మీకు అవసరం: ఎ) యాడ్-ఆన్‌లను ఇన్‌స్టాల్ చేయండి, బి) ఆపరేటర్లను అభివృద్ధి చేయండి (రోజువారీ నిర్వాహక పనులను పరిష్కరించడానికి).

కుబెర్నెట్స్ కోసం ఒక ప్రకటన ఎలా వ్రాయాలి?

సాధారణంగా, పథకం చాలా సులభం:

... కానీ అప్పుడు అది మారుతుంది:

• కుబెర్నెటెస్ API అనేది ఒక చిన్నవిషయం కాని విషయం, ఇది నైపుణ్యం సాధించడానికి చాలా సమయం పడుతుంది;
• ప్రోగ్రామింగ్ కూడా అందరికీ కాదు (గో భాషకు ప్రత్యేక ఫ్రేమ్‌వర్క్ ఉన్నందున దానిని ప్రాధాన్య భాషగా ఎంచుకున్నారు - ఆపరేటర్ SDK);
• ఫ్రేమ్‌వర్క్‌తో కూడా పరిస్థితి సమానంగా ఉంటుంది.

బాటమ్ లైన్: నియంత్రికను వ్రాయడానికి (ఆపరేటర్) చేయవలసి ఉంటుంది గణనీయమైన వనరులను ఖర్చు చేయండి మెటీరియల్ అధ్యయనం చేయడానికి. ఇది "పెద్ద" ఆపరేటర్ల కోసం సమర్థించబడుతుంది - చెప్పండి, MySQL DBMS కోసం. పైన వివరించిన ఉదాహరణలను మనం గుర్తుంచుకుంటే (రహస్యాలను విప్పడం, ఇంటర్నెట్‌కు పాడ్‌లను యాక్సెస్ చేయడం...), మనం కూడా సరిగ్గా చేయాలనుకుంటున్నాము, అప్పుడు ఖర్చు చేసిన ప్రయత్నం మనకు ఇప్పుడు అవసరమైన ఫలితాన్ని అధిగమిస్తుందని మేము అర్థం చేసుకుంటాము:

సాధారణంగా, ఒక గందరగోళం తలెత్తుతుంది: చాలా వనరులను ఖర్చు చేయండి మరియు స్టేట్‌మెంట్‌లను వ్రాయడానికి సరైన సాధనాన్ని కనుగొనండి లేదా పాత పద్ధతిలో చేయండి (కానీ త్వరగా). దాన్ని పరిష్కరించడానికి - ఈ తీవ్రతల మధ్య రాజీని కనుగొనడానికి - మేము మా స్వంత ప్రాజెక్ట్‌ను సృష్టించాము: షెల్-ఆపరేటర్ (అతని కూడా చూడండి ఇటీవలి ప్రకటన హబ్ మీద).

షెల్-ఆపరేటర్

అతను ఎలా పని చేస్తాడు? క్లస్టర్‌లో షెల్-ఆపరేటర్‌తో గో బైనరీ ఉన్న పాడ్ ఉంది. అతని పక్కన ఒక సెట్ ఉంది హుక్స్ (వాటి గురించి మరిన్ని వివరాలు - క్రింద చూడండి). షెల్-ఆపరేటర్ స్వయంగా కొన్నింటికి సబ్‌స్క్రైబ్ చేస్తాడు ఈవెంట్స్ కుబెర్నెటెస్ APIలో, ఇది సంభవించిన తర్వాత సంబంధిత హుక్స్‌ను ప్రారంభిస్తుంది.

షెల్-ఆపరేటర్‌కు ఏ ఈవెంట్‌లకు కాల్ చేయాలనే హుక్స్ ఎలా తెలుసు? ఈ సమాచారం షెల్-ఆపరేటర్‌కు హుక్స్ ద్వారా ప్రసారం చేయబడుతుంది మరియు వారు దీన్ని చాలా సరళంగా చేస్తారు.

హుక్ అనేది బాష్ స్క్రిప్ట్ లేదా ఒకే ఆర్గ్యుమెంట్‌ని ఆమోదించే ఏదైనా ఇతర ఎక్జిక్యూటబుల్ ఫైల్ --config మరియు JSONతో ప్రతిస్పందిస్తుంది. రెండోది ఏ వస్తువులు ఆసక్తి కలిగి ఉన్నాయో మరియు ఏ సంఘటనలకు (ఈ వస్తువులకు) ప్రతిస్పందించాలో నిర్ణయిస్తుంది:

నేను మా ఉదాహరణలలో ఒకదాని షెల్-ఆపరేటర్‌లో అమలు చేయడాన్ని వివరిస్తాను - అప్లికేషన్ చిత్రాలతో ప్రైవేట్ రిజిస్ట్రీని యాక్సెస్ చేయడానికి రహస్యాలను విచ్ఛిన్నం చేయడం. ఇది రెండు దశలను కలిగి ఉంటుంది.

అభ్యాసం: 1. ఒక హుక్ వ్రాయండి

అన్నింటిలో మొదటిది, హుక్లో మేము ప్రాసెస్ చేస్తాము --config, మేము నేమ్‌స్పేస్‌లపై ఆసక్తిని కలిగి ఉన్నామని మరియు ప్రత్యేకంగా, వాటి సృష్టి యొక్క క్షణం:

[[ $1 == "--config" ]] ; then
  cat << EOF
{
  "onKubernetesEvent": [
    {
      "kind": "namespace",
      "event": ["add"]
    }
  ]
}
EOF
…

లాజిక్ ఎలా ఉంటుంది? కూడా చాలా సులభం:

…
else
  createdNamespace=$(jq -r '.[0].resourceName' $BINDING_CONTEXT_PATH)
  kubectl create -n ${createdNamespace} -f - << EOF
Kind: Secret
...
EOF
fi

మొదటి దశ ఏ నేమ్‌స్పేస్ సృష్టించబడిందో కనుగొనడం మరియు రెండవది దానిని ఉపయోగించి సృష్టించడం kubectl ఈ నేమ్‌స్పేస్ రహస్యం.

అభ్యాసం: 2. చిత్రాన్ని అసెంబ్లింగ్ చేయడం

సృష్టించిన హుక్‌ను షెల్-ఆపరేటర్‌కు పంపడం మాత్రమే మిగిలి ఉంది - దీన్ని ఎలా చేయాలి? షెల్-ఆపరేటర్ దానంతట అదే డాకర్ ఇమేజ్‌గా వస్తుంది, కాబట్టి ఈ చిత్రంలోని ప్రత్యేక డైరెక్టరీకి హుక్‌ని జోడించడం మా పని:

FROM flant/shell-operator:v1.0.0-beta.1
ADD my-handler.sh /hooks

దానిని సమీకరించడం మరియు నెట్టడం మాత్రమే మిగిలి ఉంది:

$ docker build -t registry.example.com/my-operator:v1 .
$ docker push registry.example.com/my-operator:v1

చివరి టచ్ చిత్రం క్లస్టర్‌కు అమర్చడం. దీన్ని చేయడానికి, వ్రాస్తాము విస్తరణ:

apiVersion: extensions/v1beta1
kind: Deployment
metadata:
  name: my-operator
spec:
  template:
    spec:
      containers:
      - name: my-operator
        image: registry.example.com/my-operator:v1 # 1
      serviceAccountName: my-operator              # 2

శ్రద్ధ వహించడానికి రెండు పాయింట్లు ఉన్నాయి:

1. కొత్తగా సృష్టించబడిన చిత్రం యొక్క సూచన;
2. ఇది కుబెర్నెట్స్‌లోని ఈవెంట్‌లకు సభ్యత్వం పొందడానికి మరియు నేమ్‌స్పేస్‌లకు రహస్యాలను కేటాయించడానికి (కనీసం) హక్కులు అవసరమయ్యే సిస్టమ్ కాంపోనెంట్, కాబట్టి మేము హుక్ కోసం సర్వీస్ అకౌంట్ (మరియు నియమాల సమితి)ని సృష్టిస్తాము.

ఫలితం - మేము మా సమస్యను పరిష్కరించాము బంధువులు కుబెర్నెటెస్ కోసం రహస్యాలను విచ్ఛిన్నం చేయడానికి ఆపరేటర్‌ని సృష్టించే విధంగా.

ఇతర షెల్-ఆపరేటర్ లక్షణాలు

హుక్ పని చేసే మీరు ఎంచుకున్న రకం వస్తువులను పరిమితం చేయడానికి, వాటిని ఫిల్టర్ చేయవచ్చు, నిర్దిష్ట లేబుల్‌ల ప్రకారం ఎంచుకోవడం (లేదా ఉపయోగించడం matchExpressions):

"onKubernetesEvent": [
  {
    "selector": {
      "matchLabels": {
        "foo": "bar",
       },
       "matchExpressions": [
         {
           "key": "allow",
           "operation": "In",
           "values": ["wan", "warehouse"],
         },
       ],
     }
     …
  }
]

అందించబడింది డూప్లికేషన్ మెకానిజం, ఇది - jq ఫిల్టర్‌ని ఉపయోగించి - పెద్ద JSON ఆబ్జెక్ట్‌లను చిన్నవిగా మార్చడానికి మిమ్మల్ని అనుమతిస్తుంది, ఇక్కడ మేము మార్పుల కోసం పర్యవేక్షించాలనుకుంటున్న పారామితులు మాత్రమే మిగిలి ఉన్నాయి.

ఒక హుక్ పిలిచినప్పుడు, షెల్-ఆపరేటర్ దానిని పాస్ చేస్తాడు వస్తువు డేటా, ఇది ఏ అవసరం కోసం ఉపయోగించవచ్చు.

హుక్‌లను ప్రేరేపించే ఈవెంట్‌లు కుబెర్నెట్స్ ఈవెంట్‌లకు మాత్రమే పరిమితం కాలేదు: షెల్-ఆపరేటర్ దీనికి మద్దతునిస్తుంది సమయం ద్వారా హుక్స్ కాల్ (సాంప్రదాయ షెడ్యూలర్‌లో క్రోంటాబ్ లాగా), అలాగే ఒక ప్రత్యేక ఈవెంట్ ప్రారంభం లో. ఈ ఈవెంట్‌లన్నింటినీ కలిపి ఒకే హుక్‌కి కేటాయించవచ్చు.

మరియు షెల్-ఆపరేటర్ యొక్క మరో రెండు లక్షణాలు:

1. ఇది పనిచేస్తుంది అసమకాలికంగా. కుబెర్నెటీస్ ఈవెంట్ (ఒక వస్తువు సృష్టించబడటం వంటివి) స్వీకరించబడినందున, క్లస్టర్‌లో ఇతర ఈవెంట్‌లు (అదే ఆబ్జెక్ట్ తొలగించబడటం వంటివి) సంభవించి ఉండవచ్చు మరియు హుక్స్ దీనికి కారణం కావాలి. హుక్ లోపంతో అమలు చేయబడితే, అప్రమేయంగా అది ఉంటుంది తిరిగి కాల్ విజయవంతంగా పూర్తయ్యే వరకు (ఈ ప్రవర్తనను మార్చవచ్చు).
2. ఇది ఎగుమతి చేస్తుంది కొలమానాలు ప్రోమేతియస్ కోసం, షెల్-ఆపరేటర్ పని చేస్తుందో లేదో మీరు అర్థం చేసుకోగలరు, ప్రతి హుక్ కోసం లోపాల సంఖ్య మరియు ప్రస్తుత క్యూ పరిమాణాన్ని కనుగొనండి.

నివేదికలోని ఈ భాగాన్ని సంగ్రహించడానికి:

యాడ్-ఆన్ల సంస్థాపన

కుబెర్నెట్స్‌తో సౌకర్యవంతమైన పని కోసం, యాడ్-ఆన్‌లను ఇన్‌స్టాల్ చేయవలసిన అవసరం కూడా ప్రస్తావించబడింది. మేము ఇప్పుడు దీన్ని ఎలా చేయాలో మా కంపెనీ మార్గం యొక్క ఉదాహరణను ఉపయోగించి దాని గురించి నేను మీకు చెప్తాను.

మేము అనేక క్లస్టర్‌లతో కుబెర్నెటెస్‌తో కలిసి పనిచేయడం ప్రారంభించాము, దీనికి అదనంగా చేరేది మాత్రమే. ఇది ప్రతి క్లస్టర్‌లో వేర్వేరుగా ఇన్‌స్టాల్ చేయబడాలి మరియు మేము విభిన్న వాతావరణాల కోసం అనేక YAML కాన్ఫిగరేషన్‌లను చేసాము: బేర్ మెటల్, AWS...

ఎక్కువ క్లస్టర్‌లు ఉన్నందున, మరిన్ని కాన్ఫిగరేషన్‌లు ఉన్నాయి. అదనంగా, మేము ఈ కాన్ఫిగరేషన్‌లను స్వయంగా మెరుగుపరిచాము, దాని ఫలితంగా అవి చాలా భిన్నమైనవి:

ప్రతిదీ క్రమంలో ఉంచడానికి, మేము స్క్రిప్ట్‌తో ప్రారంభించాము (install-ingress.sh), ఇది మేము ఏ రకమైన క్లస్టర్‌కు ఉపయోగిస్తామో వాదనగా తీసుకుని, అవసరమైన YAML కాన్ఫిగరేషన్‌ను రూపొందించి, దానిని కుబెర్నెట్స్‌కు విడుదల చేసింది.

సంక్షిప్తంగా, మా తదుపరి మార్గం మరియు దానికి సంబంధించిన తార్కికం క్రింది విధంగా ఉన్నాయి:

• YAML కాన్ఫిగరేషన్‌లతో పని చేయడానికి, ఒక టెంప్లేట్ ఇంజిన్ అవసరం (మొదటి దశల్లో ఇది సాధారణ సెడ్);
• క్లస్టర్‌ల సంఖ్య పెరగడంతో ఆటోమేటిక్‌గా అప్‌డేట్ చేయాల్సిన అవసరం ఏర్పడింది (మొదటి పరిష్కారం Gitలో స్క్రిప్ట్‌ను ఉంచడం, క్రాన్‌ని ఉపయోగించి అప్‌డేట్ చేసి దాన్ని రన్ చేయడం);
• ప్రోమేతియస్ కోసం ఇదే స్క్రిప్ట్ అవసరం (install-prometheus.sh), అయినప్పటికీ, దీనికి చాలా ఎక్కువ ఇన్‌పుట్ డేటా అవసరం, అలాగే వాటి నిల్వ (మంచి మార్గంలో - కేంద్రీకృత మరియు క్లస్టర్‌లో), మరియు కొంత డేటా (పాస్‌వర్డ్‌లు) స్వయంచాలకంగా రూపొందించబడటం గమనార్హం:

  

• పెరుగుతున్న సంఖ్యలో క్లస్టర్‌లకు ఏదైనా తప్పుగా మారే ప్రమాదం నిరంతరం పెరుగుతోంది, కాబట్టి ఇన్‌స్టాలర్‌లు అని మేము గ్రహించాము (అనగా రెండు స్క్రిప్ట్‌లు: ప్రవేశం మరియు ప్రోమేతియస్ కోసం) స్టేజింగ్ అవసరం (Gitలో అనేక శాఖలు, వాటిని సంబంధితంగా అప్‌డేట్ చేయడానికి అనేక క్రాన్‌లు: స్థిరమైన లేదా టెస్ట్ క్లస్టర్‌లు);
• с kubectl apply దానితో పని చేయడం కష్టంగా మారింది ఎందుకంటే ఇది డిక్లరేటివ్ కాదు మరియు వస్తువులను మాత్రమే సృష్టించగలదు, కానీ వాటి స్థితిపై నిర్ణయాలు తీసుకోదు/వాటిని తొలగించదు;
• మేము ఆ సమయంలో అమలు చేయని కొన్ని ఫంక్షన్‌లను కోల్పోయాము:
  • క్లస్టర్ నవీకరణల ఫలితంపై పూర్తి నియంత్రణ,
  • క్లస్టర్ (డిస్కవరీ) నుండి పొందగలిగే డేటా ఆధారంగా కొన్ని పారామితులను (ఇన్‌స్టాలేషన్ స్క్రిప్ట్‌ల కోసం ఇన్‌పుట్) స్వయంచాలకంగా నిర్ణయించడం,
  • నిరంతర ఆవిష్కరణ రూపంలో దాని తార్కిక అభివృద్ధి.

మేము ఈ సేకరించిన అనుభవాన్ని మా ఇతర ప్రాజెక్ట్ ఫ్రేమ్‌వర్క్‌లో అమలు చేసాము - addon-operator.

యాడ్ఆన్-ఆపరేటర్

ఇది ఇప్పటికే పేర్కొన్న షెల్-ఆపరేటర్‌పై ఆధారపడి ఉంటుంది. మొత్తం వ్యవస్థ ఇలా కనిపిస్తుంది:

కిందివి షెల్-ఆపరేటర్ హుక్స్‌కు జోడించబడ్డాయి:

• విలువల నిల్వ,
• హెల్మ్ చార్ట్,
• ఆ భాగం విలువల దుకాణాన్ని పర్యవేక్షిస్తుంది మరియు - ఏవైనా మార్పులు జరిగితే - చార్ట్‌ను రీ-రోల్ చేయమని హెల్మ్‌ని అడుగుతుంది.

ఈ విధంగా, మేము కుబెర్నెట్స్‌లోని ఒక ఈవెంట్‌కు ప్రతిస్పందించవచ్చు, హుక్‌ను ప్రారంభించవచ్చు మరియు ఈ హుక్ నుండి మనం నిల్వలో మార్పులు చేయవచ్చు, ఆ తర్వాత చార్ట్ మళ్లీ డౌన్‌లోడ్ చేయబడుతుంది. ఫలిత రేఖాచిత్రంలో, మేము హుక్స్ సెట్ మరియు చార్ట్‌ను ఒక భాగంగా విభజిస్తాము, దానిని మేము పిలుస్తాము మాడ్యూల్:

అనేక మాడ్యూల్స్ ఉండవచ్చు మరియు వాటికి మేము గ్లోబల్ హుక్స్, గ్లోబల్ వాల్యూస్ స్టోర్ మరియు ఈ గ్లోబల్ స్టోర్‌ను పర్యవేక్షించే భాగాన్ని జోడిస్తాము.

ఇప్పుడు, కుబెర్నెటెస్‌లో ఏదైనా జరిగినప్పుడు, మనం గ్లోబల్ హుక్‌ని ఉపయోగించి దానికి ప్రతిస్పందించవచ్చు మరియు గ్లోబల్ స్టోర్‌లో ఏదైనా మార్చవచ్చు. ఈ మార్పు గుర్తించబడుతుంది మరియు క్లస్టర్‌లోని అన్ని మాడ్యూల్‌లు రోల్ అవుట్ చేయబడటానికి కారణమవుతాయి:

ఈ పథకం పైన పేర్కొన్న యాడ్-ఆన్‌లను ఇన్‌స్టాల్ చేయడానికి అన్ని అవసరాలను సంతృప్తిపరుస్తుంది:

• హెల్మ్ టెంప్లేటింగ్ మరియు డిక్లరేటివ్‌నెస్‌కు బాధ్యత వహిస్తుంది.
• ఆటో-అప్‌డేట్ సమస్య గ్లోబల్ హుక్‌ని ఉపయోగించి పరిష్కరించబడింది, ఇది షెడ్యూల్‌లో రిజిస్ట్రీకి వెళ్లి, అక్కడ కొత్త సిస్టమ్ ఇమేజ్‌ని చూసినట్లయితే, దాన్ని రోల్ చేస్తుంది (అంటే "తానే").
• క్లస్టర్‌లో నిల్వ సెట్టింగ్‌లు ఉపయోగించి అమలు చేయబడతాయి ConfigMap, ఇది స్టోరేజ్‌ల కోసం ప్రాథమిక డేటాను కలిగి ఉంటుంది (ప్రారంభంలో అవి స్టోరేజ్‌లలోకి లోడ్ చేయబడతాయి).
• పాస్‌వర్డ్ ఉత్పత్తి, ఆవిష్కరణ మరియు నిరంతర ఆవిష్కరణ సమస్యలు హుక్స్ ఉపయోగించి పరిష్కరించబడ్డాయి.
• డాకర్ బాక్స్ వెలుపల మద్దతునిచ్చే ట్యాగ్‌ల కారణంగా స్టేజింగ్ సాధించబడింది.
• మేము స్థితిని అర్థం చేసుకోగలిగే కొలమానాలను ఉపయోగించి ఫలితం పర్యవేక్షించబడుతుంది.

ఈ మొత్తం సిస్టమ్ గోలో ఒకే బైనరీ రూపంలో అమలు చేయబడుతుంది, దీనిని యాడ్ఆన్-ఆపరేటర్ అంటారు. ఇది రేఖాచిత్రం సరళంగా కనిపించేలా చేస్తుంది:

ఈ రేఖాచిత్రంలో ప్రధాన భాగం మాడ్యూళ్ల సమితి (క్రింద బూడిద రంగులో హైలైట్ చేయబడింది). ఇప్పుడు మనం కొంచెం ప్రయత్నంతో అవసరమైన యాడ్-ఆన్ కోసం మాడ్యూల్‌ను వ్రాయవచ్చు మరియు అది ప్రతి క్లస్టర్‌లో ఇన్‌స్టాల్ చేయబడుతుందని, అప్‌డేట్ చేయబడుతుందని మరియు క్లస్టర్‌లో అవసరమైన ఈవెంట్‌లకు ప్రతిస్పందిస్తుందని నిర్ధారించుకోండి.

"ఫ్లాంట్" ఉపయోగాలు addon-operator 70+ కుబెర్నెట్స్ క్లస్టర్‌లపై. ప్రస్తుత స్థితి - ఆల్ఫా వెర్షన్. ఇప్పుడు మేము బీటాను విడుదల చేయడానికి డాక్యుమెంటేషన్‌ని సిద్ధం చేస్తున్నాము, కానీ ప్రస్తుతానికి రిపోజిటరీలో ఉదాహరణలు అందుబాటులో ఉన్నాయి, దీని ఆధారంగా మీరు మీ స్వంత యాడ్ఆన్‌ని సృష్టించవచ్చు.

యాడ్ఆన్-ఆపరేటర్ కోసం నేను మాడ్యూల్‌లను ఎక్కడ పొందగలను? మా లైబ్రరీని ప్రచురించడం మాకు తదుపరి దశ; మేము దీన్ని వేసవిలో చేయాలని ప్లాన్ చేస్తున్నాము.

వీడియోలు మరియు స్లయిడ్‌లు

పనితీరు నుండి వీడియో (~50 నిమిషాలు):

నివేదిక ప్రదర్శన:

PS

మా బ్లాగ్‌లోని ఇతర నివేదికలు:

• «డేటాబేస్‌లు మరియు కుబెర్నెట్స్"; (డిమిత్రి స్టోలియారోవ్; నవంబర్ 8, 2018 హైలోడ్++లో);
• «పర్యవేక్షణ మరియు కుబెర్నెట్స్"; (డిమిత్రి స్టోలియారోవ్; మే 28, 2018 రూట్‌కాన్ఫ్‌లో);
• «Kubernetes మరియు GitLabతో CI/CD ఉత్తమ అభ్యాసాలు"; (డిమిత్రి స్టోలియారోవ్; నవంబర్ 7, 2017 హైలోడ్++లో);
• «చిన్న ప్రాజెక్ట్‌లలో కుబెర్నెట్స్‌తో మా అనుభవం"; (డిమిత్రి స్టోలియారోవ్; జూన్ 6, 2017 రూట్‌కాన్ఫ్‌లో).

మీరు ఈ క్రింది ప్రచురణలపై కూడా ఆసక్తి కలిగి ఉండవచ్చు:

• «షెల్-ఆపరేటర్‌ను పరిచయం చేస్తున్నాము: కుబెర్నెట్స్ కోసం ఆపరేటర్‌లను సృష్టించడం ఇప్పుడే సులభమైంది".

మూలం: www.habr.com