NAME

       debocker - build Debian packages with docker

SYNOPSIS

       debocker [OPTS] COMMAND [COMMAND OPTS] [ARGS]

DESCRIPTION

       Debocker  builds  Debian  packages  inside  docker.  The  build process is contained in docker images and
       (almost) no other tools are needed to develop Debian packages on  the  main  system.  Moreover,  docker´s
       image  cache  reuses  the same system state whenever possible. In particular, when a package is built for
       the second time, its dependecies and buildchain are not downloaded nor installed again.

       Debocker is also able to create a self-contained bundle with everything necessary to build a package with
       docker only.

       You  do not have to be root to run debocker, but you have to be able to use docker(1) command. In Debian,
       it means that you must be a member of the docker group.

       The build process consists of 5 steps:

       1.  uprade - the base image is updated to the most recent packages (with apt-get)

       2.  install-utils - the Debian toolchain is installed

       3.  install-deps - the build dependencies of the package are installed

       4.  extract-source - the source package is extracted

       5.  build - the proper build is executed

COMMANDS

       Each command accepts --help option that shows its basic CLI usage.

       •   bundle [OPTS] [PATH]: Create a tarball file containing sources of a package in the current directory,
           and  a  series  of  scripts  to  build  it using docker. The resulting bundle is stored in the parent
           directory as a tarball. If the package is non-native, the original tarball must  be  present  in  the
           parent  directory.  However,  if the original tarball is not present, debocker will try to extract it
           using pristine-tar(1).

           The bundle is independent from debocker and can be used with docker only (see EXAMPLES).

           Arguments:

           PATH: optional path to the package; defaults to the current directory

           Options:

           -o FILE, --output FILE: store bundle in FILE; the file is a traditional tarball with a Debian  source
           package, a Dockerfile, and some utils

           -f   FLAGS,  --flags  FLAGS:  define  builds  flags  that  bundle  will  use;  these  are  passed  to
           dpkg-buildpackage

           --from STEP: invalidate STEP causing docker to restart from this step, even if previous cache exists;
           possible values are: build, extract-source, install-deps, install-utils, upgrade

           --image IMAGE: define the base docker image to use; defaults to debian:unstable

       •   build-bundle [OPTS] BUNDLE: Build a tarball file created with bundle by running the process in docker
           and extracting the final files to the current directory. This multi-step process takes  advantage  of
           docker´s cache whenever possible, saving space and making successive builds very fast.

           Arguments:

           BUNDLE: the location of a bundle to build

           Options:

           -o DIRECTORY, --output DIRECTORY: store the built files in DIRECTORY

           -s, --sign: sign the results of the build; this requires installed debsign (see devscripts(1))

           --no-cache:  do  not  use  docker´s  image  cache (passed directly to docker build); this effectively
           restarts the whole build from the start

           --pull: pull the newest base image if available (passed directly to docker build)

       •   build [OPTS] [PATH]: Create a temporary bundle with  bundle  and  build  it  with  build-bundle.  The
           respective options are passed unchanged to the subcommands (e.g., -s can be used to sign packages).

OPTIONS

       -v, --verbose
              Make debocker´s output verbose.

       --help Show summary of CLI usage.

       Global options must be given before the name of the command.

FILES

       There are no config files.

EXAMPLES

       Assuming that you are in a directory with a Debian source package:

           $ debocker build

       will  build  the  package in Debian unstable (the built files will be stored in the parent directory). If
       the build was successful, every subsequent run should use cache instead. You may  force  rebuild  at  any
       stage by using --from option. To rebuild the package, you may use:

           $ debocker build --from=build

       The build command is equivalent, save for the undeleted, intermediary file, with:

           $ debocker bundle --output /tmp/bundle.tar
           $ debocker build-bundle /tmp/bundle.tar --output ..

       You may pass custom flags to your build:

           $ debocker build --flags=´-j4´

       To create a (pseudo)-reproducible, compressed bundle with your package and to build it using docker:

           $ debocker bundle --output /tmp/bundle.tar
           $ docker run - < /tmp/bundle.tar

BUGS

       Debocker does not clean after itself. If you are not careful, docker images may consume a lot of space.

       And probably many more.

AUTHOR

       Initial idea and coding has been done by Tomasz Buchert tomasz@debian.org.

       Initial packaging, many ideas and a lot of support by Dariusz Dwornikowski.

       The semi-official homepage is http://debocker.debian.net.

SEE ALSO

       pbuiler(8), docker(1), devscripts(1), pristine-tar(1)