Getting Started Guide

Install RHEL 7 using one of the following images:

Register the system by following the appropriate steps in Registering and Unregistering a System in the Red Hat Subscription Management document.

You can also use the following command to register the system.

$ sudo subscription-manager register

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.

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>

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

Verify the list of subscriptions attached to your system.

$ sudo subscription-manager list --consumed

Install the scl tool.

$ sudo yum install scl-utils

Install .NET Core 2.0 and all of its dependencies.

$ sudo yum install rh-dotnet20 -y

Enable the rh-dotnet20 Software Collection environment so you can run dotnet commands in the bash shell.

$ scl enable rh-dotnet20 bash

Run the following command to prove the installation succeeded.

$ dotnet --help
.NET Command Line Tools (2.0.0)
Usage: dotnet [runtime-options] [path-to-application]
Usage: dotnet [sdk-options] [command] [arguments] [command-options]

path-to-application:
  The path to an application .dll file to execute.

SDK commands:
  new              Initialize .NET projects.
  restore         Restore dependencies specified in the .NET project.
  run               Compiles and immediately executes a .NET project.
  build             Builds a .NET project.
  publish          Publishes a .NET project for deployment (including the runtime).
....

If you want to run the classic "Hello World" test case, create the following directory.

$ mkdir hello-world

Navigate to the hello-world directory.

$ cd hello-world

Create a project.

$ dotnet new console
The template "Console Application" was created successfully.

Processing post-creation actions...
Running 'dotnet restore' on /home/<USER>/hello-world/hello-world.csproj...
Restore succeeded.

Pull the dependencies needed for the project.

$ dotnet build

Run the project.

$ dotnet run
Hello World!

Create and navigate to the following directory.

$ mkdir mvc_runtime_example && cd mvc_runtime_example

Create a new project.

$ dotnet new mvc --no-restore

Pull all dependencies.

$ dotnet restore -r rhel.7-x64

Publish the project.

$ dotnet publish -f netcoreapp2.0 -c Release -r rhel.7-x64 \
--self-contained false /p:PublishWithAspNetCoreTargetManifest=false

Create a file called Dockerfile and add the following contents.

$ cat > Dockerfile <<EOF
FROM registry.access.redhat.com/dotnet/dotnet-20-runtime-rhel7

ADD bin/Release/netcoreapp2.0/rhel.7-x64/publish/ .

CMD ["dotnet", "mvc_runtime_example.dll"]
EOF

Build your image.

$ sudo docker build -t dotnet-20-runtime-example .

Run your image.

$ sudo docker run -d -p8080:8080 dotnet-20-runtime-example

If you are a system administrator or otherwise have sufficient permissions, change to the openshift project. Using the openshift project allows you to globally update the image stream definitions.

$ oc project openshift

If you do not have permissions to use the openshift project, you can still update your project definitions starting with Step 2.

Run the following command to list all available .NET Core image versions.

$ oc describe is dotnet

The output shows installed images or the message Error from server (NotFound) if no images are installed.

To pull the images, OpenShift needs credentials for authenticating with the registry.redhat.io server. These credentials are stored in a secret.

Enter the following command to list secrets. The first column shows the secret name.

$ oc get secret | grep kubernetes.io/dockercfg

To check the contents of a secret, you can decode the .dockercfg or .dockercfgjson data from Base64 format. This allows you to see if you already have credentials for the registry.redhat.io server. Enter the following command to show the .dockercfg section in a secret.

$ oc get secret <secret-name> -o yaml | grep .dockercfg
  .dockercfg: eyJyZWdpc3RyeS5yZWRoYXQuaW8iOnsidXNlcm5hbWUiOiIqKioqKioqKiIsInBhc3N3b3JkIjoiKioqKioqKioiLCJlbWFpbCI6InVudXNlZCIsImF1dGgiOiJLaW9xS2lvcUtpbzZLaW9xS2lvcUtpbz0ifX0=

Copy and paste the output in the following command to convert it from Base64 format. The example below shows the credentials for the registry.redhat.io server.

$ echo eyJyZWdpc3RyeS5yZWRoYXQuaW8iOnsidXNlcm5hbWUiOiIqKioqKioqKiIsInBhc3N3b3JkIjoiKioqKioqKioiLCJlbWFpbCI6InVudXNlZCIsImF1dGgiOiJLaW9xS2lvcUtpbzZLaW9xS2lvcUtpbz0ifX0= | base64 -d
{"registry.redhat.io":{"username":"********","password":"********","email":"unused","auth":"KioqKioqKio6KioqKioqKio="}}

You need to add a secret if there is no secret listed with credentials for the registry.redhat.io server.

Red Hat account credentials are used for registry.redhat.io access. If you are a customer with entitlements to Red Hat products, you already have account credentials to use. These are typically the same credentials used to log in to the Red Hat Customer Portal. To verify your Red Hat credentials, enter the following command and attempt to log in.

$ docker login registry.redhat.io

If you cannot log in, you first need to get an account with Red Hat. See Red Hat Container Registry Authentication for additional information. If you can log in, enter the following commands to create the secret.

$ oc create secret docker-registry redhat-registry \
    --docker-server=registry.redhat.io \
    --docker-username=<user-name> \
    --docker-password=<password> \
    --docker-email=unused
$ oc secrets link default redhat-registry --for=pull
$ oc secrets link builder redhat-registry

After creating the secret, enter the following command to import new image streams.

$ oc create -f https://raw.githubusercontent.com/redhat-developer/s2i-dotnetcore/master/dotnet_imagestreams.json

If image streams were already installed, use the replace command to update the image stream definitions.

$ oc replace -f https://raw.githubusercontent.com/redhat-developer/s2i-dotnetcore/master/dotnet_imagestreams.json

Run the following commands to deploy the ASP.NET Core application, which is in the app folder on the dotnetcore-2.0 branch of the redhat-developer/s2i-dotnetcore-ex GitHub repository.

$ oc new-app --name=exampleapp 'dotnet:2.0~https://github.com/redhat-developer/s2i-dotnetcore-ex#dotnetcore-2.0' --build-env DOTNET_STARTUP_PROJECT=app

As suggested by the output of the new-app command, you can track progress of the build using the oc logs command.

$ oc logs -f bc/exampleapp

Once the build is finished, you can see the deployed application.

$ oc logs -f dc/exampleapp

At this point, the application is accessible within the project. To make it accessible externally, use the oc expose command. You can then use oc get routes to find the URL.

$ oc expose svc/exampleapp
$ oc get routes