My team currently uses a fairly simple branching/deployment process that looks like this:
┌────────┐ ┌────┐ ┌──────┐ Environments: │ DEV │ │ QA │ │ PROD │ └────────┘ └────┘ └──────┘ ▲ ▲ ▲ │ │ │ ┌────────┐ ┌────┐ ┌──────┐ Builds: │ DEV │ │ QA │ │ PROD │ └────────┘ └────┘ └──────┘ ▲ ▲ ▲ │ │ │ ┌────────┐ ┌────┐ ┌──────┐ Branches: │ master │ │ qa │ │ prod │ └────────┘ └────┘ └──────┘
Each environment has its own branch (we use git) and its own build that uses that branch. When we want to promote from one environment to another, for example, from DEV to QA, we merge the
master branch into
qa and kick off a new QA build (which is then automatically deployed to the QA environment).
We're considering moving to a new process that would do away with having a dedicated branch and build for each environment. Instead, a single release build would create a "deployment package" which could then be deployed to any environment. We're imagining a typical workflow would look something like this:
┌────────┐ ┌────┐ ┌──────┐ Environments: │ DEV │ ──► │ QA │ ──► │ PROD │ └────────┘ └────┘ └──────┘ ▲ \ ┌───────────────┐ Builds: │ release build │ └───────────────┘ ▲ │ ┌────────┐ ┌─────────┐ Branches: │ master │ │ release │ └────────┘ └─────────┘
Promoting from one environment to another would no longer be handled in source control; rather, we'd just take the already-built binaries (the "deployment package") and drop that on the new environment.
This new system would allow us to deploy any build to any environment, which has several advantages. For example, it's trivial to test PROD bug fixes in DEV and QA. Our current system doesn't provide an easy way to do this without rolling back a branch, which we'd obviously like to avoid.
The biggest drawback with this new system is that we no longer have an automatic way of tracking what code is in which environment. If we need to make a fix in PROD, we no longer have a dedicated branch in sync with the current production codebase. The same goes for QA - if we want to push a quick change to QA without dredging up in-progress work from
master, we no longer have a branch that reflects the current state of the QA environment.
How can we keep track of what code is in each environment?
Some options we're considering:
- utilizing git tags to keep track of which commit is in which environment
- embedding the git commit used by the build into each deployment package