Dockerizing Applications: A “Hello world”
We get a lot of questions about Docker but mainly, what’s this Docker thing all about? At a high level, Docker allows you to run applications inside containers which provide much more density and performance over traditional virtualization. Lets take a look at the first step which is “dockerizing” an application.
Running an application inside a container takes a single command:
Let’s try it now.
And you just launched your first container!
So what just happened? Let’s step through what the
docker run command did.
First we specified the
docker binary and the command we wanted to execute,
docker run combination runs containers.
Next we specified an image:
ubuntu:14.04. This is the source of the container we ran. Docker calls this an image. In this case we used an Ubuntu 14.04 operating system image.
When you specify an image, Docker looks first for the image on your Docker host. If it can’t find it then it downloads the image from the public image registry: Docker Hub.
Next we told Docker what command to run inside our new container:
When our container was launched Docker created a new Ubuntu 14.04 environment and then executed the
/bin/echocommand inside it. We saw the result on the command line:
So what happened to our container after that? Well Docker containers only run as long as the command you specify is active. Here, as soon as
Hello worldwas echoed, the container stopped.
An Interactive Container
Let’s try the
docker run command again, this time specifying a new command to run in our container.
Here we’ve again specified the
docker runcommand and launched an
ubuntu:14.04image. But we’ve also passed in two flags:
-tflag assigns a pseudo-tty or terminal inside our new container and the
-iflag allows us to make an interactive connection by grabbing the standard in (
STDIN) of the container.
We’ve also specified a new command for our container to run:
/bin/bash. This will launch a Bash shell inside our container.
So now when our container is launched we can see that we’ve got a command prompt inside it:
Let’s try running some commands inside our container:
You can see we’ve run the
pwdto show our current directory and can see we’re in the
/root directory. We’ve also done a directory listing of the root directory which shows us what looks like a typical Linux file system.
You can play around inside this container and when you’re done you can use the
exit command to finish.
As with our previous container, once the Bash shell process has finished, the container is stopped.
A Daemonized Hello world
Now a container that runs a command and then exits has some uses but it’s not overly helpful. Let’s create a container that runs as a daemon, like most of the applications we’re probably going to run with Docker.
Again we can do this with the
docker run command:
Wait what? Where’s our “Hello world” Let’s look at what we’ve run here. It should look pretty familiar. We ran
docker runbut this time we specified a flag:
-dflag tells Docker to run the container and put it in the background, to daemonize it.
We also specified the same image:
Finally, we specified a command to run:
This is the (hello) world’s silliest daemon: a shell script that echoes
So why aren’t we seeing any
hello world’s? Instead Docker has returned a really long string:
This really long string is called a container ID. It uniquely identifies a container so we can work with it.
Note: The container ID is a bit long but there are more advanced methods to use a shorter ID and some ways to name your containers to make working with them easier.
We can use this container ID to see what’s happening with our
hello world daemon.
Firstly let’s make sure our container is running. We can do that with the
docker ps command. The
docker ps command queries the Docker daemon for information about all the containers it knows about.
Here we can see our daemonized container. The
docker pshas returned some useful information about it, starting with a shorter variant of its container ID:
We can also see the image we used to build it,
ubuntu:14.04, the command it is running, its status and an automatically assigned name,
Note: Docker automatically names any containers you start, but there are options for you to specify your own names.
Okay, so we now know it’s running. But is it doing what we asked it to do? To see this we’re going to look inside the container using the
docker logs command. Let’s use the container name Docker assigned.
docker logscommand looks inside the container and returns its standard output: in this case the output of our command
Awesome! Our daemon is working and we’ve just created our first Dockerized application!
Now we’ve established we can create our own containers let’s tidy up after ourselves and stop our daemonized container. To do this we use the
docker stop command.
docker stopcommand tells Docker to politely stop the running container. If it succeeds it will return the name of the container it has just stopped.
Let’s check it worked with the
docker ps command.
Excellent. Our container has been stopped.
Interested in learning more on how your organization can adopt and integrate Docker into your application lifecycles to deliver application portability, improved infrastructure density and next-generation IT-infrastructures on-premise and in the cloud? Shadow-Soft is one of the first authorized Docker integration partners with the expertise to deliver Docker professional services engagements, training and the resale of commercial support for Docker products. For more information on how to take the first step into integrating Docker into your development lifecycle, please contact us.