കുബർനെറ്റസ്: മാനിഫെസ്റ്റ്, ഹെൽം, AI- പവർഡ് ഓർക്കസ്ട്രേഷൻ

നേട്ടങ്ങൾ:

• കുബെർനെറ്റസിൻ്റെ അടിസ്ഥാന വസ്തുക്കളും (പോഡ്, വിന്യാസം, സേവനം, കോൺഫിഗ്‌മാപ്പ്, രഹസ്യം, നെയിംസ്‌പേസ്) എന്നിവയും പ്രഖ്യാപന തത്ത്വചിന്തയും മനസിലാക്കാനും കൃത്രിമബുദ്ധിക്ക് സോളിഡ് മാനിഫെസ്റ്റുകൾ നിർമ്മിക്കാനുമുള്ള കഴിവ്
• റിസോഴ്‌സ് പരിധികൾ, ആരോഗ്യ പരിശോധനകൾ (പ്രോബുകൾ), ഫിക്സഡ് ഇമേജ് ടാഗുകൾ, ഇടുങ്ങിയ RBAC എന്നിവ ഉപയോഗിച്ച് മാനിഫെസ്റ്റുകൾ ഉൽപ്പാദിപ്പിക്കാനും സുരക്ഷിതമാക്കാനുമുള്ള കഴിവ്
• നിർവ്വഹിക്കുന്നതിന് മുമ്പ് ശരിയായ സന്ദർഭം പരിശോധിക്കാനും ഡ്രൈ-റൺ/ഡിഫ് ഉപയോഗിച്ച് ഡ്രൈ-റൺ അച്ചടക്കം പ്രയോഗിക്കാനുമുള്ള കഴിവ്

ഒരു കണ്ടെയ്നർ പ്രവർത്തിപ്പിക്കാൻ എളുപ്പമാണ്. എന്നാൽ ഡസൻ കണക്കിന് സെർവറുകളിലുടനീളം നൂറുകണക്കിന് കണ്ടെയ്നറുകൾ വ്യാപിപ്പിക്കുന്ന ഒരു സിസ്റ്റം സ്ഥാപിക്കുന്നത്, അവയിലൊന്ന് ക്രാഷാകുമ്പോൾ യാന്ത്രികമായി പുനരാരംഭിക്കുകയും ലോഡ് കൂടുമ്പോൾ അത് ആവർത്തിക്കുകയും പൂജ്യം പ്രവർത്തനരഹിതമായി അപ്‌ഡേറ്റ് ചെയ്യുകയും ചെയ്യുന്നുണ്ടോ? അതാണ് ഓർക്കസ്ട്രേഷൻ, വ്യവസായ സ്റ്റാൻഡേർഡ് ടൂൾ കുബർനെറ്റസ് (ചുരുക്കത്തിൽ K8s) ആണ് - ഒരു ക്ലസ്റ്ററിലുടനീളം കണ്ടെയ്‌നറുകൾ സ്വയമേവ വിന്യസിക്കുകയും സ്കെയിലുചെയ്യുകയും നിയന്ത്രിക്കുകയും ചെയ്യുന്ന പ്ലാറ്റ്‌ഫോം. Kubernetes ശക്തവും എന്നാൽ സങ്കീർണ്ണവുമാണ്: എല്ലാം നിർവചിച്ചിരിക്കുന്നത് നീളമുള്ള, ഇൻഡൻ്റേഷൻ സെൻസിറ്റീവ് YAML ഫയലുകളാൽ — മാനിഫെസ്റ്റുകൾ എന്ന് വിളിക്കപ്പെടുന്നവയാണ്. ഇവിടെയാണ് AI ശുദ്ധവായു ശ്വസിക്കുന്നത്; ശരിയായ സന്ദർഭത്തിൽ, അത് ഈ മാനിഫെസ്റ്റുകളെ വേഗത്തിൽ സൃഷ്ടിക്കുകയും അവയുടെ നിഗൂഢമായ പിശകുകൾ ഡീകോഡ് ചെയ്യുകയും ചെയ്യുന്നു.

എന്നാൽ കുബെർനെറ്റസിൽ, ഒരു തെറ്റായ മാനിഫെസ്റ്റ് അർത്ഥമാക്കുന്നത് ഒരു മുഴുവൻ സേവനവും നിലകൊള്ളുന്നതിൽ പരാജയപ്പെടുക, തെറ്റായി സ്കെയിൽ ചെയ്യുക അല്ലെങ്കിൽ ഒരു അപകടസാധ്യത ഉപേക്ഷിക്കുക എന്നിവയാണ്. AI ഉത്പാദിപ്പിക്കുന്ന ഓരോ മാനിഫെസ്റ്റും മനസ്സിലാക്കുകയും പരിശോധിക്കുകയും ചെയ്യേണ്ടത് നിങ്ങളുടെ ഉത്തരവാദിത്തമാണ് - പ്രത്യേകിച്ചും kubectl പ്രയോഗിക്കുന്നതിന് മുമ്പ്.

കുബർനെറ്റസ് പ്രധാന വസ്തുക്കൾ

Kubernetes ഓഡിറ്റ് ചെയ്യുന്നതിന്, നിങ്ങൾ പ്രധാന ആശയങ്ങൾ അറിഞ്ഞിരിക്കണം:

• പോഡ്: ഏറ്റവും ചെറിയ പ്രവർത്തന യൂണിറ്റ്; അതിൽ ഒന്നോ അതിലധികമോ കണ്ടെയ്നറുകൾ അടങ്ങിയിരിക്കുന്നു. സാധാരണയായി, പോഡ് നേരിട്ട് ഉപയോഗിക്കാറില്ല, പക്ഷേ അത് കൈകാര്യം ചെയ്യുന്ന പാരൻ്റ് ഒബ്‌ജക്റ്റുകളാണ് ഉപയോഗിക്കുന്നത്.
• വിന്യാസം: ഒരു ആപ്ലിക്കേഷൻ്റെ എത്ര പകർപ്പുകൾ പ്രവർത്തിക്കും, ഏത് ചിത്രം ഉപയോഗിക്കും, അത് എങ്ങനെ അപ്‌ഡേറ്റ് ചെയ്യപ്പെടും എന്നിവ നിർവചിക്കുന്നു. ഒരു പോഡ് തകരാറിലായാൽ അത് യാന്ത്രികമായി പുനഃസൃഷ്ടിക്കും.
• സേവനം: ഒരു നിശ്ചിത നെറ്റ്‌വർക്ക് വിലാസവും പോഡുകളിലേക്ക് ലോഡ് ബാലൻസും നൽകുന്നു; പോഡുകൾ വന്നാലും പോയാലും പ്രവേശന വിലാസം മാറുന്നില്ല.
• കോൺഫിഗറേഷൻ മാപ്പും രഹസ്യവും: കോൺഫിഗറേഷൻ മൂല്യങ്ങളും രഹസ്യ വിവരങ്ങളും പോഡുകളിൽ നിന്ന് വേറിട്ട് സൂക്ഷിക്കുന്നു. ConfigMap വ്യക്തമായ ക്രമീകരണങ്ങൾക്കുള്ളതാണ്, രഹസ്യം സെൻസിറ്റീവ് മൂല്യങ്ങൾക്കുള്ളതാണ്.
• നെയിംസ്പേസ്: വിഭവങ്ങളെ യുക്തിപരമായി വിഭജിക്കുകയും ഒറ്റപ്പെടുത്തുകയും ചെയ്യുന്ന ഏരിയ (ഉദാ. ദേവ്, പ്രോഡ്).
• പ്രവേശനം: പുറം ലോകത്തിൽ നിന്നുള്ള HTTP ട്രാഫിക്കിനെ ക്ലസ്റ്ററിലെ സേവനങ്ങളിലേക്ക് നയിക്കുന്ന റൂൾ സെറ്റ്.

കുബർനെറ്റസിൻ്റെ "പാക്കേജ് മാനേജർ" ആണ് ഹെൽം: ആവർത്തിച്ചുള്ള മാനിഫെസ്റ്റുകൾ (ചാർട്ടുകൾ) ടെംപ്ലേറ്റ് ചെയ്യാനും ഒരൊറ്റ കമാൻഡ് ഉപയോഗിച്ച് വ്യത്യസ്ത പരിതസ്ഥിതികളിൽ വ്യത്യസ്ത മൂല്യങ്ങളോടെ അവ ഇൻസ്റ്റാൾ ചെയ്യാനും ഇത് നിങ്ങളെ അനുവദിക്കുന്നു. AI റോ മാനിഫെസ്റ്റും ഹെൽം ചാർട്ടും നിർമ്മിക്കുന്നു.

എന്തുകൊണ്ടാണ് ഇത്രയധികം വസ്തുക്കൾ ഉള്ളത്? കാരണം, കുബർനെറ്റസിൻ്റെ പ്രധാന തത്ത്വചിന്ത ഡിക്ലറേറ്റീവ് ആണ്: "സിസ്റ്റം ആത്യന്തികമായി എങ്ങനെ കാണണമെന്ന് നിങ്ങൾ ആഗ്രഹിക്കുന്നു" (ഉദാ. "ഈ ആപ്ലിക്കേഷൻ്റെ 3 കോപ്പികൾ എപ്പോഴും പ്രവർത്തിക്കുന്നു") നിങ്ങൾ നിർവചിക്കുന്നു, അതേസമയം കുബർനെറ്റസ് നിലവിലെ അവസ്ഥയെ ആവശ്യമുള്ള അവസ്ഥയിലേക്ക് തുടർച്ചയായി നീക്കുന്നു. ഒരു പോഡ് മരിക്കുകയാണെങ്കിൽ, അത് പുതിയൊരെണ്ണം സൃഷ്ടിക്കുന്നു; ഒരു നോഡ് താഴ്ന്നാൽ, അത് ജോലിഭാരത്തെ മറ്റൊരു നോഡിലേക്ക് നീക്കുന്നു. അതുകൊണ്ടാണ് മാനിഫെസ്റ്റുകൾ "ചെയ്യുക" കമാൻഡുകൾ അല്ല, മറിച്ച് "ഇത് ഇങ്ങനെയാകട്ടെ" പാചകക്കുറിപ്പുകളാണ്. AI ഉത്പാദിപ്പിക്കുന്ന മാനിഫെസ്റ്റുകൾ വായിക്കുമ്പോൾ ഈ വ്യത്യാസം മനസ്സിലാക്കുന്നത് വളരെ പ്രധാനമാണ്: ഓരോ ഡൊമെയ്‌നും സിസ്റ്റത്തിൻ്റെ ആവശ്യമുള്ള അവസ്ഥയുടെ ഒരു ഭാഗം വിവരിക്കുന്നു. ഒരു തെറ്റായ ഡൊമെയ്ൻ അർത്ഥമാക്കുന്നത് കുബെർനെറ്റസ് ഒരു തെറ്റായ ലക്ഷ്യത്തിലേക്കാണ് പ്രവർത്തിക്കുന്നത് - ആ ലക്ഷ്യം നിശബ്ദമായി, സ്ഥിരമായി നടപ്പിലാക്കുന്നു.

നുറുങ്ങ്: Kubernetes-ൽ, ഏറ്റവും പ്രധാനപ്പെട്ട സുരക്ഷിതമായ ടെസ്റ്റിംഗ് ടൂൾ kubectl apply --dry-run=server -f file.yaml ആണ്: ഇത് സെർവർ സ്വീകരിക്കുമോ എന്നും മാനിഫെസ്റ്റ് പ്രയോഗിക്കാതെ എന്താണ് ചെയ്യേണ്ടതെന്നും ഇത് കാണിക്കുന്നു. പ്രോഡിലേക്ക് ഒരു മാനിഫെസ്റ്റ് പ്രയോഗിക്കുന്നതിന് മുമ്പ് ഡ്രൈ-റൺ, kubectl diff എന്നിവ റൺ ചെയ്യുന്നത് ഉറപ്പാക്കുക.

ഘട്ടം ഘട്ടമായി: AI ഉപയോഗിച്ച് മാനിഫെസ്റ്റുകൾ സൃഷ്ടിക്കുന്നു

1. അപേക്ഷയും ആവശ്യവും വിവരിക്കുക. ചിത്രത്തിൻ്റെ പേര്, പോർട്ട്, എത്ര പകർപ്പുകൾ, ഉറവിട പരിധികൾ (സിപിയു/മെമ്മറി).
2. വിന്യാസം + സേവനം അഭ്യർത്ഥിക്കുക. സാധാരണയായി രണ്ടും ഒരുമിച്ച് ആവശ്യമാണ്.
3. കോൺഫിഗേഷനും രഹസ്യവും വേർതിരിക്കുക. കോൺഫിഗ്മാപ്പിലേക്കുള്ള ക്രമീകരണങ്ങൾ, രഹസ്യത്തിലേക്കുള്ള സെൻസിറ്റീവ് മൂല്യങ്ങൾ.
4. ആരോഗ്യ പരിശോധനകൾ ചേർക്കുക. livenessProbe (ഇത് ലൈവ് ആണോ), റെഡിനെസ് പ്രോബ് (ഇത് ട്രാഫിക്കിന് തയ്യാറാണോ) എന്നിവ നിർണായകമാണ്.
5. ഒരു റിസോഴ്സ് പരിധി സജ്ജമാക്കുക. അഭ്യർത്ഥനകളോ പരിധികളോ ഇല്ലാതെ ഒരു പോഡിന് മുഴുവൻ നോഡും ഉപയോഗിക്കാനാകും.
6. `--ഡ്രൈ-റൺ`, `ഡിഫ്` എന്നിവ ഉപയോഗിച്ച് പരിശോധിച്ചുറപ്പിക്കുക, തുടർന്ന് പ്രയോഗിക്കുക. ടെസ്റ്റ് നെയിംസ്പേസിൽ ആദ്യം.

സുരക്ഷ: കുബർനെറ്റസ്-നിർദ്ദിഷ്ട അപകടസാധ്യതകൾ

1. രഹസ്യം യഥാർത്ഥത്തിൽ രഹസ്യമല്ല - അത് അടിസ്ഥാന64 മാത്രമാണ്. Kubernetes Secret object base64 മൂല്യങ്ങൾ എൻകോഡ് ചെയ്യുന്നു; ഇത് എൻക്രിപ്ഷൻ അല്ല, ഇത് എളുപ്പത്തിൽ ഡീക്രിപ്റ്റ് ചെയ്യപ്പെടുന്നു. യഥാർത്ഥ സ്വകാര്യതയ്ക്കായി, etcd എൻക്രിപ്ഷനും ബാഹ്യ നിലവറയും (വോൾട്ട്, ക്ലൗഡ് രഹസ്യ മാനേജർ) ആവശ്യമാണ്. ഒരിക്കലും Git-ലേക്ക് നേരിട്ട് രഹസ്യ മാനിഫെസ്റ്റുകൾ നൽകരുത് (സീൽഡ് സീക്രട്ട്‌സ്/എക്‌സ്റ്റേണൽ സീക്രട്ട്‌സ് പോലുള്ള പരിഹാരങ്ങളുണ്ട്).
2. ഒരു റിസോഴ്സ് പരിധി സജ്ജമാക്കുക. പരിധിയില്ലാത്ത ഒരു പോഡിന് മെമ്മറി ലീക്കിലൂടെ മുഴുവൻ നോഡും ക്രാഷ് ചെയ്യാം.
3. മിനിമം അതോറിറ്റി (RBAC). റോൾ-ബേസ്ഡ് ആക്‌സസ് കൺട്രോൾ ഉപയോഗിച്ച്, ഓരോ സേവനത്തിനും/ഉപയോക്താവിനും ആവശ്യമായ അനുമതികൾ മാത്രമേ ഉള്ളൂ. AI ചിലപ്പോൾ വലിയ ക്ലസ്റ്റർ-അഡ്മിൻ നൽകുന്നു; ഇത് ചുരുക്കുക.
4. `ഏറ്റവും പുതിയ` ഇമേജ് ടാഗ് ഉപയോഗിക്കരുത്. ഏത് പതിപ്പാണ് പ്രവർത്തിക്കുന്നതെന്ന് നിങ്ങൾക്കറിയില്ല, നിങ്ങൾക്ക് അത് തിരികെ കൊണ്ടുവരാൻ കഴിയില്ല.

മുന്നറിയിപ്പ്: kubectl ഇല്ലാതാക്കൽ അല്ലെങ്കിൽ തെറ്റായ പ്രയോഗം ഒരു തത്സമയ വിന്യാസത്തെ നശിപ്പിക്കും. കമാൻഡുകൾ പ്രവർത്തിപ്പിക്കുന്നതിന് മുമ്പ് നിങ്ങൾ ഏത് നെയിംസ്പേസിലാണ് (kubectl config നിലവിലെ-സന്ദർഭം) എന്ന് പരിശോധിച്ചുറപ്പിക്കുക; ആകസ്മികമായ ജോലി ഉൽപാദന പശ്ചാത്തലത്തിൽ ഒരു സാധാരണ ദുരന്തമാണ്.

റോ മാനിഫെസ്റ്റ് വേഴ്സസ്. ഹെൽം ടേബിൾ

മാനദണ്ഡം

റോ YAML മാനിഫെസ്റ്റ്

ഹെൽം ചാർട്ട്

ഇൻസ്റ്റലേഷൻ

kubectl പ്രയോഗിക്കുക -f

ഹെൽം ഇൻസ്റ്റാൾ

മൾട്ടിമീഡിയ (dev/prod)

കോപ്പി പേസ്റ്റ്, പിശക് സാധ്യത

ഒറ്റ ചാർട്ട്, വ്യത്യസ്ത മൂല്യങ്ങൾ.yaml

പതിപ്പ്/റോൾബാക്ക്

കൈകൊണ്ട്

ഹെൽം റോൾബാക്ക് ഉപയോഗിച്ച് എളുപ്പമാണ്

പഠന വക്രം

താഴ്ന്ന

ഇടത്തരം

എപ്പോൾ

ചെറിയ, ഒറ്റ പരിസ്ഥിതി

മൾട്ടി മീഡിയ, ആവർത്തന സേവനം

മൂന്ന് മിനി കേസുകൾ

കേസ് 1 - തകർന്ന സേവനത്തിൻ്റെ രഹസ്യം. ഒരു പോഡ് നിരന്തരം റീബൂട്ട് ചെയ്തുകൊണ്ടിരുന്നു (CrashLoopBackOff). ടീം ലോഗുകളും മാനിഫെസ്റ്റും AI-ക്ക് നൽകി; റെഡിനെസ് പ്രോബ് തെറ്റായ പോർട്ടിലേക്ക് നോക്കുന്നതിനാൽ പോഡ് ഒരിക്കലും "റെഡി" ആയി കണക്കാക്കപ്പെട്ടിട്ടില്ലെന്ന് AI കാണിച്ചു. അവർ പോർട്ട് ശരിയാക്കി, 10 മിനിറ്റിനുള്ളിൽ സേവനം സ്ഥിരമായി. ഈ ബന്ധം സ്വമേധയാ സ്ഥാപിക്കാൻ മണിക്കൂറുകൾ എടുത്തേക്കാം.

കേസ് 2 - പരിധികൾ സജ്ജീകരിക്കാത്തത് കെട്ടഴിച്ചു. ഒരു വിന്യാസത്തിൽ പരിധികളില്ല; ഒരു മെമ്മറി ലീക്ക് പോഡിനെ വീർപ്പുമുട്ടിക്കുകയും മുഴുവൻ നോഡും തകരുകയും ചെയ്തു, അയൽ സേവനങ്ങളെയും ഇല്ലാതാക്കി. സംഭവത്തിന് ശേഷം, "എല്ലാ ഡിപ്ലോയ്‌മെൻ്റുകളിലേക്കും ന്യായമായ സിപിയു/മെമ്മറി അഭ്യർത്ഥനകളും പരിധികളും ചേർക്കുക" എന്ന് അവർ AI-യെ പറയുകയും അത് സ്റ്റാൻഡേർഡ് ആക്കുകയും ചെയ്തു. ഒരു നഷ്‌ടമായ ലൈൻ മണിക്കൂറുകളോളം പ്രവർത്തനരഹിതമാണ്.

കേസ് 3 - വലിയ RBAC പിടിച്ചെടുത്തു. ഒരു അന്വേഷണത്തിനിടെ, AI സൃഷ്ടിച്ച ഒരു ServiceAccount മാനിഫെസ്റ്റ് ക്ലസ്റ്റർ-അഡ്മിൻ റോളുമായി ബന്ധിപ്പിച്ചിരിക്കുന്നതായി കണ്ടെത്തി - അതായത് സേവനത്തിന് മുഴുവൻ ക്ലസ്റ്ററും നിയന്ത്രിക്കാനാകും. അവരുടെ നെയിംസ്‌പേസിൽ പോഡുകൾ മാത്രം വായിക്കാനുള്ള അനുമതി ടീം ചുരുക്കി. മിനിമം പ്രിവിലേജ് എന്ന തത്വം ഒരു സുരക്ഷാ പരാധീനത അടച്ചു.

പകർത്താവുന്ന നാല് ടെംപ്ലേറ്റുകൾ

1) വിന്യാസം + സേവന ഉത്പാദനം:

Kubernetes-നായി ഒരു വിന്യാസവും സേവന മാനിഫെസ്റ്റും എഴുതുക. അപ്ലിക്കേഷൻ: [AD], ചിത്രം: [ചിത്രം: സ്ഥിര-പതിപ്പ്], പോർട്ട്: [X], പകർപ്പ്: [N]. നിയമങ്ങൾ:- സിപിയു/മെമ്മറി അഭ്യർത്ഥനകളും പരിധികളും ചേർക്കുക.- livenessProbe, ReadinessProbe എന്നിവ നിർവ്വചിക്കുക.- കോൺഫിഗറേഷൻ കോൺഫിഗറേഷൻ റീഡ് ചെയ്യുക കോൺഫിഗറേഷൻ, സീക്രട്ട് ഒബ്‌ജക്റ്റിൽ നിന്നുള്ള രഹസ്യം; മാനിഫെസ്റ്റിൽ മൂല്യങ്ങൾ ഉൾപ്പെടുത്തരുത്, പ്ലെയ്‌സ്‌ഹോൾഡറുകൾ ഉപയോഗിക്കുക. - ഇമേജ് ടാഗ് ":ലേറ്റസ്റ്റ്" ഉപയോഗിക്കരുത്. വിവരണത്തോടെ നൽകുക.

2) മാനിഫെസ്റ്റ് പിശക് പരിഹരിക്കൽ:

നിലവിലെ പോഡ് [CrashLoopBackOff / Pending / ImagePullBackOff] അവസ്ഥയിലാണ്. ഇനിപ്പറയുന്ന മാനിഫെസ്റ്റും 'kubectl description' ഔട്ട്‌പുട്ടും അനുസരിച്ച്, പ്രോബബിലിറ്റിയുടെ ക്രമത്തിൽ സാധ്യമായ മൂലകാരണങ്ങൾ പട്ടികപ്പെടുത്തുകയും ഓരോന്നിനും വെരിഫൈ കമാൻഡ് നൽകുകയും ചെയ്യുക. മാനിഫെസ്റ്റ്: [YAML] വിവരിക്കുക: [OUTPUT]

3) സുരക്ഷ/സമഗ്രത പരിശോധന:

ഈ കുബർനെറ്റസ് മാനിഫെസ്‌റ്റ് പരിശോധിക്കുക: റിസോഴ്‌സ് ലിമിറ്റ് നഷ്‌ടമാണോ, പ്രശ്‌നം നഷ്‌ടമാണോ, ഒരു :ഏറ്റവും പുതിയ ടാഗ് ഉണ്ടോ, അതിവിശാലമായ RBAC/അനുമതി ഉണ്ടോ, മാനിഫെസ്റ്റിൽ രഹസ്യം ഉൾച്ചേർത്തിട്ടുണ്ടോ? കണ്ടെത്തലുകൾ പ്രാധാന്യത്തോടെയും തിരുത്തലോടെയും എഴുതുക. മാനിഫെസ്റ്റ്: [YAML]

4) ഹെൽം ചാർട്ടിലേക്കുള്ള പരിവർത്തനം:

ഇനിപ്പറയുന്ന അസംസ്‌കൃത മാനിഫെസ്റ്റുകളെ പുനരുപയോഗിക്കാവുന്ന ഹെൽം ചാർട്ടിലേക്ക് പരിവർത്തനം ചെയ്യുക: ഏത് മൂല്യങ്ങളാണ് values.yaml (ചിത്രം, പകർപ്പ്, ഉറവിടം, പരിസ്ഥിതി) എന്നതിലേക്ക് പോകേണ്ടത്? ചാർട്ട് ഘടനയും സാമ്പിൾ മൂല്യങ്ങളും കാണിക്കുക.yaml. മാനിഫെസ്റ്റുകൾ: [YAML]

ദുർബലമായ പ്രോംപ്റ്റ് / ശക്തമായ പ്രോംപ്റ്റ്

ദുർബലമായത്: "എൻ്റെ അപേക്ഷയ്ക്കായി Kubernetes YAML എഴുതുക."

ഫലം: ഒരു നോ-പ്രോബ്, നോ-ലിമിറ്റ് വിന്യാസം: ഏറ്റവും പുതിയ ടാഗ്, രഹസ്യ സമതലം ഉൾച്ചേർക്കുന്നു; ഉൽപ്പന്നത്തിൽ സുരക്ഷിതമല്ലാത്തതും ദുർബലവുമാണ്.

ശക്തമായത്: "കുബർനെറ്റസ് വിന്യാസം + സേവനം എഴുതുക. ഇമേജ് myapp: 1.4.2, 3 പകർപ്പുകൾ, 8080 പോർട്ടുകൾ. CPU 100m-500m, മെമ്മറി 128Mi-512Mi അഭ്യർത്ഥനകൾ/പരിധികൾ ചേർക്കുക. /healthz-നായി ലൈവ്‌നെസ് പ്രോബ് ഇടുക, സെക്രെഡ് ഒബ്‌ജക്‌റ്റിൽ നിന്ന് റെഡിനസ് പ്രോബ് ഇടുക, /ready't എന്ന ഒബ്‌ജക്‌റ്റിൽ നിന്ന് അന്വേഷണം നടത്തുക. മാനിഫെസ്റ്റിൽ വിവരണത്തോടെ നൽകുക."

വ്യത്യാസം: രണ്ടാമത്തെ പ്രോംപ്റ്റ് പതിപ്പ് സ്കെയിൽ, റിസോഴ്സ് പരിധികൾ, ആരോഗ്യ പരിശോധനകൾ, രഹസ്യ നിയമം എന്നിവ നൽകുന്നു; ഔട്ട്പുട്ട് ഉൽപ്പാദനത്തോട് അടുത്തും സുരക്ഷിതവുമാണ്.

സാധാരണ തെറ്റുകൾ

• വിഭവ പരിധി നിശ്ചയിക്കുന്നില്ല. ഒരൊറ്റ പോഡിന് മുഴുവൻ നോഡും ഉപയോഗിക്കാനാകും.
• ആരോഗ്യ പരിശോധന (അന്വേഷണം) ചേർക്കുന്നില്ല. കുബർനെറ്റസിന് ക്രാഷ്/തയ്യാറാകാത്ത പോഡ് കണ്ടെത്താൻ കഴിയില്ല.
• `:ഏറ്റവും പുതിയ ടാഗ്. ഏത് പതിപ്പാണ് പ്രവർത്തിക്കുന്നതെന്ന് വ്യക്തമല്ല, അത് തിരികെ കൊണ്ടുവരാൻ കഴിയില്ല.
• രഹസ്യം നേരിട്ട് Git ന് സമർപ്പിക്കുന്നു. Base64 എൻക്രിപ്ഷൻ അല്ല; എല്ലാവരും അത് പരിഹരിക്കുന്നു.
• തെറ്റായ സന്ദർഭത്തിൽ/നെയിംസ്പേസിൽ കമാൻഡുകൾ പ്രവർത്തിപ്പിക്കുന്നു. പ്രോഡിൽ ക്രാഷ് ചെയ്യാനുള്ള ഏറ്റവും സാധാരണമായ മാർഗ്ഗം.
• `--ഡ്രൈ-റൺ`/`diff` ഒഴിവാക്കുന്നു. നടപ്പാക്കുന്നതിന് മുമ്പ് എന്ത് സംഭവിക്കുമെന്ന് കാണുന്നില്ല.

ചുരുക്കത്തിൽ

ഒരു ക്ലസ്റ്ററിലുടനീളം കണ്ടെയ്‌നറുകൾ സ്വയമേവ വിന്യസിക്കുകയും സ്കെയിലുചെയ്യുകയും ഒപ്റ്റിമൈസ് ചെയ്യുകയും ചെയ്യുന്ന ശക്തവും എന്നാൽ സങ്കീർണ്ണവുമായ ഒരു ഓർക്കസ്‌ട്രേറ്ററാണ് കുബർനെറ്റസ്; ഹെൽം ടെംപ്ലേറ്റൈസ് ചെയ്യുന്ന മാനിഫെസ്റ്റ് YAML-കളാൽ എല്ലാം നിർവചിക്കപ്പെട്ടിരിക്കുന്നു. AI വേഗത്തിൽ വിന്യാസം/സേവന മാനിഫെസ്റ്റുകളും ഹെൽം ചാർട്ടുകളും നിർമ്മിക്കുന്നു, നിഗൂഢമായ ബഗുകൾ പരിഹരിക്കുന്നു - എന്നാൽ ഉറവിട പരിധി, ആരോഗ്യ പരിശോധന, മാറ്റമില്ലാത്ത ഇമേജ് ടാഗ്, ഇടുങ്ങിയ RBAC, രഹസ്യ സുരക്ഷാ നിയമങ്ങൾ എന്നിവ നിങ്ങൾ വ്യക്തമായി ചോദിക്കേണ്ടതുണ്ട്. --ഡ്രൈ-റൺ, ഡിഫ്, ശരിയായ സന്ദർഭ പരിശോധന എന്നിവയാണ് പ്രോഡ് ക്രാഷുകൾ തടയുന്ന ശീലങ്ങൾ.

ആപ്ലിക്കേഷൻ ടാസ്ക്

"വിന്യാസം + സർവീസ് ജനറേഷൻ" ടെംപ്ലേറ്റ് ഉപയോഗിച്ച് ഒരു സാമ്പിൾ ആപ്ലിക്കേഷനായി AI ഒരു മാനിഫെസ്റ്റ് സൃഷ്‌ടിക്കുക. തുടർന്ന്: (1) "സെക്യൂരിറ്റി/സാനിറ്റി ചെക്ക്" ടെംപ്ലേറ്റ് ഉപയോഗിച്ച് അത് റിസോഴ്സ് ലിമിറ്റ്, പ്രോബ്, :ഏറ്റവും പുതിയതും രഹസ്യവും പരിശോധിച്ചിട്ടുണ്ടോ; (2) kubectl apply --dry-run=ഒരു ടെസ്റ്റ് ക്ലസ്റ്ററിൽ/minikube-ൽ സാധ്യമെങ്കിൽ സെർവർ പ്രവർത്തിപ്പിച്ച് ഔട്ട്പുട്ട് വായിക്കുക; (3) നിങ്ങൾ നഷ്‌ടമായി കണ്ടെത്തുന്ന ഏറ്റവും നിർണായകമായ രണ്ട് സുരക്ഷാ/ദൃഢത ഇനങ്ങൾ ശ്രദ്ധിക്കുക.

ചെക്ക്ലിസ്റ്റ്

• [ ] ഞാൻ എൻ്റെ അഭ്യർത്ഥനയിൽ ചിത്രത്തിൻ്റെ പതിപ്പ്, പകർപ്പുകളുടെ എണ്ണം, പോർട്ട്, ഉറവിട പരിധികൾ എന്നിവ ചേർത്തു.
• [ ] ഞാൻ മാനിഫെസ്റ്റിലേക്ക് സജീവതയും റെഡിനെസ് പ്രോബും ചേർത്തു.
• [ ] ഇമേജ് ടാഗ് പരിഹരിച്ചു; ഞാൻ ഉപയോഗിച്ചിട്ടില്ല: ഏറ്റവും പുതിയത്.
• [ ] മാനിഫെസ്റ്റിൽ രഹസ്യം ഉൾച്ചേർത്തിട്ടില്ല; ഞാൻ രഹസ്യ വസ്തു/ബാഹ്യ നിലവറ ഉപയോഗിച്ചു.
• [ ] ഞാൻ RBAC/അനുമതികൾ ഏറ്റവും കുറഞ്ഞ അനുമതികളാക്കി ചുരുക്കി.
• [ ] അപേക്ഷിക്കുന്നതിന് മുമ്പ്, ഞാൻ ശരിയായ സന്ദർഭത്തിലാണെന്നും --ഡ്രൈ-റൺ/ഡിഫ് ഔട്ട്പുട്ടുകളാണെന്നും ഞാൻ പരിശോധിച്ചു.