anchor.diff:  
   From the pipeline view if you click on the green bar you can view the job console ouput. I confirmed the label was updated correctly during the package task.
   
  -```
  -19:04:59.567 [go] Start to execute task:
  -/c
  -package.cmd %GO_PIPELINE_LABEL%
  -.
  -19:04:59.598
  -19:04:59.598 C:\demo\GoCD\Agent\pipelines\hwPackagePipeline>IF [2] == [] GOTO error
  -19:05:00.022 Project hwPackagePipeline (.NETCoreApp,Version=v1.0) was previously compiled. Skipping compilation.
  -19:05:00.072 Producing nuget package "hwPackagePipeline.1.0.0-2" for hwPackagePipeline
  -19:05:00.118 hwPackagePipeline -> C:\demo\GoCD\Agent\pipelines\hwPackagePipeline\_build\hwPackagePipeline.1.0.0-2.nupkg
  -19:05:00.118 Producing nuget package "hwPackagePipeline.1.0.0-2.symbols" for hwPackagePipeline
  -19:05:00.122 hwPackagePipeline -> C:\demo\GoCD\Agent\pipelines\hwPackagePipeline\_build\hwPackagePipeline.1.0.0-2.symbols.nupkg
  -19:05:00.184 [go] Current job status: passed.
  -```
  -
  -Now that the build, test, and packaging is done I can move on to creating a pipeline for acceptance tests and deployment with required approval. The second pipeline will use the first for it’s material. Before we can create the second pipeline we need to go into the first and setup the jobs build artifacts.
  -
  -**Note:** *Also by adding a test artifact GoCD will display the results in the tests tab. You can use Go with any XUnit style xml reports.*
  +    19:04:59.567 [go] Start to execute task:
  +    /c
  +    package.cmd %GO_PIPELINE_LABEL%
  +    .
  +    19:04:59.598
  +    19:04:59.598 C:\demo\GoCD\Agent\pipelines\hwPackagePipeline>IF [2] == [] GOTO error
  +    19:05:00.022 Project hwPackagePipeline (.NETCoreApp,Version=v1.0) was previously compiled. Skipping compilation.
  +    19:05:00.072 Producing nuget package "hwPackagePipeline.1.0.0-2" for hwPackagePipeline
  +    19:05:00.118 hwPackagePipeline -> C:\demo\GoCD\Agent\pipelines\hwPackagePipeline\_build\hwPackagePipeline.1.0.0-2.nupkg
  +    19:05:00.118 Producing nuget package "hwPackagePipeline.1.0.0-2.symbols" for hwPackagePipeline
  +    19:05:00.122 hwPackagePipeline -> C:\demo\GoCD\Agent\pipelines\hwPackagePipeline\_build\hwPackagePipeline.1.0.0-2.symbols.nupkg
  +    19:05:00.184 [go] Current job status: passed.
  +
  +
  +Now that the build, test, and packaging is done I can move on to creating a pipeline for acceptance tests and deployment with required approval. The second pipeline will use the first for it's material. Before we can create the second pipeline we need to go into the first and setup the jobs build artifacts.
  +
  +**Note:** *Also by adding a test artifact GoCD will display the results in the tests tab. You can use GoCD with any XUnit style xml reports.*
   
   <figure>
     <img src="/assets/images/blog/dotnet-core-gocd/gocd_artifacts.png" alt="GoCD Artifacts" />
   </figure>
   
  -Now via the admin tab and selecting pipelines, I can click on “Create a new pipeline within this group”. On step one I’ll name the new pipeline “hwDeployPipeline”.
  +Now via the admin tab and selecting pipelines, I can click on "Create a new pipeline within this group". On step one I'll name the new pipeline "hwDeployPipeline".
   
   **Note:** *GoCD supports pipeline templates. Deployment pipelines would be a good use case for a template.*
   
  -For step two the material will be “Pipeline” and the pipeline will be the stage we created earlier. GoCD has autocomplete text boxes. I didn’t have to type the stage name in the screenshot below.
  +For step two the material will be "Pipeline" and the stage will be the stage we created earlier. GoCD has autocomplete text boxes. I didn't have to type the stage name in the screenshot below.
   
   <figure>
     <img src="/assets/images/blog/dotnet-core-gocd/pipeline-as-material.png" alt="Pipeline as Material" />
  
positive.code: title_tag_of_header: ".NET Core and GoCD | GoCD Blog"
  meta_description: "GoCD is a great way to learn the concepts and abstractions to help model your delivery pipeline and work towards improving it. This post documents setting up a .NET core project in GoCD in a minimal way for demo purposes."
  meta_keywords: "GoCD, continuous delivery, goforcd, open source, software, contribute to open source, agile continuous delivery, code contribution, Go, dotnet, .NET, .NET core, pipeline"
  summary_image: "/assets/images/blog/high-centered-team/sunkcosts_masthead.jpg"
  ---
  
  I’ve been reading up on continuous delivery and the GoCD tool is a great way to learn the concepts and abstractions to help model your delivery pipeline and work towards improving it.
  
  This post documents setting up a .NET core project in GoCD in a minimal way for demo purposes. I cover setting up a hello world app and simple scripts to build, test, and package. Then I will create a pipeline in GoCD to build our site and run unit tests. Finally I’ll show how to add additional pipelines for manual acceptance tests and deployment.
  
  If you want to know about my environment and .NET core project for this demo you can read the next section Demo Environment Setup. If you want to just jump ahead to the GoCD you can scroll down to the GoCD Setup or GoCD Pipelines sections.
  
  ## Demo Environment Setup
  
  ### Demo Environment
  For this post I’ll be using the following file structure:
  
  Where I keep my development git repo.
  
  
negative.code:   <img src="/assets/images/blog/dotnet-core-gocd/value-stream-map.png" alt="Value Stream Map" />
  </figure>
  
  Now we can setup a task that fetches the artifacts from the first pipeline and another task to deploy. Here is what setting up a fetch task would look like. The "pkg" folder name came from the artifacts configuration from the first pipeline.
  <figure>
    <img src="/assets/images/blog/dotnet-core-gocd/fetch_artifacts.png" alt="Fetch Artifacts" />
  </figure>
  
  Now if we trigger the first pipeline again and manually trigger the second one we can see the agent was able to fetch the build output from the first pipeline.
  
      21:31:26.919 [go] Start to execute task: .
      21:31:26.920 [go] Fetching artifact [pkg] from [hwPackagePipeline/8/defaultStage/1/defaultJob]
      21:31:32.017 [go] Saved artifact to [pipelines\hwDeployPipeline] after verifying the integrity of its contents.
      21:31:32.052 [go] Current job status: passed.
  
  <figure>
    <img src="/assets/images/blog/dotnet-core-gocd/agent-pkg.png" alt="Agent Pkg" />
  </figure>
  
  ### Review
  
  GoCD has a very good model and abstraction for how to build deployment pipelines. For example, when working on a task like packaging you don't need to worry about anything else. It leads you to using smaller focused scripts in the right places. Also, the concept of pipelines as a material give a powerful way to break up your deployment process. In my example I used another pipeline, setup with an initial task to wait for manual approval. Then after approval a fetch task runs which copies the artifacts from the build of the first pipeline, which then can be used for deployment.
  