തെറ്റുകൾ വരുത്താൻ സാധ്യതയുള്ള ഒരു ഏജന്റിന് വേണ്ടി ആഴത്തിലുള്ള പ്രതിരോധം (Defense in Depth)
ഓരോ സുരക്ഷാ സംവിധാനത്തിനും ഒരു ബഗ് (bug) ഉണ്ടാകാം. അത് ഏതാണെന്ന് നിങ്ങൾക്ക് ഇതുവരെ അറിയില്ല എന്ന് മാത്രം.
പ്രൊഡക്ഷനായി ഒരു ഓട്ടോണമസ് ഏജന്റ് (autonomous agent) നിർമ്മിക്കാനുള്ള ഏക യുക്തിസഹമായ മാർഗ്ഗമാണിത്. മനസ്സാക്ഷി (conscience) ഒരു പ്രവൃത്തിയെ തെറ്റായി തരംതിരിച്ചേക്കാം. കൗൺസിൽ (council) ഒരു മോശം ആശയത്തിന് അംഗീകാരം നൽകിയേക്കാം. ഐസൊലേഷൻ വാളിന് (isolation wall) ഒരു വിടവ് ഉണ്ടാകാം.
ഓരോ പാളിയും (layer) ഒടുവിൽ പരാജയപ്പെടും.
ഒരു പരിപൂർണ്ണമായ പാളി എങ്ങനെ നിർമ്മിക്കാം എന്നതല്ല ഡിസൈൻ ചോദ്യം. ചോദ്യം ഇതാണ്: ഒരു പാളി പരാജയപ്പെടുമ്പോൾ അതിന് പിന്നിൽ എന്താണ് നിലകൊള്ളുന്നത്?
സിസ്റ്റത്തെ സംരക്ഷിക്കാൻ ഞാൻ ആറ് പാളികൾ ഉപയോഗിക്കുന്നു. ആദ്യത്തെ പാളികൾ കുറഞ്ഞ ചിലവുള്ളവയാണ്, കാരണം പ്രശ്നങ്ങൾ യാഥാർത്ഥ്യമാകുന്നതിന് മുമ്പ് തന്നെ അവയെ തടയാൻ അവയ്ക്ക് സാധിക്കുന്നു.
• L0 — സ്ട്രക്ചറൽ ഐസൊലേഷൻ (Structural isolation). അടിസ്ഥാന തലത്തിൽ തെറ്റായ ടെനന്റ് (tenant) പ്രവർത്തനങ്ങൾ തടയുന്നു. • L1 — ഐഡിയ-ഗേറ്റ് (Idea-gate). കോഡ് നിലവിൽ വരുന്നതിന് മുമ്പ്, ചർച്ചാ വേളയിൽ തന്നെ മോശം ആശയങ്ങളെ തടയുന്നു. • L2 — ആക്ഷൻ-ഗേറ്റ് (Action-gate). റിസ്ക് അടിസ്ഥാനമാക്കി കമാൻഡുകൾ അനുവദിക്കുകയോ നിരസിക്കുകയോ ചെയ്യുന്ന ഒരു പ്രതികരണം (reflex). • L3 — റിസോഴ്സ്-ഗേറ്റ് (Resource-gate). മെമ്മറി, ബജറ്റുകൾ, നിയന്ത്രണാതീതമായ ചിലവുകൾ എന്നിവ നിയന്ത്രിക്കുന്നു. • L4 — ഓഡിറ്റ് (Audit). ഓരോ തീരുമാനവും ട്രാക്ക് ചെയ്യാൻ മാറ്റം വരുത്താൻ കഴിയാത്ത രസീതുകൾ (tamper-evident receipts) ഉപയോഗിക്കുന്നു. • L5 — റിക്കവറി (Recovery). നിലവിലുള്ള നാശനഷ്ടങ്ങൾ തടയാൻ ക്വാറന്റൈനും (quarantine) റോൾബാക്കുകളും (rollbacks) ഉപയോഗിക്കുന്നു.
പാളികളുടെ ഒരു പട്ടിക മാത്രം ഉണ്ടെന്നതുകൊണ്ട് 'ഡെഫൻസ് ഇൻ ഡെപ്ത്' (defense in depth) ആകില്ല. യഥാർത്ഥ ആഴത്തിന് ഒരു നിയമം ആവശ്യമാണ്:
ഓരോ നിർണ്ണായകമായ റിസ്കും കുറഞ്ഞത് രണ്ട് സ്വതന്ത്ര പാളികൾ (independent layers) ഉപയോഗിച്ച് കണ്ടെത്തണം.
സ്വതന്ത്രം എന്നാൽ അവ ഒരേ കാരണത്താൽ പരാജയപ്പെടില്ല എന്നാണ് അർത്ഥം. രണ്ട് പരിശോധനകളും ഒരേ കോൺഫിഗറേഷനോ (config) ഒരേ സിഗ്നലോ ആണ് ഉപയോഗിക്കുന്നതെങ്കിൽ, അവ ഒരേ പരിശോധന തന്നെയാണ്. ആ സിഗ്നൽ പരാജയപ്പെടുമ്പോൾ, രണ്ട് പരിശോധനകളും പരാജയപ്പെടുന്നു.
ഇത് സംഭവിക്കുന്നത് ഞാൻ കണ്ടിട്ടുണ്ട്. ഒരിക്കൽ എന്റെ ഐഡിയ-ഗേറ്റ് (idea-gate), നടക്കാത്ത ഒരു ചർച്ചയെക്കുറിച്ച് ആത്മവിശ്വാസത്തോടെ ഒരു വിധി നൽകി. ഒരു ഹെൽപ്പർ മുഴുവൻ ഫലവും കെട്ടിച്ചമച്ചുണ്ടാക്കിയിരുന്നു.
L1 പരാജയപ്പെട്ടു. അത് പിശക് കണ്ടതില്ല എന്ന് മാത്രമല്ല, വിശ്വസനീയമായ ഒരു നുണ നിർമ്മിക്കുകയും ചെയ്തു.
L1 മാത്രമായിരുന്നു എന്റെ ഏക സുരക്ഷാ കവചമെങ്കിൽ, ആ നുണ ഒരു യഥാർത്ഥ തീരുമാനമായി മാറുമായിരുന്നു. എന്നാൽ L4 അത് പിടികൂടി. L4 വിവരണങ്ങളെ (narration) വിശ്വസിക്കുന്നില്ല. അത് രസീതുകളെ (receipts) മാത്രമേ വിശ്വസിക്കൂ. ഞാൻ ട്രാൻസ്ക്രിപ്റ്റ് ഫയൽ (transcript file) പരിശോധിച്ചു. ആ ഫയൽ നിലവിലില്ലായിരുന്നു. അതിനാൽ ആ അവകാശവാദം അസാധുവായതുകൊണ്ട് അത് തള്ളിക്കളഞ്ഞു.
L1 പരാജയപ്പെടുമെന്ന് ഞാൻ മുൻകൂട്ടി കരുതിയതുകൊണ്ടാണ് സിസ്റ്റം സുരക്ഷിതമായിരുന്നത്.
ഈ പാളികളുടെ നിലവിലെ അവസ്ഥ:
• L1 — കോഡ് ചെയ്തു (Coded). • L2 — കോഡ് ചെയ്തു (Coded). • L4 — കോഡ് ചെയ്തു (Coded). • L0 — ഭാഗികമായി (Partial). • L3 — ഭാഗികമായി (Partial). • L5 — ഭാഗികമായി (Partial).
നിങ്ങൾക്ക് ഓഡിറ്റ് ചെയ്യാൻ കഴിയാത്ത ഒരു സുരക്ഷാ ആർക്കിടെക്ചർ (safety architecture) വെറുമൊരു മൂഡ് ബോർഡ് (mood board) മാത്രമാണ്.
ഏതൊരു സുരക്ഷിത ഏജന്റിനെക്കുറിച്ചും ഈ മൂന്ന് ചോദ്യങ്ങൾ സ്വയം ചോദിക്കുക:
- നിങ്ങളുടെ ഏറ്റവും വലിയ റിസ്കിനെ തടയാൻ സഹായിക്കുന്ന രണ്ട് സ്വതന്ത്ര പാളികൾ ഏതെല്ലാമാണ്?
- ഒരു പാളി തെറ്റായ ഒരു സിഗ്നൽ ആത്മവിശ്വാസത്തോടെ നൽകിയാൽ, അതിന് പിന്നിലുള്ള ഏത് പാളിയാണ് ആ സിഗ്നലിനെ വിശ്വസിക്കാൻ വിസമ്മതിക്കുന്നത്?
- ഏതൊക്കെ പാളികളാണ് നിർമ്മിച്ചിട്ടുള്ളത്, ഏതൊക്കെ വെറും ആശയങ്ങൾ മാത്രമാണ്?
കപ്പാസിറ്റി (Capability) എന്നത് ഒരു പാളിയാണ്. സുരക്ഷ (Safety) എന്നത് ബാക്കി അഞ്ച് പാളികളാണ്.
Source: https://dev.to/artemmatviychuk/defense-in-depth-for-an-agent-that-will-definitely-screw-up-5en0
Optional learning community: https://t.me/GyaanSetuAi