# install dependencies
sudo apt-get install -y openssh-server libssl-dev
# generate private and public keys
ssh-keygen -t rsa -f ansible_id_rsa
# allow future client with this public key to connect to this server
cat ansible_id_rsa.pub >> ~/.ssh/authorized_keys
# setup proper permissions
chmod 0700  ~/.ssh/
chmod 0600  ~/.ssh/authorized_keys
# make sure the daemon is running
sudo service ssh restart

FROM python:2.7

# Install Ansible from source (master)
RUN apt-get -y update && \
apt-get install -y python-httplib2 python-keyczar python-setuptools python-pkg-resources
git python-pip && \
apt-get clean && rm -rf /var/lib/apt/lists/* /tmp/* /var/tmp/*
RUN pip install paramiko jinja2 PyYAML setuptools pycrypto>=2.6 six \
requests docker-py # docker inventory plugin
RUN git clone http://github.com/ansible/ansible.git /opt/ansible && \
cd /opt/ansible && \
git reset --hard fbec8bfb90df1d2e8a0a4df7ac1d9879ca8f4dde && \
git submodule update --init

ENV PATH /opt/ansible/bin:$PATH
ENV PYTHONPATH $PYTHONPATH:/opt/ansible/lib
ENV ANSIBLE_LIBRARY /opt/ansible/library

# setup ssh
RUN mkdir /root/.ssh
ADD ansible_id_rsa /root/.ssh/id_rsa
ADD ansible_id_rsa.pub /root/.ssh/id_rsa.pub

# extend Ansible
# use an inventory directory for multiple inventories support
RUN mkdir -p /etc/ansible/inventory && \
cp /opt/ansible/plugins/inventory/docker.py /etc/ansible/inventory/
ADD ansible.cfg /etc/ansible/ansible.cfg
ADD hosts /etc/ansible/inventory/hosts

# hosts
# this file is an inventory that Ansible is using to address remote servers. 
Make sure to replace the information with your specific setup and variables 
that you don't want to provide for every command.

[docker]
# host properties where docker daemon is running
192.168.0.12 ansible_ssh_user=xavier

# ansible.cfg

[defaults]

# use the path created from the Dockerfile
inventory = /etc/ansible/inventory

# not really secure but convenient in non-interactive environment
host_key_checking = False
# free you from typing `--private-key` parameter
priva_key_file = ~/.sh/id_rsa

# tell Ansible where are the plugins to load
callback_plugins = /opt/ansible-plugins/callbacks
connection_plugins = /opt/ansible-plugins/connections

# make docker to listen on HTTP and default socket
DOCKER_OPTS="-H tcp://0.0.0.0:2375 -H unix:///var/run/docker.sock"

# you need DOCKER_HOST variable to point to a reachable docker daemon
# pick the method that suits your installation

# for boot2docker users
eval "$(boot2docker shellinit)"
# for docker-machine users, provisioning the running VM was named "dev"
eval "$(docker-machine env dev)"
# for users running daemon locally
export DOCKER_HOST=tcp://$(hostname -I | cut -d" " -f1):2375
# finally users relying on a remote daemon should provide the server's public ip
export DOCKER_HOST=tcp://1.2.3.4:2375

# build the container from Dockerfile
docker build -t article/ansible .

# provide server API version, as returned by `docker version | grep -i "server api"`
# it should be at least greater or equal than 1.8
export DOCKER_API_VERSION=1.19

# create and enter the workspace
docker run -it --name builder \
# make docker client available inside
-v /usr/bin/docker:/usr/bin/docker \
-v /var/run/docker.sock:/var/run/docker.sock \
# detect local ip
-e DOCKER_HOST=$DOCKER_HOST \
-e DEFAULT_DOCKER_API_VERSION=DOCKER_API_VERSION \
-v $PWD:/app -w /app \ # mount the working space
article/ansible bash

# challenge the setup
$ container > ansible docker -m ping
192.168.0.12 | SUCCESS => {
"invocation": {
"module_name": "ping",
"module_args": {}
},
"changed": false,
"ping": "pong"
}

# provision.yml

- name: debug docker host
hosts: docker
tasks:
- name: debug infrastructure
# access container data : print the state
debug: var=hostvars["builder"]["docker_state"]

# you can target individual containers by name
- name: configure the container
hosts: builder
tasks:
- name: run dummy command
command: /bin/echo hello world

ansible-playbook provision.yml -i /etc/ansible/inventory
# ...
TASK [setup] ********************************************************************
fatal: [builder]: FAILED! => {"msg": "ERROR! SSH encountered an unknown error during the
connection. Re-run the command using -vvvv, which enables SSH debugging
output to help diagnose the issue", "failed": true}
# ...

# saved as ./connection_plugins/docker.py

import subprocess
from ansible.plugins.connections import ConnectionBase

class Connection(ConnectionBase):

@property
def transport(self):
""" Distinguish connection plugin. """
return 'docker'

def _connect(self):
""" Connect to the container. Nothing to do """
return self

def exec_command(self, cmd, tmp_path, sudo_user=None, sudoable=False,
executable='/bin/sh', in_data=None, su=None,
su_user=None):
""" Run a command within container namespace. """

if executable:
local_cmd = ["docker", "exec", self._connection_info.remote_addr, executable, '-c', cmd]
else:
local_cmd = '%s exec "%s" %s' % ("docker", self._connection_info.remote_addr, cmd)

self._display.vvv("EXEC %s" % (local_cmd), host=self._connection_info.remote_addr)
p = subprocess.Popen(local_cmd,
shell=isinstance(local_cmd, basestring),
stdin=subprocess.PIPE, stdout=subprocess.PIPE,
stderr=subprocess.PIPE)

stdout, stderr = p.communicate()
return (p.returncode, '', stdout, stderr)

def put_file(self, in_path, out_path):
""" Transfer a file from local to container """
pass

def fetch_file(self, in_path, out_path):
""" Fetch a file from container to local. """
pass

def close(self):
""" Terminate the connection. Nothing to do for Docker"""
pass

# modify the builder Dockerfile to upload the plugin code 
where Ansible is expecting connection plugins
echo "ADD connection_plugins/docker.py /opt/ansible-plugins/connections/docker.py" >> Dockerfile

# then, you need to explicitly tell which connection hook to use
when executing playbooks.
# you can achieve this by inserting the 'connection' property at the top
of provision tasks in provision.yml

- name: configure the container
connection: docker
hosts: builder

# you are ready to redeploy the builder container
# (providing DOCKER_HOST and DOCKER_API_VERSION are still set like before)

# rebuild the image
docker build -t article/ansible .

# restart the builder environment
docker run -it --name builder \
# make docker client available inside
-v /usr/bin/docker:/usr/bin/docker \
-v /var/run/docker.sock:/var/run/docker.sock \
# detect local ip
-e DOCKER_HOST=$DOCKER_HOST \
-e DEFAULT_DOCKER_API_VERSION=DOCKER_API_VERSION \
-v $PWD:/app -w /app \ # mount the working space
article/ansible bash

# rerun provisioning from inside
ansible-playbook -i /etc/ansible/inventory provision.yml
# ... Hurrah, full green output ...

---
- name: initialize provisioning
  hosts: docker

- name: start up target container
docker:
image: python:2.7
name: lab
pull: missing
detach: yes
tty: yes
command: sleep infinity
state: started
# dynamically update inventory to make it available down the playbook
- name: register new container hostname
add_host: name=lab

- name: provision container
connection: docker
hosts: lab
tasks:
# ...

- name: finalize build
hosts: docker
tasks:
- name: stop container
docker:
name: lab
image: python:2.7
state: stopped

# name the resulting artifact under a human readable image tag
docker tag lab article/lab:experimental

# push this image to the official docker hub
# make sure to replace 'article' by your own Docker Hub login (https://hub.docker.com)
# (this step is optional and will only make the image available from any docker host.
You can skip it or even use your own registry)
docker push article/lab:experimental

# save as callback_plugins/docker-cache.py
import hashlib
import os
import socket

# Hacky Fix `ImportError: cannot import name display`
# pylint: disable=unused-import
import ansible.utils
import requests
import docker

class DockerDriver(object):
""" Provide snapshot feature through 'docker commit'. """

def __init__(self, author='ansible'):
self._author = author
self._hostname = socket.gethostname()
try:
err = self._connect()
except (requests.exceptions.ConnectionError, docker.errors.APIError), error:
ansible.utils.warning('Failed to contact docker daemon: {}'.format(error))
# deactivate the plugin on error
self.disabled = True
return

self._container = self.target_container()
self.disabled = True if self._container is None else False

def _connect(self):
# use the same environment variable as other docker plugins
docker_host = os.getenv('DOCKER_HOST', 'unix:///var/run/docker.sock')
# default version is current stable docker release (10/07/2015)
# if provided, DOCKER_VERSION should match docker server api version
docker_server_version = os.getenv('DOCKER_VERSION', '1.19')
self._client = docker.Client(base_url=docker_host,
version=docker_server_version)
return self._client.ping()

def target_container(self):
""" Retrieve data on the container you want to provision. """
def _match_container(metadatas):
return metadatas['Id'][:len(self._hostname)] == self._hostname

matchs = filter(_match_container, self._client.containers())
return matchs[0] if len(matchs) == 1 else None

def snapshot(self, host, task):
tag = hashlib.md5(repr(task)).hexdigest()
try:
feedback = self._client.commit(container=self._container['Id'],
repository='factory',
tag=tag,
author=self._author)
except docker.errors.APIError, error:
ansible.utils.warning('Failed to commit container: {}'.format(error))
self.disabled = True

# pylint: disable=E1101
class CallbackModule(object):
"""Emulate docker cache.
Commit the current container for each task.

This plugin makes use of the following environment variables:
- DOCKER_HOST (optional): How to reach docker daemon.
Default: unix://var/run/docker.sock
- DOCKER_VERSION (optional): Docker daemon version.
Default: 1.19
- DOCKER_AUTHOR (optional): Used when committing image. Default: Ansible

Requires:
- docker-py >= v0.5.3

Resources:
- http://docker-py.readthedocs.org/en/latest/api/
"""

_current_task = None

def playbook_on_setup(self):
""" initialize client. """
self.controller = DockerDriver(self.conf.get('author', 'ansible'))

def playbook_on_task_start(self, name, is_conditional):
self._current_task = name

def runner_on_ok(self, host, res):
if self._current_task is None:
# No task performed yet, don't commit
return
self.controller.snapshot(host, self._current_task)

# modify the builder Dockerfile to upload the code where Ansible is expecting callback plugins
echo "ADD callback_plugins/docker-cache.py /opt/ansible-plugins/callbacks/docker-cache.py" >> Dockerfile

REPOSITORY          TAG                     IMAGE ID            CREATED             VIRTUAL SIZE
factory             bc0fb8843e88566c    bbdfab2bd904        32 seconds ago      829.8 MB
factory             d19d39e0f0e5c133    e82743310d8c        55 seconds ago      785.2 MB