જાઓ? બાશ! શેલ-ઓપરેટરને મળો (કુબેકોન EU'2020 તરફથી સમીક્ષા અને વિડિઓ રિપોર્ટ)

આ વર્ષે, મુખ્ય યુરોપિયન કુબરનેટ્સ કોન્ફરન્સ - KubeCon + CloudNativeCon Europe 2020 - વર્ચ્યુઅલ હતી. જો કે, ફોર્મેટમાં આવા ફેરફારથી અમને અમારા લાંબા-આયોજિત અહેવાલ "જાઓ? બાશ! અમારા ઓપન સોર્સ પ્રોજેક્ટને સમર્પિત શેલ-ઓપરેટરને મળો શેલ-ઓપરેટર.

આ લેખ, વાર્તાલાપથી પ્રેરિત, કુબરનેટ્સ માટે ઓપરેટર્સ બનાવવાની પ્રક્રિયાને સરળ બનાવવાનો અભિગમ રજૂ કરે છે અને બતાવે છે કે તમે શેલ-ઓપરેટરનો ઉપયોગ કરીને ન્યૂનતમ પ્રયત્નો સાથે તમારું પોતાનું કેવી રીતે બનાવી શકો છો.

પરિચય અહેવાલનો વિડિયો (અંગ્રેજીમાં ~23 મિનિટ, લેખ કરતાં નોંધપાત્ર રીતે વધુ માહિતીપ્રદ) અને તેમાંથી મુખ્ય અર્ક ટેક્સ્ટ સ્વરૂપમાં. જાઓ!

ફ્લાન્ટમાં અમે સતત દરેક વસ્તુને ઑપ્ટિમાઇઝ અને સ્વચાલિત કરીએ છીએ. આજે આપણે બીજા એક રોમાંચક કોન્સેપ્ટ વિશે વાત કરીશું. મળો: ક્લાઉડ-નેટિવ શેલ સ્ક્રિપ્ટીંગ!

જો કે, ચાલો તે સંદર્ભથી પ્રારંભ કરીએ જેમાં આ બધું થાય છે: કુબરનેટ્સ.

કુબરનેટ્સ API અને નિયંત્રકો

Kubernetes માં API ને દરેક પ્રકારના ઑબ્જેક્ટ માટે ડિરેક્ટરીઓ સાથે ફાઇલ સર્વર તરીકે રજૂ કરી શકાય છે. આ સર્વર પરના ઑબ્જેક્ટ્સ (સંસાધનો) YAML ફાઇલો દ્વારા રજૂ થાય છે. વધુમાં, સર્વર પાસે મૂળભૂત API છે જે તમને ત્રણ વસ્તુઓ કરવાની મંજૂરી આપે છે:

• પ્રાપ્ત કરવા માટે તેના પ્રકાર અને નામ દ્વારા સંસાધન;
• બદલો સંસાધન (આ કિસ્સામાં, સર્વર ફક્ત "સાચા" ઑબ્જેક્ટ્સને સંગ્રહિત કરે છે - બધી ખોટી રીતે રચાયેલી અથવા અન્ય ડિરેક્ટરીઓ માટે હેતુ કાઢી નાખવામાં આવે છે);
• ટ્રેક સંસાધન માટે (આ ​​કિસ્સામાં, વપરાશકર્તા તરત જ તેનું વર્તમાન/અપડેટ કરેલ સંસ્કરણ મેળવે છે).

આમ, કુબરનેટ્સ ત્રણ મૂળભૂત પદ્ધતિઓ સાથે (YAML મેનિફેસ્ટ માટે) એક પ્રકારનાં ફાઇલ સર્વર તરીકે કાર્ય કરે છે (હા, ખરેખર અન્ય પણ છે, પરંતુ અમે તેને હમણાં માટે છોડી દઈશું).

સમસ્યા એ છે કે સર્વર ફક્ત માહિતી સંગ્રહિત કરી શકે છે. તેને કામ કરવા માટે તમારે જરૂર છે નિયંત્રક - કુબરનેટીસની દુનિયામાં બીજો સૌથી મહત્વપૂર્ણ અને મૂળભૂત ખ્યાલ.

નિયંત્રકોના બે મુખ્ય પ્રકાર છે. પ્રથમ કુબરનેટ્સ પાસેથી માહિતી લે છે, તેને નેસ્ટેડ લોજિક અનુસાર પ્રક્રિયા કરે છે, અને તેને K8s પર પરત કરે છે. બીજો કુબરનેટ્સ પાસેથી માહિતી લે છે, પરંતુ, પ્રથમ પ્રકારથી વિપરીત, કેટલાક બાહ્ય સંસાધનોની સ્થિતિમાં ફેરફાર કરે છે.

ચાલો કુબરનેટ્સમાં જમાવટ બનાવવાની પ્રક્રિયા પર નજીકથી નજર કરીએ:

• જમાવટ નિયંત્રક (આમાં સમાવિષ્ટ kube-controller-manager) જમાવટ વિશે માહિતી મેળવે છે અને પ્રતિકૃતિ સેટ બનાવે છે.
• ReplicaSet આ માહિતીના આધારે બે પ્રતિકૃતિઓ (બે પોડ) બનાવે છે, પરંતુ આ પોડ્સ હજુ સુનિશ્ચિત નથી.
• શેડ્યૂલર પોડ્સ શેડ્યૂલ કરે છે અને તેમના YAML માં નોડ માહિતી ઉમેરે છે.
• કુબેલેટ્સ બાહ્ય સંસાધનમાં ફેરફારો કરે છે (ડોકર કહે છે).

પછી આ આખો ક્રમ વિપરીત ક્રમમાં પુનરાવર્તિત થાય છે: કુબેલેટ કન્ટેનર તપાસે છે, પોડની સ્થિતિની ગણતરી કરે છે અને તેને પાછું મોકલે છે. ReplicaSet નિયંત્રક સ્થિતિ પ્રાપ્ત કરે છે અને પ્રતિકૃતિ સેટની સ્થિતિને અપડેટ કરે છે. આ જ વસ્તુ ડિપ્લોયમેન્ટ કંટ્રોલર સાથે થાય છે અને વપરાશકર્તા છેલ્લે અપડેટ (વર્તમાન) સ્થિતિ મેળવે છે.

શેલ-ઓપરેટર

તે તારણ આપે છે કે કુબરનેટ્સ વિવિધ નિયંત્રકોના સંયુક્ત કાર્ય પર આધારિત છે (કુબરનેટ્સ ઓપરેટરો પણ નિયંત્રકો છે). પ્રશ્ન ઊભો થાય છે કે, ન્યૂનતમ પ્રયત્નો સાથે તમારું પોતાનું ઓપરેટર કેવી રીતે બનાવવું? અને અહીં આપણે જે વિકસાવ્યું છે તે બચાવમાં આવે છે શેલ-ઓપરેટર. તે સિસ્ટમ સંચાલકોને પરિચિત પદ્ધતિઓનો ઉપયોગ કરીને તેમના પોતાના નિવેદનો બનાવવાની મંજૂરી આપે છે.

સરળ ઉદાહરણ: રહસ્યોની નકલ કરવી

ચાલો એક સરળ ઉદાહરણ જોઈએ.

ચાલો કહીએ કે અમારી પાસે કુબરનેટ્સ ક્લસ્ટર છે. તેમાં નેમસ્પેસ છે default કેટલાક રહસ્યો સાથે mysecret. આ ઉપરાંત, ક્લસ્ટરમાં અન્ય નેમસ્પેસ છે. તેમાંના કેટલાક તેમની સાથે ચોક્કસ લેબલ જોડાયેલા છે. અમારો ધ્યેય લેબલ સાથે નેમસ્પેસમાં સિક્રેટની નકલ કરવાનો છે.

કાર્ય એ હકીકત દ્વારા જટિલ છે કે ક્લસ્ટરમાં નવી નેમસ્પેસ દેખાઈ શકે છે, અને તેમાંના કેટલાકમાં આ લેબલ હોઈ શકે છે. બીજી બાજુ, જ્યારે લેબલ કાઢી નાખવામાં આવે છે, ત્યારે સિક્રેટ પણ કાઢી નાખવું જોઈએ. આ ઉપરાંત, સિક્રેટ પોતે પણ બદલાઈ શકે છે: આ કિસ્સામાં, નવા સિક્રેટને લેબલ્સ સાથેના તમામ નેમસ્પેસમાં કૉપિ કરવું આવશ્યક છે. જો કોઈ નેમસ્પેસમાં આકસ્મિક રીતે સિક્રેટ ડિલીટ થઈ જાય, તો અમારા ઓપરેટરે તેને તરત જ રિસ્ટોર કરવું જોઈએ.

હવે જ્યારે કાર્ય ઘડવામાં આવ્યું છે, તે શેલ-ઓપરેટરનો ઉપયોગ કરીને તેને અમલમાં મૂકવાનો સમય છે. પરંતુ પ્રથમ તે શેલ-ઓપરેટર વિશે થોડાક શબ્દો કહેવા યોગ્ય છે.

શેલ-ઓપરેટર કેવી રીતે કાર્ય કરે છે

કુબરનેટ્સમાં અન્ય વર્કલોડની જેમ, શેલ-ઓપરેટર તેના પોતાના પોડમાં ચાલે છે. ડિરેક્ટરીમાં આ પોડમાં /hooks એક્ઝેક્યુટેબલ ફાઇલો સંગ્રહિત છે. આ Bash, Python, Ruby, વગેરેમાં સ્ક્રિપ્ટો હોઈ શકે છે. અમે આવી એક્ઝેક્યુટેબલ ફાઇલોને હુક્સ કહીએ છીએ (હુક્સ).

શેલ-ઓપરેટર કુબરનેટ્સ ઇવેન્ટ્સમાં સબ્સ્ક્રાઇબ કરે છે અને તે ઇવેન્ટ્સના જવાબમાં આ હૂક ચલાવે છે જેની અમને જરૂર છે.

શેલ-ઓપરેટરને કેવી રીતે ખબર પડે છે કે કયો હૂક ચલાવવો અને ક્યારે? મુદ્દો એ છે કે દરેક હૂકમાં બે તબક્કા હોય છે. સ્ટાર્ટઅપ દરમિયાન, શેલ-ઓપરેટર દલીલ સાથે તમામ હુક્સ ચલાવે છે --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;
    • જો સ્થાનિક રહસ્ય શોધાયેલ નથી, તો તે કંઈ કરતું નથી.

બાશમાં અલ્ગોરિધમનો અમલ તમે અમારા માં ડાઉનલોડ કરી શકો છો ઉદાહરણો સાથે ભંડાર.

આ રીતે અમે YAML રૂપરેખાની 35 લાઇનનો ઉપયોગ કરીને અને બૅશ કોડની સમાન રકમનો ઉપયોગ કરીને એક સરળ કુબરનેટ્સ નિયંત્રક બનાવવા માટે સક્ષમ હતા! શેલ-ઓપરેટરનું કામ તેમને એકસાથે જોડવાનું છે.

જો કે, રહસ્યોની નકલ કરવી એ ઉપયોગિતાના એપ્લિકેશનનું એકમાત્ર ક્ષેત્ર નથી. તે શું સક્ષમ છે તે બતાવવા માટે અહીં થોડા વધુ ઉદાહરણો છે.

ઉદાહરણ 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: ક્લસ્ટર નેટવર્ક મોનિટરિંગ

જેમ તમે જાણો છો, પિંગનો ઉપયોગ કરવો એ નેટવર્કને મોનિટર કરવાની સૌથી સરળ રીત છે. આ ઉદાહરણમાં આપણે બતાવીશું કે શેલ-ઓપરેટરનો ઉપયોગ કરીને આવા મોનિટરિંગને કેવી રીતે અમલમાં મૂકવું.

સૌ પ્રથમ, તમારે નોડ્સ પર સબ્સ્ક્રાઇબ કરવાની જરૂર પડશે. શેલ ઓપરેટરને દરેક નોડના નામ અને 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/સ્ટાર્સ જોઈને હંમેશા ખુશ છીએ, જ્યાં તમે અન્ય લોકોને શોધી શકો છો. રસપ્રદ પ્રોજેક્ટ્સ. તેમાંથી તે હાઇલાઇટ કરવા યોગ્ય છે એડઓન ઓપરેટર, જે શેલ-ઓપરેટરનો મોટો ભાઈ છે. આ યુટિલિટી એડ-ઓન ઇન્સ્ટોલ કરવા માટે હેલ્મ ચાર્ટનો ઉપયોગ કરે છે, અપડેટ્સ વિતરિત કરી શકે છે અને વિવિધ ચાર્ટ પરિમાણો/મૂલ્યોનું નિરીક્ષણ કરી શકે છે, ચાર્ટની ઇન્સ્ટોલેશન પ્રક્રિયાને નિયંત્રિત કરે છે અને ક્લસ્ટરમાંની ઘટનાઓના પ્રતિભાવમાં તેમને સંશોધિત પણ કરી શકે છે.

વિડિઓઝ અને સ્લાઇડ્સ

પ્રદર્શનમાંથી વિડિઓ (~23 મિનિટ):

અહેવાલની રજૂઆત:

PS

અમારા બ્લોગ પર પણ વાંચો:

• «શેલ-ઓપરેટર સાથે કુબરનેટ્સ ઓપરેટર્સની સરળ રચના: વર્ષ દરમિયાન પ્રોજેક્ટની પ્રગતિ»;
• «શેલ-ઓપરેટરનો પરિચય: કુબરનેટ્સ માટે ઓપરેટર બનાવવાનું સરળ બન્યું છે»;
• «શું કુબરનેટ્સ ક્લસ્ટર તૈયાર કરવું સરળ અને અનુકૂળ છે? એડઓન-ઓપરેટરની જાહેરાત»;
• «કુબરનેટ્સનું વિસ્તરણ અને પૂરક" (સમીક્ષા અને વિડિયો રિપોર્ટ).

સોર્સ: www.habr.com