Azure DevOps Server: Difference between revisions

Content deleted Content added
article not exist
 
(583 intermediate revisions by more than 100 users not shown)
Line 1:
{{short description|Source code management software}}
'''Team Foundation Server''' (commonly abbreviated TFS) is a [[Microsoft]] offering for [[source control]], data collection, [[reporting]], and project tracking, intended for collaborative [[software development]] projects. It is available either as stand-alone software, or as the server side backend platform for [[Visual Studio Team System]] (VSTS).
{{Infobox software
| name = Azure DevOps Server
| logo = Windows Azure logo.png
| logo size = 220px
| screenshot =
| caption =
| developer = [[Microsoft]]
| released = {{Start date and age|2005}}
| latest release version = 2022
| latest release date = {{Start date and age|2022|12|06}}<ref>{{cite web |title=Azure DevOps Server 2022 |url=https://learn.microsoft.com/fr-fr/azure/devops/server/release-notes/azuredevops2022?view=azure-devops|website=[[Microsoft Docs]]| date=14 November 2023 }}</ref>
| operating system = [[Microsoft Windows]]
| language =
| genre = [[Application lifecycle management]]
| license = [[Trialware]]
}}
 
'''Azure DevOps Server''', formerly known as '''Team Foundation Server''' ('''TFS''') and '''Visual Studio Team System''' ('''VSTS'''), is a [[Microsoft]] product that provides [[version control]] (either with [[#TFVC|Team Foundation Version Control]] (TFVC) or [[Git (software)|Git]]), reporting, [[requirements management]], [[project management]] (for both [[agile software development]] and [[waterfall model|waterfall team]]s), automated builds, [[software testing|testing]] and [[release management]] capabilities. It covers the entire [[Application Lifecycle Management|application lifecycle]] and enables [[DevOps]] capabilities.<ref>{{cite web |url=http://msdn.microsoft.com/en-us/library/vstudio/fda2bad5(v=vs.120).aspx |title=Application Lifecycle Management with Visual Studio and Team Foundation Server |year=2013 |website=[[Microsoft Developer Network|MSDN]] |publisher=Microsoft |access-date=2013-10-15}}</ref> Azure DevOps can be used as a back-end to numerous [[integrated development environment]]s (IDEs) but is tailored for [[Microsoft Visual Studio]] and [[Eclipse (software)|Eclipse]] on all platforms.<ref>{{cite web |url=http://msdn.microsoft.com/en-us/library/gg413285.aspx |title=Adopting Team Explorer Everywhere |publisher=Microsoft |website=[[MSDN]] |date=28 April 2015 |access-date=26 May 2017}}</ref>
 
==On-premises vs. online==
Azure DevOps is available in two different forms: on-premises ("Server") and online ("Services").<ref>{{cite web|url=https://codefresh.io/learn/azure-devops/|title=What Is Azure DevOps? Services, Examples, and Best Practices|website=codefresh.io}}</ref> The latter form is called [[Azure DevOps Services]] (formerly Visual Studio Online before it was renamed to Visual Studio Team Services in 2015). The cloud service is backed by the [[Microsoft Azure]] cloud platform. It uses the same code as the on-premises version of Azure DevOps, with minor modifications, and implements the most recent features. A user [[sign in|signs in]] using a [[Microsoft account]] to set up an environment, creating projects and adding team members. New features developed in short development cycles are added to the cloud version first. These features migrate to the on-premises version as updates, at approximately three-month intervals.<ref>{{cite web
|publisher=1105 Media
|year=2013
|url=http://visualstudiomagazine.com/articles/2013/05/10/new-visual-studio-release-cadence-begins.aspx
|title=New Release 'Cadence' Begins with Visual Studio 2012 Update 2
|access-date=2013-10-15
}}</ref>
 
==Architecture==
[[Image:TFS.svg|thumb|225px|right|Team Foundation ===Server 3-tier architecture]]===
Azure DevOps is built on [[multitier architecture|multi-tier]], scalable architecture. The primary structure consists of an application tier responsible for processing logic and maintaining the web application portal (referred to as Team Web Access or TWA). Azure DevOps is built using [[Windows Communication Foundation]] web services. These may be consumed by any client, although the client object model is recommended. The data tier and application tier can exist on the same machine.
Team Foundation Server works in a three-tier architecture: the ''client tier'', the ''application tier'' and the ''data tier''. The ''client tier'' is used for creating and managing projects and accessing the items that are stored and managed for a project. TFS does not include any UI for this tier, rather it exposes [[web service]]s which client applications can use to integrate TFS functionality with themselves. These web services are used by applications like [[Visual Studio Team System]] to use TFS as data storage back end or dedicated TFS management applications like the included ''Team Foundation Client''. The web services are in the ''application layer''. The ''application layer'' also includes a web portal and a document repository facilitated by [[Windows SharePoint Services]]. The web portal, called the ''Team Project Portal'', acts as the central point of communication for projects managed by TFS. The document repository is used for both project items and the revisions tracked, as well as for aggregated data and generated reports. The ''data layer'', essentially a [[Microsoft SQL Server|SQL Server 2005 Standard Edition]] installation, provides the persistent data storage services for the document repository. The ''data tier'' and ''application tier'' can exist on different physical or virtual servers as well, provided they are running [[Windows Server 2003]] or better. The ''data tier'' is not exposed to the ''client tier'', only the ''application tier'' is.
 
To support scalability, the application tier can be load balanced and the data tier can be clustered. If using [[Microsoft SQL Server]] 2012 or later, AlwaysOn SQL Server Failover Clusters and Availability Groups are supported which allows for geographic replication of data.<ref>{{cite web
Most activity in Team Foundation Server revolves around a "work item". Work items are a single unit of work which needs to be completed. In many respects they are similar to a "bug" item in [[bug tracking system]]s such as [[Bugzilla]], in that a work item has fields to define Area, Iteration, Assignee, Reported By, a history, file attachments, and any number of other attributes. Work items themselves can be of several different types, such as a ''Bug'', a ''Task'', a ''Quality of Service Assessment'', a ''Scenario'', and so forth. The framework chosen for any given project in a Team Foundation Server defines what types of work items are available and what attributes each type of work item contains. These items are internally stored in [[XML]] format, and their schema can be customized to add other attributes to different items, or create new items on a per-project basis. Each work item has an associated control policies which control who is allowed to access and/or change the items. It also includes notification and logging capabilities to log all the creation, access or change events (controlled by policies) and optionally notify certain users when certain events occur.
|publisher=Microsoft
|year=2012
|url=http://msdn.microsoft.com/en-us/library/cc645581(v=sql.110).aspx
|title=Availability Enhancements (Database Engine)
|access-date=2013-10-17
}}</ref> The primary container is the project collection. A project collection is a database that contains a group of Team Projects. The Project Collection is another scalability mechanism, in that each collection can be placed on different SQL Servers or SQL Server instances. 'Oe' configuration database per Azure DevOps instance stores project collection metadata. Data from the project collection databases is aggregated into the warehouse database, which denormalizes the data in preparation for loading into an Analysis Services cube. The warehouse and the cube allow complex trend reporting and data analysis.
 
Azure DevOps can integrate with an existing [[SharePoint]] farm. SQL Server Reporting Services are supported for more advanced reporting against the data warehouse or the Analysis Services data cube. These installations can be on the same system or on different systems. Build servers, lab management servers, release management servers and proxy servers (to reduce some of the load on the application tier), test machines and load test machines can also be added to the infrastructure.<ref>{{cite web
Any given Team Foundation Server contains one or more ''Team Projects'', which consists of Visual Studio solutions, configuration files for Team Build and Team Load Test Agents, and a single Sharepoint repository containing the pertinent documents for the project. A team project contains the user defined work items, source branches, and reports that are to be managed by TFS. TFS provides capabilities for managing these projects. When creating a project, a software development framework must be chosen, and cannot be changed afterwards. TFS includes several templates for the most common ones, including agile and formal methodologies. Choosing the framework populates the project with predefined items such as project roles and permissions, as well as other documents like project roadmap, document templates, and report definitions. These items can be then linked to work items as well. The status of certain elements of the project can be set to automatically update as work items are updated. TFS can integrate with [[Microsoft Office Excel|Microsoft Excel]] for the creation and tracking of project items. The status of the items can be created and edited in Excel and the resulting spreadsheet document can be submitted to TFS, which will import the data into its project management feature. It can also integrate with [[Microsoft Project]] as the project management front end. The project items can also be exported as Excel documents for further analysis of the data.
|publisher=Microsoft
|year=2012
|url=http://msdn.microsoft.com/en-us/library/vstudio/ms252473.aspx
|title=Team Foundation Server Architecture
|access-date=2013-10-17
}}</ref> To support teams requiring enterprise project scheduling, Azure DevOps also integrates with [[Microsoft Project Server]], which allows enterprise level portfolio management, resource management and project tracking.
 
===Extensibility===
TFS does not natively include any UI for performing these tasks, rather the capabilities are exposed via [[web service]]s, which are then used by client applications like [[Visual Studio Team System]] [[Integrated Development Environment|IDE]]. However, TFS does include a ''Team Foundation Client'' (TFC) application which can be used to perform these tasks outside of the VSTS IDE. TFC also operates by invoking the same web services. TFS exposes a client API that can be used by client applications to access the functionality; the API itself manages proxies to communicate with the web services as well as client side caching to reduce latency. The [[WSDL]] descriptions of the web services are also provided, in case an application wants to directly call the web services.
Microsoft provides two standalone redistributed [[application programming interface|APIs]] for connecting to Azure DevOps. One is a [[Java (programming language)|Java]] SDK, the other is a [[.NET Framework]] SDK. These APIs allow for client connectivity to Azure DevOps. Because Azure DevOps is written on a [[service-oriented architecture]], it can communicate with virtually any tool that can call a web service. Another extensible mechanism is subscribing to system alerts: for example, alerts that a work item was changed, or a build completed. There are approximately 20 preconfigured alerts, and teams can configure as many additional alerts as needed.<ref>{{cite web
|publisher=Microsoft
|year=2013
|url=http://msdn.microsoft.com/en-us/library/vstudio/ms181334.aspx
|title=Set alerts, get notified when changes occur
|access-date=2013-10-17
}}</ref> When used in an extensible scenario, these alerts can be sent to a web service, triggering actions to alter or update work items (such as implementing advanced business rules or generating work items programmatically based on a given scenario).
 
The data warehouse can also be extended through the creation of custom data warehouse adapters.<ref>{{cite web
===Source control===
|publisher=Microsoft
Team Foundation Server provides a [[source control]] repository, called ''Team Foundation Version Control'' (TFVC). Unlike Microsoft's previous source control offering, [[Visual SourceSafe]] (VSS), which relied on a file-based storage mechanism, Team Foundation source control stores all code, as well as a record of all changes and current check-outs in a SQL Server database. It supports features such as multiple simultaneous check-outs, conflict resolution, shelving and unshelving (shelving is a way to save a set of pending changes without committing them to source control, while still making them available to other users), [[Branching (software)|branching]] and merging, and the ability to set security levels on any level of a source tree, alongside the most visible features of document versioning, locking and rollback. The source control mechanism integrates with Team System's work items as well; when a check-in (termed "changeset") occurs, a developer can choose to have their code associated with one or more specific work items, to indicate what the check-in works towards solving specific issues. TFS administrators can enforce check-in policies that require Code Analysis requirements to have passed, as well as to enforce the association of check-ins with work items, or update the state of associated work items (like flagging a bug as "fixed" when checking in code that has the bug fixed). Individual versions of files can be assigned labels, and all files with the same label forms a release group. Unlike VSS, TFS source control repository does not support linking to an item from multiple places in the source folder structure, nor does it allow an item to be "pinned" (allow different references to the same file from different directories to point to different versions in a way that cannot be further edited).
|year=2008
|url=http://msdn.microsoft.com/en-us/library/bb286956(v=vs.90).aspx
|title=How to create an adapter
|access-date=2013-10-17
}}</ref> With the introduction of TFS 2012, custom add-ins can also be created for Team Web Access, called '''Web Access Extensions'''.
 
===Clients===
TFVC supports [[Branching (software)|branching]] at entire source code level as well as individual files and directory levels as well, with each branch being maintained individually. Multiple branches can be merged together, with the built in conflict resolution algorithm merging the changes between two branches of the same file where it can automatically reconcile the differences or flagging them for manual inspection if it cannot. Merge can be performed at "changeset" level as well, instead of the branch level. A successful merge is automatically checked out in the souce control repository.
Azure DevOps supports Visual Studio 2010 and later, Microsoft Test Manager (MTM) 2012, and 2013. Eclipse, older versions of Visual Studio, and other environments can be plugged into Azure DevOps using the Microsoft Source Code Control Integration Provider (MSSCCI Provider – pronounced “Miss-Key”).<ref>{{cite web
|publisher=Microsoft
|year=2012
|url=http://visualstudiogallery.msdn.microsoft.com/b5b5053e-af34-4fa3-9098-aaa3f3f007cd
|title=Microsoft Visual Studio Team Foundation Server 2012 MSSCCI Provider
|access-date=2013-10-17
}}</ref> These tools provide full access to the features in Azure DevOps.
[[Microsoft Excel]] and [[Microsoft Project]] are also supported to help manage work items which allows for bulk update, bulk entry and bulk export of work items. Microsoft Project can be used to schedule work when conforming to a waterfall software development methodology. Both Excel and Project support bi-directional updates of data. This allows, for example, project managers to put a schedule in Project, have that work imported into Azure DevOps where developers update the work and then the schedule can be updated without the project manager having to perform extra work.
 
With Team Foundation Server 2012, [[Microsoft PowerPoint]] was also integrated with Azure DevOps to enable rapid storyboard development to help with the requirements management process. The integration provides extensible storyboard shapes that can be used to build any type of interface mockup that can then be animated with PowerPoint's built-in functions. These storyboards can then be linked to work items.
TFVC is not limited to source code only, but using the [[Windows SharePoint Services]] infrastructure it is built on, it provides a version-controlled library for other documents in the project as well, including project plans, requirements and feature analysis documents among others. All documents in the source controlled repository can be linked with any work item, and access to them can be controlled by defining access policies.
 
In an effort to handle the growing geographic dispersion of teams and to involve stakeholders earlier and more often in the process, Microsoft added the Feedback Client.<ref>{{cite web
===Reporting===
|publisher=Microsoft
Reporting is another major component of Team Foundation Server. Using the combined data for work items, changesets, and information provided by Team Build and results from Test Agents (described below), a variety of reports can be created. For example, the rate of code change over time, lists of bugs that don't have test cases, regressions on previously passing tests, and so on. The reports are built using [[SQL Server Reporting Services]], and can be exported in several different formats, including Excel, [[XML]], [[PDF]], and [[TIFF]]. Reports can be accessed both through Visual Studio, as well as through the web portal.
|year=2012
|url=http://msdn.microsoft.com/en-us/library/vstudio/hh301769.aspx
|title=Request and review feedback
|access-date=2013-10-17
}}</ref> This tool allows users to exercise an application, annotate what they are seeing with audio and video, capture screens and provide contextual feedback to the development team. This provides specific feedback on the functions of an application from a users’ perspective without requiring meetings and demonstration sessions. Azure DevOps also provides for command line tools for both Unix and Windows environments. The Power Tools for TFS include a [[Windows shell]] integration that allows users to check files in and out, add files and perform other basic tasks by right-clicking on a file or folder.
 
==Work items==
TFS uses its logging framework for automated data collection as well. The logging infrastructure monitors and logs information regarding access and use of the work items and source code, which can then be used by the analysis services to find trends. TFS includes a warehouse adapter in the data tier, which caches data from the underlying normalized database in a form suitable for analytics - in fact tables and dimension tables. [[SQL Server Analysis Services]] are then used to analyze this data, and reports created. Reports can span multiple work items including bug trends, code churning, build trends amongst others. Other analysis applications can also use the data directly pulled off the web services.
At the heart of Azure DevOps is the "work item". A work item represents a thing – it can be work that needs to be accomplished, a risk to track, a test case, a bug or virtually anything else a user can imagine. Work items are defined through the [[XML]] documents and are highly extensible.<ref>{{cite web
|publisher=Ted Gustaf
|year=2010
|url=http://tedgustaf.com/blog/2011/1/how-to-customize-tfs-2010-work-items-and-workflows/
|title=How to customize TFS 2010 work items and workflows
|access-date=2013-10-17
|archive-date=2013-10-19
|archive-url=https://web.archive.org/web/20131019045206/http://tedgustaf.com/blog/2011/1/how-to-customize-tfs-2010-work-items-and-workflows/
|url-status=dead
}}</ref> Work items are combined into a '''Process Template''' that contains these and other pieces of information to provide a development framework. Azure DevOps includes Process Templates for the [[Microsoft Solutions Framework]] for Agile, Scrum and CMMI. Teams can choose to use a built-in template or one of the many templates available for use created by third parties. Process templates can be customized using the Process Template Editor, which is part of the Power Tools.<ref>{{cite web
|publisher=Microsoft
|year=2013
|url=http://visualstudiogallery.msdn.microsoft.com/f017b10c-02b4-4d6d-9845-58a06545627f
|title=Microsoft Visual Studio Team Foundation Server 2013 Power Tools
|access-date=2013-10-17
}}</ref>
 
Work items can be linked to each other using different relationships to create a hierarchical tree of work items or a flat relationship between work items. Work items can also be linked to external artifacts such as web pages, documents on a file share or documents stored in another repository such as SharePoint. Work items can also be linked to source code, build results, test results and specific versions of items in source control.
===Project portal===
On a per-project basis, TFS also creates a SharePoint site for the project, which can be used to track the progress of the project as well as to explore the work items and source controlled documents in the project, which are presented via the document library. It can also be used to view the reports generated. As a communication medium, the users associated with each other can use it to communicate amongst each other. The comments can be linked to various items as well. For each project, depending on the project properties, TFS uses a predefined template that defines the appearance of the site. These templates can be customized by the TFS administrators.
 
The flexibility in the work item system allows Azure DevOps to play many roles from requirements management to bug tracking, risk and issue tracking, as well as recording the results of reviews. The extensible linking capabilities ensure that traceability from requirements to source code to test cases and results can be accomplished and reported on for auditing purposes as well as historical understanding of changes.
===Shared services===
TFS provides a handful of services that can be used for integration with other applications like [[IDE]]s and [[Project management software|Project Management System]]s. The ''linking service'' allows loosely coupled relationships to be created between items, for example a ''bug'' item and the source code revision(s) it applies to. The ''security services'' allows creation of security groups from users, to which access rights are then assigned. The ''classification service'' allows definition of policies to automatically classify items based on a multitude of criteria and the ''eventing service'' allows any component to raise an event and a notification action assigned to the event. The notification can be either using [[web feed|feed]] [[Web syndication|syndication]] or e-mail, or invoking other web service.
 
==TeamSource buildcontrol==
Azure DevOps supports two different types of [[source control]] – its original source control engine called Team Foundation Version Control (TFVC) and with the release of TFS 2013, it supports [[#Git|Git]] as a core source control repository.
''Team Build'' is a build server included with Team Foundation Server that can be installed on almost any machine that can support Visual Studio. Machines configured with Team Build can be used by developers to do a complete build of the most recent versions of the software contained in source control. Records of every build, whether it succeeds or fails, are kept so that developers and build administrators can keep track of the progress of the project. If a build succeeds, it analyses what changes have been made to in source control since the last successful build, and updates any work items to indicate that progress has been made. For example, if a tester filed a bug work-item against build #15, and a developer checked in a change just prior to build #18 being created, then the bug work-item would be updated to state that the bug has been fixed. A tester can then confirm or deny that the bug has been resolved.
 
===Team Foundation Version Control===
==References==
{{refbeginanchor|TFVC}}
TFVC is a centralized version control system allowing teams to store any type of artifact within its repository.<ref name="MSD-TFVC">{{cite web |title=Team Foundation Version Control (TFVC) |department=Azure DevOps |url=https://docs.microsoft.com/azure/devops/repos/tfvc/index |website=[[Microsoft Docs]] |access-date=2019-09-23}}</ref> TFVC supports two different types of workspaces when working with client tools – Server Workspaces and Local Workspaces.<ref>{{cite web
*[http://msdn2.microsoft.com/en-us/library/ms364061(vs.80).aspx Team Foundation Server: At Work]
|publisher=Phil Kelley
*[http://msdn2.microsoft.com/en-us/library/aa302182.aspx Visual Studio 2005 Team System: Enterprise-Class Source Control]
|year=2013
*[http://msdn2.microsoft.com/en-us/library/ms364074(vs.80).aspx Using Source Code Control in Team Foundation]
|url=http://blogs.msdn.com/b/phkelley/archive/2013/05/29/server-workspaces-vs-local-workspaces.aspx
*[http://msdn2.microsoft.com/en-us/library/ms364062(vs.80).aspx Team Foundation Server Fundamentals: A Look at the Capabilities and Architecture]
|title=Server workspaces vs. local workspaces
{{refend}}
|access-date=2013-10-17
}}</ref> Server workspaces allow developers to lock files for check-out and provide notification to other developers that files are being edited. A frequent complaint for this model is that files on the development machine are marked as read-only. It also requires developers to "go offline" when the server can't be contacted. Local workspaces were designed to avoid these problems. In a local workspace scenario files are not read-only and they do not have to be checked out before working on them. As long as the files are on the developer's local machine, it doesn't matter if the server is connected or not. Conflicts are dealt with at [[revision control|check-in]] time.
 
To improve performance for remote clients, Azure DevOps includes the ability to install [[Proxy Server]]s.<ref>{{cite web
==External links==
|publisher=Microsoft
*[http://msdn2.microsoft.com/en-us/library/bb668991.aspx patterns & practices Team Development with Visual Studio Team Foundation Server] (MSDN)
|year=2013
*[http://www.amazon.com/dp/0735625719 patterns & practices Team Development with Visual Studio Team Foundation Server] (Book)
*[ |url=http://msdn2msdn.microsoft.com/en-us/library/bb671361ee248710.aspx patterns & practices Team System Videos] (MSDN)
|title=How to: Install Team Foundation Proxy and set up a remote site
*[http://www.codeplex.com/VSTSGuidance patterns & practices Visual Studio Team System Guidance] (Online KB)
|access-date=2013-10-17
*[http://msdn2.microsoft.com/en-us/teamsystem/aa718934.aspx Team Foundation Server Team Center]
}}</ref> Proxy servers allow source control contents to be cached at a site closer to the developers to avoid long network trips and the associated latency. Check-ins are still performed directly against the Azure DevOps application tier so the Proxy Server is most beneficial in read scenarios.
*[http://msdn2.microsoft.com/en-us/library/ms242904(VS.80).aspx Team Foundation overview]
*[http://www.microsoft.com/downloads/details.aspx?familyid=D5C12289-F4E4-49A9-9235-AB2F6D4CA097&displaylang=en Trial download]
 
As part of the source control engine, Azure DevOps supports a number of features to help developers ensure the code that is checked in follows configurable rules. This rule engine is called a Check-in Policy. There are several out of the box policies such as the Changeset Comments Policy which will not allow a check-in unless the developer enters a check-in comment. These policies are extensible and can be used to examine all aspects of the code being checked in, the comments and the related work items. Azure DevOps also supports a Code Analysis feature that when used independently is known as [[FxCop]]. The inclusion in Azure DevOps means that the analysis can run against code checked into the server and during automated builds.
 
The Azure Repos extension for [[Visual Studio Code]] supports TFVC.<ref>{{cite web |title=Team Foundation Version Control (TFVC) Support |url=https://github.com/microsoft/azure-repos-vscode/blob/master/TFVC_README.md |department=Azure Repos Extension for Visual Studio Code |website=[[GitHub]] |access-date=2019-09-23}}</ref>
[[Category:Microsoft software]]
 
===Git===
With the release of TFS 2013, Microsoft added native support for [[Git (software)|Git]]. This is not a Microsoft specific implementation but a standard implementation based on the libgit2<ref>{{cite web
|publisher=GitHub
|year=2013
|url=https://github.com/libgit2/libgit2
|title=GitHub libgit2/libgit2
|access-date=2013-10-31
}}</ref> library. This is the same library that powers the popular [[GitHub]] and the code is freely available from GitHub. Because Microsoft took the approach of using a standard library, any Git client can now be used natively with Azure DevOps (in other words, developers can use their favorite tools and never install the standard Azure DevOps clients). This allows tools on any platform and any IDE that support Git to connect to Azure DevOps. For example, both [[Xcode]] and [[Android Studio]] support Git plug-ins. In addition, if developers do not want to use Microsoft's Team Explorer Everywhere plug-in for [[Eclipse (software)|Eclipse]], they can choose to use eGit<ref>{{cite web
|publisher=Eclipse
|year=2013
|url=http://www.eclipse.org/egit/
|title=EGit
|access-date=2013-10-31
}}</ref> to connect to Azure DevOps.
 
Using Git does not preclude the benefit of using Azure DevOps work item or build system. When checking code in with Git, referencing the work item ID in the check-in comment will associate the check-in with the given work item. Likewise, Team Build will also build Git projects.
 
One of the major reasons to use Azure DevOps as a Git repository is that it is backed by SQL Server and is afforded the same protection as Team Foundation Version Control (TFVC){{clarify|date=September 2024}}. This gives developers some choices when choosing the type of project and work style that works best for them.
 
==Reporting==
Reporting has been a core component of Azure DevOps since its initial release in 2005. The reporting infrastructure consists of a data warehouse<ref>{{cite web
|publisher=Microsoft
|year=2013
|url=http://msdn.microsoft.com/en-us/library/ms244687.aspx
|title=Components of the TFS data warehouse
|access-date=2013-10-17
}}</ref> (Tfs_Warehouse) which is a relational database and a SQL Server Analysis Services data cube.<ref>{{cite web
|publisher=Microsoft
|year=2013
|url=http://msdn.microsoft.com/en-us/library/ms244710.aspx
|title=Perspectives and measure groups provided in the Analysis Services cube for Team System
|access-date=2013-10-17
}}</ref> Both of these sources are available for reporting through SQL Server Reporting Services when this option is installed. Since these are standard database and cube structures, any tool which can point to these data sources can report from them. This includes tools such as Cognos, Tableau, Excel and other reporting tools. Included with each out of the box process template is a set of reports for reporting services which cover Build information, Test results and progress, project management, agile reports (Backlog Overview, Release Burndown, Sprint Burndown and Velocity), bug and issue data. New reports can be created using Report Builder for SSRS and any of the existing reports can be modified.
 
More specialized reporting is available for load test results. This data is available directly within Visual Studio and can be exported to Excel for detailed analysis.
 
TFS 2013 introduced a new feature called "light-weight reporting" which provides for the ability to create real-time reports based on query results and which do not rely on the warehouse or cube. TFS 2012 (and continuing into 2013) offers real-time burndown, velocity and CFD diagrams directly within Team Web Access.
 
==Team Build==
Team Build (prior to TFS 2015) is a build server application included with Team Foundation Server. Two components make up Team Build – [[MSBuild]] and [[Windows Workflow Foundation]]. MSBuild is a declarative XML language similar to [[Apache Ant]]. WF was added to the build process starting with TFS 2010; prior to that only MSBuild was available. The build capabilities have continued to evolve with each subsequent release of Azure DevOps. In TFS 2010 and 2012, the WF templates ([[XAML|Extensible Application Markup Language]]) files were stored in source control and could be edited and versioned directly from source control. In TFS 2013, these files were removed to eliminate clutter and streamline the build process. The WF templates can still be downloaded, edited and stored in source control if desired and TFS 2013 does not break existing TFS 2010 or 2012 build process templates. With the support of [[Git (software)|Git]] in TFS 2013, Team Build has been enhanced to allow automated building of Git projects as well as TFVC projects.
 
Windows Workflow controls the overall flow of the build process and Azure DevOps includes many pre-built workflow activities for managing common tasks that are performed during a build.<ref>{{cite web
|publisher=Microsoft
|year=2013
|url=http://msdn.microsoft.com/en-us/library/vstudio/gg265783.aspx
|title=Team Foundation Build Activities
|access-date=2013-10-17
}}</ref> MSBuild is the markup language that is found in the .proj (csproj for C# projects and vbproj for Visual Basic projects) files. The build system is extensible with users being able to create their own workflow activities, the ability to inject MSBuild into the process and to execute external processes. The workflow nature of the build allows for unlimited flexibility, but it may take some work to achieve that flexibility. Shared<ref>{{cite web
|publisher=Codeplex
|year=2013
|url=http://tfsbuildextensions.codeplex.com/
|title=Community TFS Build Extensions
|access-date=2013-10-17
|archive-date=2013-10-11
|archive-url=https://web.archive.org/web/20131011050816/http://tfsbuildextensions.codeplex.com/
|url-status=dead
}}</ref> and open source projects have been started to build community backed activities to enhance the capabilities of Team Build.
 
The build process can be configured for various types of builds including scheduled builds, [[continuous integration]], gated check-in and rolling builds. A gated check-in build will shelve code that a developer checks in, perform a "get latest" on the server code and perform a build. If the build succeeds, the code is checked in on behalf of the developer who submitted the code. If the build fails, the developer is notified and can fix the code before trying another check-in.
 
Builds have retention policies with them so that they do not accumulate when not needed (or builds can be directed not to produce any saved output) or build output can be locked and saved forever. New with TFS 2013 is the ability to check in the build results into source control. This was a necessary enhancement to support automated builds on the Azure DevOps Services where there is no drop ___location to place the builds. In the on-premises version build output can be configured to end up in any accessible shared folder ___location.
 
The build process in Azure DevOps is also part of the traceability mechanism in that Team Build brings together many of the artifacts that are created and stored in Azure DevOps. Assuming developers associate source code with work items on check-in, Team Build has the ability to report on the changes in each build – both source code changes and work item changes as well as test results (this includes [[unit testing]] results as well as automated functional testing (CodedUI) results). As bugs and [[Scrum (software development)#Product backlog|PBIs]] are resolved and integrated into builds, the work items which track these artifacts are automatically updated to indicate in which build they were successfully integrated. Combined with the testing tools, testers then get an integrated view of what code was changed in each build, but also which bugs, [[Scrum (software development)#Product backlog|PBIs]] and other work changed from build to build.
 
Initially, in TFS 2015 and with Visual Studio Team Services (VSTS), Microsoft has reinvented the architecture for the build engine to be based on a cross-platform friendly Node.js application. Windows, Mac, and Linux build agents are currently supported. Azure DevOps provides for elastic build capabilities via build hosting in Microsoft Azure.<ref>{{cite web
|publisher=Microsoft
|year=2016
|url=https://azure.microsoft.com/
|title=Microsoft Azure - Portal
|access-date=2016-05-17
}}</ref>
 
==Release management==
In mid-2013 Microsoft purchased a product called InRelease from InCycle Software.<ref>{{cite web
|publisher=The Next Web
|year=2013
|url=https://thenextweb.com/microsoft/2013/06/03/microsoft-acquires-inrelease-adding-continuous-deployment-to-visual-studio-team-foundation-server/
|title=Microsoft acquires InRelease, adding continuous deployment to Visual Studio, Team Foundation Server
|access-date=2013-11-15
}}</ref> InRelease was fully incorporated into Team Foundation Server 2013. This capability complemented the automated build and testing processes by allowing a true [[continuous delivery|continuous deployment]] solution. The tools were re-branded "Release Management" for TFS 2013. The Release Management capabilities give teams the ability to perform a controlled, workflow (provided by [[Windows Workflow Foundation]]) driven release to development, test and production environments and provides dashboards for monitoring the progress of one or more releases.
 
Microsoft has rebuilt Release Management for Visual Studio Team Services and on-premises version of TFS with the new changes in 2015 Update 2. The new version of Release Management leverages the web browser as the client and relies on the same agent architecture as Team Foundation Build. Release Management enables [[DevOps]] capabilities for Azure DevOps.
 
== History ==
This first version of Team Foundation Server was released March 17, 2006.<ref>{{cite web |last=Taft |first=Darryl K. |date=2006-03-16 |url=https://www.eweek.com/development/microsoft-announces-release-of-team-foundation-server |title=Microsoft Announces Release of Team Foundation Server |department=Development |website=[[eWeek]] |publisher=[[Ziff Davis]] |access-date=2019-10-13 |df=mdy}}</ref>
{| class="wikitable sortable"
|-
!Product name
!Form
!Release year
!Version Number <ref>{{Cite web|last=kexugit|title=What version of Team Foundation Server do I have?|url=https://docs.microsoft.com/en-us/archive/blogs/tfssetup/what-version-of-team-foundation-server-do-i-have|access-date=2020-08-26|website=docs.microsoft.com|date=21 November 2013 |language=en-us}}</ref><ref>{{Cite web|last=|title=Azure DevOps Feature Timeline|url=https://docs.microsoft.com/en-us/azure/devops/release-notes/features-timeline#azure-devops-server-build-numbers|access-date=2021-02-15|website=docs.microsoft.com|language=en-us}}</ref>
|-
|Team Foundation Server 2005
|On-premises
|2006
|8
|-
|Team Foundation Server 2008
|On-premises
|2008
|9
|-
|Team Foundation Server 2010<ref>{{cite web |url=https://news.microsoft.com/2008/09/29/microsoft-unveils-next-version-of-visual-studio-and-net-framework/ |title=Microsoft Unveils Next Version of Visual Studio and .NET Framework |website=Company News |publisher=[[Microsoft]] |date=2008-09-29 |access-date=2019-10-13 |df=mdy}}</ref>
|On-premises
|2010
|10
|-
|Team Foundation Service Preview
|Cloud
|2012
|
|-
|Team Foundation Server 2012
|On-premises
|2012
|11
|-
|Visual Studio Online<ref>{{cite web |first=Peter |last=Bright |date=2013-11-12 |url=https://arstechnica.com/information-technology/2013/11/microsoft-takes-development-into-the-cloud-with-visual-studio-online/ |title=Microsoft takes development into the cloud with Visual Studio Online |department=Information Technology |website=[[Ars Technica]] |publisher=[[Condé Nast]] |access-date=2019-10-13 |df=mdy}}</ref>
|Cloud
|2013
|
|-
|Team Foundation Server 2013
|On-premises
|2013
|12
|-
|Team Foundation Server 2015
|On-premises
|2015
|14
|-
|Visual Studio Team Services
|Cloud
|2015
|
|-
|Team Foundation Server 2017
|On-premises
|2017
|15
|-
|Team Foundation Server 2018
|On-premises
|2017
|16
|-
|Azure DevOps Services<ref>{{cite web |last=Cool |first=Jamie |date=2018-09-10 |url=https://azure.microsoft.com/en-us/blog/introducing-azure-devops/ |title=Introducing Azure DevOps |department=Blog |website=[[Microsoft Azure]] |publisher=[[Microsoft]] |access-date=2019-10-13 |df=mdy}}</ref>
|Cloud
|2018
|
|-
|Azure DevOps Server 2019<ref>{{cite web |last=Mackie|first=Kurt |date=2019-03-05 |url=https://azure.microsoft.com/en-us/blog/now-available-azure-devops-server-2019/ |title=Now available: Azure DevOps Server 2019 |department=Blog |website=[[Microsoft Azure]] |publisher=[[Microsoft]] |access-date=2019-10-13 |df=mdy}}</ref>
|On-premises
|2019
|17
|-
|Azure DevOps Server 2020
|On-premises
|2020
|18
|-
|Azure DevOps Server 2022<ref>{{cite web |last=Morales|first=Gloridel |date=2022-12-06 |url=https://devblogs.microsoft.com/devops/now-available-azure-devops-server-2022-rtw/ |title=Now available: Azure DevOps Server 2022 RTW |department=Blog |website=Azure DevOps Blog |publisher=[[Microsoft]]}}</ref>
|On-premises
|2022
|
|}
 
==See also==
* [[Comparison of version-control software]]
* [[Comparison of issue-tracking systems]]
* [[Microsoft Teams]]
* [[Microsoft Visual SourceSafe]] (VSS)
* [[List of version-control software]]
* [[Rational Team Concert]]
* [[SVNBridge]], a Windows client or server side extension to TFS that allows access to TFS revision controlled items from [[Subversion (software)|Subversion]] client applications.
 
==References==
{{Reflist|30em}}
 
==External links==
* {{Official website}}
{{Version control software}}
{{Microsoft Azure Services Platform}}
{{Microsoft}}
[[Category:Proprietary version control systems]]
[[Category:Microsoft Visual Studio]]
[[Category:Agile software development]]
[[Category:Project management software]]
[[Category:Build automation]]
[[Category:Unit testing frameworks]]
[[Category:Web applications]]
[[Category:Code search engines]]
[[Category:Collaborative software]]
[[Category:Continuous integration]]
[[Category:Project hosting websites]]
[[Category:Bug and issue tracking software]]
[[Category:Distributed bug tracking systems]]
[[Category:Software using distributed version control]]
[[Category:Software testing tools]]
[[Category:Load testing tools]]
[[Category:Java development tools]]
[[Category:Task management software]]