ஏன் Git LFS களஞ்சியங்கள் பெரியதாக இருக்கலாம்: ஒரு வழிகாட்டி

ஏன் Git LFS களஞ்சியங்கள் பெரியதாக இருக்கலாம்: ஒரு வழிகாட்டி
Mauve Garcia
செவ்வாய், 28 மே, 2024 ’அன்று’ பிற்பகல் 12:12:09
Bash Script

Git LFS களஞ்சிய அளவைப் புரிந்துகொள்வது

ஒரு பெரிய SVN களஞ்சியத்தை Git க்கு மாற்றும் செயல்பாட்டில், நான் ஒரு சுவாரஸ்யமான சிக்கலை எதிர்கொண்டேன். பைனரிகளை சேமிப்பதற்காக Git LFS ஐப் பயன்படுத்த Git களஞ்சியத்தை மாற்றும் போது, ​​களஞ்சியத்தின் அளவு கணிசமாக அதிகரித்தது.

Git LFS இடம்பெயர்ந்த களஞ்சியமானது அசலை விட ஏன் பெரியதாக முடிவடைகிறது மற்றும் Git LFS ஐ விட வழக்கமான Git பைனரிகளை மிகவும் திறமையாக பேக் செய்கிறது என்பதை இந்தக் கட்டுரை ஆராய்கிறது. இடம்பெயர்வு செயல்பாட்டின் போது பயன்படுத்தப்படும் படிகள் மற்றும் கட்டளைகளையும் பகிர்ந்து கொள்கிறேன்.

கட்டளை விளக்கம்
git lfs track Git LFS மூலம் குறிப்பிடப்பட்ட கோப்பு வகைகளைக் கண்காணிக்கிறது, பெரிய கோப்புகளை முக்கிய Git களஞ்சியத்திலிருந்து நகர்த்துகிறது.
bfg --convert-to-git-lfs Git LFS ஐப் பயன்படுத்த களஞ்சியத்தில் உள்ள குறிப்பிட்ட கோப்பு வகைகளை மாற்றுகிறது, Git வரலாற்றிலிருந்து பெரிய கோப்புகளை நீக்குகிறது.
git reflog expire ரெப்லாக்கில் உள்ள அனைத்து உள்ளீடுகளையும் காலாவதியாகிறது, இது LFS இடம்பெயர்வுக்குப் பிறகு களஞ்சிய அளவைக் குறைக்க உதவும்.
git gc --prune=now --aggressive தேவையற்ற கோப்புகளை அகற்றவும், களஞ்சிய அளவை ஆக்ரோஷமாக மேம்படுத்தவும் குப்பை சேகரிப்பை இயக்குகிறது.
subprocess.run பைதான் ஸ்கிரிப்டில் இருந்து இயக்க முறைமையின் கட்டளை-வரி இடைமுகத்துடன் தொடர்பு கொள்ள அனுமதிக்கும் துணைச் செயலாக்கத்தில் ஒரு கட்டளையை இயக்குகிறது.
du -sh ஒரு குறிப்பிட்ட கோப்பகத்தின் வட்டு பயன்பாட்டை மனிதர்கள் படிக்கக்கூடிய வடிவத்தில் காண்பிக்கும்.

இடம்பெயர்வு ஸ்கிரிப்ட்களைப் புரிந்துகொள்வது

பாஷ் ஸ்கிரிப்ட் Git LFS ஐப் பயன்படுத்த ஒரு Git களஞ்சியத்தின் நகர்வை தானியக்கமாக்க வடிவமைக்கப்பட்டுள்ளது. முதலில், இது LFS ஐ துவக்குகிறது மற்றும் பைனரி கோப்புகளை கண்காணிக்கிறது git lfs track கட்டளை. பின்னர், இது கண்காணிப்பு உள்ளமைவை களஞ்சியத்தில் சேர்த்து அதைச் செய்கிறது. தி bfg --convert-to-git-lfs களஞ்சியத்தில் இருக்கும் பைனரி கோப்புகளை LFS ஆக மாற்ற கட்டளை பயன்படுத்தப்படுகிறது, முக்கிய Git வரலாற்றில் இருந்து அவற்றை திறம்பட நீக்குகிறது. இந்த மாற்றத்திற்குப் பிறகு, ஸ்கிரிப்ட் இயங்குகிறது git reflog expire மற்றும் git gc --prune=now பழைய குறிப்புகளை காலாவதி செய்யவும் மற்றும் தேவையற்ற கோப்புகளை கத்தரிக்கவும், களஞ்சிய அளவை குறைக்கவும்.

பைதான் ஸ்கிரிப்ட் இடம்பெயர்வுக்கு முன்னும் பின்னும் களஞ்சிய அளவுகளை ஒப்பிடுவதற்கான வழியை வழங்குவதன் மூலம் இதை நிறைவு செய்கிறது. பயன்படுத்தி subprocess.run செயல்பாடு, இது செயல்படுத்துகிறது du -sh குறிப்பிட்ட கோப்பகங்களின் வட்டு பயன்பாட்டைப் பெற கட்டளை. இது LFSக்கு முந்தைய மற்றும் பிந்தைய இடப்பெயர்ச்சிக்கான களஞ்சிய அளவுகளின் தெளிவான ஒப்பீட்டை அனுமதிக்கிறது. இடம்பெயர்வு மற்றும் சுத்தப்படுத்தும் கட்டளைகளின் தாக்கத்தை களஞ்சிய அளவில் புரிந்து கொள்ள வெளியீடு உதவுகிறது, இடம்பெயர்வு செயல்முறையின் செயல்திறனை சரிபார்க்கிறது.

Git LFS இடம்பெயர்வு மற்றும் சுத்தம் செய்யும் செயல்முறையை தானியக்கமாக்குகிறது

Git LFS இடம்பெயர்வு மற்றும் சுத்தம் செய்வதற்கான பாஷ் ஸ்கிரிப்ட்

#!/bin/bash
# Step 1: Initialize LFS and track file type
git lfs install
git lfs track "*.bin"
git add .gitattributes
git commit -m "Track binary files with LFS"
# Step 2: Migrate existing files to LFS
bfg --convert-to-git-lfs '*.bin' --no-blob-protection
git reflog expire --expire=now --all
git gc --prune=now --aggressive

இடப்பெயர்வுக்குப் பின் களஞ்சிய அளவு மாற்றங்களை பகுப்பாய்வு செய்தல்

களஞ்சிய அளவு ஒப்பீட்டிற்கான பைதான் ஸ்கிரிப்ட்

import subprocess
def get_repo_size(path):
    result = subprocess.run(['du', '-sh', path], stdout=subprocess.PIPE)
    size = result.stdout.split()[0].decode('utf-8')
    return size
before_migration = get_repo_size('/path/to/repo_before_lfs')
after_migration = get_repo_size('/path/to/repo_after_lfs')
print(f"Size before LFS migration: {before_migration}")
print(f"Size after LFS migration: {after_migration}")

களஞ்சிய அளவு மீது Git LFS இன் தாக்கத்தை ஆராய்தல்

Git LFS க்கு இடம்பெயர்வதில் ஒரு முக்கியமான அம்சம் Git மற்றும் Git LFS கோப்பு சேமிப்பகத்தை எவ்வாறு கையாள்கிறது என்பதில் உள்ள வேறுபாடுகளைப் புரிந்துகொள்வது. Git LFS உங்கள் களஞ்சியத்தில் உள்ள பெரிய கோப்புகளை சிறிய சுட்டிக்காட்டி கோப்புகளுடன் மாற்றுகிறது, அதே நேரத்தில் உண்மையான கோப்பு உள்ளடக்கங்கள் தனித்தனியாக சேமிக்கப்படும். இந்த பிரிப்பு அசல் பெரிய கோப்புகள் மற்றும் புதிய LFS சுட்டிகள் இரண்டும் இருப்பதால் இடம்பெயர்வின் போது வட்டு அளவு தற்காலிகமாக அதிகரிக்கலாம். மற்றொரு காரணி என்னவென்றால், Git LFS வெவ்வேறு சுருக்க மற்றும் சேமிப்பக வழிமுறைகளைப் பயன்படுத்துகிறது, இது எப்போதும் சிறிய களஞ்சிய அளவுகளை ஏற்படுத்தாது, குறிப்பாக இடம்பெயர்ந்த உடனேயே.

இடப்பெயர்வுக்குப் பின் களஞ்சிய அளவை மேம்படுத்த, போன்ற கட்டளைகளை இயக்குவது முக்கியம் git reflog expire மற்றும் git gc --prune=now --aggressive. இந்த கட்டளைகள் தேவையற்ற கோப்புகள் மற்றும் குறிப்புகளை அகற்ற உதவுகின்றன, இது களஞ்சிய அளவைக் கணிசமாகக் குறைக்கிறது. காலப்போக்கில் களஞ்சியத்தின் அளவைக் கண்காணிப்பதும், அதை உகந்ததாக வைத்திருக்க வழக்கமான பராமரிப்பைச் செய்வதும் முக்கியம். இந்த நுணுக்கங்களைப் புரிந்துகொள்வது எதிர்பார்ப்புகளை நிர்வகிக்கவும் திறமையான இடம்பெயர்வு செயல்முறையை உறுதிப்படுத்தவும் உதவும்.

Git LFS இடம்பெயர்வு பற்றிய பொதுவான கேள்விகள்

  1. ஆரம்ப Git LFS இடம்பெயர்வுக்குப் பிறகு களஞ்சியத்தின் அளவு ஏன் அதிகரிக்கிறது?
  2. அசல் கோப்புகள் மற்றும் LFS சுட்டிகள் இரண்டும் இருப்பதால் அதிகரிப்பு. ஓடுதல் git gc கட்டளைகள் இந்த அளவைக் குறைக்க உதவுகின்றன.
  3. என்ன செய்கிறது git reflog expire செய்?
  4. இந்த கட்டளையானது காலாவதியான reflog உள்ளீடுகளை நீக்கி, களஞ்சியத்தை சுத்தம் செய்யவும், இடத்தை விடுவிக்கவும் உதவுகிறது.
  5. எப்படி செய்கிறது bfg --convert-to-git-lfs வேலை?
  6. இது ஏற்கனவே உள்ள பெரிய கோப்புகளை Git LFS ஐப் பயன்படுத்த மாற்றுகிறது, முக்கிய Git வரலாற்றிலிருந்து அவற்றை திறம்பட நகர்த்துகிறது.
  7. ஏன் git gc --prune=now --aggressive பயன்படுத்தப்பட்டது?
  8. இந்த கட்டளையானது தேவையற்ற கோப்புகளை தீவிரமாக சுத்தம் செய்து களஞ்சிய சேமிப்பை மேம்படுத்துகிறது.
  9. Git LFSஐப் பயன்படுத்துவதால் என்ன பயன்?
  10. Git LFS ஆனது பெரிய கோப்புகளை தனித்தனியாக சேமித்து, செயல்திறனை மேம்படுத்துவதன் மூலம் களஞ்சிய குளோன்களின் அளவைக் குறைக்கிறது.
  11. இடம்பெயர்ந்த உடனேயே களஞ்சிய அளவைக் குறைக்க முடியுமா?
  12. ஆம், ஓடுவதன் மூலம் git reflog expire மற்றும் git gc தேவையற்ற தரவை நீக்க கட்டளைகள்.
  13. Git LFSஐப் பயன்படுத்தும் போது தரவு இழப்பு ஏற்படும் அபாயம் உள்ளதா?
  14. இல்லை, இடம்பெயர்வு மற்றும் சுத்தம் செய்யும் கட்டளைகள் சரியாக இயங்கும் வரை, தரவு அப்படியே இருக்கும்.
  15. பராமரிப்பு கட்டளைகளை எவ்வளவு அடிக்கடி இயக்க வேண்டும்?
  16. பராமரிப்பு கட்டளைகளை தொடர்ந்து இயக்குவது நல்லது, குறிப்பாக களஞ்சியத்தில் குறிப்பிடத்தக்க மாற்றங்களுக்குப் பிறகு.

Git LFS இடம்பெயர்வு பற்றிய இறுதி எண்ணங்கள்

அசல் கோப்புகள் மற்றும் LFS சுட்டிகள் இணைந்திருப்பதன் காரணமாக, Git LFS க்கு இடம்பெயர்தல், களஞ்சிய அளவில் தற்காலிக அதிகரிப்புக்கு வழிவகுக்கும். இருப்பினும், போன்ற பராமரிப்பு கட்டளைகளை இயக்குகிறது git reflog expire மற்றும் git gc --prune=now --aggressive அளவை கணிசமாக குறைக்க முடியும். Git மற்றும் Git LFS கோப்பு சேமிப்பகத்தைக் கையாளும் விதத்தில் உள்ள வேறுபாடுகளைப் புரிந்துகொள்வது பயனுள்ள இடம்பெயர்வுக்கு முக்கியமானது.

ஆரம்ப அளவு அதிகரிப்பு கவலைக்குரியதாக இருந்தாலும், Git LFS ஐப் பயன்படுத்துவதன் நீண்ட கால நன்மைகள், குறிப்பாக தொலைநிலை சேமிப்பு மற்றும் குளோனிங் செயல்திறனுக்காக, தற்காலிக குறைபாடுகளை விட அதிகமாக உள்ளது. வழக்கமான பராமரிப்பு மற்றும் சரியான கட்டமைப்பு ஒரு உகந்த மற்றும் நிர்வகிக்கக்கூடிய களஞ்சிய அளவை உறுதி செய்ய முடியும்.