Docker-build is a command line tool for building docker images and uploading them to the registry. It extends the low level docker build by building images with a Dockerfile, Vagrantfile or a rootfs archive.

Once built the image can be uploaded to a registry, which could be the official docker registry or your private registry.

Getting started - Installation

$ virtualenv venv
$ source venv/bin/activate
$ pip install docker-build

Sample build and upload

$ docker-build

docker-build.images and optionally docker-build.registry file must exist in the current working directory.

Alternatively you can set the image build file with:

$ docker-build -c my-images.config

The image configuration itself are pure python scripts with special meanings for builtin members Image and Registry. An Image can be one of:

a native docker image. The already existing image is used as it is. If the image is not present locally it's pulled from the global registry or the defined registry: Image('hello-world') Image('hello-world', registry=my_registry)
an image that uses an existing Dockerfile. The filename can differ from Dockerfile.
an image that uses an existing Vagrantfile with docker as provider.
an image created from an archive (tar, tar.bz2, tar.gz, tar.xz) that contains a root filesystem.

Listing image before building them:

$ docker-build -l

Registry configuration

There are two ways to configure registries. Either by command line argument -r or in a registry configuration file with the argument --rc.

$ docker-build -r staging=localhost:5000

$ docker-build --rc Dockerbuild.registries

Registry configuration file

Registries can be defined in the file docker-build.registry in the same folder where the docker-build.images can be found or as global settings in one of the pathes:

$HOME/.docker-build/registry
/etc/docker-build/registry

Example

# file: docker-build.registries
staging = Registry('https://foo:bar@localhost:5000')
qa      = Registry(user='foo', password='bar', host='localhost', port=5001)

Examples

ssh-server with a Dockerfile

#!docker-build -c
#
# file: docker-build.images
#
# use the ubuntu image from the official registry to create an image that
# runs a ssh server
ubuntu_image = Image('ubuntu')

Image('my-ubuntu-ssh', base=ubuntu_image,
    run = ['apt-get install -y openssh-server',
           'mkdir -p /var/run/sshd'],
    cmd = '/usr/sbin/sshd -D -e',
    expose = 22)

# another image using an existing Dockerfile that contains the same logic
Image('my-ubuntu-ssh2', dockerfile = 'ssh-server.Dockerfile')

upload to registry

#!docker-build -c
#
# file: docker-build.images
#
# Uploads official images to your private registry

my_registry = Registry('localhost:5000')

images = [
    Image('ubuntu:14.04'),
    Image('ubuntu:14.10'),
    Image('ubuntu:15.04')]

for image in images:
    Image(image.repotag, base=image, registry=my_registry)

use vagrant for provisioning

#!docker-build -c
#
# file: docker-build.images
#
# Use vagrant for provisioning a docker image

Image('my-ubuntu-vg', vagrant='vagrant.Vagrantfile')

build from root filesystem

#!docker-build -c
#
# file: docker-build.images
#
# Use an existing root filesystem in a (packed) tar file to create a
# docker image.

def build_rootfs():
    return os.system('make -f rootfs.makefile all')

def clean_rootfs():
    return os.system('make -f rootfs.makefile dist-clean')

# anonymous image
root_image = Image(rootfs='rootfs.tar', pre=build_rootfs, post=clean_rootfs)

Image('my-app', cmd='/opt/my-app/bin/app', base=root_image)

with environment variables

#!docker-build -c
#
# Uses environment variables.
#
# Example call:
#   REVISION=1.2.3 ./environment.images
#   REVISION=2.3.4 docker-build -c environment.images

import os

revision = os.environ['REVISION']

Image('hello-world:%s' % revision, base=Image('hello-world'))

peick / docker-build