Azure DevOps

Overview

Azure DevOps provides a comprehensive set of services for managing the software development lifecycle, from planning and code management to continuous delivery and monitoring. Originating from Team Foundation Server (TFS), Azure DevOps evolved into a cloud-based offering that integrates with the broader Azure ecosystem while also supporting hybrid and multi-cloud environments through its flexible deployment options. It is designed to assist development teams in adopting DevOps practices by centralizing tools required for collaboration, automation, and project visibility.

The platform offers five core services:

• Azure Boards: For agile planning, tracking work items, and managing backlogs and sprints. It supports various methodologies, including Scrum and Kanban, enabling teams to visualize progress and manage tasks.
• Azure Repos: Provides unlimited private Git repositories and Team Foundation Version Control (TFVC) for source code management. It includes pull requests, code reviews, and policy enforcement to maintain code quality as described in the Git quickstart.
• Azure Pipelines: A CI/CD service that supports building, testing, and deploying to any cloud or on-premises environment. It integrates with various programming languages, platforms, and cloud providers, offering hosted agents and parallel job execution capabilities.
• Azure Test Plans: Offers integrated tools for manual and exploratory testing, load testing, and automated test management. It allows teams to create, execute, and track test cases linked to requirements and bugs directly within the platform.
• Azure Artifacts: A package management service that supports popular package formats like Maven, npm, NuGet, Python, and Universal Packages. It enables teams to create, host, and share packages within their organization, facilitating code reuse and dependency management.

Azure DevOps is generally suitable for organizations seeking an integrated solution that works within the Microsoft ecosystem, including integrations with Azure Active Directory, Visual Studio, and various Azure services as detailed in the integration guide. Its modular design allows teams to adopt specific services as needed rather than requiring the entire suite. The platform also includes extensive customization options, though these can introduce initial complexity for new users. For large enterprise teams, its compliance certifications, such as ISO 27001 and HIPAA BAA, address regulatory requirements.

Key features

• Work Item Tracking: Customizable work items, backlogs, and sprints with support for Scrum, Kanban, and custom processes via Azure Boards.
• Version Control: Unlimited private Git repositories and TFVC with advanced branching strategies, pull requests, and code review workflows provided by Azure Repos.
• CI/CD Pipelines: Automated build, test, and deployment across multiple environments, supporting diverse languages and platforms, with YAML-based pipelines in Azure Pipelines.
• Test Management: Integrated manual, exploratory, and automated testing tools, with test case management and bug tracking capabilities through Azure Test Plans.
• Package Management: Universal package feeds for Maven, npm, NuGet, Python, and other formats to manage dependencies and share binaries using Azure Artifacts.
• Dashboards and Analytics: Customizable dashboards, widgets, and reporting tools to visualize project progress and team velocity.
• Integrated Security: Role-based access control, conditional access policies, and integration with Azure Active Directory for identity management.
• Extensibility: A marketplace with extensions and webhooks to integrate with third-party tools and services.

Pricing

Azure DevOps offers a free tier for small teams and open-source projects, with paid plans based on user count and additional services.

Common integrations

• Azure Active Directory: For identity and access management, user synchronization, and single sign-on as described in Azure AD user integration.
• Visual Studio / VS Code: Direct integration for development, debugging, and source control operations within the IDE.
• Microsoft Teams: Notifications, project updates, and collaboration directly within Teams channels.
• GitHub: Connect Git repositories, track issues, and trigger Azure Pipelines from GitHub via GitHub integration for Azure Boards.
• ServiceNow: Bi-directional synchronization of work items, incidents, and change requests.
• Slack: Receive notifications and updates from Azure DevOps services in Slack channels.
• SonarQube: Integrate static code analysis into CI/CD pipelines to enforce code quality standards.
• Jira Software: Integrate work item tracking between Azure Boards and Jira for hybrid team environments.

Alternatives

• GitLab: An open-core, single application for the entire DevOps lifecycle, known for its integrated source control, CI/CD, security, and monitoring capabilities.
• GitHub Actions: A feature of GitHub that provides CI/CD and workflow automation directly within GitHub repositories, often chosen by teams already using GitHub for source control.
• Jira Software: A widely used issue tracking and project management tool for agile development, often complemented by other Atlassian products like Bitbucket and Confluence.
• Bitbucket: Atlassian's Git-based code hosting and collaboration platform, offering private repositories and integrated CI/CD with Bitbucket Pipelines.
• AWS DevOps services: A suite of services from Amazon Web Services, including AWS CodeCommit, CodeBuild, CodeDeploy, and CodePipeline, for building a custom DevOps toolchain in the AWS cloud.

Getting started

This example demonstrates how to set up a basic Azure Pipeline to build a .NET Core application. First, ensure you have an Azure DevOps organization and project created. Then, navigate to 'Pipelines' in your project and create a new pipeline, selecting your code repository (e.g., Azure Repos Git or GitHub). Azure DevOps will often suggest a YAML template based on your project type. For a .NET Core application, it might look like this:

# Azure Pipelines YAML for .NET Core application

trigger:
- main

pool:
  vmImage: 'ubuntu-latest'

variables:
  buildConfiguration: 'Release'

steps:
- task: DotNetCoreCLI@2
  displayName: 'Restore'
  inputs:
    command: 'restore'
    projects: '**/*.csproj'

- task: DotNetCoreCLI@2
  displayName: 'Build'
  inputs:
    command: 'build'
    projects: '**/*.csproj'
    arguments: '--configuration $(buildConfiguration)'

- task: DotNetCoreCLI@2
  displayName: 'Test'
  inputs:
    command: 'test'
    projects: '**/*[Tt]ests/*.csproj'
    arguments: '--configuration $(buildConfiguration)'

- task: DotNetCoreCLI@2
  displayName: 'Publish'
  inputs:
    command: 'publish'
    projects: '**/*.csproj'
    arguments: '--configuration $(buildConfiguration) --output $(Build.ArtifactStagingDirectory)'
    zipAfterPublish: true

- task: PublishBuildArtifacts@1
  displayName: 'Publish Artifact'
  inputs:
    pathToPublish: '$(Build.ArtifactStagingDirectory)'
    artifactName: 'drop'

This YAML defines a pipeline that triggers on changes to the main branch. It uses an Ubuntu virtual machine, restores NuGet packages, builds the .NET Core project, runs tests, and then publishes the build artifacts. After saving this pipeline, any push to the main branch will automatically trigger a build as outlined in the pipeline creation guide.