2015-06-08 03:07:20 +00:00
|
|
|
<!--[metadata]>
|
|
|
|
+++
|
|
|
|
title = "Dockerizing applications: A 'Hello world'"
|
|
|
|
description = "A simple 'Hello world' exercise that introduced you to Docker."
|
|
|
|
keywords = ["docker guide, docker, docker platform, virtualization framework, how to, dockerize, dockerizing apps, dockerizing applications, container, containers"]
|
|
|
|
[menu.main]
|
|
|
|
parent = "smn_applied"
|
|
|
|
+++
|
|
|
|
<![end-metadata]-->
|
2014-05-21 21:05:19 +00:00
|
|
|
|
2015-04-21 15:50:09 +00:00
|
|
|
# Dockerizing applications: A "Hello world"
|
2014-05-21 21:05:19 +00:00
|
|
|
|
|
|
|
*So what's this Docker thing all about?*
|
|
|
|
|
|
|
|
Docker allows you to run applications inside containers. Running an
|
|
|
|
application inside a container takes a single command: `docker run`.
|
|
|
|
|
2015-08-05 16:07:11 +00:00
|
|
|
>**Note**: Depending on your Docker system configuration, you may be required to
|
|
|
|
>preface each `docker` command on this page with `sudo`. To avoid this behavior,
|
|
|
|
>your system administrator can create a Unix group called `docker` and add users
|
|
|
|
>to it.
|
2014-12-29 08:19:42 +00:00
|
|
|
|
2014-07-01 22:07:05 +00:00
|
|
|
## Hello world
|
2014-05-21 21:05:19 +00:00
|
|
|
|
|
|
|
Let's try it now.
|
|
|
|
|
2015-03-26 18:12:37 +00:00
|
|
|
$ docker run ubuntu:14.04 /bin/echo 'Hello world'
|
2014-07-01 22:07:05 +00:00
|
|
|
Hello world
|
2014-05-21 21:05:19 +00:00
|
|
|
|
|
|
|
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, `run`. The `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
|
2014-06-01 20:48:04 +00:00
|
|
|
image registry: [Docker Hub](https://hub.docker.com).
|
2014-05-21 21:05:19 +00:00
|
|
|
|
|
|
|
Next we told Docker what command to run inside our new container:
|
|
|
|
|
2014-07-01 22:07:05 +00:00
|
|
|
/bin/echo 'Hello world'
|
2014-05-21 21:05:19 +00:00
|
|
|
|
|
|
|
When our container was launched Docker created a new Ubuntu 14.04
|
|
|
|
environment and then executed the `/bin/echo` command inside it. We saw
|
|
|
|
the result on the command line:
|
|
|
|
|
2014-07-01 22:07:05 +00:00
|
|
|
Hello world
|
2014-05-21 21:05:19 +00:00
|
|
|
|
|
|
|
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
|
2014-07-01 22:07:05 +00:00
|
|
|
`Hello world` was echoed, the container stopped.
|
2014-05-21 21:05:19 +00:00
|
|
|
|
2015-04-21 15:50:09 +00:00
|
|
|
## An interactive container
|
2014-05-21 21:05:19 +00:00
|
|
|
|
|
|
|
Let's try the `docker run` command again, this time specifying a new
|
|
|
|
command to run in our container.
|
|
|
|
|
2015-03-26 18:12:37 +00:00
|
|
|
$ docker run -t -i ubuntu:14.04 /bin/bash
|
2014-05-21 21:05:19 +00:00
|
|
|
root@af8bae53bdd3:/#
|
|
|
|
|
|
|
|
Here we've again specified the `docker run` command and launched an
|
|
|
|
`ubuntu:14.04` image. But we've also passed in two flags: `-t` and `-i`.
|
|
|
|
The `-t` flag assigns a pseudo-tty or terminal inside our new container
|
|
|
|
and the `-i` flag 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:
|
|
|
|
|
|
|
|
root@af8bae53bdd3:/#
|
|
|
|
|
|
|
|
Let's try running some commands inside our container:
|
|
|
|
|
|
|
|
root@af8bae53bdd3:/# pwd
|
|
|
|
/
|
|
|
|
root@af8bae53bdd3:/# ls
|
|
|
|
bin boot dev etc home lib lib64 media mnt opt proc root run sbin srv sys tmp usr var
|
|
|
|
|
|
|
|
You can see we've run the `pwd` to 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
|
2014-08-28 17:02:32 +00:00
|
|
|
use the `exit` command or enter Ctrl-D to finish.
|
2014-05-21 21:05:19 +00:00
|
|
|
|
|
|
|
root@af8bae53bdd3:/# exit
|
|
|
|
|
|
|
|
As with our previous container, once the Bash shell process has
|
|
|
|
finished, the container is stopped.
|
|
|
|
|
2015-04-21 15:50:09 +00:00
|
|
|
## A daemonized Hello world
|
2014-05-21 21:05:19 +00:00
|
|
|
|
|
|
|
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:
|
|
|
|
|
2015-03-26 18:12:37 +00:00
|
|
|
$ docker run -d ubuntu:14.04 /bin/sh -c "while true; do echo hello world; sleep 1; done"
|
2014-05-21 21:05:19 +00:00
|
|
|
1e5535038e285177d5214659a068137486f96ee5c2e85a4ac52dc83f2ebe4147
|
|
|
|
|
2015-03-19 15:42:15 +00:00
|
|
|
Wait, what? Where's our "hello world" output? Let's look at what we've run here.
|
2014-05-21 21:05:19 +00:00
|
|
|
It should look pretty familiar. We ran `docker run` but this time we
|
|
|
|
specified a flag: `-d`. The `-d` flag tells Docker to run the container
|
|
|
|
and put it in the background, to daemonize it.
|
|
|
|
|
|
|
|
We also specified the same image: `ubuntu:14.04`.
|
|
|
|
|
|
|
|
Finally, we specified a command to run:
|
|
|
|
|
|
|
|
/bin/sh -c "while true; do echo hello world; sleep 1; done"
|
|
|
|
|
|
|
|
This is the (hello) world's silliest daemon: a shell script that echoes
|
|
|
|
`hello world` forever.
|
|
|
|
|
|
|
|
So why aren't we seeing any `hello world`'s? Instead Docker has returned
|
|
|
|
a really long string:
|
|
|
|
|
|
|
|
1e5535038e285177d5214659a068137486f96ee5c2e85a4ac52dc83f2ebe4147
|
|
|
|
|
|
|
|
This really long string is called a *container ID*. It uniquely
|
|
|
|
identifies a container so we can work with it.
|
|
|
|
|
|
|
|
> **Note:**
|
2015-08-08 23:06:25 +00:00
|
|
|
> The container ID is a bit long and unwieldy. A bit later,
|
|
|
|
> we'll see a shorter ID and ways to name our containers to make
|
2014-05-21 21:05:19 +00:00
|
|
|
> working with them easier.
|
|
|
|
|
2014-11-02 14:55:36 +00:00
|
|
|
We can use this container ID to see what's happening with our `hello world` daemon.
|
2014-05-21 21:05:19 +00:00
|
|
|
|
|
|
|
Firstly let's make sure our container is running. We can
|
|
|
|
do that with the `docker ps` command. The `docker ps` command queries
|
2014-06-27 06:34:47 +00:00
|
|
|
the Docker daemon for information about all the containers it knows
|
2014-05-21 21:05:19 +00:00
|
|
|
about.
|
|
|
|
|
2015-03-26 18:12:37 +00:00
|
|
|
$ docker ps
|
2014-05-21 21:05:19 +00:00
|
|
|
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
|
|
|
|
1e5535038e28 ubuntu:14.04 /bin/sh -c 'while tr 2 minutes ago Up 1 minute insane_babbage
|
|
|
|
|
|
|
|
Here we can see our daemonized container. The `docker ps` has returned some useful
|
|
|
|
information about it, starting with a shorter variant of its container ID:
|
|
|
|
`1e5535038e28`.
|
|
|
|
|
|
|
|
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,
|
|
|
|
`insane_babbage`.
|
|
|
|
|
2014-06-08 15:25:53 +00:00
|
|
|
> **Note:**
|
2015-08-08 23:06:25 +00:00
|
|
|
> Docker automatically generates names for any containers started.
|
|
|
|
> We'll see how to specify your own names a bit later.
|
2014-05-21 21:05:19 +00:00
|
|
|
|
|
|
|
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.
|
|
|
|
|
2015-03-26 18:12:37 +00:00
|
|
|
$ docker logs insane_babbage
|
2014-05-21 21:05:19 +00:00
|
|
|
hello world
|
|
|
|
hello world
|
|
|
|
hello world
|
|
|
|
. . .
|
|
|
|
|
|
|
|
The `docker logs` command looks inside the container and returns its standard
|
|
|
|
output: in this case the output of our command `hello world`.
|
|
|
|
|
|
|
|
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.
|
|
|
|
|
2015-03-26 18:12:37 +00:00
|
|
|
$ docker stop insane_babbage
|
2014-05-21 21:05:19 +00:00
|
|
|
insane_babbage
|
|
|
|
|
|
|
|
The `docker stop` command 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.
|
|
|
|
|
2015-03-26 18:12:37 +00:00
|
|
|
$ docker ps
|
2014-05-21 21:05:19 +00:00
|
|
|
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
|
|
|
|
|
|
|
|
Excellent. Our container has been stopped.
|
|
|
|
|
|
|
|
# Next steps
|
|
|
|
|
2015-03-19 15:42:15 +00:00
|
|
|
Now we've seen how simple it is to get started with Docker. Let's learn how to
|
2014-05-21 21:05:19 +00:00
|
|
|
do some more advanced tasks.
|
|
|
|
|
2015-10-09 23:50:41 +00:00
|
|
|
Go to [Working With Containers](usingdocker.md).
|
2014-05-21 21:05:19 +00:00
|
|
|
|