இரண்டாவது முறையாக

Arthur Petit

வெள்ளி, 27 செப்டம்பர், 2024 ’அன்று’ பிற்பகல் 4:36:03

பெரிய களஞ்சியங்களில் இரண்டாவது கிட் எடுப்பது ஏன் அதிக நேரம் எடுக்கும்?

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

முதல் மற்றும் இரண்டாவது பெறுதலுக்கு இடையில் களஞ்சியத்தில் எந்த மாற்றமும் இல்லாதபோது, இந்த நிலைமை மிகவும் குழப்பமடைகிறது. Git வரலாற்றின் ஜிகாபைட்களைக் கொண்ட ஒரு பெரிய திட்டம், இன்னும் நீண்ட செயலாக்க நேரத்தைக் காணலாம், இது ஏன் நடக்கிறது என்று டெவலப்பர்கள் ஆச்சரியப்படுகிறார்கள். இந்த சூழ்நிலையில் ஜென்கின்ஸ் போன்ற CI/CD பைப்லைன்களுடன் பணிபுரிவது செயல்திறன் முறைகேடுகளை மிகவும் முக்கியமானதாக மாற்றும்.

முதல் மற்றும் இரண்டாவது பெறுதலுக்கு இடையில் களஞ்சியத்தில் எந்த மாற்றமும் இல்லாதபோது, இந்த நிலைமை மிகவும் குழப்பமடைகிறது. Git வரலாற்றின் ஜிகாபைட்களைக் கொண்ட ஒரு பெரிய திட்டம், இருப்பினும், இது ஏன் நடந்தது என்று பொறியாளர்களை ஆச்சரியப்பட வைக்கும் ஒரு நீடித்த செயலாக்க நேரத்தைக் காட்ட முடியும். இந்த சூழ்நிலையில் ஜென்கின்ஸ் போன்ற CI/CD பைப்லைன்களுடன் பணிபுரிவது செயல்திறன் முறைகேடுகளை மிகவும் முக்கியமானதாக மாற்றும்.

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

கட்டளை	பயன்பாட்டின் உதாரணம்
git fetch --prune	சேவையகத்திலிருந்து தொலைநிலை கிளைகளுக்கான அனைத்து குறிப்புகளையும் நீக்குகிறது. பெரிய களஞ்சியங்களிலிருந்து மாற்றங்களைச் சேகரிக்கும் போது இது அவசியம், ஏனெனில் இது பழைய கிளைகளை சுத்தம் செய்ய உதவுகிறது.
git fetch --depth=1	பெறப்பட்ட களஞ்சிய வரலாற்றின் அளவைக் கட்டுப்படுத்துகிறது, முழுமையான வரலாற்றைக் காட்டிலும் மிகச் சமீபத்திய ஸ்னாப்ஷாட்டை மட்டுமே பெறுகிறது. பெரிய களஞ்சியங்களுக்கு, இது செயல்முறையை விரைவுபடுத்துகிறது மற்றும் அலைவரிசை பயன்பாட்டை குறைக்கிறது.
git fetch --no-tags	டேக் எடுப்பதை முடக்குகிறது, இது இந்த நிகழ்வில் மிதமிஞ்சியதாக உள்ளது மற்றும் ரிமோட் ரிபோசிட்டரியில் இருந்து பெறப்பட்ட தரவின் அளவைக் குறைக்க உதவுகிறது.
subprocess.run()	பைத்தானில் உள்ள Subprocess.run() ஷெல் கட்டளையை இயக்குகிறது (Git கட்டளை போன்றது) மற்றும் அதன் முடிவை பதிவு செய்கிறது. கணினி-நிலை கட்டளைகளை ஆட்டோமேஷன் ஸ்கிரிப்ட்களில் இணைக்க இது உதவியாக இருக்கும்.
exec()	Node.js இல், exec() ஒரு JavaScript ஷெல் கட்டளையை இயக்குகிறது. Git பணிகளைச் செய்வதற்கும் அவற்றின் விளைவுகளை ஒத்திசைவற்ற முறையில் கையாளுவதற்கும் இது பயன்படுத்தப்படுகிறது.
unittest.TestCase	செல்லுபடியாகும் மற்றும் தவறான பாதைகள் உட்பட பல்வேறு சூழ்நிலைகளில் git_fetch() முறை வெற்றிகரமாக இயங்குவதை உறுதிசெய்யப் பயன்படும் பைதான் அலகு சோதனையை வரையறுக்கிறது.
git fetch --force	தகராறு ஏற்பட்டாலும் கூட, விரைவாக முன்னனுப்பாத புதுப்பிப்புகளை விளைவித்தாலும் மீட்டெடுப்பதை கட்டாயப்படுத்துவதன் மூலம், உள்ளூர் களஞ்சியமானது ரிமோட்டுடன் துல்லியமாக ஒத்திசைக்கப்படுவதை உறுதி செய்கிறது.
git fetch "+refs/heads/:refs/remotes/origin/"	ரிமோட் ரெபோசிட்டரியில் இருந்து எந்த கிளைகள் அல்லது குறிப்புகள் எடுக்கப்பட வேண்டும் என்பதைக் குறிக்கிறது. துல்லியமான புதுப்பிப்புகளுக்கு உத்தரவாதம் அளிக்க, இந்த கட்டளை குறிப்பாக தொலைநிலை கிளைகளை உள்ளூர் குறிப்புகளுக்கு வரைபடமாக்குகிறது.

பெரிய களஞ்சியங்களுக்கு Git Fetch ஐ மேம்படுத்துதல்: ஒரு விளக்கம்

முன்னர் கொடுக்கப்பட்ட ஸ்கிரிப்டுகள் எப்போது நிகழும் திறமையின்மைகளைச் சமாளிக்கும் பெறுதல் கட்டளைகள் பெரிய களஞ்சியங்களில் நடத்தப்படுகின்றன. களஞ்சியத்தில் பெரிய மாற்றங்கள் எதுவும் இல்லையென்றாலும், Git தற்செயலாக பெரிய பேக் கோப்புகளைப் பதிவிறக்கும் போது, தொடக்கப் பெறுதலுக்குப் பிறகு, இந்த திறமையின்மைகள் பொதுவாக வெளிப்படையாகத் தெரியும். ஸ்கிரிப்டுகள் போன்ற வாதங்களைப் பயன்படுத்துகின்றன --ஆழம்=1 மற்றும் --கத்தரிக்காய் தேவையற்ற பதிவிறக்கங்களைக் குறைக்கும் முயற்சியில், கமிட் வரலாற்றைக் கட்டுப்படுத்தவும், வழக்கற்றுப் போன குறிப்புகளை அகற்றவும். ஜென்கின்ஸ் போன்ற தொடர்ச்சியான ஒருங்கிணைப்பு (CI) சூழல்களில் பணிபுரியும் போது வேகம் மற்றும் செயல்திறனைப் பராமரிப்பது மிகவும் முக்கியமானது, எனவே இது மிகவும் முக்கியமானது.

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

பைத்தானில் எழுதப்பட்ட இரண்டாவது ஸ்கிரிப்ட் மூலம் மிகவும் தகவமைக்கக்கூடிய விருப்பம் வழங்கப்படுகிறது. Git fetch கட்டளையானது பைதான் ஸ்கிரிப்டைப் பயன்படுத்தி செயல்படுத்தப்படுவதால் கூடுதல் கட்டுப்பாடு மற்றும் பிழை கையாளுதல் சாத்தியமாகும். subprocess.run() செயல்பாடு. CI/CD பைப்லைன் போன்ற ஒரு பெரிய அமைப்பில் மீட்டெடுப்பு கட்டளை சேர்க்கப்பட வேண்டியிருக்கும் போது, இது குறிப்பாக உதவியாக இருக்கும். பிழைத்திருத்த சிக்கல்கள் அல்லது பெறுதல் வெற்றிகரமாக உள்ளதா என்பதைச் சரிபார்ப்பது பைதான் ஸ்கிரிப்ட் மூலம் எளிதாக்கப்படுகிறது, இது ஃபெட்ச் அழைப்பின் வெளியீட்டைப் பதிவுசெய்து, ஏதேனும் பிழைகளை பதிவுசெய்கிறது. பைதான் ஸ்கிரிப்டிங் ஆதரிக்கப்படுவதால், மிகவும் சிக்கலான தானியங்கு செயல்பாடுகளுக்கு இந்தத் தீர்வை அளவிடுவதும் எளிதானது.

கடைசியாக, இறுதி அணுகுமுறை Node.js ஐப் பயன்படுத்தி ஒரு Git பெறுதலை மேற்கொள்கிறது. குறிப்பிட்ட கிளைகளைப் பெறுவதில் கவனம் செலுத்தும் இந்த ஸ்கிரிப்டைப் பயன்படுத்துவதன் மூலம் பரிமாற்றப்பட்ட தரவின் அளவைக் கணிசமாகக் குறைக்கலாம். பயன்படுத்தி "+refs/heads/*:refs/remotes/origin/*" கிளைகளைக் குறிக்க தேவையான குறிப்புகள் மட்டுமே பதிவிறக்கம் செய்யப்படுவதை உறுதி செய்கிறது. செயல்திறனை மேலும் மேம்படுத்த, டெவலப்பர்கள் குறிப்பிட்ட கிளைகளில் மட்டுமே புதுப்பிப்புகளை விரும்பும் சூழ்நிலைகளில் இந்த உத்தி குறிப்பாக உதவியாக இருக்கும். Node.js ஒத்திசைவற்றதாக இருப்பதால், இந்த செயல்முறை மற்ற செயல்முறைகளைத் தடுக்காமல் செயல்படும், இது நிகழ்நேர பயன்பாடுகளுக்கு சரியானதாக அமைகிறது.

பெரிய களஞ்சியங்களில் Git Fetch செயல்திறனை மேம்படுத்துதல்

பெரிய கிட் பெறுதல்களை நிர்வகிக்கவும் மேம்படுத்தவும் பாஷ் ஸ்கிரிப்டைப் பயன்படுத்துதல்

#!/bin/bash
# Bash script to improve Git fetch efficiency by avoiding unnecessary pack downloads
# This solution ensures only required refs are fetched
REPO_URL="git@code.wexx.com:ipc/hj_app.git"
LOCAL_REPO_DIR="/path/to/local/repo"
cd $LOCAL_REPO_DIR || exit
# Fetch only the refs that have changed
git fetch --prune --no-tags --force --progress $REPO_URL
# Check the status of the fetch
if [ $? -eq 0 ]; then echo "Fetch successful"; else echo "Fetch failed"; fi

CI/CD பைப்லைன்களில் Git Fetchக்கு பைதான் ஸ்கிரிப்டைப் பயன்படுத்துதல்

CI/CD பைப்லைன் பெறுதல் செயல்திறனை மேம்படுத்த பைதான் ஸ்கிரிப்ட்

import subprocess
import os
# Function to run a Git fetch command and handle output
def git_fetch(repo_path, repo_url):
    os.chdir(repo_path)
    command = ["git", "fetch", "--prune", "--no-tags", "--force", "--depth=1", repo_url]
    try:
        result = subprocess.run(command, capture_output=True, text=True)
        if result.returncode == 0:
            print("Fetch completed successfully")
        else:
            print(f"Fetch failed: {result.stderr}")
    except Exception as e:
        print(f"Error: {str(e)}")

Git இலிருந்து குறிப்பிட்ட கிளைகளை மட்டும் பெற Node.js ஸ்கிரிப்ட்

Node.js ஸ்கிரிப்ட் சுமையை குறைக்க குறிப்பிட்ட கிளைகளை எடுக்க

const { exec } = require('child_process');
const repoUrl = "git@code.wexx.com:ipc/hj_app.git";
const repoDir = "/path/to/local/repo";
# Function to fetch only a single branch
const fetchBranch = (branch) => {
  exec(`cd ${repoDir} && git fetch --no-tags --force ${repoUrl} ${branch}`, (err, stdout, stderr) => {
    if (err) {
      console.error(\`Error: ${stderr}\`);
    } else {
      console.log(\`Fetched ${branch} successfully: ${stdout}\`);
    }
  });
};
# Fetching a specific branch to optimize performance
fetchBranch('refs/heads/main');

கிட் ஃபெட்ச் பைதான் ஸ்கிரிப்ட்டுக்கான யூனிட் டெஸ்ட்

கிட் ஃபெட்ச் ஸ்கிரிப்ட் சரியாக வேலை செய்கிறது என்பதை உறுதிப்படுத்த பைதான் யூனிட் சோதனை

import unittest
from fetch_script import git_fetch
class TestGitFetch(unittest.TestCase):
    def test_successful_fetch(self):
        result = git_fetch('/path/to/repo', 'git@code.wexx.com:ipc/hj_app.git')
        self.assertIsNone(result)
    def test_failed_fetch(self):
        result = git_fetch('/invalid/path', 'git@code.wexx.com:ipc/hj_app.git')
        self.assertIsNotNone(result)
if __name__ == '__main__':
    unittest.main()

Git Fetch Speed இல் பிக் பேக் கோப்புகளின் விளைவுகளை ஆய்வு செய்தல்

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

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

பயன்படுத்தி கிட் ஃபெட்ச் --ப்ரூன் தேவையற்ற கிளைகள் மற்றும் குறிப்புகளை அகற்றுவது என்பது காலாவதியான தொலைதூர கிளைகளை அழிக்க உதவும் கூடுதல் வழியாகும். வழக்கமாக களஞ்சியத்தை சுத்தம் செய்வதன் மூலமும், பொருத்தமான தரவு மட்டுமே எடுக்கப்படுவதை உறுதி செய்வதன் மூலமும் நீங்கள் பெறும் நேரத்தை வெகுவாகக் குறைக்கலாம். தொடர்ச்சியான ஒருங்கிணைப்பு/தொடர்ச்சியான மேம்பாடு (CI/CD) அமைப்புகளில், மீண்டும் மீண்டும் பெறுதல்கள் உருவாக்க வேகம் மற்றும் மேம்பாட்டுத் திறனைத் தடுக்கலாம், இது மிகவும் பயனுள்ளதாக இருக்கும்.

Git Fetch செயல்திறன் சிக்கல்கள் பற்றிய பொதுவான கேள்விகள்

எனது இரண்டாவது கிட் எடுக்க அதன் முதல் நேரத்தை விட ஏன் அதிக நேரம் எடுக்கிறது?
முதல் பெறுதலுக்குத் தேவையில்லாத பெரிய பேக் கோப்புகளை Git அடிக்கடி பதிவிறக்குகிறது, இதனால் இரண்டாவது பெறுதலுக்கு அதிக நேரம் எடுக்கும். பயன்படுத்தவும் --depth=1 மிதமிஞ்சிய வரலாற்றைக் குறைக்க.
Git தேவையில்லாத டேட்டாவைப் பதிவிறக்குவதை எவ்வாறு தடுப்பது?
உள்ளூர் களஞ்சியமானது ரிமோட்டுடன் சரியாகப் பொருந்துகிறதா என்பதை உறுதிப்படுத்தவும் குறிச்சொற்களைப் பெறுவதைத் தவிர்க்கவும் --no-tags மற்றும் --force விருப்பங்கள்.
Git இல் பேக் கோப்புகளின் பங்கு என்ன?
Git பொருள்கள் பேக் கோப்புகள் எனப்படும் குழுக்களாக சுருக்கப்படுகின்றன. அவை இடத்தைச் சேமித்தாலும், பெரிய கோப்புகள் பெறும்போது பதிவிறக்கம் செய்யப்பட்டால், அவை மெதுவாகப் பெற நேரலாம்.
செயல்திறனை மேம்படுத்த குறிப்பிட்ட கிளைகளை மட்டும் பெற முடியுமா?
ஆம், குறிப்பிட்ட கிளைகளைப் பயன்படுத்தி பெறுதலை நீங்கள் கட்டுப்படுத்தலாம் "+refs/heads/*:refs/remotes/origin/*", இது அனுப்பப்படும் தரவுகளின் அளவைக் குறைக்கும்.
எப்படி செய்கிறது git fetch --prune பெறுதல் வேகத்தை மேம்படுத்த உதவுமா?
இந்த கட்டளை களஞ்சியத்தை சுத்தம் செய்யவும், செயல்பாட்டில் இல்லாத தொலை கிளைகளுக்கான குறிப்புகளை அகற்றுவதன் மூலம் மீட்டெடுக்கும் நேரத்தை மேம்படுத்தவும் உதவுகிறது.

Git Fetch செயல்திறன் பற்றிய இறுதி எண்ணங்கள்

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

பரிமாற்றப்பட்ட தரவின் அளவைக் குறைப்பதன் மூலம், முறைகள் போன்றவை --ஆழம்=1 மற்றும் --கத்தரிக்காய் விரைவான பெறுதல்களுக்கு உத்தரவாதம். ஜென்கின்ஸ் போன்ற அமைப்புகளில் இந்த நுட்பங்களைப் பயன்படுத்துவதன் மூலம், வளர்ச்சியை நெறிப்படுத்தலாம் மற்றும் மீண்டும் மீண்டும் மீட்டெடுக்கும் செயல்பாடுகளில் செலவிடும் நேரத்தை குறைக்கலாம்.

Git Fetch செயல்திறனுக்கான ஆதாரங்கள் மற்றும் குறிப்புகள்

பேக் கோப்புகளின் விளக்கம் மற்றும் Git தேர்வுமுறை உத்திகள்: ஜிட் இன்டர்னல்ஸ்: பேக்ஃபைல்கள்
Git fetch செயல்திறன் ட்யூனிங் பற்றிய விவரங்கள்: Git Fetch ஐ விரைவுபடுத்துவது பற்றிய ஸ்டாக் ஓவர்ஃப்ளோ விவாதம்
CI/CD பைப்லைன்களில் பெரிய களஞ்சியங்களை மேம்படுத்துவதற்கான சிறந்த நடைமுறைகள்: ஜென்கின்ஸ் கிட் ஒருங்கிணைப்பு சிறந்த நடைமுறைகள்
மேம்பட்ட பெறுதல் விருப்பங்களுக்கான Git ஆவணங்கள்: Git Fetch அதிகாரப்பூர்வ ஆவணம்

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