


Streamlined Release Process for a Web Application: Trunk-Based Development with Feature Flags
In this article, we will outline a robust and efficient release process for web applications, built around trunk-based development and environment-based feature flags. This methodology ensures continuous integration, easy testing in production, and a smooth path from development to release while maintaining high-quality standards.
Core Principles
-
Trunk-Based Development:
- The trunk branch serves as the single source of truth for all development work.
- Developers create feature branches (e.g., feature/xyz) from the trunk for new features or Jira tickets.
- Pull requests (PRs) are submitted from these feature branches to the trunk for review and merging after successful tests.
-
Environment-Based Feature Flags:
- Feature flags are used to control the activation of features across environments.
- Flags are stored in environment-specific configuration files or as part of the CI/CD pipeline configuration.
- In the trunk branch, all feature flags are set to OFF by default.
- Flags can be toggled ON in specific environments (e.g., sandbox, staging, or production) as needed.
JIRA Versions in Sprint
Environment Deployment Flow
-
Sandbox or Staging Environment:
- For QA and integration testing, teams can create a branch prefixed with sandbox/ (e.g., sandbox/xyz) from the trunk.
- This branch is deployed to a dedicated sandbox or staging environment using CI/CD pipelines.
- QA teams can validate new features, and integration tests can ensure compatibility.
- Feature flags are toggled ON in this environment for testing specific features.
-
Production Release Preparation:
- To prepare for a release, create a release/xyz branch from the trunk.
- The release/xyz branch serves as the release candidate and is initially deployed to 5% of production traffic for beta testing.
- Feature flags for new features are toggled ON in this branch to allow testing in production.
- Nginx or a similar load balancer can handle this traffic split, ensuring only a subset of users see the changes.
Feature Flags: Examples and Usage
-
Flag Structure:
- Store feature flags in a configuration file (e.g., config/feature-flags.json):
1
2
3
4
{
"feature_xyz"
: false,
"feature_abc"
: true
}
Copy after login
-
Use environment variables to control flags during runtime:
1
FEATURE_XYZ=true FEATURE_ABC=false npm start
Copy after login
-
Backend Example:
- Toggle flags in code:
1
2
3
4
5
6
7
const
featureFlags =
require
(
'./config/feature-flags'
);
if
(featureFlags.feature_xyz) {
console.log(
'Feature XYZ is enabled!'
);
}
else
{
console.log(
'Feature XYZ is disabled.'
);
}
Copy after login -
Frontend Example:
- Use flags to conditionally render UI components:
1
2
3
4
5
if
(process.env.REACT_APP_FEATURE_XYZ ===
'true'
) {
render(<NewFeatureComponent />);
}
else
{
render(<OldFeatureComponent />);
}
Copy after login -
Toggling Flags During Testing:
- To toggle a flag for testing, update the configuration or environment variables and restart the relevant service (frontend or backend):
1
FEATURE_XYZ=true npm start
Copy after login
- For CI/CD pipelines, ensure that the appropriate flag values are injected into the environment during deployment.
Testing in Production
-
Traffic Routing for Beta Testing:
- Use Nginx configurations to control traffic allocation:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
http {
upstream stable_backend {
server stable_backend_1;
server stable_backend_2;
}
upstream canary_backend {
server canary_backend_1;
server canary_backend_2;
}
upstream mixed_backend {
server stable_backend_1 weight=45;
server stable_backend_2 weight=45;
server canary_backend_1 weight=5;
server canary_backend_2 weight=5;
}
server {
listen 80;
server_name my-app.example.com;
location / {
if
(
$http_x_qa_test
=
"true"
) {
proxy_pass http:
//canary_backend;
break
;
}
proxy_pass http:
//mixed_backend;
}
}
}
Copy after login
- Route 5% of production traffic to servers running the new version by adjusting load balancer weights.
-
Dedicated QA Testing in Production:
- QA teams can attach a custom cookie (e.g., qa-test=true) to their requests.
- Nginx checks this cookie and routes these requests to the new version 100% of the time, ensuring targeted testing in production.
Stabilizing the Release
-
Fixing Issues:
- Developers fix any issues identified during beta testing by opening PRs to the trunk branch.
- Once merged, these fixes are cherry-picked into the release/xyz branch.
-
Finalizing the Release:
- After all issues are resolved and the branch is stable, the release branch is tagged with a semantic version (e.g., v1.2.0), triggering deployment to the stable backend.
- Release notes are generated for documentation and shared with stakeholders.
Hotfix Process
-
Creating Hotfix Branches:
- For urgent fixes, create a hotfix/xyz branch directly from the latest production tag.
- Hotfix branches follow the same stabilization and tagging process as release branches.
-
Versioning:
- Hotfixes increment the patch version (e.g., from v1.2.0 to v1.2.1) following Semantic Versioning (SemVer) standards.
Branch Cleanup
- Routinely delete merged branches to avoid clutter.
- Periodically remove unused feature flags to maintain organization.
- Automate branch deletion post-merge using GitHub Actions or similar tools.
Alternative QA and Testing Strategies
Instead of cookies, additional strategies for routing QA traffic in production include:
-
Header-Based Routing:
- QA adds a custom header (e.g., X-QA-Test: true) to their requests.
- Nginx routes these requests to the new version for testing.
-
IP-Based Routing:
- Restrict traffic to the new version based on QA’s IP addresses.
-
Authentication Token-Based Routing:
- QA logs in with a specific test account tied to a role or token that ensures requests are routed to the new version.
Conclusion
This release process leverages trunk-based development and environment-based feature flags to create a scalable, testable, and production-safe deployment workflow. By using sandbox environments, traffic routing, and dedicated testing strategies, teams can deliver high-quality features while minimizing risk. The approach ensures that issues are caught early and addressed efficiently, paving the way for seamless feature rollouts and hotfixes.
The above is the detailed content of Streamlined Release Process for a Web Application: Trunk-Based Development with Feature Flags. For more information, please follow other related articles on the PHP Chinese website!

Hot AI Tools

Undresser.AI Undress
AI-powered app for creating realistic nude photos

AI Clothes Remover
Online AI tool for removing clothes from photos.

Undress AI Tool
Undress images for free

Clothoff.io
AI clothes remover

Video Face Swap
Swap faces in any video effortlessly with our completely free AI face swap tool!

Hot Article

Hot Tools

Notepad++7.3.1
Easy-to-use and free code editor

SublimeText3 Chinese version
Chinese version, very easy to use

Zend Studio 13.0.1
Powerful PHP integrated development environment

Dreamweaver CS6
Visual web development tools

SublimeText3 Mac version
God-level code editing software (SublimeText3)

Hot Topics

Frequently Asked Questions and Solutions for Front-end Thermal Paper Ticket Printing In Front-end Development, Ticket Printing is a common requirement. However, many developers are implementing...

JavaScript is the cornerstone of modern web development, and its main functions include event-driven programming, dynamic content generation and asynchronous programming. 1) Event-driven programming allows web pages to change dynamically according to user operations. 2) Dynamic content generation allows page content to be adjusted according to conditions. 3) Asynchronous programming ensures that the user interface is not blocked. JavaScript is widely used in web interaction, single-page application and server-side development, greatly improving the flexibility of user experience and cross-platform development.

There is no absolute salary for Python and JavaScript developers, depending on skills and industry needs. 1. Python may be paid more in data science and machine learning. 2. JavaScript has great demand in front-end and full-stack development, and its salary is also considerable. 3. Influencing factors include experience, geographical location, company size and specific skills.

Learning JavaScript is not difficult, but it is challenging. 1) Understand basic concepts such as variables, data types, functions, etc. 2) Master asynchronous programming and implement it through event loops. 3) Use DOM operations and Promise to handle asynchronous requests. 4) Avoid common mistakes and use debugging techniques. 5) Optimize performance and follow best practices.

Discussion on the realization of parallax scrolling and element animation effects in this article will explore how to achieve similar to Shiseido official website (https://www.shiseido.co.jp/sb/wonderland/)...

How to merge array elements with the same ID into one object in JavaScript? When processing data, we often encounter the need to have the same ID...

The latest trends in JavaScript include the rise of TypeScript, the popularity of modern frameworks and libraries, and the application of WebAssembly. Future prospects cover more powerful type systems, the development of server-side JavaScript, the expansion of artificial intelligence and machine learning, and the potential of IoT and edge computing.

In-depth discussion of the root causes of the difference in console.log output. This article will analyze the differences in the output results of console.log function in a piece of code and explain the reasons behind it. �...
