{"id":15,"date":"2017-10-12T00:13:40","date_gmt":"2017-10-11T21:13:40","guid":{"rendered":"http:\/\/faridnakhle.com\/home\/?p=15"},"modified":"2017-10-15T14:23:50","modified_gmt":"2017-10-15T11:23:50","slug":"exploring-docker-on-windows-10-pro","status":"publish","type":"post","link":"https:\/\/faridnakhle.com\/home\/2017\/10\/12\/exploring-docker-on-windows-10-pro\/","title":{"rendered":"Exploring Docker on Windows 10 Pro"},"content":{"rendered":"

For the past few months, Docker has been continuously\u00a0updating and stabilizing their container services on windows.
\nHowever, since docker depends on Hyper-V, It’s currently only available on Windows 10 Pro\u00a0<\/strong>and Windows Server 2016.<\/p>\n

Although containers are becoming a “common methodology” in 2017, let me try and describe them briefly for those of you who are late to the party.<\/p>\n

What is a container?<\/h2>\n

Programmers and Computer Scientists usually, believe it or not, try to simplify things as much as possible; especially when it comes to namings. By that, I mean that containers are named containers because that’s what they do. Their job is to simply “contain” a process and isolate it from other processes running on the Operating System. The process running in a container can only communicate with processes running in the same container, and the processes running outside the container cannot communicate with processes inside the container.<\/p>\n

Commonly, containers are used in a way where each container run a single process or have a single functionality such as a web server, a database container, etc… and it is typical for us to see that process sharing its lifecycle with the container’s lifecycle. meaning that when the container starts, the service\/process starts with it. And naturally, when the container is stopped, the service is stopped with it.<\/p>\n

Why are containers useful?<\/h2>\n

The main use of containers is to help us isolate an application from the outside world. This could be helpful if we are willing to move this application around and\/or copy it to multiple computers. To do so, we have to include all of the application’s dependencies in our container.
\nOne would think that this is contradicting with my previous statement saying that a container should typically have a single functionality. However, this is a wrong assumption and the statement is still valid because of the nature of how containers can be inherited. In other words, the dependencies of our application can be (and are advisable to be) different containers.<\/p>\n

Containers come in form of “Images”, where an image consists a set of instructions telling the host what commands to run and which, if any, other containers are needed to run this image. For example, if we are running a web app, our image file would typically contain an inheritance of an OS container, a web server container, a database container, and our app to be hosted upon them. We can think of containers like a class, where a host can instantiate many instances of this class and use them independently. And the class could be inheriting different classes. It is supposed\u00a0to have all it needs to do its intended functionalities.<\/p>\n

What is Docker then?<\/h2>\n

We can think of Docker (again with the naming thing) as a dock, where ships ship containers from remote locations (usually from docker hub<\/a>) to our host (the dock).<\/p>\n

Docker helps us manage containers on our system from getting their images to running and removing them.<\/p>\n

Messing with Docker on Windows 10 Pro<\/h2>\n

First things first, as I mentioned in the introduction that I’m proud of (not really), that docker needs Hyper-V to run. Hence your computer needs to support Hardware Virtualization (most computers do nowadays).<\/p>\n

You can download and install docker from here.<\/a><\/p>\n

Once you install docker, it will tell you that it will turn on Hyper-V for you (if you don’t have it on). After that, your computer will restart and Docker will be up and running. You can tell so by noticing the cute whale icon next to the clock on your taskbar \"\".<\/p>\n

Open up PowerShell and type docker. This will show you the list of commands that you can use with docker.<\/p>\n

The first natural thing to try is to run:<\/p>\n

docker run hello-world<\/pre>\n
this will look for a container named hello-world. Don’t worry about not having it. Docker will look to the container Image locally. If it doesn’t exist, It will pull it from docker hub.<\/p>\n
Once you’re done playing with the hello-world container (which unlike typical containers, it exists after the first run) you can remove it by typing:<\/p>\n
docker rmi hello-world<\/pre>\n
This will remove the image completely from your system. If it’s stubborn and doesn’t want to leave, add the force parameter (-f) to the previous command:<\/p>\n
docker rmi hello-world -f<\/pre>\n
This will show it who’s the boss.<\/p>\n
Some interesting containers to try<\/h2>\n
As an IIS hater, the first container to try was *drum roll* NGINX.<\/p>\n
It is no surprise. I use WAMP on windows (don’t judge me. not a big fan either). and I thought, yes! now I can run all those projects on NGINX instead of the windows version of apache added by WAMP.<\/p>\n
NGINX is a good example because it will help me show you how containers that are supposed to be contained in a sandbox can be accessed by my host and how can I run all of my projects on NGINX while they exist on my host outside of the container. It’s pretty simple, all we need to do is to tell the container to map the container’s port 80 (web server, duh) to any port we want on the host. if the host’s port 80 is not used by other services like IIS or WAMP, we can map it.\u00a0 Optionally, we can also tell the container to map a path on the host (outside the container) to the container. This is how I made NGINX read my project folders and thus the projects inside.<\/p>\n
The command I ran was as following:<\/p>\n
docker run --name nginx -p 8181:80 -v C:\/wamp\/www:\/usr\/share\/nginx\/html:ro -d nginx<\/pre>\n
Yes, it is as simple as it looks:
\ndocker run nginx obviously checks if nginx image exists on your computer, if not, gets it from docker hub.<\/p>\n
–name nginx is a name for your container instance. you can name it whatever you want. –name myNginx. or whatever.<\/p>\n
-p 8181:80 is where the port mapping happens. I chose to map the container’s port 80 to my host as 8181. you can naturally choose whatever port you see fit. As long as it’s not being used by another process.<\/p>\n
-v C:\/wamp\/www:\/usr\/share\/nginx\/html is where I tell the container to map my wamp projects folder to nginx’s projects folder. “:ro” stands for read only.<\/p>\n
You can explore further options and customizations on the NGINX container’s official hub page here<\/a>.<\/p>\n
Other awesome containers that I’ve found and tried<\/h2>\n