કુબરનેટ્સનું વિસ્તરણ અને પૂરક (વિહંગાવલોકન અને વિડિયો રિપોર્ટ)

8 એપ્રિલે કોન્ફરન્સમાં સેન્ટ હાઇલોડ++ 2019, "DevOps અને ઓપરેશન્સ" વિભાગના ભાગ રૂપે, "કુબરનેટ્સનું વિસ્તરણ અને પૂરક" અહેવાલ આપવામાં આવ્યો હતો, જેની રચનામાં ફ્લેંટ કંપનીના ત્રણ કર્મચારીઓએ ભાગ લીધો હતો. તેમાં, અમે અસંખ્ય પરિસ્થિતિઓ વિશે વાત કરીએ છીએ જેમાં અમે કુબરનેટ્સની ક્ષમતાઓને વિસ્તૃત અને પૂરક બનાવવા માંગીએ છીએ, પરંતુ જેના માટે અમને તૈયાર અને સરળ ઉકેલ મળ્યો નથી. અમારી પાસે ઓપન સોર્સ પ્રોજેક્ટ્સના રૂપમાં જરૂરી ઉકેલો છે, અને આ ભાષણ પણ તેમને સમર્પિત છે.

પરંપરા દ્વારા, અમે પ્રસ્તુત કરવા માટે ઉત્સુક છીએ અહેવાલનો વિડિયો (50 મિનિટ, લેખ કરતાં વધુ માહિતીપ્રદ) અને ટેક્સ્ટ સ્વરૂપમાં મુખ્ય સારાંશ. જાઓ!

K8s માં કોર અને ઉમેરાઓ

કુબરનેટ્સ ઉદ્યોગ અને વહીવટ માટેના અભિગમોને બદલી રહ્યા છે જે લાંબા સમયથી સ્થાપિત છે:

• તેમનો આભાર અમૂર્ત, અમે હવે રૂપરેખા સેટ કરવા અથવા કમાન્ડ (રસોઇયા, જવાબી...) ચલાવવા જેવા ખ્યાલો સાથે કામ કરતા નથી, પરંતુ કન્ટેનર, સેવાઓ વગેરેના જૂથનો ઉપયોગ કરીએ છીએ.
• ની ઘોંઘાટ વિશે વિચાર્યા વિના અમે એપ્લિકેશન તૈયાર કરી શકીએ છીએ ચોક્કસ સાઇટ, જેના પર તે લોન્ચ કરવામાં આવશે: બેર મેટલ, પ્રદાતાઓમાંના એકનો વાદળ, વગેરે.
• K8s સાથે તમે ક્યારેય વધુ સુલભ ન હતા શ્રેષ્ઠ વ્યવહાર ઈન્ફ્રાસ્ટ્રક્ચરના આયોજન પર: સ્કેલિંગ તકનીકો, સ્વ-હીલિંગ, દોષ સહનશીલતા, વગેરે.

જો કે, અલબત્ત, બધું એટલું સરળ નથી: કુબરનેટ્સે તેના પોતાના નવા પડકારો પણ લાવ્યા.

ક્યુબર્નેટિસ નથી એક સંયોજન છે જે તમામ વપરાશકર્તાઓની તમામ સમસ્યાઓનું નિરાકરણ કરે છે. કોર કુબરનેટ્સ એ ન્યૂનતમ જરૂરી કાર્યોના સમૂહ માટે જ જવાબદાર છે જે તેમાં હાજર છે દરેક વ્યક્તિ ક્લસ્ટર:

કુબરનેટીસ કોર કન્ટેનરને જૂથબદ્ધ કરવા, ટ્રાફિકનું સંચાલન કરવા વગેરે માટે આદિમના મૂળભૂત સમૂહને વ્યાખ્યાયિત કરે છે. અમે તેમના વિશે વધુ વિગતવાર વાત કરી 2 વર્ષ પહેલાનો અહેવાલ.

બીજી બાજુ, K8s ઉપલબ્ધ કાર્યોને વિસ્તૃત કરવાની શ્રેષ્ઠ તકો આપે છે, જે અન્યને બંધ કરવામાં મદદ કરે છે - ચોક્કસ - વપરાશકર્તા જરૂરિયાતો. કુબરનેટ્સમાં ઉમેરણો એ ક્લસ્ટર એડમિનિસ્ટ્રેટર્સની જવાબદારી છે, જેમણે તેમના ક્લસ્ટરને "યોગ્ય આકારમાં" [તેમની ચોક્કસ સમસ્યાઓ હલ કરવા] માટે જરૂરી બધું ઇન્સ્ટોલ અને ગોઠવવું આવશ્યક છે. આ કયા પ્રકારના ઉમેરાઓ છે? ચાલો કેટલાક ઉદાહરણો જોઈએ.

ઍડ-ઑન્સનાં ઉદાહરણો

કુબરનેટ્સ ઇન્સ્ટોલ કર્યા પછી, અમે આશ્ચર્ય પામી શકીએ છીએ કે નોડની અંદર અને નોડ વચ્ચે બંને પોડ્સની ક્રિયાપ્રતિક્રિયા માટે એટલું જરૂરી નેટવર્કિંગ તેની પોતાની રીતે કામ કરતું નથી. Kubernetes કર્નલ જરૂરી જોડાણોની ખાતરી આપતું નથી; તેના બદલે, તે નેટવર્ક નક્કી કરે છે ઈન્ટરફેસ (સીએનઆઇ) તૃતીય પક્ષ ઍડ-ઑન્સ માટે. આપણે આમાંથી એક એડ-ઓન ઇન્સ્ટોલ કરવું જોઈએ, જે નેટવર્ક ગોઠવણી માટે જવાબદાર હશે.

નજીકનું ઉદાહરણ ડેટા સ્ટોરેજ સોલ્યુશન્સ છે (સ્થાનિક ડિસ્ક, નેટવર્ક બ્લોક ઉપકરણ, Ceph...). શરૂઆતમાં તેઓ મૂળમાં હતા, પરંતુ આગમન સાથે CSI પરિસ્થિતિ પહેલાથી વર્ણવેલ સમાન કંઈક બદલાય છે: ઇન્ટરફેસ કુબરનેટ્સમાં છે, અને તેનો અમલ થર્ડ-પાર્ટી મોડ્યુલોમાં છે.

અન્ય ઉદાહરણોમાં નીચેનાનો સમાવેશ થાય છે:

• પ્રવેશ- નિયંત્રકો (માં તેમની સમીક્ષા જુઓ અમારો તાજેતરનો લેખ).
• પ્રમાણપત્ર-વ્યવસ્થાપક:

  

• ઓપરેટરો એડ-ઓન્સનો સંપૂર્ણ વર્ગ છે (જેમાં ઉલ્લેખિત પ્રમાણપત્ર-મેનેજરનો સમાવેશ થાય છે), તેઓ આદિમ(ઓ) અને નિયંત્રક(ઓ) ને વ્યાખ્યાયિત કરે છે. તેમના કાર્યનો તર્ક ફક્ત અમારી કલ્પના દ્વારા મર્યાદિત છે અને અમને તૈયાર માળખાકીય ઘટકો (ઉદાહરણ તરીકે, ડીબીએમએસ) ને આદિમમાં ફેરવવાની મંજૂરી આપે છે, જેની સાથે કામ કરવું વધુ સરળ છે (કન્ટેનર અને તેમની સેટિંગ્સના સેટ કરતાં). મોટી સંખ્યામાં ઓપરેટરો લખવામાં આવ્યા છે - જો તેમાંથી ઘણા હજી ઉત્પાદન માટે તૈયાર ન હોય તો પણ, તે માત્ર સમયની બાબત છે:

  

• મેટ્રિક્સ - કુબરનેટ્સે કેવી રીતે ઇન્ટરફેસ (મેટ્રિક્સ API) ને અમલીકરણથી અલગ કર્યું તેનું બીજું ઉદાહરણ (તૃતીય-પક્ષ એડ-ઓન્સ જેમ કે પ્રોમિથિયસ એડેપ્ટર, ડેટાડોગ ક્લસ્ટર એજન્ટ...).
• માટે મોનીટરીંગ અને આંકડા, જ્યાં વ્યવહારમાં માત્ર જરૂરી નથી પ્રોમિથિયસ અને ગ્રાફના, પણ કુબે-સ્ટેટ-મેટ્રિક્સ, નોડ-નિકાસકાર, વગેરે.

અને આ ઉમેરાઓની સંપૂર્ણ સૂચિ નથી... ઉદાહરણ તરીકે, ફ્લેંટ કંપનીમાં અમે હાલમાં ઇન્સ્ટોલ કરીએ છીએ 29 ઉમેરાઓ (જે તમામ કુલ 249 કુબરનેટ્સ ઓબ્જેક્ટ બનાવે છે). સરળ શબ્દોમાં કહીએ તો, આપણે ઉમેરાઓ વિના ક્લસ્ટરનું જીવન જોઈ શકતા નથી.

ઓટોમેશન

ઓપરેટરોને નિયમિત કામગીરીને સ્વચાલિત કરવા માટે ડિઝાઇન કરવામાં આવી છે જેનો આપણે દરરોજ સામનો કરીએ છીએ. અહીં વાસ્તવિક જીવનના ઉદાહરણો છે જેના માટે ઑપરેટર લખવું એ ઉત્તમ ઉકેલ હશે:

1. એપ્લિકેશન માટે છબીઓ સાથે ખાનગી (એટલે ​​કે લૉગિન જરૂરી) રજિસ્ટ્રી છે. એવું માનવામાં આવે છે કે દરેક પોડને એક વિશિષ્ટ રહસ્ય સોંપવામાં આવે છે જે રજિસ્ટ્રીમાં પ્રમાણીકરણને મંજૂરી આપે છે. અમારું કાર્ય એ સુનિશ્ચિત કરવાનું છે કે આ રહસ્ય નેમસ્પેસમાં જોવા મળે છે જેથી પોડ્સ છબીઓ ડાઉનલોડ કરી શકે. ત્યાં ઘણી બધી એપ્લિકેશનો હોઈ શકે છે (જેમાંના દરેકને ગુપ્તની જરૂર છે), અને તે રહસ્યોને નિયમિતપણે અપડેટ કરવા માટે ઉપયોગી છે, તેથી હાથ દ્વારા રહસ્યો મૂકવાનો વિકલ્પ દૂર કરવામાં આવે છે. આ તે છે જ્યાં ઓપરેટર બચાવમાં આવે છે: અમે એક નિયંત્રક બનાવીએ છીએ જે નેમસ્પેસ દેખાવાની રાહ જોશે અને, આ ઇવેન્ટના આધારે, નેમસ્પેસમાં એક રહસ્ય ઉમેરશે.
2. પોડ્સથી ઈન્ટરનેટની ડિફોલ્ટ એક્સેસ પર પ્રતિબંધ છે. પરંતુ કેટલીકવાર તેની જરૂર પડી શકે છે: એક્સેસ પરવાનગી મિકેનિઝમ માટે ચોક્કસ કૌશલ્યોની જરૂર વગર, સરળ રીતે કાર્ય કરવું તે તાર્કિક છે, ઉદાહરણ તરીકે, નેમસ્પેસમાં ચોક્કસ લેબલની હાજરી દ્વારા. ઓપરેટર અમને અહીં કેવી રીતે મદદ કરી શકે? એક નિયંત્રક બનાવવામાં આવે છે જે નેમસ્પેસમાં લેબલ દેખાવાની રાહ જુએ છે અને ઇન્ટરનેટ ઍક્સેસ માટે યોગ્ય નીતિ ઉમેરે છે.
3. સમાન પરિસ્થિતિ: ધારો કે આપણે ચોક્કસ ઉમેરવાની જરૂર છે કલંક, જો તે સમાન લેબલ ધરાવે છે (અમુક પ્રકારના ઉપસર્ગ સાથે). ઓપરેટર સાથેની ક્રિયાઓ સ્પષ્ટ છે...

કોઈપણ ક્લસ્ટરમાં, નિયમિત કાર્યો ઉકેલવા જોઈએ, અને અધિકાર આ ઓપરેટરોનો ઉપયોગ કરીને કરી શકાય છે.

વર્ણવેલ તમામ વાર્તાઓનો સારાંશ આપતાં, અમે એવા નિષ્કર્ષ પર આવ્યા છીએ કુબરનેટ્સમાં આરામદાયક કામ માટે તમને જરૂર છે: અ) એડ-ઓન્સ ઇન્સ્ટોલ કરો, b) ઓપરેટરોનો વિકાસ કરો (રોજિંદા એડમિન કાર્યો ઉકેલવા માટે).

કુબરનેટ્સ માટે નિવેદન કેવી રીતે લખવું?

સામાન્ય રીતે, યોજના સરળ છે:

... પરંતુ પછી તે તારણ આપે છે કે:

• કુબરનેટ્સ API એ એક બિન-તુચ્છ વસ્તુ છે જે માસ્ટર થવામાં ઘણો સમય લે છે;
• પ્રોગ્રામિંગ પણ દરેક માટે નથી (ગો ભાષાને પસંદગીની ભાષા તરીકે પસંદ કરવામાં આવી હતી કારણ કે તેના માટે એક ખાસ માળખું છે - ઓપરેટર SDK);
• પરિસ્થિતિ ફ્રેમવર્ક સાથે સમાન છે.

બોટમ લાઇન: નિયંત્રક લખવા માટે (ઓપરેટર) પાસે છે નોંધપાત્ર સંસાધનો ખર્ચ કરો સામગ્રીનો અભ્યાસ કરવો. આ "મોટા" ઓપરેટરો માટે વાજબી હશે - કહો, MySQL DBMS માટે. પરંતુ જો આપણે ઉપર વર્ણવેલ ઉદાહરણો યાદ રાખીએ (રહસ્યો જાહેર કરવા, ઈન્ટરનેટ પર પોડ્સ એક્સેસ કરવા...), જે આપણે પણ યોગ્ય રીતે કરવા માંગીએ છીએ, તો આપણે સમજીશું કે ખર્ચવામાં આવેલ પ્રયત્નો હવે આપણને જોઈતા પરિણામ કરતાં વધુ હશે:

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

શેલ-ઓપરેટર

તે કેવી રીતે કામ કરે છે? ક્લસ્ટરમાં શેલ-ઓપરેટર સાથે ગો બાઈનરી ધરાવતી પોડ છે. તેની બાજુમાં એક સેટ છે હુક્સ (તેમના વિશે વધુ વિગતો - નીચે જુઓ). શેલ-ઓપરેટર પોતે ચોક્કસ માટે સબ્સ્ક્રાઇબ કરે છે ઇવેન્ટ્સ Kubernetes 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 રૂપરેખાંકનો સાથે કામ કરવા માટે, ટેમ્પલેટ એન્જિન જરૂરી છે (પ્રથમ તબક્કે આ સરળ સેડ છે);
• ક્લસ્ટરોની સંખ્યામાં વધારા સાથે, સ્વચાલિત અપડેટની જરૂરિયાત આવી (સૌથી પહેલો ઉકેલ એ હતો કે સ્ક્રિપ્ટને ગિટમાં મૂકવી, તેને ક્રોનનો ઉપયોગ કરીને અપડેટ કરવી અને તેને ચલાવવી);
• પ્રોમિથિયસ માટે સમાન સ્ક્રિપ્ટ જરૂરી હતી (install-prometheus.sh), જો કે, તે હકીકત માટે નોંધપાત્ર છે કે તેને વધુ ઇનપુટ ડેટા, તેમજ તેમના સ્ટોરેજની જરૂર છે (સારી રીતે - કેન્દ્રિય અને ક્લસ્ટરમાં), અને કેટલાક ડેટા (પાસવર્ડ્સ) આપમેળે જનરેટ થઈ શકે છે:

  

• ક્લસ્ટરોની વધતી જતી સંખ્યામાં કંઈક ખોટું થવાનું જોખમ સતત વધી રહ્યું હતું, તેથી અમને સમજાયું કે ઇન્સ્ટોલર્સ (એટલે ​​​​કે બે સ્ક્રિપ્ટો: ઇન્ગ્રેસ અને પ્રોમિથિયસ માટે) સ્ટેજીંગની જરૂર હતી (ગીટમાં કેટલીક શાખાઓ, તેમને અનુરૂપમાં અપડેટ કરવા માટે ઘણા ક્રોન્સ: સ્થિર અથવા પરીક્ષણ ક્લસ્ટરો);
• с kubectl apply તેની સાથે કામ કરવું મુશ્કેલ બની ગયું છે કારણ કે તે ઘોષણાત્મક નથી અને માત્ર વસ્તુઓ બનાવી શકે છે, પરંતુ તેની સ્થિતિ અંગે નિર્ણય લઈ શકતી નથી/તેમને કાઢી નાખી શકતી નથી;
• અમારી પાસે કેટલાક કાર્યો ખૂટે છે જે અમે તે સમયે અમલમાં મૂક્યા ન હતા:
  • ક્લસ્ટર અપડેટ્સના પરિણામ પર સંપૂર્ણ નિયંત્રણ,
  • ક્લસ્ટર (શોધ) માંથી મેળવી શકાય તેવા ડેટાના આધારે કેટલાક પરિમાણો (ઇન્સ્ટોલેશન સ્ક્રિપ્ટ્સ માટે ઇનપુટ)નું સ્વચાલિત નિર્ધારણ,
  • સતત શોધના સ્વરૂપમાં તેનો તાર્કિક વિકાસ.

અમે અમારા અન્ય પ્રોજેક્ટના માળખામાં આ બધા સંચિત અનુભવને અમલમાં મૂક્યો - એડઓન ઓપરેટર.

એડઓન-ઓપરેટર

તે પહેલેથી જ ઉલ્લેખિત શેલ-ઓપરેટર પર આધારિત છે. આખી સિસ્ટમ આના જેવી લાગે છે:

શેલ-ઓપરેટર હુક્સમાં નીચેના ઉમેરવામાં આવે છે:

• મૂલ્યોનો સંગ્રહ,
• સુકાન ચાર્ટ,
• ઘટક કે વેલ્યુ સ્ટોર પર નજર રાખે છે અને - કોઈપણ ફેરફારોના કિસ્સામાં - હેલ્મને ચાર્ટને ફરીથી રોલ કરવા કહે છે.

આમ, અમે કુબરનેટ્સમાં કોઈ ઇવેન્ટ પર પ્રતિક્રિયા આપી શકીએ છીએ, હૂક લૉન્ચ કરી શકીએ છીએ અને આ હૂકમાંથી અમે સ્ટોરેજમાં ફેરફાર કરી શકીએ છીએ, જેના પછી ચાર્ટ ફરીથી ડાઉનલોડ કરવામાં આવશે. પરિણામી રેખાકૃતિમાં, અમે હુક્સના સમૂહ અને ચાર્ટને એક ઘટકમાં અલગ કરીએ છીએ, જેને આપણે કહીએ છીએ. મોડ્યુલ:

ત્યાં ઘણા મોડ્યુલો હોઈ શકે છે, અને તેમાં અમે વૈશ્વિક હુક્સ, વૈશ્વિક મૂલ્યો સ્ટોર અને એક ઘટક ઉમેરીએ છીએ જે આ વૈશ્વિક સ્ટોરનું નિરીક્ષણ કરે છે.

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

આ સ્કીમ એડ-ઓન્સ ઇન્સ્ટોલ કરવા માટેની બધી આવશ્યકતાઓને સંતોષે છે જે ઉપર જણાવેલ છે:

• સુકાન ટેમ્પ્લેટિંગ અને ઘોષણાત્મકતા માટે જવાબદાર છે.
• સ્વતઃ-અપડેટનો મુદ્દો વૈશ્વિક હૂકનો ઉપયોગ કરીને ઉકેલવામાં આવ્યો હતો, જે શેડ્યૂલ પર રજિસ્ટ્રીમાં જાય છે અને, જો તે ત્યાં નવી સિસ્ટમની છબી જુએ છે, તો તેને રોલઆઉટ કરે છે (એટલે ​​​​કે "પોતે").
• ક્લસ્ટરમાં સ્ટોરિંગ સેટિંગ્સનો ઉપયોગ કરીને અમલ કરવામાં આવે છે ConfigMap, જેમાં સ્ટોરેજ માટે પ્રાથમિક ડેટા હોય છે (સ્ટાર્ટઅપ સમયે તેઓ સ્ટોરેજમાં લોડ થાય છે).
• પાસવર્ડ જનરેશન, શોધ અને સતત શોધ સાથેની સમસ્યાઓ હૂકનો ઉપયોગ કરીને હલ કરવામાં આવી હતી.
• સ્ટેજિંગ ટૅગ્સ માટે આભાર પ્રાપ્ત થાય છે, જેને ડોકર બૉક્સની બહાર સપોર્ટ કરે છે.
• મેટ્રિક્સનો ઉપયોગ કરીને પરિણામનું નિરીક્ષણ કરવામાં આવે છે જેના દ્વારા આપણે સ્થિતિ સમજી શકીએ છીએ.

આ આખી સિસ્ટમ ગોમાં સિંગલ બાઈનરીના રૂપમાં અમલમાં છે, જેને એડ-ઓપરેટર કહેવામાં આવે છે. આ ડાયાગ્રામને સરળ બનાવે છે:

આ રેખાકૃતિમાં મુખ્ય ઘટક મોડ્યુલોનો સમૂહ છે (નીચે ગ્રે રંગમાં પ્રકાશિત). હવે આપણે થોડી મહેનત સાથે જરૂરી એડ-ઓન માટે મોડ્યુલ લખી શકીએ છીએ અને ખાતરી કરી શકીએ છીએ કે તે દરેક ક્લસ્ટરમાં ઇન્સ્ટોલ થશે, અપડેટ કરવામાં આવશે અને ક્લસ્ટરમાં જરૂરી ઘટનાઓનો પ્રતિસાદ આપી શકાશે.

"Flant" વાપરે છે એડઓન ઓપરેટર 70+ કુબરનેટ્સ ક્લસ્ટરો પર. વર્તમાન સ્થિતિ - આલ્ફા સંસ્કરણ. હવે અમે બીટા રીલીઝ કરવા માટે દસ્તાવેજીકરણ તૈયાર કરી રહ્યા છીએ, પરંતુ હાલ માટે રીપોઝીટરીમાં ઉદાહરણો ઉપલબ્ધ છે, જેના આધારે તમે તમારું પોતાનું એડઓન બનાવી શકો છો.

એડઓન-ઓપરેટર માટે હું મોડ્યુલો ક્યાંથી મેળવી શકું? અમારી લાઇબ્રેરી પ્રકાશિત કરવી એ અમારા માટે આગળનો તબક્કો છે; અમે ઉનાળામાં આ કરવાની યોજના બનાવીએ છીએ.

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

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

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

PS

અમારા બ્લોગ પર અન્ય અહેવાલો:

• «ડેટાબેસેસ અને કુબરનેટ્સ»; (દિમિત્રી સ્ટોલ્યારોવ; હાઇલોડ++ પર નવેમ્બર 8, 2018);
• «મોનિટરિંગ અને કુબરનેટ્સ»; (દિમિત્રી સ્ટોલ્યારોવ; રૂટકોન્ફ ખાતે 28 મે, 2018);
• «કુબરનેટ્સ અને ગિટલેબ સાથે CI/CD શ્રેષ્ઠ વ્યવહારો»; (દિમિત્રી સ્ટોલ્યારોવ; હાઇલોડ++ પર નવેમ્બર 7, 2017);
• «નાના પ્રોજેક્ટ્સમાં કુબરનેટ્સ સાથેનો અમારો અનુભવ»; (દિમિત્રી સ્ટોલ્યારોવ; રૂટકોન્ફ ખાતે જૂન 6, 2017).

તમને નીચેના પ્રકાશનોમાં પણ રસ હોઈ શકે છે:

• «શેલ-ઓપરેટરનો પરિચય: કુબરનેટ્સ માટે ઓપરેટર બનાવવાનું સરળ બન્યું છે».

સોર્સ: www.habr.com