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

നേട്ടങ്ങൾ:

• ബാഷ്, പൈത്തൺ, പവർഷെൽ എന്നിവയുടെ ശക്തി മനസ്സിലാക്കാനും കൃത്രിമബുദ്ധി സുരക്ഷിതവും സംരക്ഷിതവുമായ സ്ക്രിപ്റ്റ് ഡ്രാഫ്റ്റുകൾ നിർമ്മിക്കാനുള്ള കഴിവ്
• Set -euo pipefail, ശൂന്യമായ വേരിയബിൾ ചെക്കിംഗ്, ഡ്രൈ-റൺ മോഡ്, ലോഗിംഗ് എന്നിവ പോലുള്ള സ്ക്രിപ്റ്റുകളിലേക്ക് ഗാർഡ്‌റെയിലുകൾ ചേർക്കാനുള്ള കഴിവ്
• വിനാശകരമായ കമാൻഡുകൾ വായിക്കാനും ഒറ്റപ്പെട്ട അന്തരീക്ഷത്തിൽ ആദ്യം ഡ്രൈ-റൺ ഉപയോഗിച്ച് പരീക്ഷിക്കാനും സ്ക്രിപ്റ്റിൽ രഹസ്യം ഉൾച്ചേർക്കാതിരിക്കാനുള്ള അച്ചടക്കം പ്രയോഗിക്കാനുമുള്ള കഴിവ്.

DevOps-ൻ്റെ ആത്മാവ് ഒരു വാചകത്തിൽ സംഗ്രഹിച്ചിരിക്കുന്നു: "നിങ്ങൾ ചെയ്യുന്ന ജോലി രണ്ടുതവണ ഓട്ടോമേറ്റ് ചെയ്യുക." സ്വമേധയാ ചെയ്യുന്ന ഏതൊരു ആവർത്തന ജോലിയും - ലോഗ് ക്ലീനപ്പ്, ബാക്കപ്പ് എടുക്കൽ, സെർവർ ഹെൽത്ത് ചെക്ക്, ബാച്ച് ഫയൽ പ്രോസസ്സിംഗ് - സമയമെടുക്കുന്നു, ഒടുവിൽ മനുഷ്യ പിശകിനാൽ കേടാകുന്നു. സ്ക്രിപ്റ്റുകൾ ഈ ജോലികൾ ഏറ്റെടുക്കുന്നു: തുടർച്ചയായതും വിശ്വസനീയവും ആവർത്തിക്കാവുന്നതുമായ രീതിയിൽ കമാൻഡുകളുടെ ഒരു പരമ്പര നടപ്പിലാക്കുന്ന ചെറിയ പ്രോഗ്രാമുകൾ. DevOps പ്രൊഫഷണലുകൾ പതിവായി മൂന്ന് ഭാഷകൾ ഉപയോഗിക്കുന്നു: ബാഷ് (ലിനക്സ്/യുണിക്സ് ഷെൽ സ്ക്രിപ്റ്റുകൾക്ക്), പൈത്തൺ (സങ്കീർണ്ണമായ ലോജിക്ക്, എപിഐ കോളിംഗ്, ഡാറ്റ കൃത്രിമത്വം), പവർഷെൽ (വിൻഡോസ്, ക്ലൗഡ് മാനേജ്മെൻ്റ് എന്നിവയ്ക്കായി).

സ്‌ക്രിപ്റ്റ് ജനറേഷനിൽ ഏറ്റവും പ്രായോഗിക മൂല്യം നൽകുന്ന ഇടമാണ് AI: ഒരു വാക്യ വിവരണത്തിൽ നിന്ന് ഒരു വർക്കിംഗ് ഡ്രാഫ്റ്റ് നിർമ്മിക്കുക, നിഗൂഢമായ ഒരു ബഗ് പരിഹരിക്കുക, ഒരു സ്‌ക്രിപ്റ്റ് മറ്റൊരു ഭാഷയിലേക്ക് വിവർത്തനം ചെയ്യുക. എന്നാൽ അന്ധമായി പ്രവർത്തിപ്പിക്കുമ്പോൾ ഒരു സ്‌ക്രിപ്റ്റ് അപകടകരമാണ് - തെറ്റായ rm, ഒരു Remove-Item -Recurse ഫയലുകളെ മാറ്റാനാകാതെ ഇല്ലാതാക്കും. അതുകൊണ്ടാണ് ഈ യൂണിറ്റിൻ്റെ മുദ്രാവാക്യം: AI സ്ക്രിപ്റ്റ് എഴുതാൻ അനുവദിക്കുക, നിങ്ങൾ അത് വായിക്കുക, ആദ്യം സുരക്ഷിത മോഡിൽ ശ്രമിക്കുക, തുടർന്ന് അത് പ്രവർത്തിപ്പിക്കുക.

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

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

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

സുരക്ഷിതമായ സ്ക്രിപ്റ്റിംഗിൻ്റെ അവശ്യകാര്യങ്ങൾ

ഒരു പ്രൊഡക്ഷൻ സ്‌ക്രിപ്റ്റിൽ ഈ ഗാർഡ്‌റെയിലുകൾ അടങ്ങിയിരിക്കണം:

• പിശകുണ്ടായാൽ നിർത്തുന്നു. ബാഷ്: set -euo pipefail. PowerShell: $ErrorActionPreference = 'നിർത്തുക'. ഒരു ഘട്ടം പരാജയപ്പെട്ടാൽ, അടുത്തത് പ്രവർത്തിക്കില്ല.
• ഐഡമ്പറ്റൻസി (ആവർത്തനക്ഷമത). സ്ക്രിപ്റ്റ് രണ്ടുതവണ പ്രവർത്തിക്കുകയാണെങ്കിൽ, അത് ഇരട്ടി കേടുപാടുകൾ വരുത്തരുത്; "നിങ്ങൾക്ക് ഇത് ഇതിനകം ഉണ്ടെങ്കിൽ, അത് ഒഴിവാക്കുക" യുക്തി.
• അംഗീകാരവും ഡ്രൈ-റണ്ണും. വിനാശകരമായ പ്രവർത്തനങ്ങൾക്ക് "നിങ്ങൾക്ക് ഉറപ്പാണോ?" അല്ലെങ്കിൽ --ഡ്രൈ-റൺ ഫ്ലാഗ്.
• ഇൻപുട്ട് മൂല്യനിർണ്ണയം. പാരാമീറ്ററുകൾ പ്രതീക്ഷിച്ചതുപോലെയാണോ? ഒരു ശൂന്യമായ വേരിയബിളിന് rm -rf "$DIR"/ എന്നതിനെ rm -rf / disaster ആക്കി മാറ്റാൻ കഴിയും.
• ലോഗിംഗ്. എന്ത്, എപ്പോൾ ചെയ്തു എന്നതിൻ്റെ രേഖ.

നുറുങ്ങ്: ശൂന്യമായ വേരിയബിൾ ഉപയോഗിച്ച് ഇല്ലാതാക്കുന്നതാണ് ബാഷിലെ ഏറ്റവും അപകടകരമായ തെറ്റ്. $DIR ശൂന്യമാണെങ്കിൽ റൂട്ട് ഡയറക്ടറി ഇല്ലാതാക്കാൻ rm -rf "$DIR" ശ്രമിക്കുന്നു. സെറ്റ് -u (നിർവചിക്കാത്ത വേരിയബിളിൽ നിർത്തുക) കൂടാതെ ഇല്ലാതാക്കുന്നതിന് മുമ്പ് [ -n "$DIR" ] പരിശോധിക്കുന്നത് ഒരു ലൈഫ് സേവർ ആണ്. AI-യിൽ നിന്ന് സ്ക്രിപ്റ്റുകൾ അഭ്യർത്ഥിക്കുമ്പോൾ ഈ പരിരക്ഷകൾ വ്യക്തമായി അഭ്യർത്ഥിക്കുക.

സുരക്ഷ: രഹസ്യവും വിനാശകരവുമായ കമാൻഡുകൾ

രണ്ട് വലിയ അപകടങ്ങൾ:

1. സ്ക്രിപ്റ്റിൽ രഹസ്യം ഉൾച്ചേർക്കുന്നു. ടോക്കൺ സ്‌ക്രിപ്റ്റിനുള്ളിൽ പാസ്‌വേഡ് പ്ലെയിൻ ടെക്‌സ്‌റ്റ് ആയിരിക്കരുത്; പരിസ്ഥിതി വേരിയബിളിൽ നിന്നോ നിലവറയിൽ നിന്നോ വായിച്ചിരിക്കണം. സ്ക്രിപ്റ്റുകൾ Git-ലേക്ക് പോകുന്നു; കുഴിച്ചിട്ട രഹസ്യം സ്ഥിരമായ ചോർച്ചയാണ്.
2. വിനാശകരമായ കമാൻഡുകൾ. rm -rf, Remove-Item -Recurse -Force, DROP TABLE, terraform destroy — ഇവ ഒരു സ്ക്രിപ്റ്റിൽ കാണുമ്പോൾ, നിർത്തി രണ്ടുതവണ ചിന്തിക്കുക. പ്രോഡിൽ AI സൃഷ്ടിച്ച വിനാശകരമായ കമാൻഡ് ഒരിക്കലും പരീക്ഷിക്കരുത്.

മുന്നറിയിപ്പ്: "ഈ ഫയലുകൾ വൃത്തിയാക്കുന്ന ഒരു സ്‌ക്രിപ്റ്റ് എഴുതാൻ" നിങ്ങൾ AI-യോട് പറയുമ്പോൾ, അത് ഉത്പാദിപ്പിക്കുന്ന കണ്ടെത്തൽ ... -delete അല്ലെങ്കിൽ rm കമാൻഡിൻ്റെ വ്യാപ്തി ശ്രദ്ധാപൂർവ്വം വായിക്കുക. ഒരു വൈൽഡ് കാർഡ് (*) അല്ലെങ്കിൽ തെറ്റായ പാത നിങ്ങൾ ഇല്ലാതാക്കാൻ ആഗ്രഹിക്കുന്നതിനേക്കാൾ കൂടുതൽ ഇല്ലാതാക്കും. എല്ലായ്‌പ്പോഴും സ്‌ക്രിപ്റ്റ് ആദ്യം ഇല്ലാതാക്കുന്നതിന് പകരം "ലിസ്‌റ്റ് ടു ഡിലീറ്റ്" മോഡിൽ പ്രവർത്തിപ്പിക്കുക.

മൂന്ന് ഭാഷകളുടെ താരതമ്യം

മാനദണ്ഡം

ബാഷ്

പൈത്തൺ

പവർഷെൽ

എവിടെയാണ് നല്ലത്

ലിനക്സ് ഷെൽ, കമാൻഡ് ചെയിൻ

കോംപ്ലക്സ് ലോജിക്, API, ഡാറ്റ

വിൻഡോസ് ക്ലൗഡ് മാനേജ്മെൻ്റ്

പഠന വക്രം

ഇടത്തരം (കുടുങ്ങിയത്)

എളുപ്പമുള്ള

ഇടത്തരം

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

സെറ്റ് -euo പൈപ്പ് പരാജയം

ശ്രമിക്കുക/ഒഴികെ

ശ്രമിക്കുക/പിടിക്കുക, -ErrorAction

പോർട്ടബിലിറ്റി

Unix/Linux/mac

എല്ലായിടത്തും

ക്രോസ്-പ്ലാറ്റ്ഫോം (PS 7+)

എപ്പോൾ

ചുരുക്കത്തിൽ, സിസ്റ്റം പ്രവർത്തിക്കുന്നു

20 വരികളിൽ കൂടുതൽ നീളമുള്ള ലോജിക്

Windows/AD/Azure

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

കേസ് 1 - 2 മണിക്കൂർ ക്രാഫ്റ്റ് 5 മിനിറ്റിനുള്ളിൽ. ഓരോ ആഴ്ചയും 40 സെർവറുകളിൽ നിന്ന് ലോഗുകൾ ശേഖരിക്കാനും ആർക്കൈവ് ചെയ്യാനും ഒരു എഞ്ചിനീയർ 2 മണിക്കൂർ ചെലവഴിക്കുന്നു. ടാസ്‌ക് വിവരിക്കുകയും -euo pipefail + ഡ്രൈ-റൺ പരിരക്ഷകൾ സജ്ജമാക്കുകയും ഒരു ബാഷ് സ്‌ക്രിപ്‌റ്റ് സൃഷ്‌ടിക്കുകയും ചെയ്‌ത അദ്ദേഹം AI-യെ ചുമതലപ്പെടുത്തി. ആദ്യം ഡ്രൈ-റൺ ഉപയോഗിച്ച് സ്ക്രിപ്റ്റ് സാധൂകരിക്കുകയും പിന്നീട് അത് ഷെഡ്യൂൾ ചെയ്ത ടാസ്ക്കിലേക്ക് (ക്രോൺ) ലിങ്ക് ചെയ്യുകയും ചെയ്തു. പ്രതിവാര ജോലി 5 മിനിറ്റായി കുറയ്ക്കുകയും മനുഷ്യ പിശക് ഇല്ലാതാക്കുകയും ചെയ്യുന്നു.

കേസ് 2 - നൾ വേരിയബിൾ ദുരന്തം ഒഴിവാക്കി. AI നിർമ്മിച്ച ക്ലീനിംഗ് സ്ക്രിപ്റ്റിൽ rm -rf "$TARGET"/* ഉണ്ടായിരുന്നു, എന്നാൽ എവിടെയെങ്കിലും TARGET അസൈൻ ചെയ്‌തില്ലെങ്കിൽ, അത് ശൂന്യമായി തുടരും. എഞ്ചിനീയറായി പഠിക്കുമ്പോൾ അദ്ദേഹം ഇത് തിരിച്ചറിഞ്ഞു; set -u കൂടാതെ [ -n "$TARGET" ] || എക്സിറ്റ് 1 നിയന്ത്രണം ചേർത്തു. പരിശോധനയ്ക്കിടെ വേരിയബിൾ അസാധുവായി തുടരുകയും സ്ക്രിപ്റ്റ് അപകടകരമാകാതെ സുരക്ഷിതമായി നിലക്കുകയും ചെയ്തു.

കേസ് 3 - ഉൾച്ചേർത്ത ടോക്കൺ പിടിച്ചെടുത്തു. സൗകര്യാർത്ഥം, AI ഒരു API ആവശ്യപ്പെടുന്ന പൈത്തൺ സ്ക്രിപ്റ്റിലേക്ക് TOKEN = "ghp_realtoken" ലൈൻ ചേർത്തു (ഉദാഹരണമായി). എഞ്ചിനീയർ ഇത് നീക്കം ചെയ്യുകയും os.environ["TOKEN"] ഉപയോഗിച്ച് എൻവയോൺമെൻ്റ് വേരിയബിളിൽ നിന്ന് റീഡിംഗ് ആക്കി മാറ്റുകയും ടോക്കൺ റദ്ദാക്കുകയും പുതുക്കുകയും ചെയ്തു. സ്‌ക്രിപ്റ്റ് Git-ലേക്ക് പോയാൽ, ടോക്കൺ പബ്ലിക് ആയിരിക്കും.

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

1) സുരക്ഷിത ബാഷ് സ്ക്രിപ്റ്റ്:

ഒരു ബാഷ് സ്ക്രിപ്റ്റ് എഴുതുക: [TASK]. നിർബന്ധിത നിയമങ്ങൾ:- തുടക്കത്തിൽ തന്നെ `set -euo pipefail`.- എവിടെ ഇല്ലാതാക്കുന്നു/ചലിക്കുന്നിടത്ത് വേരിയബിൾ ശൂന്യമല്ലെന്ന് പരിശോധിക്കുക.- `--dry-run` ഫ്ലാഗ്: ഈ മോഡിൽ എന്താണ് ചെയ്യേണ്ടതെന്ന് എഴുതുക എന്നാൽ അത് ചെയ്യരുത്.- രഹസ്യം ഉൾച്ചേർക്കരുത്; പരിസ്ഥിതി വേരിയബിളിൽ നിന്ന് വായിക്കുക. - ഓരോ ഘട്ടത്തിലും വിജ്ഞാന രേഖ അച്ചടിക്കുക. സ്ക്രിപ്റ്റ് കമൻ്റ് ചെയ്ത് ഏറ്റവും അപകടകരമായ ലൈൻ അടയാളപ്പെടുത്തുക.

2) സ്ക്രിപ്റ്റ് വിവരണം/നിയന്ത്രണം:

ഇനിപ്പറയുന്ന സ്ക്രിപ്റ്റ് വരി വരിയായി വിവരിക്കുക, സുരക്ഷയ്ക്കായി പരിശോധിക്കുക: ഉൾച്ചേർത്ത രഹസ്യം, വിനാശകരമായ കമാൻഡ് (rm/Remove-Item/DROP), അസാധുവായ ഇൻപുട്ട്, പിശക് കൈകാര്യം ചെയ്യാനുള്ള അഭാവം? പ്രാധാന്യത്തിൻ്റെയും തിരുത്തലിൻ്റെയും ക്രമത്തിൽ ഓരോ അപകടസാധ്യതയും എഴുതുക. സ്ക്രിപ്റ്റ്: [കോഡ്]

3) ഭാഷാ വിവർത്തനം:

ആ [SOURCE LANGUAGE] സ്ക്രിപ്റ്റ് [TARGET LANGUAGE] എന്നതിലേക്ക് വിവർത്തനം ചെയ്യുക. പെരുമാറ്റം പദാനുപദമായി സൂക്ഷിക്കുക, ടാർഗെറ്റ് ഭാഷയുടെ ഭാഷാപരമായ പിശക് കൈകാര്യം ചെയ്യുക, ഉൾച്ചേർത്ത രഹസ്യങ്ങൾ ഒരു പരിസ്ഥിതി വേരിയബിളിലേക്ക് നീക്കുക. വ്യത്യസ്തമായി പെരുമാറിയേക്കാവുന്ന പോയിൻ്റുകൾ ശ്രദ്ധിക്കുക. സ്ക്രിപ്റ്റ്: [കോഡ്]

4) ആസൂത്രിതമായ ടാസ്‌ക് (ക്രോൺ/ഷെഡ്യൂൾഡ് ടാസ്‌ക്):

ഈ സ്ക്രിപ്റ്റ് ഉപയോഗിക്കുക [ആവൃത്തി: ഉദാ. ഒരു ഷെഡ്യൂൾ നിർവചനം എഴുതുക ([cron / systemd ടൈമർ / വിൻഡോസ് ടാസ്ക് ഷെഡ്യൂളർ]) അത് [എല്ലാ രാത്രിയും 02:00 മണിക്ക്] പ്രവർത്തിക്കും. പരാജയത്തെക്കുറിച്ച് എനിക്ക് എങ്ങനെ മുന്നറിയിപ്പ് നൽകാമെന്നും (ലോഗ്/എക്സിറ്റ് കോഡ്/അറിയിപ്പ്) ഓവർലാപ്പ് എങ്ങനെ തടയാമെന്നും ചേർക്കുക.

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

ദുർബലമായത്: "പഴയ ഫയലുകൾ ഇല്ലാതാക്കുന്ന ഒരു സ്ക്രിപ്റ്റ് എഴുതുക."

ഫലം: ഒരു സ്കോപ്പില്ലാത്ത, സുരക്ഷിതമല്ലാത്ത, ഡ്രൈ-റൺലെസ്സ് rm സ്ക്രിപ്റ്റ്; തെറ്റായ ഫോൾഡറിലാണ് ഇത് പ്രവർത്തിക്കുന്നതെങ്കിൽ, അത് മാറ്റാനാകാതെ ഇല്ലാതാക്കും.

ശക്തമായത്: "/var/log/app-ന് കീഴിൽ 30 ദിവസത്തിലധികം പഴക്കമുള്ള .log ഫയലുകൾ ഇല്ലാതാക്കാൻ ഒരു ബാഷ് സ്‌ക്രിപ്റ്റ് എഴുതുക. set -euo pipefail ഉപയോഗിക്കുക, ടാർഗെറ്റ് ഡയറക്‌ടറി ശൂന്യമാണെങ്കിൽ നിർത്തുക, --dry-run ഉപയോഗിച്ച് ഇല്ലാതാക്കേണ്ടവ ലിസ്റ്റ് ചെയ്യുക, എല്ലാ ഇടപാടുകളും ലോഗ് ചെയ്യുക, രഹസ്യം ഉൾച്ചേർക്കരുത്. ഏറ്റവും അപകടകരമായ ലൈൻ അടയാളപ്പെടുത്തുക."

വ്യത്യാസം: രണ്ടാമത്തെ ക്ലെയിം പൂർണ്ണ വ്യാപ്തിയും സുരക്ഷാ ഗാർഡ്‌റെയിലുകളും ഡ്രൈ-റൺ പ്രതീക്ഷയും നൽകുന്നു; ഔട്ട്പുട്ട് സുരക്ഷിതമായി പ്രവർത്തിപ്പിക്കാൻ കഴിയും.

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

• സ്ക്രിപ്റ്റ് വായിക്കാതെ പ്രവർത്തിപ്പിക്കുന്നു. പ്രത്യേകിച്ച് വരികൾ ഇല്ലാതാക്കുക/നീക്കുക എന്നത് ദുരന്തത്തിലേക്ക് നയിക്കുന്നു.
• ശൂന്യമായ വേരിയബിളുകൾക്കായി പരിശോധിക്കുന്നില്ല. rm -rf "$X"/ ഉപയോഗിച്ച് റൂട്ട് ഡയറക്‌ടറി ഇല്ലാതാക്കുന്നതിൻ്റെ ക്ലാസിക് ദുരന്തം.
• `set -euo pipefail` / `-ErrorAction Stop` ഒഴിവാക്കുക. ഒരു ചുവടുവെപ്പ്, സ്ക്രിപ്റ്റ് അന്ധമായി തുടരുന്നു.
• സ്ക്രിപ്റ്റിൽ രഹസ്യം ഉൾച്ചേർക്കുന്നു. Git-ലേക്ക് സ്ഥിരമായ ചോർച്ച.
• ഡ്രൈ-റൺ ഇല്ലാതെ വിനാശകരമായ പ്രക്രിയ. ആദ്യം "എന്താണ് ചെയ്യേണ്ടതെന്ന് എന്നെ കാണിക്കൂ", എന്നിട്ട് അത് ചെയ്യുക.
• ഉൽപ്പന്നത്തിൽ ആദ്യ ശ്രമം നടത്തുന്നു. ഒറ്റപ്പെട്ട ടെസ്റ്റ് പരിതസ്ഥിതി ഇല്ലാതെ പ്രവർത്തിക്കുന്നു.

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

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

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

ഒരു ആവർത്തിച്ചുള്ള ടാസ്ക്ക് തിരഞ്ഞെടുക്കുക (ലോഗ് ആർക്കൈവിംഗ്, ബാക്കപ്പ്, ക്ലീനിംഗ്). (1) "സെക്യൂർ ബാഷ് സ്‌ക്രിപ്റ്റ്" ടെംപ്ലേറ്റ് ഉപയോഗിച്ച് ഒരു സംരക്ഷിത സ്‌ക്രിപ്റ്റ് സൃഷ്‌ടിക്കാൻ AI-യെ അനുവദിക്കുക. (2) "സ്ക്രിപ്റ്റ് വിവരണം/ഓഡിറ്റ്" ടെംപ്ലേറ്റ് പോലെ സുരക്ഷയ്ക്കായി അതേ സ്ക്രിപ്റ്റ് പരിശോധിച്ച് AI ഫ്ലാഗ് ചെയ്ത ഏറ്റവും അപകടകരമായ ലൈൻ കണ്ടെത്തുക. (3) ഒരു ടെസ്റ്റ് ഫോൾഡറിൽ സാമ്പിൾ ഫയലുകൾ ഉപയോഗിച്ച് സ്ക്രിപ്റ്റ് പ്രവർത്തിപ്പിച്ച് അതിൻ്റെ സ്വഭാവം പരിശോധിക്കുക, ആദ്യം --dry-run ഉപയോഗിച്ച്.

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

• [ ] എനിക്ക് ആവശ്യമില്ലാത്ത ടാസ്‌ക്, OS/ഷെൽ, സെക്യൂരിറ്റി ഗാർഡ്‌റെയിലുകൾ എന്നിവ ഞാൻ എഴുതി.
• [ ] സ്ക്രിപ്റ്റിന് സെറ്റ് -euo pipefail / -ErrorAction Stop പോലെ നിർത്തുന്നതിൽ പിശകുണ്ട്.
• [ ] ഞാൻ ശൂന്യമായ വേരിയബിളും ഇൻപുട്ട് പരിശോധനയും ഇല്ലാതാക്കി/നീക്കുന്നതിന് മുമ്പ് ചേർത്തു.
• [ ] വിനാശകരമായ പ്രവർത്തനങ്ങൾക്ക് --ഡ്രൈ-റൺ/സ്ഥിരീകരണ സംവിധാനം ഉണ്ട്.
• [ ] സ്ക്രിപ്റ്റിൽ ഒരു രഹസ്യവും ഉൾച്ചേർത്തിട്ടില്ല; പരിസ്ഥിതി വേരിയബിൾ/കേസിൽ നിന്നാണ് മൂല്യങ്ങൾ വരുന്നത്.
• [ ] ഡ്രൈ-റൺ ഉള്ള ഒരു ഒറ്റപ്പെട്ട ടെസ്റ്റ് പരിതസ്ഥിതിയിൽ ഞാൻ ആദ്യ ടെസ്റ്റ് നടത്തി.