🥇போகவா? பேஷ்! ஷெல்-ஆபரேட்டரை சந்திக்கவும் (குபேகான் EU'2020 இன் மதிப்பாய்வு மற்றும் வீடியோ அறிக்கை)

இந்த ஆண்டு, முக்கிய ஐரோப்பிய குபெர்னெட்ஸ் மாநாடு - KubeCon + CloudNativeCon Europe 2020 - மெய்நிகர். எவ்வாறாயினும், வடிவமைப்பில் இத்தகைய மாற்றம் எங்கள் நீண்டகாலமாக திட்டமிடப்பட்ட அறிக்கையை வழங்குவதைத் தடுக்கவில்லை “போவா? பேஷ்! ஷெல்-ஆபரேட்டரை சந்திக்கவும்" எங்கள் திறந்த மூல திட்டத்திற்காக அர்ப்பணிக்கப்பட்டது ஷெல்-ஆபரேட்டர்.

பேச்சால் ஈர்க்கப்பட்ட இந்தக் கட்டுரை, Kubernetes க்காக ஆபரேட்டர்களை உருவாக்கும் செயல்முறையை எளிதாக்குவதற்கான அணுகுமுறையை முன்வைக்கிறது மற்றும் ஷெல்-ஆபரேட்டரைப் பயன்படுத்தி குறைந்த முயற்சியில் நீங்கள் எவ்வாறு சொந்தமாகச் செய்யலாம் என்பதைக் காட்டுகிறது.

அறிமுகப்படுத்துகிறது அறிக்கையின் வீடியோ (ஆங்கிலத்தில் ~23 நிமிடங்கள், கட்டுரையை விட குறிப்பிடத்தக்க தகவல்) மற்றும் உரை வடிவில் அதிலிருந்து முக்கிய சாறு. போ!

Flant இல் நாங்கள் தொடர்ந்து எல்லாவற்றையும் மேம்படுத்துகிறோம் மற்றும் தானியங்குபடுத்துகிறோம். இன்று நாம் மற்றொரு அற்புதமான கருத்தைப் பற்றி பேசுவோம். சந்திப்பு: கிளவுட்-நேட்டிவ் ஷெல் ஸ்கிரிப்டிங்!

இருப்பினும், இவை அனைத்தும் நிகழும் சூழலில் தொடங்குவோம்: குபெர்னெட்ஸ்.

குபெர்னெட்ஸ் API மற்றும் கட்டுப்படுத்திகள்

குபெர்னெட்டஸில் உள்ள ஏபிஐ, ஒவ்வொரு வகை பொருளுக்கான கோப்பகங்களுடன் ஒரு வகையான கோப்பு சேவையகமாக குறிப்பிடப்படலாம். இந்த சேவையகத்தில் உள்ள பொருள்கள் (வளங்கள்) YAML கோப்புகளால் குறிப்பிடப்படுகின்றன. கூடுதலாக, சர்வரில் அடிப்படை API உள்ளது, இது மூன்று விஷயங்களைச் செய்ய உங்களை அனுமதிக்கிறது:

получать அதன் வகை மற்றும் பெயரால் வளம்;
மாற்றம் ஆதாரம் (இந்த விஷயத்தில், சேவையகம் "சரியான" பொருட்களை மட்டுமே சேமிக்கிறது - தவறாக உருவாக்கப்பட்டவை அல்லது பிற கோப்பகங்களுக்கு நோக்கம் கொண்டவை நிராகரிக்கப்படுகின்றன);
தடம் ஆதாரத்திற்காக (இந்த வழக்கில், பயனர் உடனடியாக அதன் தற்போதைய/புதுப்பிக்கப்பட்ட பதிப்பைப் பெறுகிறார்).

எனவே, குபெர்னெட்டஸ் மூன்று அடிப்படை முறைகளுடன் (YAML வெளிப்பாட்டிற்கு) ஒரு வகையான கோப்பு சேவையகமாக செயல்படுகிறது (ஆம், உண்மையில் மற்றவை உள்ளன, ஆனால் அவற்றை இப்போதைக்கு விட்டுவிடுவோம்).

சிக்கல் என்னவென்றால், சேவையகம் தகவல்களை மட்டுமே சேமிக்க முடியும். வேலை செய்ய உங்களுக்குத் தேவை கட்டுப்படுத்தி - குபெர்னெட்டஸ் உலகில் இரண்டாவது மிக முக்கியமான மற்றும் அடிப்படை கருத்து.

இரண்டு முக்கிய வகையான கட்டுப்படுத்திகள் உள்ளன. முதலாவது குபெர்னெட்டஸிடமிருந்து தகவல்களைப் பெற்று, உள்ளமைக்கப்பட்ட தர்க்கத்தின்படி அதைச் செயலாக்கி, அதை K8 களுக்குத் திருப்பி அனுப்புகிறது. இரண்டாவது குபெர்னெட்டஸிடமிருந்து தகவல்களைப் பெறுகிறது, ஆனால், முதல் வகையைப் போலன்றி, சில வெளிப்புற வளங்களின் நிலையை மாற்றுகிறது.

குபெர்னெட்ஸில் வரிசைப்படுத்தலை உருவாக்கும் செயல்முறையை இன்னும் விரிவாகப் பார்ப்போம்:

வரிசைப்படுத்தல் கட்டுப்படுத்தி (சேர்க்கப்பட்டுள்ளது kube-controller-manager) வரிசைப்படுத்தல் பற்றிய தகவலைப் பெறுகிறது மற்றும் ஒரு பிரதிசெட்டை உருவாக்குகிறது.
ReplicaSet இந்தத் தகவலின் அடிப்படையில் இரண்டு பிரதிகளை (இரண்டு காய்கள்) உருவாக்குகிறது, ஆனால் இந்த காய்கள் இன்னும் திட்டமிடப்படவில்லை.
திட்டமிடுபவர் காய்களை திட்டமிடுகிறார் மற்றும் அவற்றின் YAML களில் முனை தகவலைச் சேர்க்கிறார்.
குபெலெட்டுகள் வெளிப்புற ஆதாரத்தில் மாற்றங்களைச் செய்கிறார்கள் (டோக்கர் என்று சொல்லுங்கள்).

இந்த முழு வரிசையும் தலைகீழ் வரிசையில் மீண்டும் மீண்டும் செய்யப்படுகிறது: குபெலெட் கொள்கலன்களைச் சரிபார்த்து, நெற்று நிலையைக் கணக்கிட்டு அதைத் திருப்பி அனுப்புகிறது. ReplicaSet கட்டுப்படுத்தி நிலையைப் பெற்று, பிரதி தொகுப்பின் நிலையைப் புதுப்பிக்கிறது. வரிசைப்படுத்தல் கன்ட்ரோலரிலும் இதேதான் நடக்கும் மற்றும் பயனர் இறுதியாக புதுப்பிக்கப்பட்ட (தற்போதைய) நிலையைப் பெறுகிறார்.

ஷெல்-ஆபரேட்டர்

குபெர்னெட்ஸ் பல்வேறு கட்டுப்படுத்திகளின் கூட்டுப் பணியை அடிப்படையாகக் கொண்டது என்று மாறிவிடும் (குபெர்னெட்ஸ் ஆபரேட்டர்களும் கட்டுப்படுத்திகள்). கேள்வி எழுகிறது, குறைந்த முயற்சியுடன் உங்கள் சொந்த ஆபரேட்டரை எவ்வாறு உருவாக்குவது? இங்கே நாம் உருவாக்கிய ஒன்று மீட்புக்கு வருகிறது ஷெல்-ஆபரேட்டர். இது கணினி நிர்வாகிகள் தங்கள் சொந்த அறிக்கைகளை பழக்கமான முறைகளைப் பயன்படுத்தி உருவாக்க அனுமதிக்கிறது.

எளிய எடுத்துக்காட்டு: ரகசியங்களை நகலெடுப்பது

ஒரு எளிய உதாரணத்தைப் பார்ப்போம்.

எங்களிடம் குபெர்னெட்ஸ் கிளஸ்டர் உள்ளது என்று வைத்துக்கொள்வோம். அதற்கு ஒரு பெயர்வெளி உள்ளது default சில ரகசியங்களுடன் mysecret. கூடுதலாக, கிளஸ்டரில் வேறு பெயர்வெளிகள் உள்ளன. அவற்றில் சில குறிப்பிட்ட லேபிள் இணைக்கப்பட்டுள்ளன. ரகசியத்தை லேபிளுடன் பெயர்வெளிகளில் நகலெடுப்பதே எங்கள் குறிக்கோள்.

புதிய பெயர்வெளிகள் கிளஸ்டரில் தோன்றக்கூடும் என்பதாலும், அவற்றில் சில இந்த லேபிளைக் கொண்டிருக்கலாம் என்பதாலும் பணி சிக்கலானது. மறுபுறம், லேபிள் நீக்கப்படும் போது, இரகசியமும் நீக்கப்பட வேண்டும். இது தவிர, ரகசியமும் மாறலாம்: இந்த வழக்கில், புதிய ரகசியமானது அனைத்து பெயர்வெளிகளிலும் லேபிள்களுடன் நகலெடுக்கப்பட வேண்டும். ஏதேனும் பெயர்வெளியில் ரகசியம் தற்செயலாக நீக்கப்பட்டால், எங்கள் ஆபரேட்டர் அதை உடனடியாக மீட்டெடுக்க வேண்டும்.

இப்போது பணி வடிவமைக்கப்பட்டுள்ளது, ஷெல்-ஆபரேட்டரைப் பயன்படுத்தி அதைச் செயல்படுத்தத் தொடங்க வேண்டிய நேரம் இது. ஆனால் முதலில் ஷெல்-ஆபரேட்டரைப் பற்றி சில வார்த்தைகளைச் சொல்வது மதிப்பு.

ஷெல்-ஆபரேட்டர் எவ்வாறு செயல்படுகிறது

குபெர்னெட்டஸில் உள்ள மற்ற பணிச்சுமைகளைப் போலவே, ஷெல்-ஆபரேட்டரும் அதன் சொந்த பானையில் இயங்குகிறது. அடைவில் இந்த பாட் /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 இல் மாற்றங்களைச் செய்தல்

மூன்று காய்களைக் கொண்ட ஒரு வரிசைப்படுத்தலைப் பார்ப்போம். சில உள்ளமைவுகளைச் சேமிக்க காய்கள் ConfigMap ஐப் பயன்படுத்துகின்றன. காய்கள் தொடங்கப்பட்டபோது, ConfigMap ஒரு குறிப்பிட்ட நிலையில் இருந்தது (அதை v.1 என்று அழைக்கலாம்). அதன்படி, அனைத்து காய்களும் இந்த குறிப்பிட்ட ConfigMap பதிப்பைப் பயன்படுத்துகின்றன.

இப்போது ConfigMap மாறிவிட்டது என்று வைத்துக்கொள்வோம் (v.2). இருப்பினும், காய்கள் ConfigMap இன் முந்தைய பதிப்பைப் பயன்படுத்தும் (v.1):

புதிய ConfigMap (v.2) க்கு மாற நான் அவர்களை எவ்வாறு பெறுவது? பதில் எளிது: ஒரு டெம்ப்ளேட்டைப் பயன்படுத்தவும். பிரிவில் செக்சம் சிறுகுறிப்பைச் சேர்ப்போம் template வரிசைப்படுத்தல் கட்டமைப்புகள்:

இதன் விளைவாக, இந்த செக்சம் அனைத்து காய்களிலும் பதிவு செய்யப்படும், மேலும் இது வரிசைப்படுத்தல் போலவே இருக்கும். இப்போது நீங்கள் ConfigMap மாறும் போது சிறுகுறிப்பை புதுப்பிக்க வேண்டும். ஷெல்-ஆபரேட்டர் இந்த விஷயத்தில் கைக்குள் வருகிறது. நீங்கள் செய்ய வேண்டியது எல்லாம் நிரல் ConfigMap க்கு குழுசேர்ந்து செக்சம் புதுப்பிக்கும் ஒரு கொக்கி.

பயனர் ConfigMap இல் மாற்றங்களைச் செய்தால், ஷெல்-ஆபரேட்டர் அவற்றைக் கவனித்து, செக்ஸத்தை மீண்டும் கணக்கிடுவார். அதன் பிறகு குபெர்னெட்டஸின் மந்திரம் செயல்பாட்டுக்கு வரும்: ஆர்கெஸ்ட்ரேட்டர் பானைக் கொன்று, புதிய ஒன்றை உருவாக்கி, அது மாறும் வரை காத்திருங்கள். Ready, மற்றும் அடுத்ததுக்கு செல்கிறது. இதன் விளைவாக, வரிசைப்படுத்தல் ஒத்திசைக்கப்பட்டு, ConfigMap இன் புதிய பதிப்பிற்கு மாறும்.

எடுத்துக்காட்டு 2: தனிப்பயன் வள வரையறைகளுடன் பணிபுரிதல்

உங்களுக்குத் தெரிந்தபடி, தனிப்பயன் வகையான பொருட்களை உருவாக்க குபெர்னெட்ஸ் உங்களை அனுமதிக்கிறது. உதாரணமாக, நீங்கள் ஒரு வகையை உருவாக்கலாம் MysqlDatabase. இந்த வகைக்கு இரண்டு மெட்டாடேட்டா அளவுருக்கள் உள்ளன என்று வைத்துக் கொள்வோம்: name и namespace.

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

நாம் MySQL தரவுத்தளங்களை உருவாக்கக்கூடிய பல்வேறு பெயர்வெளிகளைக் கொண்ட குபெர்னெட்ஸ் கிளஸ்டர் உள்ளது. இந்த வழக்கில் ஷெல்-ஆபரேட்டர் ஆதாரங்களை கண்காணிக்க பயன்படுத்தப்படலாம் MysqlDatabase, அவற்றை MySQL சேவையகத்துடன் இணைத்து, கிளஸ்டரின் விரும்பிய மற்றும் கவனிக்கப்பட்ட நிலைகளை ஒத்திசைக்கிறது.

எடுத்துக்காட்டு 3: கிளஸ்டர் நெட்வொர்க் கண்காணிப்பு

உங்களுக்குத் தெரியும், பிங்கைப் பயன்படுத்துவது பிணையத்தைக் கண்காணிக்க எளிய வழியாகும். ஷெல்-ஆபரேட்டரைப் பயன்படுத்தி அத்தகைய கண்காணிப்பை எவ்வாறு செயல்படுத்துவது என்பதை இந்த எடுத்துக்காட்டில் காண்போம்.

முதலில், நீங்கள் முனைகளுக்கு குழுசேர வேண்டும். ஷெல் ஆபரேட்டருக்கு ஒவ்வொரு முனையின் பெயர் மற்றும் ஐபி முகவரி தேவை. அவர்களின் உதவியுடன், அவர் இந்த முனைகளை பிங் செய்வார்.

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
}

நாங்கள் முனைகளின் பட்டியலை மீண்டும் செய்கிறோம், அவற்றின் பெயர்கள் மற்றும் ஐபி முகவரிகளைப் பெறுகிறோம், அவற்றை பிங் செய்து முடிவுகளை ப்ரோமிதியஸுக்கு அனுப்புகிறோம். ஷெல்-ஆபரேட்டர் ப்ரோமிதியஸுக்கு அளவீடுகளை ஏற்றுமதி செய்யலாம், சூழல் மாறியில் குறிப்பிடப்பட்டுள்ள பாதையின்படி அமைந்துள்ள கோப்பில் அவற்றைச் சேமிக்கிறது $METRICS_PATH.

இங்கே அப்படி ஒரு கிளஸ்டரில் எளிய நெட்வொர்க் கண்காணிப்புக்கு நீங்கள் ஒரு ஆபரேட்டரை உருவாக்கலாம்.

வரிசை பொறிமுறை

ஷெல்-ஆபரேட்டரில் கட்டமைக்கப்பட்ட மற்றொரு முக்கியமான வழிமுறையை விவரிக்காமல் இந்தக் கட்டுரை முழுமையடையாது. கிளஸ்டரில் ஒரு நிகழ்வுக்கு பதிலளிக்கும் விதமாக இது ஒருவித கொக்கியை இயக்குகிறது என்று கற்பனை செய்து பாருங்கள்.

அதே நேரத்தில், கிளஸ்டரில் ஏதாவது நடந்தால் என்ன நடக்கும்? இன்னும் ஒன்று நிகழ்வு?
ஷெல்-ஆபரேட்டர் கொக்கியின் மற்றொரு நிகழ்வை இயக்குமா?
ஒரே நேரத்தில் ஐந்து நிகழ்வுகள் கிளஸ்டரில் நடந்தால் என்ன செய்வது?
ஷெல்-ஆபரேட்டர் அவற்றை இணையாக செயல்படுத்துமா?
நினைவகம் மற்றும் CPU போன்ற நுகரப்படும் வளங்களைப் பற்றி என்ன?

அதிர்ஷ்டவசமாக, ஷெல்-ஆபரேட்டர் ஒரு உள்ளமைக்கப்பட்ட வரிசை பொறிமுறையைக் கொண்டுள்ளது. அனைத்து நிகழ்வுகளும் வரிசைப்படுத்தப்பட்டு வரிசையாக செயலாக்கப்படும்.

இதை உதாரணங்களுடன் விளக்குவோம். எங்களிடம் இரண்டு கொக்கிகள் உள்ளன என்று வைத்துக்கொள்வோம். முதல் நிகழ்வு முதல் கொக்கிக்கு செல்கிறது. அதன் செயலாக்கம் முடிந்ததும், வரிசை முன்னோக்கி நகர்கிறது. அடுத்த மூன்று நிகழ்வுகள் இரண்டாவது கொக்கிக்கு திருப்பி விடப்படுகின்றன - அவை வரிசையில் இருந்து அகற்றப்பட்டு, அதில் ஒரு "மூட்டையில்" உள்ளிடப்படுகின்றன. அது ஹூக் நிகழ்வுகளின் வரிசையைப் பெறுகிறது - அல்லது, இன்னும் துல்லியமாக, பிணைப்பு சூழல்களின் வரிசை.

மேலும் இவை நிகழ்வுகளை ஒரு பெரிய ஒன்றாக இணைக்க முடியும். இதற்கு அளவுரு பொறுப்பு group பிணைப்பு கட்டமைப்பில்.

நீங்கள் எத்தனை வரிசைகள்/கொக்கிகள் மற்றும் அவற்றின் பல்வேறு சேர்க்கைகளை உருவாக்கலாம். உதாரணமாக, ஒரு வரிசை இரண்டு கொக்கிகள் அல்லது நேர்மாறாக வேலை செய்யலாம்.

நீங்கள் செய்ய வேண்டியது எல்லாம் அதற்கேற்ப புலத்தை உள்ளமைக்க வேண்டும் queue பிணைப்பு கட்டமைப்பில். வரிசையின் பெயர் குறிப்பிடப்படவில்லை என்றால், ஹூக் இயல்புநிலை வரிசையில் இயங்கும் (default) இந்த வரிசை பொறிமுறையானது கொக்கிகளுடன் பணிபுரியும் போது அனைத்து வள மேலாண்மை சிக்கல்களையும் முழுமையாக தீர்க்க உங்களை அனுமதிக்கிறது.

முடிவுக்கு

ஷெல்-ஆபரேட்டர் என்றால் என்ன என்பதை நாங்கள் விளக்கினோம், விரைவாகவும் சிரமமின்றியும் குபெர்னெட்ஸ் ஆபரேட்டர்களை உருவாக்க அதை எவ்வாறு பயன்படுத்தலாம் என்பதைக் காண்பித்தோம், மேலும் அதன் பயன்பாட்டிற்கு பல எடுத்துக்காட்டுகளையும் கொடுத்தோம்.

ஷெல்-ஆபரேட்டரைப் பற்றிய விரிவான தகவலும், அதை எவ்வாறு பயன்படுத்துவது என்பது பற்றிய விரைவான பயிற்சியும் தொடர்புடையது. GitHub இல் களஞ்சியங்கள். கேள்விகளுடன் எங்களைத் தொடர்பு கொள்ள தயங்க வேண்டாம்: நீங்கள் அவற்றை ஒரு சிறப்புடன் விவாதிக்கலாம் தந்தி குழு (ரஷ்ய மொழியில்) அல்லது இந்த மன்றம் (ஆங்கிலத்தில்).

நீங்கள் விரும்பியிருந்தால், GitHub இல் புதிய சிக்கல்கள்/PR/நட்சத்திரங்களைக் காண்பதில் நாங்கள் எப்போதும் மகிழ்ச்சியடைகிறோம், மற்றவற்றை நீங்கள் காணலாம். சுவாரஸ்யமான திட்டங்கள். அவற்றுள் இது சிறப்பம்சமாக உள்ளது addon-operator, இது ஷெல்-ஆபரேட்டரின் பெரிய சகோதரர். இந்த பயன்பாடானது துணை நிரல்களை நிறுவ ஹெல்ம் விளக்கப்படங்களைப் பயன்படுத்துகிறது, புதுப்பிப்புகளை வழங்கலாம் மற்றும் பல்வேறு விளக்கப்பட அளவுருக்கள்/மதிப்புகளைக் கண்காணிக்கலாம், விளக்கப்படங்களின் நிறுவல் செயல்முறையைக் கட்டுப்படுத்தலாம் மற்றும் கிளஸ்டரில் உள்ள நிகழ்வுகளுக்கு பதிலளிக்கும் வகையில் அவற்றை மாற்றலாம்.

வீடியோக்கள் மற்றும் ஸ்லைடுகள்

செயல்திறன் வீடியோ (~23 நிமிடங்கள்):

அறிக்கையின் விளக்கக்காட்சி:

சோசலிஸ்ட் கட்சி

எங்கள் வலைப்பதிவிலும் படிக்கவும்:

ஆதாரம்: www.habr.com

போ? பேஷ்! ஷெல்-ஆபரேட்டரை சந்திக்கவும் (குபேகான் EU'2020 இன் மதிப்பாய்வு மற்றும் வீடியோ அறிக்கை)