Comprendre la récupération lente de Git dans les grands référentiels pour la deuxième fois

Pourquoi la deuxième récupération de Git prend-elle plus de temps dans les grands référentiels ?

La gestion de référentiels massifs est une tâche typique du développement de logiciels, en particulier pour les projets à long terme en développement constant. La complexité de la gestion efficace d'un référentiel avec des commandes Git telles que git récupérer augmente à mesure que le référentiel se développe. Il est courant que les développeurs s'attendent à un long délai initial git récupérer, c'est donc déroutant lorsque la deuxième récupération se produit beaucoup plus lentement que prévu.

Lorsqu'il n'y a eu aucun changement dans le référentiel entre la première et la deuxième récupération, cette situation devient beaucoup plus perplexe. Un projet de grande envergure, avec des gigaoctets d'historique Git, peut encore connaître un temps d'exécution long, laissant les développeurs se demander pourquoi cela se produit. Travailler avec des pipelines CI/CD tels que Jenkins dans ce scénario peut rendre les irrégularités de performances très importantes.

Lorsqu'il n'y a eu aucun changement dans le référentiel entre la première et la deuxième récupération, cette situation devient beaucoup plus perplexe. Un projet énorme, avec des gigaoctets d'historique Git, peut néanmoins présenter un temps d'exécution long, laissant les ingénieurs se demander pourquoi cela s'est produit. Travailler avec des pipelines CI/CD tels que Jenkins dans ce scénario peut rendre les irrégularités de performances très importantes.

Nous étudierons les causes de ces lenteurs de récupération dans les grands référentiels dans cet article. Nous examinerons également quelques moyens d'éviter le téléchargement répété d'objets Git volumineux, ce qui accélérera et améliorera l'efficacité de vos récupérations.

Optimiser Git Fetch pour les grands référentiels : une explication

Les scripts donnés précédemment sont destinés à gérer les inefficacités qui se produisent lorsque git récupérer les commandes sont effectuées sur de gros référentiels. Même s'il n'y a pas eu de changements majeurs dans le référentiel, ces inefficacités deviennent généralement apparentes après la récupération initiale lorsque Git télécharge involontairement des fichiers volumineux. Les scripts utilisent des arguments comme --profondeur=1 et --élaguer pour limiter l'historique des validations et supprimer les références obsolètes, dans le but de minimiser les téléchargements inutiles. Maintenir la vitesse et l'efficacité est essentiel lorsque l'on travaille dans des environnements d'intégration continue (CI) tels que Jenkins, c'est donc particulièrement vital.

Le premier script est écrit en Bash et est très utile pour les tâches liées à git récupérer automation. Après avoir accédé au répertoire du référentiel local, il émet la commande fetch avec des paramètres optimaux, comme --pas de balises pour éviter de récupérer des balises inutiles et --forcer pour garantir que le référentiel local et le référentiel distant sont complètement synchronisés. Ce script ajoute également le --élaguer option, qui permet de maintenir le référentiel propre en supprimant les références aux branches distantes qui n'existent plus. Des vitesses d'exécution plus rapides sont obtenues grâce à ces améliorations en réduisant la taille totale des données récupérées.

L'option la plus adaptable est offerte par le deuxième script, écrit en Python. Plus de contrôle et de gestion des erreurs sont possibles car la commande Git fetch est exécutée à partir d'un script Python à l'aide de l'option sous-processus.run() fonction. Lorsque la commande de récupération doit être incluse dans un système plus grand, comme un pipeline CI/CD, cela est particulièrement utile. Le débogage des problèmes ou la vérification de la réussite de la récupération sont facilités par le script Python, qui enregistre la sortie de l'appel de récupération et enregistre toutes les erreurs. Il est également plus simple d'adapter cette solution à des activités automatisées plus complexes, car les scripts Python sont pris en charge.

Enfin, l'approche finale effectue une récupération Git à l'aide de Node.js. La quantité de données transférées peut être considérablement réduite en utilisant ce script, qui se concentre sur la récupération de branches particulières. En utilisant "+refs/heads/*:refs/remotes/origine/*" pour indiquer les succursales, il s'assure que seules les références nécessaires sont téléchargées. Pour optimiser davantage l'efficacité, cette stratégie est particulièrement utile dans les scénarios où les développeurs souhaitent des mises à jour uniquement sur des branches spécifiques. Node.js étant asynchrone, ce processus peut fonctionner sans entraver les autres processus, ce qui le rend parfait pour les applications en temps réel.

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

Examen des effets des fichiers Big Pack sur la vitesse de récupération de Git

L'une des causes les moins connues de git récupérer prendre plus de temps lors d'une deuxième exécution est lié à la gestion par Git des grands référentiels, à savoir les fichiers pack. Les fichiers Pack, qui sont des collections compressées d'objets tels que des commits, des arbres et des blobs, constituent un moyen efficace pour Git de stocker les données du référentiel. Bien que cela économise de l'espace, cela peut entraîner des retards de récupération, en particulier si les fichiers Big Pack sont téléchargés plus souvent que nécessaire. Ces fichiers de pack peuvent devenir très volumineux et entraîner des temps de récupération longs lorsqu'un référentiel s'agrandit au fil du temps, comme cela peut être le cas dans un projet en développement depuis plusieurs années.

Il est essentiel de comprendre comment Git utilise des indicateurs spécifiques pour optimiser les processus de récupération afin d'éviter ce problème. Par exemple, récupérer uniquement l'historique des validations le plus récent lorsque le --profondeur=1 L'option utilisée restreint la récupération à une copie superficielle. Néanmoins, si Git détecte des différences ou des modifications dans les branches, il peut toujours décider de télécharger un fichier pack volumineux dans des circonstances spécifiques. Même en l’absence de mises à niveau majeures du référentiel, cela pourrait se produire et semer la confusion parmi les ingénieurs.

En utilisant git fetch --prune supprimer les branches et références inutiles est un moyen supplémentaire d’aider à supprimer les branches distantes obsolètes. Vous pouvez réduire considérablement le temps de récupération en nettoyant régulièrement le référentiel et en vous assurant que seules les données pertinentes sont récupérées. Dans les configurations d'intégration continue/développement continu (CI/CD), où les récupérations récurrentes peuvent entraver la vitesse de construction et l'efficacité du développement, cela est très utile.