ഓട്ടോമേഷൻ സ്ക്രിപ്റ്റുകൾ: ബാഷ്, പവർഷെൽ, പൈത്തൺ എന്നിവ സുരക്ഷിതമായി സൃഷ്ടിക്കുന്നു

നേട്ടങ്ങൾ:

• വ്യക്തമായ നിയന്ത്രണങ്ങളോടെ ബാഷ്, പവർഷെൽ, പൈത്തൺ ഓട്ടോമേഷൻ സ്‌ക്രിപ്റ്റുകൾ നിർമ്മിക്കാനുള്ള കഴിവ്, ആർട്ടിഫിഷ്യൽ ഇൻ്റലിജൻസ് ഉള്ള സെക്യൂരിറ്റി ഗാർഡ്‌റെയിലുകൾ
• ഓരോ സ്ക്രിപ്റ്റിലേക്കും ഐഡമ്പറ്റൻസി, ഡ്രൈ-റൺ, എറർ ഹാൻഡ്ലിംഗ്, റോൾബാക്ക് തുടങ്ങിയ തത്വങ്ങൾ ചേർക്കാനും 'ജനറേറ്റ്, ഹാർഡൻ, വെരിഫൈ' സൈക്കിൾ പ്രയോഗിക്കാനുമുള്ള കഴിവ്
• നിർമ്മിച്ച തിരക്കഥയുടെ നിർവ്വഹണം അത് സുരക്ഷിതമാണെന്ന് അർത്ഥമാക്കുന്നില്ലെന്നും വിനാശകരമായ വരികൾ വായിച്ചും പരീക്ഷിച്ചും ഉത്തരവാദിത്തം ഏറ്റെടുക്കുന്ന ശീലം നേടുമെന്നും മനസ്സിലാക്കാനുള്ള കഴിവ്.

ഓട്ടോമേഷൻ സ്ക്രിപ്റ്റുകൾ: AI ഉപയോഗിച്ച് സുരക്ഷിതമായി ബാഷ്, പവർഷെൽ, പൈത്തൺ എന്നിവ സൃഷ്ടിക്കുന്നു

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

ഈ യൂണിറ്റിൽ, AI ഉപയോഗിച്ച് സുരക്ഷിതവും വായിക്കാവുന്നതും വീണ്ടെടുക്കാവുന്നതുമായ സ്ക്രിപ്റ്റുകൾ എങ്ങനെ നിർമ്മിക്കാമെന്ന് നിങ്ങൾ പഠിക്കും; ഐഡിയംപോട്ടൻസി (ഒരേ സ്ക്രിപ്റ്റ് രണ്ടുതവണ പ്രവർത്തിപ്പിക്കുന്നത് കേടുപാടുകൾ വരുത്തുന്നില്ല), ഡ്രൈ-റൺ തുടങ്ങിയ ജീവൻരക്ഷാ തത്വങ്ങൾ; ഒരു സ്‌ക്രിപ്റ്റ് നിർമ്മിക്കുന്നതിന് മുമ്പ് അത് കടന്നുപോകേണ്ട പരിശോധനകൾ നിങ്ങൾ പഠിക്കും.

AI ഉപയോഗിച്ചുള്ള സ്‌ക്രിപ്റ്റിംഗ് ഇത്ര ശക്തമായിരിക്കുന്നത് എന്തുകൊണ്ട്?

പരിചയസമ്പന്നനായ ഒരു അഡ്മിനിസ്ട്രേറ്റർക്ക് പോലും ഒരു ബാഷ് ലൂപ്പിൻ്റെ കൃത്യമായ വാക്യഘടന, പവർഷെൽ cmdlet (കമാൻഡ്) പാരാമീറ്ററുകൾ അല്ലെങ്കിൽ ഒരു പൈത്തൺ ശ്രമിക്കാം/ഹൃദയത്തോടെ ബ്ലോക്ക് ഒഴികെ. AI ഈ വിടവ് തൽക്ഷണം നികത്തുന്നു: നിങ്ങൾ പ്ലെയിൻ ടർക്കിഷ് ഭാഷയിൽ ഉദ്ദേശ്യം വിശദീകരിക്കുന്നു, അത് ഒരു പ്രവർത്തന രൂപരേഖ ഉണ്ടാക്കുന്നു. മാത്രമല്ല, നിങ്ങൾക്ക് AI-ക്ക് നിലവിലുള്ള ഒരു സ്‌ക്രിപ്റ്റ് നൽകുകയും "ഇത് വിശദീകരിക്കുക", "എറർ കൈകാര്യം ചെയ്യൽ ചേർക്കുക", "കൂടുതൽ വായിക്കാനാകുന്നതാക്കുക" എന്ന് പറയുകയും ചെയ്യാം. ഇത് പഠന വക്രത കുറയ്ക്കുകയും ജൂനിയർ ടീം അംഗങ്ങളെ വേഗത്തിലാക്കുകയും ചെയ്യുന്നു.

എന്നാൽ അധികാരത്തിനൊപ്പം ഉത്തരവാദിത്തവും വരുന്നു. മിക്കപ്പോഴും, AI- സൃഷ്ടിച്ച സ്ക്രിപ്റ്റ് "സന്തോഷകരമായ പാത" ശരിയായി എഴുതുന്നു (എല്ലാം ശരിയാണെങ്കിൽ); എന്നാൽ ഇതിന് എഡ്ജ് കേസുകൾ നഷ്ടപ്പെടാം (ഫയൽ കാണുന്നില്ല, ഡിസ്ക് നിറഞ്ഞിരിക്കുന്നു, നെറ്റ്‌വർക്ക് ഡൗൺ) അല്ലെങ്കിൽ അപകടകരമായ അനുമാനങ്ങൾ ഉണ്ടാക്കാം. അതിനാൽ AI ഉപയോഗിച്ച് സ്‌ക്രിപ്റ്റ് സൃഷ്‌ടിക്കുന്നതിനെക്കുറിച്ച് മൂന്ന് ഘട്ടങ്ങളിലായി ചിന്തിക്കുക: സൃഷ്ടിക്കുക, കഠിനമാക്കുക, സ്ഥിരീകരിക്കുക.

ഘട്ടം ഘട്ടമായി: സുരക്ഷിത സ്ക്രിപ്റ്റ് സൃഷ്ടിക്കൽ

1. ഉദ്ദേശ്യവും നിയന്ത്രണവും വ്യക്തമായി എഴുതുക. ഏത് ഓപ്പറേറ്റിംഗ് സിസ്റ്റം, ഏത് ഷെൽ പതിപ്പ്, ഏത് ഫയൽ പാത്ത്, എന്ത് അവകാശങ്ങൾ? "Ubuntu 22.04, Bash 5, sudo റൂട്ട് അല്ല, /opt/app/logs-ന് കീഴിൽ മാത്രം പ്രവർത്തിപ്പിക്കുക" പോലെ. അവ്യക്തമായ ആവശ്യം അപകടകരമായ അനുമാനം സൃഷ്ടിക്കുന്നു.
2. സുരക്ഷാ റെയിലിംഗുകൾ ആവശ്യപ്പെടുക. "പരാജയത്തിൽ നിർത്തുക" (ബാഷിൽ -euo പൈപ്പ്ഫെയ്ൽ സജ്ജമാക്കുക), വിനാശകരമായ പ്രവർത്തനങ്ങളുടെ സ്ഥിരീകരണം, പ്രവർത്തനത്തിന് മുമ്പുള്ള ബാക്കപ്പ്, ഡ്രൈ-റൺ മോഡ് എന്നിവയ്ക്കായി സ്ക്രിപ്റ്റ് ആവശ്യപ്പെടുക. ഈ ഗാർഡ്‌റെയിലുകൾ AI ബൈപാസ് ചെയ്യുന്ന എഡ്ജ് സ്റ്റേറ്റ്‌സ് ക്യാപ്‌ചർ ചെയ്യുന്നു.
3. ബുദ്ധിശൂന്യമായി എഴുതുക. രണ്ടാം തവണ പ്രവർത്തിപ്പിക്കുമ്പോൾ സ്ക്രിപ്റ്റ് എന്തെങ്കിലും പിശകുകളോ കേടുപാടുകളോ ഉണ്ടാക്കരുത്. "ഉപയോക്താവ് ഇതിനകം നിലവിലുണ്ടെങ്കിൽ ഒഴിവാക്കുക", "ഡയറക്‌ടറി നിലവിലില്ലെങ്കിൽ അത് സൃഷ്‌ടിക്കുക, അത് നിലവിലുണ്ടെങ്കിൽ തൊടരുത്" എന്നതിൻ്റെ ഒരു ലോജിക് സ്ഥാപിക്കുക. ഇത് ഓട്ടോമേഷൻ സുരക്ഷിതമായി വീണ്ടും വീണ്ടും പ്രവർത്തിപ്പിക്കാൻ അനുവദിക്കുന്നു.
4. വായിച്ചു മനസ്സിലാക്കുക. നിർമ്മിച്ച ഓരോ വരിയും വായിക്കുക. വിനാശകരമായ കമാൻഡുകൾ (rm, Remove-Item, DROP) പ്രത്യേകം അടയാളപ്പെടുത്താൻ AI-യോട് ആവശ്യപ്പെടുക.
5. ഡ്രൈ-റൺ ഉപയോഗിച്ച് പരിശോധിക്കുക. ആദ്യം, യഥാർത്ഥ പ്രവർത്തനങ്ങൾക്ക് പകരം "എന്താണ് ചെയ്യേണ്ടതെന്ന് പറയൽ" മോഡിൽ പ്രവർത്തിപ്പിക്കുക. നിങ്ങൾ പ്രതീക്ഷിക്കുന്നത് ഔട്ട്പുട്ട് ആണെങ്കിൽ, യഥാർത്ഥ മോഡിലേക്ക് മാറുക - ആദ്യം ടെസ്റ്റ് മെഷീനിൽ.
6. നിങ്ങളുടെ തിരിച്ചുവരവ് തയ്യാറാക്കുക. സ്ക്രിപ്റ്റ് ബാക്കപ്പ് എടുക്കുമോ? ബാക്കപ്പ് എങ്ങനെ പുനഃസ്ഥാപിക്കാമെന്ന് നിങ്ങൾക്കറിയാമോ? ലോഗിംഗ് ഉണ്ടോ, അത് പിന്നീട് എന്താണ് ചെയ്യുന്നതെന്ന് നിങ്ങൾക്ക് കാണാൻ കഴിയുമോ?

നുറുങ്ങ്: ഓരോ ഡിസ്ട്രക്റ്റർ സ്ക്രിപ്റ്റിലും ഒരു DRY_RUN=true വേരിയബിളും --apply ഫ്ലാഗും ഉൾപ്പെടുത്തുക. ഒന്നും ഇല്ലാതാക്കാതെ എന്താണ് സംഭവിക്കുന്നതെന്ന് എഴുതുക എന്നതാണ് സ്വതവേയുള്ള പെരുമാറ്റം; --apply വ്യക്തമായി നൽകിയിട്ടുണ്ടെങ്കിൽ മാത്രമേ യഥാർത്ഥ ഇല്ലാതാക്കൽ പ്രവർത്തിക്കൂ. ഈ ഒരു ശീലം കരിയർ നീണ്ടുനിൽക്കുന്ന ദുരന്തങ്ങളെ തടയുന്നു.

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

കേസ് 1 - ഐഡമ്പോട്ടൻസി 3 മണിക്കൂർ ലാഭിച്ചു. ഒരു അഡ്മിനിസ്ട്രേറ്റർ 25 സെർവറുകളിൽ ഒരേ മോണിറ്ററിംഗ് ഏജൻ്റ് ഇൻസ്റ്റാൾ ചെയ്ത ഒരു സ്ക്രിപ്റ്റ് എഴുതി. ആദ്യ പതിപ്പ് അസാമാന്യമായിരുന്നില്ല: ഏജൻ്റ് ഇതിനകം ഇൻസ്റ്റാൾ ചെയ്തിട്ടുണ്ടെങ്കിൽ അത് രണ്ടാമത്തെ റണ്ണിൽ കോൺഫിഗറേഷൻ തകർത്തു. "ഇത് ഇൻസ്റ്റാൾ ചെയ്തിട്ടുണ്ടോയെന്ന് പരിശോധിക്കുക, ആണെങ്കിൽ ഒഴിവാക്കുക" എന്ന ലോജിക് AI ചേർക്കുകയാണ് എഞ്ചിനീയർ ചെയ്തത്. അടുത്ത മെയിൻ്റനൻസ് വിൻഡോയിൽ സ്‌ക്രിപ്റ്റ് അബദ്ധത്തിൽ രണ്ടുതവണ ട്രിഗർ ചെയ്‌തെങ്കിലും അത് ദോഷം വരുത്തിയില്ല. ഐഡംപോട്ടൻസി 25-സെർവർ വീണ്ടെടുക്കൽ അനാവശ്യമാക്കി.

കേസ് 2 - ഡ്രൈ-റൺ ഒരു റൂട്ട് ഡയറക്ടറി സംരക്ഷിച്ചു. പഴയ ബാക്കപ്പുകൾ ശുദ്ധീകരിക്കുന്ന ഒരു ബാഷ് സ്ക്രിപ്റ്റ് ഒരു ടീമിന് ലഭിച്ചു. വേരിയബിൾ ശൂന്യമാണെങ്കിൽ, പാത / പകരം / ബാക്കപ്പുകൾ / - ഒരു ക്ലാസിക് അപകടമായി. എഞ്ചിനീയർ ആദ്യം ഇത് DRY_RUN മോഡിൽ പ്രവർത്തിപ്പിച്ചു, ഔട്ട്‌പുട്ടിൽ rm -rf / എന്നതിന് സമാനമായ ഒരു ലൈൻ കണ്ടപ്പോൾ മരവിച്ചു, കൂടാതെ ഒരു വേരിയബിൾ ചെക്ക് ചേർത്തു (: "${BACKUP_DIR:?ശൂന്യമാകാൻ കഴിയില്ല}"). ഡ്രൈ റണ്ണിംഗ് ഒരു ബഗ് പിടിപെട്ടു, അത് ഉൽപ്പാദനത്തിലേക്ക് പോകുന്നതിന് മുമ്പ് മുഴുവൻ ഡിസ്കും തുടച്ചുമാറ്റും.

കേസ് 3 - ഒരു രാത്രി ഉണരുന്നതിൽ നിന്ന് പിശക് മാനേജ്മെൻ്റ് അതിനെ തടഞ്ഞു. ഡിസ്ക് നിറഞ്ഞപ്പോൾ ഒരു PowerShell സ്ക്രിപ്റ്റ് ലോഗുകൾ ആർക്കൈവ് ചെയ്യുകയായിരുന്നു. നെറ്റ്‌വർക്ക് പങ്കിടൽ ആക്‌സസ്സുചെയ്യാനാകാതെ ഡിസ്‌ക് പൂരിപ്പിക്കുന്നത് തുടരുകയാണെങ്കിൽ ആദ്യ പതിപ്പ് നിശബ്ദമായി പരാജയപ്പെടും. "ഓരോ ഘട്ടത്തിലും വിജയം പരിശോധിച്ചുറപ്പിക്കുക, വിജയിച്ചില്ലെങ്കിൽ, ഇ-മെയിൽ അറിയിച്ച് നിർത്തുക" എന്ന് AI-യിൽ ചേർത്തു. ഒരാഴ്ച കഴിഞ്ഞപ്പോൾ പോസ്റ്റ് ഒടിഞ്ഞു; സ്ക്രിപ്റ്റ് നിർത്തി മുന്നറിയിപ്പ് നൽകി, ഡിസ്ക് നിറഞ്ഞില്ല, 3 മണിക്ക് ആരും ഉണർന്നില്ല.

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

1) സുരക്ഷിത ബാഷ് സ്ക്രിപ്റ്റ് ജനറേഷൻ:

നിങ്ങളുടെ റോൾ: സീനിയർ ലിനക്സ് ഓട്ടോമേഷൻ എഞ്ചിനീയർ. ഉബുണ്ടു 22.04 / ബാഷ് 5-ന് വേണ്ടി ഒരു സ്ക്രിപ്റ്റ് എഴുതുക. ഉദ്ദേശ്യം:[ഉദ്ദേശ്യം]. നിയമങ്ങൾ:- "set -euo pipefail" ഉപയോഗിച്ച് ആരംഭിക്കുക.- ": ${VAR:?}" ഉപയോഗിച്ച് ആവശ്യമായ വേരിയബിളുകൾ സാധൂകരിക്കുക.- ഡിഫോൾട്ടായി വിനാശകരമായ പ്രവർത്തനങ്ങൾ നടത്തുക DRY_RUN=true; യഥാർത്ഥ ആപ്ലിക്കേഷൻ --apply ഫ്ലാഗ് ഉപയോഗിച്ച് മാത്രം പ്രവർത്തിക്കട്ടെ. - ഓരോ ഘട്ടവും stdout-ലേക്ക് ലോഗിൻ ചെയ്യുക, പിശക് സംബന്ധിച്ച അർത്ഥവത്തായ സന്ദേശത്തോടെ നിർത്തുക. - ഇത് നിർജ്ജീവമാക്കുക (അതിനാൽ ഇത് രണ്ടാമത്തെ ഓട്ടത്തിൽ കേടുപാടുകൾ വരുത്തില്ല). തുടർന്ന്: വിനാശകരമായ വരകൾ വെവ്വേറെ അടയാളപ്പെടുത്തുകയും നിർമ്മാണത്തിന് മുമ്പ് ഞാൻ പരിശോധിക്കേണ്ട 3 കേസുകൾ എഴുതുകയും ചെയ്യുക.

2) നിലവിലുള്ള സ്ക്രിപ്റ്റ് കഠിനമാക്കൽ:

ഇനിപ്പറയുന്ന സ്‌ക്രിപ്റ്റ് നിർമ്മാണത്തിനായി തയ്യാറാക്കുക: (1) പിശക് കൈകാര്യം ചെയ്യലും ലോഗ്ഗിംഗും ചേർക്കുക, (2) അത് ഇഡമ്പറ്റൻ്റ് ആക്കുക, (3) ഡ്രൈ-റണ്ണിന് പിന്നിൽ വിനാശകരമായ കമാൻഡുകൾ ഇടുക, (4) വേരിയബിളിലേക്ക് ഹാർഡ്-കോഡ് ചെയ്ത പാതകളും രഹസ്യങ്ങളും എക്‌സ്‌ട്രാക്റ്റുചെയ്യുക. നിങ്ങൾ മാറ്റിയ ഓരോ വരിയും എന്തുകൊണ്ടാണെന്നും സംക്ഷിപ്തമായി വിവരിക്കുക. സ്ക്രിപ്റ്റ്: [സ്ക്രിപ്റ്റ്]

3) പവർഷെൽ സുരക്ഷിത ഓട്ടോമേഷൻ:

നിങ്ങളുടെ റോൾ: വിൻഡോസ് ഓട്ടോമേഷൻ വിദഗ്ധൻ. ഒരു PowerShell 5.1 അനുയോജ്യമായ സ്ക്രിപ്റ്റ് എഴുതുക. ഉദ്ദേശ്യം: [ഉദ്ദേശ്യം]. നിയമങ്ങൾ:- "$ErrorActionPreference = 'Stop'" ഉപയോഗിച്ച് ആരംഭിക്കുക.- ഡിസ്ട്രക്റ്റർ cmdlets-ലേക്ക് -WhatIf പിന്തുണ ചേർക്കുക (ഡിഫോൾട്ട് WhatIf).- ഓരോ പ്രവർത്തനവും ശ്രമിക്കുക/കാച്ച്, ലോഗ് പിശക് ഉപയോഗിച്ച് പൊതിയുക.- ക്രെഡൻഷ്യൽ ഹാർഡ്കോഡിംഗ്; പരാമീറ്റർ അല്ലെങ്കിൽ സുരക്ഷിത ഇൻപുട്ട് ഉപയോഗിക്കുക. വിനാശകരമായ വരികൾ അടയാളപ്പെടുത്തുക, പഴയപടിയാക്കുക ഘട്ടങ്ങൾ എഴുതുക.

4) ക്രോൺ/ഷെഡ്യൂൾ എക്സ്പ്രഷൻ ഡീകോഡിംഗും സ്ഥിരീകരണവും:

ഇനിപ്പറയുന്ന ക്രോൺ സ്റ്റേറ്റ്‌മെൻ്റ് പ്ലെയിൻ ടർക്കിഷ് ഭാഷയിൽ വിശദീകരിച്ച് അടുത്ത 3 റൺടൈമുകൾ എഴുതുക: [എക്‌സ്‌പ്രഷൻ] കൂടാതെ, എൻ്റെ ലക്ഷ്യം "[ഉദ്ദേശ്യം]" ആണെങ്കിൽ, ഈ പ്രസ്താവന ശരിയാണോ അതോ നിങ്ങൾ നിർദ്ദേശിക്കുന്ന എന്തെങ്കിലും പരിഹാരമുണ്ടോ? സമയ കാലയളവിൻ്റെ ഫലവും ശ്രദ്ധിക്കുക.

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

ദുർബലമായ പ്രോംപ്റ്റ്:

ലോഗ് വൃത്തിയാക്കുന്ന ഒരു സ്ക്രിപ്റ്റ് എനിക്ക് എഴുതൂ.

ഈ നിർദ്ദേശം അപകടകരമാണ്: ഏത് OS, ഏത് ഡയറക്‌ടറി, ഏത് പ്രായപരിധി, ഏത് സെക്യൂരിറ്റി ഗാർഡ്‌റെയിൽ എന്നിവ വ്യക്തമല്ല. AI-ന് ഒരു വൺ-ലൈനർ, വിനാശകരവും പരിശോധിക്കാനാകാത്തതുമായ rm നൽകാൻ കഴിയും.

ശക്തമായ നിർദ്ദേശം:

നിങ്ങളുടെ റോൾ: സീനിയർ ലിനക്സ് ഓട്ടോമേഷൻ എഞ്ചിനീയർ. ഉബുണ്ടു 22.04 / ബാഷിനായി ഒരു ലോഗ് ക്ലീനിംഗ് സ്ക്രിപ്റ്റ് എഴുതുക. 30 ദിവസത്തിലധികം പഴക്കമുള്ള /opt/app/logs-ന് കീഴിലുള്ള .log ഫയലുകൾ മാത്രം ഇല്ലാതാക്കുക. നിയമങ്ങൾ: set -euo pipefail; BACKUP_DIR, LOG_DIR വേരിയബിളുകൾ സാധൂകരിക്കുക (ശൂന്യമാണെങ്കിൽ നിർത്തുക); ഇല്ലാതാക്കുന്നതിന് മുമ്പ് ഫയൽ ലിസ്റ്റ് ലോഗ് ചെയ്യുക; DRY_RUN=true ആകട്ടെ ഡിഫോൾട്ട്, യഥാർത്ഥ ഇല്ലാതാക്കൽ --apply ഉപയോഗിച്ച് മാത്രം; അത് ബുദ്ധിശൂന്യമായിരിക്കട്ടെ. വിനാശകരമായ വരികൾ അടയാളപ്പെടുത്തി ഞാൻ പരിശോധിക്കേണ്ട 3 സാഹചര്യങ്ങൾ എഴുതുക.

സവിശേഷത

ദുർബലമായ/വേഗതയുള്ള സ്ക്രിപ്റ്റ്

കഠിനമായ സ്ക്രിപ്റ്റ്

കൈകാര്യം ചെയ്യുന്നതിൽ പിശക്

ഇല്ല, നിശബ്ദ പരാജയം

set -euo pipefail, ശ്രമിക്കുക/പിടിക്കുക

വിനാശകരമായ പ്രവർത്തനം

നേരിട്ട് പ്രവർത്തിക്കുന്നു

ഡ്രൈ-റൺ + ഓപ്പൺ ചെക്ക് ഫ്ലാഗ്

പുനരാരംഭിക്കുക

ദോഷം വരുത്തിയേക്കാം

നിർഭയൻ, സുരക്ഷിതം

രഹസ്യ മാനേജ്മെൻ്റ്

ഹാർഡ് കോഡ്

വേരിയബിൾ/മറഞ്ഞിരിക്കുന്ന ഇൻപുട്ട്

പഴയപടിയാക്കുക

ഒന്നുമില്ല

ബാക്കപ്പ് + പുനഃസ്ഥാപിക്കൽ ഘട്ടം

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

• ഡ്രൈ-റൺ ഇല്ലാതെ വിനാശകരമായ സ്ക്രിപ്റ്റ് പ്രവർത്തിപ്പിക്കുന്നു. ഡ്രൈ മോഡ് കോസ്റ്റ് ഡിസ്കിൽ rm, Remove-Item, DROP എന്നിവ അടങ്ങിയ സ്ക്രിപ്റ്റ് കാണുന്നില്ല.
• നൾ വേരിയബിൾ പരിശോധന ഒഴിവാക്കുക. ഒരു ശൂന്യമായ പാത്ത് വേരിയബിൾ / പകരം /ബാക്കപ്പുകൾ/; : "${VAR:?}" ഉപയോഗിച്ച് സ്ഥിരീകരിക്കുന്നത് ഉറപ്പാക്കുക.
• ഐഡമ്പറ്റൻസി മറക്കുന്നു. രണ്ടുതവണ പ്രവർത്തിപ്പിക്കുമ്പോൾ സ്ക്രിപ്റ്റ് തകരുന്നു, ഓട്ടോമേഷൻ വിശ്വസനീയമല്ല.
• ഹാർഡ്-കോഡിംഗ് രഹസ്യങ്ങൾ. നിങ്ങൾ ആ സ്‌ക്രിപ്റ്റ് പങ്കിടുമ്പോൾ സ്‌ക്രിപ്റ്റിലേക്ക് പാസ്‌വേഡും കീയും എഴുതുന്നത് ചോർച്ചയാണ്.
• ഉത്പാദനത്തിൽ പരിശോധന. പ്രൊഡക്ഷനിൽ ആദ്യ ഓട്ടം നടത്തുന്നത് സ്റ്റേജിൽ റിഹേഴ്സൽ ചെയ്യുകയാണ്; ആദ്യം ടെസ്റ്റ് മെഷീൻ.

ശ്രദ്ധിക്കുക: "അത് പ്രവർത്തിച്ചു, അതിനർത്ഥം അത് ശരിയാണെന്ന്" AI നൽകുന്ന ഒരു സ്ക്രിപ്റ്റ് സ്വീകരിക്കരുത്. അത് പ്രവർത്തിക്കുന്നു എന്നതുകൊണ്ട് അത് വിനാശകരമല്ലെന്ന് അർത്ഥമാക്കുന്നില്ല. ഒരു സ്ക്രിപ്റ്റിന് സന്തോഷകരമായ പാതയിൽ പ്രവർത്തിക്കാനും എഡ്ജ് സ്റ്റേറ്റിലെ ഡാറ്റ ഇല്ലാതാക്കാനും കഴിയും; എഡ്ജ് കേസുകളാണ് യഥാർത്ഥ പരീക്ഷണം.

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

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

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

നിങ്ങളുടെ ജോലിയിൽ നിങ്ങൾ സ്വമേധയാ ആവർത്തിക്കുന്ന ഒരു ടാസ്‌ക്ക് തിരഞ്ഞെടുക്കുക (ഉദാ. ലോഗ് ക്ലീനപ്പ്, ഉപയോക്തൃ തുറക്കൽ, ആരോഗ്യ പരിശോധന). മുകളിലുള്ള "സെക്യൂർ ബാഷ് സ്‌ക്രിപ്റ്റ്" അല്ലെങ്കിൽ "പവർഷെൽ സെക്യൂരിറ്റി ഓട്ടോമേഷൻ" ടെംപ്ലേറ്റ് ഉപയോഗിച്ച് AI-യിൽ നിന്ന് ഒരു ഔട്ട്‌ലൈൻ അഭ്യർത്ഥിക്കുക. സൃഷ്ടിച്ച സ്ക്രിപ്റ്റ് വരി വരിയായി വായിക്കുക, വിനാശകരമായ വരികൾ അടയാളപ്പെടുത്തുക. ഒരു ടെസ്റ്റ് മെഷീനിൽ ആദ്യം ഡ്രൈ-റൺ മോഡിൽ ഇത് പ്രവർത്തിപ്പിക്കുക, നിങ്ങളുടെ പ്രതീക്ഷയുമായി ഔട്ട്പുട്ട് താരതമ്യം ചെയ്യുക. തുടർന്ന് സ്‌ക്രിപ്റ്റ് AI-ലേക്ക് തിരികെ നൽകുകയും "ഹാർഡൻ" ടെംപ്ലേറ്റ് ഉപയോഗിച്ച് അതിനെ പരിഷ്കരിക്കുകയും രണ്ട് പതിപ്പുകൾ തമ്മിലുള്ള 5 വ്യത്യാസങ്ങൾ ശ്രദ്ധിക്കുകയും ചെയ്യുക.

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

• [ ] പ്രോംപ്റ്റിൽ OS, ഷെൽ പതിപ്പ്, പാതകൾ, അവകാശങ്ങൾ തുടങ്ങിയ നിയന്ത്രണങ്ങൾ ഞാൻ ഉൾപ്പെടുത്തിയിട്ടുണ്ടോ?
• [ ] സെറ്റ് -euo pipefail / $ErrorActionPreference='Stop' ഉപയോഗിച്ച് സ്‌ക്രിപ്റ്റ് തെറ്റ്-സഹിഷ്ണുതയുള്ളതാണോ?
• [ ] ഡ്രൈ-റണ്ണിന് പിന്നിൽ വിനാശകരമായ പ്രവർത്തനങ്ങൾ ഉണ്ടോ/-എന്ത് എങ്കിൽ വ്യക്തമായ ഒരു ചെക്ക് ഫ്ലാഗ് ആവശ്യമാണോ?
• [ ] സ്‌ക്രിപ്റ്റ് നിർജീവമാണോ (രണ്ടാം ഓട്ടത്തിൽ സുരക്ഷിതമാണോ)?
• [ ] ഹാർഡ് കോഡിംഗിന് പകരം ഞാൻ രഹസ്യങ്ങൾ വേരിയബിൾ/രഹസ്യ ഇൻപുട്ടിലേക്ക് എക്‌സ്‌ട്രാക്‌റ്റ് ചെയ്‌തിട്ടുണ്ടോ?
• [ ] ഞാൻ ടെസ്റ്റ് മെഷീനിൽ ആദ്യ ഓട്ടം നടത്തി ഒരു റിട്ടേൺ പ്ലാൻ തയ്യാറാക്കിയിട്ടുണ്ടോ?