Version control systems are valuable tools for tracking and managing changes to software projects. They record every modification to software code and store the complete project history in a database, enabling developers to collaborate, experiment with new features, and roll back changes when necessary. Git is the most widely used version control system today. When paired with a continuous integration and delivery (CI/CD) pipeline, Git allows development teams to rapidly iterate and deliver new features while keeping software stable and deployable.
Git tags and branches are two key Git concepts that allow developers to work on different versions of a project simultaneously. Both play an important role in organizing development work so that changes are easier to track and manage, but they serve different purposes in the development process. Tags are used as markers for significant points in the project timeline, whereas branches are separate lines of development that will eventually be merged back into the main application code.
In this article, you’ll learn the differences and similarities between Git tags and branch development more organized and efficient.
What is a Git tag?
A tag is an object referencing a specific commit within the project history, similar to chapter markers in a book. You can create tags to point to a new version release, a significant codebase change, or any other event development teams may want to reference. Many development teams use semantic versioning to communicate the types of changes that occur between one tag and another.
Once a tag has been created, it cannot be modified with any further commits, but you can reference it easily via the tag name. This allows you to switch to the tagged version of the codebase to see what the code looked like when the tag was created and, if necessary, revert to that specific codebase version.
Working with the git tag command
git tag command allows you to create, list, delete, and verify tags. Let’s look at an example of how you can use the
git tag command to specify a new version of your application code.
First, create a new tag called
v1.0.0 for the latest commit in your repository. Run the following command:
git tag v1.0.0
List all the tags in your repository by running the following command:
git tag command can also verify a specific tag. The following command verifies the
v1.0 tag and displays the details, including the tagger, date, and message.
git tag -v v1.0.0
git tag command can delete tags. To delete the
v1.0 tag, run the following command:
git tag -d v1.0.0
Deleting a tag does not affect the code in your repository — it just removes the tag label.
What is a Git branch?
A branch is an independent development line containing a pointer — or the branch head — to the most recent commit in the code.
A single Git repository can track many branches, but your working tree centers on just one. The head points to the tip or latest commit of a branch.
A branch is automatically generated when you create a repository for your code. This default branch is known as the main. Writing code and committing your work automatically records a commit in the working branch.
Working with the git branch command
git branch command lets you create, list, rename, and delete branches. You cannot use it to switch between branches.
Here is an example of how to use
First, create a new branch called
dev by running the following command:
git branch dev
Next, switch to the development branch by running the following command:
git switch dev
Now, make changes to your code and commit them to the dev branch using the usual
git add and
git commit commands.
To merge your changes in the dev branch into the main branch, run the following command:
git merge dev
git branch command will display a list of all the branches in your repository, with an asterisk next to the branch you are currently on:
You can also use the
git branch command to rename a branch. To rename the dev branch to development, run the following command:
git branch -m dev development
git branch command can delete a branch. To delete the development branch, run the following command:
git branch -d development
You cannot delete a branch you are currently on. You must switch to a different branch first.
Differences between Git tags and branches
Tags and branches are both used for version control within your code base. They do not compete with each other but are instead used together.
A branch is often used for new features and fixing bugs. It allows you to work without impacting the main codebase. Once your work is complete, you can incorporate your changes into the application by merging the branch back into the main codebase. This allows multiple people to work on different aspects of the project simultaneously. It also provides a way to experiment with new ideas without risking the main codebase’s stability.
Unlike branches, tags are not intended for ongoing development. Tags mark a specific point in the repository’s history to give developers an easy way to reference important milestones in the development timeline.
When to use branches
Imagine that you want to add a new feature to a software project’s codebase. However, you are unsure if the new feature will work as expected and want to experiment without affecting the main codebase.
In this scenario, use a Git branch to create a separate line of development for the new feature. This avoids affecting the main codebase. Once the feature is complete and tested, you can merge the branch back into the main codebase. Depending on your organization’s process, you may choose to delete the branch to prevent clutter.
When to use tags
Now, suppose that you complete and test the new feature. You want to release the new software version to the users. In this case, use a Git tag to mark the current state of the codebase as a new version release.
You can name the tag to reflect the version number (such as
v1.2.3) and include a brief description of the changes in the release. This allows you to easily reference the specific version of the released codebase. It is also easy to roll back to the previous version if necessary.
Using Git tags and branches in a CI/CD pipeline
Tags and branches are important tools for keeping the development process organized and efficient. Not only do they make it easier for development teams to manually coordinate and review their progress, but they can also help automate, orchestrate, and monitor development processes in a continuous integration and delivery (CI/CD) pipeline.
For example, a CI/CD tool like CircleCI can automatically build and test the code in a new feature branch to ensure it is ready for integration into the main codebase. This ensures that the production branch remains stable and developers can add new features quickly and safely without breaking existing functionality.
Every CI/CD pipeline is different. There are several branching strategies you can use during development, including:
- The Git flow model, which uses two main branches (develop and main) and several supporting branches for different stages of development.
- The feature branch model, which uses a separate branch for each new feature being developed.
- The trunk-based model, which uses a single main branch for all development. It uses temporary branches for small, frequent code check-ins into the main branch.
The best strategy for your project depends on your team’s specific needs and goals. However, the most effective DevOps teams prioritize making smaller, more frequent changes directly to the main line to achieve faster feedback loops and improve team velocity. As such, trunk-based development is often the best fit for teams that want to get the most value out of their continuous integration pipelines.
Using Git tags and branches with CircleCI
There are many ways that branches and tags can help manage features, testing, deployment, and releases from your CircleCI pipeline.
With CircleCI, you can use tags as triggers for your pipelines. You can specify certain tags that automatically trigger a pipeline to run when they are added to a commit. This can be useful for several things, including automated tests or deploying your code to production.
You can also use tags to track the progress of your pipeline runs. You can use a tag to indicate that a certain step in the pipeline is complete. This helps you track the overall progress of the pipeline and identify potential issues. You can also use tags to filter for certain workflows in the Insights dashboard, giving you actionable metrics on build speed and performance that you can use to optimize your team’s delivery process.
Branch and tag filters
With CircleCI’s branch and tag filters, you can specify the branches and tags to include in a pipeline. You can use branch filters to run a workflow (or a specific job within a workflow) only for changes on specific branches. This is useful for restricting certain jobs — such as running a subset of your tests or deploying your code to production — to branches dedicated to those activities.
You can also use Git tags to automatically execute a workflow in CircleCI using the
filters key in your CircleCI configuration. This allows you to specify which tags should trigger the workflow.
To use branch and tag filters for workflows in CircleCI, specify the filters in the workflows section of your CircleCI configuration. Using branch and tag filters in CircleCI allows you to fine-tune your pipeline and control when and how your changes are built, tested, and deployed.
Monitor tagged workflows
The CircleCI Insights dashboard allows you to monitor workflows and track the performance of your builds.
To access the Insights endpoint, navigate to the CircleCI web UI and click the Insights tab. This brings up a dashboard of important metrics showing the performance of your pipelines over time, along with additional data on resource and credit consumption that you can use to predict and control costs.
You can use the filters to narrow down the data, showing a specific tag’s triggered pipelines.
This allows you to track information such as success rate and workflow duration or review the most recent workflow runs for a given tag.
Many development teams that use Git frequently make use of both Git branches and Git tags. Branches allow you to code features or fix bugs without impacting the main code branch, whereas tags are essential for marking a point in time in your code, such as a new release of your application.
Branches and tags work together to optimize your workflow. With CircleCI, they can also add flexibility and functionality to your CI/CD process. You can use them to orchestrate and streamline builds, tests, and deployments and to monitor the performance of high priority builds.
To learn more about how you can use effective branching and tagging strategies alongside best-in-class CI/CD to streamline your software delivery, get started with your free CircleCI account today.