anchor.diff:      $ cf create-service p.config-server standard my_configserver  -c .\config-server.json
       </pre>
   
  -### <a id='parameterize-manifest'></a> Configure Your App Manifest File for Spring Cloud Server
  -
  -Your app manifest file must be modified so it accepts configuration values from your externalized gitHub repository values.
  +
  +## <a id='bind-service-to-app'></a> Bind Config Service to App Using Manifest 
  +
  +Your app manifest file must be modified so it accepts configuration values from your externalized Git repository values.
   
   1. Backup your app manifest file.  
   
  -1. To parameterize your environment string, replace your manifest's hardcoded `env` value with `ASPNETCORE_ENVIRONMENT: ((env))` using the following format:  
  -
  -    ```yaml
  -    env:
  -      ASPNETCORE_ENVIRONMENT: ((env))     
  -    ```
  -
  -1. To bind your config server to your app, add a new `services` section to your app manifest file 
  -using the following format:
  -
  -    ```yaml
  -    services:
  -    - SERVER-NAME     
  -    ```
  -
  +1. To bind your config server to your app, add a new `services` section to your app manifest file with the following format:
  +
  +<br> 
       Where `SERVER-NAME` is the name for your config server.  
   <br>
   
  -1. Review the resulting manifest file. The manifest file should adhere to the following format:
  -    
  -    ```yaml
  -    applications:
  -    - name: sampleapp
  -      stack: windows
  -      buildpacks:
  -      - https://github.com/cloudfoundry-community/web-config-transform-buildpack/releases/download/VERSION/web-config-transform-buildpack-VERSION.zip
  -      - hwc_buildpack
  -      env:
  -        ASPNETCORE_ENVIRONMENT: ((env))  
  -
  -      services:
  -      - SERVER-NAME     
  -    ```
  -
  -    Where:  
  -    * `VERSION` is the buildpack version.  
  -    * `SERVER-NAME` is the name for your config server. 
  -    
  -    For example:
  +<br>
  +    For example: 
  +<br>
   
       ```yaml
       ---
  
positive.code:     ```
  
      Where:  
      * `ACCOUNT-ID` is the is the github account ID.  
      * `CONFIG-REPO` is your github configuration repository.   
  
  1. Save the text file as a JSON file, for example `config-server.json`.  
     <p class='note'><strong>Note:</strong> Ensure file is not BOM-encoded.</p>
  1. To create a config server using your configuration file, run the following command:  
  
      ```script
      cf create-service CONFIG-SERVER-MARKET standard SERVER-NAME  -c .\CONFIG-FILE
      ```
  
      Where:  
      * `CONFIG-SERVER-MARKET` is the name of the config server available in your CF Marketplace.
      * `SERVER-NAME` is the name for your config server.  
      * `CONFIG-FILE` is the filename of your server config json file.  
  
  
negative.code: owner: Buildpacks
  ---
  
  This topic explains how to use the .NET Framework Web Config Transform Extension Buildpack
  
  ## <a id='prerequisites'></a>Prerequisites
  
  * Linux, Windows or MacOS development machine or VM.
  * A foundation with Windows cells available to push to.
  * A foundation with the .NET Framework Web Config Transform Extension Buildpack installed. This will be installed by an admin.
  
  ## <a id='overview'></a> Overview
  
  Cloud Native Applications are expected to bring in configurations from external sources like environment variables, config servers, etc. 
  
  In applications that run on IIS (e.g. ASP.NET applications), configuration settings are injected through Web.config files.  As per cloud native principles, configuration should stay out of build artifacts. The .NET Framework Web Config Transform Extension Buildpack buildpack provides a solution to this problem by using token replacement during ‘cf push’ staging. 
  
  To leverage the .NET Framework Web Config Transform Extension Buildpack, complete the following procedures:  
  
  1. [Identify Environment Dependent Configurations and Externalize](#tokenize)
  1. [Create a Cloud Foundry App Manifest](#create-manifest)
  1. [Add Web Config Transformations](#transformations)
  1. [Move Config to Git Repoistory](#move-to-git-repo)
  1. [Create Spring Cloud Service](#create-spring-cloud-service)
  1. [Bind Config Service to App](#bind-service-to-app)
  1. [Add ASPNETCORE_ENV Variable to Manifest](#add-aspnetcore-env)
  1. [Push App By Parameterized Environment Name](#push-app)
  
  <p class='note'><strong>Note:</strong> This buildpack can inject appSettings and 
      connectionStrings regardless of whether the replacement tokens are present in the <code>Web.Release.Config</code> file. For more information please see the Special Behaviors section at the end.
  </p>
  
  ## <a id='tokenize'></a> Identify Environment-Dependent Configurations and Externalize
  
  Your `Web.config` environment-specific settings will be replaced with placeholder tokens and their values externalized 
  outside of your application.  
  
  To externalize your workload's environment-specific configuration settings, complete the following steps:  
  
  1. Backup your application's `Web.config` file, and its transform files (e.g. `Web.Debug.Config`,`Web.Release.Config`)  
  
  1. Identify configuration items (in `Web.config` files) that are environment-dependent that need to be externalized.
  
  1. Modify your transform files (e.g. `Web.Release.Config`) to use tokenized configuration items by replacing hard-coded values 
  with tokens of following the format `#{configPath:key}`.  
  <br>
      For example please refer to sample files before and after tokenizing: 
  <br>
  
      <p class='note'><strong>Note:</strong> Transform xml attributes and tokens are case-sensitive.</p>
  
      **Before tokenizing**
      
      Web.Config
      ```xml
      <connectionStrings>
          <add name="MyDB" 
               connectionString="Data Source=LocalSQLServer;Initial Catalog=MyReleaseDB;User ID=xxxx;Password=xxxx" />
      </connectionStrings>
      ```
  
      Web.Release.Config
      ```xml
      <connectionStrings>
          <add name="MyDB" 
               connectionString="Data Source=ReleaseSQLServer;Initial Catalog=MyReleaseDB;User ID=xxxx;Password=xxxx" 
               xdt:Transform="SetAttributes" 
               xdt:Locator="Match(name)"/>
      </connectionStrings>
      ```
  
      **After tokenizing** 
  
      Web.Config (no change)
  
      Web.Release.Config
      ```xml
      <connectionStrings>
          <add name="MyDB" 
               connectionString="#{connectionStrings:MyDB}" 
               xdt:Transform="SetAttributes" 
               xdt:Locator="Match(name)"/>
      </connectionStrings>
      ``` 
  
  ## <a id='create-manifest'></a> Create a Cloud Foundry App Manifest 
  
  Perform the following steps to test your tokenizations by using environment variables in the Cloud Foundry app manifest
  to perform the token replacements. In following steps, we will externalize these configurations using a git repository and Spring Cloud Config Server.
  
  ### <a id='create-manifest'></a> Create a Cloud Foundry App Manifest  
  
  To create a Cloud Foundry app manifest for your workload, complete the following step:  
  
  1. Ensure your application has a Cloud Foundry manifest file. If your application is in Cloud Foundry, you can create the manifest file 
      by running the following command:  
  
      ```
      cf create-app-manifest APP-NAME
      ```
  
      Where `APP-NAME` is your app's name.
  
  ### <a id='modify-manifest'></a> Modify Your Cloud Foundry App Manifest  
  
  To configure your workload's Cloud Foundry app manifest for token replacement, complete the following steps:  
  
  *Note*: You should prepare your Cloud Foundry app manifest for token replacement with debug/development environment connection values.  
  
  1. Backup your app manifest file.  
  
  1. Open the app manifest file in a text editor.
  
  1. Add a reference for the .NET Framework Web Config Transform Extension Buildpack to the manifest file's `buildpacks` 
  property.  
  
      ```yaml
      buildpacks:
      - WEB-CONFIG-TRANSFORM-BUILDPACK
      - hwc_buildpack
      ```    
      Where:  
      * `WEB-CONFIG-TRANSFORM-BUILDPACK` is name of the .NET Framework Web Config Transform Extension buildpack in your foundation. Check `cf buildpacks` to see all the buildpacks in your foundation.
  
      <p class='note'><strong>Note:</strong> Ensure the new entry precedes the existing 
        <code>hwc_buildpack</code> buildpacks entry.
      </p>
  
    
  1. Add `key:value` pairs to the manifest for each the Web Config file's tokenized settings. 
  <br>
      ***Reminder***: token replacements with environment variables is solely for testing purposes, to ensure the tokens are being replaced correctly. Config settings will eventually be externalized using git repositories and Spring Cloud Config Server, which we will complete in steps below. 
  <br>
  
      Below is a sample added referring to the connection string 
      ```yaml
      applications:
      - name: sampleapp
        stack: windows
        buildpacks:
        - WEB-CONFIG-TRANSFORM-BUILDPACK
        - hwc_buildpack
        env:
          "connectionStrings:MyDB": "Data Source=ReleaseSQLServer;Initial Catalog=MyReleaseDB;User ID=xxxx;Password=xxxx"
      ```
  
      <p class='note'><strong>Note:</strong> Create as many <code>key:value</code> pair lines as are 
          needed by your application. The values you provide should be your debug/development 
          environment's connection values.
      </p>
  
  ## <a id='tokenize'></a> Add Web Config Transformations
  
  By default, all web apps and WCF apps are created with **Debug** and **Release** configurations and corresponding web config transformation files (`Web.Debug.Config`, `Web.Release.Config`).
  
  1. Add required transformations to `Web.Release.Config` 
  
      <p class='note'><strong>Note:</strong>  For developer machine debugging, use `Debug` configuration profile and `Web.Debug.config` for transformation.
      </p>
  
  <br>
     Sample `Web.Release.Config` with transformations
  <br>
  
      ```xml
      <?xml version="1.0" encoding="utf-8"?>
      <!-- For Cloud Foundry -->
      <configuration xmlns:xdt="http://schemas.microsoft.com/XML-Document-Transform">
  
        <connectionStrings  xdt:Transform="Replace">
          <add name="MyDB" connectionString="#{connectionStrings:MyDB}" providerName="System.Data.SqlClient"/>
        </connectionStrings>
  
        <system.serviceModel>
          <client xdt:Transform="Replace">
  
            <endpoint 
              address="#{client:Default_IMyLogService:address}" 
              binding="#{client:Default_IMyLogService:binding}" 
              bindingConfiguration="#{client:Default_IMyLogService:bindingConfiguration}"
              contract="ServiceProxy.IMyLogService" name="Default_IMyLogService" />
  
          </client>
        </system.serviceModel>
  
      </configuration>
      ```
  
  1.  Build and push the application to Cloud Foundry to verify that your config settings are properly transformed:  
  
      ```script
      cf push
      ```
  
  ## <a id='move-to-git'></a> Move Config Settings to Git Repository  
  
  A multi-environment, production-ready deployment configuration can be achieved by using Spring Cloud Config Server 
  backed by a git repository data source.
  
  To move your configuration settings to a Git repository, complete the following steps:  
  
  1. Create a network-accessible Git repository for specifically storing this application's transform configuration files.  
  
  1. Create a YAML file in your repository to hold your common settings across all environments. 
  Name the file `YOUR-APPLICATION`.yaml.  
  <br>
      Where `YOUR-APPLICATION` is the identifier name for your application.  
  