Latest Posts

Version Control with Git + DevOps

Posted on by Rishan Solutions

Loading

Introduction

In today’s fast-paced software development environment, maintaining consistency, traceability, and collaboration across teams is crucial. Whether you’re building full-stack applications, automating processes, or managing infrastructure as code, version control is the backbone that holds your development workflow together. At the center of most modern version control systems is Git, a distributed version control system that has become the industry standard.

When paired with Azure DevOps, Git becomes even more powerful. Azure DevOps not only hosts Git repositories but also provides integrated tools for project planning, continuous integration and delivery (CI/CD), artifact management, and testing.

This article explores how Git works, how to use it effectively within Azure DevOps, and how this combination enhances your version control and DevOps workflows.

What Is Git?

Git is a distributed version control system designed to handle everything from small to very large projects with speed and efficiency. It was created by Linus Torvalds in 2005 to manage the development of the Linux kernel.

Key Features of Git:

  • Distributed architecture: Every developer has a full copy of the code repository.
  • Branching and merging: Developers can create lightweight branches to work on features or fixes independently.
  • Commit history: All changes are logged with author, timestamp, and commit messages.
  • Staging area: You can stage changes before committing, offering flexibility.
  • Fast performance: Git operations are typically fast due to local data access.

What Is Azure DevOps?

Azure DevOps is a cloud-based DevOps toolchain provided by Microsoft, supporting the full application lifecycle. Its services include:

  • Azure Repos: Git repository hosting with integrated version control
  • Azure Pipelines: CI/CD pipelines for automated builds and deployments
  • Azure Boards: Agile project tracking with Kanban boards, backlogs, and sprints
  • Azure Test Plans: Manual and automated testing tools
  • Azure Artifacts: Package management and distribution

When integrated with Git, Azure DevOps becomes a powerful platform for collaborative, enterprise-grade software development.

Why Use Git with Azure DevOps?

Combining Git’s version control features with Azure DevOps brings significant benefits:

  • End-to-end DevOps: From code to deployment, everything is connected.
  • Cloud and on-prem options: Azure DevOps works in both hosted and self-hosted environments.
  • Collaboration: Teams can work together on features, bugs, and documentation in a single platform.
  • Security and compliance: Role-based access, audit logs, and enterprise-grade policies.
  • Integration: Works well with Visual Studio, GitHub, VS Code, and third-party tools.

Key Concepts of Git for Version Control

Understanding these core concepts is essential to using Git effectively:

1. Repository (Repo)

A repository is a project’s complete history, including all versions of files and commits.

2. Commit

A snapshot of your changes, accompanied by a commit message explaining what was changed and why.

3. Branch

A branch represents an independent line of development. Common practices include:

  • main or master for production-ready code
  • develop for ongoing work
  • Feature branches (feature/login)
  • Bugfix branches (bugfix/header-fix)
  • Release branches (release/v1.0)

4. Merge

Combines changes from one branch into another. For example, merging a feature branch into main.

5. Pull Request (PR)

A formal request to merge changes, usually reviewed by team members. Azure DevOps supports policies like mandatory reviews and checks before PRs can be merged.

Setting Up Git Repositories in Azure DevOps

Step 1: Create a Project

  1. Go to dev.azure.com.
  2. Create a new project (select Git as the version control system).

Step 2: Clone the Repository

From your terminal or VS Code:

git clone https://dev.azure.com/your-org/your-project/_git/your-repo
cd your-repo

Step 3: Set Up Git Configuration

git config --global user.name "Your Name"
git config --global user.email "you@example.com"

Branching Strategy with Azure DevOps

A well-defined branching strategy improves team collaboration and code quality. Common models include:

1. GitFlow

A branching model for managing releases:

  • main: Production-ready code
  • develop: Integration branch
  • feature/*: New features
  • release/*: Pre-release work
  • hotfix/*: Emergency fixes

2. Feature Branching

Each new feature or fix is done in its own branch. This simplifies code reviews and testing.

3. Trunk-Based Development

Developers commit to main or master frequently, supported by feature flags. Best for fast-moving teams with robust CI/CD.

4. Release Branching

Used when supporting multiple versions in parallel, such as release/v1.0, release/v2.0.

Using Pull Requests in Azure DevOps

Pull requests (PRs) are central to collaboration in Git. In Azure DevOps, PRs provide:

  • Code review
  • Approval workflows
  • Linked work items
  • CI build validation

Steps:

  1. Push your feature branch to Azure Repos.
  2. Create a PR from your branch to main.
  3. Assign reviewers and set policies (like build success required).
  4. Once approved, complete the PR to merge.

Azure DevOps can automatically delete the source branch and squash commits if configured.

CI/CD with Azure Pipelines

Version control doesn’t stop at managing code—it integrates tightly with build and deployment processes.

Sample CI/CD Workflow:

  1. Developer pushes code ➝ Git triggers pipeline
  2. Azure Pipelines builds the application
  3. Automated tests run
  4. Build artifacts created
  5. Deployment to Dev, Test, or Prod environments

Pipeline Example (YAML)

trigger:
  branches:
    include:
      - main

pool:
  vmImage: 'ubuntu-latest'

steps:
- task: UseDotNet@2
  inputs:
    packageType: 'sdk'
    version: '7.x.x'
    installationPath: $(Agent.ToolsDirectory)/dotnet

- script: dotnet build
  displayName: 'Build project'

- script: dotnet test
  displayName: 'Run tests'

Version Control Best Practices

To get the most out of Git and Azure DevOps, follow these best practices:

1. Commit Often, But Meaningfully

Frequent commits help track progress. Keep each commit focused on a single change.

2. Write Clear Commit Messages

Use present-tense imperative:

Add user login endpoint
Fix bug in email validation
Refactor invoice generation

3. Use Branch Protection Rules

Enforce policies such as:

  • PR reviews required
  • Build success required
  • Limit force pushes

4. Tag Releases

Use Git tags for marking versions:

git tag -a v1.0 -m "Initial release"
git push origin v1.0

5. Avoid Large Binary Files

Git isn’t optimized for binaries. Use Git LFS or Azure Artifacts if needed.

6. Merge Regularly

Don’t let branches diverge for too long. Regularly merge main into feature branches to avoid conflicts.

Git + DevOps for Power Platform and Low-Code Projects

Azure DevOps and Git are increasingly being used for Power Platform and low-code development. Tools like the Power Platform Build Tools extension allow you to:

  • Export/import Power Apps solutions
  • Manage environments
  • Apply solution checker rules
  • Automate deployments

Combined with Git, you can:

  • Track app changes in source control
  • Enforce CI/CD for Power Platform solutions
  • Support collaboration between pro developers and low-code makers

Common Challenges and How to Overcome Them

ChallengeSolution
Merge conflictsCommit frequently, rebase often, communicate early
Hard to track large projectsUse tags, branches, and descriptive commits
Poor PR review qualityEnforce review policies and use checklists
Environment driftAutomate deployments via pipelines
Managing secrets in codeUse Azure Key Vault or secure pipeline variables

Leave a Reply

Your email address will not be published. Required fields are marked *