github.com/noxiouz/docker@v0.7.3-0.20160629055221-3d231c78e8c5/docs/tutorials/dockerizing.md

<!--[metadata]>
+++
aliases = [
"/engine/userguide/containers/dockerizing/",
"/engine/userguide/dockerizing/"
]
title = "Hello world in a container"
description = "A simple 'Hello world' exercise that introduced you to Docker."
keywords = ["docker guide, docker, docker platform, how to, dockerize, dockerizing apps, dockerizing applications, container,  containers"]
[menu.main]
parent = "engine_learn_menu"
weight=-6
+++
<![end-metadata]-->

# Hello world in a container

*So what's this Docker thing all about?*

Docker allows you to run applications, worlds you create, inside containers.
Running an application inside a container takes a single command: `docker run`.

>**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.

## Run a Hello world

Let's run a hello world container.

    $ docker run ubuntu /bin/echo 'Hello world'
    Hello world

You just launched your first container!

In this example:

* `docker run` runs a container.

* `ubuntu` is the image you run, for example the Ubuntu operating system image.
  When you specify an image, Docker looks first for the image on your
  Docker host. If the image does not exist locally, then the image is pulled from the public
  image registry [Docker Hub](https://hub.docker.com).

* `/bin/echo` is the command to run inside the new container.

The container launches. Docker creates a new Ubuntu
environment and executes the `/bin/echo` command inside it and then prints out:

    Hello world

So what happened to the container after that? Well, Docker containers
only run as long as the command you specify is active. Therefore, in the above example,
the container stops once the command is executed.

## Run an interactive container

Let's specify a new command to run in the container.

    $ docker run -t -i ubuntu /bin/bash
    root@af8bae53bdd3:/#

In this example:

* `docker run` runs a container.
* `ubuntu` is the image you would like to run.
* `-t` flag assigns a pseudo-tty or terminal inside the new container.
* `-i` flag allows you to make an interactive connection by
grabbing the standard in (`STDIN`) of the container.
* `/bin/bash` launches a Bash shell inside our container.

The container launches. We can see there is a
command prompt inside it:

    root@af8bae53bdd3:/#

Let's try running some commands inside the 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

In this example:

* `pwd` displays the current directory, the `/` root directory.  
* `ls` displays the directory listing of the root directory of a typical Linux file system.

Now, you can play around inside this container. When completed, run the `exit` command or enter Ctrl-D
to exit the interactive shell.

    root@af8bae53bdd3:/# exit

>**Note:** As with our previous container, once the Bash shell process has
finished, the container stops.

## Start a daemonized Hello world

Let's create a container that runs as a daemon.

    $ docker run -d ubuntu /bin/sh -c "while true; do echo hello world; sleep 1; done"
    1e5535038e285177d5214659a068137486f96ee5c2e85a4ac52dc83f2ebe4147

In this example:

* `docker run` runs the container.
* `-d` flag runs the container in the background (to daemonize it).
* `ubuntu` is the image you would like to run.

Finally, we specify a command to run:

    /bin/sh -c "while true; do echo hello world; sleep 1; done"


In the output, we do not see `hello world` but a long string:

    1e5535038e285177d5214659a068137486f96ee5c2e85a4ac52dc83f2ebe4147

This 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 and unwieldy. Later, we will cover the short
> ID and ways to name our containers to make
> working with them easier.

We can use this container ID to see what's happening with our `hello world` daemon.

First, let's make sure our container is running. Run the `docker ps` command.
The `docker ps` command queries the Docker daemon for information about all the containers it knows
about.

    $ docker ps
    CONTAINER ID  IMAGE         COMMAND               CREATED        STATUS       PORTS NAMES
    1e5535038e28  ubuntu  /bin/sh -c 'while tr  2 minutes ago  Up 1 minute        insane_babbage

In this example, we can see our daemonized container. The `docker ps` returns some useful
information:

* `1e5535038e28` is the shorter variant of the container ID.
* `ubuntu` is the used image.
* the command, status, and assigned name `insane_babbage`.


> **Note:**
> Docker automatically generates names for any containers started.
> We'll see how to specify your own names a bit later.

Now, we know the container is 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 `insane_babbage`.

    $ docker logs insane_babbage
    hello world
    hello world
    hello world
    . . .

In this example:

* `docker logs` looks inside the container and returns `hello world`.

Awesome! The daemon is working and you have just created your first
Dockerized application!

Next, run the `docker stop` command to stop our detached container.

    $ docker stop insane_babbage
    insane_babbage

The `docker stop` command tells Docker to politely stop the running
container and returns the name of the container it stopped.

Let's check it worked with the `docker ps` command.

    $ docker ps
    CONTAINER ID  IMAGE         COMMAND               CREATED        STATUS       PORTS NAMES

Excellent. Our container is stopped.

# Next steps

So far, you launched your first containers using the `docker run` command. You
ran an *interactive container* that ran in the foreground. You also ran a
*detached container* that ran in the background. In the process you learned
about several Docker commands:

* `docker ps` - Lists containers.
* `docker logs` - Shows us the standard output of a container.
* `docker stop` - Stops running containers.

Now, you have the basis learn more about Docker and how to do some more advanced
tasks. Go to ["*Run a simple application*"](usingdocker.md) to actually build a
web application with the Docker client.