fbad 0.1.4
build tools for docker images
License: MIT
Keywords: docker build tools

# FBAD
FBAD is a commandline tool for projects requiring multiple docker images.

# Features
- easily build projects with multiple docker images
- build on remote server
- automatically push build images to registry
- select a subset of images to build
- build images in parallel on multiple buildservers
- you can also build all images on each buildserver (useful for different os architectures)
- run command before each image build (useful for generating dockerfiles before the build)
- automatically format tags (e.g. `myproject-{arch}` -> `myproject-x86`)
- show build output live
- ...

# Recommended directory structure

```
myproject/
    imagea/
        DOCKERFILE
        ...
    imageb/
        DOCKERFILE
        ...
    ...
    project.py
```

# Example `project.py`

```python
"""example fbad build file"""
from fbad import Project, Image


# the project contains all project and image data
project = Project(

    # name of the project
    name="Project",

    # list of images of the project
    images=[
        # most simple form
        # build the dockerfile in 'cachserver/'
        # use 'cachserver/Dockerfile' as dockerfile
        # build cwd is 'cachserver/'
        # name and tag are 'cachserver'
        Image(
            path="cacheserver/",
            ),

        # build image from the directory which contains 'project.py'
        # everything like above, but cwd is different
        # this is useful if you have shared files, like a package for common functionality
        # please note that all files being contained in the buildpath will be send to the buildserver.
        Image(
            path="webserver/",
            buildpath="",
            ),

        # build image with auto-formated tag and auto-generated dockerfile
        # the tag will be formated on the buildserver (e.g. 'worker-x86')
        # the dockerfile will also be generated on the buildserver
        # this is useful for building architecture specific images or
        # images with architecture-specific dependencies
        # this example also uses a custom buildpath
        Image(
            path="worker/",
            tag="worker-{arch}",
            buildpath="",
            preexec_command=["/usr/bin/python", "worker/generate_dockerfile.py"],
            ),

        # build image with a dockerfile having a different name.
        # dockerfile will be 'db/dbdockerfile.txt'
        Image(
            path="db/",
            dockerfile="dbdockerfile.txt",
            ),
        ],
    )


if __name__ == "__main__":
    # run the cli
    project.main()

```

# Buildserver
A buildserver is available using the `fbad-server` command.
You can also access import the buildserver as `fbad.server.FBADServerFactory`.
If no custom buildserver is specified when building a project, another buildserver is temporarly started.

# Installation
**Requirements**
FBAD requires python2 (most implementations should work) and twisted.
The buildserver also requires docker to be installed.

**Install via pip**
1. `pip install fbad`
2. Done

**Install from source**
1. `git clone https://github.com/bennr01/fbad.git`
2. `cd fbad`
3. `python setup.py install` (`sudo` may be required, depending on your python configuration)
4. Done.