How To Create Dockerfile In Windows

Writer
Recent Posts

Josh'southward principal focus is in Windows security and PowerShell automation. He is a GIAC Certified Windows Security Ambassador (GCWN) and GIAC Certified Forensic Analyst (GCFA). You can reach Josh at MSAdministrator.com or on Twitter at @MS_dministrator.

A Dockerfile (no file extension) is a definition file that will build and run a container. That container can be a simple Microsoft IIS spider web awarding or Python/Flask application or a simple build/reporting service. A definition file helps us with our operational tasks, peculiarly when we are building services or scripts for the repeatable tasks we face on a daily basis.

Hither is an example of a Dockerfile that will prepare an IIS web server with ASP.Net four.v on a Windows system:

FROM microsoft/iis  RUN mkdir c:\myapp RUN powershell -NoProfile -Command \     Install-WindowsFeature NET-Framework-45-ASPNET; \     Install-WindowsFeature Web-Asp-Net45; \     Import-Module IISAdministration; \     New-IISSite -Name "MyApp" -PhysicalPath C:\myapp -BindingInformation "*:8000:"  EXPOSE 8000  ADD bin/ /myapp

Wow, I bet you lot didn't think these few lines would gear up an entire IIS web application with ASP.NET 4.5, did you? Well, they practice! Let's break this downwards a bit farther.

As explained in my previous mail service, Docker images are prebuilt "prerequisites" nosotros tin can install and use when creating and running our container. Within a Dockerfile we specify the base image we want to use by declaring FROM {image name}. In this case, we are using the Docker Hub image for an IIS server Microsoft has provided.

FROM microsoft/iis

The second statement you run across uses the RUN control to tell the container, in one case information technology is running, to call mkdir c:\myapp. At this point, it creates a new directory within our container itself called c:\myapp.

At this point Docker has downloaded and built a containerized application based of the Microsoft/iis epitome with all the base prerequisites needed for setting up an IIS server. In add-on we are telling the container also to create a new "virtual" folder inside the container itself. You lot don't really have access to this location, meaning you won't run across it on your local file organisation. At this point, you just need to trust Docker is doing what y'all specified (and it is).

Moving on, the next statement you lot encounter is another RUN command:

RUN powershell -NoProfile -Command \     Install-WindowsFeature Cyberspace-Framework-45-ASPNET; \     Install-WindowsFeature Web-Asp-Net45; \     Import-Module IISAdministration; \     New-IISSite -Name "MyApp" -PhysicalPath C:\myapp -BindingInformation "*:8000:"

This RUN control is a scrap different but does essentially the same thing. This time we are now specifying that nosotros should create a new PowerShell "beat out" past calling:

powershell -NoProfile -Command

Next, we specify our standard PowerShell commands as normal. You may discover that each line has a "\" at the terminate of information technology. The backslash is to ensure line continuation within the Docker container.

Install-WindowsFeature NET-Framework-45-ASPNET; \ Install-WindowsFeature Spider web-Asp-NET45; \ Import-Module IISAdministration; \ New-IISSite -Name "MyApp" -PhysicalPath C:\myapp -BindingInformation "*:8000:"

We then install the NET-Framework-45-ASPNET and Web-Asp-Net45 Windows features, just similar we would do on a normal IIS web server. We then import the IISAdministration PowerShell module and create a new IIS website called MyApp. The New-IISSite cmdlet also allows united states to specify a PhysicalPath and a specific port to bind to. In our example, we are binding all requests to port 8000.

Next, we and so run the Expose networking pick in our Dockerfile. This option is a bit disruptive to some, just information technology allows the individual who is generating the Docker container to specify a network port the individual can utilise to interact with the container. EXPOSE does not really expose the network port. To betrayal a port to the world (or our network), you lot would need to specify another option when you run your container. For instance, you would do the post-obit:

docker run {image} -p 80

This would really expose the container to a network outside your local system.

Inside our folder that contains our Dockerfile, nosotros should too have a folder named bin. Within this binder, nosotros should have a basic HTML file called index.html with the following content:

<!DOCTYPE html PUBLIC "-//IETF//DTD HTML 2.0//EN"> <HTML>    <HEAD>       <Title>          Hello from my Docker for Windows Container!       </Championship>    </Head> <BODY>    <H1>Howdy</H1>    <P>This is very minimal "hullo globe" HTML certificate, but it's running within Docker for Windows</P> </BODY> </HTML>

The concluding statement in our Dockerfile is the Add command. This control will add files or scripts or whatsoever you accept specified to the container.

Add bin/ /myapp

How the Add together control works is that information technology takes the current directory holding your Dockerfile, and if you have specified a specific folder, like bin/, it would add this directory and all of its contents to /myapp within the Docker container. Here's a visual representation of this:

Add files from local file system to your Docker container

Add files from local file arrangement to your Docker container

Now that we accept our Dockerfile and our bin/index.html in the same binder, we will now build and run our new container!

To run our new container, open up upwards your PowerShell console. Next, change directories to the folder container for your Dockerfile and bin/index.html binder. For me, I accept these located at C:\Docker For Windows Example:

[Open PowerShell Console] cd 'C:\Docker For Windows Case' docker build .

Please annotation that the full command is docker build . The period at the end is needed, and it references the location of our Dockerfile.

After nosotros take pulled down our image from Docker Hub, we should at present have a new IIS website fix and running our alphabetize.html page. You can view it by going to your browser and going to:

http://127.0.0.1/ alphabetize.html

Also the options I mentioned in our example, you have additional commands available that I believe you will observe extremely useful. These additional commands are:

ENTRYPOINT/CMD: You may see this control as either ENTRYPOINT or CMD, simply there are only pocket-sized differences between the two. An instance of how to utilise CMD is as follows:

General Example: CMD ["executable","param1","param2"] Python Example: CMD ["python", "/usr/src/app/setup.py"] PowerShell Case: CMD [powershell.exe, -executionpolicy, bypass, c:\startup.ps1]

ENV:The ENV argument allows y'all to specify environmental variables within the container you are running. These can exist peachy for a handful of variables, but this command does slow down your build process.

WORKDIR:WORKDIR allows y'all to set up the working directory within a container. This is great if you want to employ relative paths within your container. Nosotros'd typically utilize this before we call our RUN, CMD, ENTRYPOINT, etc. commands in our Dockerfile

You can find more than data about all the commands bachelor by visiting Docker's official documentation. Delight view this documentation here.

At present that we empathise the basics on building containers, we should be familiar enough to commencement playing around with all the bachelor images on Docker Hub and fifty-fifty starting to create our own.

In the side by side segment of this serial, nosotros will become a flake farther and talk about using docker-etch. This amazing feature volition allow you lot to create multiple containers simultaneously. Why is this useful? Imagine creating an application that has both a front-end UI and a back-end database. In the meantime, please cheque out more than information well-nigh Docker Etch hither.