microsoft's leading web development framework for constructing server-side applications is asp.net. docker has assured that it supports asp.net because it has been around for a long time for development.

table of content

what is .net application?
why is containerizing a .net application is important?
what are asp.net core docker images?
how to setup and execute .net applications in docker?
how to installing the asp.net container in windows?
usage of .dockerignore
how to create dockerfile?
how to optimize your dockerfile for dotnet restore?
how to use multi-stage build?
how to create a docker container?
essential docker commands
how to clean up resources?
adding healthchecks to your containers
choosing appropriate isolation mode for windows containers
how to run linux and windows containers?
how to build and deploy a dockerfile?
containerize asp.net applications - faqs

what is a .net application?

a .net application is a software program that is developed using the .net framework. it facilitates providing a comprehensive platform for building and running applications on windows, macos, and linux. it comes with supporting multiple programming languages such as c#, f#, and visual basic facilitating the developers to create a wide range of applications from web and mobile to desktop and cloud-based solutions. the .net framework provides strong security features with efficient performance and seamless integration with other microsoft technologies.

why is containerizing a .net application is important?

the following are the reasons for containerizing a .net application:

portability: containerizing the .net application provides consistency minimize across the different environments including development, testing, lightweight and production.
isolation: the containers come with lightweight consistency, and isolated environments for running the applications to minimize, conflicts and operate reliably and effectively.
scalability: through containerizing the application scaling up or down will become easier based on the amount of traffic.
devops practices: containerization of .net application helps in practising the devops principles promoting the automation, collaboration and ci/cd.

what are asp.net core docker images?

asp.net core docker images are the pre-configured containers that designed to facilitate the deployment and execution of asp.net applications within the docker environments. these images serve as ready-to-use templates with containing all the needed components such as asp.net core runtime, dependencies and configurations. it helps in simplifying the deployment process to promote the consistency and enhance scalability as isolated containers

how to setup and execute .net applications in docker?

the following steps must be completed before executing asp.net

step 1: because this is only compatible with windows computers, you must first guarantee that you have either windows 10 or windows server 2016.

step 2: next, make sure hyper-v and containers are installed on your windows system. go to turn windows features on or off to install hyper-v and containers.

then, check the hyper-v and containers options and press the ok button.

after this procedure, the system may need to be restarted.

step 3: then, use the powershell command below to install the docker 1.13.0rc4 version. the following command will download it and save it to a temporary place.

invoke-webrequest "https://test.
docker.com/builds/windows/x86_64/docker-1.13.0-
rc4.zip" -outfile "$env:temp\docker-1.13.
0-rc4.zip" –usebasicparsing

step 4: the archive must then be expanded using the powershell command below.

expand-archive -path "$env:temp\
docker-1.13.0-rc4.zip" 
-destinationpath $env:programfiles

step 5: next, use the following powershell command to add the dockerfiles to the environment variable.

$env:path += ";$env:programfiles\docker"

step 6: use the powershell command to register the docker daemon service.

dockerd --register-service

step 7: finally, use the following command to start the docker daemon.

start-service docker

to ensure that the docker daemon is operational, use the docker version command in powershell.

create a sample dockerfile for .net application

dockerfile is a text file that contains a set of instructions that define docker image template. docker build reads this instructions from top to bottom and build the docker image as a read-only template. in creating dockerfile involves with defining the instructions such as

starting with a base image with from keyword
setting the working directory using workdir
copying the files from local to and from container using copy
specifying regard expose of ports with expose keyword
defining the runtime command with cmd keyword

the following is the sample dockerfile of asp.net application:

# use the official asp.net core runtime as the base image
from mcr.microsoft.com/dotnet/aspnet:6.0 as base
  # set the working directory for the base image
  workdir /app
  # expose port 80 for web traffic
  expose 80

# use the official asp.net core sdk as the build image
from mcr.microsoft.com/dotnet/sdk:6.0 as build
  # set the working directory for the build image
  workdir /src

# copy project file and restore dependencies
copy ["myaspnetapp/myaspnetapp.csproj", "myaspnetapp/"]run dotnet restore "myaspnetapp/myaspnetapp.csproj"

# copy the rest of the application code
copy . .

# build the application in release mode
workdir "/src/myaspnetapp"
run dotnet build "myaspnetapp.csproj" -c release -o /app/build

# publish the application in release mode
from build as publish
  run dotnet publish "myaspnetapp.csproj" -c release -o /app/publish

# create the final image
from base as final
  # set the working directory for the final image
  workdir /app
  # copy published application from publish stage
  copy --from=publish /app/publish .
  # set the entrypoint to run the application on startup
  entrypoint ["dotnet", "myaspnetapp.dll"]

to know more about dockerfile refer this - article

how to deploy the asp.net container in windows?

let's look at how to set up the asp.net container, the following steps guide you in installing the asp.net containers in windows:

step 1: the first step is to get the docker hub image. when you connect to docker hub, you will be able to search and view the microsoft/aspnet image, as shown below.

simply enter asp into the search box and click on the microsoft/aspnet link that appears in the search results.

step 2: the docker pull command for asp.net will be shown in the repository metadata on docker hub.

step 3: run the docker pull command for the microsoft/aspnet image on docker host. it's worth noting that the image is quite large, around 4.2 gb.

step 4: now, navigate to https://github.com/microsoft/aspnet-docker and download the full git repository.

step 5: make an app folder in your c drive. then, on your c drive, copy the contents of the 4.6.2/sample folder. go to the dockerfile in the sample directory and run the command.

docker build –t aspnet-site-new –build-arg site_root=/

the following points should be observed regarding the preceding command:

the docker file is used to create a new image called aspnet-site-new.
the local path folder is specified as the root path.

step 6: it's now time to start the container.

docker run –d –p 8000:80 –name my-running-site-new aspnet-site-new

step 7: iis will now be operating within the docker container. to determine the ip address of a docker container, use the docker inspect command, as illustrated below.

inspect -f "{{ .networksettings.networks.nat.ipaddress }}" my-running-site-new

usage of .dockerignore

the following points helps in the usage of .dockerignore:

optimize build context: the .dockerignore file helps in reducing the docker context size by specifying the excluding files and directories to fasten more efficient docker builds.
improve security: by ignoring the sensitive files that regarding credentials, configuration excluding in the dockerfile is the best practice with .dockerignore.
reduce image size: through excluding the files and directories with the helps of .dockerignore helps in reducing the size of the final image size.

the following is sample created .dockerignore file, in this file we specified some of files and file formats that we wanted to excluded in the docker build context.

# ignore node_modules directory
node_modules

# ignore local development files
*.log
*.env

# ignore build and temp directories
dist
tmp

how to optimize your dockerfile for dotnet restore?

the following are insights on optimizing the dockerfile for dotnet restoration:

use caching layers: place the copy instruction for the .csproj file and the run dotnet restore command early in the dockerfile. this allows docker to cache the restore layer and reuse it if dependencies don't change, avoiding unnecessary restores during subsequent builds.
minimize context changes: only copy the project files required for dotnet restore before running the restore command. copy the rest of the source code afterwards to avoid invalidating the cache.
separate dependencies from source code: copy and restore dependencies before copying the entire source code. this ensures that changes in the source code do not invalidate the dependency cache.

the following is the sampele example of optimized dockerfile with these optimized techniques:

# use the official asp.net core runtime as the base image
from mcr.microsoft.com/dotnet/aspnet:6.0 as base
workdir /app
expose 80

# use the official asp.net core sdk as the build image
from mcr.microsoft.com/dotnet/sdk:6.0 as build
workdir /src

# copy the project file and restore dependencies
copy ["myaspnetapp/myaspnetapp.csproj", "myaspnetapp/"]
run dotnet restore "myaspnetapp/myaspnetapp.csproj"

# copy the rest of the application code
copy . .

workdir "/src/myaspnetapp"
run dotnet build "myaspnetapp.csproj" -c release -o /app/build

# publish the application
from build as publish
run dotnet publish "myaspnetapp.csproj" -c release -o /app/publish

# create the final stage/image
from base as final
workdir /app
copy --from=publish /app/publish .
entrypoint ["dotnet", "myaspnetapp.dll"]

how to use multi-stage build for .net application ?

the following are some of the insights on the usage of multi-stage build:

reduce image size: multi-stage builds facilitates to use intermediate stages for building, compiling the code and then copy only the necessary artifacts to the final stage, reducing the final image size significantly.
improve security: on excluding the build tools and dependencies from the final image, multi-stage build reduces the attack surfacce and potential vulnerabilities.
streamline build process: multi-stage builds simplifies the dockerfile by isolating the build and runtime environments making the easier of management.

the following is an example for multi-stage build with asp.net core application:

# stage 1: build the application
from mcr.microsoft.com/dotnet/sdk:6.0 as build
workdir /src
copy ["myaspnetapp/myaspnetapp.csproj", "myaspnetapp/"]
run dotnet restore "myaspnetapp/myaspnetapp.csproj"
copy . .
workdir "/src/myaspnetapp"
run dotnet build "myaspnetapp.csproj" -c release -o /app/build

# stage 2: publish the application
from build as publish
run dotnet publish "myaspnetapp.csproj" -c release -o /app/publish

# stage 3: create the runtime image
from mcr.microsoft.com/dotnet/aspnet:6.0 as final
workdir /app
copy --from=publish /app/publish .
entrypoint ["dotnet", "myaspnetapp.dll"]

to know more about multi stage dockerfile refer this - aritcle

how to create a docker container?

the following are the steps that guides in creating a docker container:

step 1: create a dockerfile

create a dockerfile with specifying the instructions on building the container.

# use the official node.js base image
from node:14
workdir /app
copy package*.json ./
run npm install
copy . .
expose 3000
cmd ["node", "app.js"]

step 2: build a docker image

now, using the docker build command create a docker image from the created dockerfile with the following command:

docker build -t my-node-app .

step 3: run the docker container

use the following docker run command to start a new container from the image, here running container on port 3000.

docker run -d -p 3000:3000 my-node-app

step 4: verify the container running state

check the list of the running containers in the list with the following command:

docker ps

step 5: access the application

open the web browser and navigate to http://localhost:3000 to access your application

http://localhost:3000

step 6: manage the container

stop the docker running the state using its container name or id, the command looks as follows:

docker stop <container_id>

to remove the container use the following command:

docker rm <container_id>

to know more on how to create a docker container refer this - article

essential docker commands

the following are the some of the essential docker commands:

1. docker build

the following command is used for building an image from a dockerfile

docker build -t my-img .

2. docker run

the following command is used for creating and starting a container from an image.

docker run -d -p 8080:80 my-img

3. docker ps

the following command helps in listing the running containers

docker ps

4. docker images

the following command is used for listing the docker images.

docker images

5. docker stop

the following command is used to stop a running docker container:

docker stop container_name

to know more about essential docker commands, refer this - article

how to clean up resources?

the following are commands are used to clean up the docker resources and reclaim the disk space:

1. remove unused containers

the following command removes all the stopped containers:

docker container prune

2. remove unused images

the following command helps in removing all the dangling images:

docker image prune

3. remove unused volumes

the following command is used for removing all the unused volumes:

docker volume prune

4. remove unused networks

the following command is used for removing all the unused networks:

docker network prune

5. remoe all unused resources

this command removes all the stopped containers, dangling images, unused volumes and networks:

docker system prune

adding healthchecks to your containers

adding healthchecks to your containers ensures that your applications are running smoothly and can automatically handle failures. docker allows you to define healthchecks for your containers, which periodically check the status of your application and report it back to docker.

you can add a healthcheck to your dockerfile using the healthcheck instruction, specifying a command that docker will run to determine the health of the container. for example, in a node.js application, you can check if the server is responding to http requests:

from node:14

# set working directory
workdir /app

# copy package.json and package-lock.json
copy package*.json ./

# install dependencies
run npm install

# copy the rest of the application code
copy . .

# expose port
expose 3000

# define healthcheck
healthcheck --interval=30s --timeout=3s cmd curl -f http://localhost:3000/ || exit 1

# command to run the application
cmd ["node", "app.js"]

choosing appropriate isolation mode for windows containers

the following are the some of the appropriate isolation modes for windows containers:

process isolation: it offer comptability and performance by coming with lightweight isolation. it is suitable for running multiple applications on the same host.
hyper-v isolation: it offers enhanced security and isolation with uitlizing the hardware virtualization. it is ideal for untrusted workloads or security requirements.
nesting considerations: it comes with proces isolation that allows the container nesting. the hyper-v isolation does not support nesting.
performance vs security: the process isolation offers better performance with providing stronger security.

how to run linux and windows containers?

running linux and windows containers on the same host requires a mixed-os environment and platform support. here's how to do it effectively:

ensure platform compatibility: ensure that the host sytem and docker engine support running both the linux and windows containers such as docker desktop softwares..
select the container os: determine whether you want to run linux or windows containers. linux containers are light weighted used for microservices and cloud native applications, whereas windows containers are suitable for applications that are built on microsoft systems.
set docker engine mode: switching the docker engine to the appropriate mode for running linux or windows containers. through using the docker desktop we can switch between the linux and windows containers using the sytem tray icon.

how to build and deploy a dockerfile?

the following steps guides you on building and deploying a dockerfile:

step 1: create a dockerfile specifying the instructiosn to build the container image.

step 2: build an image by running the below command with specifying the dockerfile path:

docker build -t my-img .

step 3: tag the image with a docker hub account ( docker repository ) and a tag for a easier identification. the command looks as follows:

docker tag my-img myrepo/my-img:latest

step 4: push image to repository

push the docker image to a docker registry like docker hub for distribution and deployment. the command looks as follows:

docker push my-repo/my-image:latest

step 5: pull the image on deployment environment

on the deployment environment, pull the docker image from the registry using the following command:

docker pull myrepo/my-image:latest

step 6: run the container

deploy the docker container on the deployment environment using docker run. the command looks as follows:

docker run -d -p 8080:80 myrepo/my-image:latest

to know more on how to build and deploy a dockerfile, refer this - article

comment

article tags:

devops

Save or share this article