Git Remote: उदाहरणों के साथ एक संपूर्ण मार्गदर्शिका

Git एक लोकप्रिय वर्शन कंट्रोल सिस्टम (VCS) है, जिसका उपयोग सॉफ़्टवेयर विकास में समय के साथ फ़ाइलों में हुए बदलावों को ट्रैक करने के लिए किया जाता है। यह सहयोग को आसान बनाता है, क्योंकि डेवलपर्स एक-दूसरे के योगदान को ओवरराइट किए बिना एक साथ काम कर सकते हैं। चूंकि सभी डेवलपर्स प्रोजेक्ट के इतिहास की पूरी स्थानीय प्रतियां रखते हैं, इसलिए व्यक्ति ऑफ़लाइन स्वतंत्र रूप से काम कर सकते हैं और तैयार होने पर सुरक्षित रूप से अपने बदलाव मर्ज कर सकते हैं।

एक रिमोट रिपॉज़िटरी, या रिमोट, आपके Git प्रोजेक्ट का वह संस्करण है जो GitHub या BitBucket जैसे ऑनलाइन होस्टिंग सेवा के माध्यम से क्लाउड में होस्ट किया जाता है।

यह लेख Git remotes को विस्तार से समझेगा। यदि आप Git के साथ अभी शुरुआत कर रहे हैं, तो हमारा शुरुआती लोगों के लिए Git ट्यूटोरियल पढ़ने पर विचार करें। 

Git Remote क्या है?

Git remote एक केंद्रीकृत स्थान प्रदान करता है जहाँ एक रिपॉज़िटरी को संग्रहीत, साझा, और अन्य लोगों द्वारा एक्सेस किया जा सकता है। उपयोगकर्ता अपनी स्थानीय परिवर्तनों को रिमोट पर पुश कर सकते हैं और टीम के साथियों द्वारा किए गए अपडेट को रिमोट से पुल कर सकते हैं। कोड का बैकअप लेने और प्रोडक्शन वातावरण में कोड डिप्लॉय करने के लिए भी remotes उपयोगी हो सकते हैं।

एक लोकल रिपॉज़िटरी आपके अपने कंप्यूटर पर रहती है, इसलिए आप लोकली कोड लिख सकते हैं, कमिट कर सकते हैं और बदलावों का परीक्षण कर सकते हैं। एक रिमोट रिपॉज़िटरी, जो ऑनलाइन स्थित होती है, का उपयोग कोड साझा करने, दूसरों के साथ सहयोग करने और अपने काम का बैकअप लेने के लिए किया जाता है। इस लेख में, हम Git कमांड्स का उपयोग करके लोकल और रिमोट रिपो के बीच बदलावों को कैसे सिंक करें, यह देखेंगे।

Git वर्कफ़्लो

एक सामान्य Git वर्कफ़्लो आपकी लोकल मशीन पर रिमोट रिपॉज़िटरी को “क्लोन” करने से शुरू होता है। क्लोन करने के बाद, आप किसी फीचर या फिक्स पर काम करने के लिए नई ब्रांच बना सकते हैं, संशोधन कर सकते हैं और उन बदलावों को लोकली कमिट कर सकते हैं। 

जब आपका काम तैयार हो जाए, तो आप ब्रांच को रिमोट पर “पुश” करते हैं और रिव्यू के लिए पुल रिक्वेस्ट खोलते हैं। स्वीकृति के बाद, बदलावों को मुख्य ब्रांच में मर्ज करें। 

पूरे प्रोसेस के दौरान, आप अपने लोकल रिपॉज़िटरी को रिमोट के साथ सिंक में रखने के लिए नियमित रूप से “पुल” करते रहते हैं।

एक सामान्य Git वर्कफ़्लो (छवि Introduction to Git Course से)

आइए इस प्रक्रिया को और विस्तार से देखें।

रिपो क्लोन करना

मान लीजिए आप किसी रिमोट रिपॉज़िटरी की एक प्रति बनाना चाहते हैं, जिसे रिपो “क्लोन” करना कहा जाता है। लोकल कॉपी होने पर, आप कोड में बदलाव कर सकते हैं और नई सुविधाओं का परीक्षण कर सकते हैं।

Git का उपयोग करने के लिए सुनिश्चित करें कि यह इंस्टॉल है, फिर टर्मिनल खोलें और यह कमांड चलाएँ: git clone <URL>.

उदाहरण के लिए, GitHub पेज पर यूज़रनेम “datacamp” से “project” नामक प्रोजेक्ट को क्लोन करने के लिए उपयोग करें

git clone https://github.com/datacamp/project.gitसंचालित द्वारा

डिफ़ॉल्ट रिमोट: 'origin'

जब आप किसी रिपॉज़िटरी को क्लोन करते हैं, तो Git एक डिफ़ॉल्ट रिमोट बनाता है जिसका नाम origin होता है। यह लेबल origin उस रिपॉज़िटरी के URL का एलियस होता है जिससे आपने क्लोन किया।

सामान्य Git वर्कफ़्लो में, जब आप git push या git pull जैसे कमांड चलाते हैं, तो Git मान लेता है कि आप origin का संदर्भ दे रहे हैं, जब तक कि आप कोई अलग रिमोट निर्दिष्ट न करें। यह आपकी लोकल कॉपी और साझा रिपॉज़िटरी के बीच बदलावों को सिंक करना आसान बनाता है। हम इस लेख में आगे पुश और पुल पर विस्तार से नज़र डालेंगे।

Git Remotes का प्रबंधन

आम रिमोट प्रबंधन कार्यों में git remote का उपयोग करके मौजूदा remotes देखना और git remote add के साथ नया रिमोट जोड़ना शामिल है।

मौजूदा remotes देखना

मौजूदा remotes देखने के लिए, कमांड git remote का उपयोग करें। 

git remote
>> originसंचालित द्वारा

हमारे उदाहरण में रिमोट एलियस origin सूचीबद्ध है, लेकिन उसका URL नहीं दिखता। यदि आप प्रत्येक रिमोट से जुड़े URL देखना चाहते हैं, तो -v फ़्लैग का उपयोग करें।

git remote -v
>> origin	https://github.com/datacamp/project.git (fetch)
>> origin	https://github.com/datacamp/project.git (push)संचालित द्वारा

नया रिमोट जोड़ना

आप अपनी लोकल रिपॉज़िटरी को किसी अन्य रिमोट से कनेक्ट करना चाह सकते हैं। उदाहरण के लिए, यदि आपने किसी प्रोजेक्ट को फोर्क किया है, तो आप main रिमोट के अलावा मूल रिपॉज़िटरी में होने वाले बदलावों पर भी नज़र रखना चाहेंगे। या, आप अपना कोड GitHub और GitLab जैसी कई प्लेटफ़ॉर्म पर पुश करना चाह सकते हैं।

नया रिमोट जोड़ने के लिए, कमांड git remote add <name> <URL> का उपयोग करें। आइए new_remote नाम का नया रिमोट जोड़ें।

git remote add new_remote https://github.com/datacamp/projectसंचालित द्वारा

रिमोट को नाम देना उपयोगी है ताकि मर्ज करते समय आपको बार-बार URL टाइप न करना पड़े।

remotes का नाम बदलना और हटाना

किसी रिमोट का नाम बदलना सरल है। कमांड git remote rename <old-name> <new-name> का उपयोग करें। उदाहरण के लिए,

git remote rename new_remote original_remoteसंचालित द्वारा

रिमोट का नाम बदल गया है या नहीं, यह सत्यापित करने के लिए git remote से remotes सूचीबद्ध करें।

किसी रिमोट को हटाने के लिए, git remote remove <name> का उपयोग करें। हमारे उदाहरण में:

git remote remove new_remoteसंचालित द्वारा

अब, सत्यापन के लिए remotes सूचीबद्ध करें।

git remote
>> originसंचालित द्वारा

हम देखते हैं कि एकमात्र रिमोट origin है।

रिमोट ब्रांचेस के साथ काम करना

Git में एक ब्रांच main से स्वतंत्र एक पथ है जो आपको अपने प्रोजेक्ट के मुख्य संस्करण से अलग बदलावों पर काम करने की अनुमति देता है। एक बार काम पूरा और रिव्यू हो जाने पर, आप ब्रांच को वापस मुख्य प्रोजेक्ट में मर्ज कर सकते हैं।

रिमोट ब्रांचेस सूचीबद्ध करना

रिमोट ब्रांचेस सूचीबद्ध करने के लिए, हम कमांड git branch -r का उपयोग करते हैं।

git branch -r
>> origin/HEAD -> origin/main
>> origin/mainसंचालित द्वारा

आउटपुट की व्याख्या करें। लाइन origin/main इंगित करती है कि रिमोट origin पर main नाम की एक रिमोट ब्रांच है। लाइन origin/HEAD -> origin/main दर्शाती है कि रिमोट पर डिफ़ॉल्ट ब्रांच origin/main है। तो, यह आउटपुट बताता है कि origin रिमोट पर main डिफ़ॉल्ट ब्रांच है, और फिलहाल वही एकमात्र रिमोट ब्रांच सूचीबद्ध है।

रिमोट ब्रांच को ट्रैक करना

आप अक्सर अपने कोड को सिंक में रखने के लिए किसी लोकल ब्रांच को रिमोट ब्रांच से जोड़ना चाहेंगे। जब कोई लोकल ब्रांच किसी रिमोट ब्रांच को ट्रैक करती है, तो आप हर बार रिमोट और ब्रांच नाम निर्दिष्ट किए बिना बदलावों को पुल और पुश कर सकते हैं। 

Git यह भी ट्रैक करता है कि आपकी लोकल ब्रांच रिमोट से कितने कमिट आगे या पीछे है, जिससे बदलावों का प्रबंधन आसान हो जाता है।

कमांड git checkout --track origin/<branch-name> निर्दिष्ट रिमोट ब्रांच को ट्रैक करने वाली नई लोकल ब्रांच बनाती है। यह <branch-name> के समान नाम की लोकल ब्रांच सेट करती है और उसे रिमोट संस्करण से लिंक करती है। इस तरह, भविष्य में git pull और git push कमांड अपने आप सही रिमोट ब्रांच से इंटरैक्ट करेंगे। आप हमारे ट्यूटोरियल में Git Push और Pull के बारे में और सीख सकते हैं। 

remotes से फ़ेच और पुल करना

अपनी लोकल ब्रांच को अन्य डेवलपर्स के बदलावों के साथ सिंक्रनाइज़ रखने के लिए, आपको कंटेंट अपनी लोकल ब्रांच में पुल करनी होगी। “पुल” करने का अर्थ है रिमोट पर संबंधित ब्रांच से नवीनतम बदलावों को डाउनलोड करना और उन बदलावों को आपकी उस ब्रांच के लोकल संस्करण में मर्ज करना। इससे सुनिश्चित होता है कि आप सबसे ताज़ा कोड के साथ काम कर रहे हैं।

मान लें कि हम origin नामक रिमोट से सभी ब्रांचेस को पुल करना चाहते हैं। यह कमांड git fetch origin से किया जाता है। यदि आप केवल किसी विशिष्ट ब्रांच, जैसे main, को ही फ़ेच करना चाहते हैं, तो उसे निर्दिष्ट करें, जैसे git fetch origin main।

फ़ेच करने के बाद, आपको फ़ेच किए गए बदलावों को अपनी वर्तमान लोकल ब्रांच में मर्ज करके कंटेंट को सिंक्रनाइज़ करना होगा। इसके लिए, git merge origin/<branch-name> चलाएँ, और <branch-name> को उस ब्रांच के नाम से बदलें जिसे आपने फ़ेच किया है। उदाहरण के लिए, रिमोट main ब्रांच से बदलावों को मर्ज करने के लिए, आप git merge origin/main का उपयोग करेंगे।

चूंकि क्रम में फ़ेच और मर्ज करना आम बात है, Git एक सिंगल कमांड देता है जो दोनों करता है: git pull। उदाहरण के लिए, origin नामक रिमोट की main ब्रांच से बदलावों को फ़ेच और मर्ज करने के लिए आप git pull origin main का उपयोग कर सकते हैं।

आपको कब fetch और merge का उपयोग करना चाहिए और कब pull? fetch और merge की दो-चरणीय प्रक्रिया आपको अपडेट प्रक्रिया पर अधिक नियंत्रण देती है। फ़ेच करने से आप रिमोट पर हुए बदलावों को लोकल ब्रांच में मर्ज करने से पहले देख सकते हैं। यह उपयोगी है यदि आप अपडेट्स की समीक्षा करना, अंतर तुलना करना या संभावित कॉन्फ्लिक्ट्स को सावधानी से हैंडल करना चाहते हैं। 

जब आप आश्वस्त हों कि रिमोट बदलाव तुरंत मर्ज करने के लिए सुरक्षित हैं और आप अपनी ब्रांच को जल्दी अपडेट करना चाहते हैं, तो pull का उपयोग करें। यह सुविधाजनक है और दोनों चरणों को एक में जोड़ देता है, लेकिन मर्ज होने से पहले आपको कम दृश्यता मिलती है।

रिमोट रिपॉज़िटरी पर पुश करना

लोकल ब्रांच से रिमोट पर कंटेंट “पुश” करने का मतलब है कि आप अपने लोकल बदलावों को रिमोट रिपॉज़िटरी की संबंधित ब्रांच पर भेज रहे हैं। इससे रिमोट आपके नवीनतम काम से अपडेट हो जाता है ताकि अन्य लोग उसे देख सकें, पुल कर सकें या उस पर आगे काम कर सकें। पुश करना आपके योगदान साझा करता है और प्रोजेक्ट पर काम करने वाले सभी लोगों के लिए रिमोट रिपॉज़िटरी को अप टू डेट रखने में मदद करता है।

लोकल बदलावों को रिमोट पर अपलोड करना तीन-चरणीय प्रक्रिया है।

1. जिन फ़ाइलों को शामिल करना है उन्हें स्टेज करने के लिए git add का उपयोग करें। सभी बदलाव जोड़ने के लिए उपयोग करें

git addसंचालित द्वारा

किसी विशेष फ़ाइल को जोड़ने के लिए, फ़ाइल का नाम निर्दिष्ट करें।

git add <filename>संचालित द्वारा

2. अपने बदलाव कमिट करें। आपने क्या किया, इसका वर्णन करने के लिए संदेश शामिल करें।

git commit -m “Your commit message here”संचालित द्वारा

3. रिमोट पर पुश करें।

git push origin branch-nameसंचालित द्वारा

व्यावहारिक उदाहरण

आइए कुछ व्यावहारिक उदाहरण देखें: रिपो क्लोन करना, और एकाधिक remotes के साथ सहयोग करना।

रिपॉज़िटरी क्लोन करना

यहाँ रिपो क्लोन करने की चरण-दर-चरण गाइड है।

1. रिपॉज़िटरी URL प्राप्त करें। उस रिपॉज़िटरी का URL कॉपी करें जिसे आप क्लोन करना चाहते हैं। यह URL आपके क्लाउड प्रदाता, जैसे GitHub या BitBucket, से उपलब्ध होता है।
2. डायरेक्टरी चुनें। अपने कंप्यूटर पर उस फ़ोल्डर में जाएँ जहाँ आप रिपो की प्रति रखना चाहते हैं।
3. रिपॉज़िटरी क्लोन करें। कमांड git clone <URL> चलाएँ। उदाहरण के लिए, git clone https://github.com/datacamp/project चलाएँ।यह “project” नाम का नया फ़ोल्डर बनाता है जिसमें रिपो की सामग्री होती है।
4. कनफ़िगर किए गए remotes सूचीबद्ध करें। क्लोन करने के बाद, कमांड git remote से remotes जाँचें।हमारे उदाहरण में, आप origin देखेंगे, जो उस रिमोट का डिफ़ॉल्ट नाम है जिससे आपने क्लोन किया, और उसका URL।

एकाधिक remotes के साथ सहयोग करना

ओपन-सोर्स प्रोजेक्ट में योगदान देते समय या व्यक्तिगत कॉपी (फोर्क) के माध्यम से सहयोग करते समय, दो remotes के साथ काम करना आम है: origin, जो आपके फोर्क का रिपो है, और upstream, जो वह रिपो है जिससे आपने फोर्क किया। आमतौर पर, आपके पास origin पर लिखने की अनुमति होती है, लेकिन upstream पर नहीं।

एकाधिक remotes का प्रबंधन करते समय ध्यान में रखने के लिए कुछ सर्वोत्तम प्रथाएँ हैं।

1. upstream रिमोट जोड़ें। अपने फोर्क को क्लोन करने के बाद, मूल रिपो को upstream के रूप में ट्रैक करें: git remote add upstream <URL>।
2. अपने फोर्क को अप-टू-डेट रखें। कमांड git fetch upstream का उपयोग करके नियमित रूप से upstream रिपो से बदलाव फ़ेच करें। फिर उन बदलावों को अपनी लोकल ब्रांच में मर्ज या रीबेस करें।
3. upstream रिपो पर पुश करने से बचें। आमतौर पर आपके पास upstream रिपो पर पुश एक्सेस नहीं होता (या आवश्यकता नहीं होती)। आपके सभी बदलाव origin पर पुश किए जाने चाहिए, और वहीं से पुल रिक्वेस्ट बनाए जाने चाहिए।
4. वर्णनात्मक ब्रांच नामों का उपयोग करें। अपनी लोकल ब्रांचेस को व्यवस्थित रखें। जिस फीचर या इश्यू पर आप काम कर रहे हैं, उसके अनुसार नाम रखना एक अच्छा विचार है।
5. अपने remotes जाँचें। git remote -v का उपयोग करके अपनी रिमोट सेटअप की समीक्षा करें और origin और upstream के URLs सही हैं, यह सत्यापित करें।
6. काम शुरू करने से पहले सिंक में रहें। नया काम शुरू करने से पहले हमेशा अपनी मुख्य ब्रांच में upstream से नवीनतम बदलाव पुल करें ताकि आप वर्तमान में बने रहें और बाद में कॉन्फ्लिक्ट से बचें।

Git Remote सर्वोत्तम प्रथाएँ और टिप्स

यहाँ कुछ सर्वोत्तम प्रथाएँ हैं जिनका आपको Git remote का उपयोग करते समय पालन करना चाहिए: 

remotes को अपडेटेड रखना

नियमित रूप से बदलाव फ़ेच करना सुनिश्चित करता है कि आपकी लोकल कॉपी रिपॉज़िटरी की रिमोट संस्करण के साथ अप-टू-डेट रहे। git fetch चलाने से आप रिमोट से नए बदलाव डाउनलोड करते हैं, बिना आपकी वर्तमान ब्रांच को प्रभावित किए। 

यह आपको साथियों द्वारा पुश की गई चीज़ों से अवगत रखता है, बदलावों की तुलना करने देता है, और आवश्यक अपडेट या मर्ज के लिए तैयार होने में मदद करता है। नियमित रूप से फ़ेच करने से कॉन्फ्लिक्ट की संभावना कम होती है और आपका सहयोग वर्कफ़्लो सुचारू रहता है।

समय के साथ, जब रिमोट रिपॉज़िटरी से ब्रांचेस हटा दी जाती हैं, तो आपकी लोकल Git सेटअप अभी भी उन पुरानी ब्रांचेस को रिमोट-ट्रैकिंग ब्रांचेस के रूप में दिखा सकती है। इन्हें “stale” रिमोट-ट्रैकिंग ब्रांचेस कहा जाता है। 

अपनी ब्रांचेस को साफ करने के लिए, git remote prune origin चलाएँ ताकि उन रिमोट-ट्रैकिंग ब्रांचेस को हटाया जा सके जो अब origin रिमोट पर मौजूद नहीं हैं। 

ऐसा नियमित रूप से करने से आपकी लोकल रिपॉज़िटरी व्यवस्थित रहती है, प्रासंगिक ब्रांचेस ढूंढना आसान होता है, और आप पुराने काम को संदर्भित नहीं करते।

remotes के साथ कॉन्फ्लिक्ट हैंडल करना

रिमोट कॉन्फ्लिक्ट्स को हल करना कठिन हो सकता है। सबसे अच्छा समाधान यह है कि एक ही समय में एक ही कोड भागों पर कई लोग काम न कर रहे हों, यह सुनिश्चित करके उन्हें रोका जाए। हालाँकि, यह हमेशा संभव नहीं होता। 

हमारी सर्वोत्तम इच्छाओं के बावजूद, कॉन्फ्लिक्ट्स हो सकते हैं और होते हैं। जब वे हों, तो उन्हें प्रभावी ढंग से संभालने के लिए इस योजना का पालन करें।

1. कौन-से कॉन्फ्लिक्ट्स आपके ध्यान की आवश्यकता रखते हैं, यह देखने के लिए git status का उपयोग करें।
2. कॉनफ़्लिक्टेड फ़ाइलें खोलें और बदलावों को हल करने के लिए उन्हें एडिट करें।
3. मर्ज टूल का उपयोग करें। VS Code या git mergetool जैसे टूल साइड-बाय-साइड तुलना दिखाते हैं और आपको यह चुनने देते हैं कि कोड का कौन-सा संस्करण रखना है।
4. टीम से संवाद करें। यदि कॉन्फ्लिक्ट स्पष्ट नहीं है, तो समस्या हल करने से पहले अपने सहयोगियों से जाँच करें। सुनिश्चित करें कि किन पंक्तियों को रखना है और किन्हें हटाना है, आप समझते हैं।
5. कॉनफ़्लिक्ट हल करने के बाद अपने कोड का परीक्षण करें ताकि कुछ भी टूटा न हो और सब कुछ अपेक्षा के अनुरूप काम करे।
6. अपने बदलाव कमिट करें। सभी कॉन्फ्लिक्ट हल करने के बाद, फ़ाइलों को स्टेज करें और मर्ज पूरा करने के लिए कमिट करें।

Rebase

git pull --rebase का उपयोग नवीनतम रिमोट कमिट्स के ऊपर आपके बदलाव लागू करके जटिल मर्ज कॉन्फ्लिक्ट्स की संभावना को कम कर सकता है।

जब आप git pull --rebase का उपयोग करते हैं, तो Git पहले रिमोट से नवीनतम बदलाव फ़ेच करता है, फिर आपके लोकल कमिट्स को ऊपर इस तरह लागू करता है मानो आपका काम बाद में हुआ हो।

यह तरीका एक साफ-सुथरा, रैखिक कमिट इतिहास बनाने में मदद करता है और गंदे मर्ज कॉन्फ्लिक्ट्स की आशंका कम कर सकता है।

हिस्ट्री को जोड़ने वाला मर्ज कमिट बनाने के बजाय, रीबेस ऐसा दिखाता है मानो आपके बदलाव रिमोट अपडेट्स के बाद किए गए हों। आप हमारे Git Rebase ट्यूटोरियल में और जान सकते हैं। 

निष्कर्ष

Git remotes सहयोगात्मक विकास के लिए अत्यावश्यक हैं, जो लोकल रिपॉज़िटरीज़ को साझा कोडबेस से जोड़ते हैं। इस गाइड में, हमने आवश्यक रिमोट ऑपरेशंस कवर किए हैं, जिनमें सेटअप करना, fetch, pull और push कमांड्स के माध्यम से सिंक्रनाइज़ करना, और एकाधिक रिमोट कनेक्शन्स का प्रबंधन शामिल है।

हमने जिन अवधारणाओं को कवर किया है, उन पर महारत हासिल करने से आप अधिक कुशलता से सहयोग कर पाएँगे, प्रोजेक्ट हिस्ट्री स्पष्ट रख पाएँगे, और अपनी डेवलपमेंट टीम में बेहतर योगदान दे पाएँगे।

git रिमोट ब्रांचेस से संबंधित अधिक जानकारी के लिए, DataCamp के संसाधन देखें।

• Git Checkout Remote Branch: चरण-दर-चरण गाइड 
• Git Push और Pull ट्यूटोरियल
• Git Pull Force: लोकल ब्रांच को रिमोट से कैसे ओवरराइट करें
• Introduction to Git Course
• Intermediate Git Course 
• Advanced Git Course
• Introduction to GitHub Concepts
• GitHub और शुरुआती लोगों के लिए Git ट्यूटोरियल
• 2025 में Git कैसे सीखें: शुरुआती लोगों के लिए संपूर्ण गाइड
• Git चीट शीट