Continuous Delivery with TFS: Save to a Folder for Stages You Can’t Yet Deploy to

In previous posts in this blog series on continuous delivery with TFS, our activities have been geared up to deploying the sample application to target servers – or nodes as they are sometimes referred to. But what happens when for some reason you have an environment that’s just not ready to be a target for automated deployment? Maybe the business is just not ready to go that far right now. Maybe there is some technical hurdle you have yet to overcome. On the other hand, you have already experienced how easy it is to manage the configuration of your application with Release Management and how it can bring config order where once there was chaos.

If you find yourself in this position, a possible interim solution is to use Release Management to create what I call Release Ready Builds™ of your application. These are builds which have the correct configuration for the environment they are destined for but which are saved to a staging disk location rather than being actually deployed to target servers. Deployment of these builds is still likely to be a manual process but that’s probably what you are doing already and at least the configuration and any other jiggery-pokery can be taken care of by Release Management.

Create a New Stage

In order to illustrate this technique, I’m going to add a new stage to the deployment pipeline called PRD. This will represent the production environment that for whatever reason I’m unable to deploy to using Release Management automation. Carry out the following in Release Management:

1. Add a stage type called PRD from Administration > Manage Pick Lists > Stage Type.
2. Create a new Agent-based environment called Contoso University\PRD from Configure Paths > Environments. I linked my web server (ALMWEB01) for convenience but in a non demo context you would probably want to use something more permanent such as a build server. This would of course entail installing the Deployment Agent on that server.
3. Add the new environment to the Contoso University\DAT>DQA release path from Configure Paths > Agent-based Release paths. The stage should be fully automated with email notifications turned off and this is probably a good time to change the name of the release path to Contoso University\DAT>DQA>PRD.
   
4. Whilst in the newly renamed Contoso University\DAT>DQA>PRD release path help to speed up the debugging process by making the DQA stage fully automated, removing any Approvers from the Approval Step and turning off email notifications.
5. Open the Contoso University\DAT>DQA release template from Configure Apps > Agent-based Release Templates and in Properties change the name to Contoso University\DAT>DQA>PRD.
6. On the web server (ALMWEB01 in my case) create a folder called C:\ReleaseReadyBuilds.

Configure New Components

With the PRD stage added, we now need to create new components that will deploy to a folder structure. For the web application, it’s not really all that different because we’re using XCopy anyway as the deployment method so it’s just a case of specifying a new location. The database side of things is more interesting because we need to create scripts rather than run actions against a database. On top of all this, we need a mechanism to ensure that each release is placed in a unique folder. To achieve this, carry out the following steps in Release Management Configure Apps > Components:

1. Create a new component called Contoso University\Script DACPAC and configure as follows:
   1. Source > Builds with application (= selected) > Path to package = \
   2. Deployment:
      1. Tool = DACPAC Database Deployer
      2. Arguments = /Action:Script /SourceFile:”__FileName__” /TargetServerName:”__ServerName__”
         /TargetDatabaseName:”__DatabaseName__” /OutputPath:”__OutputPath__”
      3. Parameters > OutputPath > Description = The location for the DACPAC script file
2. Create a new component called Contoso University\Script Login & User SQL Script and configure as follows:
   1. Source > Builds with application (= selected) > Path to package = \Scripts
   2. Deployment:
      1. Tool = Windows Common IO
      2. Arguments = -File ./ManageWindowsIO.ps1 -Action __Action__ -FileFolderName “__FileFolderName__” -DestinationName “__DestinationName__”
      3. Parameters > DestinationName > Description = Location to copy the file to
   3. Configuration Variables:
      1. Variable Replacement Mode = Before Installation
      2. File Extension Filter = *.sql
      3. Parameter #1 = LOGIN_OR_USER | Standard | Name of login or user to create
      4. Parameter #2 = DB_NAME | Standard | Database to set security for
3. Create a new component called Contoso University\RRB and configure as follows:
   1. Source > Builds with application (= selected) > Path to package = \
   2. Deployment:
      1. Tool = Windows Common IO
      2. Arguments = -File ./ManageWindowsIO.ps1 -Action __Action__ -FileFolderName “__FileFolderName__” -DestinationName “__DestinationName__”
      3. Parameters > DestinationName > Description = Destination name

Configure the PRD Stage

Next we need to configure the PRD stage. To achieve this, carry out the following steps in the Contoso University\DAT>DQA>PRD agent-based release template:

1. In order to speed up the debugging process, visit the DAT and DQA stages and click the top left hand icon of every action or component to toggle the skip state:
   
2. In the PRD stage, drag the ALMWEB01 server to the Deployment Sequence.
3. Drag the Contoso University\Deploy Web Site to ALMWEB01 and set the parameters as follows:
   1. Installation Path = C:\ReleaseReadyBuilds\PRD\Web
   2. DATA_SOURCE = ALMSQL01
   3. INITIAL_CATALOG = CU-PRD
4. Navigate to Toolbox > Windows OS and drag a Create Folder action below Contoso University\Deploy Web Site and set the FolderName to C:\ReleaseReadyBuilds\PRD\Database.
5. Navigate to Toolbox > Components and right-click the Components node. Add Contoso University\Script DACPAC.
6. Drag the Contoso University\Script DACPAC component below the Create Folder action and set the parameters as follows:
   1. FileName = ContosoUniversity.Database.dacpac
   2. ServerName = ALMSQL01
   3. DatabaseName = CU-PRD
   4. OutputPath = C:\ReleaseReadyBuilds\PRD\Database\DACPAC.sql
7. Navigate to Toolbox > Components and right-click the Components node. Add Contoso University\Script Login & User SQL Script.
8. Drag the Contoso University\Script Login & User SQL Script component below the Contoso University\Script DACPAC component and set the parameters as follows:
   1. Action = move
   2. FileFolderName = Create login and database user.sql
   3. DestinationName = C:\ReleaseReadyBuilds\PRD\Database\Create login and database user.sql
   4. LOGIN_OR_USER = ALM\CU-PRD
   5. DB_NAME = CU-PRD
9. Navigate to Toolbox > Components and right-click the Components node. Add Contoso University\RRB.
10. Drag the Contoso University\RRB component below the Contoso University\Script Login & User SQL Script component and set the parameters as follows:
    1. Action = create
    2. FileFolderName = C:\ReleaseReadyBuilds\$(BuildNumber)
11. Drag a second Contoso University\RRB component below the first one and set the parameters as follows:
    1. Action = move
    2. FileFolderName = C:\ReleaseReadyBuilds\PRD
    3. DestinationName = C:\ReleaseReadyBuilds\$(BuildNumber)\PRD

Check the Stage Works

Navigate to Releases > Releases and manually create a release based on the latest build. Because the previous stages are in skip mode, the PRD stage should finish almost immediately and you should very quickly be able to verify everything is working. Essentially, you should be checking for a folder similar to C:\ReleaseReadyBuilds\ContosoUniversity_Main_Nightly_20150214.8 that contains a PRD folder with Web and Database folders containing our deployable artifacts. The magic that achieves this is the $(BuildNumber) configuration variable that is one of several that are only available in components. If that’s all working, then you should revisit the DAT and DQA stages and toggle all the components and actions so that they are not skipped, but leave DQA in automated mode. Now run a couple of complete builds from the nightly build definition in Visual Studio, confirming that each PRD build is placed in its own separate folder. Finally, when that’s working, you can revisit the DQA stage and return it to its manual status.

By way of finishing off, I want to stress that you should be doing everything possible to use the full automation capabilities of Release Management to deploy your application along the whole delivery pipeline. But when you really do have a problem with a particular stage, hopefully the technique I’ve illustrated here will tide you over.

Cheers – Graham

The post Continuous Delivery with TFS: Save to a Folder for Stages You Can’t Yet Deploy to appeared first on Please Release Me.