TechPrufer
Get started
Microsoft
Microsoft logoMicrosoft · Feature trail

Azure Pipelines Agent Operating System Support

42 posts · Mar 2012 – Apr 2025

What this trail covers

Azure Pipelines continues to enhance its deployment capabilities with updates to hosted agent images and the introduction of agent-based deployments. Agent-based deployment allows for direct installation of agents on target servers, enabling rolling updates and high availability. Deployment groups logically group targets, representing physical environments and specifying security contexts. Bootstrapping agents is simplified with cmdlets, and integration with Azure resources is planned. This evolution now includes support for building and testing Windows 8 "Metro Style" applications using Team Foundation Build 2011 Express, requiring specific configurations for developer licenses, build service interactivity, and the handling of .appx package formats for test execution.

All Microsoft trails
  1. April Patches for Azure DevOps Server and Team Foundation ServerThis patch addresses the migration of the Azure DevOps Agent from the `vstsagentpackage.azureedge.net` endpoint (backed by Edgio CDN) to a new Akamai-backed CDN endpoint `download.agent.dev.azure.com` due to the decommissioning of the former. This ensures continued availability of Agent binaries for Azure DevOps Server and Team Foundation Server.
  2. CDN Domain URL change for Agents in PipelinesThis post announces a change in CDN providers for Azure DevOps Pipelines agent packages, transitioning from Edgio CDN to Akamai and Azure Front Door. It details the impact on customers using self-hosted agents, Azure Virtual Machine Scale Set agents, and Managed DevOps Pools agents. The core technical contribution is the guidance on updating firewall allow lists to include the new domain URL (https://download.agent.dev.azure.com) and the provision of a test pipeline script to verify network accessibility. It also outlines specific patch requirements for various Azure DevOps Server versions to manage the CDN retiral.
  3. Announcing the General Availability of Managed DevOps Pools (MDP) for Azure DevOpsThis post announces the General Availability of Managed DevOps Pools (MDP) for Azure DevOps. Key new features introduced include: support for new Azure regions (Sweden Central, Brazil South, Japan East, UAE North, Korea Central, and Norway East), easier discoverability from the Azure DevOps "Add agent pool" UI, proxy support for network traffic, visibility of agent IP addresses in pipeline logs, the ability to move pools to different resource groups or subscriptions, Ubuntu 24.04 support (via marketplace images and BYO), and the ability to add secrets from Azure Key Vault using a Managed Identity. Future plans include container-based agents, SPOT VMs support, managed data disk support, trusted root certificate addition, faster pipeline starts, and Log Analytics integration.
  4. Announcing Public Preview of Managed DevOps Pools (MDP) for Azure DevOpsThis post announces the public preview of Managed DevOps Pools (MDP) for Azure DevOps. MDP is a fully managed service that allows teams to create custom DevOps pools, combining the flexibility of VM Scale Set agents with the ease of maintenance of Microsoft-hosted agents. It reduces management overhead, enables specific pools for workloads, optimizes billing, and scales to thousands of agents. Key features highlighted include quick-starter images, standby agents, private networking, BYO images, stateful agents, flexible SKU selection, additional storage, and geographic co-location. The service is hosted on Microsoft-owned Azure subscriptions, reducing the burden on customer subscriptions.
  5. End of support for Azure Pipelines agents running on CentOS 6, Debian 4.9, Fedora 32, Ubuntu 16, macOS 10.14, and older versionsThis post details the end-of-support for Azure Pipelines agents on specific older operating systems (CentOS 6, Debian 4.9, Fedora 32, Ubuntu 16, macOS 10.14) due to the agent's upgrade to .NET 6. It outlines the failure message users will encounter and provides two options: migrating agents to newer OS versions or setting the `AGENT_ACKNOWLEDGE_NO_UPDATES` environment variable. It also includes instructions on how to set this variable via environment configuration or pipeline variables (YAML and classic). Additionally, it offers a script to identify incompatible agents and clarifies the impact on Azure DevOps Server.
  7. Node runner update guidance for Azure Pipelines task authorsThis post provides guidance for Azure Pipelines task authors on updating their tasks to support the Node 16 runner. It explains the Node runner lifecycle, the upcoming removal of EOL Node versions from release feeds and hosted agents, and the potential for tasks not updated to fail. It details how to update `task.json` to include multiple execution sections for Node 10 and Node 16, and advises task authors to test their tasks across different Node runner versions.
  8. Safely Upgrade Your Pipelines from Azure DevOps Server 2019 to Server 2020This post details a critical upgrade path for Azure DevOps Server 2019 to 2020, specifically addressing the significant changes in the build retention model. It explains the limitations of the 2019 model (pipeline-level settings, difficulty inferring retention reasons) and the improvements in the 2020 model (project-level settings, retention leases for explicit reasons). The post provides a step-by-step guide to safely upgrade by disabling the new retention model on Server 2019, backing up the database, upgrading to Server 2020, creating leases for important pipeline runs, re-enabling the new retention model, and removing pipeline-specific retention policies. It also includes an FAQ addressing retention behavior when the new model is off and the fate of manually retained runs.
  9. Hosted Pipelines Image DeprecationThis post details the deprecation and upcoming retirement of specific hosted pipeline images: `ubuntu-16.04`, `macOS-10.14`, `vs2017-win2016`, and `windows-latest` (which will soon reference `windows-2019`). It provides YAML snippets for updating pipelines to use newer images like `macOS-10.15`, `macOS-11`, `ubuntu-18.04`, `ubuntu-20.04`, `windows-2019`, and `windows-2022`. It also outlines methods for identifying pipelines using deprecated images, including checking agent queues in Azure DevOps and using a PowerShell script to query job history. Migration advice includes switching to `windows-2019` or upgrading Visual Studio projects.
  10. On Prem To the Cloud: Let's Rub Some DevOps On It! (Ep 3)This post demonstrates how to apply DevOps practices, specifically CI/CD pipelines using Azure Pipelines and GitHub Actions, to a "legacy" application that has been migrated to the cloud. It details the process of configuring a YAML pipeline for continuous integration (building, testing, packaging) and continuous deployment (deploying to virtual machines). Key tasks highlighted include using the 'Publish Pipeline Artifact' task, setting up 'Environments' in Azure Pipelines with VM resources, and deploying applications using the 'Deploy SQL Dacpac Deployment Group' and 'IIS Web Application Deployment' tasks. For GitHub Actions, it notes the use of self-hosted runners and the need to find alternative actions for IIS and DACPAC deployment.
  11. Azure Pipelines hosted pools updatesThis post announces upcoming changes to Azure Pipelines hosted images between January and March 2020. It details the update of `ubuntu-latest` to `ubuntu-18.04`, the introduction of `macOS-10.15` and the update of `macOS-latest` to `macOS-10.15`, and the removal of specific older images (`vs2015-win2012r2`, `macOS-10.13`, `win1803`) to facilitate the rollout of newer versions.
  12. Removing older images in Azure Pipelines hosted poolsThis post announces the removal of specific older hosted images in Azure Pipelines: Windows Server 2012R2 with VS 2015 (`vs2015-win2012r2` or `Hosted`), macOS High Sierra 10.13 (`macOS-10.13`), and Windows Server Core 1803 (`win1803`) effective March 23, 2020. It provides migration guidance for users of these images, including updating YAML pipelines, using newer Visual Studio images (`vs2017-win2016`, `windows-2019`), or setting up self-hosted agent pools. The removal of `vs2015-win2012r2` was delayed to March 31, 2020, and the `Hosted` agent pool is redirected to `vs2017-win2016`. The post also details the introduction of `macOS-10.15` (Catalina) and the deprecation of Xcode versions older than 9.4.1. Brownout schedules are announced to highlight builds using these soon-to-be-removed images.
  13. Hosted Pipelines Announcements: VS 2019, Mojave, and moreThis post announces the availability of a new hosted image for Azure Pipelines based on Windows Server 2019, including the Visual Studio 2019 Preview. It also details the upgrade of Hosted macOS pools to OS X 10.14 (Mojave), noting that Xcode versions prior to 9.4.1 will no longer be supported. The post outlines future plans for hosted agents, such as aligning image updates with sprint cycles, enabling image version rollback, and adding support for Ubuntu 18.04 and Server Core 1809 for Windows Container scenarios. It also mentions an investigation into improving OS drive speeds. A workaround for a known issue with .NET Core 3 installer and VS 2019 Preview is provided.
  14. Cross-Platform Container Builds with Azure PipelinesThis post details how to configure Azure Pipelines to use custom Docker containers for build jobs. It provides a step-by-step guide on creating a Dockerfile with necessary dependencies (e.g., `yum install` for CentOS), building the Docker image, pushing it to a registry (Docker Hub), and then referencing it in the `azure-pipelines.yml` file using the `resources.containers` and `container` syntax. It also demonstrates how to map local directories to container directories for source and binary access, and how to share build scripts between local and CI environments. A specific example of building libgit2 on CentOS with updated libssh2 is provided to illustrate troubleshooting and dependency management within containers.
  15. Top 5 Open Source Features in Azure PipelinesThis post details how the libgit2 open-source project uses Azure Pipelines for its CI/CD. It highlights the ability to build on multiple platforms (Linux, Windows, macOS) within a single service, the free tier offering unlimited build minutes and 10 parallel pipelines for open-source projects, the capability to schedule builds for less frequent platforms, and the publishing of test results with visualizations. It also discusses the use of build badges for project health visibility.
  16. Azure DevOps Agents on Azure Container Instances (ACI)This post introduces a solution for running Azure DevOps agents on Windows Server Core containers hosted on Azure Container Instances (ACI). This approach offers scalability, customization (installing specific tools like Terraform, json2hcl, and PowerShell modules), and enhanced security (no public IPs, no exposed ports, no interactive logons) compared to Microsoft-hosted agents or traditional IaaS VMs. It details three PowerShell scripts for initialization, installation, and removal, and outlines prerequisites and lifecycle management.
  17. Xcode 8.0-8.3.2 deprecation on Azure Pipelines hosted agentsAnnounces the deprecation of Xcode versions 8.0 through 8.3.2 on Microsoft-hosted Azure Pipelines agents, effective November 28, 2018. Recommends updating pipelines to use Xcode 8.3.3 or higher. Notes that self-hosted agents are not affected. Provides guidance on how to change the Xcode version in pipeline settings or via `xcode-select`.
  18. Deployment Groups is now generally available: sharing of targets and more...Announces the general availability of Deployment Groups in Release Management for VSTS/TFS. Highlights key features such as multi-machine deployment orchestration, rolling updates, on-premises and cloud deployment targets, end-to-end traceability, and agent-based deployment leveraging the full task catalog. Introduces new capabilities including shared deployment targets across team projects, new release definition templates for IIS and SQL deployments, and enhanced VM provisioning via the Azure Resource Group task and portal. Provides links to documentation and quick starts for getting started.
  19. January 2018 VSTS Hosted Agent Image UpdatesThis post details the January 2018 updates for Azure Pipelines hosted agent images. Key updates include disabling the IE Welcome Screen, adding .NET Core SDK 2.1.4, updating Node.js to 8.9.1, and upgrading Visual Studio to 15.5.3 with additional components like Windows 8.1 SDK, Native Desktop SDKs, Blend SDK for WPF, and .NET Framework 4.6.2 and 4.7.1 developer tools and SDKs. It also adds the Wix Vsix extension, updates SSDT to 15.5.1, includes Android components (platform-27, build-tools 27.0.1, add-ons), adds Azure PowerShell 5.1.1, and extends JAVA_HOME variables for Java 8 and 9. The Linux agent image sees an update to the Docker daemon to 17.12.
  20. Sharing of Deployment Groups across projectsThis post introduces the ability to share Deployment Groups across Azure DevOps projects. Previously, Deployment Groups were scoped to a single project. Now, by exposing the underlying 'Deployment Pool' concept, users can share deployment targets (IaaS machines) across multiple projects. This addresses scenarios like branch offices or enterprise environments where multiple applications are installed on the same machine, or where a central admin manages resources consumed by project users. The post details the conditions for sharing a Deployment Pool and provides a step-by-step guide on how to share a Deployment Group between projects.
  21. Using the latest NuGet in your buildThis post addresses the challenge of using newer versions of NuGet (4.1+) with Team Build in Visual Studio Team Services (VSTS) and Team Foundation Server (TFS). It introduces the 'NuGet Tool Installer' task for VSTS and TFS 2017 Update 3+, which automatically installs the required NuGet version. For older TFS versions (TFS 2017 Update 2 and earlier), a workaround involving a PowerShell script to fetch and use a specific NuGet version before the 'NuGet Restore' or 'NuGet' task is provided. This ensures compatibility with new .NET Core and .NET Standard project types and meets the NuGet.org protocol version requirement for pushing packages.
  22. Deploy Visual Studio Test Agent Task – Test Machine Rebooting ScenariosThis post addresses specific scenarios related to the Deploy Visual Studio Test Agent (DTA) task in TFS/VSTS, focusing on test machine rebooting and auto-logon requirements for UI tests. It details how the DTA task enables auto-logon by modifying registry keys when disabled locally, but notes that Group Policies can override this. The post highlights issues with legal notices/logon banners causing auto-logon failures and introduces a reboot cap of 3 in newer versions (VSTS, TFS 2015 Update 4 & TFS 2017 Update 2 onwards) to prevent infinite reboots. It also details warning messages provided by the DTA task when policies or registry entries might hinder auto-logon, and answers common questions regarding reboots, auto-logon necessity, and troubleshooting repeated reboots.
  23. Announcing public preview of the new Deployment Groups in Release ManagementThis post announces the public preview of Deployment Groups in Visual Studio Team Services (VSTS) Release Management. Deployment Groups are introduced as a new feature to orchestrate multi-machine deployments, perform rolling updates while ensuring high availability, and represent physical environments (Dev, QA, UAT/Prod). Getting started involves creating a Deployment Group in the 'Build & Release' hub, adding servers by running a cmdlet, and using in-the-box templates for deployments. Servers can be tagged for rolling deployments, and live logs are available for each server.
  24. Using 'Visual Studio Agent Deployment' task on machines not connected to the internetThis post details how to deploy and configure Visual Studio Test Agents on machines that are not connected to the internet. It provides specific instructions for Test Agent 2015, requiring manual download and sharing of the installer. For Test Agent 2017, it introduces PowerShell scripts and manual steps to create an offline installer package (TestAgent.zip) that can be shared via a UNC path. It also notes that for Azure machines, agents are downloaded from the internet by default, and recommends pre-installing Test Agents on VM images for faster configuration. Finally, it recommends installing the latest Windows Management Framework on test agent machines.
  25. Building Your App in a CI Pipeline with Customized Build Servers (Private Agents)This post details how to set up and use private build agents in Azure Pipelines (formerly Visual Studio Team Services) to overcome limitations of hosted agents, particularly for builds requiring custom tools or specific software versions. It highlights benefits such as dependency caching (NuGet, Maven), incremental builds, and faster machines. The post provides links to documentation for deploying agents on Windows, macOS, and Linux, as well as Docker images. It also emphasizes the use of Azure DevTest Labs for managing agent pools and controlling costs, and outlines the process of creating a Personal Access Token (PAT) for agent registration. Finally, it explains how to configure build definitions to use private agent pools and demonstrates how to verify that builds are running on private agents.
  26. Deploying to On-Premises Environments with Visual Studio Team Services or Team Foundation ServerThis post details how to use Visual Studio Team Services (VSTS) or Team Foundation Server (TFS) to deploy to on-premises environments by leveraging private agents. It explains the communication model between agents and VSTS/TFS, the requirement for agents to have line-of-sight connectivity to target servers, and the setup process for private agents, including authentication via Personal Access Tokens (PATs) and agent pooling. The post provides links to documentation for deploying agents on Windows, macOS, and Linux, and outlines how to configure release pipelines to use on-premises agent pools for deployment.
  27. Monitoring build resources with the TFS 2017 management packThis post announces that the TFS 2017 management pack no longer supports monitoring of build resources (XAML controllers/agents, Build/Release agents). It details the historical approaches to build resource monitoring within TFS management packs and explains the decision to abandon this in TFS 2017 due to complexity and the availability of equivalent monitoring in System Center. The post provides a recommended approach for monitoring build resources using System Center's built-in capabilities: monitoring machine availability, creating Windows Service monitors for XAML build resources (e.g., TFSBuildServiceHost.2013), and creating process monitors for Build/Release resources (e.g., Agent.Listener.exe) with specific machine groups. This new approach allows for monitoring interactive agents, Linux agents, and setting custom thresholds for CPU/memory consumption.
  28. VSTest task dons a new avatar - testing with unified agents and phasesThis post introduces the unification of build, release, and test agents in Azure Pipelines, allowing for reusable agent pools across all pipeline types. It details the advantages of this unified approach, including reduced infrastructure management, support for single and multi-machine distributed execution, and the elimination of the 'Deploy Test Agent' step. The post specifically highlights the capabilities of the VSTest task v2, explaining its support for agent phases with 'None', 'Multi-agent', and 'Multi-config' modes. 'Multi-agent' mode enables distributed test execution across multiple agents, while 'Multi-config' mode allows for running tests across different configurations (e.g., browsers) using multipliers. The post also clarifies that the Run Functional Tests (RFT) task remains unchanged and requires separate agent deployment.
  29. Agent-based deployment in Release ManagementThis post introduces agent-based deployment in Release Management, a new capability for orchestrating multi-machine deployments and performing rolling updates with high availability. It defines 'Deployment Groups' as logical groupings of target machines with agents installed directly on them, representing physical environments. The post details the process of creating deployment groups, authoring release definitions with various deployment configuration options (one target at a time, half, all, custom), and viewing live logs during deployment. It also highlights simplified agent bootstrapping via cmdlets and planned enhancements for Azure resource integration.
  30. JBoss and WildFly extension for Visual Studio Team ServicesThis post introduces a new extension for Visual Studio Team Services / Team Foundation Server that enables the deployment of Java applications to JBoss EAP 7 or WildFly Application Server 8 and above. The extension provides a task for deployment over the HTTP management interface and a utility to run CLI commands as part of the build/release process. The extension is open-sourced on GitHub.
  31. December Hosted Build Image UpdatesThis post announces updates to the hosted build image for Azure Pipelines, including the addition of .NET Core 1.1, Android SDK v25, Azure CLI 0.10.7, Azure PS 3.1.0, Azure SDK 2.9.6, Cmake 3.7.1, Git for Windows 2.10.2, Git LFS 1.5.2, Node 6.9.1, Service Fabric SDK 2.3.311, Service Fabric 5.3.311, and Typescript 2.0.6 for Visual Studio 2015. It also notes permission changes to allow building of .NET 3.5 ASP.NET Web Forms projects.
  32. Agent-based deployment in Release ManagementThis post introduces agent-based deployment for Release Management, which relies on the same build and deployment agents. It enables orchestrated deployments across multiple nodes, performing rolling updates while ensuring high availability of the application throughout. The post also references a follow-up post on Deployment Groups for the latest information.
  33. New .NET Core Build Agent on Hosted Pool – Some builds may require reactionThis post announces the rollout of a new .NET Core-based build agent to the hosted pool on VSTS. This agent is open-source and provides feature parity across supported platforms. A key change is the reversion to using server workspaces for TFVC-based repositories to improve stability and scale, addressing issues encountered with local workspaces in the previous agent. Builds that modify checked-in files without marking them as editable will now encounter errors and require explicit marking using 'attrib -r <filename>' before modification.
  34. Deploying an Azure Red Hat Linux VM Running Apache Tomcat for use with Visual Studio Team Services and Team Foundation ServerThis post details the setup and configuration of an Azure Red Hat Enterprise Linux (v. 7.2) VM running Apache Tomcat. It provides step-by-step instructions for installing Apache Tomcat, configuring it with mod_jk for integration with Apache HTTP Server, and setting up SSH and FTP for deployment from Visual Studio Team Services and Team Foundation Server. It also highlights an Azure QuickStart ARM template for rapid deployment.
  35. Deploying an Azure Ubuntu Linux VM Running Apache Tomcat for use with Visual Studio Team Services and Team Foundation ServerThis post details the setup and configuration of an Azure Ubuntu Linux VM running Apache Tomcat to support deployment tasks from Visual Studio Team Services and Team Foundation Server. It covers creating the VM in Azure, installing Apache Tomcat, configuring services like mod-jk, and setting up inbound security rules for traffic. It also introduces three distinct deployment methods: the Apache Tomcat Deployment task, the Copy Files over SSH task, and the FTP Upload task, providing a walkthrough for each.
  36. July Hosted Build Pool Image UpdatesThis post announces updates to the hosted build pool image for Azure Pipelines, including the addition of .NET Core 1.0 (Preview 2 tooling), Visual Studio 2015 Update 3, June 2016 SSDT for Visual Studio 2015, Lets Encrypt root certificates to the JDK certificate store, and Azure Service Fabric SDK 2.1. It also notes a side-by-side issue with Service Fabric SDK version 2.0 that requires updating to 2.1, and updates to Android support repository (version 30) and Google Repository (version 29). A link to the full software list is provided.
  37. UrbanCode Deploy build extension for Team ServicesThis post introduces a new Azure Pipelines build extension for integrating with IBM UrbanCode Deploy. It provides a dedicated build task for deploying artifacts as UrbanCode Deploy Component Versions, establishing traceability links back to the VSTS builds. For more advanced integration, it offers the IBM UrbanCode Deploy Client (udclient) build task to execute arbitrary udclient commands. The source code for this extension is open-sourced on GitHub.
  38. Hosted Build Pool Images UpdatesThis post announces an update to the hosted build pool images, specifically adding .NET Core RC2 Tooling and Service Fabric runtime, SDK, and tools for Visual Studio 2015. It directs users to a documentation link for a full list of software updates.
  39. Hosted Build Pool Image UpdatesThis post announces an update to the hosted build pool image, including Visual Studio 2013 Update 5, Node.JS 5.11.0, NPM 3.8.6, Azure Powershell and Azure RM Powershell 1.3.2, ANT 1.9.7, Cordova 6.1.0, and Typescript 1.8.6 for Visual Studio 2013 and 2015.
  40. Cloud Foundry build extension for Team ServicesIntroduced a Cloud Foundry build extension for Team Services, available on the Visual Studio Team Services Marketplace. This extension provides a build task for deploying applications to any Cloud Foundry instance and a utility task for executing Cloud Foundry CLI commands within build/release processes. The extension is open-sourced.
  41. Release Management planning update - 2016 H2This post details plans for 2016 H2, focusing on simplifying application deployment in Release Management. Key enhancements include agent-based deployment to machine groups, which will deprecate the current concept of machine groups in the Test Hub and introduce a more robust multi-machine deployment capability by installing agents directly on target servers. This will simplify prerequisites, improve scalability for rolling and canary deployments, ease Linux server deployment, and provide better traceability. Azure deployments are being simplified by using ARM endpoints, webdeploy, tokenization, and integrating continuous deployment from the Azure portal. Support for Docker and Windows container deployments is planned via Marketplace extensions. Release orchestration will be enhanced with manual intervention steps, meta-tasks for reusable task sequences, folders and favorites for organizing release definitions, and audit history for releases. Package management integration will be expanded to support consuming feeds from package management services and direct deployment from code repositories like Git and TFVC.
  42. CI Experience FuturesThis post details upcoming investments in Azure Pipelines' CI experience. Key areas of focus include: missing features for parity with XAML builds (label sources, associate work items, gated builds for TFVC), improved build resource management and visibility (agent pooling, access control on build queues), enhanced visibility into build quality and test results (front-and-center test failures, richer code coverage reports for Ant/Maven and VS engine), build extensibility improvements (Markdown summaries, VSO App Extensions for build tasks and summary tabs), and cross-platform support (reducing the gap for xplat agents, Subversion support). The web-based build experience is also being refined.
  43. Speeding up Unit Test Execution in TFSThis post details techniques for speeding up unit test execution within TFS builds. It covers two primary methods: maximizing hardware resource utilization through parallel test execution within a single machine (e.g., using TestNG's multi-threading capabilities) and distributing test runs across multiple machines by dividing tests into logical sets and configuring TFS build definitions for multi-configuration parallel execution. Examples are provided for both C# and Java test scenarios.
  44. Announcing Octopus Deploy integration for Visual Studio OnlineThis post announces the integration of Octopus Deploy with Visual Studio Online's new build system (Build vNext). It details the creation of a custom build step and a PowerShell script that allow users to create Octopus Deploy releases as a separate step in their build definitions. The custom build step offers a UI and includes release notes pulled from changesets and work items. The integration enables separation of build and deploy phases, with OctoPack still used for packaging and pushing NuGet packages.
  45. Testing in Continuous Integration and Continuous Deployment WorkflowsThis post details the setup and configuration of automated testing within Continuous Integration (CI) and Continuous Deployment (CD) workflows using Visual Studio Online (VSO) and Team Foundation Server (TFS) 2015 RC. It outlines the steps for setting up build and unit test tasks, provisioning machines for application deployment and testing, configuring deployment and remote test execution tasks (including PowerShell scripts, file copying, and Visual Studio Test Agent deployment), and queuing builds with test result analysis. The post emphasizes the extensibility of the build framework, the ability to reuse assets across CI and release management, simplified machine provisioning, distributed test execution, and rich test reporting.
  46. Build FuturesThis post announces a significant revision to the build automation system for TFS and Visual Studio Online, moving away from the Windows Workflow Foundation (XAML builds) to a new system designed with principles of avoiding new DSLs, cross-platform support, intentional extensibility, and transparent build logs. The new system will be available in TFS 2015 and Visual Studio Online in Q2 2015. Key highlights include easy customization via build steps and custom tasks, real-time web visibility of builds, cross-platform build capabilities for iOS, Android, Java, and Linux, and build definition diffing/auditing. Existing XAML builds will continue to be supported alongside the new system during the transition.
  47. Deploy automatically to virtual machines in Windows Azure using Visual Studio Release ManagementThis post details the configuration of Visual Studio Release Management for continuous deployment to virtual machines in Windows Azure. It outlines the steps for setting up a proxy Release Management Deployer, installing Azure PowerShell cmdlets and the .NET SDK, configuring Azure credentials, and linking subscriptions. It also explains how to configure Release Management servers and components for Azure VMs, including starting and stopping VMs as part of release stages and managing drop location access. The post provides specific examples of release template configurations for development, QA, and production stages, highlighting the use of configuration variables for Azure VM actions.
  48. Get started with some basic TFBuild scriptsThis post introduces the capability to execute custom batch (.bat) and PowerShell scripts within the Team Foundation Build (TFBuild) process in Visual Studio and Team Foundation Server 2013. It provides two example scripts: 'ApplyVersionToAssemblies.ps1' to version assemblies before compilation and 'GatherItemsForDrop.ps1' to prepare binaries for staging after compilation. The post also details how to reference these scripts from the build definition, explains the environment variables available to scripts, and offers debugging tips.
  49. Team Building your windows 8 Metro style Applications.This post details the process of building and testing Windows 8 "Metro Style" applications using Team Foundation Build 2011 Express. It outlines the necessity of a Windows 8 machine for building these applications, the limitations of the Team Foundation Service build hosted service for this task, and the steps for acquiring a developer license. It also covers configuring the on-premise Team Foundation Build server to run interactively for test execution, creating and checking in Metro Style projects with their associated .pfx files, and installing these certificates on build machines. Crucially, it explains how to modify the build definition's automated test configuration to correctly identify and run tests packaged as .appx files instead of the traditional .dll pattern.
  50. Build on the Team Foundation ServiceIntroduced the 'Hosted Build Controller' for Team Foundation Service Preview, enabling users to leverage cloud-based build machines without local setup. This feature supports Visual Studio 2010 SP1 and Visual Studio 11 Beta. It also details how to integrate custom unit testing frameworks (e.g., xUnit) by checking in necessary DLLs and configuring the build controller's custom assembly path. Output drops are stored in source control under $/teamproject/drops.