GitFlow ट्यूटोरियल: फीचर्स, रिलीज़ और हॉटफ़िक्स के लिए ब्रांचिंग

GitFlow सेटअप करना

GitFlow के संरचित ब्रांचिंग मॉडल का लाभ उठाने से पहले, आपको इसे अपनी मशीन पर इंस्टॉल करना होगा और अपनी रिपॉजिटरी में इनिशियलाइज़ करना होगा। शुक्र है, दोनों चरण सीधे-सादे हैं।

GitFlow का उपयोग करने के लिए, आपकी मशीन पर पहले से Git इंस्टॉल होना चाहिए। Git इंस्टॉल करने के बारे में और पढ़ें Git Install Tutorial में।

GitFlow इंस्टॉल करना

GitFlow, Git का एक एक्सटेंशन है, इसलिए आपको इसे अलग से इंस्टॉल करना होगा। डिफ़ॉल्ट रूप से यह Git के साथ बंडल नहीं आता। इंस्टॉलेशन प्रक्रिया आपके ऑपरेटिंग सिस्टम पर निर्भर करती है।

GitFlow कैसे इंस्टॉल करें, इस पर विस्तृत निर्देशों के लिए आधिकारिक दस्तावेज़ पढ़ें।

नोट: ऊपर दिया गया GitFlow एक्सटेंशन सरल कमांड्स के साथ फीचर ब्रांच, रिलीज़ और हॉटफ़िक्स मैनेज करना आसान बनाता है, लेकिन यह अनिवार्य नहीं है। आप मानक Git कमांड्स का उपयोग करके GitFlow वर्कफ़्लो का पालन कर सकते हैं—जब तक आप नामकरण और मर्जिंग प्रैक्टिस के साथ सुसंगत हैं। यह टूल बस प्रक्रिया को ऑटोमेट और लागू करता है, जो टीमों या बड़े प्रोजेक्ट्स के लिए सहायक हो सकता है।

macOS

यदि आप Homebrew का उपयोग कर रहे हैं, जो macOS के लिए सबसे लोकप्रिय पैकेज मैनेजर है, तो चलाएँ:

brew install git-flow-avhसंचालित द्वारा

Linux (Debian/Ubuntu-आधारित)

यदि आप Ubuntu जैसे Debian-आधारित सिस्टम पर हैं, तो इस्तेमाल करें:

sudo apt-get install git-flowसंचालित द्वारा

Windows

यदि आप Windows पर हैं, तो आप Git for Windows के माध्यम से GitFlow इंस्टॉल कर सकते हैं और अपने टर्मिनल में Git Bash जोड़ सकते हैं।

यह जाँचना हो कि GitFlow इंस्टॉल है या नहीं, आप चला सकते हैं:

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

किसी रिपॉजिटरी में GitFlow इनिशियलाइज़ करना

पहले कदम के रूप में, GitFlow इस्तेमाल करने से पहले आपके पास एक इनिशियलाइज़्ड Git रिपॉजिटरी होनी चाहिए। और पढ़ें How to Initialize and Set Up a Git Repository में।

GitFlow इंस्टॉल होने के बाद, आप इसे किसी भी मौजूदा Git रिपॉजिटरी में इस कमांड से इनिशियलाइज़ कर सकते हैं:

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

GitFlow आपको कई सेटिंग्स कॉन्फ़िगर करने के लिए प्रेरित करेगा। यहाँ उनका अर्थ और सही विकल्प चुनने का तरीका दिया है:

1. ब्रांच के नाम: आपसे डिफ़ॉल्ट ब्रांच नाम पूछे जाएँगे।
1. प्रोडक्शन ब्रांच का नाम (डिफ़ॉल्ट: master)
2. डेवलपमेंट ब्रांच का नाम (डिफ़ॉल्ट develop)
2. सपोर्टिंग ब्रांच के प्रीफ़िक्स: GitFlow अपनी अलग-अलग ब्रांच टाइप्स के लिए नामकरण मानक उपयोग करता है।
1. फ़ीचर ब्रांच: feature/
2. बगफिक्स ब्रांच: bugfix/
3. रिलीज़ ब्रांच: release/
4. हॉटफ़िक्स ब्रांच: hotfix/
5. सपोर्ट ब्रांच: support/ (व्यवहार में शायद ही कभी उपयोग)
6. वर्ज़न टैग प्रीफ़िक्स: v (उदा. v.1.2.0)

डिफ़ॉल्ट सेटिंग्स अधिकतर टीमों के लिए अच्छी तरह काम करती हैं, पर आप अपनी संस्था के नामकरण मानकों के अनुसार उन्हें कस्टमाइज़ कर सकते हैं।

इनिशियलाइज़ेशन का उदाहरण आउटपुट:

git flow init

Which branch should be used for bringing forth production releases?
   - master
Branch name for production releases: [master]
Branch name for "next release" development: [develop]

How to name your supporting branch prefixes?
Feature branches? [feature/]
Bugfix branches? [bugfix/]
Release branches? [release/]
Hotfix branches? [hotfix/]
Support branches? [support/]
Version tag prefix? [] vसंचालित द्वारा

इनिशियलाइज़ करने के बाद, आप develop ब्रांच को अपनी रिमोट रिपॉजिटरी पर पुश कर सकते हैं। ब्रांचेस को पुश और पुल करने के बारे में अधिक पढ़ें Git Push and Pull Tutorial में।

डेवलपमेंट के लिए GitFlow का उपयोग

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

अगले उप-अध्यायों में, हम व्यवहार में GitFlow को समझेंगे।

फ़ीचर ब्रांच बनाना

फ़ीचर ब्रांच मुख्य कोडबेस को प्रभावित किए बिना नई कार्यक्षमता विकसित करने के लिए उपयोग होती हैं।

आप यह कमांड चलाकर एक फ़ीचर ब्रांच बना सकते हैं:

git flow feature start <feature-name>संचालित द्वारा

यह कमांड develop से एक नई ब्रांच feature/<feature-name> बनाती है। आप अपना फीचर विकसित करना शुरू कर सकते हैं और सामान्य रूप से कमिट कर सकते हैं।

फ़ीचर ब्रांच समाप्त करना

जब आपका फीचर पूरा और टेस्ट हो जाए, तो आप इसे इस तरह समाप्त कर सकते हैं: 

git flow feature finish <feature-name>संचालित द्वारा

यह निम्नलिखित करता है:

• आपकी फीचर ब्रांच को develop ब्रांच में मर्ज करता है।
• लोकल feature/<feature-name> ब्रांच को डिलीट करता है।

यदि आपको मर्ज कॉन्फ्लिक्ट मिलें, तो उन्हें मैन्युअली हल करें और Git के मानक कॉन्फ्लिक्ट रेज़ोल्यूशन फ़्लो का उपयोग करके मर्ज पूरा करें।

यदि आप बड़ी टीमों में काम करते हैं जहाँ पहले पुल रिक्वेस्ट बनाकर रिव्यू करना आवश्यक है, तो आप सीधे GitFlow का finish कमांड उपयोग नहीं कर सकते, बल्कि इसके बजाय आप यह कर सकते हैं:

1. अपना काम कमिट करें, फिर ब्रांच पुश करें:

git push origin feature/<feature-name>संचालित द्वारा

2. GitHub, GitLab आदि पर feature/<feature-name> से develop में एक पुल रिक्वेस्ट बनाएं।
3. रिव्यू का अनुरोध करें, टेस्ट चलाएँ, और अनुमोदन प्राप्त करें।
4. स्वीकृत होने पर, प्लेटफ़ॉर्म के UI से मर्ज करें और ब्रांच डिलीट करें।

यदि आप GitHub और उसके उपयोग के बारे में और सीखना चाहते हैं, तो मैं GitHub Foundations और GitHub Concepts कोर्स की सिफारिश करता हूँ। अन्य टीमों में, आप मानक git flow feature finish फ्लो का पालन कर सकते हैं, लेकिन develop में वापस मर्ज करने से पहले अपनी ब्रांच के लिए रिव्यू मांगना और कोड परिवर्तनों पर टेस्ट चलाना आवश्यक होगा ताकि सही व्यवहार सुनिश्चित हो सके।

रिलीज़ ब्रांच बनाना

रिलीज़ ब्रांच, develop ब्रांच पर चल रहे डेवलपमेंट को ब्लॉक किए बिना नई प्रोडक्शन वर्ज़न की तैयारी के लिए बनाई जाती हैं।

रिलीज़ शुरू करने के लिए, यह चलाएँ:

git flow release start <version-number>संचालित द्वारा

यह release/<version-number> नाम की नई ब्रांच बनाता है। यह ब्रांच develop से निकाली जाती है।

इस ब्रांच में, आप आमतौर पर वर्ज़न नंबर फाइनलाइज करते हैं, छोटे बग्स ठीक करते हैं, और डॉक्यूमेंटेशन व चेंजलॉग अपडेट करते हैं।

रिलीज़ ब्रांच समाप्त करना

जब आपकी रिलीज़ प्रोडक्शन के लिए तैयार हो जाए, तो इसे इस तरह समाप्त करें:

git flow release finish <version-number>संचालित द्वारा

यह कमांड:

• रिलीज़ ब्रांच को master और develop दोनों में मर्ज करता है।
• master पर रिलीज़ को टैग करता है (जैसे, v1.0.0)।
• लोकल release/<release-number> ब्रांच को डिलीट करता है।

अपनी चेंजिस और टैग्स पुश करना न भूलें:

git push origin master
git push origin develop
git push --tags

# or in short
git push origin master develop --tagsसंचालित द्वारा

हॉटफ़िक्स ब्रांच बनाना

हॉटफ़िक्स, master ब्रांच में बग मिलने पर तात्कालिक प्रोडक्शन फिक्स के लिए उपयोग होते हैं।

हॉटफ़िक्स शुरू करने के लिए:

git flow hotfix start <version-number>संचालित द्वारा

यह master से एक hotfix/<version-number> ब्रांच बनाता है। अब आप बदलाव लागू कर सकते हैं और फिक्स को कमिट कर सकते हैं।

काम पूरा होने पर, इसे इस तरह समाप्त करें:

git flow hotfix finish <version-number>संचालित द्वारा

यह:

• हॉटफ़िक्स को master और develop में मर्ज करता है।
• master पर फिक्स को टैग करता है।
• लोकल `hotfix/<version-number> ब्रांच को डिलीट करता है।

अपनी लोकल चेंजिस और टैग्स सामान्य रूप से पुश करें:

git push origin master develop --tagsसंचालित द्वारा

हॉटफ़िक्स विशेष रूप से शक्तिशाली हैं क्योंकि वे आपको develop ब्रांच पर चल रहे डेवलपमेंट में दखल दिए बिना प्रोडक्शन समस्याओं को जल्दी से ठीक करने देते हैं।

कल्पना करें कि कुछ नई फीचर्स पहले से ही develop में मर्ज हो चुकी हैं जिन्हें आप अभी रिलीज़ नहीं करना चाहते, लेकिन प्रोडक्शन एप्लिकेशन में एक गंभीर और तात्कालिक बग को ठीक करना जरूरी है। 

यहीं हॉटफ़िक्स काम आते हैं, क्योंकि वे master से ब्रांच होकर केवल develop में वापस मर्ज होते हैं।

GitFlow ब्रांचिंग उदाहरण

आइए दो आम वर्कफ़्लो—एक फीचर डेवलपमेंट साइकिल और एक हॉटफ़िक्स के साथ रिलीज़—से GitFlow को एक्शन में देखते हैं और पारंपरिक Git कमांड्स से तुलना करते हैं।

दोनों पक्ष देखने से, आप बेहतर समझेंगे कि GitFlow एक्सटेंशन कैसे कई Git चरणों को सरल, मानकीकृत कमांड्स में समेटकर प्रक्रिया को आसान बनाता है।

यदि आपको पारंपरिक Git कमांड्स का त्वरित सार चाहिए, तो Complete Git Cheat Sheet देखें। यदि आप Git का त्वरित अवलोकन चाहते हैं, तो GitHub and Git Tutorial for Beginners पढ़ने की सिफारिश करता हूँ।

फ़ीचर डेवलपमेंट वर्कफ़्लो

मान लें आप एक नया फीचर इम्प्लीमेंट कर रहे हैं जो उपयोगकर्ताओं को आपकी एप्लिकेशन में प्रमाणित होने देता है। आप इस फीचर को user-authentication कहते हैं।

GitFlow का उपयोग करते हुए:

git flow feature start user-authentication

# Work on the feature
git add .
git commit -m "feat: Implement basic user authentication"

# Once finished:
git flow feature finish user-authentication

git push origin developसंचालित द्वारा

अब साधारण Git का उपयोग करते हुए:

# Create and switch to a new branch manually
git checkout -b feature/user-authentication develop

# Work on the feature
git add .
git commit -m "Implement basic user authentication"

# Once finished
git checkout develop
git merge feature/user-authentication
git branch -d feature/user-authentication
git push origin developसंचालित द्वारा

जैसा कि आप देख सकते हैं, GitFlow कमांड्स की संख्या और इस प्रकार जटिलता को कम करता है। यह कम त्रुटिप्रवण भी है—जैसे गलती से गलत ब्रांच में मर्ज कर देना।

Git में मर्जिंग कैसे काम करती है, इसके बारे में और जानने के लिए Git Merge Tutorial: A Comprehensive Guide with Examples पढ़ें।

अब मान लें कि आप रिलीज़ 1.0.0 की तैयारी कर रहे हैं। लेकिन नई वर्ज़न रिलीज़ करने के कुछ समय बाद एक क्रिटिकल बग मिला जिसे हॉटफ़िक्स से ठीक करना जरूरी है। 

GitFlow का उपयोग करते हुए:

# Start a release
git flow release start 1.0.0

# Make final tweaks, update version numbers
git commit -am "Prepare release v1.0.0"

# Finish the release
git flow release finish 1.0.0
git push origin master develop --tagsसंचालित द्वारा

अब आपने बग खोज लिया है, और आपको एक हॉटफ़िक्स बनाना है:

# Start a hotfix
git flow hotfix start 1.0.1

# Apply the fix
git commit -am "Fix login issue in production"

# Finish the hotfix
git flow hotfix finish 1.0.1
git push origin master develop --tagsसंचालित द्वारा

और यह सब फिर से साधारण Git कमांड्स के साथ:

# Release manually
git checkout -b release/1.0.0 develop

# Make changes
git commit -am "Prepare release v1.0.0"

# Merge manually
git checkout master
git merge release/1.0.0
git tag -a v1.0.0 -m "Release v1.0.0"
git checkout develop
git merge release/1.0.0

# Delete release branch
git branch -d release/1.0.0
git push origin master develop --tags

# Hotfix manually
git checkout -b hotfix/1.0.1 master

# Apply fix
git commit -am "Fix login issue in production"
git checkout master
git merge hotfix/1.0.1
git tag -a v1.0.1 -m "Hotfix v1.0.1"
git checkout develop
git merge hotfix/1.0.1

# Delete hotfix branch
git branch -d hotfix/1.0.1
git push origin master develop --tagsसंचालित द्वारा

GitFlow का उपयोग करने के सर्वोत्तम तरीके

GitFlow काफी शक्तिशाली है और आपकी टीम के कोड को मैनेज करने में मदद करता है। फिर भी, इस संरचना का अधिकतम लाभ उठाने के लिए कुछ सर्वोत्तम प्रथाओं का पालन करना चाहिए।

ये प्रथाएँ ब्रांचेज़ को साफ रखने, मर्ज कॉन्फ्लिक्ट्स घटाने, और टीम की उत्पादकता बढ़ाने में मदद करती हैं—खासकर सहयोगी वातावरण में।

सुसंगत ब्रांच नामकरण

सहयोग में सुसंगतता सबसे ज़रूरी है। जब तक आपकी टीम के पास कस्टमाइज़ करने का ठोस कारण न हो, GitFlow के डिफ़ॉल्ट नामकरण मानकों का पालन करें।

सिफारिश किए गए नामकरण पैटर्न:

• फ़ीचर ब्रांच: feature/<feature-name>
• रिलीज़ ब्रांच: release/<version-number>
• हॉटफ़िक्स ब्रांच: hotfix/<version-number>

मल्टी-वर्ड नामों के लिए kebab-case उपयोग करें (उदा., feature/user-authentication)।

छोटे, बार-बार वाले बदलाव

लंबे समय तक चलने वाली ब्रांचेज़ अक्सर दर्दनाक मर्ज और विशाल पुल रिक्वेस्ट्स का कारण बनती हैं, जिनकी समीक्षा करना कठिन होता है। 

मुझे पता है मैं किस बारे में बोल रहा हूँ—मैं कई बार मर्ज कॉन्फ्लिक्ट के नरक से गुज़रा हूँ, और आप इसे यथासंभव टालना चाहेंगे!

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

छोटे, क्रमिक बदलावों का टेस्ट, रिव्यू और इंटीग्रेशन आसान होता है।

develop के साथ नियमित सिंक

फ़ीचर ब्रांच पर काम करते समय, पीछे नहीं रहना चाहिए। बाद में मर्ज कॉन्फ्लिक्ट्स को कम करने के लिए सुनिश्चित करें कि आप नियमित रूप से develop ब्रांच से नवीनतम बदलाव पुल करें:

git checkout feature/<your-feature>
git fetch origin
git rebase origin/developसंचालित द्वारा

सिंक में रहना इंटीग्रेशन को सुगम बनाता है और आपकी चेंजिस को दूसरों द्वारा बनाए जा रहे फीचर्स के साथ संगत रखता है।

मर्ज से पहले समीक्षा और परीक्षण

भले ही GitFlow git flow feature finish जैसे कमांड्स के साथ डायरेक्ट मर्जिंग को सपोर्ट करता है, फिर भी develop और master में सभी मर्ज के लिए पुल रिक्वेस्ट (PR) या मर्ज रिक्वेस्ट (MR) का उपयोग करना बेहतर है।

लाभ:

• कोड समीक्षा और अनुमोदन वर्कफ़्लो सक्षम होते हैं
• स्वचालित CI/CD जाँच शुरू होती हैं
• बदलावों का स्पष्ट ऑडिट ट्रेल मिलता है

यह खासकर प्रोडक्शन-स्तरीय वातावरण में महत्वपूर्ण है जहाँ क्वालिटी कंट्रोल मायने रखता है।

GitFlow ट्रबलशूटिंग

GitFlow जैसा संरचित वर्कफ़्लो होने पर भी समस्याएँ आ सकती हैं—खासकर टीमों में या लंबी चलने वाली ब्रांचेज़ पर काम करते समय। 

यह सेक्शन सबसे आम चुनौतियों और उन्हें प्रभावी ढंग से हल करने के तरीकों को कवर करेगा।

मर्ज कॉन्फ्लिक्ट्स

एक बड़े टीम के साथ एक ही कोडबेस पर काम करते समय मर्ज कॉन्फ्लिक्ट आम और खीझ पैदा करने वाले होते हैं।आमतौर पर ये तब होते हैं जब दो ब्रांचों ने एक ही लाइनों में बदलाव किया हो।

मर्ज कॉन्फ्लिक्ट हल करने के चरण:

1. git flow finish प्रक्रिया रोकें।
2. ब्रांच को उसके लक्ष्य में मैन्युअली मर्ज करें:

git checkout develop
git merge feature/<your-feature>संचालित द्वारा

3. Git आपको कॉन्फ्लिक्ट्स हल करने के लिए कहेगा। कॉन्फ्लिक्टिंग फाइलें खोलें और ऐसे मार्कर्स ढूँढें:

<<<<<<< HEAD
Code from develop
=======
Code from feature branch
>>>>>>> feature/my-featureसंचालित द्वारा

4. कोड को मैन्युअली एडिट करके साफ करें।
5. हल होने के बाद, फाइलों को resolved के रूप में मार्क करें:

git add <resolved-file>संचालित द्वारा

6. फिर मर्ज को इस तरह पूरा करें:

git commit -m “resolve merge conflict …”संचालित द्वारा

स्टेल ब्रांचेज़ की सफाई

कभी-कभी आपकी रिपॉजिटरी में आउटडेटेड feature, release या hotfix ब्रांचेज़ रह जाती हैं। भ्रम से बचने के लिए, अपनी रिपॉजिटरी को यथासंभव साफ रखें।

आप नीचे दिए चरणों का पालन करके इसे ठीक कर सकते हैं:

1. सभी लोकल ब्रांचेज़ सूचीबद्ध करें:

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

2. किसी लोकल ब्रांच को डिलीट करें:

git branch -d <branch-name>संचालित द्वारा

3. यदि ब्रांच अभी तक मर्ज नहीं हुई है और आप सुनिश्चित हैं कि इसे डिलीट किया जा सकता है:

git branch -D <branch-name>संचालित द्वारा

4. किसी रिमोट ब्रांच को डिलीट करें:

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

अपनी रिपॉजिटरी को साफ रखने के लिए ब्रांचेज़ को नियमित रूप से जाँचें और स्टेल ब्रांचेज़ को हटाएँ—यह अत्यंत आवश्यक है।

निष्कर्ष

GitFlow आपके डेवलपमेंट वर्कफ़्लो में सहयोग, स्पष्टता और नियंत्रण के लिए एक मजबूत ढाँचा है। चाहे आप किसी ऐसे सोलो प्रोजेक्ट पर काम कर रहे हों जिसमें अधिक लोग शामिल हों या किसी बड़ी टीम में योगदान दे रहे हों, GitFlow फीचर डेवलपमेंट, रिलीज़ और हॉटफ़िक्स को स्पष्ट रूप से अलग करके आपको संगठित रहने में मदद करता है।

जब मैंने पहली बार GitFlow इस्तेमाल किया, तो यह गेम-चेंजर लगा। अब मर्ज की अराजकता नहीं। अब यह अनुमान नहीं लगाना पड़ता कि किस ब्रांच का उपयोग करें। हर काम का अपना स्थान था, और हर रिलीज़ एक दोहराने योग्य, विश्वसनीय प्रक्रिया का पालन करती थी। समय के साथ, मैंने जिन भी टीमों के साथ काम किया, वहाँ GitFlow को लागू किया। और हर बार, इससे अधिक संरचना, सुचारू सहयोग, और कम गलतियाँ हुईं।

इस ट्यूटोरियल में, आपने सीखा:

• GitFlow क्या है और यह क्यों सहायक है
• GitFlow कैसे इंस्टॉल और इनिशियलाइज़ करें
• फ़ीचर्स, रिलीज़ और हॉटफ़िक्स के साथ कैसे काम करें
• आम समस्याओं से बचने के सर्वोत्तम तरीके
• पुल रिक्वेस्ट्स का उपयोग करके आधुनिक वर्कफ़्लो में GitFlow को कैसे अपनाएँ

यदि आप अपने Git वर्कफ़्लो को अगले स्तर पर ले जाने के लिए तैयार हैं, तो अपने अगले प्रोजेक्ट में GitFlow का उपयोग आज़माएँ। और यदि आप पहले से मूल बातें जानते हैं, तो इसे अपनी टीम की CI/CD पाइपलाइन, रिव्यू प्रक्रिया या GitHub Actions के साथ एकीकृत करने पर विचार करना शुरू करें।