Table of Contents
In this tutorial, we will use multi-stage Docker builds to illustrate how we can build an application in the first stage and in next stage, use the output from first stage to create an application image. A multi-stage build is done by creating different sections of a Dockerfile, each referencing a different base image. This allows a multi-stage build to fulfill a function previously filled by using multiple docker files, copying files between containers, or running different pipelines.
Refer to section Create new console application in Create your first .Net Core console application on Ubuntu to understand basics about how to create .Net Core console application. We will re-use the application created here.
Multi-stage docker file
In the application build stage, we will use mcr.microsoft.com/dotnet/core/sdk:2.1 as base image. We will copy source code inside the container and publish a self-contained application. We will use linux-musl-x64 as runtime configuration since we are using Apline as base image as mentioned below. Output for this stage will be available in /source/bin/Release/netcoreapp2.1/linux-musl-x64/publish/.
Next stage we will create application image which will consume the output from build stage. We will use amd64/alpine:3.12 as base image this time. It is a very small image with size 5.57 MB. However, to be able to sucessfully run .Net Core applications, we will need to install few packages. The list of packages is mentioned in https://github.com/dotnet/dotnet-docker/blob/master/src/runtime-deps/2.1/alpine3.12/amd64/Dockerfile.
We will also add two environment variables DOTNET_RUNNING_IN_CONTAINER and DOTNET_SYSTEM_GLOBALIZATION_INVARIANT and set them to true as suggested by Microsoft.
DOTNET_RUNNING_IN_CONTAINER variable is used to detect whether the .Net Core application is running inside the docker.
DOTNET_SYSTEM_GLOBALIZATION_INVARIANT is used to enable Globalization Invariant Mode. In earlier tutorial we had used by adding following line under <PropertyGroup> tag in hellodocker.csproj:
Hence, we can remove that line from hellodocker.csproj this time.
Final Dockerfile contents:
Dockerfile
To increase the build's performance, exclude files and directories, create a .dockerignore file in the same directory as Dockerfile with following contents:
.dockerignore
Now that our Dockerfile is ready along with .dockerignore file, we can run docker build command like below:
We have tagged the image with 3.0, so that we can differntiate it with earlier docker images created earlier for hellodocker application. We will use the earlier images to do a size comparison later.
Sample output from docker build command:
We can verify that the hellodocker application still runs without any issue with below command:
Sample output:
Docker size comparison
Now let us try to do a size comparison for docker images created earlier with the latest image:
Sample output:
hellodocker:1.0 was created with mcr.microsoft.com/dotnet/core/runtime:2.1 as base image. This base image itself has size of around 180 MB. As our application was not published as self-contained, it required .Net runtime installed to run. Appllication size was only 24 KB.
hellodocker:2.0 was created with ubuntu:18.04 as base image. This base image still has size of around 64 MB. Our application was published as self-contained, it did not require .Net runtime installed to run. However, application size had grown to 71.2 MB. Hence, the resultant size of image was 138 MB.
hellodocker:3.0 we have created just now uses alpine:3.12 as base image. This base image is just 5.57 MB in size. But in order to run .Net Core applications, we have to install few packages as mentioned in the Dockerfile. Here the size of docker image is just 86.4 MB. That is a significant reduction in size in comparison to 180 MB.
Sample output:
In .Net Core 3.0 onward, there is an additional option p:PublishTrimmed to further reduce the size of self-contained executable. We will cover that option as well in another tutorial. You can refer to link given in References section below to take a look at it.
References
- https://github.com/dotnet/core/blob/master/Documentation/linux-prereqs.md
- https://github.com/dotnet/dotnet-docker/blob/master/src/runtime-deps/2.1/alpine3.12/amd64/Dockerfile