{"id":14916,"date":"2015-01-14T09:13:00","date_gmt":"2015-01-14T09:13:00","guid":{"rendered":"https:\/\/blogs.msdn.microsoft.com\/webdev\/2015\/01\/14\/running-asp-net-5-applications-in-linux-containers-with-docker\/"},"modified":"2024-01-22T14:01:29","modified_gmt":"2024-01-22T22:01:29","slug":"running-asp-net-5-applications-in-linux-containers-with-docker","status":"publish","type":"post","link":"https:\/\/devblogs.microsoft.com\/dotnet\/running-asp-net-5-applications-in-linux-containers-with-docker\/","title":{"rendered":"Running ASP.NET 5 applications in Linux Containers with Docker"},"content":{"rendered":"

As a part of our ASP.NET 5 cross-platform efforts, we are actively working on making applications written in ASP.NET 5 easy to deploy and ship on Linux and Mac OS X. A while ago, we have released the first official Docker image by Microsoft: the ASP.NET 5 Preview Docker Image<\/a>.<\/p>\n

Docker<\/a> is an open source project that makes it easier to run applications in sandboxed application containers on Linux. With the ASP.NET 5 Docker image, you can get a base image where the ASP.NET 5 bits are already installed to run on Linux for you. All you need to do is add your application to the image and ship it so it will run in an app container!<\/p>\n

\n

Hey, look at that @aspnet<\/a> 5 docker image in the Docker Repository. https:\/\/t.co\/hfBmVUgrwK<\/a><\/p>\n

— The ASP.NET Team (@aspnet) November 14, 2014<\/a><\/p><\/blockquote>\n

 <\/p>\n

In this tutorial we will show how a simple application written in ASP.NET 5 Preview can be deployed to a Linux Virtual Machine running on Microsoft Azure cloud using Docker. The tutorial can be executed on a Linux or Mac OS X machine where Docker client is installed (or you can ssh into the Linux VM you will use). Once Windows client for Docker is available, you will be able to run these commands on Windows and once Windows Server container support comes out you will be able to use Docker to manage Windows Server containers.<\/p>\n

\n

NOTE<\/strong>: Both ASP.NET 5 (vNext) and the Docker image are in preview and the following instructions are subject to change in the future. Please refer to Docker Hub<\/a> page and GitHub repository<\/a> for latest documentation on how to use the Docker image for ASP.NET 5.<\/p>\n<\/blockquote>\n

Step 1: Create a Linux VM with Docker<\/h2>\n

As Docker only runs on Linux today, you will need a Linux machine or VM to run Docker on your server. You can find Docker installation instructions here<\/a> or follow the Getting Started with Docker on Azure<\/a> to get a Docker-ready Linux VM on Azure.<\/p>\n

In this tutorial we will assume you have a Linux Virtual Machine on Azure with Docker installed. If you are using some other machine, most of this tutorial will still be relevant.<\/p>\n

Step 2: Create a container image for your app<\/h2>\n

In order to deliver your ASP.NET application to the cloud, you will need to create a container image containing your application.<\/p>\n

Docker container images are layers on top of each other. This means your application is an addition on top of a “base image” –in this case the base image will be microsoft\/aspnet<\/code><\/a>. The image layers are stored as diffs, therefore while deploying your application, your image will not contain the Linux distribution or the ASP.NET binaries; it will only contain your application, making it small in size and quickly deployable.<\/p>\n

Creating a Docker image is done using a file called Dockerfile<\/code>. Similar to a Makefile, the Dockerfile contains instructions telling Docker how to build the image.<\/p>\n

For the sake of this tutorial, we will use the sample HelloWeb<\/code> application<\/a> from aspnet\/Home<\/a> repository on GitHub. First, clone this repository on your development machine and go to the HelloWeb<\/code> directory using git:<\/p>\n

\n
git clone git@github.com:aspnet\/Home.git aspnet-Home\r\ncd aspnet-Home\/samples\/HelloWeb<\/pre>\n<\/blockquote>\n
In this directory you will see the following files:<\/p>\n
\n
\u251c\u2500\u2500 Startup.cs\r\n\u251c\u2500\u2500 image.jpg\r\n\u2514\u2500\u2500 project.json<\/pre>\n<\/blockquote>\n
We are going to create a file called Dockerfile<\/code> in this directory with the following contents:<\/p>\n
\n
FROM microsoft\/aspnet\r\n\r\nCOPY . \/app\r\nWORKDIR \/app\r\nRUN [\"dnu\", \"restore\"]\r\n\r\nEXPOSE 5004\r\nENTRYPOINT [\"dnx\", \"-p\", \"project.json\", \"kestrel\"]<\/pre>\n<\/blockquote>\n
Let’s go through this Dockerfile line by line. The first FROM<\/code> line tells Docker that we will use the official ASP.NET image<\/a> on Docker Hub as our base image.<\/p>\n
The COPY<\/code> line tells Docker that we will copy contents of this folder (.<\/code>) to the \/app<\/code> directory of the container and the WORKDIR<\/code> instruction will move to the \/app<\/code> directory.<\/p>\n
The RUN<\/code> instruction tells Docker to run the dnu restore<\/code> command to install the dependencies of the application. We do this before running out application for the first time.<\/p>\n
The EXPOSE<\/code> instruction will inform Docker that this image has a service which will be listening at port 5004 (see project.json<\/code> of the sample file for details). Lastly, the ENTRYPOINT<\/code> instruction is the command executed to start the container and keep it up and running. In this case it is the “dnx . kestrel\" <\/code>command, starting the Kestrel<\/a> development server for ASP.NET 5. Once executed, this process will start listening to HTTP connections coming from port 5004. <\/p>\n
Step 3: Build the container image<\/h2>\n
Once we have Dockerfile ready, the directory should look like this, a Dockerfile residing with next to the application:<\/p>\n
\n
\u251c\u2500\u2500 Dockerfile\r\n\u251c\u2500\u2500 Startup.cs\r\n\u251c\u2500\u2500 image.jpg\r\n\u2514\u2500\u2500 project.json<\/pre>\n<\/blockquote>\n
Now we will actually build the Docker image. It is very simple –just run the following Docker command in this directory:<\/p>\n
\n
docker build -t myapp .<\/pre>\n<\/blockquote>\n
This will build an image using the Dockerfile we just created and call it myapp<\/code>. Every time you change your application, a new image can be built using this command. After this command finishes, we should be able to see our application in the list of Docker images on our Linux VM by running the following command on our development machine:<\/p>\n
\n
$ docker images\r\nREPOSITORY          TAG                 IMAGE ID            CREATED             VIRTUAL SIZE\r\nmyapp               latest              ccb7994d2bc1        39 seconds ago      499.8 MB\r\nmicrosoft\/aspnet    latest              16b1838c0b34        12 days ago         473.4 MB\r\n<\/pre>\n<\/blockquote>\n
As you can see, your app and the ASP.NET image are listed as images that exist on your machine.<\/p>\n
Now we are ready to deploy our application to the cloud.<\/p>\n
Step 4: Run the container<\/h2>\n
Running the container is the easiest part of the tutorial. Run the following Docker command on your development machine:<\/p>\n
\n
docker run -t -d -p 80:5004 myapp<\/pre>\n<\/blockquote>\n