Best Practices for Azure Repositories

Azure Repositories is a set of version control tools that you can use to manage your code. To ensure a clean, secure, and efficient workflow, follow these best practices:

1. Branching Strategy

• Adopt a Branching Model: Use a branching strategy like GitFlow, GitHub Flow, or trunk-based development.

  • Main Branch: Always represents production-ready code.

  • Develop Branch: Represents the latest development code (optional, depending on your strategy).

  • Feature Branches: Used for individual features or bug fixes.

  • Hotfix Branches: Used for urgent fixes to production.

• Name Branches Clearly: Use consistent naming conventions for branches, e.g., feature/feature-name, bugfix/issue-id, hotfix/issue-id.

2. Pull Requests (PRs)

• Require Pull Requests for Merging: Always use pull requests to merge changes into the main branch. This ensures code is reviewed before being merged.

• Small, Focused PRs: Keep pull requests small and focused on a single feature or bug fix. This makes them easier to review.

• Add Descriptive Titles and Descriptions: Clearly explain what the PR does and why it is needed.

• Link Work Items: Link pull requests to Azure DevOps work items (e.g., tasks, bugs) to track progress.

3. Code Reviews

• Require Code Reviews: Ensure that all code changes are reviewed by at least one other team member before merging.

• Use Review Checklists: Create a checklist for reviewers to ensure consistent and thorough reviews (e.g., check for coding standards, test coverage, and potential bugs).

• Encourage Constructive Feedback: Foster a culture of constructive feedback to improve code quality.

4. Branch Policies

• Set Up Branch Policies: Use Azure DevOps branch policies to enforce rules on branches (e.g., main).

  • Require a minimum number of reviewers.

  • Enforce work item linking.

  • Require successful builds before merging.

  • Enforce code coverage thresholds.

• Protect the main Branch: Prevent direct commits to the main branch by requiring pull requests.

5. Commit Messages

• Write Clear Commit Messages: Use descriptive commit messages that explain the "what" and "why" of the change.

Follow a Standard Format: Use a consistent format for commit messages, e.g.,:
[Type] Short description of the change

Detailed explanation of the change (if necessary).

Example:
[Feature] Add user authentication

Implemented JWT-based authentication for the API. Added unit tests for the login endpoint.

6. Automated Testing

• Run Tests Automatically: Use Azure Pipelines to run unit tests, integration tests, and other automated tests on every pull request.

• Fail Fast: Ensure the pipeline fails if any test fails.

• Code Coverage: Measure and enforce code coverage thresholds.

7. Continuous Integration (CI)

• Build on Every Commit: Set up a CI pipeline in Azure Pipelines to build the code and run tests on every commit or pull request.

• Static Code Analysis: Use tools like SonarQube or CodeQL to analyze code for potential issues.

8. Security

• Use Secrets Management: Store sensitive information (e.g., API keys, passwords) in Azure Key Vault or pipeline secrets, not in the repository.

• Enable Two-Factor Authentication (2FA): Require 2FA for all users with access to the repository.

• Audit Repository Access: Regularly review who has access to the repository and remove unnecessary permissions.

9. Documentation

• Document the Repository: Include a README.md file with an overview of the project, setup instructions, and contribution guidelines.

• Add a CONTRIBUTING.md File: Provide guidelines for contributing to the repository (e.g., coding standards, branching strategy).

• Use a CHANGELOG.md File: Maintain a changelog to track changes in each release.

10. Monitor and Audit

• Enable Audit Logs: Use Azure DevOps audit logs to track changes to the repository, branch policies, and permissions.

• Monitor Build and Test Results: Regularly review build and test results to identify and fix issues early.

How to Ensure Merge to main Branch Requires at Least One Approver

Azure DevOps allows you to enforce branch policies to ensure that code is reviewed and approved before being merged into the main branch.

Steps to Set Up Branch Policies in Azure DevOps

1. Navigate to the Repository:

• Go to your Azure DevOps project.

• Select Repos from the left-hand menu.

• Select the repository you want to configure.

2. Open Branch Policies:

• Click on Branches in the left-hand menu.

• Locate the main branch (or the branch you want to protect).

• Click the ellipsis (⋮) next to the branch and select Branch Policies.

3. Set Up Required Reviewers:

• Under Policies, enable Require a minimum number of reviewers.

• Set the Minimum number of reviewers to 1 (or more, depending on your team's requirements).

4. Optional: Add Additional Review Rules:

• Reset Code Reviewer Votes: Enable this option to reset approvals if new changes are pushed to the branch after a review.

• Allow Requestors to Approve Their Own Changes: Disable this option to prevent authors from approving their own pull requests.

5. Require Linked Work Items:

• Enable Check for linked work items to ensure that pull requests are linked to Azure DevOps work items.

6. Require Passing Builds:

• Enable Build validation to require that a build pipeline runs successfully before the pull request can be merged.

7. Save the Policy:

• Click Save to apply the branch policies.

Example Branch Policy Configuration

Policy

Setting

Require a minimum number of reviewers

Enabled, Minimum: 1

Reset code reviewer votes

Enabled

Allow requestors to approve their own changes

Disabled

Check for linked work items

Enabled

Build validation

Enabled, Pipeline: CI Pipeline

Testing the Policy

1. Create a pull request targeting the main branch.

2. Ensure that:

• At least one reviewer approves the pull request.

• The build pipeline runs successfully.

• The pull request is linked to a work item (if required).

3. Attempt to merge the pull request without meeting the requirements to verify that the policy blocks the merge.

By following these best practices and enforcing branch policies, you can ensure a high-quality, secure, and efficient workflow in Azure Repositories.