Ymmärtää Slow Git Fetch suurissa arkistoissa toista kertaa

Miksi toinen Git-haku kestää kauemmin suurissa arkistoissa?

Massiivisten tietovarastojen hallinta on tyypillinen tehtävä ohjelmistokehityksessä, erityisesti pitkäaikaisissa projekteissa, joita on kehitetty jatkuvasti. Tietovaraston tehokkaan hallinnan monimutkaisuus Git-komennoilla, kuten git hakea kasvaa arkiston laajentuessa. On tavallista, että kehittäjät odottavat pitkän alkuvaiheen git hakea, joten on hämmentävää, kun toinen nouto tapahtuu paljon odotettua hitaammin.

Kun arkistossa ei ole tapahtunut muutoksia ensimmäisen ja toisen haun välillä, tämä tilanne muuttuu paljon hämmentävämmäksi. Suuri projekti, jossa on gigatavuja Git-historiaa, saattaa silti nähdä pitkän suoritusajan, jolloin kehittäjät ihmettelevät, miksi näin tapahtuu. Työskentely CI/CD-putkien, kuten Jenkinsin, kanssa tässä skenaariossa voi tehdä suorituskyvyn epäsäännöllisyydestä varsin tärkeitä.

Kun arkistossa ei ole tapahtunut muutoksia ensimmäisen ja toisen haun välillä, tämä tilanne muuttuu paljon hämmentävämmäksi. Valtava projekti, jossa on gigatavuja Git-historiaa, voi kuitenkin näyttää pitkittyneen suoritusajan, jolloin insinöörit ihmettelevät, miksi näin tapahtui. Työskentely CI/CD-putkien, kuten Jenkinsin, kanssa tässä skenaariossa voi tehdä suorituskyvyn epäsäännöllisyydestä varsin tärkeitä.

Tutkimme tässä artikkelissa näiden hitaiden hakujen syitä suurissa arkistoissa. Tutkimme myös joitakin tapoja estää suurten Git-objektien lataaminen toistuvasti, mikä nopeuttaa ja parantaa hakujen tehokkuutta.

Git Fetch -haun optimointi suurille arkistoille: Selitys

Aiemmin annetut skriptit on tarkoitettu käsittelemään tehottomuuksia, joita esiintyy silloin git hakea komennot suoritetaan suurissa arkistoissa. Vaikka arkistoon ei ole tehty suuria muutoksia, nämä tehottomuudet tulevat yleensä ilmi ensimmäisen noudon jälkeen, kun Git vahingossa lataa suuria paketteja. Skriptit käyttävät argumentteja, kuten --syvyys=1 ja --karsia rajoittaa toimitushistoriaa ja poistaa vanhentuneet viittaukset, jotta turhat lataukset voidaan minimoida. Nopeuden ja tehokkuuden ylläpitäminen on kriittistä työskenneltäessä jatkuvan integroinnin (CI) ympäristöissä, kuten Jenkinsissä, joten tämä on erityisen tärkeää.

Ensimmäinen käsikirjoitus on kirjoitettu bashilla ja on erittäin hyödyllinen aiheeseen liittyvissä tehtävissä git hakea automaatio. Kun olet navigoinut paikalliseen arkistohakemistoon, se antaa hakukomennon optimaalisilla parametreilla, kuten --ei-tunnisteita välttääksesi tarpeettomien tunnisteiden hakemisen ja --pakottaa varmistaaksesi, että paikallinen arkisto ja kaukosäädin ovat täysin synkronoituja. Tämä kirjoitus lisää myös --karsia -vaihtoehto, joka auttaa pitämään arkiston puhtaana poistamalla viittaukset ei-olemassa oleviin etähaaroihin. Näillä parannuksilla saavutetaan nopeammat suoritusnopeudet vähentämällä haettujen tietojen kokonaiskokoa.

Mukautuvamman vaihtoehdon tarjoaa toinen skripti, joka on kirjoitettu Pythonilla. Enemmän valvontaa ja virheiden käsittelyä on mahdollista, koska Git fetch -komento suoritetaan Python-komentosarjasta käyttämällä subprocess.run() toiminto. Kun hakukomento on sisällytettävä suurempaan järjestelmään, kuten CI/CD-liukuhihnaan, tämä on erityisen hyödyllistä. Virheenkorjaus tai noudon onnistumisen varmistaminen on helppoa Python-komentosarjan avulla, joka tallentaa hakukutsun lähdön ja kirjaa kaikki virheet lokiin. On myös yksinkertaisempaa skaalata tämä ratkaisu monimutkaisempiin automatisoituihin toimintoihin, koska Python-komentosarja on tuettu.

Lopuksi viimeinen lähestymistapa suorittaa Git-haun Node.js:n avulla. Siirrettävän tiedon määrää voidaan vähentää merkittävästi käyttämällä tätä komentosarjaa, joka keskittyy tiettyjen haarojen hakemiseen. Käyttämällä "+refs/heads/*:refs/remotes/origin/*" sivukonttoreiden ilmoittaminen varmistaa, että vain tarvittavat viitteet ladataan. Tehokkuuden optimoimiseksi tämä strategia on erityisen hyödyllinen skenaarioissa, joissa kehittäjät haluavat päivityksiä vain tietyille sivuille. Koska Node.js on asynkroninen, tämä prosessi voi toimia estämättä muita prosesseja, mikä tekee siitä täydellisen reaaliaikaisiin sovelluksiin.

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

Big Pack -tiedostojen vaikutusten tutkiminen Git Fetch -nopeuteen

Yksi vähemmän tunnetuista syistä git hakea Toisen ajon pidempi kesto liittyy Gitin suurten tietovarastojen, nimittäin pakkaustiedostojen, käsittelyyn. Pack-tiedostot, jotka ovat pakattuja objektikokoelmia, kuten committeja, puita ja blobeja, ovat tehokas tapa Gitille tallentaa arkistotietoja. Vaikka tämä säästää tilaa, se voi aiheuttaa noutoviiveitä, varsinkin jos isokokoisia tiedostoja ladataan useammin kuin on tarpeen. Nämä pakettitiedostot voivat kasvaa erittäin suuriksi ja aiheuttaa pitkiä hakuaikoja, kun arkiston määrä kasvaa ajan myötä, kuten voi tapahtua useita vuosia kehitetyssä projektissa.

On tärkeää ymmärtää, kuinka Git käyttää tiettyjä lippuja optimoimaan hakuprosessit tämän ongelman estämiseksi. Esimerkiksi vain viimeisimmän toimitushistorian hakeminen, kun --syvyys=1 -vaihtoehtoa käytetään rajoittaa haun matalaan kopioon. Siitä huolimatta, jos Git löytää eroja tai muutoksia haaroissa, se voi silti päättää ladata suuren pakettitiedoston tietyissä olosuhteissa. Vaikka suuria arkiston päivityksiä ei olisikaan, tämä saattaa tapahtua ja aiheuttaa hämmennystä suunnittelijoiden keskuudessa.

Käyttämällä git fetch --luumu tarpeettomien haarojen ja viitteiden poistaminen on lisätapa vanhentuneiden etähaarojen poistamiseen. Voit lyhentää hakuaikaa huomattavasti puhdistamalla arkiston rutiininomaisesti ja varmistamalla, että vain asiaankuuluvat tiedot noudetaan. Jatkuvan integroinnin/jatkuvan kehityksen (CI/CD) asetuksissa, joissa toistuvat haut voivat haitata rakennusnopeutta ja kehitystehokkuutta, tämä on erittäin hyödyllistä.