వెళ్ళండి? బాష్! షెల్-ఆపరేటర్‌ను కలవండి (KubeCon EU'2020 నుండి సమీక్ష మరియు వీడియో నివేదిక)

ఈ సంవత్సరం, ప్రధాన యూరోపియన్ కుబెర్నెట్స్ కాన్ఫరెన్స్ - KubeCon + CloudNativeCon Europe 2020 - వర్చువల్. అయినప్పటికీ, ఫార్మాట్‌లో అటువంటి మార్పు మా దీర్ఘకాలంగా ప్రణాళిక చేయబడిన నివేదికను అందించకుండా నిరోధించలేదు “వెళ్లాలా? బాష్! షెల్-ఆపరేటర్‌ని కలవండి” మా ఓపెన్ సోర్స్ ప్రాజెక్ట్‌కు అంకితం చేయబడింది షెల్-ఆపరేటర్.

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

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

ఫ్లాంట్‌లో మేము నిరంతరం ప్రతిదీ ఆప్టిమైజ్ చేస్తాము మరియు ఆటోమేట్ చేస్తాము. ఈ రోజు మనం మరొక ఉత్తేజకరమైన భావన గురించి మాట్లాడుతాము. కలుసుకోవడం: క్లౌడ్-నేటివ్ షెల్ స్క్రిప్టింగ్!

అయితే, ఇవన్నీ జరిగే సందర్భంతో ప్రారంభిద్దాం: కుబెర్నెటెస్.

కుబెర్నెట్స్ API మరియు కంట్రోలర్‌లు

కుబెర్నెటీస్‌లోని APIని ప్రతి రకమైన వస్తువు కోసం డైరెక్టరీలతో ఒక రకమైన ఫైల్ సర్వర్‌గా సూచించవచ్చు. ఈ సర్వర్‌లోని ఆబ్జెక్ట్‌లు (వనరులు) YAML ఫైల్‌ల ద్వారా సూచించబడతాయి. అదనంగా, సర్వర్ ప్రాథమిక APIని కలిగి ఉంది, ఇది మూడు పనులను చేయడానికి మిమ్మల్ని అనుమతిస్తుంది:

• స్వీకరించడానికి దాని రకం మరియు పేరు ద్వారా వనరు;
• మార్పు వనరు (ఈ సందర్భంలో, సర్వర్ “సరైన” వస్తువులను మాత్రమే నిల్వ చేస్తుంది - అన్నీ తప్పుగా ఏర్పడినవి లేదా ఇతర డైరెక్టరీల కోసం ఉద్దేశించినవి విస్మరించబడతాయి);
• ట్రాక్ వనరు కోసం (ఈ సందర్భంలో, వినియోగదారు దాని ప్రస్తుత/నవీకరించబడిన సంస్కరణను వెంటనే స్వీకరిస్తారు).

అందువల్ల, కుబెర్నెటెస్ మూడు ప్రాథమిక పద్ధతులతో (YAML మానిఫెస్ట్‌ల కోసం) ఒక రకమైన ఫైల్ సర్వర్‌గా పనిచేస్తుంది (అవును, వాస్తవానికి ఇతరులు ఉన్నాయి, కానీ మేము వాటిని ప్రస్తుతానికి విస్మరిస్తాము).

సమస్య ఏమిటంటే సర్వర్ సమాచారాన్ని మాత్రమే నిల్వ చేయగలదు. ఇది పని చేయడానికి మీకు అవసరం కంట్రోలర్ - కుబెర్నెటీస్ ప్రపంచంలో రెండవ అత్యంత ముఖ్యమైన మరియు ప్రాథమిక భావన.

రెండు ప్రధాన రకాల కంట్రోలర్లు ఉన్నాయి. మొదటిది కుబెర్నెటెస్ నుండి సమాచారాన్ని తీసుకుంటుంది, సమూహ తర్కం ప్రకారం దాన్ని ప్రాసెస్ చేస్తుంది మరియు దానిని K8sకి తిరిగి ఇస్తుంది. రెండవది కుబెర్నెట్స్ నుండి సమాచారాన్ని తీసుకుంటుంది, కానీ, మొదటి రకానికి భిన్నంగా, కొన్ని బాహ్య వనరుల స్థితిని మారుస్తుంది.

కుబెర్నెట్స్‌లో విస్తరణను సృష్టించే ప్రక్రియను నిశితంగా పరిశీలిద్దాం:

• విస్తరణ కంట్రోలర్ (చేర్చబడింది kube-controller-manager) డిప్లాయ్‌మెంట్ గురించి సమాచారాన్ని అందుకుంటుంది మరియు ప్రతిరూప సెట్‌ను సృష్టిస్తుంది.
• ఈ సమాచారం ఆధారంగా రెప్లికాసెట్ రెండు ప్రతిరూపాలను (రెండు పాడ్‌లు) సృష్టిస్తుంది, అయితే ఈ పాడ్‌లు ఇంకా షెడ్యూల్ చేయబడలేదు.
• షెడ్యూలర్ పాడ్‌లను షెడ్యూల్ చేస్తుంది మరియు వాటి YAMLలకు నోడ్ సమాచారాన్ని జోడిస్తుంది.
• Kubelets బాహ్య వనరుకు మార్పులు చేస్తాయి (డాకర్ చెప్పండి).

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

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

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

సాధారణ ఉదాహరణ: రహస్యాలను కాపీ చేయడం

ఒక సాధారణ ఉదాహరణ చూద్దాం.

మనకు కుబెర్నెట్స్ క్లస్టర్ ఉందని చెప్పండి. దీనికి నేమ్‌స్పేస్ ఉంది default కొన్ని రహస్యాలతో mysecret. అదనంగా, క్లస్టర్‌లో ఇతర నేమ్‌స్పేస్‌లు ఉన్నాయి. వాటిలో కొన్ని వాటికి నిర్దిష్ట లేబుల్ జోడించబడ్డాయి. రహస్యాన్ని లేబుల్‌తో నేమ్‌స్పేస్‌లలోకి కాపీ చేయడమే మా లక్ష్యం.

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

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

షెల్ ఆపరేటర్ ఎలా పని చేస్తుంది

కుబెర్నెటెస్‌లోని ఇతర పనిభారం వలె, షెల్-ఆపరేటర్ దాని స్వంత పాడ్‌లో నడుస్తుంది. డైరెక్టరీలో ఈ పాడ్‌లో /hooks ఎక్జిక్యూటబుల్ ఫైల్స్ నిల్వ చేయబడతాయి. ఇవి బాష్, పైథాన్, రూబీ మొదలైన వాటిలో స్క్రిప్ట్‌లు కావచ్చు. మేము అటువంటి ఎక్జిక్యూటబుల్ ఫైళ్లను హుక్స్ అని పిలుస్తాము (hooks).

షెల్-ఆపరేటర్ కుబెర్నెటెస్ ఈవెంట్‌లకు సబ్‌స్క్రైబ్ చేస్తుంది మరియు మనకు అవసరమైన ఈవెంట్‌లకు ప్రతిస్పందనగా ఈ హుక్స్‌లను అమలు చేస్తుంది.

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

బాష్‌లో ఆపరేటర్‌ని తయారు చేయడం

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

• కాన్ఫిగరేషన్ దశకు మొదటిది అవసరం - ఇది బైండింగ్ సందర్భాన్ని ప్రదర్శిస్తుంది;
• రెండవది హుక్ యొక్క ప్రధాన తర్కాన్ని కలిగి ఉంటుంది.

#!/bin/bash

source /shell_lib.sh

function __config__() {
  cat << EOF
    configVersion: v1
    # BINDING CONFIGURATION
EOF
}

function __main__() {
  # THE LOGIC
}

hook::run "$@"

మనకు ఏ వస్తువులు అవసరమో నిర్ణయించుకోవడం తదుపరి దశ. మా విషయంలో, మేము ట్రాక్ చేయాలి:

• మార్పులకు మూల రహస్యం;
• క్లస్టర్‌లోని అన్ని నేమ్‌స్పేస్‌లు, ఏవి వాటికి లేబుల్ జోడించబడి ఉన్నాయో మీకు తెలుస్తుంది;
• మూల రహస్యంతో అవన్నీ సమకాలీకరించబడుతున్నాయని నిర్ధారించడానికి రహస్యాలను లక్ష్యంగా చేసుకోండి.

రహస్య మూలానికి సభ్యత్వాన్ని పొందండి

దాని కోసం బైండింగ్ కాన్ఫిగరేషన్ చాలా సులభం. మేము పేరుతో సీక్రెట్‌పై ఆసక్తి కలిగి ఉన్నామని మేము సూచిస్తున్నాము mysecret నేమ్‌స్పేస్‌లో default:

function __config__() {
  cat << EOF
    configVersion: v1
    kubernetes:
    - name: src_secret
      apiVersion: v1
      kind: Secret
      nameSelector:
        matchNames:
        - mysecret
      namespace:
        nameSelector:
          matchNames: ["default"]
      group: main
EOF

ఫలితంగా, మూల రహస్యం మారినప్పుడు హుక్ ప్రేరేపించబడుతుంది (src_secret) మరియు కింది బైండింగ్ సందర్భాన్ని స్వీకరించండి:

మీరు గమనిస్తే, ఇది పేరు మరియు మొత్తం వస్తువును కలిగి ఉంటుంది.

నేమ్‌స్పేస్‌లను ట్రాక్ చేయడం

ఇప్పుడు మీరు నేమ్‌స్పేస్‌లకు సభ్యత్వాన్ని పొందాలి. దీన్ని చేయడానికి, మేము ఈ క్రింది బైండింగ్ కాన్ఫిగరేషన్‌ను నిర్దేశిస్తాము:

- name: namespaces
  group: main
  apiVersion: v1
  kind: Namespace
  jqFilter: |
    {
      namespace: .metadata.name,
      hasLabel: (
       .metadata.labels // {} |  
         contains({"secret": "yes"})
      )
    }
  group: main
  keepFullObjectsInMemory: false

మీరు గమనిస్తే, పేరుతో కాన్ఫిగరేషన్‌లో కొత్త ఫీల్డ్ కనిపించింది jqFilter. దాని పేరు సూచించినట్లుగా, jqFilter అన్ని అనవసరమైన సమాచారాన్ని ఫిల్టర్ చేస్తుంది మరియు మాకు ఆసక్తి ఉన్న ఫీల్డ్‌లతో కొత్త JSON ఆబ్జెక్ట్‌ను సృష్టిస్తుంది. సారూప్య కాన్ఫిగరేషన్‌తో హుక్ కింది బైండింగ్ సందర్భాన్ని అందుకుంటుంది:

ఇది ఒక శ్రేణిని కలిగి ఉంటుంది filterResults క్లస్టర్‌లోని ప్రతి నేమ్‌స్పేస్ కోసం. బూలియన్ వేరియబుల్ hasLabel ఇచ్చిన నేమ్‌స్పేస్‌కు లేబుల్ జోడించబడిందో లేదో సూచిస్తుంది. సెలెక్టర్ keepFullObjectsInMemory: false పూర్తి వస్తువులను మెమరీలో ఉంచవలసిన అవసరం లేదని సూచిస్తుంది.

లక్ష్య రహస్యాలను ట్రాక్ చేయడం

ఉల్లేఖనాన్ని పేర్కొన్న అన్ని రహస్యాలకు మేము సభ్యత్వాన్ని పొందుతాము managed-secret: "yes" (ఇవే మా లక్ష్యం dst_secrets):

- name: dst_secrets
  apiVersion: v1
  kind: Secret
  labelSelector:
    matchLabels:
      managed-secret: "yes"
  jqFilter: |
    {
      "namespace":
        .metadata.namespace,
      "resourceVersion":
        .metadata.annotations.resourceVersion
    }
  group: main
  keepFullObjectsInMemory: false

ఈ సందర్భంలో jqFilter నేమ్‌స్పేస్ మరియు పారామీటర్ మినహా మొత్తం సమాచారాన్ని ఫిల్టర్ చేస్తుంది resourceVersion. రహస్యాన్ని సృష్టించేటప్పుడు చివరి పరామితి ఉల్లేఖనానికి పంపబడింది: ఇది రహస్యాల సంస్కరణలను సరిపోల్చడానికి మరియు వాటిని తాజాగా ఉంచడానికి మిమ్మల్ని అనుమతిస్తుంది.

ఈ విధంగా కాన్ఫిగర్ చేయబడిన ఒక హుక్, అమలు చేయబడినప్పుడు, పైన వివరించిన మూడు బైండింగ్ సందర్భాలను అందుకుంటుంది. వాటిని ఒక రకమైన స్నాప్‌షాట్‌గా భావించవచ్చు (స్నాప్షాట్) క్లస్టర్.

ఈ మొత్తం సమాచారం ఆధారంగా, ప్రాథమిక అల్గోరిథం అభివృద్ధి చేయవచ్చు. ఇది అన్ని నేమ్‌స్పేస్‌లలో పునరావృతమవుతుంది మరియు:

• ఉంటే hasLabel విషయాలను true ప్రస్తుత నేమ్‌స్పేస్ కోసం:
  • ప్రపంచ రహస్యాన్ని స్థానిక రహస్యంతో పోలుస్తుంది:
    • అవి ఒకేలా ఉంటే, అది ఏమీ చేయదు;
    • అవి భిన్నంగా ఉంటే - అమలు చేస్తుంది kubectl replace లేదా create;
• ఉంటే hasLabel విషయాలను false ప్రస్తుత నేమ్‌స్పేస్ కోసం:
  • ఇచ్చిన నేమ్‌స్పేస్‌లో రహస్యం లేదని నిర్ధారిస్తుంది:
    • స్థానిక రహస్యం ఉన్నట్లయితే, దాన్ని ఉపయోగించి తొలగించండి kubectl delete;
    • స్థానిక రహస్యం కనుగొనబడకపోతే, అది ఏమీ చేయదు.

బాష్‌లో అల్గోరిథం అమలు మీరు మాలో డౌన్‌లోడ్ చేసుకోవచ్చు ఉదాహరణలతో రిపోజిటరీలు.

మేము 35 లైన్ల YAML కాన్ఫిగరేషన్ మరియు అదే మొత్తంలో బాష్ కోడ్‌ని ఉపయోగించి ఒక సాధారణ కుబెర్నెట్స్ కంట్రోలర్‌ని ఎలా సృష్టించగలిగాము! షెల్-ఆపరేటర్ యొక్క పని వాటిని ఒకదానితో ఒకటి లింక్ చేయడం.

అయినప్పటికీ, రహస్యాలను కాపీ చేయడం అనేది యుటిలిటీ యొక్క అప్లికేషన్ యొక్క ఏకైక ప్రాంతం కాదు. అతని సామర్థ్యం ఏమిటో చూపించడానికి ఇక్కడ మరికొన్ని ఉదాహరణలు ఉన్నాయి.

ఉదాహరణ 1: ConfigMapకి మార్పులు చేయడం

మూడు పాడ్‌లతో కూడిన విస్తరణను చూద్దాం. పాడ్‌లు కొంత కాన్ఫిగరేషన్‌ను నిల్వ చేయడానికి కాన్ఫిగ్‌మ్యాప్‌ని ఉపయోగిస్తాయి. పాడ్‌లను ప్రారంభించినప్పుడు, కాన్ఫిగ్‌మ్యాప్ ఒక నిర్దిష్ట స్థితిలో ఉంది (దీనిని v.1 అని పిలుద్దాం). దీని ప్రకారం, అన్ని పాడ్‌లు కాన్ఫిగ్‌మ్యాప్ యొక్క ఈ ప్రత్యేక సంస్కరణను ఉపయోగిస్తాయి.

ఇప్పుడు ConfigMap మారిందని అనుకుందాం (v.2). అయినప్పటికీ, పాడ్‌లు కాన్ఫిగ్‌మ్యాప్ యొక్క మునుపటి సంస్కరణను ఉపయోగిస్తాయి (v.1):

నేను వాటిని కొత్త కాన్ఫిగ్‌మ్యాప్ (v.2)కి ఎలా మార్చగలను? సమాధానం సులభం: టెంప్లేట్ ఉపయోగించండి. విభాగానికి చెక్‌సమ్ ఉల్లేఖనాన్ని జోడిద్దాం template విస్తరణ కాన్ఫిగరేషన్‌లు:

ఫలితంగా, ఈ చెక్‌సమ్ అన్ని పాడ్‌లలో నమోదు చేయబడుతుంది మరియు ఇది డిప్లాయ్‌మెంట్ మాదిరిగానే ఉంటుంది. ఇప్పుడు మీరు ConfigMap మారినప్పుడు ఉల్లేఖనాన్ని నవీకరించాలి. మరియు షెల్-ఆపరేటర్ ఈ సందర్భంలో ఉపయోగపడుతుంది. మీరు చేయాల్సిందల్లా ప్రోగ్రామ్ కాన్ఫిగ్‌మ్యాప్‌కు సబ్‌స్క్రైబ్ చేసి చెక్‌సమ్‌ను అప్‌డేట్ చేసే హుక్.

వినియోగదారు కాన్ఫిగ్‌మ్యాప్‌లో మార్పులు చేస్తే, షెల్-ఆపరేటర్ వాటిని గమనించి చెక్‌సమ్‌ను మళ్లీ లెక్కిస్తుంది. దీని తర్వాత కుబెర్నెటెస్ యొక్క మాయాజాలం అమలులోకి వస్తుంది: ఆర్కెస్ట్రేటర్ పాడ్‌ను చంపి, కొత్తదాన్ని సృష్టిస్తాడు, అది అయ్యే వరకు వేచి ఉండండి Ready, మరియు తదుపరి దానికి వెళుతుంది. ఫలితంగా, విస్తరణ సమకాలీకరించబడుతుంది మరియు కాన్ఫిగ్మ్యాప్ యొక్క కొత్త సంస్కరణకు మారుతుంది.

ఉదాహరణ 2: అనుకూల వనరుల నిర్వచనాలతో పని చేయడం

మీకు తెలిసినట్లుగా, కస్టమ్ రకాల వస్తువులను సృష్టించడానికి Kubernetes మిమ్మల్ని అనుమతిస్తుంది. ఉదాహరణకు, మీరు రకాన్ని సృష్టించవచ్చు MysqlDatabase. ఈ రకానికి రెండు మెటాడేటా పారామితులు ఉన్నాయని అనుకుందాం: name и namespace.

apiVersion: example.com/v1alpha1
kind: MysqlDatabase
metadata:
  name: foo
  namespace: bar

మేము MySQL డేటాబేస్‌లను సృష్టించగల విభిన్న నేమ్‌స్పేస్‌లతో కూడిన Kubernetes క్లస్టర్‌ని కలిగి ఉన్నాము. ఈ సందర్భంలో షెల్-ఆపరేటర్ వనరులను ట్రాక్ చేయడానికి ఉపయోగించవచ్చు MysqlDatabase, వాటిని MySQL సర్వర్‌కు కనెక్ట్ చేయడం మరియు క్లస్టర్ యొక్క కావలసిన మరియు గమనించిన స్థితులను సమకాలీకరించడం.

ఉదాహరణ 3: క్లస్టర్ నెట్‌వర్క్ మానిటరింగ్

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

అన్నింటిలో మొదటిది, మీరు నోడ్‌లకు సభ్యత్వాన్ని పొందాలి. షెల్ ఆపరేటర్‌కు ప్రతి నోడ్ యొక్క పేరు మరియు IP చిరునామా అవసరం. వారి సహాయంతో, అతను ఈ నోడ్లను పింగ్ చేస్తాడు.

configVersion: v1
kubernetes:
- name: nodes
  apiVersion: v1
  kind: Node
  jqFilter: |
    {
      name: .metadata.name,
      ip: (
       .status.addresses[] |  
        select(.type == "InternalIP") |
        .address
      )
    }
  group: main
  keepFullObjectsInMemory: false
  executeHookOnEvent: []
schedule:
- name: every_minute
  group: main
  crontab: "* * * * *"

పరామితి executeHookOnEvent: [] ఏదైనా ఈవెంట్‌కు ప్రతిస్పందనగా హుక్‌ను నిరోధిస్తుంది (అంటే నోడ్‌లను మార్చడం, జోడించడం, తొలగించడం వంటి వాటికి ప్రతిస్పందనగా). అయితే, అతను పరిగెత్తుతుంది (మరియు నోడ్‌ల జాబితాను నవీకరించండి) షెడ్యూల్ చేయబడింది - ప్రతి నిమిషం, ఫీల్డ్ సూచించినట్లు schedule.

ఇప్పుడు ప్రశ్న తలెత్తుతుంది, ప్యాకెట్ లాస్ వంటి సమస్యల గురించి మనకు ఖచ్చితంగా ఎలా తెలుసు? కోడ్‌ని పరిశీలిద్దాం:

function __main__() {
  for i in $(seq 0 "$(context::jq -r '(.snapshots.nodes | length) - 1')"); do
    node_name="$(context::jq -r '.snapshots.nodes['"$i"'].filterResult.name')"
    node_ip="$(context::jq -r '.snapshots.nodes['"$i"'].filterResult.ip')"
    packets_lost=0
    if ! ping -c 1 "$node_ip" -t 1 ; then
      packets_lost=1
    fi
    cat >> "$METRICS_PATH" <<END
      {
        "name": "node_packets_lost",
        "add": $packets_lost,
        "labels": {
          "node": "$node_name"
        }
      }
END
  done
}

మేము నోడ్‌ల జాబితా ద్వారా పునరావృతం చేస్తాము, వాటి పేర్లు మరియు IP చిరునామాలను పొందుతాము, వాటిని పింగ్ చేసి ప్రోమేతియస్‌కు ఫలితాలను పంపుతాము. షెల్-ఆపరేటర్ ప్రోమేతియస్‌కు కొలమానాలను ఎగుమతి చేయవచ్చు, ఎన్విరాన్మెంట్ వేరియబుల్‌లో పేర్కొన్న మార్గం ప్రకారం ఉన్న ఫైల్‌లో వాటిని సేవ్ చేయడం $METRICS_PATH.

ఇలా మీరు క్లస్టర్‌లో సాధారణ నెట్‌వర్క్ పర్యవేక్షణ కోసం ఆపరేటర్‌ని తయారు చేయవచ్చు.

క్యూయింగ్ మెకానిజం

షెల్-ఆపరేటర్‌లో నిర్మించబడిన మరొక ముఖ్యమైన యంత్రాంగాన్ని వివరించకుండా ఈ కథనం అసంపూర్ణంగా ఉంటుంది. క్లస్టర్‌లోని ఈవెంట్‌కు ప్రతిస్పందనగా ఇది ఒక రకమైన హుక్‌ని అమలు చేస్తుందని ఊహించుకోండి.

• అదే సమయంలో, క్లస్టర్‌లో ఏదైనా జరిగితే ఏమి జరుగుతుంది? మరొకటి ఈవెంట్?
• షెల్-ఆపరేటర్ హుక్ యొక్క మరొక ఉదాహరణను అమలు చేస్తుందా?
• క్లస్టర్‌లో ఒకేసారి ఐదు సంఘటనలు జరిగితే?
• షెల్-ఆపరేటర్ వాటిని సమాంతరంగా ప్రాసెస్ చేస్తారా?
• మెమరీ మరియు CPU వంటి వినియోగించిన వనరుల గురించి ఏమిటి?

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

దీనిని ఉదాహరణలతో ఉదహరిద్దాం. మనకు రెండు హుక్స్ ఉన్నాయని అనుకుందాం. మొదటి ఈవెంట్ మొదటి హుక్కి వెళుతుంది. దాని ప్రాసెసింగ్ పూర్తయిన తర్వాత, క్యూ ముందుకు కదులుతుంది. తదుపరి మూడు ఈవెంట్‌లు రెండవ హుక్‌కి మళ్లించబడతాయి - అవి క్యూ నుండి తీసివేయబడతాయి మరియు “బండిల్”లో నమోదు చేయబడతాయి. అంటే హుక్ ఈవెంట్‌ల శ్రేణిని అందుకుంటుంది — లేదా, మరింత ఖచ్చితంగా, బైండింగ్ సందర్భాల శ్రేణి.

ఇవి కూడా సంఘటనలను ఒక పెద్దగా కలపవచ్చు. పరామితి దీనికి బాధ్యత వహిస్తుంది group బైండింగ్ కాన్ఫిగరేషన్‌లో.

మీరు ఎన్ని క్యూలు/హుక్స్‌లు మరియు వాటి వివిధ కలయికలను సృష్టించవచ్చు. ఉదాహరణకు, ఒక క్యూ రెండు హుక్స్‌తో లేదా వైస్ వెర్సాతో పని చేయవచ్చు.

మీరు చేయాల్సిందల్లా ఫీల్డ్‌ను తదనుగుణంగా కాన్ఫిగర్ చేయడం queue బైండింగ్ కాన్ఫిగరేషన్‌లో. క్యూ పేరు పేర్కొనబడకపోతే, హుక్ డిఫాల్ట్ క్యూలో నడుస్తుంది (default) హుక్స్‌తో పనిచేసేటప్పుడు అన్ని వనరుల నిర్వహణ సమస్యలను పూర్తిగా పరిష్కరించడానికి ఈ క్యూయింగ్ మెకానిజం మిమ్మల్ని అనుమతిస్తుంది.

తీర్మానం

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

షెల్-ఆపరేటర్ గురించి సవివరమైన సమాచారం, అలాగే దానిని ఎలా ఉపయోగించాలో శీఘ్ర ట్యుటోరియల్ సంబంధిత లో అందుబాటులో ఉన్నాయి GitHubపై రిపోజిటరీలు. ప్రశ్నలతో మమ్మల్ని సంప్రదించడానికి సంకోచించకండి: మీరు వాటిని ప్రత్యేకంగా చర్చించవచ్చు టెలిగ్రామ్ సమూహం (రష్యన్ భాషలో) లేదా ఈ ఫోరమ్ (ఆంగ్లం లో).

మరియు మీరు దీన్ని ఇష్టపడితే, GitHubలో కొత్త సమస్యలు/PR/స్టార్‌లను చూడటం మాకు ఎల్లప్పుడూ సంతోషాన్నిస్తుంది, ఇక్కడ మీరు ఇతరులను కనుగొనవచ్చు. ఆసక్తికరమైన ప్రాజెక్టులు. వాటిలో హైలైట్ చేయడం విలువ addon-operator, ఇది షెల్-ఆపరేటర్ యొక్క పెద్ద సోదరుడు. ఈ యుటిలిటీ యాడ్-ఆన్‌లను ఇన్‌స్టాల్ చేయడానికి హెల్మ్ చార్ట్‌లను ఉపయోగిస్తుంది, అప్‌డేట్‌లను అందించగలదు మరియు వివిధ చార్ట్ పారామితులు/విలువలను పర్యవేక్షించగలదు, చార్ట్‌ల ఇన్‌స్టాలేషన్ ప్రక్రియను నియంత్రిస్తుంది మరియు క్లస్టర్‌లోని ఈవెంట్‌లకు ప్రతిస్పందనగా వాటిని సవరించగలదు.

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

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

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

PS

మా బ్లాగులో కూడా చదవండి:

• «షెల్-ఆపరేటర్‌తో కుబెర్నెటీస్ ఆపరేటర్‌లను సులభంగా సృష్టించడం: ఏడాది పొడవునా ప్రాజెక్ట్ పురోగతి";
• «షెల్-ఆపరేటర్‌ను పరిచయం చేస్తున్నాము: కుబెర్నెట్స్ కోసం ఆపరేటర్‌లను సృష్టించడం ఇప్పుడే సులభమైంది";
• «కుబెర్నెటెస్ క్లస్టర్‌ను సిద్ధం చేయడం సులభం మరియు సౌకర్యవంతంగా ఉందా? యాడ్ఆన్-ఆపరేటర్‌ను ప్రకటిస్తోంది";
• «కుబెర్నెట్‌లను విస్తరించడం మరియు పూర్తి చేయడం" (సమీక్ష మరియు వీడియో నివేదిక).

మూలం: www.habr.com