DevOps, Cloud AI എന്നിവയിലേക്കുള്ള ആമുഖം: റോളുകൾ, അതിരുകൾ, ആധികാരികത, സുരക്ഷ, രഹസ്യങ്ങൾ

നേട്ടങ്ങൾ:

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

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

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

DevOps ശൃംഖലയിൽ എവിടെയാണ് AI ഉപയോഗപ്രദമാകുന്നത്?

നമുക്ക് DevOps ജോലികളെ രണ്ട് വലിയ ക്ലസ്റ്ററുകളായി തിരിക്കാം. ആദ്യ ക്ലസ്റ്റർ: ആവർത്തന, വാചകം, ഘടനാപരമായ ജോലികൾ. ഒരു CI/CD (തുടർന്നുള്ള സംയോജനം / തുടർച്ചയായ ഡെലിവറി - കോഡ് സ്വയമേവ പരിശോധിച്ച് പുറത്തുവിടുന്ന പൈപ്പ്ലൈൻ) വിവരണം എഴുതുക, ഒരു ഡോക്കർഫിൽ ഡ്രാഫ്റ്റ് ചെയ്യുക (ഒരു ആപ്ലിക്കേഷൻ ഒരു കണ്ടെയ്‌നറിലേക്ക് പാക്കേജ് ചെയ്യുന്ന റെസിപ്പി ഫയൽ), സങ്കീർണ്ണമായ ഒരു ടെറാഫോം (അടിസ്ഥാന സൗകര്യങ്ങളെ നിർവചിക്കുന്ന ഉപകരണം) വിശദീകരിക്കൽ (കോഡായി നിർവചിക്കുന്ന ഉപകരണം) ലോഗ് സ്റ്റാക്ക് സംഗ്രഹിച്ച് സിസ്റ്റം നിർമ്മിക്കുന്നു. അപാകത, ഒരു ബാഷ് സ്ക്രിപ്റ്റ് ഡ്രാഫ്റ്റിംഗ്. ഈ ടാസ്‌ക്കുകളിൽ, AI മിനിറ്റുകൾ മുതൽ സെക്കൻഡുകൾ വരെ കുറയ്ക്കുന്നു, മാത്രമല്ല ക്ഷീണിതനാകില്ല.

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

നമുക്ക് ഒരു വാചകത്തിൽ വ്യത്യാസം വ്യക്തമാക്കാം: "ഈ കോൺഫിഗറേഷൻ എന്ത് ചെയ്യുന്നു, എങ്ങനെ എഴുതാം" എന്നീ ചോദ്യങ്ങളിൽ AI ശക്തമാണ്; "ഞാൻ ഇത് ഉൽപ്പന്നത്തിൽ പ്രയോഗിക്കണോ, ആരാണ് ഇതിന് ഉറപ്പ് നൽകുന്നത്?" തുടങ്ങിയ ചോദ്യങ്ങൾ വരുമ്പോൾ തീരുമാനം നിങ്ങളുടേതാണ്.

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

ഘട്ടം ഘട്ടമായി: AI- പവർ ചെയ്യുന്ന DevOps ബിസിനസ്സ് എങ്ങനെ പ്രവർത്തിക്കും?

1. സന്ദർഭം ശേഖരിക്കുക. ഏത് ക്ലൗഡ് (AWS, Azure, GCP), ഏത് ടൂൾ പതിപ്പ്, എന്ത് നിയന്ത്രണങ്ങൾ? നിങ്ങൾ AI അപൂർണ്ണമായ സന്ദർഭം നൽകുകയാണെങ്കിൽ, നിങ്ങൾക്ക് അപൂർണ്ണവും അപകടകരവുമായ ഔട്ട്പുട്ട് ലഭിക്കും.
2. വ്യക്തമായ ജോലികൾ നിർവ്വചിക്കുക. "ഒരു പൈപ്പ്ലൈൻ എഴുതുക" അല്ല; "GitHub ആക്‌ഷനുകൾ ഉപയോഗിച്ച്, പുഷിൽ പ്രവർത്തിക്കുന്ന, ടെസ്റ്റുകൾ നടത്തുന്ന, ഡോക്കർ ഇമേജ് നിർമ്മിക്കുന്ന, പക്ഷേ അത് വിന്യസിക്കാത്ത ഒരു വർക്ക്ഫ്ലോ എഴുതുക."
3. ഡ്രാഫ്റ്റ് നിർമ്മിക്കുക. ആദ്യ പതിപ്പ് എഴുതാൻ AI-യെ അനുവദിക്കുക.
4. സ്ഥിരീകരിക്കുക. വാക്യഘടന പരിശോധിക്കുക, രഹസ്യാത്മക വിവരങ്ങൾ ചോർന്നിട്ടുണ്ടോയെന്ന് കാണുക, ഡ്രൈ-റൺ ഉപയോഗിച്ച് പരിശോധിക്കുക (എന്താണ് ചെയ്യേണ്ടതെന്ന് ആപ്ലിക്കേഷനെ കാണിക്കുന്ന ഒരു മോഡ്).
5. സാൻഡ്‌ബോക്‌സിൽ ഇത് പരീക്ഷിക്കുക. ഉൽപ്പന്നത്തിൽ ആദ്യ ശ്രമം ഒരിക്കലും ചെയ്യരുത്; ഒരു ടെസ്റ്റിംഗ്/സ്റ്റേജിംഗ് പരിതസ്ഥിതിയിൽ പ്രവർത്തിപ്പിക്കുക.
6. ക്രമേണ പ്രയോഗിക്കുക, നിരീക്ഷിക്കുക. മെട്രിക്കുകളും ലോഗുകളും നിരീക്ഷിച്ച് ഇത് തത്സമയം നേടുക.

സ്ഥിരീകരണ അച്ചടക്കം: മൂന്ന് ഘട്ടങ്ങൾ

AI ഒഴുക്കോടെയും ആത്മവിശ്വാസത്തോടെയും സംസാരിക്കുന്നു; അതിനർത്ഥം അത് സത്യമാണെന്നല്ല. AI ഇടയ്ക്കിടെ ഭ്രമാത്മകത സൃഷ്ടിക്കുന്നു - നിലവിലില്ലാത്ത ഒരു കമാൻഡ് ഫ്ലാഗ്, ഒരു ക്ലൗഡ് സേവന നാമം അല്ലെങ്കിൽ ഒരു കോൺഫിഗറേഷൻ കീ യഥാർത്ഥമായി ഉണ്ടാക്കുന്നു. DevOps-ൽ, ഒരു വ്യാജ --ഫോഴ്സ് ഫ്ലാഗിന് ഡാറ്റ ഇല്ലാതാക്കാൻ കഴിയും, അതേസമയം ഒരു വ്യാജ IAM (ഐഡൻ്റിറ്റി ആൻഡ് ആക്സസ് മാനേജ്മെൻ്റ്) അനുമതി ഒരു സുരക്ഷാ അപകടസാധ്യത സൃഷ്ടിക്കുന്നു. റിഫ്ലെക്സ്:

1. ഇത് ഉറവിടത്തിലേക്ക് ബന്ധിപ്പിക്കുക. AI നൽകുന്ന എല്ലാ കമാൻഡും ഫ്ലാഗും യഥാർത്ഥത്തിൽ ഔദ്യോഗിക ഡോക്യുമെൻ്റേഷനിലാണോ? "ഈ ഫ്ലാഗ് ഏത് പതിപ്പിലാണ് വരുന്നതെന്നും ഔദ്യോഗിക പ്രമാണത്തിൽ അതിൻ്റെ പേരും പറയൂ" എന്ന് ചോദിക്കുക; ഉറപ്പില്ലെങ്കിൽ, വിശ്വസിക്കരുത്.
2. ഉണക്കി ഓടുക. ടെറാഫോം പ്ലാൻ, kubectl --dry-run, --check പോലുള്ള മോഡുകൾ ഉപയോഗിച്ച് യഥാർത്ഥത്തിൽ ഇത് പ്രയോഗിക്കാതെ എന്താണ് സംഭവിക്കുന്നതെന്ന് കാണുക.
3. സിസ്റ്റം ഫിൽട്ടറിലൂടെ കടന്നുപോകുക. ഔട്ട്‌പുട്ട് നിങ്ങളുടെ ആർക്കിടെക്ചർ, സുരക്ഷാ നയം, ലഭ്യമായ ഉറവിട നാമങ്ങൾ എന്നിവയുമായി പൊരുത്തപ്പെടുന്നുണ്ടോ? നിങ്ങളുടെ ഡൊമെയ്ൻ അറിവാണ് അന്തിമ ഫിൽട്ടർ.

ശ്രദ്ധിക്കുക: "AI അങ്ങനെ എഴുതി" എന്നത് ഒരു ന്യായീകരണമല്ല. ഒരു പ്രൊഡക്ട് തടസ്സമുണ്ടായാൽ, ഉത്തരവാദിത്തം AI-യുടെതല്ല, അത് പരിശോധിക്കാതെ ആ കമാൻഡ് പ്രവർത്തിപ്പിക്കുന്ന വ്യക്തിക്കാണ്. ഒരു rm -rf വായിക്കാതെ എക്സിക്യൂട്ട് ചെയ്യുന്നതുപോലെ തന്നെ അപകടസാധ്യതയുള്ളതാണ് സ്ഥിരീകരിക്കാത്ത AI കമാൻഡ്.

സുരക്ഷയും രഹസ്യങ്ങളും: ഒരിക്കലും ചോർച്ച ചെയ്യരുത്

DevOps-ലെ ഏറ്റവും നിർണായകമായ സ്വകാര്യതാ നിയമം രഹസ്യങ്ങളെക്കുറിച്ചാണ്. രഹസ്യം; ഇത് പാസ്‌വേഡ്, API കീ, ഡാറ്റാബേസ് കണക്ഷൻ സ്ട്രിംഗ്, സ്വകാര്യ സർട്ടിഫിക്കറ്റ് എന്നിവ പോലുള്ള രഹസ്യാത്മക വിവരങ്ങളാണ്, അത് വിട്ടുവീഴ്ച ചെയ്യപ്പെടുകയാണെങ്കിൽ നിങ്ങളുടെ മുഴുവൻ സിസ്റ്റവും തുറക്കാനാകും. ഒരു AI പ്രോംപ്റ്റിൽ യഥാർത്ഥ രഹസ്യങ്ങളൊന്നും ഒട്ടിക്കരുത്. ഒരു കോഡിൻ്റെ ഒരു ബ്ലോക്കിൽ ഒരു യഥാർത്ഥ AWS ആക്‌സസ് കീയോ .env ഫയലിൻ്റെ ഉള്ളടക്കമോ പ്രൊഡക്ഷൻ ഡാറ്റാബേസ് പാസ്‌വേഡോ അടങ്ങിയിട്ടുണ്ടെങ്കിൽ, AI-ക്ക് നൽകുന്നതിന് മുമ്പ് AKIA... എന്നതിന് പകരം <AWS_ACCESS_KEY> പോലുള്ള പ്ലെയ്‌സ്‌ഹോൾഡറുകൾ ഉപയോഗിച്ച് ഇവ മാസ്ക് ചെയ്യുക.

AI നിർമ്മിക്കുന്ന കോഡും പരിശോധിക്കുക: AI ചിലപ്പോൾ സൗകര്യാർത്ഥം രഹസ്യം നേരിട്ട് കോഡിലേക്ക് ഹാർഡ്കോഡ് ചെയ്യുന്ന ഉദാഹരണങ്ങൾ നിർമ്മിക്കുന്നു. ഇതൊരു സുരക്ഷാ വീഴ്ചയാണ്. വാസ്തവത്തിൽ, രഹസ്യങ്ങൾ ഒരു രഹസ്യ നിലവറയിൽ (വോൾട്ട്, AWS സീക്രട്ട്സ് മാനേജർ, അസൂർ കീ വോൾട്ട്) സൂക്ഷിക്കുകയും റൺ ടൈമിൽ എൻവയോൺമെൻ്റ് വേരിയബിളുകളായി കുത്തിവയ്ക്കുകയും ചെയ്യുന്നു.

ഈ മേഖലയിലെ മറ്റൊരു ധാർമ്മികവും നിയമപരവുമായ പരിധി: പ്രതിരോധ ഉപയോഗം. നിങ്ങളുടെ സിസ്റ്റങ്ങൾ കഠിനമാക്കാനും, അപകടസാധ്യതകൾക്കായി സ്കാൻ ചെയ്യാനും, ലോഗുകളിൽ നിന്ന് ആക്രമണത്തിൻ്റെ സൂചനകൾ വേർതിരിച്ചെടുക്കാനും AI ഉപയോഗിക്കുക. മറ്റൊരാളുടെ സിസ്റ്റത്തിലേക്കുള്ള അനധികൃത ആക്‌സസ്, അനധികൃത സ്‌കാനിംഗ് അല്ലെങ്കിൽ ആക്രമണ ഉപകരണം സൃഷ്‌ടിക്കുന്നത് നിയമവിരുദ്ധവും ഈ പ്ലാറ്റ്‌ഫോമിൻ്റെ പരിധിക്ക് പുറത്തുള്ളതുമാണ്. നിങ്ങൾക്ക് അധികാരമുള്ളതും കരാറിലൂടെ രേഖാമൂലമുള്ള അനുമതി ലഭിച്ചിട്ടുള്ളതുമായ സിസ്റ്റങ്ങളിൽ എപ്പോഴും പ്രവർത്തിക്കുക.

ഏത് വാഹനത്തിലേക്ക് ഏത് ഡാറ്റയാണ് പോകുന്നത്?

ഡാറ്റ തരം

ഉദാഹരണം

അനുയോജ്യമായ വാഹനം

തുറന്ന ഡാറ്റ

ഔദ്യോഗിക പ്രമാണം, ഓപ്പൺ സോഴ്സ് കോഡ്

ഓരോ വാഹനവും

ആന്തരിക ഡാറ്റ (രഹസ്യമല്ല)

ജനറൽ ആർക്കിടെക്ചർ ഡയഗ്രം, ജനറിക് പൈപ്പ്ലൈൻ

സ്ഥാപനം അംഗീകരിച്ച വാഹനം

രഹസ്യാത്മകം/സെൻസിറ്റീവ്

രഹസ്യം, പ്രോഡ് ഐപി/ടോപ്പോളജി, ഉപഭോക്തൃ ഡാറ്റ

സ്ഥാപനം കരാർ ചെയ്ത ഒരു വാഹനം മാത്രം, അതിൻ്റെ ഡാറ്റ പരിശീലനത്തിന് പോകുന്നില്ല; മുഖംമൂടിയിലൂടെ

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

കേസ് 1 - ശരിയായ സ്ഥലത്ത് സമയം ലഭിച്ചു. ഒരു DevOps എഞ്ചിനീയർ 6 മണിക്കൂർ ചെലവഴിച്ചു, പഴയ 300-ലൈൻ ജെങ്കിൻസ് പൈപ്പ്ലൈൻ GitHub ആക്ഷൻസിലേക്ക് നീക്കി. AI ഘട്ടം ഘട്ടമായി വിശദീകരിക്കുകയും ഒരു ഡ്രാഫ്റ്റ് തയ്യാറാക്കുകയും ചെയ്തുകൊണ്ട് അദ്ദേഹം ജോലി 90 മിനിറ്റായി ചുരുക്കി. സ്റ്റേജിംഗിൽ AI നിർമ്മിച്ച ഓരോ ഘട്ടവും ഓരോന്നായി പരിശോധിച്ചുകൊണ്ട് അദ്ദേഹം ലാഭിച്ച സമയം ചെലവഴിച്ചു. AI മെക്കാനിക്കൽ വിവർത്തനം എടുത്തു; മൂല്യനിർണ്ണയം മനുഷ്യനിൽ തുടർന്നു.

കേസ് 2 - പരിശോധന ദുരന്തം ഒഴിവാക്കി. ടെറാഫോം ക്ലീനപ്പ് സ്ക്രിപ്റ്റിനായി ഒരു ടീം AI-യോട് ആവശ്യപ്പെട്ടു. AI ഒഴുക്കുള്ള കോഡ് നൽകി; എന്നാൽ എഞ്ചിനീയർ ടെറാഫോം പ്ലാൻ പ്രവർത്തിപ്പിച്ചപ്പോൾ, ഉപയോഗത്തിലുള്ള ഒരു പ്രൊഡക്ഷൻ ഡാറ്റാബേസ് ഇല്ലാതാക്കാൻ സ്ക്രിപ്റ്റ് പദ്ധതിയിട്ടിട്ടുണ്ടെന്ന് അദ്ദേഹം കണ്ടെത്തി - റിസോഴ്സ് ഫിൽട്ടർ AI തെറ്റായി ടൈപ്പ് ചെയ്തു. ഡ്രൈ റണ്ണിംഗ് മണിക്കൂറുകളോളം ഡാറ്റ നഷ്ടപ്പെടുന്നത് തടഞ്ഞു.

കേസ് 3 - രഹസ്യ ചോർച്ചയിൽ നിന്ന് മടങ്ങുക. "എന്തുകൊണ്ടാണ് ആ വിന്യസിക്കൽ പിശക്" എന്ന് ചോദിക്കുമ്പോൾ ഒരു ഇൻ്റേൺ മുഴുവൻ .env ഫയലും യഥാർത്ഥ പ്രൊഡക്ഷൻ ഡാറ്റാബേസ് പാസ്‌വേഡ് ഉള്ള ഒരു പൊതു ടൂളിലേക്ക് ഒട്ടിച്ചു. സീനിയർ എഞ്ചിനീയർ ഉടൻ തന്നെ താക്കോലുകൾ തിരിക്കുകയും പുനരുജ്ജീവിപ്പിക്കുകയും ചെയ്തു. <DB_PASSWORD> ഉപയോഗിച്ച് പാസ്‌വേഡ് മറയ്ക്കുകയും പിശക് സന്ദേശം മാത്രം പങ്കിടുകയും ചെയ്യുക എന്നതായിരുന്നു ശരിയായ മാർഗം.

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

1) ജോലി അനുയോജ്യത വിലയിരുത്തൽ:

നിങ്ങളുടെ റോൾ: മുതിർന്ന DevOps/SRE കൺസൾട്ടൻ്റ്. ഞാൻ നിങ്ങൾക്കായി ഒരു റോൾ വിവരിക്കും. എന്നോട് പറയൂ (1) ഇത് AI-ലേക്ക് സുരക്ഷിതമായി ഏൽപ്പിക്കാൻ കഴിയുന്ന ഡ്രാഫ്റ്റിംഗ്/അനാലിസിസ് ടാസ്‌ക് ആണോ അതോ ഉൽപ്പന്നത്തെ ബാധിക്കുന്ന ഒരു നിർണായക തീരുമാനമാണോ; (2) അത് തെറ്റായി സംഭവിച്ചാൽ ഏറ്റവും മോശമായ ഫലം പറയുക; (3) നടപ്പിലാക്കുന്നതിന് മുമ്പ് ചെയ്യേണ്ട പരിശോധനാ ഘട്ടങ്ങൾ പറയുക. ടാസ്ക്: [ഇവിടെ]

2) സുരക്ഷിതമായ സന്ദർഭം നൽകൽ (രഹസ്യ മാസ്കിംഗ്):

താഴെയുള്ള പിശക് വിശകലനം ചെയ്യുക. <PLACEHOLDER> ഉപയോഗിച്ച് ഞാൻ എല്ലാ രഹസ്യങ്ങളും മറച്ചുവച്ചു; സൊല്യൂഷനിൽ ഒരിക്കലും യഥാർത്ഥ രഹസ്യം നിർമ്മിക്കരുതെന്നും നിങ്ങൾ നിർദ്ദേശിക്കുന്നു, ഒരു പ്ലെയ്‌സ്‌ഹോൾഡർ ഉപയോഗിക്കുക, രഹസ്യ നിലവറയിൽ നിന്ന് വായിക്കുക, രഹസ്യം കോഡിൽ ഉൾപ്പെടുത്തുക. പിശക്/ലോഗ്: [മാസ്ക് ചെയ്ത ഉള്ളടക്കം]

3) കമാൻഡ് സ്ഥിരീകരണം:

ഈ കമാൻഡ് എന്നോട് വിശദീകരിക്കുക: ഓരോ ഫ്ലാഗും എന്താണ് ചെയ്യുന്നത്, ഏത് ടൂൾ പതിപ്പിന് അത് ബാധകമാണ്, അതിൻ്റെ ഏറ്റവും അപകടകരമായ പാർശ്വഫലങ്ങൾ എന്നിവ എഴുതുക. പ്രോഡിൽ ഇത് പ്രവർത്തിപ്പിക്കുന്നതിന് മുമ്പ് ചെയ്യേണ്ട 3 പരിശോധനകൾ അവസാനമായി ലിസ്റ്റ് ചെയ്യുക. കമാൻഡ്: [ഇവിടെ]

4) പഠനം/സങ്കൽപ്പം ചോദ്യം:

ഞാൻ [ ആശയം: ഉദാ. [നീല-പച്ച വിന്യാസം] എന്ന ആശയം നിങ്ങൾ ഒരു DevOps എഞ്ചിനീയർക്ക് വിശദീകരിക്കുന്നത് പോലെ വിശദീകരിക്കുക: അത് എന്താണ് ചെയ്യുന്നത്, എപ്പോൾ ഉപയോഗിക്കണം, എപ്പോൾ ഉപയോഗിക്കരുത്, 2 സാധാരണ തെറ്റുകൾ. സംക്ഷിപ്തവും മൂർത്തവുമായിരിക്കുക.

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

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

ഉപസംഹാരം: ഏത് മേഘം, ഏത് ഉപകരണം, ഏത് പരിസ്ഥിതി എന്നിവ വ്യക്തമല്ല; രഹസ്യം കോഡിലേക്ക് ഉൾച്ചേർക്കുന്ന ഒരു പൊതു, ഒരുപക്ഷേ നോൺ-പ്രോഡ് സ്ക്രിപ്റ്റ് AI നിർമ്മിക്കുന്നു.

ശക്തമായത്: "AWS ECS-ലേക്ക് (Elastic Container Service) വിന്യസിക്കുന്ന ഒരു ബാഷ് സ്‌ക്രിപ്റ്റിൻ്റെ ഡ്രാഫ്റ്റ് എഴുതുക. പ്രദേശം eu-central-1 ആണ്, ECR-ൽ നിന്നാണ് ചിത്രം വരുന്നത്. ഒരിക്കലും കോഡിൽ രഹസ്യങ്ങൾ ഉൾച്ചേർക്കരുത്, AWS സീക്രട്ട്‌സ് മാനേജറിൽ നിന്ന് അവ വായിക്കുക. ഓരോ ഘട്ടത്തിലും ഒരു പിശക് ഉണ്ടെങ്കിൽ, എല്ലാ നടപടികളും നിർത്തുക. ഉൽപ്പന്നം."

വ്യത്യാസം: രണ്ടാമത്തെ പ്രോംപ്റ്റ് ക്ലൗഡ്, ടൂൾ, പരിസ്ഥിതി, സുരക്ഷാ നിയമം, മൂല്യനിർണ്ണയ പ്രതീക്ഷ എന്നിവ നൽകുന്നു - ഔട്ട്പുട്ട് നേരിട്ട് ഉപയോഗപ്രദവും സുരക്ഷിതവുമാണ്.

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

• യഥാർത്ഥ രഹസ്യം പ്രോംപ്റ്റിലേക്ക് ഒട്ടിക്കുന്നു. ഏറ്റവും സാധാരണവും അപകടകരവുമായ തെറ്റ്. എപ്പോഴും മുഖംമൂടി.
• സന്ദർഭരഹിതമായ പ്രോംപ്റ്റ്. ക്ലൗഡ്, പതിപ്പ്, പരിസ്ഥിതി എന്നിവ വ്യക്തമാക്കാതെ, ആവശ്യമുള്ള ഔട്ട്‌പുട്ട് പലപ്പോഴും തെറ്റായ പതിപ്പിൻ്റെ അല്ലെങ്കിൽ തെറ്റായ ആർക്കിടെക്ചറിൻ്റേതാണ്.
• ഡ്രൈ റണ്ണിംഗ് ഒഴിവാക്കുന്നു. ആസൂത്രണം ചെയ്യാതെ/--ഡ്രൈ-റൺ നടപ്പിലാക്കുന്നത് DevOps-ലെ ഏറ്റവും ചെലവേറിയ കുറുക്കുവഴിയാണ്.
• ഉൽപ്പന്നത്തിൽ ആദ്യ ശ്രമം നടത്തുന്നു. എല്ലാ പുതിയ AI ഔട്ട്‌പുട്ടും ആദ്യം ടെസ്റ്റിംഗ്/സ്റ്റേജിംഗിൽ പ്രവർത്തിപ്പിക്കണം.
• "AI പറഞ്ഞു" ഉപയോഗിച്ച് ഉത്തരവാദിത്തം ഏൽപ്പിക്കുന്നു. ഉത്തരവാദിത്തം എല്ലായ്‌പ്പോഴും നടപ്പിലാക്കുന്ന എഞ്ചിനീയർക്കാണ്.
• ഭ്രമാത്മക പതാകയെ വിശ്വസിക്കുന്നു. അന്വേഷണമില്ലാതെ നിലവിലില്ലാത്ത ഒരു കമാൻഡ് ഫ്ലാഗ് എക്സിക്യൂട്ട് ചെയ്യുന്നു.

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

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

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

നിങ്ങളുടെ സ്വന്തം ജോലിയിൽ നിന്ന് (അല്ലെങ്കിൽ ഒരു സാമ്പിൾ പ്രോജക്‌റ്റിൽ) സമീപകാല DevOps ടാസ്‌ക് തിരഞ്ഞെടുക്കുക. (1) മുകളിലുള്ള "ജോലി അനുയോജ്യത വിലയിരുത്തൽ" ടെംപ്ലേറ്റ് ഉപയോഗിച്ച് AI-യോട് ഈ ടാസ്ക്ക് വിവരിക്കുകയും അതിൻ്റെ വർഗ്ഗീകരണം വായിക്കുകയും ചെയ്യുക. (2) അതിൽ രഹസ്യം അടങ്ങിയിട്ടുണ്ടെങ്കിൽ, അത് മറച്ചുവെച്ച് ഒരു സന്ദർഭ വാചകം തയ്യാറാക്കുക. (3) മൂന്ന്-ഘട്ട പരിശോധനയോടെ AI-യുടെ ഔട്ട്പുട്ട് പരിശോധിക്കുക, ഓരോ ഘട്ടത്തിലും നിങ്ങൾ തിരുത്തിയത് ഒരു വാക്യത്തിൽ രേഖപ്പെടുത്തുക.

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

• [ ] ഞാൻ എൻ്റെ ചുമതലയെ "നിയോഗിക്കാവുന്ന ജോലി" അല്ലെങ്കിൽ "നിർണ്ണായക തീരുമാനം" എന്ന് തരംതിരിച്ചു.
• [ ] ഞാൻ പ്രോംപ്റ്റിൽ യഥാർത്ഥ രഹസ്യങ്ങളൊന്നും ഒട്ടിച്ചിട്ടില്ല; ഞാൻ അവയെല്ലാം ഒരു പ്ലെയ്‌സ്‌ഹോൾഡർ ഉപയോഗിച്ച് മറച്ചു.
• [ ] ക്ലൗഡ്, ടൂൾ പതിപ്പ്, പരിസ്ഥിതി എന്നിവയുമായി ബന്ധപ്പെട്ട പ്രോംപ്റ്റിലേക്ക് ഞാൻ സന്ദർഭം ചേർത്തു.
• AI ഔട്ട്‌പുട്ട് പ്രയോഗിക്കുന്നതിന് മുമ്പ് ഞാൻ ഡ്രൈ റൺ/പ്ലാൻ ഉപയോഗിച്ച് പരിശോധിച്ചു.
• [ ] ഞാൻ ആദ്യ ശ്രമം നടത്തിയത് ടെസ്റ്റ്/സ്റ്റേജിംഗ് പരിതസ്ഥിതിയിലാണ്, പ്രോഡിൽ അല്ല.
• [ ] പ്രതിരോധ ആവശ്യങ്ങൾക്കായി എനിക്ക് അധികാരമുള്ള സിസ്റ്റങ്ങളിൽ മാത്രമാണ് ഞാൻ പ്രവർത്തിച്ചത്.