4/14/2014 - 5:35 AM

Docker Cheat Sheet

Docker Cheat Sheet

Docker Cheat Sheet


Why Should I Care (For Developers)

"Docker interests me because it allows simple environment isolation and repeatability. I can create a run-time environment once, package it up, then run it again on any other machine. Furthermore, everything that runs in that environment is isolated from the underlying host (much like a virtual machine). And best of all, everything is fast and simple."

TL;DR, I just want a dev environment


Use Homebrew.

ruby -e "$(curl -fsSL https://raw.github.com/mxcl/homebrew/go)"


UPDATE (2/5/2014): Docker 0.8 supports MacOS.

Install VirtualBox and Vagrant using Brew Cask.

brew tap phinze/homebrew-cask
brew install brew-cask
brew cask install virtualbox
brew cask install vagrant

Then we follow the instructions from http://docs.docker.io/en/latest/installation/mac/:

Install boot2docker:

mkdir -p $HOME/bin
cd $HOME/bin
curl https://raw.github.com/boot2docker/boot2docker/master/boot2docker > $HOME/bin/boot2docker
chmod +x $HOME/bin/boot2docker

Install the docker daemon:

curl -o docker https://get.docker.io/builds/Darwin/x86_64/docker-latest
chmod +x docker
export DOCKER_HOST=tcp://
sudo cp docker /usr/local/bin/

If you have trouble with port numbers (4243 is taken on my machine):

echo "export DOCKER_HOST=tcp://" >> "$HOME/.zshenv"
echo "DOCKER_PORT=9111" >> "$HOME/.boot2docker/profile"

Then start up the daemon:

$HOME/bin/boot2docker init
$HOME/bin/boot2docker up

Pull the ubuntu repository:

docker pull ubuntu

Then start up a container:

docker run -i -t ubuntu /bin/bash

That's it, you have a running Docker container.

I use Oh My Zsh with the Docker plugin for autocompletion of docker commands. YMMV.


Your basic isolated Docker process. Containers are to Virtual Machines as threads are to processes. Or you can think of them as chroots on steroids.

Some common misconceptions it's worth correcting:

  • Containers are not transient. docker run doesn't do what you think.
  • Containers are not limited to running a single command or process. You can use supervisord or runit.


If you want to run and then interact with a container, docker start then docker attach to get in.

If you want a transient container, docker run -rm will remove the container after it stops.

If you want to poke around in an image, docker run -t -i <myshell> to open a tty.

If you want to map a directory on the host to a docker container, docker run -v $HOSTDIR:$DOCKERDIR (also see Volumes section).

If you want to integrate a container with a host process manager, start the daemon with -r=false then use docker start -a.

If you want to expose container ports through the host, see the exposing ports section.


docker ps -a shows running and stopped containers.

Import / Export

There doesn't seem to be a way to use docker directly to import files into a container's filesystem.

  • docker cp copies files or folders out of a container's filesystem.
  • docker export turns container filesystem into tarball.


Images are just templates for docker containers.


  • docker images shows all images.
  • docker import creates an image from a tarball.
  • docker build creates image from Dockerfile.
  • docker commit creates image from a container.
  • docker rmi removes an image.
  • docker insert inserts a file from URL into image. (kind of odd, you'd think images would be immutable after create)
  • docker load loads an image from a tar archive as STDIN, including images and tags (as of 0.7).
  • docker save saves an image to a tar archive stream to STDOUT with all parent layers, tags & versions (as of 0.7).

docker import and docker commit only set up the filesystem, not Dockerfile info like CMD or ENTRYPOINT or EXPOSE. See bug.


Registry & Repository

A repository is a hosted collection of tagged images that together create the file system for a container.

A registry is a host -- a server that stores repositories and provides an HTTP API for managing the uploading and downloading of repositories.

Docker.io hosts its own index to a central registry which contains a large number of repositories.


The configuration file. Sets up a Docker container when you run docker build on it. Vastly preferable to docker commit.

Best to look at http://github.com/wsargent/docker-devenv and the best practices for more details.


The versioned filesystem in Docker is based on layers. They're like git commits or changesets for filesystems.


Links are how Docker containers talk to each other through TCP/IP ports. Linking into Redis and Atlassian show worked examples.

NOTE: If you want containers to ONLY communicate with each other through links, start the docker daemon with -icc=false to disable inter process communication.

If you have a container with the name CONTAINER (specified by docker run -name CONTAINER) and in the Dockerfile, it has an exposed port:


Then if we create another container called LINKED like so:

docker run -d -link CONTAINER:ALIAS -name LINKED user/wordpress

Then the exposed ports and aliases of CONTAINER will show up in LINKED with the following environment variables:


And you can connect to it that way.

To delete links, use docker rm -link.


Docker volumes are free-floating filesystems. They don't have to be connected to a particular container.

Volumes are useful in situations where you can't use links (which are TCP/IP only). For instance, if you need to have two docker instances communicate by leaving stuff on the filesystem.

You can mount them in several docker containers at once, using docker run -volume-from

See advanced volumes for more details.

Exposing ports

Exposing ports through the host container is fiddly but doable.

First expose the port in your Dockerfile:


Then map the container port to the host port:

docker run -p $HOSTPORT:$CONTAINERPORT -name CONTAINER -t someimage

If you're running Docker in Virtualbox, you then need to forward the port there as well. It can be useful to define something in Vagrantfile to expose a range of ports so that you can dynamically map them:

Vagrant.configure(VAGRANTFILE_API_VERSION) do |config|

  (49000..49900).each do |port|
    config.vm.network :forwarded_port, :host => port, :guest => port

If you forget what you mapped the port to on the host container, use docker port to show it:




Last Ids

alias dl='docker ps -l -q'
docker run ubuntu echo hello world
docker commit `dl` helloworld

Commit with command (needs Dockerfile)

docker commit -run='{"Cmd":["postgres", "-too -many -opts"]}' `dl` postgres

Get IP address

docker inspect `dl` | grep IPAddress | cut -d '"' -f 4


wget http://stedolan.github.io/jq/download/source/jq-1.3.tar.gz
tar xzvf jq-1.3.tar.gz
cd jq-1.3
./configure && make && sudo make install
docker inspect `dl` | jq -r '.[0].NetworkSettings.IPAddress'

Get Environment Settings

docker run -rm ubuntu env 

Delete old containers

docker ps -a | grep 'weeks ago' | awk '{print $1}' | xargs docker rm

Delete stopped containers

docker rm `docker ps -a -q`

Show image dependencies

docker images -viz | dot -Tpng -o docker.png