Chapter 1. Using .NET Core 2.2 on Red Hat Enterprise Linux

This Getting Started Guide describes how to install .NET Core 2.2 on Red Hat Enterprise Linux (RHEL). See Red Hat Enterprise Linux documentation for more information about RHEL 7.

1.1. Install and Register Red Hat Enterprise Linux

  1. Install RHEL 7 using one of the following images:

  2. Use the following command to register the system.

    $ sudo subscription-manager register

    You can also register the system by following the appropriate steps in Registering and Unregistering a System in the Red Hat Subscription Management document.

  3. Display a list of all subscriptions that are available for your system and identify the pool ID for the subscription.

    $ sudo subscription-manager list --available

    This command displays the subscription name, unique identifier, expiration date, and other details related to it. The pool ID is listed on a line beginning with Pool ID.

  4. Attach the subscription that provides access to the dotNET on RHEL repository. Use the pool ID you identified in the previous step.

    $ sudo subscription-manager attach --pool=<appropriate pool ID from the subscription>
  5. Enable the .NET Core channel for Red Hat Enterprise 7 Server, Red Hat Enterprise 7 Workstation, or HPC Compute Node with one of the following commands, respectively.

    $ sudo subscription-manager repos --enable=rhel-7-server-dotnet-rpms
    $ sudo subscription-manager repos --enable=rhel-7-workstation-dotnet-rpms
    $ sudo subscription-manager repos --enable=rhel-7-hpc-node-dotnet-rpms
  6. Verify the list of subscriptions attached to your system.

    $ sudo subscription-manager list --consumed
  7. Install the scl tool.

    $ sudo yum install scl-utils

1.2. Install .NET Core

  1. Install .NET Core 2.2 and all of its dependencies.

    $ sudo yum install rh-dotnet22 -y
  2. Enable the rh-dotnet22 Software Collection environment so you can run dotnet commands in the bash shell.

    This procedure installs the .NET Core 2.2 runtime with the latest 2.2 SDK. When a newer SDK becomes available, it automatically installs as a package update.

    $ scl enable rh-dotnet22 bash

    This command does not persist; it creates a new shell, and the dotnet command is only available within that shell. If you log out, use another shell, or open up a new terminal, the dotnet command is no longer enabled.


    Red Hat does not recommend permanently enabling rh-dotnet22 because it may affect other programs. For example, rh-dotnet22 includes a version of libcurl that differs from the base RHEL version. This may lead to issues in programs that do not expect a different version of libcurl. If you want to enable rh-dotnet permanently, add the following line to your ~/.bashrc file.

    source scl_source enable rh-dotnet22

  3. Run the following command to verify the installation succeeded.

    $ dotnet --info
    .NET Core SDK (reflecting any global.json):
     Version:   2.2.100
     Commit:    b9f2fa0ca8
    Runtime Environment:
     OS Name:     rhel
     OS Version:  7
     OS Platform: Linux
     RID:         rhel.7-x64
     Base Path:   /opt/rh/rh-dotnet22/root/usr/lib64/dotnet/sdk/2.2.100/
    Host (useful for support):
      Version: 2.2.0
      Commit:  1249f08fed
    .NET Core SDKs installed:
      2.2.100 [/opt/rh/rh-dotnet22/root/usr/lib64/dotnet/sdk]
    .... omitted

1.3. Create an Application

  1. Create a new Console application in a directory called hello-world.

    $ dotnet new console -o hello-world
      The template "Console Application" was created successfully.
      Processing post-creation actions...
      Running 'dotnet restore' on hello-world/hello-world.csproj...
      Restoring packages for /home/<USER>/hello-world/hello-world.csproj...
      Generating MSBuild file /home/<USER>/hello-world/obj/hello-world.csproj.nuget.g.props.
      Generating MSBuild file /home/<USER>/hello-world/obj/hello-world.csproj.nuget.g.targets.
      Restore completed in 224.85 ms for /home/<USER>/hello-world/hello-world.csproj.
      Restore succeeded.
  2. Run the project.

    $ cd hello-world
    $ dotnet run
    Hello World!

1.4. Publish Applications

The .NET Core 2.2 applications can be published to use a shared system-wide version of .NET Core or to include .NET Core. These two deployment types are called framework-dependent deployment (FDD) and self-contained deployment (SCD), respectively.

For RHEL, we recommend publishing by FDD. This method ensures the application is using an up-to-date version of .NET Core, built by Red Hat, that includes a specific set of native dependencies. These native libraries are part of the rh-dotnet22 Software Collection. On the other hand, SCD uses a runtime built by Microsoft. Running applications outside the rh-dotnet22 Software Collection may cause issues due to the unavailability of native libraries.

1.4.1. Publish .NET Core Applications

  1. Use the following command to publish a framework-dependent application.

    $ dotnet publish -f netcoreapp2.2 -c Release
  2. Optional: If the application is only for RHEL, trim out the dependencies needed for other platforms with these commands.

    $ dotnet restore -r rhel.7-x64
    $ dotnet publish -f netcoreapp2.2 -c Release -r rhel.7-x64 --self-contained false
  3. Enable the Software Collection and pass the application assembly name to the dotnet command to run the application on a RHEL system.

    $ scl enable rh-dotnet22 -- dotnet <app>.dll
  4. This command can be added to a script that is published with the application. Add the following script to your project and update the ASSEMBLY variable.

    DIR="$(dirname "$(readlink -f "$0")")"
    scl enable $SCL -- dotnet "$DIR/$ASSEMBLY" "$@"
  5. To include the script when publishing, add this ItemGroup to the csproj file.

        <None Update="<scriptname>" Condition="'$(RuntimeIdentifier)' == 'rhel.7-x64' and '$(SelfContained)' == 'false'" CopyToPublishDirectory="PreserveNewest" />

1.4.2. Publish ASP.NET Core Applications

When using the Microsoft SDK, ASP.NET Core 2.2 web applications are published with a dependency on the ASP.NET Core shared framework. This is a set of packages that are expected to be available on the runtime system.

When publishing on RHEL, these packages are included with the application. To include the packages using the Microsoft SDK, the MicrosoftNETPlatformLibrary property must be set to Microsoft.NETCore.App in the project file, as shown below.

<Project Sdk="Microsoft.NET.Sdk.Web">
    <PackageReference Include="Microsoft.AspNetCore.App" Version="2.2" />

As an alternative, this property can be set when publishing the application.

$ dotnet publish -f netcoreapp2.2 -c Release -r rhel.7-x64 --self-contained false /p:MicrosoftNETPlatformLibrary=Microsoft.NETCore.App

1.5. Run Applications on Linux Containers

This section shows how to use the dotnet/dotnet-22-runtime-rhel7 image to run a precompiled application inside a Linux container.

  1. Create a new mvc project in a directory named mvc_runtime_example.

    $ dotnet new mvc -o mvc_runtime_example --no-restore
    $ cd mvc_runtime_example
  2. Restore and publish the project.

    $ dotnet restore -r rhel.7-x64
    $ dotnet publish -f netcoreapp2.2 -c Release -r rhel.7-x64 --self-contained false /p:MicrosoftNETPlatformLibrary=Microsoft.NETCore.App
  3. Create the Dockerfile.

    $ cat > Dockerfile <<EOF
    ADD bin/Release/netcoreapp2.2/rhel.7-x64/publish/ .
    CMD ["dotnet", "mvc_runtime_example.dll"]
  4. Build your image.

    $ podman build -t dotnet-22-runtime-example .

    If you get an error containing the message unable to retrieve auth token: invalid username/password, you need to provide credentials for the server. Use the command $ podman login to log in. Your credentials are typically the same as those used for the Red Hat Customer Portal.

  5. Run your image.

    $ podman run -d -p8080:8080 dotnet-22-runtime-example
  6. View the result in a browser:

Report a bug