Hand-on Demo – GitHub Flow for Continuous Delivery

Hand-on Demo – GitHub Flow for Continuous Delivery

The GitHub Flow branching model is simple and effective for teams practicing Continuous Delivery (CD). It is lightweight and encourages fast iteration, focusing on short-lived feature branches and automated deployment from the main branch.

GitHub Flow Core Principles

1. 'main' Branch:

   • The deployable branch.

   • Code merged into main is ready for production.

2. Short-Lived Feature Branches:

   • Used for developing new features or fixing bugs.

   • Merged into main via pull requests (PRs).

3. Automated CI/CD Pipeline:

   • Every commit triggers automated tests.

   • main branch deploys automatically to production.

Scenario: Adding a New Feature to a Web Application

1. Initial Setup

1. Branches:

   • main: The production-ready branch.

   • feature/add-login-page: A temporary feature branch.

2. Tools:

   • Git for version control.

   • CI/CD pipeline (e.g., GitHub Actions, Jenkins).

   • Automated tests to validate changes.

2. Workflow Steps

Step 1: Create a Feature Branch

The developer creates a new branch from main for the feature:

xxxxxxxxxx
2
1
git checkout main
2
git checkout -b feature/add-login-page

Step 2: Implement Changes

Develop the feature and commit changes incrementally:

xxxxxxxxxx
9
1
# Example change: Create a login page
2
echo "<h1>Login Page</h1>" > login.html
3
git add login.html
4
git commit -m "Add login page structure"
5

6
# Add form validation
7
echo "Add form validation" >> login.html
8
git add login.html
9
git commit -m "Implement form validation"

Step 3: Push and Open a Pull Request

Push the feature branch to the remote repository and open a pull request:

xxxxxxxxxx
1
1
git push origin feature/add-login-page

CI pipelines are triggered to:

• Run automated tests.

• Check for code quality issues (e.g., linting).

Step 4: Code Review and Merge

Once the pull request is approved and tests pass:

1. Merge the feature branch into main:

   xxxxxxxxxx
   3
   1
   git checkout main
   2
   git merge feature/add-login-page
   3
   git push origin main
   

2. Alternatively, perform a squash and merge via the GitHub UI to keep a cleaner history.

Step 5: Automated Deployment

The CI/CD pipeline automatically deploys the updated main branch to production:

Example with GitHub Actions:

xxxxxxxxxx
25
1
name: CI/CD Pipeline
2
on:
3
  push:
4
    branches:
5
      - main
6
jobs:
7
  build-and-deploy:
8
    runs-on: ubuntu-latest
9
    steps:
10
      - name: Checkout code
11
        uses: actions/checkout@v3
12
      - name: Set up Node.js
13
        uses: actions/setup-node@v3
14
        with:
15
          node-version: 16
16
      - name: Install dependencies
17
        run: npm install
18
      - name: Run tests
19
        run: npm test
20
      - name: Deploy to production
21
        env:
22
          DEPLOY_KEY: ${{ secrets.DEPLOY_KEY }}
23
        run: |
24
          echo "Deploying to production..."
25
          ./deploy.sh

Step 6: Clean Up the Feature Branch

Delete the feature branch after merging:

xxxxxxxxxx
2
1
git branch -d feature/add-login-page
2
git push origin --delete feature/add-login-page

Git Commands Summary

xxxxxxxxxx
23
1
# Clone the repository
2
git clone https://github.com/your-repo.git
3
cd your-repo
4

5
# Step 1: Create a feature branch
6
git checkout -b feature/add-login-page
7

8
# Step 2: Make changes and commit
9
echo "<h1>Login Page</h1>" > login.html
10
git add login.html
11
git commit -m "Add basic login page"
12

13
# Step 3: Push the branch and open a pull request
14
git push origin feature/add-login-page
15

16
# Step 4: Merge into main after review
17
git checkout main
18
git merge feature/add-login-page
19
git push origin main
20

21
# Step 5: Clean up the branch
22
git branch -d feature/add-login-page
23
git push origin --delete feature/add-login-page

Advantages of GitHub Flow for Continuous Delivery

1. Simplicity: Fewer branches and less overhead.

2. Rapid Iteration: Short-lived feature branches enable faster delivery.

3. Always Deployable: The main branch is always production-ready.

4. Built-in CI/CD: Fully automated testing and deployment pipelines.

Challenges

• Limited support for long-term development or multiple versions.

• Requires a robust CI/CD pipeline to maintain main branch quality.