Release Management with ASP.Net Core and GitHub Actions

In this article, we will learn how to set up automated release creation for an ASP.Net Core project with GitHub Actions

Release management can be a complicated beast at the best of times, and is notoriously hard to get right. Previously, shell scripts and batch files used to be the most common tools used for automation, and countless hours were spent trying to get them working as expected.

This has changed in recent times, with platforms such as GitHub Actions providing a much simpler way of automating tasks and managing releases.

, we have seen how GitHub Actions can be used to set up a pipeline for Continuous Integration (CI). In the following sections, we will build on that, and add a workflow that publishes release artifacts when new code is merged to the 

For the purposes of this tutorial, we will use a simple .NET Core console application. This can be created via the following command using the .NET CLI which is installed along with the SDK.

We will use the GitHub repository that we created in the previous article, which already contains a GitHub Actions CI workflow that builds and runs unit tests on pushes to 

Step 2: Understanding GitHub Tags and Releases 🧐

 is a label that can be applied to any commit in your repository for later identification. Tags are typically used to mark commits for releases.

You can create a tag using the following commands in your terminal/command line.

Tag names can be any arbitrary string, but are usually version numbers like v1.0.0 or v.1.1.2-beta5.

When a tag has been published, it will appear in the 'Tags' section in your repository.

You can then use the created tag to create a GitHub 

 - each release has a title, short description and attachments such as release notes, source code and built artifacts. 

In the next step, we will learn how to build our project and associate the built app code artifacts with the just-created release.

 event to trigger our workflow. This means our workflow will get triggered when a new release is published using the mechanism from the previous step.

name: Publish

on:
  release:
    types: [published]
env:
  DOTNET_VERSION: '6.0.x'
jobs:
  release:
    name: Release
    strategy:
      matrix:
        kind: ['linux', 'windows']
        include:
          - kind: linux
            os: ubuntu-latest
            target: linux-x64
          - kind: windows
            os: windows-latest
            target: win-x64
    runs-on: ${{ matrix.os }}
    steps:
      - name: Checkout
        uses: actions/checkout@v3

      - name: Setup dotnet
        uses: actions/setup-dotnet@v3
        with:
          dotnet-version: ${{ env.DOTNET_VERSION }}

      - name: Build
        shell: bash
        run: |
          tag=$(git describe --tags --abbrev=0)
          release_name="app-$tag-${{ matrix.target }}"

          # Build everything
          dotnet publish --framework net6.0 --runtime "${{ matrix.target }}" -c Release -o "$release_name"

          # Pack files
          if [ "${{ matrix.target }}" == "win-x64" ]; then
            # Pack to zip for Windows
            7z a -tzip "${release_name}.zip" "./${release_name}/*"
          else
          tar czvf "${release_name}.tar.gz" "$release_name"
          fi

          # Delete output directory
          rm -r "$release_name"

      - name: Publish
        uses: softprops/action-gh-release@v1
        with:
          files: "app*"
        env:
          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

Let us now understand what this workflow does:

We can now create a release using the steps described earlier.

Let us first tag the last commit in our repo. I'll call the tag 

The tag will now appear in the 'Tags' section, and we can create a release from it. The release notes can be automatically populated based on the commits since the last tag.

Once we hit publish, a release gets created on the 'Releases' page. Note that this only has the source code, and not the built artifacts from the tagged commit.

Publishing the release also triggers our new workflow.

When the workflow has finished, the built ZIP file and tarball are added to the release assets, and we have successfully released v1.0 of our app! 🎉

In this tutorial, we have learnt how to create and automate tasks around releases for an ASP.Net Core project using GitHub Actions. We built on concepts we learnt in the previous tutorial on 

If you find yourself stuck at any point during the tutorial, you can view all the source code on my GitHub 

More detail on all the events that can be used to trigger GitHub Actions workflows can be found in the 

Learn

The newline Guide to Building Your First GraphQL Server with Node and TypeScript

Teach

Amelia Wattenberger

Author of Fullstack D3

Community

Tutorials on Release Management

Release Management with ASP.Net Core and GitHub Actions

Email Newsletter

Popular Topics

Masterclasses

Tutorials

Fullstack React with TypeScript