-->

Here is a quick and dirty example of a docker container running a desktop with OpenGL apps, now remember this are all being rendered on an EC2 instance, and I am using Xpra for the display. There was some kind of font issue on this container but I am not interested in resolving that. Docker for Mac is necessary to run Docker containers. I recommend that you use the stable release unless you have an explicit purpose for the edge channel. Within the Docker container we will use: Python 3, specifically the slim-3.6.5 version from Docker Hub; Bottle version 0.12.13. Webapps with Docker. So we have now looked at docker run, played with a Docker container and also got a hang of some terminology.Armed with all this knowledge, we are now ready to get to the real-stuff, i.e. Deploying web applications with Docker!

In this tutorial, you'll learn how to containerize a .NET Core application with Docker. Containers have many features and benefits, such as being an immutable infrastructure, providing a portable architecture, and enabling scalability. The image can be used to create containers for your local development environment, private cloud, or public cloud.

In this tutorial, you:

Create and publish a simple .NET Core app
Create and configure a Dockerfile for .NET Core
Build a Docker image
Create and run a Docker container

You'll understand the Docker container build and deploy tasks for a .NET Core application. The Docker platform uses the Docker engine to quickly build and package apps as Docker images. These images are written in the Dockerfile format to be deployed and run in a layered container.

Note

This tutorial is not for ASP.NET Core apps. If you're using ASP.NET Core, see the Learn how to containerize an ASP.NET Core application tutorial.

Prerequisites

Install the following prerequisites:

.NET Core 3.1 SDK
If you have .NET Core installed, use the dotnet --info command to determine which SDK you're using.
A temporary working folder for the Dockerfile and .NET Core example app. In this tutorial, the name docker-working is used as the working folder.

Create .NET Core app

You need a .NET Core app that the Docker container will run. Open your terminal, create a working folder if you haven't already, and enter it. In the working folder, run the following command to create a new project in a subdirectory named app:

Your folder tree will look like the following:

The dotnet new command creates a new folder named App and generates a 'Hello World' console application. Change directories and navigate into the App folder, from your terminal session. Use the dotnet run command to start the app. The application will run, and print Hello World! below the command:

Docker Mac Download

The default template creates an app that prints to the terminal and then immediately terminates. For this tutorial, you'll use an app that loops indefinitely. Open the Program.cs file in a text editor.

Tip

If you're using Visual Studio Code, from the previous terminal session type the following command:

This will open the App folder that contains the project in Visual Studio Code.

The Program.cs should look like the following C# code:

Replace the file with the following code that counts numbers every second:

Save the file and test the program again with dotnet run. Remember that this app runs indefinitely. Use the cancel command Ctrl+C to stop it. The following is an example output:

If you pass a number on the command line to the app, it will only count up to that amount and then exit. Try it with dotnet run -- 5 to count to five.

Important

Any parameters after -- are not passed to the dotnet run command and instead are passed to your application.

Publish .NET Core app

Before adding the .NET Core app to the Docker image, first it must be published. It is best to have the container run the published version of the app. To publish the app, run the following command:

This command compiles your app to the publish folder. The path to the publish folder from the working folder should be .AppbinReleasenetcoreapp3.1publish

From the App folder, get a directory listing of the publish folder to verify that the NetCore.Docker.dll file was created.

Use the ls command to get a directory listing and verify that the NetCore.Docker.dll file was created.

Create the Dockerfile

The Dockerfile file is used by the docker build command to create a container image. This file is a text file named Dockerfile that doesn't have an extension.

Create a file named Dockerfile in directory containing the .csproj and open it in a text editor. This tutorial will use the ASP.NET Core runtime image (which contains the .NET Core runtime image) and corresponds with the .NET Core console application.

Note

The ASP.NET Core runtime image is used intentionally here, although the mcr.microsoft.com/dotnet/core/runtime:3.1 image could have been used.

The FROM keyword requires a fully qualified Docker container image name. The Microsoft Container Registry (MCR, mcr.microsoft.com) is a syndicate of Docker Hub - which hosts publicly accessible containers. The dotnet/core segment is the container repository, where as the aspnet segment is the container image name. The image is tagged with 3.1, which is used for versioning. Thus, mcr.microsoft.com/dotnet/core/aspnet:3.1 is the .NET Core 3.1 runtime. Make sure that you pull the runtime version that matches the runtime targeted by your SDK. For example, the app created in the previous section used the .NET Core 3.1 SDK and the base image referred to in the Dockerfile is tagged with 3.1.

Save the Dockerfile file. The directory structure of the working folder should look like the following. Some of the deeper-level files and folders have been omitted to save space in the article:

From your terminal, run the following command:

Docker will process each line in the Dockerfile. The . in the docker build command tells Docker to use the current folder to find a Dockerfile. This command builds the image and creates a local repository named counter-image that points to that image. After this command finishes, run docker images to see a list of images installed:

Notice that the two images share the same IMAGE ID value. The value is the same between both images because the only command in the Dockerfile was to base the new image on an existing image. Let's add three commands to the Dockerfile. Each command creates a new image layer with the final command representing the counter-image repository entry points to.

The COPY command tells Docker to copy the specified folder on your computer to a folder in the container. In this example, the publish folder is copied to a folder named App in the container.

The WORKDIR command changes the current directory inside of the container to App.

The next command, ENTRYPOINT, tells Docker to configure the container to run as an executable. When the container starts, the ENTRYPOINT command runs. When this command ends, the container will automatically stop.

From your terminal, run docker build -t counter-image -f Dockerfile . and when that command finishes, run docker images.

Each command in the Dockerfile generated a layer and created an IMAGE ID. The final IMAGE ID (yours will be different) is cd11c3df9b19 and next you'll create a container based on this image.

Create a container

Now that you have an image that contains your app, you can create a container. You can create a container in two ways. First, create a new container that is stopped.

The docker create command from above will create a containe

Run Mac App In Docker