Fabric

Fabric is a Python (2.5-2.7) library and command-line tool for streamlining the use of SSH for application deployment or systems administration tasks. Actually, Fabric, in essence, is a deployment management framework written in Python which makes remotely managing multiple servers incredibly easy as shown in the example below:

for s in $(cat servers.txt); do ssh $s service httpd graceful; done

where we issue a change to a group servers.

Fabric is best installed via pip:

$ pip install fabric

In order for Fabric's installation to succeed, we'll need following:

1. the setuptools packaging/installation library
2. the Python Paramiko SSH library
3. and Paramiko's dependency, the PyCrypto cryptography library
4. and, if using the parallel execution mode, the multiprocessing library
5. if we're using Paramiko 1.12 or above, we will also need an additional dependency for Paramiko, the ecdsa library

The installation process added a Python script called fab to a directory in our path. This is the script which will be used to make magic happen with Fabric, however, just running fab from the command-line won't do much at all. In order to do anything interesting, we'll need to create our first fabfile.

Typical use involves creating a Python module containing one or more functions, then executing them via the fab command-line tool. Below is a small but complete fabfile containing a single task (http://www.fabfile.org/):

from fabric.api import run

def host_type():
    run('uname -s')

Output:

$ fab -H localhost host_type
[localhost] Executing task 'host_type'
[localhost] run: uname -s
[localhost] out: Linux
[localhost] out: 


Done.
Disconnecting from localhost... done.

The fabfile is where all of your functions, roles, configurations, etc. will be defined. It's just a little bit of Python which tells Fabric exactly what it needs to do. By convention, this file should be named fabfile.py, but we can name it anything we'd like. If it's something other than fabfile.py, we'll need to specify the path with fab -f /path/to/notfabfile.py. Here's a simple example which runs uptime locally (from github):

#!/usr/bin/env python
from fabric.api import local

def uptime():
  local('uptime')

Output:

$ fab uptime
[localhost] local: uptime
 07:09:41 up 2 days, 12:39,  2 users,  load average: 1.88, 1.78, 1.31

Done.

Fabric provides a set of functions which can be used to interact with these remote hosts. The most commonly used ones are:

1. run - Run a shell command on a remote host.
2. sudo - Run a shell command on a remote host, with superuser privileges.
3. get - Download one or more files from a remote host.
4. put - Upload one or more files to a remote host.

#!/usr/bin/env python

from fabric.api import env, run

#env.hosts = [ '173.254.28.78', 'localhost' ]
#env.hosts = [ 'localhost' ]
env.hosts = [ '127.0.0.1' ]

def uptime():
  run('uptime')

Here, I used localhost, however, it should work on remote as well.

Here is the list of differences and similarities (DevOps Technologies: Fabric or Ansible):

1. We get results fairly quick in Fabric while Ansible needs more efforts to understand.
2. Ansible is more powerful since it provides much deeper and more complex semantics for modeling multi-tier infrastructure, such as those with arrays of web and database hosts.
3. From the user's perspective, Fabric has a more basic API and uses Python for authoring.
4. Ansible usess YAML and provides a richness in its behavior.
5. Both Ansible and Fabric do their taks via secure shell (SSH).
6. Fabric executes simple command-line statements to target machines over SSH.
7. Ansible pushes modules to remote machines and then executes these modules remotely.
8. The biggest difference between them is in the features and complexity.