Azure DevOps: Repos

 Azure DevOps Repos is a set of version control tools that you can use to manage your code in Azure DevOps. It offers both Git (distributed version control) and Team Foundation Version Control (TFVC, a centralized version control).

Lets  focus on the features and functionalities of Azure DevOps Git repositories, as Git is the more commonly used option. Below are the list of features it provides.

• Version Control
• Pull Requests and Code Review
• Branch Policies
• Integration with Build Pipelines
• File Management and Browsing
• Collaboration and commenting
• Work Items Linking
• Wiki
• Tagging and Releases
• Security and Permissions
• Integration with Other Azure DevOps Services
• APIs for Custom Integration
• Extensibility with Marketplace Extensions

Lets explore these in detail.

Version Control

A Version Control System (VCS) is a tool that helps manage changes to documents, programs, and other information stored as files. It allows multiple people to work on a single project without conflicting, tracks every modification, and enables reverting to previous versions if needed.

Example: Imagine a team working on a website. One person edits the homepage, while another updates contact information. VCS helps them do this simultaneously, keeps a record of who made which changes, and allows reverting to older versions if an update causes issues.

Git is a popular VCS, widely used for tracking changes in source code during software development. It is designed for coordinating work among programmers, but it can be used to track changes in any set of files. Git is a distributed VCS, meaning every developer's working copy of the code is also a repository that can contain the full history of all changes.

Example: A team is developing an app. Each member clones the central repository, makes changes in their local copy, and commits these changes. Git keeps track of all these modifications. When ready, they push their changes to the central repository, making it available to others.

Pull Request and Code Review

Pull Request (PR): A PR in Azure DevOps is a method to submit your code changes for review before merging them into the main branch. It's a request to peers for reviewing the code and providing feedback. A PR creates a platform for discussing proposed changes and ensures that only quality code is merged.

 Code Review: When a PR is created, team members can review the code changes, comment, suggest improvements, or approve the changes. Code reviews ensure adherence to coding standards, catch bugs, and improve the overall quality of the software.

 Example:

Imagine you're working on a feature in an app. Once the feature is developed, you create a new branch in your Azure DevOps Repo and commit your changes. To merge these changes into the main branch, you submit a PR. Your teammates receive a notification to review the changes. They can then view the diffs, comment on specific lines of code, discuss improvements, and finally approve or reject the PR. Once approved, the PR can be merged, integrating your changes into the main branch.

 This process of using PRs and conducting code reviews is fundamental in modern software development, promoting collaboration, maintaining code quality, and reducing the risk of bugs or issues in the production code.

Branch Policies

Branch policies in Azure DevOps Repos are rules set on branches, particularly in Git repositories, to enforce certain standards and workflows. These policies ensure that changes in the codebase meet the required quality and are reviewed before being merged.

 

Example:

Consider a development team working on a new feature. They use a branch called feature-a for this purpose. To maintain code quality, they might enforce a branch policy that requires:

Code Reviews: Every pull request (PR) to merge changes from feature-a into the main branch must be reviewed and approved by at least two team members.

Build Validation: Changes pushed to the PR trigger an automated build, and the code can be merged only if the build passes. This ensures that the new code does not break the existing functionality.

Minimum Number of Reviewers: Specifies that each PR must be reviewed by a minimum number of reviewers before merging.

Check for Linked Work Items: Ensures that every PR is linked to a work item, providing traceability of changes to the tasks or features they relate to.

By implementing these branch policies, the team ensures that all changes are scrutinized, tested, and aligned with the project's goals, thus maintaining the integrity and quality of the codebase.

3. Integration with Build Pipelines:

Azure DevOps Repos provides seamless integration with Azure Pipelines, enabling automated build processes whenever code changes are committed to the repository. This integration streamlines the Continuous Integration (CI) process, allowing for automated testing and building of code with each commit, ensuring that new changes don't break the existing functionality.

 

Example Scenario:

Project: You have a web application stored in an Azure DevOps Repo.

CI Pipeline Setup: You set up a build pipeline in Azure Pipelines linked to this repo.

Trigger: Whenever a developer commits new code or a feature to the repo, the build pipeline is automatically triggered.

Action: The pipeline fetches the latest code and runs predefined tasks such as compiling the code, running unit tests, and generating build artifacts.

Outcome: If the build succeeds, it indicates that the changes are safe to merge. If it fails, the team is alerted to fix the issues, ensuring code integrity and quality.

This integration ensures that code changes are consistently and automatically tested, reducing manual intervention and improving code quality and deployment speed.

 

4. File Management and Browsing:

Azure DevOps Repos provides a cloud-hosted private Git repository service, which is part of the Azure DevOps suite. It offers robust file management and browsing capabilities, allowing teams to effectively manage and navigate their codebase.

 

File Management: Within Azure DevOps Repos, users can add, edit, delete, and rename files directly in the web interface. This makes it easy to manage the project's files without needing to clone the repository or use a Git client locally.

 

Browsing: Users can easily navigate through their repository in Azure DevOps, viewing files, folders, and their history. The interface allows you to browse different branches, examine commit histories, and explore the changes made over time.

 

Example: Consider a team working on a web application. They use Azure DevOps Repos to manage their source code. A developer can browse to a feature branch directly within the web interface, edit a JavaScript file to fix a bug, commit the change, and push it back to the repository, all without leaving the browser. Other team members can then view this change, its history, and the file’s previous versions easily through the Azure DevOps Repos interface.

 

Azure DevOps Repos streamlines the process of code management and browsing, making it a powerful tool for teams to collaborate and maintain their code effectively.

 

5. Collaboration and Commenting:

Azure DevOps Repos provides a rich platform for code collaboration and commenting, making it easier for development teams to work together on coding projects. It's integrated with Git, a version control system, allowing multiple team members to work on the same codebase simultaneously.

 

Collaboration: Teams can use branches to work on features, bug fixes, or experiments separately from the main codebase. For instance, a developer can create a new branch to add a feature, make changes, commit them, and push the branch to Azure DevOps Repos without affecting the main code.

 

Pull Requests (PRs): When a feature in a branch is ready, the developer creates a PR. This is a request to merge their changes into the main codebase. For example, after finishing a feature, a developer creates a PR, initiating a review process.

 

Commenting: During the PR review, team members can comment directly on the code, offering suggestions, asking questions, or requesting changes. For example, a reviewer might comment on a specific line of code, asking for clarification or suggesting an improvement.

 

Example Scenario: Radha is working on adding a new login feature to an app. She creates a branch, develops the feature, and submits a PR. Krishna, a senior developer, reviews the PR and comments on a few lines of code where improvements are needed. Radha makes the changes, updates the PR, and after final approval from Bob, the branch is merged into the main codebase.

 

Azure DevOps Repos streamlines the collaborative process, enabling clear communication and efficient team workflows. Its integration with Git and features like PRs and in-line commenting enhance code quality and foster a collaborative development environment.

6. Work Items Linking:

Azure DevOps Repos offers the capability to link work items to code changes, fostering better traceability and organization in software development projects. This feature allows team members to connect commits, pull requests, or branches directly to work items like user stories, bugs, or tasks.

 

Example: Suppose a developer is fixing a bug reported in the project, tracked as a work item in Azure Boards. When they commit their code changes to Azure Repos, they can include the work item ID in the commit message (e.g., "Fixed layout issue, resolves #12345"). This links the commit to the work item #12345. Team members can then easily see the specific changes made to address the bug, directly from the work item in Azure Boards.

This linking provides a comprehensive view of what changes were made, why, and by whom, enhancing collaboration and enabling teams to track the progress of tasks throughout the development lifecycle.

7. Wikis for Documentation:

Azure DevOps Repos offers a Wiki feature, providing a convenient space for teams to document their projects directly within Azure DevOps. This Wiki is a repository itself, where you can write pages in Markdown, manage them with Git version control, and collaborate with your team.

 

Example: Consider a software development team using Azure DevOps for their project. They can create a Wiki within their Azure DevOps Repos to document their software architecture, coding standards, meeting notes, project plans, and sprint reviews. Each team member can contribute to the Wiki, updating documentation as the project evolves. The Wiki tracks these changes, allowing team members to see updates in real-time, revert to previous versions if needed, and collaborate efficiently.

8. Tagging and Releases:

 

Azure DevOps Repos offers robust features for version control, including tagging and releases, which are essential for managing and tracking different versions of your software.

 

Tagging

Purpose: Tags in Azure DevOps are labels you can apply to specific commits in your repository. They are typically used to mark a significant point in the repo's history, like a version release.

Example: If you release version 1.0 of your application, you can tag the corresponding commit with a "v1.0" tag. This allows anyone to quickly find the exact code state representing version 1.0.

Releases

Purpose: Releases in Azure DevOps represent a specific packaged and deployable iteration of your code, often built from a tagged commit. It’s a way of bundling the code and artifacts associated with a particular version for deployment.

Example: After tagging your commit for version 1.0, you create a release from this tag. This release can include compiled binaries, release notes, and configuration files needed to deploy version 1.0 of your application in different environments.

Conclusion

Tagging and releases in Azure DevOps Repos provide a structured approach to versioning and deploying your software. Tags offer a reference to specific points in your development history, while releases package these into deployable units, simplifying the deployment and distribution process of your application.

9. Security and Permissions:

 

Azure DevOps Repos provides robust security and permissions features to manage access control and ensure the security of your code repositories. Here's a brief overview with an example:

 

Security and Permissions in Azure DevOps Repos

Granular Access Control: Azure DevOps Repos allows setting detailed permissions at various levels - project, repository, branch, etc. You can control who can read, write, create branches, or merge changes.

Integration with Azure AD: It integrates with Azure Active Directory (Azure AD), allowing you to leverage existing user accounts and groups for access management.

Branch Policies: Implement branch policies to enforce code quality standards, like requiring pull request reviews, running automated builds and tests, and more before code is merged.

Audit Trails: Azure DevOps maintains audit logs for repository activities, providing transparency over changes and access.

Example

Imagine a project in Azure DevOps with multiple repositories. The project has two teams: Developers and Quality Assurance (QA).

 

Developers Team: They need read and write access to the repositories to commit code changes. For critical branches like main or release, you set branch policies requiring at least two peer reviews before merging changes.

QA Team: They only need read access to the repositories to view the code and run tests. They do not have write access, ensuring they can’t accidentally modify the code.

By configuring these permissions and policies in Azure DevOps Repos, you ensure that the right people have the appropriate level of access and that code changes meet quality standards before being merged. This approach enhances both the security and the integrity of the development process.