Skip to main content

fabricio

Project description

Fabricio is a Docker deploy automation tool used along with the Fabric.

https://travis-ci.org/renskiy/fabricio.svg?branch=master https://coveralls.io/repos/github/renskiy/fabricio/badge.svg?branch=master

Features

  • build Docker images

  • create containers from images with provided tags

  • unlimited infrastructures

  • Fabric’s parallel execution mode compatibility

  • rollback containers to previous version

  • public and private Docker registries support

  • tasks groups

  • migrations apply and rollback

  • data backup and restore

  • DB master-slave configurations support

See changelog for detailed info.

Basic example

The most basic fabfile.py you can use with the Fabricio is something like this:

from fabricio import docker, tasks


nginx = tasks.DockerTasks(
    container=docker.Container(
        name='nginx',
        image='nginx:stable',
        options={
            'ports': '80:80',
        },
    ),
    hosts=['user@example.com'],
)

Type fab --list in your terminal to see available Fabric commands:

Available commands:

    nginx           backup -> pull -> migrate -> update
    nginx.deploy    backup -> pull -> migrate -> update
    nginx.pull      pull Docker image from registry
    nginx.rollback  rollback container to previous version
    nginx.update    start new Docker container if necessary

Finally, to deploy such configuration you simply have to execute following bash command:

fab nginx

To display detailed info about command (including available options) use following command: fab --display <command>.

See also Fabricio examples and recipes.

Install

pip install --upgrade fabricio

Roles and infrastructures

You can define as many roles and infrastructures as you need. The following example shows ‘production’ and ‘staging’ configurations for two-roles deploy configuration:

from fabric import colors, api as fab
from fabricio import docker, tasks


@tasks.infrastructure
def staging():
    fab.env.roledefs.update(
        balancer=['user@staging.example.com'],
        web=['user@staging.example.com'],
    )


@tasks.infrastructure(color=colors.red)
def production():
    fab.env.roledefs.update(
        balancer=['user@balancer.example.com'],
        web=['user@web1.example.com', 'user@web2.example.com'],
    )

balancer = tasks.DockerTasks(
    container=docker.Container(
        name='balancer',
        image='registry.example.com/nginx:balancer',
        options={
            'ports': ['80:80', '443:443'],
            'volumes': '/etc/cert:/etc/cert:ro',
        },
    ),
    roles=['balancer'],
)

web = tasks.DockerTasks(
    container=docker.Container(
        name='web',
        image='registry.example.com/nginx:web',
        options={
            'ports': '80:80',
            'volumes': '/media:/media',
        },
    ),
    roles=['web'],
)

Here is the list of available commands:

Available commands:

    production          select production infrastructure to run task(s) on
    production.confirm  automatically confirm production infrastructure selection
    staging             select staging infrastructure to run task(s) on
    staging.confirm     automatically confirm staging infrastructure selection
    balancer            backup -> pull -> migrate -> update
    balancer.deploy     backup -> pull -> migrate -> update
    balancer.pull       pull Docker image from registry
    balancer.rollback   rollback container to previous version
    balancer.update     start new Docker container if necessary
    web                 backup -> pull -> migrate -> update
    web.deploy          backup -> pull -> migrate -> update
    web.pull            pull Docker image from registry
    web.rollback        rollback container to previous version
    web.update          start new Docker container if necessary

‘production’ and ‘staging’ are available infrastructures here. To deploy to a particular infrastructure just provide it before any other Fabric command. For example:

fab staging balancer web

Tags

Almost every Fabricio command takes optional argument ‘tag’ which means Docker image tag to use when deploying container. For instance, if you want to deploy specific version of your application you can do it as following:

fab app.deploy:v1.2

By default, value for tag is taken from Container’s Image.

Rollback

To return container to previous version execute command fab app.rollback.

Forced update

fab app.update:force=yes

Forced update forces creation of new container.

Local Docker registry

It is often when production infrastructure has limited access to the Internet. In such case Fabricio offers ability to use local Docker registry which can be used as an intermediate registry for the selected infrastructure. To use this option you have to have local Docker registry running within your LAN and also Docker client on your work PC. You can up your own Docker registry by executing following command on the PC with Docker installed:

docker run --name registry --publish 5000:5000 --detach --restart always registry:2

When your local Docker registry is up and run you can use special tasks class to bypass infrastructure network limitations:

from fabricio import docker, tasks

nginx = tasks.PullDockerTasks(
    container=docker.Container(
        name='nginx',
        image='nginx:stable',
        options={
            'ports': '80:80',
        },
    ),
    hosts=['user@example.com'],
)

List of commands in this case updated with additional two commands:

nginx.prepare   prepare Docker image
nginx.push      push Docker image to registry

The first one pulls Image from the original registry and the second pushes it to the local registry which is used as main registry for all configuration’s infrastructures.

Building Docker images

Using local Docker registry you can also build Docker images from local sources. This example shows how this can be set up:

from fabricio import docker, tasks

app = tasks.BuildDockerTasks(
    container=docker.Container(
        name='app',
        image='app',
    ),
    hosts=['user@example.com'],
    build_path='src',
)

Commands list for BuildDockerTasks is same as for PullDockerTasks. The only difference is that ‘prepare’ builds image instead of pulling it from the original registry.

Project details


Download files

Download the file for your platform. If you're not sure which to choose, learn more about installing packages.

Source Distribution

fabricio-0.3.8.tar.gz (16.0 kB view hashes)

Uploaded Source

Supported by

AWS AWS Cloud computing and Security Sponsor Datadog Datadog Monitoring Fastly Fastly CDN Google Google Download Analytics Microsoft Microsoft PSF Sponsor Pingdom Pingdom Monitoring Sentry Sentry Error logging StatusPage StatusPage Status page