.NET is a free, open-source development platform for building numerous apps, such as web apps, web APIs, serverless functions in the cloud, mobile apps and much more. .NET is a general purpose development platform maintained by Microsoft and the .NET community on GitHub. It is cross-platform, supporting Windows, macOS and Linux, and can be used in device, cloud, and embedded/IoT scenarios.

Docker is quite popular among the .NET community. .NET Core can easily run in a Docker container. .NET has several capabilities that make development easier, including automatic memory management, (runtime) generic types, reflection, asynchrony, concurrency, and native interop. Millions of developers take advantage of these capabilities to efficiently build high-quality applications.

Building the Application

In this tutorial, you will see how to containerize a .NET application using Docker Compose. The application used in this blog is a Webapp communicating with a Postgresql database. When the page is loaded, it will query the Student table for the record with ID and display the name of student on the page.

What will you need?

Getting Started

Visit https://www.docker.com/get-started/ to download Docker Desktop for Mac and install it in your system.

Once the installation gets completed, click “About Docker Desktop” to verify the version of Docker running on your system.

If you follow the above steps, you will always find the latest version of Docker desktop installed on your system.

1. In your terminal, type the following command

dotnet new webApp -o myWebApp --no-https

The `dotnet new` command creates a .NET project or other artifacts based on a template.

You should see the output in terminal

This will bootstrap a new web application from a template shipped with dotnet sdk. The -o parameter creates a directory named myWebApp where your app is stored.

2. Navigate to the application directory

cd myWebApp

you will have a list of files –

3. In your terminal, type the following command to run your application

The dotnet run command provides a convenient option to run your application from the source code.

dotnet run

The application will start to listen on port 5000 for requests

4. Test the application

Run the curl command to test the connection of the web application.

# curl http://localhost:5000

5. Put the application in the container

In order to run the same application in a Docker container, let us create a Dockerfile with the following content:

This is a Multistage Dockerfile. The build stage uses SDK images to build the application and create final artifacts in the publish folder. Then in the final stage copy artifacts from the build stage to the app folder, expose port 80 to incoming requests and specify the command to run the application myWebApp.

Now that we have defined everything we need to run in our Dockerfile, we can now build an image using this file. In order to do that, we’ll need to run the following command:

$ docker build -t mywebapp

We can now verify that our image exists on our machine by using docker images command:

In order to run this newly created image, we can use the docker run command and specify the ports that we want to map to and the image we wish to run.

$ docker run --rm - p 5000:80 mywebapp

• - p 5000:80– This exposes our application which is running on port 80 within our container on http://localhost:5000 on our local machine.
• --rm – This flag will clean the container after it runs
• myweapp – This is the name of the image that we want to run in a container.

Now we start the browser and put http://localhost:5000 to address bar

Update application

The myWebApp and Postgresql will be running in two separate containers, and thus making this a multi-container application.

1.  Add package to allow app talk to database

Change directory to myWebapp and run the following command:
dotnet add package Npgsql.EntityFrameworkCore.PostgreSQL

2. Create student model

• Create a Models folder in the project folder
• Create Models/Student.cs with the following code:

3. Create the `SchoolContext` with the following code:

4. Register SchoolContext to DI in Startup.cs

5. Adding database connection string to `appsettings.json`

6. Bootstrap the table if it does not exist in Program.cs

Update the UI

Index.cshtml

and Index.cshtml.cs

Configuration file

The entry point to Docker Compose is a Compose file, usually called docker-compose.yml

In the project directory, create a new file docker-compose.yml in it. Add the following contents:

In this Compose file:

• Two services in this Compose are defined by the name db and web attributes; the adminer service is a helper for us to access db
• Image name for each service defined using image attribute
• The postgres image starts the Postgres server.
• environment attribute defines environment variables to initialize postgres server.
  • POSTGRES_PASSWORD is used to set the default user’s, postgres, password. This user will be granted superuser permissions for the database my_db in the connectionstring.
• app application uses the  db service as specified in the connection string
• The app image is built using the Dockerfile in the project directory
• Port forwarding is achieved using ports attribute.
• depends_on attribute allows to express dependency between services. In this case, Postgres will be started before the app. Application-level health checks are still the user’s responsibility.

Start the application

All services in the application can be started, in detached mode, by giving the command:

docker-compose up -d

An alternate Compose file name can be specified using -foption.

An alternate directory where the compose file exists can be specified using -p option.

This shows the output as:

The output may differ slightly if the images are downloaded as well.

Started services can be verified using the command docker-compose ps:

This provides a consolidated view of all the services, and containers within each of them.

Alternatively, the containers in this application, and any additional containers running on this Docker host can be verified by using the usual docker container ls command

Service logs can be seen using docker-compose logs command, and looks like:

Verify application

Let’s access the application. In your browser address bar type http://localhost:5000

you will see the page show no student name since the database is empty.

Open a new tab with address http://localhost:8080 and you will be asked to login:

Use postgres and example as username/password to login  my_db. Once you are logged in, you can create a new student record as shown:

Next, refresh the app page at http://localhost:5000, the new added student name will be displayed:

Shutdown application

Shutdown the application using docker-compose down:

This stops the container in each service and removes all the services. It also deletes any networks that were created as part of this application.

Conclusion

We demonstrated the containerization of .NET application and the usage of docker compose to construct a two layers simple web application with dotnet. The real world business application can be composed of multiple similar applications, ie. microservice application, that can be described by docker compose file. The same process in the tutorial can be applied to much more complicated applications.