0deps இயக்கம்: உள்ளூர் சார்புகள் (Local Dependencies) மற்றும் மாற்ற முடியாத ஒப்பந்தங்கள் (Immutable Contracts)

மென்பொருள் உருவாக்குநர்கள் ஒவ்வொரு திட்டத்திலும் நூற்றுக்கணக்கான வெளிப்புற நூலகங்களை (external libraries) நிறுவுவது வழக்கம். நவீன கட்டமைப்புகள் (frameworks) ஆயிரக்கணக்கான இடைநிலைச் சார்புகளை (transitive dependencies) நம்பியிருக்கின்றன. இதன் பொருள் உங்கள் பயன்பாடு நூற்றுக்கணக்கான அறியப்படாத பங்களிப்பாளர்களிடமிருந்து வரும் குறியீடுகளை இயக்குகிறது என்பதாகும்.

இந்த அமைப்பு மேம்பாட்டு வேகத்தை அதிகரிக்கிறது. அதே சமயம் இது உங்கள் மென்பொருள் விநியோகச் சங்கிலியில் (software supply chain) மிகப்பெரிய பாதுகாப்பு அபாயங்களையும் உருவாக்குகிறது.

0deps இயக்கம் ஒரு எளிய கேள்வியைக் கேட்கிறது: உங்கள் பயன்பாடு நீங்கள் உண்மையில் கட்டுப்படுத்தும் குறியீடுகளை மட்டுமே இயக்கினால் என்னவாகும்?

ஒவ்வொரு சார்பும் உங்கள் தாக்குதல் பரப்பளவை (attack surface) அதிகரிக்கிறது. சார்புகள் பின்வருவனவற்றைச் செய்யலாம்:

  • பாதுகாப்பு குறைபாடுகளைக் கொண்டுவரலாம்.
  • விநியோகச் சங்கிலித் தாக்குதல்களைச் சந்திக்கலாம்.
  • கைவிடப்படலாம்.
  • அவற்றின் பொதுவான API-களை மாற்றலாம்.
  • முந்தைய பதிப்புகளுடனான இணக்கத்தன்மையை (backward compatibility) உடைக்கலாம்.

0deps மாதிரியில், தேவையான அனைத்துச் சார்புகளையும் உங்கள் திட்டக் களஞ்சியத்திலேயே (project repository) நேரடியாகச் சேர்த்துக்கொள்கிறீர்கள். நிறுவும் போது அவற்றை நீங்கள் இயங்குதள ரீதியாக (dynamically) பதிவிறக்கம் செய்வதில்லை. செயலியை உருவாக்கவும் இயக்கவும் தேவையான அனைத்தும் முதல் முறை நகலெடுப்பதே (clone) முதல் அங்கேயே இருக்கும்.

இந்த அணுகுமுறை பின்வருவனவற்றை வழங்குகிறது:

  • மீண்டும் உருவாக்கக்கூடிய கட்டமைப்புகள் (Reproducible builds).
  • வெளிப்புற தொகுப்புப் பதிவேடுகளை (package registries) சார்ந்திருத்தல் குறைவு.
  • மையப்படுத்தப்பட்ட பாதுகாப்புத் தணிக்கைகள்.
  • அதிகக் கணிக்கக்கூடிய தன்மை.
  • சிறிய விநியோகச் சங்கிலித் தாக்குதல் பரப்பு.

0deps என்பது நீங்கள் குறியீட்டைப் புதுப்பிப்பதை நிறுத்திவிட வேண்டும் என்று அர்த்தமல்ல. அல்காரிதம்களும் பாதுகாப்புத் திருத்தங்களும் தொடர்ந்து மாற வேண்டும். அதற்குப் பதிலாக, நீங்கள் பொதுவான ஒப்பந்தத்தை (public contract) நிலையாக வைத்திருக்க வேண்டும்.

ஒவ்வொரு நூலகமும் கவனமாக வடிவமைக்கப்பட்ட ஒரு இடைமுகத்தை (interface) வெளிப்படுத்துகிறது. உதாரணமாக:

  • authenticate()
  • createSession()
  • verifyPasskey()

இந்தச் செயல்பாடுகள் ஒரு ஒப்பந்தத்தை வரையறுக்கின்றன. இந்த ஒப்பந்தம் மாறாமல் இருக்கும். உங்கள் பயன்பாட்டின் மற்ற பகுதிகளைப் பாதிக்காமல், அடிப்படையிலுள்ள குறியீட்டை நீங்கள் மீண்டும் எழுதலாம் அல்லது உட்புற நூலகங்களை மாற்றலாம்.

ஒரு பாதுகாப்பு ஓட்டை (vulnerability) ஏற்படும் போது, அந்த இடைமுகத்திற்குப் பின்னால் உள்ள செயல்பாட்டை (implementation) நீங்கள் புதுப்பிக்கலாம். பொதுவான API அப்படியே இருக்கும். உங்கள் பயன்பாடு குறியீட்டு மாற்றங்கள் இன்றி தொடர்ந்து இயங்கும்.

இதன் அமைப்பு இவ்வாறு இருக்கும்: பயன்பாடு (Application) ↓ பொது இடைமுகம் (Public Interface) ↓ உட்புற அடாப்டர் (Internal Adapter) ↓ செயல்படுத்தல் (Implementation)

ஒரு வெளிப்புற நூலகம் மறைந்துவிட்டால், நீங்கள் அடாப்டரை மட்டும் மாற்றினால் போதும். உங்கள் பயன்பாட்டின் மற்ற எந்தப் பகுதியும் பாதிக்கப்படாது. இந்தத் தனிமைப்படுத்தல் (isolation) உங்களைத் தீய தொகுப்புகள் (malicious packages), பதிவேடு ஊடுருவல்கள் (registry compromises) மற்றும் சார்பு குழப்பங்கள் (dependency confusion) ஆகியவற்றிலிருந்து பாதுகாக்கிறது.

திட்டங்கள் பல தசாப்தங்கள் நீடிக்கும். ஆனால் நூலகங்களும் கட்டமைப்புகளும் அவ்வளவு காலம் நீடிக்காது. 0deps மூலம், சுற்றியுள்ள சூழல் மாறினாலும், உங்கள் பயன்பாடு பல ஆண்டுகளாக அதே நிலையான ஒப்பந்தங்களைப் பயன்படுத்த அனுமதிக்கிறது.

இதன் மூலம் நீங்கள் கணிக்கக்கூடிய, மீள்திறன் கொண்ட மற்றும் பராமரிக்க எளிதான மென்பொருளைப் பெறுகிறீர்கள்.

Source: https://dev.to/fullagenticstack/mouvement-0deps-dependances-locales-contrats-immuables-et-securite-par-conception-24c2

Optional learning community: https://t.me/GyaanSetuAi