Disclaimer: Currently I am employed by Microsoft, but my views and thoughts are still my own. The reason I joined Microsoft was, the work Microsoft have been doing for last couple of years in Open Source Space. Today I am a advocate for Open Source representing Microsoft.
After my last post on running .NET Core Console Application last month, I thought Docker containers are much more useful for something like a ASP.NET Core application.
Note: As this post is based on my previous post, I have tried to keep most of the sections as is. So that you can see the similarities.
If you are not fully familiar with Docker, please consider reading my other posts on Docker:
In order to package and run a ASP.NET Core application you will need:
- .NET Core SDK
ASP.NET Core Application
Create new application
To make it easier, I am just going to use the
dotnet new webapp --name hello
Note: dotnet-cli uses the current directory name as the project name. You can override it with
--name <project name>argument.
Test the application
It is always a good idea to test the application, before we try to containerize it, just to make sure the application is working. If there is a problem down the road, we know it is with the container and not the application itself.
We can simply do a quick test by running the applications:
You should be able to see that the dotnet-cli has started a server. From the output in the terminal, you should be able to see which port(s) the server was started on. You can just enter the address in your browser to access the application.
In my case there ports were:
Note: You might get an Invalid Certificate Error. This is expected.
Now that we know the application works, we can try to containerize it.
You can stop the server by pressing
CTRL+C. This will stop the server, and return the control of the terminal back to you.
Note: When you run the project dotnet-cli will run
dotnet buildbefore running the project.
Publish the project
When you publish the project, dotnet-cli will build the project an publish the output along with the any needed dependencies.
You can publish the project with:
dotnet publish -c Release
-c Release makes sure that dotnet-cli will build the project in Release profile, without any Debug Symbols.
The main executable for this project will be
hello.dll. dotnet-cli outputs by default a
<project name>.dll, this can be overridden by configuring the
.csproj file for the project.
dotnet-cli will publish the output to
bin/Release/netcoreapp3.1/publish/ directory by default, this can be overridden by
--output <directory> argument.
Note: Just like with
dotnet run, when you publish the project dotnet-cli will run
dotnet buildbefore published the project.
Create a DockerFile
Docker needs a docker file in order to build images and run these images in container. Dockerfile defines, how the image is build and how the content in the image can be executed.
We can simply create an empty file by:
type nul > Dockerfile
On POSIX (Linux and macOS)
Paste the following into the the newly created
Note: Make sure to use the same runtime version as the SDK you have installed on your develpoment host.
FROM mcr.microsoft.com/dotnet/core/aspnet:3.1 COPY bin/Release/netcoreapp3.1/publish/ App/ WORKDIR /App ENTRYPOINT ["dotnet", "hello.dll"]
FROM tells the Docker to which base image to use. I am using a prebuilt ASP.NET Core Runtime version 3.1.
COPY tells the Docker to copy content from the host to the image.
WORKDIR tells the Docker to switch to
/App directory in the image. It is similar to
ENTRYPOINT tells Docker what to execute. In this we want to execute
dotnet with the argument
hello.dll is compiled output's main executable.
Build the image
TO be able to use the image, we need to first build it.
docker build -t hello -f Dockerfile .
-t hello tells Docker to name the image with the name
hello, so that it is easier to reference later on.
-f Dockerfile tells the Docker to use the
Dockerfile as the build file. You can have several Dockerfiles in a single project, i.e. one for development and another for production.
. (the dot) tells the Docker to use current directory as the working directory. This is important if you are using the relative paths in the
When we list all the images we can see the image was built:
The output will show you both the image you created, and the base image Docker downloaded to build your image.
REPOSITORY TAG IMAGE ID CREATED SIZE hello latest 785c4ef006af 4 minutes ago 352MB mcr.microsoft.com/dotnet/core/aspnet 3.1 54240314fe71 3 weeks ago 347MB
Run the container
Now that was have a container image ready, we can create and run the container.
You can run the container with:
docker run -ti -p 5000:80 hello
-ti tells the Docker to run the container in TTY and interactive mode. You can use
-d for running the application in background.
-p 5000:80 tells docker to forward/expose internal port 80 to hosts port 5000.
hello is the name of the image we want to run.
You should be able to access the ASP.NET Core application in your browser when you enter
As you can see it is very easy to run a AST.NET Core application inside a Docker container.
Keep in mind this post just highlights very quickly basic of how to run a Console application in Docker.