{"id":4156,"date":"2015-08-20T16:49:02","date_gmt":"2015-08-20T16:49:02","guid":{"rendered":"https:\/\/ushipblogsubd.wpengine.com\/?p=4156"},"modified":"2025-09-03T16:06:44","modified_gmt":"2025-09-03T16:06:44","slug":"net-web-applications-running-docker","status":"publish","type":"post","link":"https:\/\/ushipblogsubd.wpengine.com\/shipping-code\/net-web-applications-running-docker\/","title":{"rendered":".NET Web Applications Running in Docker"},"content":{"rendered":"

Here at uShip, we love to try interesting things during our hackathons. Recently, Greg Walker<\/a> and I decided to try to get one of our front-end solutions up and running in a docker container. Since docker<\/a> containers have to run on Linux, that meant getting the project running on Mono<\/a> first.<\/p>\n

Installing Mono<\/h2>\n

To start, we set up a Ubuntu 14.04 virtual machine. The first thing we did when we got the box setup is installed MonoDevelop, which installed all the Mono dependencies for us. I would recommend following the installation instructions<\/a> provided by the Mono Project. The latest version of Mono in Ubuntu\u2019s repositories at the time of this post (3.2.8) were out of date and caused additional problems. Use at least Mono version 4.0.2 and MonoDevelop version 5.9.5. Once you get the official Mono repositories setup. You can install MonoDevelop with the command sudo apt-get update && sudo apt-get install monodevelop<\/span>.<\/p>\n

Building in MonoDevelop<\/h2>\n

The first step we took was to try to clone our repository in Linux and attempt to build it in MonoDevelop. Unfortunately, one of our test projects refused to load because the project type wasn\u2019t supported. We decided to ignore this error and unload that test project since we weren\u2019t planning on running any tests for this example.<\/p>\n

\"\"<\/p>\n

 <\/p>\n

We attempted to build our project in Mono, but we had a few assembly versioning issues. Luckily, these are only warnings that MonoDevelop treats as errors, thus we decided to turn those errors off and move onward.<\/p>\n

\"\"<\/p>\n

 <\/p>\n

Once we made these changes, our project was building successfully.<\/p>\n

Running with Mono<\/h2>\n

Once we solved the issues with getting the solution building on Linux, it was just a matter of fixing our code to make everything work in the new environment.<\/p>\n

To start up a web server to host our MVC project, we used xsp4<\/a>. You can install this by running sudo apt-get install mono-xsp4<\/span>. To get this up and running, we ran the command xsp4<\/span> in our project\u2019s root directory which got a server up and running on port 8080.<\/p>\n

Missing Assemblies<\/h3>\n

The first code-related issue we ran into was assemblies that live in the Global Assembly Cache (GAC) on Windows were not found on Linux. We fixed this by copying the DLLs over and placing them in the bin directory. Another solution to this problem is to add it to Mono\u2019s GAC. This can be done by running the following command gacutil -i <assembly><\/span>. If you are trying to add any delayed-signed assemblies to the GAC, add the -bootstrap<\/span> option before specifying the assembly.<\/p>\n

We fixed several of these missing assembly errors until we started getting new exceptions that had our code in the stack traces. Once we saw our methods in the stack traces, this told us that Mono was able to begin executing our code!<\/p>\n

Loading our Configuration<\/h3>\n

The next major issue was in the way we locate our external configuration files.<\/p>\n

In our code, when we look for our configuration files, we start by calling Server.MapPath(“\/”)<\/span> in order to get the root directory. Unfortunately, this doesn\u2019t quite work in Mono, and instead we needed to change it to Server.MapPath(“~”)<\/span>. This works in both Mono and in .NET, so this is likely the correct way to do it, anyway.<\/p>\n

For Linux file systems, letter case matters! We had several places in our code where we looked for files without the proper casing. Solving this was simple, but tracking it down took quite a bit of time stepping through code and very thoroughly analyzing every filename in our code to make sure it matched what was on disk.<\/p>\n

Differences in Mono<\/h2>\n

Now that configuration files were loading, we could actually use our site. We ran into one problem that was due to differences between Mono and Microsoft\u2019s .NET Runtime.<\/p>\n

CultureInfo Implementations<\/h3>\n

Deep in our localization code, we do a check to see if a culture is the InvariantCulture<\/a>. To do this, we were comparing the culture\u2019s ThreeLetterISOLanguageName<\/span> to a constant string “ivl”<\/span>.<\/p>\n

[cc lang=”csharp”]
\nprivate const string InvariantCultureCode = “ivl”;
\npublic static CultureSpecificity Specificity(this CultureInfo culture)
\n{
\nif (culture.ThreeLetterISOLanguageName == InvariantCultureCode)
\n{
\nreturn CultureSpecificity.Default;
\n}
\n\/\/…
\n}
\n[\/cc]<\/p>\n

This works in Windows, where the ThreeLetterISOLanguageName<\/span> is all lower case. But, in Mono, it is all uppercase and this check was not passing when it should have. To solve this error, we changed the code to compare the culture to CultureInfo.InvariantCulture<\/span>. Doing so removes the need for the constant string and the ThreeLetterISOLanguageName<\/span>.<\/p>\n

[cc lang=”csharp”]
\npublic static CultureSpecificity Specificity(this CultureInfo culture)
\n{
\nif(culture.Equals(CultureInfo.InvariantCulture))
\n{
\nreturn CultureSpecificity.Default;
\n}
\n\/\/…
\n}
\n[\/cc]<\/p>\n

This is the only difference we encountered when running on Mono, which was a huge surprise to us. We were expecting many more things to not work quite right, but had no clue what might go wrong.<\/p>\n

Installing Docker<\/h2>\n

Setting up docker on our Ubuntu 14.04 virtual machine was straight forward. We were able to follow the docker installation instructions for Linux<\/a> and got up and running quickly.<\/p>\n

The technologies that docker relies on<\/a> are only available in Linux. Installing docker on Windows<\/a> or OSX<\/a> requires running a Linux virtual machine that hosts your containers.<\/p>\n

Setting up our Docker Container<\/h2>\n

Setting up our docker container proved to be the least convoluted part of this experiment. We decided to use the official Mono container from Docker Hub<\/a> which saved us a bit of time scripting out the installation of Mono in our own container.<\/p>\n

Dockerfile<\/b><\/p>\n

FROM mono:4.0\r\nRUN apt-get update && apt-get -y install mono-xsp4\r\nADD . \/app\/\r\n# RUN gacutil -i -bootstrap assembly_1.dll\r\n# RUN gacutil -i -bootstrap assembly_2.dll\r\nWORKDIR \/app\r\nEXPOSE 9000\r\nENTRYPOINT [\"xsp4\", \"--port=9000\", \"--nonstop\"]\r\n<\/pre>\n
What this configuration file is doing:<\/p>\n