A Docker container image is a lightweight, standalone, executable package of software that includes everything needed to run an application: code, runtime, system tools, system libraries and settings.

Container images become containers at runtime and in the case of Docker containers - images become containers when they run on Docker Engine. Containerized software will always run the same, regardless of the infrastructure. Containers isolate software from its environment and ensure that it works uniformly despite differences for instance between development and staging.¹

In modern deployment strategies, a container is used to create scalable web applications in cloud environments such as Azure, AWS or Google Cloud. On Microsoft Azure, containerized applications can be deployed to Azure Service Fabric. Service Fabric applications run on a cluster, a network-connected set of virtual or physical machines.

This very simple example shows how to create a Docker image based on the standard Microsoft Windows Server Core image which is essentially a Windows Server 2016.

A Docker image is created automatically based on a Dockerfile by reading the instructions. The following steps are required to prepare a build process:

1. Create a new folder named TextControlDocker that contains the following sub-folders and files:

   • Folder named deployment_txservice
   • Folder named deployment_webapplication
   • A text file named Dockerfile (no extension)

   

2. In the folder deployment_txservice, copy all redistributable files required to deploy the TX Text Control Windows Service. Based on the components you are deploying, the folder should look similar to this screenshot:

   

3. In the folder deployment_webapplication, copy all required files required for your ASP.NET web application that uses TX Text Control .NET Server and the HTML5 based editor. This folder should look similar to the following screenshot:

   

4. The Dockerfile should have the following content:

   FROM microsoft/windowsservercore:latest
   ADD ./deployment_txservice/ /txserver/
   ADD ./deployment_webapplication/ /inetpub/wwwroot/
   
   SHELL ["powershell"]
   
   RUN Install-WindowsFeature NET-Framework-45-ASPNET ; \
       Install-WindowsFeature Web-Asp-Net45 ; \
           Install-WindowsFeature Web-Server ; \
           Install-WindowsFeature Web-WebSockets
   
   ADD "http://download.microsoft.com/download/2/E/6/2E61CFA4-993B-4DD4-91DA-3737CD5CD6E3/vcredist_x64.exe" "/vcredist_x64.exe"
   
   RUN powershell.exe -Command Start-Process "c:/vcredist_x64.exe" -ArgumentList "/passive" -Wait -Passthru
   
   RUN Start-Process "./txserver/txregwebsvr.exe" '/i + /e + /w' -wait

Based on the Dockerfile, Docker will build an image based on the image microsoft/windowsservercore:latest. The prepared folders will be added to the destination machine and the required Windows features are enabled (.NET 4.5, IIS, Web Sockets). Additionally, the VC++ 2013 Redistributable Package will be downloaded and installed. Finally, the TX Text Control Service will be silently installed.

In order to create the image, use the following commands:

1. Assume that you have installed Docker for Windows, open a PowerShell command window with explicit administrator rights and change to the directory where you created the folder TextControlDocker.

   

2. Type in the following command to build the Docker image based on the Dockerfile in the same directory:

   docker build -t tx25 .

   

3. Start the image by creating a container:

   docker run -it --name tx25editor tx25 powershell

4. A new PowerShell is opened on the newly create and started machine. Type in the following command to see which IP address has been delegated:

   ipconfig

   

5. Open any browser and type in the IPv4 Address into the location bar. You should see your deployed web application:

   

The HTML5 based editor can be easily containerized in a Docker container which allows you to package software into standardized units for development, shipment and deployment.

¹ What is a Container, https://www.docker.com