Installing Containers Feature on Windows Server

You’ll learn about the first two parts of the procedure in this section. Finding, downloading, and using container images will be addressed in later sections.

The version numbers may be different. Even the names may be different, given the rate of change Microsoft is imposing, which is why we urge you to check the documentation.

You must accept the message to install from an untrusted source and press Enter to continue or use the -Force parameter to bypass the message.

The containers feature and Docker are now installed on your server. Let’s turn to the Windows Server previews for a moment.

Installing Containers Feature on Windows Server Insider Previews

Installing the containers feature on a Windows Server Preview instance is very similar to the installation on Windows Server, except you use the preview provider.

You should be able to install containers on any of the Windows Server versions now. The last installation option to consider is Windows 10.

Installing Containers Feature on Windows 10

The installation procedure on Windows 10 is completely different—isn’t consistency a jewel. You’ll need to have the Hyper-V feature installed and working on your Windows 10 system before installing Docker.

First, you must download the Docker for Windows installer from https://download.docker.com/win/stable/InstallDocker.msi . Installation instructions are available from Docker at https://docs.docker.com/docker-for-windows/install/ , but they aren’t totally consistent with those in the Microsoft documentation at https://docs.microsoft.com/en-us/virtualization/windowscontainers/quick-start/quick-start-windows-10 .

Our install experience can only be described as awful. Once you’ve started it, you’ll get no feedback—not even when it finishes! You’ll have to add your user account into the Docker-users local group. (The installation creates the group but doesn’t add you to it!) If you’re not in the group, Docker for Windows won’t start. Once you’ve added yourself to the group, either log off and log on or restart the machine. We recommend restarting.

The Docker installation procedure will create a VM switch called DockerNAT with a switch type of Internal.

You’ll have to start Docker for Windows manually, the first time you use it. Docker should start automatically on subsequent machine restarts.

If you then click on the Docker icon (whale shape) in the notification area, you’ll see something like Figure 17-1. You can use the switching option on the menu, to switch between Windows and Linux containers, if you don’t want to use the command line.

Sometimes things go wrong and you may have to become more involved in the installation process .

Troubleshooting the Installation Process

You could try to use Save-Package, but we got a similar error. This seems to a be a common issue discussed in the following thread: https://github.com/OneGet/MicrosoftDockerProvider/issues/15 .

Because the download file exists, the save is skipped. The hash verification works, and Docker is installed. The installation of Docker also enables the containers feature. The installation output is shown in Figure 17-2.

Restart the VM to finish the installation and start the Docker service.

You’ve spent a lot of time covering the installation options, but given the differences in procedure between the various options, it’s important that you get the installation correct. Now that installation is out of the way, it’s time to create your first container.

Finding Container Images

With the background information out of the way, you’ll need to know where to look to find your container OS images.

The answer is the Docker Hub. Microsoft has embraced the Docker ecosystem and made their container images available through Docker’s portal: https://hub.docker.com/ . The Docker Hub directs you to the Docker Store as the new place to find container images, but at the time of writing, the Docker Hub was still the primary point for finding container images.

If you click on Explore of the Docker Hub home page, you’ll find a list of vendor repositories to browse through. The URL for the Microsoft repository is https://hub.docker.com/r/microsoft/ , if you want to shortcut the process. On the first page of the Microsoft repository, you’ll find the nanoserver and windowsservercore images. The Server Core images are shown in Figure 17-3.

The commands will pull a Windows Server 2016, Windows Server 1709, and Windows Server 1803 image respectively. The repository is Microsoft/windowsservercore and the optional tags are 1709 and 1803. You can view the available options for a container image in the Docker Hub. Navigate to the appropriate repository and click Tags.

You’re pulling the previews from a different repository.

As you can see from Table 17-5, Microsoft is working to decrease the size of the base OS container image with each release.

The number of images you ask for must be in the range 1–100. Some of the images returned will be from Microsoft, and others from individuals.

In reality, the search option in the Docker command-line utility doesn’t appear to have evolved to match the growth of the Docker ecosystem. In reality, it’s not useful for any practical searches, and you’re better off using the browser.

Now that you know how to find your container images, it’s time to download them.

Downloading Container Images

The IIS specifics will be merged with the base image, to produce the final image.

When downloading, if you get an error such as Error response from daemon: Get https://registry-1.docker.io/v2/: dial tcp: lookup registry-1.docker.io: no such host or an indication of a time-out, then try stopping and restarting the Docker service. Attempt the download again in a new instance of PowerShell or cmd.

You’ve found your images and downloaded them. It’s time to create a container.

Creating a Container

In both cases, you’re starting a container, based on the stated image, and telling the container to run cmd.exe and echo Hello World! The output is automatically returned to your console, and the container stops. These containers are running as Windows Server containers.

You’ll be using the docker run command extensively. It’s worth reading the full documentation at https://docs.docker.com/engine/reference/commandline/run/ .

The display is wrapped, unfortunately, but you should be able to follow it. Docker will automatically assign the container ID and the name. The container ID is the shortened version, as you’ll see later. The name is random!

Later in the chapter, you’ll be running containers that don’t automatically exit. You’ll learn then how to stop and restart them.

The containers you’ve run so far have all been Windows containers. It’s time to investigate Hyper-V containers.

Running Hyper-V Containers

You might think that using Windows 10 as a host isn’t a good idea, but in reality, you can develop and test the container on your workstation and then move the container to a production host, where it could run as a Windows or Hyper-V container, depending on the scenario.

This starts a continuous ping process. The -d (-detach) parameter runs the container in the background and prints the container ID to the screen. Note that you get the long version of the container id.

There’ll be one instance of VMWP per running VM on your Hyper-V host. Starting a container in Hyper-V isolation mode will also spawn a new instance of the VMWP.

You’ve learned how to create containers, but you’ve only connected to them from the host. You must learn how to attach a container to your network, so that the application can be accessed from any client.

Default Container Network

The address 172.22.80.1 is part of the 172.16.0.0/12 private address space (see https://technet.microsoft.com/en-us/library/cc958825.aspx ).

Get-ContainerNetwork is in the Containers module, which has four cmdlets for working with container networks.

Before we go any further, we’d better explain the term NAT, which is used in the name of the adapter and as the network type or mode. NAT stands for “Network Address Translation.” It’s a technique in networking wherein an internal address, in this case, in the 172.22.80.0/20 range, is mapped to an address and port on the machine’s network adapter, so that the container can communicate with machines external to the host. We’ll explain this further with an example.

You’ll recognize that the IP address of the default gateway is the same as the network adapter Docker automatically installs.

The computer name is set to the container ID. Note that the computer type is set to Container.

You’ll notice that we haven’t given any credentials when creating the PowerShell remoting session. Don’t let that fool you into thinking that the container is part of your AD. It isn’t. Containers don’t create AD objects and aren’t part of your AD.

There is also a loop back adapter: 127.0.0.1.

If your container host has a GUI and, therefore, a browser, you’ll be able to connect to http:// 172.21.142.23/ and view the default web site. You won’t be able to ping the container or connect to the web site from another host, as the 172.21.142.23 address is only visible on the container host. You must create a mapping from the 172.21.142.23 address to the external IP address of the host, to make the web site visible on the external network.

Creating an NAT Mapping

In this case, you’re mapping port 80 (HTTP) and port 443 (HTTPS) to the corresponding port number on the external NIC. The order in which you define the ports is important. It should be -p <external port>:<container port>.

You can access the container as you would any web site, because you’ve mapped the HHTP port from the container directly to the external NIC. Figure 17-4 shows the container’s web site being accessed from an external machine.

The instance of the browser on the left accesses the web site, using the server name http://W1803CN01, and that on the right uses the IP address http://10.10.54.60, which is the IP address of the container host.

The Policies parameter shows the port mappings between the container and the external NIC.

The display is wrapped, because of the width of the page, but you can see the PORTS information at the beginning of the last line.

In this case, you’re mapping port 80 on the container to port 8080 on the external NIC. You can connect to the web site in the container, from an external machine, by using http://W1803CN01:8080/ or http://10.10.54.60:8080/. You can use the same techniques as earlier to view the port mappings.

Using NAT works for a small number of containers—ideal for a development environment. NAT breaks down when you have to run many containers on a host, especially if you have to remember the port mappings to connect to the container from an external machine.

Other Network Options

By default, containers use the NAT network that’s created when you install the containers feature. Other network options are available, as shown in Table 17-7.

Creating Containers

This will create the container, run the command, return the results, and shut down the container.

You can view the full syntax and options at https://docs.docker.com/engine/reference/commandline/run/ .

You’ll usually run in the background, but you can run containers interactively.

Interactive Containers

If you run a container interactively (by using the -it option), you are immediately connected to the container, as shown in Figure 17-5.

The first line in Figure 17-5 shows the process ID (PID) of the current PowerShell session as 2928. A Windows Server Core container is started. The container is started in an interactive mode by using the -it parameter.

A new PowerShell session is generated within the container, and your current session is connected to it. You’ll see the PowerShell start banner and a new (and different) prompt, as in Figure 17-5. The console overwriting itself seems to be a console artifact.

If you repeat the exercise of retrieving the PowerShell PID, you’ll get a different result—1960, in this case. You can run PowerShell commands, and they execute within the container. Getting the PowerShell process only shows the process within the container—isolated environment—though there are four instances of PowerShell running on the host at that time, including the one in the container.

You can use the exit command to close the container instance of PowerShell, which will also shut down the container. Check the PID, and you’ll see that you’re back in your original PowerShell session.

This approach works when you want to work interactively with a container, but what about a situation in which you have multiple containers on a host? You must be able to pick and choose which containers to work with, meaning you must be able to identify your containers.

Container Identification

The short ID is the first 12 characters of the full ID.

It’s worth assigning names to your containers, even though some Docker commands expect to work with IDs (usually the short ID), rather than container names. Container names must be unique.

The commands you’ve seen so far have been to create and immediately run a container. You have the option of creating the container and running it as two separate actions.

Pre-creating Containers

In this example, you’re creating another instance of the IIS container but not starting it. The docker ps command uses the table option to display a header for each column. The columns are spaces using tabs ( ). Note that the long ID is supplied when the container is created, but the short ID is usually used in subsequent commands.

You now have three instances of your container running. The next step is to stop the containers or remove them from the host.

Stopping and Removing Containers

This is the type of scenario in which PowerShell, with its ability to filter and pipe objects, would be of real benefit. Use the Docker commands you need, to quietly get the running containers to use as the input to docker stop.

Once you’ve stopped the containers, you can remove them.

You need the -a parameter on docker ps, to view non-running containers.

You’ve installed the container feature, downloaded container images, and created containers from those images. At some stage, you’ll have to modify a container image and roll that changed image into production.

Modifying and Using Container Images

Containers are very lightweight objects and, therefore, easy to move around your environment. They are a great component to include in your DevOps procedures. In earlier sessions, you’ve seen containers running IIS. Modifying the web site is a common occurrence in application development.

The first step is to create the container.

Modify Web Site

As a quick change to your web site (we’re just demonstrating concepts), modify the iisstart.png file (the default web site start page) to look like Figure 17-6.

Copy the replacement iisstart.png file into the container, using a PowerShell remoting session.

PS>  $sc = New-PSSession -ContainerId ` b2585f81aa6e8585ac9f16df13605eaf6046477c55655543efb0d0c5152c5480 `

-RunAsAdministrator

PS>  Copy-Item -Path C:Sourceiisstart.png `

-Destination c:inetpubwwwroot -ToSession $sc -Force

PS>  Remove-PSSession $sc

Create a remoting session to the container, copy the file, and then remove the session. You’ll have to restart IIS in the container, so the new file is used.

PS>  docker restart IISdev

IISdev

Connect to the container’s web site, and you should see the changed page, as shown in Figure 17-7.

The change in file survives stopping and starting the container. After the web site changes have been tested, it’s time to move the change into production.

Using the New Container Image

Before you can use the new image, you must import the image.

PS>  docker load --input c:sourceprohyperv_iis_version1.tar

b88f82691d05: Loading layer [==================================================>]  184.4MB/184.4MB

Loaded image: prohyperv/iis:version1

Once the image is imported, you can create containers. Create a container from the original IIS image and the new one.

PS>  docker run --name IIS1 -d -p 80:80 microsoft/iis:windowsservercore-1803

8b18255fc3150068a25e999e3a29c284348d2dc7d8a0cb1a886574e690b88592

PS>  docker run --name IIS2 -d -p 81:80 prohyperv/iis:version1

f455230201acd26a3153d191c9bda8bcc0265ccb577224acc4dfce230a564ac1

The container using the original image is mapped to external port 80, and the container from the new image is mapped using port 81. This means that you can view both the original web site and the new web site, as shown in Figure 17-8.

The ability to modify running containers and create an image from that container that can be exported to other machines gives you a very fast, safe way to deploy applications in your environment. If your organization is embracing the DevOps principles, you’ll find that containers can play a significant role in your application deployment strategies.

TRY IT YOURSELF

Follow the steps in this section to modify a container, create a new image, copy the image to a new machine, and create a container from the new image.

The steps involved in modifying a container and creating an image that can be used throughout the organization are manually intensive. The container images can be several gigabytes in size, leading to slow copy times. It would be useful if there were a way to automate the production of new images and reduce the size of data that had to be copied around the environment.

Automating Image Creation

A Docker file is a text file that contains the instructions to create a new container image—using an existing base image—the commands to be run when the image is created, and the commands to be run when containers are created from the image. The Microsoft documentation for Docker files is located at https://docs.microsoft.com/en-us/virtualization/windowscontainers/manage-docker/manage-windows-dockerfile .

As an example, let’s rework the modification of the web site that was performed manually in the previous section.

First, we must create a new IIS start image (Figure 17-9).

In this version, we’ve added the fact that we’re using a Docker file to make the differences obvious. The next task is to create a Docker file. Visual Studio Code (the recommended editor for PowerShell v6 and later versions— https://code.visualstudio.com/ ) works with PowerShell and many other languages, including Docker files.

The FROM directive instructs Docker to use the microsoft/iis:windowsservercore-1803 image as the basis of the build. The COPY command instructs the build process to copy the new version of iisstart.png into the image.

Many other tasks can be accomplished using Docker files. The Docker file reference can be found at https://docs.docker.com/engine/reference/builder/#usage .

In this case, you’re using a Docker file IIS2.dockerfile to build a new image called prohyperv/iis:version2. The dot at the end of the command line instructs Docker that all of the required files are in the current directory. It’s recommended that you keep the Docker file and other required files together, for simplicity.

Figure 17-10 shows the latest version of the web site, with the original and the version you created in the previous section.

Once you’ve tested the new web site, you can copy the Docker file and any other required files to your production machine(s). This is much less data than a full image, so it is much quicker. Re-create the image, using the same docker build command. You can then create containers from the new image.

Using Docker files is a quicker and easier way to modify your container images and get the new image into production.

The containers you’ve been working with throughout the book use the Windows OS. You can also run containers based on Linux.