ਦੂਜੀ ਵਾਰ ਵੱਡੇ ਭੰਡਾਰਾਂ

Arthur Petit

ਸ਼ੁੱਕਰਵਾਰ, 27 ਸਤੰਬਰ 2024 4:10:02 ਬਾ.ਦੁ.

ਵੱਡੀ ਰਿਪੋਜ਼ਟਰੀਆਂ ਵਿੱਚ ਦੂਜੀ ਗਿੱਟ ਪ੍ਰਾਪਤੀ ਜ਼ਿਆਦਾ ਸਮਾਂ ਕਿਉਂ ਲੈਂਦੀ ਹੈ?

ਵਿਸ਼ਾਲ ਰਿਪੋਜ਼ਟਰੀਆਂ ਦਾ ਪ੍ਰਬੰਧਨ ਕਰਨਾ ਸਾਫਟਵੇਅਰ ਵਿਕਾਸ ਵਿੱਚ ਇੱਕ ਖਾਸ ਕੰਮ ਹੈ, ਖਾਸ ਤੌਰ 'ਤੇ ਲੰਬੇ ਸਮੇਂ ਦੇ ਪ੍ਰੋਜੈਕਟਾਂ ਲਈ ਜੋ ਨਿਰੰਤਰ ਵਿਕਾਸ ਅਧੀਨ ਹਨ। Git ਕਮਾਂਡਾਂ ਨਾਲ ਇੱਕ ਰਿਪੋਜ਼ਟਰੀ ਨੂੰ ਪ੍ਰਭਾਵਸ਼ਾਲੀ ਢੰਗ ਨਾਲ ਪ੍ਰਬੰਧਿਤ ਕਰਨ ਦੀ ਪੇਚੀਦਗੀ git ਪ੍ਰਾਪਤ ਕਰੋ ਰਿਪੋਜ਼ਟਰੀ ਦੇ ਫੈਲਣ ਨਾਲ ਵਧਦਾ ਹੈ। ਡਿਵੈਲਪਰਾਂ ਲਈ ਲੰਬੇ ਅਰੰਭਕ ਦੀ ਉਮੀਦ ਕਰਨਾ ਆਮ ਗੱਲ ਹੈ git ਪ੍ਰਾਪਤ ਕਰੋ, ਇਸ ਲਈ ਇਹ ਉਲਝਣ ਵਾਲਾ ਹੁੰਦਾ ਹੈ ਜਦੋਂ ਦੂਜੀ ਪ੍ਰਾਪਤੀ ਉਮੀਦ ਨਾਲੋਂ ਬਹੁਤ ਹੌਲੀ ਹੁੰਦੀ ਹੈ।

ਜਦੋਂ ਪਹਿਲੀ ਅਤੇ ਦੂਜੀ ਪ੍ਰਾਪਤੀ ਦੇ ਵਿਚਕਾਰ ਰਿਪੋਜ਼ਟਰੀ ਵਿੱਚ ਕੋਈ ਬਦਲਾਅ ਨਹੀਂ ਹੋਇਆ ਹੈ, ਤਾਂ ਇਹ ਸਥਿਤੀ ਹੋਰ ਵੀ ਉਲਝਣ ਵਾਲੀ ਬਣ ਜਾਂਦੀ ਹੈ। ਇੱਕ ਵੱਡਾ ਪ੍ਰੋਜੈਕਟ, ਗੀਗਾਬਾਈਟ ਦੇ ਗਿੱਟ ਇਤਿਹਾਸ ਦੇ ਨਾਲ, ਅਜੇ ਵੀ ਇੱਕ ਲੰਮਾ ਐਗਜ਼ੀਕਿਊਸ਼ਨ ਸਮਾਂ ਦੇਖ ਸਕਦਾ ਹੈ, ਜਿਸ ਨਾਲ ਡਿਵੈਲਪਰ ਹੈਰਾਨ ਹੁੰਦੇ ਹਨ ਕਿ ਅਜਿਹਾ ਕਿਉਂ ਹੁੰਦਾ ਹੈ। ਇਸ ਦ੍ਰਿਸ਼ ਵਿੱਚ ਜੇਨਕਿਨਜ਼ ਵਰਗੀਆਂ CI/CD ਪਾਈਪਲਾਈਨਾਂ ਨਾਲ ਕੰਮ ਕਰਨਾ ਪ੍ਰਦਰਸ਼ਨ ਦੀਆਂ ਬੇਨਿਯਮੀਆਂ ਨੂੰ ਕਾਫ਼ੀ ਮਹੱਤਵਪੂਰਨ ਬਣਾ ਸਕਦਾ ਹੈ।

ਜਦੋਂ ਪਹਿਲੀ ਅਤੇ ਦੂਜੀ ਪ੍ਰਾਪਤੀ ਦੇ ਵਿਚਕਾਰ ਰਿਪੋਜ਼ਟਰੀ ਵਿੱਚ ਕੋਈ ਬਦਲਾਅ ਨਹੀਂ ਹੋਇਆ ਹੈ, ਤਾਂ ਇਹ ਸਥਿਤੀ ਹੋਰ ਵੀ ਉਲਝਣ ਵਾਲੀ ਬਣ ਜਾਂਦੀ ਹੈ। ਇੱਕ ਵਿਸ਼ਾਲ ਪ੍ਰੋਜੈਕਟ, ਗੀਗਾਬਾਈਟ ਦੇ ਗਿੱਟ ਇਤਿਹਾਸ ਦੇ ਨਾਲ, ਫਿਰ ਵੀ ਇੱਕ ਲੰਮਾ ਐਗਜ਼ੀਕਿਊਸ਼ਨ ਸਮਾਂ ਦਿਖਾ ਸਕਦਾ ਹੈ, ਇੰਜਨੀਅਰ ਹੈਰਾਨ ਰਹਿ ਜਾਂਦੇ ਹਨ ਕਿ ਅਜਿਹਾ ਕਿਉਂ ਹੋਇਆ। ਇਸ ਦ੍ਰਿਸ਼ ਵਿੱਚ ਜੇਨਕਿਨਜ਼ ਵਰਗੀਆਂ CI/CD ਪਾਈਪਲਾਈਨਾਂ ਨਾਲ ਕੰਮ ਕਰਨਾ ਪ੍ਰਦਰਸ਼ਨ ਦੀਆਂ ਬੇਨਿਯਮੀਆਂ ਨੂੰ ਕਾਫ਼ੀ ਮਹੱਤਵਪੂਰਨ ਬਣਾ ਸਕਦਾ ਹੈ।

ਅਸੀਂ ਇਸ ਲੇਖ ਵਿੱਚ ਵੱਡੇ ਭੰਡਾਰਾਂ ਵਿੱਚ ਇਹਨਾਂ ਸੁਸਤ ਪ੍ਰਾਪਤੀਆਂ ਦੇ ਕਾਰਨਾਂ ਦੀ ਜਾਂਚ ਕਰਾਂਗੇ। ਅਸੀਂ ਵੱਡੀਆਂ ਗਿੱਟ ਵਸਤੂਆਂ ਨੂੰ ਵਾਰ-ਵਾਰ ਡਾਉਨਲੋਡ ਕਰਨ ਤੋਂ ਰੋਕਣ ਦੇ ਕੁਝ ਤਰੀਕਿਆਂ ਦੀ ਵੀ ਜਾਂਚ ਕਰਾਂਗੇ, ਜੋ ਤੁਹਾਡੀਆਂ ਪ੍ਰਾਪਤੀਆਂ ਦੀ ਪ੍ਰਭਾਵਸ਼ੀਲਤਾ ਨੂੰ ਤੇਜ਼ ਅਤੇ ਬਿਹਤਰ ਬਣਾਉਣਗੇ।

ਹੁਕਮ	ਵਰਤੋਂ ਦੀ ਉਦਾਹਰਨ
git fetch --prune	ਸਰਵਰ ਤੋਂ ਰਿਮੋਟ ਸ਼ਾਖਾਵਾਂ ਦੇ ਸਾਰੇ ਸੰਦਰਭਾਂ ਨੂੰ ਹਟਾ ਦਿੰਦਾ ਹੈ ਜੋ ਹੁਣ ਮੌਜੂਦ ਨਹੀਂ ਹਨ। ਵੱਡੇ ਰਿਪੋਜ਼ਟਰੀਆਂ ਤੋਂ ਤਬਦੀਲੀਆਂ ਨੂੰ ਇਕੱਠਾ ਕਰਨ ਵੇਲੇ ਇਹ ਜ਼ਰੂਰੀ ਹੁੰਦਾ ਹੈ ਕਿਉਂਕਿ ਇਹ ਪੁਰਾਣੀਆਂ ਸ਼ਾਖਾਵਾਂ ਨੂੰ ਸਾਫ਼ ਕਰਨ ਵਿੱਚ ਮਦਦ ਕਰਦਾ ਹੈ।
git fetch --depth=1	ਸੰਪੂਰਨ ਇਤਿਹਾਸ ਦੀ ਬਜਾਏ ਸਿਰਫ ਸਭ ਤੋਂ ਤਾਜ਼ਾ ਸਨੈਪਸ਼ਾਟ ਪ੍ਰਾਪਤ ਕਰਦੇ ਹੋਏ, ਪ੍ਰਾਪਤ ਕੀਤੇ ਗਏ ਰਿਪੋਜ਼ਟਰੀ ਇਤਿਹਾਸ ਦੀ ਮਾਤਰਾ ਨੂੰ ਸੀਮਤ ਕਰਦਾ ਹੈ। ਵੱਡੇ ਰਿਪੋਜ਼ਟਰੀਆਂ ਲਈ, ਇਹ ਪ੍ਰਕਿਰਿਆ ਨੂੰ ਤੇਜ਼ ਕਰਦਾ ਹੈ ਅਤੇ ਬੈਂਡਵਿਡਥ ਦੀ ਵਰਤੋਂ ਨੂੰ ਘਟਾਉਂਦਾ ਹੈ।
git fetch --no-tags	ਟੈਗ ਪ੍ਰਾਪਤ ਕਰਨਾ ਬੰਦ ਕਰਦਾ ਹੈ, ਜੋ ਕਿ ਇਸ ਸਥਿਤੀ ਵਿੱਚ ਲੋੜ ਤੋਂ ਵੱਧ ਹੈ ਅਤੇ ਰਿਮੋਟ ਰਿਪੋਜ਼ਟਰੀ ਤੋਂ ਪ੍ਰਾਪਤ ਕੀਤੇ ਡੇਟਾ ਦੀ ਮਾਤਰਾ ਨੂੰ ਘੱਟ ਕਰਨ ਵਿੱਚ ਮਦਦ ਕਰਦਾ ਹੈ।
subprocess.run()	Python ਵਿੱਚ Subprocess.run() ਇੱਕ ਸ਼ੈੱਲ ਕਮਾਂਡ (ਜਿਵੇਂ ਕਿ ਇੱਕ ਗਿੱਟ ਕਮਾਂਡ) ਚਲਾਉਣ ਅਤੇ ਇਸਦੇ ਨਤੀਜੇ ਨੂੰ ਰਿਕਾਰਡ ਕਰਨ ਦੇ ਯੋਗ ਬਣਾਉਂਦਾ ਹੈ। ਇਹ ਆਟੋਮੇਸ਼ਨ ਸਕ੍ਰਿਪਟਾਂ ਵਿੱਚ ਸਿਸਟਮ-ਪੱਧਰ ਦੀਆਂ ਕਮਾਂਡਾਂ ਨੂੰ ਸ਼ਾਮਲ ਕਰਨ ਲਈ ਮਦਦਗਾਰ ਹੈ।
exec()	Node.js ਵਿੱਚ, exec() ਇੱਕ JavaScript ਸ਼ੈੱਲ ਕਮਾਂਡ ਚਲਾਉਂਦੀ ਹੈ। ਇਹ ਗਿੱਟ ਕਾਰਜਾਂ ਨੂੰ ਪੂਰਾ ਕਰਨ ਅਤੇ ਉਹਨਾਂ ਦੇ ਨਤੀਜਿਆਂ ਨੂੰ ਅਸਿੰਕ੍ਰੋਨਸ ਤਰੀਕੇ ਨਾਲ ਸੰਭਾਲਣ ਲਈ ਲਗਾਇਆ ਜਾਂਦਾ ਹੈ।
unittest.TestCase	ਪਾਈਥਨ ਯੂਨਿਟ ਟੈਸਟ ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕਰਦਾ ਹੈ ਜੋ ਇਹ ਯਕੀਨੀ ਬਣਾਉਣ ਲਈ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ ਕਿ git_fetch() ਵਿਧੀ ਵੱਖ-ਵੱਖ ਸਥਿਤੀਆਂ ਵਿੱਚ ਸਫਲਤਾਪੂਰਵਕ ਕੰਮ ਕਰਦੀ ਹੈ, ਜਿਸ ਵਿੱਚ ਵੈਧ ਅਤੇ ਅਵੈਧ ਪਾਥ ਵੀ ਸ਼ਾਮਲ ਹਨ।
git fetch --force	ਇਹ ਸੁਨਿਸ਼ਚਿਤ ਕਰਦਾ ਹੈ ਕਿ ਸਥਾਨਕ ਰਿਪੋਜ਼ਟਰੀ ਰਿਮੋਟ ਨਾਲ ਬਿਲਕੁਲ ਸਮਕਾਲੀ ਹੈ, ਭਾਵੇਂ ਕਿ ਵਿਵਾਦ ਦੀ ਸਥਿਤੀ ਵਿੱਚ, ਇੱਕ ਮੁੜ ਪ੍ਰਾਪਤ ਕਰਨ ਲਈ ਮਜਬੂਰ ਕਰਕੇ, ਭਾਵੇਂ ਇਹ ਗੈਰ-ਫਾਸਟ-ਅੱਗੇ ਅੱਪਡੇਟ ਦੇ ਨਤੀਜੇ ਵਜੋਂ ਹੁੰਦਾ ਹੈ।
git fetch "+refs/heads/:refs/remotes/origin/"	ਦਰਸਾਉਂਦਾ ਹੈ ਕਿ ਰਿਮੋਟ ਰਿਪੋਜ਼ਟਰੀ ਤੋਂ ਕਿਹੜੀਆਂ ਸ਼ਾਖਾਵਾਂ ਜਾਂ ਹਵਾਲੇ ਪ੍ਰਾਪਤ ਕੀਤੇ ਜਾਣੇ ਚਾਹੀਦੇ ਹਨ। ਸਹੀ ਅੱਪਡੇਟ ਦੀ ਗਾਰੰਟੀ ਦੇਣ ਲਈ, ਇਹ ਕਮਾਂਡ ਖਾਸ ਤੌਰ 'ਤੇ ਦੂਰ-ਦੁਰਾਡੇ ਦੀਆਂ ਸ਼ਾਖਾਵਾਂ ਨੂੰ ਸਥਾਨਕ ਸੰਦਰਭਾਂ ਲਈ ਮੈਪ ਕਰਦੀ ਹੈ।

ਵੱਡੇ ਰਿਪੋਜ਼ਟਰੀਆਂ ਲਈ ਗਿੱਟ ਫੈਚ ਨੂੰ ਅਨੁਕੂਲਿਤ ਕਰਨਾ: ਇੱਕ ਵਿਆਖਿਆ

ਪਹਿਲਾਂ ਦਿੱਤੀਆਂ ਗਈਆਂ ਸਕ੍ਰਿਪਟਾਂ ਉਹਨਾਂ ਅਯੋਗਤਾਵਾਂ ਨਾਲ ਨਜਿੱਠਣ ਲਈ ਹੁੰਦੀਆਂ ਹਨ ਜੋ ਉਦੋਂ ਵਾਪਰਦੀਆਂ ਹਨ git ਪ੍ਰਾਪਤ ਕਰੋ ਕਮਾਂਡਾਂ ਵੱਡੇ ਰਿਪੋਜ਼ਟਰੀਆਂ 'ਤੇ ਚਲਾਈਆਂ ਜਾਂਦੀਆਂ ਹਨ। ਹਾਲਾਂਕਿ ਰਿਪੋਜ਼ਟਰੀ ਵਿੱਚ ਕੋਈ ਵੱਡੀਆਂ ਤਬਦੀਲੀਆਂ ਨਹੀਂ ਹੋਈਆਂ ਹਨ, ਇਹ ਅਕੁਸ਼ਲਤਾਵਾਂ ਆਮ ਤੌਰ 'ਤੇ ਸ਼ੁਰੂਆਤੀ ਪ੍ਰਾਪਤੀ ਤੋਂ ਬਾਅਦ ਸਪੱਸ਼ਟ ਹੋ ਜਾਂਦੀਆਂ ਹਨ ਜਦੋਂ Git ਅਣਜਾਣੇ ਵਿੱਚ ਵੱਡੀਆਂ ਪੈਕ ਫਾਈਲਾਂ ਨੂੰ ਡਾਊਨਲੋਡ ਕਰਦਾ ਹੈ। ਸਕ੍ਰਿਪਟਾਂ ਜਿਵੇਂ ਆਰਗੂਮੈਂਟਾਂ ਦੀ ਵਰਤੋਂ ਕਰਦੀਆਂ ਹਨ --ਡੂੰਘਾਈ = 1 ਅਤੇ --ਛਾਂਗਣਾ ਵਚਨਬੱਧ ਇਤਿਹਾਸ ਨੂੰ ਸੀਮਤ ਕਰਨ ਅਤੇ ਅਪ੍ਰਚਲਿਤ ਸੰਦਰਭਾਂ ਨੂੰ ਹਟਾਉਣ ਲਈ, ਬੇਲੋੜੇ ਡਾਊਨਲੋਡਾਂ ਨੂੰ ਘੱਟ ਤੋਂ ਘੱਟ ਕਰਨ ਦੀ ਕੋਸ਼ਿਸ਼ ਵਿੱਚ। ਜੇਨਕਿਨਸ ਵਰਗੇ ਨਿਰੰਤਰ ਏਕੀਕਰਣ (CI) ਵਾਤਾਵਰਣਾਂ ਵਿੱਚ ਕੰਮ ਕਰਦੇ ਸਮੇਂ ਗਤੀ ਅਤੇ ਕੁਸ਼ਲਤਾ ਨੂੰ ਬਣਾਈ ਰੱਖਣਾ ਮਹੱਤਵਪੂਰਨ ਹੁੰਦਾ ਹੈ, ਇਸਲਈ ਇਹ ਵਿਸ਼ੇਸ਼ ਤੌਰ 'ਤੇ ਮਹੱਤਵਪੂਰਨ ਹੈ।

ਪਹਿਲੀ ਸਕਰਿਪਟ ਬਾਸ਼ ਵਿੱਚ ਲਿਖੀ ਗਈ ਹੈ ਅਤੇ ਨਾਲ ਸਬੰਧਤ ਕਰਤੱਵਾਂ ਲਈ ਬਹੁਤ ਮਦਦਗਾਰ ਹੈ git ਪ੍ਰਾਪਤ ਕਰੋ ਆਟੋਮੇਸ਼ਨ. ਲੋਕਲ ਰਿਪੋਜ਼ਟਰੀ ਡਾਇਰੈਕਟਰੀ ਵਿੱਚ ਨੈਵੀਗੇਟ ਕਰਨ ਤੋਂ ਬਾਅਦ, ਇਹ ਅਨੁਕੂਲ ਪੈਰਾਮੀਟਰਾਂ ਦੇ ਨਾਲ fetch ਕਮਾਂਡ ਜਾਰੀ ਕਰਦਾ ਹੈ, ਜਿਵੇਂ ਕਿ --ਨੋ-ਟੈਗ ਬੇਲੋੜੇ ਟੈਗਾਂ ਨੂੰ ਪ੍ਰਾਪਤ ਕਰਨ ਤੋਂ ਰੋਕਣ ਲਈ ਅਤੇ --ਫੋਰਸ ਇਹ ਗਾਰੰਟੀ ਦੇਣ ਲਈ ਕਿ ਲੋਕਲ ਰਿਪੋਜ਼ਟਰੀ ਅਤੇ ਰਿਮੋਟ ਪੂਰੀ ਤਰ੍ਹਾਂ ਸਿੰਕ ਕੀਤੇ ਗਏ ਹਨ। ਇਹ ਸਕ੍ਰਿਪਟ ਵੀ ਜੋੜਦੀ ਹੈ --ਛਾਂਗਣਾ ਵਿਕਲਪ, ਜੋ ਕਿ ਹੁਣ-ਮੌਜੂਦ ਰਿਮੋਟ ਸ਼ਾਖਾਵਾਂ ਦੇ ਹਵਾਲੇ ਹਟਾ ਕੇ ਰਿਪੋਜ਼ਟਰੀ ਨੂੰ ਸਾਫ਼ ਰੱਖਣ ਵਿੱਚ ਮਦਦ ਕਰਦਾ ਹੈ। ਪ੍ਰਾਪਤ ਕੀਤੇ ਡੇਟਾ ਦੇ ਕੁੱਲ ਆਕਾਰ ਨੂੰ ਘਟਾ ਕੇ ਇਹਨਾਂ ਸੁਧਾਰਾਂ ਦੁਆਰਾ ਤੇਜ਼ ਐਗਜ਼ੀਕਿਊਸ਼ਨ ਸਪੀਡ ਪ੍ਰਾਪਤ ਕੀਤੀ ਜਾਂਦੀ ਹੈ।

ਹੋਰ ਅਨੁਕੂਲ ਵਿਕਲਪ ਦੂਜੀ ਸਕ੍ਰਿਪਟ ਦੁਆਰਾ ਪੇਸ਼ ਕੀਤਾ ਗਿਆ ਹੈ, ਜੋ ਪਾਈਥਨ ਵਿੱਚ ਲਿਖੀ ਗਈ ਹੈ। ਵਧੇਰੇ ਨਿਯੰਤਰਣ ਅਤੇ ਗਲਤੀ ਹੈਂਡਲਿੰਗ ਸੰਭਵ ਹੈ ਕਿਉਂਕਿ Git fetch ਕਮਾਂਡ ਨੂੰ ਪਾਈਥਨ ਸਕ੍ਰਿਪਟ ਦੇ ਅੰਦਰ ਤੋਂ ਚਲਾਇਆ ਜਾਂਦਾ ਹੈ subprocess.run() ਫੰਕਸ਼ਨ. ਜਦੋਂ ਮੁੜ ਪ੍ਰਾਪਤ ਕਰਨ ਦੀ ਕਮਾਂਡ ਨੂੰ ਇੱਕ ਵੱਡੇ ਸਿਸਟਮ ਵਿੱਚ ਸ਼ਾਮਲ ਕਰਨ ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ, ਜਿਵੇਂ ਕਿ ਇੱਕ CI/CD ਪਾਈਪਲਾਈਨ, ਇਹ ਵਿਸ਼ੇਸ਼ ਤੌਰ 'ਤੇ ਮਦਦਗਾਰ ਹੁੰਦਾ ਹੈ। ਸਮੱਸਿਆਵਾਂ ਨੂੰ ਡੀਬੱਗ ਕਰਨਾ ਜਾਂ ਪੁਸ਼ਟੀ ਕਰਨਾ ਕਿ ਪ੍ਰਾਪਤ ਕਰਨਾ ਸਫਲ ਰਿਹਾ ਸੀ, ਪਾਈਥਨ ਸਕ੍ਰਿਪਟ ਦੁਆਰਾ ਆਸਾਨ ਬਣਾਇਆ ਗਿਆ ਹੈ, ਜੋ ਪ੍ਰਾਪਤ ਕਾਲ ਦੇ ਆਉਟਪੁੱਟ ਨੂੰ ਰਿਕਾਰਡ ਕਰਦੀ ਹੈ ਅਤੇ ਕਿਸੇ ਵੀ ਤਰੁੱਟੀ ਨੂੰ ਲੌਗ ਕਰਦੀ ਹੈ। ਵਧੇਰੇ ਗੁੰਝਲਦਾਰ ਸਵੈਚਾਲਿਤ ਗਤੀਵਿਧੀਆਂ ਲਈ ਇਸ ਹੱਲ ਨੂੰ ਸਕੇਲ ਕਰਨਾ ਵੀ ਸੌਖਾ ਹੈ ਕਿਉਂਕਿ ਪਾਈਥਨ ਸਕ੍ਰਿਪਟਿੰਗ ਸਮਰਥਿਤ ਹੈ।

ਅੰਤ ਵਿੱਚ, ਅੰਤਮ ਪਹੁੰਚ Node.js ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਇੱਕ ਗਿੱਟ ਪ੍ਰਾਪਤ ਕਰਦੀ ਹੈ। ਇਸ ਸਕ੍ਰਿਪਟ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਟ੍ਰਾਂਸਫਰ ਕੀਤੇ ਗਏ ਡੇਟਾ ਦੀ ਮਾਤਰਾ ਨੂੰ ਕਾਫ਼ੀ ਘਟਾਇਆ ਜਾ ਸਕਦਾ ਹੈ, ਜੋ ਕਿ ਖਾਸ ਸ਼ਾਖਾਵਾਂ ਨੂੰ ਪ੍ਰਾਪਤ ਕਰਨ 'ਤੇ ਕੇਂਦ੍ਰਿਤ ਹੈ। ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ "+refs/heads/*:refs/remotes/origin/*" ਸ਼ਾਖਾਵਾਂ ਨੂੰ ਦਰਸਾਉਣ ਲਈ ਇਹ ਯਕੀਨੀ ਬਣਾਉਂਦਾ ਹੈ ਕਿ ਸਿਰਫ਼ ਲੋੜੀਂਦੇ ਹਵਾਲੇ ਹੀ ਡਾਊਨਲੋਡ ਕੀਤੇ ਗਏ ਹਨ। ਕੁਸ਼ਲਤਾ ਨੂੰ ਹੋਰ ਅਨੁਕੂਲ ਬਣਾਉਣ ਲਈ, ਇਹ ਰਣਨੀਤੀ ਖਾਸ ਤੌਰ 'ਤੇ ਉਹਨਾਂ ਸਥਿਤੀਆਂ ਵਿੱਚ ਮਦਦਗਾਰ ਹੈ ਜਿੱਥੇ ਡਿਵੈਲਪਰ ਸਿਰਫ਼ ਖਾਸ ਸ਼ਾਖਾਵਾਂ 'ਤੇ ਹੀ ਅੱਪਡੇਟ ਚਾਹੁੰਦੇ ਹਨ। ਕਿਉਂਕਿ Node.js ਅਸਿੰਕਰੋਨਸ ਹੈ, ਇਹ ਪ੍ਰਕਿਰਿਆ ਹੋਰ ਪ੍ਰਕਿਰਿਆਵਾਂ ਵਿੱਚ ਰੁਕਾਵਟ ਦੇ ਬਿਨਾਂ ਕੰਮ ਕਰ ਸਕਦੀ ਹੈ, ਜੋ ਇਸਨੂੰ ਰੀਅਲ-ਟਾਈਮ ਐਪਲੀਕੇਸ਼ਨਾਂ ਲਈ ਸੰਪੂਰਨ ਬਣਾਉਂਦਾ ਹੈ।

ਵੱਡੇ ਰਿਪੋਜ਼ਟਰੀਆਂ ਵਿੱਚ ਗਿੱਟ ਫੈਚ ਪ੍ਰਦਰਸ਼ਨ ਨੂੰ ਅਨੁਕੂਲਿਤ ਕਰਨਾ

ਵੱਡੇ ਗਿੱਟ ਫੈਚਾਂ ਦਾ ਪ੍ਰਬੰਧਨ ਅਤੇ ਅਨੁਕੂਲਿਤ ਕਰਨ ਲਈ ਬੈਸ਼ ਸਕ੍ਰਿਪਟ ਦੀ ਵਰਤੋਂ ਕਰਨਾ

#!/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 ਪਾਈਪਲਾਈਨਾਂ ਵਿੱਚ ਗਿੱਟ ਫੈਚ ਲਈ ਪਾਈਥਨ ਸਕ੍ਰਿਪਟ ਦੀ ਵਰਤੋਂ ਕਰਨਾ

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 ਪ੍ਰਾਪਤ ਕਰੋ ਦੂਜੀ ਰਨ 'ਤੇ ਜ਼ਿਆਦਾ ਸਮਾਂ ਲੈਣਾ ਗਿੱਟ ਦੇ ਵੱਡੇ ਰਿਪੋਜ਼ਟਰੀਆਂ, ਅਰਥਾਤ ਪੈਕ ਫਾਈਲਾਂ ਦੇ ਪ੍ਰਬੰਧਨ ਨਾਲ ਸਬੰਧਤ ਹੈ। ਪੈਕ ਫਾਈਲਾਂ, ਜੋ ਕਿ ਕਮਿਟ, ਟ੍ਰੀ ਅਤੇ ਬਲੌਬ ਵਰਗੀਆਂ ਵਸਤੂਆਂ ਦੇ ਸੰਕੁਚਿਤ ਸੰਗ੍ਰਹਿ ਹਨ, ਰਿਪੋਜ਼ਟਰੀ ਡੇਟਾ ਨੂੰ ਸਟੋਰ ਕਰਨ ਲਈ ਗਿੱਟ ਲਈ ਇੱਕ ਪ੍ਰਭਾਵਸ਼ਾਲੀ ਤਰੀਕਾ ਹੈ। ਹਾਲਾਂਕਿ ਇਹ ਸਪੇਸ ਬਚਾਉਂਦਾ ਹੈ, ਇਸਦੇ ਨਤੀਜੇ ਵਜੋਂ ਪ੍ਰਾਪਤ ਕਰਨ ਵਿੱਚ ਦੇਰੀ ਹੋ ਸਕਦੀ ਹੈ, ਖਾਸ ਤੌਰ 'ਤੇ ਜੇ ਵੱਡੀਆਂ ਪੈਕ ਫਾਈਲਾਂ ਨੂੰ ਲੋੜ ਤੋਂ ਵੱਧ ਵਾਰ ਡਾਊਨਲੋਡ ਕੀਤਾ ਜਾਂਦਾ ਹੈ। ਇਹ ਪੈਕ ਫਾਈਲਾਂ ਬਹੁਤ ਵੱਡੀਆਂ ਹੋ ਸਕਦੀਆਂ ਹਨ ਅਤੇ ਲੰਬੇ ਸਮੇਂ ਦੇ ਮੁੜ ਪ੍ਰਾਪਤ ਕਰਨ ਦਾ ਕਾਰਨ ਬਣ ਸਕਦੀਆਂ ਹਨ ਜਦੋਂ ਇੱਕ ਰਿਪੋਜ਼ਟਰੀ ਸਮੇਂ ਦੇ ਨਾਲ ਵਧਦੀ ਹੈ, ਜਿਵੇਂ ਕਿ ਇਹ ਇੱਕ ਪ੍ਰੋਜੈਕਟ ਵਿੱਚ ਹੋ ਸਕਦੀ ਹੈ ਜੋ ਕਈ ਸਾਲਾਂ ਤੋਂ ਵਿਕਾਸ ਕਰ ਰਿਹਾ ਹੈ।

ਇਹ ਸਮਝਣਾ ਮਹੱਤਵਪੂਰਨ ਹੈ ਕਿ ਕਿਵੇਂ ਗਿੱਟ ਇਸ ਸਮੱਸਿਆ ਨੂੰ ਰੋਕਣ ਲਈ ਪ੍ਰਾਪਤ ਕਰਨ ਦੀਆਂ ਪ੍ਰਕਿਰਿਆਵਾਂ ਨੂੰ ਅਨੁਕੂਲ ਬਣਾਉਣ ਲਈ ਖਾਸ ਫਲੈਗ ਦੀ ਵਰਤੋਂ ਕਰਦਾ ਹੈ। ਉਦਾਹਰਣ ਦੇ ਲਈ, ਸਿਰਫ ਸਭ ਤੋਂ ਤਾਜ਼ਾ ਪ੍ਰਤੀਬੱਧ ਇਤਿਹਾਸ ਪ੍ਰਾਪਤ ਕਰਨਾ ਜਦੋਂ --ਡੂੰਘਾਈ = 1 ਵਿਕਲਪ ਦੀ ਵਰਤੋਂ ਕੀਤੀ ਜਾਂਦੀ ਹੈ ਇੱਕ ਖੋਖਲੀ ਕਾਪੀ ਤੱਕ ਪ੍ਰਾਪਤ ਕਰਨ ਨੂੰ ਸੀਮਤ ਕਰਦਾ ਹੈ। ਫਿਰ ਵੀ, ਜੇਕਰ Git ਨੂੰ ਸ਼ਾਖਾਵਾਂ ਵਿੱਚ ਅੰਤਰ ਜਾਂ ਸੋਧਾਂ ਮਿਲਦੀਆਂ ਹਨ, ਤਾਂ ਇਹ ਅਜੇ ਵੀ ਖਾਸ ਸਥਿਤੀਆਂ ਵਿੱਚ ਇੱਕ ਵੱਡੇ ਪੈਕ ਫਾਈਲ ਨੂੰ ਡਾਊਨਲੋਡ ਕਰਨ ਦਾ ਫੈਸਲਾ ਕਰ ਸਕਦਾ ਹੈ। ਵੱਡੇ ਰਿਪੋਜ਼ਟਰੀ ਅੱਪਗਰੇਡਾਂ ਦੀ ਅਣਹੋਂਦ ਵਿੱਚ ਵੀ, ਇਹ ਵਾਪਰ ਸਕਦਾ ਹੈ ਅਤੇ ਇੰਜੀਨੀਅਰਾਂ ਵਿੱਚ ਉਲਝਣ ਪੈਦਾ ਕਰ ਸਕਦਾ ਹੈ।

ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ git fetch -- prune ਬੇਲੋੜੀਆਂ ਸ਼ਾਖਾਵਾਂ ਅਤੇ ਹਵਾਲਿਆਂ ਨੂੰ ਹਟਾਉਣਾ ਪੁਰਾਣੀਆਂ ਰਿਮੋਟ ਸ਼ਾਖਾਵਾਂ ਨੂੰ ਸਾਫ਼ ਕਰਨ ਵਿੱਚ ਸਹਾਇਤਾ ਕਰਨ ਦਾ ਇੱਕ ਵਾਧੂ ਤਰੀਕਾ ਹੈ। ਤੁਸੀਂ ਰਿਪੋਜ਼ਟਰੀ ਨੂੰ ਨਿਯਮਤ ਤੌਰ 'ਤੇ ਸਾਫ਼ ਕਰਕੇ ਅਤੇ ਇਹ ਯਕੀਨੀ ਬਣਾ ਕੇ ਪ੍ਰਾਪਤ ਕਰਨ ਦੇ ਸਮੇਂ ਨੂੰ ਬਹੁਤ ਘੱਟ ਕਰ ਸਕਦੇ ਹੋ ਕਿ ਸਿਰਫ਼ ਢੁਕਵਾਂ ਡੇਟਾ ਪ੍ਰਾਪਤ ਕੀਤਾ ਗਿਆ ਹੈ। ਨਿਰੰਤਰ ਏਕੀਕਰਣ/ਨਿਰੰਤਰ ਵਿਕਾਸ (CI/CD) ਸੈੱਟਅੱਪਾਂ ਵਿੱਚ, ਜਿੱਥੇ ਵਾਰ-ਵਾਰ ਫੈਚ ਬਿਲਡ ਸਪੀਡ ਅਤੇ ਵਿਕਾਸ ਕੁਸ਼ਲਤਾ ਵਿੱਚ ਰੁਕਾਵਟ ਪਾ ਸਕਦੇ ਹਨ, ਇਹ ਬਹੁਤ ਲਾਭਦਾਇਕ ਹੈ।

Git Fetch ਪ੍ਰਦਰਸ਼ਨ ਮੁੱਦਿਆਂ ਬਾਰੇ ਆਮ ਸਵਾਲ

ਮੇਰੀ ਦੂਜੀ ਗਿੱਟ ਪ੍ਰਾਪਤ ਕਰਨ ਲਈ ਇਸ ਦੇ ਪਹਿਲੇ ਨਾਲੋਂ ਜ਼ਿਆਦਾ ਸਮਾਂ ਕਿਉਂ ਲੱਗਦਾ ਹੈ?
Git ਅਕਸਰ ਵੱਡੀਆਂ ਪੈਕ ਫਾਈਲਾਂ ਨੂੰ ਡਾਊਨਲੋਡ ਕਰਦਾ ਹੈ ਜਿਨ੍ਹਾਂ ਦੀ ਪਹਿਲੀ ਪ੍ਰਾਪਤੀ ਲਈ ਲੋੜ ਨਹੀਂ ਸੀ, ਜਿਸ ਨਾਲ ਦੂਜੀ ਪ੍ਰਾਪਤੀ ਵਿੱਚ ਜ਼ਿਆਦਾ ਸਮਾਂ ਲੱਗਦਾ ਹੈ। ਦੀ ਵਰਤੋਂ ਕਰੋ --depth=1 ਬੇਲੋੜੇ ਇਤਿਹਾਸ ਨੂੰ ਘਟਾਉਣ ਲਈ.
ਮੈਂ Git ਨੂੰ ਬੇਲੋੜਾ ਡਾਟਾ ਡਾਊਨਲੋਡ ਕਰਨ ਤੋਂ ਕਿਵੇਂ ਰੋਕ ਸਕਦਾ ਹਾਂ?
ਇਹ ਯਕੀਨੀ ਬਣਾਉਣ ਲਈ ਕਿ ਸਥਾਨਕ ਰਿਪੋਜ਼ਟਰੀ ਰਿਮੋਟ ਨਾਲ ਬਿਲਕੁਲ ਮੇਲ ਖਾਂਦੀ ਹੈ ਅਤੇ ਟੈਗ ਪ੍ਰਾਪਤ ਕਰਨ ਤੋਂ ਬਚਣ ਲਈ, ਦੀ ਵਰਤੋਂ ਕਰੋ --no-tags ਅਤੇ --force ਵਿਕਲਪ।
Git ਵਿੱਚ ਪੈਕ ਫਾਈਲਾਂ ਦੀ ਕੀ ਭੂਮਿਕਾ ਹੈ?
Git ਵਸਤੂਆਂ ਨੂੰ ਸਮੂਹਾਂ ਵਿੱਚ ਸੰਕੁਚਿਤ ਕੀਤਾ ਜਾਂਦਾ ਹੈ ਜਿਸਨੂੰ ਪੈਕ ਫਾਈਲਾਂ ਕਿਹਾ ਜਾਂਦਾ ਹੈ। ਭਾਵੇਂ ਉਹ ਸਪੇਸ ਦੀ ਬਚਤ ਕਰਦੇ ਹਨ, ਜੇਕਰ ਫੈਚ ਦੌਰਾਨ ਵੱਡੀਆਂ ਫਾਈਲਾਂ ਡਾਊਨਲੋਡ ਕੀਤੀਆਂ ਜਾਂਦੀਆਂ ਹਨ, ਤਾਂ ਉਹਨਾਂ ਦੇ ਨਤੀਜੇ ਵਜੋਂ ਪ੍ਰਾਪਤ ਕਰਨ ਦਾ ਸਮਾਂ ਹੌਲੀ ਹੋ ਸਕਦਾ ਹੈ।
ਕੀ ਮੈਂ ਪ੍ਰਦਰਸ਼ਨ ਨੂੰ ਬਿਹਤਰ ਬਣਾਉਣ ਲਈ ਸਿਰਫ਼ ਖਾਸ ਸ਼ਾਖਾਵਾਂ ਲਿਆ ਸਕਦਾ ਹਾਂ?
ਹਾਂ, ਤੁਸੀਂ ਵਰਤਦੇ ਹੋਏ ਖਾਸ ਸ਼ਾਖਾਵਾਂ ਤੱਕ ਪ੍ਰਾਪਤੀ ਨੂੰ ਸੀਮਤ ਕਰ ਸਕਦੇ ਹੋ "+refs/heads/*:refs/remotes/origin/*", ਜੋ ਪ੍ਰਸਾਰਿਤ ਡੇਟਾ ਦੀ ਮਾਤਰਾ ਨੂੰ ਘਟਾ ਦੇਵੇਗਾ।
ਕਿਵੇਂ ਕਰਦਾ ਹੈ git fetch --prune ਪ੍ਰਾਪਤ ਕਰਨ ਦੀ ਗਤੀ ਨੂੰ ਸੁਧਾਰਨ ਵਿੱਚ ਮਦਦ ਕਰੋ?
ਇਹ ਕਮਾਂਡ ਰਿਪੋਜ਼ਟਰੀ ਨੂੰ ਸਾਫ਼ ਕਰਨ ਅਤੇ ਰਿਮੋਟ ਸ਼ਾਖਾਵਾਂ ਦੇ ਹਵਾਲਿਆਂ ਨੂੰ ਹਟਾ ਕੇ ਮੁੜ ਪ੍ਰਾਪਤ ਕਰਨ ਦੇ ਸਮੇਂ ਵਿੱਚ ਸੁਧਾਰ ਕਰਨ ਵਿੱਚ ਮਦਦ ਕਰਦੀ ਹੈ ਜੋ ਹੁਣ ਕਿਰਿਆਸ਼ੀਲ ਨਹੀਂ ਹਨ।

ਗਿੱਟ ਫੈਚ ਪ੍ਰਦਰਸ਼ਨ 'ਤੇ ਅੰਤਮ ਵਿਚਾਰ

ਡਿਵੈਲਪਰ ਇਹ ਜਾਣ ਕੇ ਆਪਣੇ ਵਰਕਫਲੋ ਨੂੰ ਅਨੁਕੂਲ ਬਣਾ ਸਕਦੇ ਹਨ ਕਿ ਦੂਜਾ ਕਿਉਂ ਹੈ git ਪ੍ਰਾਪਤ ਕਰੋ ਜ਼ਿਆਦਾ ਸਮਾਂ ਲੱਗਦਾ ਹੈ, ਖਾਸ ਕਰਕੇ ਵੱਡੇ ਰਿਪੋਜ਼ਟਰੀਆਂ ਵਿੱਚ। ਆਮ ਤੌਰ 'ਤੇ, Git ਵਾਧੂ ਪੈਕ ਫਾਈਲਾਂ ਨੂੰ ਡਾਊਨਲੋਡ ਕਰਨ ਤੋਂ ਸਮੱਸਿਆ ਪੈਦਾ ਹੁੰਦੀ ਹੈ; ਇਸ ਨੂੰ ਕੁਝ ਫੈਚ ਸੈਟਿੰਗਾਂ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਰੋਕਿਆ ਜਾ ਸਕਦਾ ਹੈ।

ਟ੍ਰਾਂਸਫਰ ਕੀਤੇ ਗਏ ਡੇਟਾ ਦੀ ਮਾਤਰਾ ਨੂੰ ਘਟਾ ਕੇ, ਵਿਧੀਆਂ ਜਿਵੇਂ ਕਿ --ਡੂੰਘਾਈ = 1 ਅਤੇ --ਛਾਂਗਣਾ ਤੇਜ਼ ਪ੍ਰਾਪਤੀ ਦੀ ਗਰੰਟੀ. ਜੇਨਕਿਨਸ-ਵਰਗੇ ਪ੍ਰਣਾਲੀਆਂ ਵਿੱਚ ਇਹਨਾਂ ਤਕਨੀਕਾਂ ਦੀ ਵਰਤੋਂ ਕਰਕੇ, ਵਿਕਾਸ ਨੂੰ ਸੁਚਾਰੂ ਬਣਾਇਆ ਜਾ ਸਕਦਾ ਹੈ ਅਤੇ ਦੁਹਰਾਉਣ ਵਾਲੇ ਮੁੜ ਪ੍ਰਾਪਤ ਕਰਨ ਦੇ ਕਾਰਜਾਂ 'ਤੇ ਬਿਤਾਏ ਸਮੇਂ ਨੂੰ ਘਟਾਇਆ ਜਾ ਸਕਦਾ ਹੈ।

Git Fetch ਪ੍ਰਦਰਸ਼ਨ ਲਈ ਸਰੋਤ ਅਤੇ ਹਵਾਲੇ

ਪੈਕ ਫਾਈਲਾਂ ਅਤੇ ਗਿੱਟ ਓਪਟੀਮਾਈਜੇਸ਼ਨ ਰਣਨੀਤੀਆਂ ਦੀ ਵਿਆਖਿਆ: ਗਿੱਟ ਇੰਟਰਨਲ: ਪੈਕਫਾਈਲਾਂ
ਗਿੱਟ ਫੈਚ ਪ੍ਰਦਰਸ਼ਨ ਟਿਊਨਿੰਗ 'ਤੇ ਵੇਰਵੇ: Git ਪ੍ਰਾਪਤੀ ਨੂੰ ਤੇਜ਼ ਕਰਨ 'ਤੇ ਸਟੈਕ ਓਵਰਫਲੋ ਚਰਚਾ
CI/CD ਪਾਈਪਲਾਈਨਾਂ ਵਿੱਚ ਵੱਡੇ ਰਿਪੋਜ਼ਟਰੀਆਂ ਨੂੰ ਅਨੁਕੂਲ ਬਣਾਉਣ ਲਈ ਵਧੀਆ ਅਭਿਆਸ: ਜੇਨਕਿੰਸ ਗਿਟ ਏਕੀਕਰਣ ਵਧੀਆ ਅਭਿਆਸ
ਉੱਨਤ ਪ੍ਰਾਪਤੀ ਵਿਕਲਪਾਂ ਲਈ ਗਿੱਟ ਦਸਤਾਵੇਜ਼: Git ਅਧਿਕਾਰਤ ਦਸਤਾਵੇਜ਼ ਪ੍ਰਾਪਤ ਕਰੋ

ਦੂਜੀ ਵਾਰ ਵੱਡੇ ਭੰਡਾਰਾਂ ਵਿੱਚ ਹੌਲੀ ਗਿੱਟ ਪ੍ਰਾਪਤੀ ਨੂੰ ਸਮਝਣਾ