Hands-on Demo – Trunk-Based Development for Continuous Delivery with Git branch model

Hands-on Demo – Trunk-Based Development for Continuous Delivery with Git branch model

Trunk-Based Development (TBD) is a streamlined Git branching strategy designed for rapid iteration and Continuous Delivery (CD). It emphasizes a single primary branch (main) for integration and encourages small, frequent commits to avoid long-lived branches.

Trunk-Based Development Core Principles

1. Single Long-Lived Branch:

   • The main branch is the single source of truth.

   • Always deployable.

2. Short-Lived Feature Work:

   • Developers commit directly to main or use short-lived feature branches merged quickly.

   • Encourages small, incremental changes.

3. CI/CD Pipeline:

   • Every commit triggers automated testing and validation.

   • Ensures the main branch remains stable.

Scenario: Adding a New Feature Using TBD

1. Initial Setup

1. Branches: main: The primary branch for development and deployment.

2. Tools:

   • CI/CD pipeline for automated testing and deployment.

   • Feature toggles for deploying incomplete or experimental features.

2. Workflow Steps

Step 1: Pull the Latest main

Before starting new work, pull the latest changes from the main branch:

xxxxxxxxxx
2
1
git checkout main
2
git pull origin main

Step 2: Make Changes

Option 1: Commit Directly to main

Suitable for small, low-risk changes.

Example:

xxxxxxxxxx
4
1
echo "<h1>Login Page</h1>" > login.html
2
git add login.html
3
git commit -m "Add basic login page structure"
4
git push origin main

Option 2: Use a Short-Lived Feature Branch

For slightly more complex changes, create a short-lived branch:

xxxxxxxxxx
5
1
git checkout -b add-login-page
2
echo "<h1>Login Page</h1>" > login.html
3
git add login.html
4
git commit -m "Add basic login page structure"
5
git push origin add-login-page

Merge the branch back into main quickly (after review if necessary):

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

Step 3: Automated Testing and Deployment

Every commit to main triggers the CI/CD pipeline to:

1. Run automated tests (unit, integration, end-to-end).

2. Validate code quality (e.g., linting, static analysis).

3. Deploy to staging or production environments.

Example CI/CD Pipeline with GitHub Actions:

xxxxxxxxxx
18
1
name: CI/CD Pipeline
2
on:
3
  push:
4
    branches:
5
      - main
6
jobs:
7
  test-and-deploy:
8
    runs-on: ubuntu-latest
9
    steps:
10
      - name: Checkout code
11
        uses: actions/checkout@v3
12
      - name: Install dependencies
13
        run: npm install
14
      - name: Run tests
15
        run: npm test
16
      - name: Deploy to production
17
        if: success()
18
        run: ./deploy.sh

Step 4: Use Feature Toggles for Incomplete Work

If a feature isn’t fully complete but must be merged, use a feature toggle to hide or disable the feature in production:

xxxxxxxxxx
6
1
const isFeatureEnabled = process.env.FEATURE_LOGIN === 'true';
2
if (isFeatureEnabled) {
3
  renderLoginPage();
4
} else {
5
  renderComingSoonMessage();
6
}

Set the toggle via environment variables in the CI/CD pipeline:

xxxxxxxxxx
1
1
FEATURE_LOGIN=false

This allows the code to exist in production without being user-facing.

Step 5: Maintain a Clean History

Periodically clean up by removing unused feature toggles or redundant code.

Example TBD Git Workflow

xxxxxxxxxx
17
1
# Pull the latest main branch
2
git checkout main
3
git pull origin main
4

5
# Create a short-lived branch (if necessary)
6
git checkout -b add-login-page
7

8
# 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 structure"
12

13
# Push and merge quickly
14
git push origin add-login-page
15
git checkout main
16
git merge add-login-page
17
git push origin main

Advantages of Trunk-Based Development for CD

1. Rapid Delivery:

   • Frequent commits reduce integration conflicts.

   • Encourages small, manageable changes.

2. Simplified Workflow: No long-lived branches to manage.

3. Always Deployable: Ensures the main branch is production-ready.

4. Encourages Automation: Requires robust CI/CD pipelines for testing and deployment.

Challenges

1. Discipline: Requires teams to commit small, incremental changes.

2. Strong Automation: Relies heavily on CI/CD pipelines to maintain branch quality.

3. Risk of Incomplete Features: Feature toggles must be used to hide unfinished work.