Voor de tweede keer Slow Git Fetch in grote repositories begrijpen

Waarom duurt de tweede Git-fetch langer in grote repositories?

Het beheren van enorme repository's is een typische taak bij softwareontwikkeling, vooral voor langetermijnprojecten die voortdurend in ontwikkeling zijn. De complexiteit van het effectief beheren van een repository met Git-opdrachten zoals git ophalen neemt toe naarmate de opslagplaats groter wordt. Het is gebruikelijk dat ontwikkelaars anticiperen op een lange initiaal git ophalen, dus het is verwarrend als de tweede ophaalactie veel langzamer plaatsvindt dan verwacht.

Als er geen enkele verandering in de repository heeft plaatsgevonden tussen de eerste en de tweede ophaalactie, wordt deze situatie veel verwarrender. Een groot project, met gigabytes aan Git-geschiedenis, kan nog steeds een lange uitvoeringstijd kennen, waardoor ontwikkelaars zich afvragen waarom dit gebeurt. Als u in dit scenario met CI/CD-pijplijnen zoals Jenkins werkt, kunnen de onregelmatigheden in de prestaties behoorlijk belangrijk worden.

Als er geen enkele verandering in de repository heeft plaatsgevonden tussen de eerste en de tweede ophaalactie, wordt deze situatie veel verwarrender. Een enorm project, met gigabytes aan Git-geschiedenis, kan niettemin een langdurige uitvoeringstijd vertonen, waardoor ingenieurs zich afvragen waarom dit is gebeurd. Als u in dit scenario met CI/CD-pijplijnen zoals Jenkins werkt, kunnen de onregelmatigheden in de prestaties behoorlijk belangrijk worden.

In dit artikel zullen we de oorzaken van deze trage ophaalacties in grote repository's onderzoeken. We zullen ook enkele manieren onderzoeken om te voorkomen dat grote Git-objecten herhaaldelijk worden gedownload, wat de effectiviteit van je ophaalacties zal versnellen en verbeteren.

Git Fetch optimaliseren voor grote repositories: een uitleg

De eerder gegeven scripts zijn bedoeld om om te gaan met de inefficiënties die optreden wanneer git ophalen opdrachten worden uitgevoerd op grote repositories. Ook al zijn er geen grote veranderingen in de repository geweest, deze inefficiënties worden meestal duidelijk na de eerste ophaalactie, wanneer Git onbedoeld big pack-bestanden downloadt. De scripts gebruiken argumenten als --diepte=1 En --snoeien om de commitgeschiedenis te beperken en verouderde referenties te verwijderen, in een poging onnodige downloads te minimaliseren. Het behouden van snelheid en efficiëntie is van cruciaal belang bij het werken in continue integratie (CI)-omgevingen zoals Jenkins. Daarom is dit vooral van cruciaal belang.

Het eerste script is geschreven in Bash en is zeer nuttig voor taken die verband houden met git ophalen automatisering. Nadat naar de lokale repositorymap is genavigeerd, wordt de opdracht fetch uitgevoerd met optimale parameters, zoals --geen tags om te voorkomen dat onnodige tags worden opgehaald en --kracht om te garanderen dat de lokale repository en de afstandsbediening volledig gesynchroniseerd zijn. Dit script voegt ook de --snoeien optie, die helpt de repository schoon te houden door verwijzingen naar niet langer bestaande externe branches te verwijderen. Door deze verbeteringen worden hogere uitvoeringssnelheden bereikt door de totale omvang van de opgehaalde gegevens te verkleinen.

De meer aanpasbare optie wordt geboden door het tweede script, dat is geschreven in Python. Meer controle en foutafhandeling zijn mogelijk omdat het Git fetch-commando wordt uitgevoerd vanuit een Python-script met behulp van de subproces.run() functie. Wanneer de opdracht ophalen moet worden opgenomen in een groter systeem, zoals een CI/CD-pijplijn, is dit vooral handig. Het debuggen van problemen of het verifiëren dat het ophalen succesvol was, wordt eenvoudig gemaakt door het Python-script, dat de uitvoer van de ophaalaanroep registreert en eventuele fouten registreert. Het is ook eenvoudiger om deze oplossing te schalen voor meer gecompliceerde geautomatiseerde activiteiten, omdat Python-scripting wordt ondersteund.

Ten slotte voert de laatste benadering een Git-fetch uit met behulp van Node.js. De hoeveelheid overgedragen gegevens kan aanzienlijk worden verminderd door dit script te gebruiken, dat zich concentreert op het ophalen van bepaalde vertakkingen. Gebruiken "+refs/heads/*:refs/remotes/origin/*" het aangeven van branches zorgt ervoor dat alleen de benodigde referenties worden gedownload. Om de efficiëntie verder te optimaliseren, is deze strategie vooral nuttig in scenario's waarin ontwikkelaars alleen updates voor specifieke branches willen. Omdat Node.js asynchroon is, kan dit proces werken zonder andere processen te belemmeren, waardoor het perfect is voor realtime toepassingen.

#!/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

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)}")

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()

Onderzoek naar de effecten van Big Pack-bestanden op de Git Fetch-snelheid

Een van de minder bekende oorzaken van git ophalen het langer duren bij een tweede run heeft te maken met de manier waarop Git omgaat met grote repository's, namelijk pack-bestanden. Pack-bestanden, die gecomprimeerde verzamelingen objecten zijn, zoals commits, bomen en blobs, zijn een effectieve manier voor Git om repositorygegevens op te slaan. Hoewel dit ruimte bespaart, kan dit vertragingen bij het ophalen tot gevolg hebben, vooral als big pack-bestanden vaker dan nodig worden gedownload. Deze pakketbestanden kunnen erg groot worden en lange ophaaltijden veroorzaken wanneer een repository in de loop van de tijd groter wordt, zoals het geval kan zijn bij een project dat al een aantal jaren in ontwikkeling is.

Het is van cruciaal belang om te begrijpen hoe Git specifieke vlaggen gebruikt om ophaalprocessen te optimaliseren om dit probleem te voorkomen. Door bijvoorbeeld alleen de meest recente commitgeschiedenis op te halen wanneer de --diepte=1 optie wordt gebruikt, beperkt het ophalen tot een ondiepe kopie. Desalniettemin, als Git verschillen of aanpassingen in branches vindt, kan het onder specifieke omstandigheden nog steeds besluiten om een ​​aanzienlijk pakketbestand te downloaden. Zelfs als er geen grote upgrades van de repository plaatsvinden, kan dit gebeuren en voor verwarring onder de technici zorgen.

Gebruiken git fetch --prune het verwijderen van onnodige filialen en referenties is een extra manier om verouderde externe filialen op te ruimen. U kunt de ophaaltijd drastisch verkorten door de repository routinematig op te schonen en ervoor te zorgen dat alleen relevante gegevens worden opgehaald. In continue integratie/continue ontwikkeling (CI/CD)-opstellingen, waar terugkerende ophaalacties de bouwsnelheid en ontwikkelingsefficiëntie kunnen belemmeren, is dit erg handig.