કુબરનેટ્સ: મેનિફેસ્ટ, હેલ્મ અને એઆઈ-સંચાલિત ઓર્કેસ્ટ્રેશન

નફો:

મૂળભૂત વસ્તુઓ (પોડ, ડિપ્લોયમેન્ટ, સર્વિસ, કોન્ફિગમેપ, સિક્રેટ, નેમસ્પેસ) અને કુબરનેટ્સની ઘોષણાત્મક ફિલસૂફી સમજવાની અને કૃત્રિમ બુદ્ધિ માટે નક્કર મેનિફેસ્ટ ઉત્પન્ન કરવાની ક્ષમતા
ઉત્પાદન માટે મેનિફેસ્ટ તૈયાર કરવાની ક્ષમતા અને સંસાધન મર્યાદાઓ, આરોગ્ય તપાસો (પ્રોબ્સ), નિશ્ચિત ઇમેજ ટૅગ્સ અને સાંકડી RBAC સાથે સુરક્ષિત
અમલ પહેલા સાચા સંદર્ભને ચકાસવાની ક્ષમતા અને ડ્રાય-રન/ડિફ સાથે ડ્રાય-રન શિસ્ત લાગુ કરવાની ક્ષમતા

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

પરંતુ કુબરનેટ્સમાં, ખોટા મેનિફેસ્ટનો અર્થ થાય છે કે સંપૂર્ણ સેવા ઊભી કરવામાં નિષ્ફળ થવું, ખોટી રીતે સ્કેલિંગ કરવું અથવા નબળાઈ છોડી દેવી. AI દ્વારા ઉત્પાદિત દરેક મેનિફેસ્ટને સમજવાની અને ચકાસવાની જવાબદારી તમારી છે - ખાસ કરીને kubectl લાગુ કરતાં પહેલાં.

કુબરનેટ્સ કોર ઑબ્જેક્ટ્સ

કુબરનેટ્સનું ઑડિટ કરવા માટે, તમારે મુખ્ય ખ્યાલો જાણવી જોઈએ:

પોડ: સૌથી નાનું કાર્યકારી એકમ; તેમાં એક અથવા અનેક કન્ટેનર હોય છે. સામાન્ય રીતે, પોડનો સીધો ઉપયોગ થતો નથી, પરંતુ તેનું સંચાલન કરતી મૂળ વસ્તુઓનો ઉપયોગ થાય છે.
ડિપ્લોયમેન્ટ: એપ્લિકેશનની કેટલી નકલો ચાલશે, તે કઈ છબીનો ઉપયોગ કરશે અને તેને કેવી રીતે અપડેટ કરવામાં આવશે તે વ્યાખ્યાયિત કરે છે. જો પોડ ક્રેશ થાય છે તો તે આપોઆપ તેને ફરીથી બનાવશે.
સેવા: એક નિશ્ચિત નેટવર્ક સરનામું પ્રદાન કરે છે અને પોડ્સને લોડ બેલેન્સિંગ કરે છે; ભલે શીંગો આવે અને જાય, પણ પ્રવેશ સરનામું બદલાતું નથી.
ConfigMap અને સિક્રેટ: રૂપરેખાંકન મૂલ્યો અને ગુપ્ત માહિતીને પોડ્સથી અલગ રાખે છે. ConfigMap સ્પષ્ટ સેટિંગ્સ માટે છે, સિક્રેટ સંવેદનશીલ મૂલ્યો માટે છે.
નેમસ્પેસ: વિસ્તાર કે જે તાર્કિક રીતે સંસાધનોને વિભાજિત અને અલગ કરે છે (દા.ત. dev, prod).
પ્રવેશ: નિયમ સેટ જે ક્લસ્ટરમાં સેવાઓ માટે બાહ્ય વિશ્વમાંથી HTTP ટ્રાફિકને નિર્દેશિત કરે છે.

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

શા માટે ત્યાં ઘણા બધા પદાર્થો છે? કારણ કે કુબરનેટસની મુખ્ય ફિલસૂફી ઘોષણાત્મક છે: તમે "સિસ્ટમને આખરે કેવી રીતે જોવા માંગો છો" તે વ્યાખ્યાયિત કરો છો (દા.ત. "હંમેશા આ એપ્લિકેશનની 3 નકલો ચાલુ રાખો"), જ્યારે કુબરનેટ્સ સતત વર્તમાન સ્થિતિને તે ઇચ્છિત સ્થિતિની નજીક લઈ જાય છે. જો પોડ મૃત્યુ પામે છે, તો તે એક નવું બનાવે છે; જો નોડ નીચે જાય છે, તો તે વર્કલોડને બીજા નોડ પર ખસેડે છે. તેથી જ મેનિફેસ્ટ એ "ડુ" આદેશો નથી, પરંતુ "તેને આના જેવું રહેવા દો" વાનગીઓ છે. AI દ્વારા ઉત્પાદિત મેનિફેસ્ટ્સ વાંચતી વખતે આ તફાવતને સમજવું મહત્વપૂર્ણ છે: દરેક ડોમેન સિસ્ટમની ઇચ્છિત સ્થિતિના ભાગનું વર્ણન કરે છે. ખોટા ડોમેનનો અર્થ છે કે કુબરનેટ્સ ખોટા ધ્યેય તરફ કામ કરી રહ્યું છે — અને તે ધ્યેય શાંતિપૂર્વક, સતત અમલમાં છે.

ટીપ: કુબરનેટ્સમાં, સૌથી મહત્વપૂર્ણ સલામત પરીક્ષણ સાધન છે kubectl apply --dry-run=server -f file.yaml: તે બતાવે છે કે સર્વર સ્વીકારશે કે કેમ અને ખરેખર મેનિફેસ્ટ લાગુ કર્યા વિના શું કરવું. પ્રોડ પર મેનિફેસ્ટ લાગુ કરતાં પહેલાં ડ્રાય-રન અને ક્યુબેક્ટલ ડિફ ચલાવવાની ખાતરી કરો.

સ્ટેપ બાય સ્ટેપ: AI સાથે મેનિફેસ્ટ બનાવવું

એપ્લિકેશન અને જરૂરિયાતનું વર્ણન કરો. છબીનું નામ, પોર્ટ, કેટલી પ્રતિકૃતિઓ, સંસાધન મર્યાદા (CPU/મેમરી).
જમાવટ + સેવાની વિનંતી કરો. સામાન્ય રીતે બંને એકસાથે જરૂરી છે.
અલગ રૂપરેખા અને ગુપ્ત. ConfigMap માટે સેટિંગ્સ, સિક્રેટ માટે સંવેદનશીલ મૂલ્યો.
આરોગ્ય તપાસો ઉમેરો. livenessProbe (શું તે જીવંત છે) અને રેડીનેસપ્રોબ (શું તે ટ્રાફિક માટે તૈયાર છે) મહત્વપૂર્ણ છે.
સંસાધન મર્યાદા સેટ કરો. વિનંતીઓ/મર્યાદા વિના પોડ સમગ્ર નોડનો ઉપયોગ કરી શકે છે.
`--ડ્રાય-રન` અને `ડિફ` વડે ચકાસો, પછી અરજી કરો. ટેસ્ટ નેમસ્પેસમાં પ્રથમ.

સુરક્ષા: કુબરનેટ્સ-વિશિષ્ટ જોખમો

ગુપ્ત ખરેખર ગુપ્ત નથી - તે માત્ર આધાર64 છે. કુબરનેટ્સ સિક્રેટ ઑબ્જેક્ટ બેઝ64 મૂલ્યોને એન્કોડ કરે છે; આ એન્ક્રિપ્શન નથી, તે સરળતાથી ડિક્રિપ્ટ થાય છે. સાચી ગોપનીયતા માટે, etcd એન્ક્રિપ્શન અને બાહ્ય વૉલ્ટ (વૉલ્ટ, ક્લાઉડ સિક્રેટ મેનેજર) જરૂરી છે. ગિટને સીધેસીધું સિક્રેટ મેનિફેસ્ટ ક્યારેય મોકલશો નહીં (ત્યાં આના માટે ઉકેલો છે જેમ કે સીલબંધ રહસ્યો/બાહ્ય રહસ્યો).
સંસાધન મર્યાદા સેટ કરો. મર્યાદા વિનાનો પોડ મેમરી લીક સાથે સમગ્ર નોડને ક્રેશ કરી શકે છે.
ન્યૂનતમ સત્તા (RBAC). રોલ-બેઝ્ડ એક્સેસ કંટ્રોલ સાથે, દરેક સેવા/વપરાશકર્તા પાસે માત્ર તે જ પરવાનગીઓ હોય છે જેની તેને જરૂર હોય છે. AI ક્યારેક મોટા ક્લસ્ટર-એડમિન આપે છે; આને સંકુચિત કરો.
`નવીનતમ` ઇમેજ ટૅગનો ઉપયોગ કરશો નહીં. તમે જાણતા નથી કે કયું સંસ્કરણ ચાલી રહ્યું છે અને તમે તેને પાછું રોલ કરી શકતા નથી.

સાવધાન: kubectl કાઢી નાખવું અથવા ખોટી અરજી લાઇવ ડિપ્લોયમેન્ટને નષ્ટ કરી શકે છે. આદેશો ચલાવતા પહેલા તમે કઈ નેમસ્પેસમાં છો તેની ખાતરી કરો (kubectl config current-context); ઉત્પાદન સંદર્ભમાં આકસ્મિક કાર્ય એ સામાન્ય આપત્તિ છે.

રો મેનિફેસ્ટ વિ. હેલ્મ ટેબલ

માપદંડ

કાચો YAML મેનિફેસ્ટ

સુકાન ચાર્ટ

સ્થાપન

kubectl લાગુ કરો -f

સુકાન સ્થાપિત કરો

મલ્ટીમીડિયા (dev/prod)

કોપી-પેસ્ટ, ભૂલની સંભાવના

સિંગલ ચાર્ટ, વિવિધ મૂલ્યો.yaml

સંસ્કરણ/રોલબેક

હાથ દ્વારા

સુકાન રોલબેક સાથે સરળ

શીખવાની કર્વ

નીચું

મધ્યમ

જ્યારે

નાનું, એકલ વાતાવરણ

મલ્ટી-મીડિયા, પુનરાવર્તિત સેવા

ત્રણ નાના કેસો

કેસ 1 - ક્રેશ થયેલ સેવાનું રહસ્ય. એક પોડ સતત રીબૂટ થઈ રહ્યું હતું (CrashLoopBackOff). ટીમે AI ને લોગ્સ અને મેનિફેસ્ટ આપ્યા; એઆઈએ બતાવ્યું કે પોડને ક્યારેય "તૈયાર" માનવામાં આવતું ન હતું કારણ કે રેડીનેસપ્રોબ ખોટા પોર્ટને જોઈ રહી હતી. તેઓએ પોર્ટને ઠીક કર્યું, સેવા 10 મિનિટમાં સ્થિર થઈ ગઈ. આ સંબંધ મેન્યુઅલી સ્થાપિત કરવામાં કલાકો લાગી શકે છે.

કેસ 2 - મર્યાદા સેટ ન કરવાથી ગાંઠ તૂટી ગઈ. જમાવટમાં કોઈ મર્યાદા ન હતી; મેમરી લીકથી પોડ ફૂલી ગયો અને સમગ્ર નોડ ક્રેશ થઈ ગયો, પડોશી સેવાઓ પણ નીચે લાવી. આ ઘટના પછી, તેઓએ AI ને "તમામ ડિપ્લોયમેન્ટ્સમાં વ્યાજબી CPU/મેમરી વિનંતીઓ અને મર્યાદાઓ ઉમેરો" અને તેને પ્રમાણભૂત બનાવ્યું. એક ખૂટતી લાઇન ડાઉનટાઇમના કલાકો ખર્ચ કરે છે.

કેસ 3 — મોટા RBAC કેપ્ચર. તપાસ દરમિયાન, AI દ્વારા જનરેટ કરાયેલ સર્વિસ એકાઉન્ટ મેનિફેસ્ટ ક્લસ્ટર-એડમિન ભૂમિકા સાથે જોડાયેલું હોવાનું જણાયું હતું - એટલે કે સેવા સમગ્ર ક્લસ્ટરનું સંચાલન કરી શકે છે. ટીમે તેમની નેમસ્પેસમાં ફક્ત પોડ્સ વાંચવાની પરવાનગીને સંકુચિત કરી. ઓછામાં ઓછા વિશેષાધિકારના સિદ્ધાંતે સુરક્ષાની નબળાઈને બંધ કરી દીધી છે.

ચાર નકલ કરી શકાય તેવા નમૂનાઓ

1) જમાવટ + સેવા ઉત્પાદન:

કુબરનેટ્સ માટે ડિપ્લોયમેન્ટ અને સર્વિસ મેનિફેસ્ટ લખો. એપ્લિકેશન: [એડી], છબી: [છબી: નિશ્ચિત-સંસ્કરણ], પોર્ટ: [એક્સ], પ્રતિકૃતિ: [એન]. નિયમો:- CPU/મેમરી વિનંતીઓ અને મર્યાદાઓ ઉમેરો.- livenessProbe અને રેડીનેસપ્રોબ વ્યાખ્યાયિત કરો.- ConfigMap માંથી ગોઠવણી વાંચો, સિક્રેટ ઑબ્જેક્ટમાંથી ગુપ્ત; મેનિફેસ્ટમાં મૂલ્યોને એમ્બેડ કરશો નહીં, પ્લેસહોલ્ડર્સનો ઉપયોગ કરો. - ઇમેજ ટેગ ": લેટેસ્ટ" નો ઉપયોગ કરશો નહીં. વર્ણન સાથે આપો.

2) મેનિફેસ્ટ ભૂલ ઉકેલવા:

વર્તમાન પોડ [CrashLoopBackOff/Pending/ImagePullBackOff] સ્થિતિમાં છે. નીચેના મેનિફેસ્ટ અને 'kubectl describe' આઉટપુટ મુજબ, સંભવિત ક્રમમાં સંભવિત મૂળ કારણોની યાદી બનાવો અને દરેક માટે verify આદેશ જારી કરો. મેનિફેસ્ટ: [YAML] વર્ણન કરો: [આઉટપુટ]

3) સુરક્ષા/અખંડિતતા તપાસ:

આ કુબરનેટ્સ મેનિફેસ્ટ તપાસો: શું સંસાધન મર્યાદા ખૂટે છે, શું તે પ્રોબ ખૂટે છે, શું ત્યાં કોઈ : નવીનતમ ટેગ છે, શું ત્યાં વધુ પડતી વ્યાપક RBAC/પરવાનગી છે, શું ગુપ્ત મેનિફેસ્ટમાં એમ્બેડ થયેલ છે? તારણો મહત્વના ક્રમમાં અને સુધારા સાથે લખો. મેનિફેસ્ટ: [YAML]

4) હેલ્મ ચાર્ટમાં રૂપાંતર:

નીચેના કાચા મેનિફેસ્ટને ફરીથી વાપરી શકાય તેવા હેલ્મ ચાર્ટમાં કન્વર્ટ કરો: કયા મૂલ્યો values.yaml (ઇમેજ, પ્રતિકૃતિ, સ્ત્રોત, પર્યાવરણ) પર જવા જોઈએ? ચાર્ટ માળખું અને નમૂના મૂલ્યો બતાવો. yaml. મેનિફેસ્ટ: [YAML]

નબળા પ્રોમ્પ્ટ / મજબૂત પ્રોમ્પ્ટ

નબળા: "મારી અરજી માટે કુબરનેટ્સ YAML લખો."

પરિણામ: નો-પ્રોબ, નો-લિમિટ ડિપ્લોયમેન્ટ સાથે : લેટેસ્ટ ટેગ, સિક્રેટ પ્લેન એમ્બેડ કરવું; ઉત્પાદનમાં અસુરક્ષિત અને નાજુક.

સશક્ત: "કુબરનેટ્સ ડિપ્લોયમેન્ટ + સેવા લખો. છબી myapp:1.4.2, 3 પ્રતિકૃતિઓ, 8080 પોર્ટ્સ. CPU 100m-500m, મેમરી 128Mi-512Mi વિનંતીઓ/મર્યાદાઓ ઉમેરો. /healthz માટે જીવંતતા તપાસ મૂકો, ઑબ્જેક્ટ માટે તૈયાર / વાંચો. તેને મેનિફેસ્ટમાં એમ્બેડ કરો.

તફાવત: બીજું પ્રોમ્પ્ટ સંસ્કરણ સ્કેલ, સંસાધન મર્યાદા, આરોગ્ય તપાસો અને ગુપ્ત નિયમ આપે છે; આઉટપુટ ઉત્પાદનની નજીક અને સલામત છે.

સામાન્ય ભૂલો

સંસાધન મર્યાદા સેટ નથી. એક પોડ સમગ્ર નોડનો ઉપયોગ કરી શકે છે.
આરોગ્ય તપાસ (તપાસ) ઉમેરતા નથી. કુબરનેટ્સ ક્રેશ થયેલ/તૈયાર નથી પોડ શોધી શકતા નથી.
`:નવીનતમ` ટૅગ. તે અસ્પષ્ટ બની જાય છે કે કયું સંસ્કરણ ચાલી રહ્યું છે, તેને પાછું ફેરવી શકાતું નથી.
ગિટને સીધું રહસ્ય મોકલવું. Base64 એ એન્ક્રિપ્શન નથી; દરેક તેને હલ કરે છે.
ખોટા સંદર્ભ/નેમસ્પેસમાં આદેશો ચલાવી રહ્યા છે. ઉત્પાદનમાં ક્રેશ થવાની સૌથી સામાન્ય રીત.
`--ડ્રાય-રન`/`ડિફ` અવગણવું. અમલીકરણ પહેલા શું થશે તે જોતા નથી.

સારાંશમાં

કુબરનેટ્સ એક શક્તિશાળી પરંતુ જટિલ ઓર્કેસ્ટ્રેટર છે જે ક્લસ્ટરમાં કન્ટેનરને આપમેળે ગોઠવે છે, સ્કેલ કરે છે અને ઑપ્ટિમાઇઝ કરે છે; દરેક વસ્તુને મેનિફેસ્ટ YAML દ્વારા વ્યાખ્યાયિત કરવામાં આવે છે, જેને હેલ્મ ટેમ્પલેટાઇઝ કરે છે. AI ઝડપથી ડિપ્લોયમેન્ટ/સર્વિસ મેનિફેસ્ટ અને હેલ્મ ચાર્ટ બનાવે છે, રહસ્યમય બગ્સ ઉકેલે છે — પરંતુ તમારે સ્પષ્ટપણે સંસાધન મર્યાદા, આરોગ્ય તપાસ, અપરિવર્તનશીલ ઇમેજ ટેગ, સાંકડી RBAC અને ગુપ્ત સુરક્ષા નિયમો માટે પૂછવું પડશે. --ડ્રાય-રન, ડિફ અને યોગ્ય સંદર્ભ તપાસ એ ટેવો છે જે પ્રોડ ક્રેશને અટકાવે છે.

એપ્લિકેશન કાર્ય

AI પાસે "ડિપ્લોયમેન્ટ + સર્વિસ જનરેશન" ટેમ્પલેટ સાથે નમૂના એપ્લિકેશન માટે મેનિફેસ્ટ જનરેટ કરો. પછી: (1) તેને "સિક્યોરિટી/સેનિટી ચેક" ટેમ્પલેટ સાથે સંસાધન મર્યાદા, ચકાસણી, :લેટેસ્ટ અને ગુપ્ત માટે તપાસો; (2) જો શક્ય હોય તો ટેસ્ટ ક્લસ્ટર/મિનીક્યુબ પર kubectl apply --dry-run=server ચલાવો અને આઉટપુટ વાંચો; (3) તમને ગુમ થયેલ બે સૌથી મહત્વપૂર્ણ સલામતી/મજબૂત વસ્તુઓની નોંધ લો.

ચેકલિસ્ટ

[ ] મેં મારી વિનંતીમાં ઇમેજ વર્ઝન, પ્રતિકૃતિઓની સંખ્યા, પોર્ટ અને સંસાધન મર્યાદા ઉમેર્યા છે.
[ ] મેં મેનિફેસ્ટમાં જીવંતતા અને તૈયારીની તપાસ ઉમેરી.
[ ] ઇમેજ ટેગ નિશ્ચિત; મેં ઉપયોગ કર્યો નથી :latest.
[ ] ગુપ્ત મેનિફેસ્ટમાં જડિત નથી; મેં સિક્રેટ ઑબ્જેક્ટ/બાહ્ય વૉલ્ટનો ઉપયોગ કર્યો.
[ ] મેં RBAC/પરમિશનને ન્યૂનતમ પરવાનગીઓ સુધી સંકુચિત કરી છે.
અરજી કરતા પહેલા, મેં ખરાઈ કરી કે હું સાચા સંદર્ભમાં હતો અને તે --dry-run/diff આઉટપુટ.