Fabric on Dapeng Zhang

fabric 2.5.0添加类似env配置文件，减少执行命令重复操作

Wed, 30 Jul 2025 11:44:26 +0800

fabric 2.5.0可以通过添加类似env配置文件，从而达到减少执行命令的重复操作，比如减少每次执行任务的用户名和密码的输入

如果将用户名和密码写入fabric.py这种项目文件中，并提交到git仓库的话也是非常不安全的

但是根据用户来创建一个可自己访问和执行的文件就比较方便，尤其是在linux系统下，多个用户多一个操作系统都有权限的话，每个用户下面只要有个~/.fabric.yaml文件

便可以执行fabric的任务操作，从而避免了将重要密码暴漏给所有人，或者将自己的密码共享给所有人

创建配置文件


touch ~/.fabric.yaml

在配置文件中添加类似如下的配置信息


user: dpzhang
pwd: 123456

然后在fabric.py中添加任务


# -*- coding: utf-8 -*-
# @Author: durban.zhang
# @Date: 2019-12-04 16:52:35
# @Last Modified by: durban.zhang
# @Last Modified time: 2019-12-20 18:50:44

import getpass
from fabric import Connection, task

@task
def test(c):
 print(c.user)
 print(c.pwd)

命令行下执行


fab test

得到输出的结果如下


dpzhang
123456

如果将test方法修改如下


# -*- coding: utf-8 -*-
# @Author: durban.zhang
# @Date: 2019-12-04 16:52:35
# @Last Modified by: durban.zhang
# @Last Modified time: 2019-12-20 18:50:44

import getpass
from fabric import Connection, task

@task
def test(c):
 print(c.user)
 print(c.pwd)
 print(c.hosts.host)

同时修改~/.fabric.yaml，内容修改后如下


user: dpzhang
pwd: 123456
hosts:
 host: 127.0.0.1

再次运行


fab test

得到的输出结果如下


dpzhang
123456
127.0.0.1

Python小技巧 - Fabric并发执行远程主机操作

Wed, 30 Jul 2025 10:40:36 +0800

fabric中如何实现并发执行远程主机任务

比如我有多台远程主机，想要通过并行的方式在没太主机上执行同样的命令

如果按照fabric提供的ThreadingGroup的话，可能会遇到一个问题就是，每个主机在执行命令的时候，遇到问题，比如链接失败的话可能会导致所有的链接都失败，再比如我要判断每台机器的部署项目的目录是否存在，这个时候的话，每个远程主机执行的时候需要执行不同的逻辑，我采用另外一个方式，就是multiprocessing的方式

首先看下multiprocessing的并发如何实现

第一种是Process

实现方式如下


from multiprocessing import Pool, Process
import time

def host_run(host):
 print('执行 %s' % host)
 time.sleep(10)
 print('结束 %s' % host)

hosts = ['1', '2', '3', '4', '5', '6', '7', '8', '9', '10']

# Process方式创建进程
print('创建Process')
for h in hosts:
 p = Process(target=host_run, args=(h + ' - process', ))
 p.start()
print('Process执行结束')

运行结果如下


创建Process
执行 1 - process
执行 2 - process
执行 3 - process
执行 4 - process
执行 5 - process
执行 6 - process
执行 7 - process
执行 8 - process
Process执行结束
执行 9 - process
执行 10 - process
结束 1 - process
结束 2 - process
结束 3 - process
结束 4 - process
结束 5 - process
结束 6 - process
结束 7 - process
结束 8 - process
结束 9 - process
结束 10 - process

第二种是Pool

实现方式如下


from multiprocessing import Pool, Process
import time

def host_run(host):
 print('执行 %s' % host)
 time.sleep(10)
 print('结束 %s' % host)

hosts = ['1', '2', '3', '4', '5', '6', '7', '8', '9', '10']

# Pool方式创建大量子进程
print('创建Pool')
pool = Pool(len(hosts))
for h in hosts:
 pool.apply_async(host_run, args=(h + 'pool', ))
print('等待Pool执行')
pool.close()
pool.join()

运行结果如下


创建Pool
等待Pool执行
执行 1 - pool
执行 2 - pool
执行 3 - pool
执行 4 - pool
执行 5 - pool
执行 6 - pool
执行 7 - pool
执行 8 - pool
执行 9 - pool
执行 10 - pool
结束 2 - pool
结束 3 - pool
结束 1 - pool
结束 4 - pool
结束 5 - pool
结束 6 - pool
结束 7 - pool
结束 8 - pool
结束 9 - pool
结束 10 - pool

到这里，两种方式我们都实现了并发的方式执行代码逻辑

下面回到主体，整合到fabric中，要如何实现

实现代码如下


import socket, paramiko.ssh_exception
from fabric import SerialGroup, exceptions, runners, Connection
from fabric import task
from fabric.exceptions import GroupException
from multiprocessing import Process

hosts = ['localhost', 'localhost', 'localhost', 'localhost']

def host_run(host):
 c = Connection(host)
 res = c.run('ls -ahl')
 print(res)

@task
def asyncrun(c):
 for h in hosts:
 p = Process(target=host_run, args=(h, ))
 p.start()

运行结果如下


$ fab asyncrun
Process Process-1:
Traceback (most recent call last):
 File "/usr/local/Cellar/python@2/2.7.16/Frameworks/Python.framework/Versions/2.7/lib/python2.7/multiprocessing/process.py", line 267, in _bootstrap
 self.run()
 File "/usr/local/Cellar/python@2/2.7.16/Frameworks/Python.framework/Versions/2.7/lib/python2.7/multiprocessing/process.py", line 114, in run
 self._target(*self._args, **self._kwargs)
 File "/Users/durban/python/practise/fabfile.py", line 34, in host_run
 res = c.run('ls -ahl')
 File "<decorator-gen-3>", line 2, in run
 File "/Users/durban/python/.env_2.7.16/lib/python2.7/site-packages/fabric/connection.py", line 29, in opens
 self.open()
 File "/Users/durban/python/.env_2.7.16/lib/python2.7/site-packages/fabric/connection.py", line 634, in open
 self.client.connect(**kwargs)
 File "/Users/durban/python/.env_2.7.16/lib/python2.7/site-packages/paramiko/client.py", line 368, in connect
Process Process-3:
Process Process-4:
Process Process-2:
Traceback (most recent call last):
Traceback (most recent call last):
Traceback (most recent call last):
 File "/usr/local/Cellar/python@2/2.7.16/Frameworks/Python.framework/Versions/2.7/lib/python2.7/multiprocessing/process.py", line 267, in _bootstrap
 File "/usr/local/Cellar/python@2/2.7.16/Frameworks/Python.framework/Versions/2.7/lib/python2.7/multiprocessing/process.py", line 267, in _bootstrap
 File "/usr/local/Cellar/python@2/2.7.16/Frameworks/Python.framework/Versions/2.7/lib/python2.7/multiprocessing/process.py", line 267, in _bootstrap
 self.run()
 File "/usr/local/Cellar/python@2/2.7.16/Frameworks/Python.framework/Versions/2.7/lib/python2.7/multiprocessing/process.py", line 114, in run
 self.run()
 File "/usr/local/Cellar/python@2/2.7.16/Frameworks/Python.framework/Versions/2.7/lib/python2.7/multiprocessing/process.py", line 114, in run
 self._target(*self._args, **self._kwargs)
 File "/Users/durban/python/practise/fabfile.py", line 34, in host_run
 self._target(*self._args, **self._kwargs)
 File "/Users/durban/python/practise/fabfile.py", line 34, in host_run
 res = c.run('ls -ahl')
 File "<decorator-gen-3>", line 2, in run
 self.run()
 File "/Users/durban/python/.env_2.7.16/lib/python2.7/site-packages/fabric/connection.py", line 29, in opens
 File "/usr/local/Cellar/python@2/2.7.16/Frameworks/Python.framework/Versions/2.7/lib/python2.7/multiprocessing/process.py", line 114, in run
 self._target(*self._args, **self._kwargs)
 File "/Users/durban/python/practise/fabfile.py", line 34, in host_run
 res = c.run('ls -ahl')
 res = c.run('ls -ahl')
 File "<decorator-gen-3>", line 2, in run
 File "<decorator-gen-3>", line 2, in run
 File "/Users/durban/python/.env_2.7.16/lib/python2.7/site-packages/fabric/connection.py", line 29, in opens
 File "/Users/durban/python/.env_2.7.16/lib/python2.7/site-packages/fabric/connection.py", line 29, in opens
 raise NoValidConnectionsError(errors)
NoValidConnectionsError: [Errno None] Unable to connect to port 22 on 127.0.0.1 or ::1
 self.open()
 File "/Users/durban/python/.env_2.7.16/lib/python2.7/site-packages/fabric/connection.py", line 634, in open
 self.client.connect(**kwargs)
 File "/Users/durban/python/.env_2.7.16/lib/python2.7/site-packages/paramiko/client.py", line 368, in connect
 self.open()
 File "/Users/durban/python/.env_2.7.16/lib/python2.7/site-packages/fabric/connection.py", line 634, in open
 self.client.connect(**kwargs)
 File "/Users/durban/python/.env_2.7.16/lib/python2.7/site-packages/paramiko/client.py", line 368, in connect
 self.open()
 File "/Users/durban/python/.env_2.7.16/lib/python2.7/site-packages/fabric/connection.py", line 634, in open
 self.client.connect(**kwargs)
 File "/Users/durban/python/.env_2.7.16/lib/python2.7/site-packages/paramiko/client.py", line 368, in connect
 raise NoValidConnectionsError(errors)
 raise NoValidConnectionsError(errors)
NoValidConnectionsError: [Errno None] Unable to connect to port 22 on 127.0.0.1 or ::1
NoValidConnectionsError: [Errno None] Unable to connect to port 22 on 127.0.0.1 or ::1
 raise NoValidConnectionsError(errors)
NoValidConnectionsError: [Errno None] Unable to connect to port 22 on 127.0.0.1 or ::1

我这里是报了错误，但是从错误信息可以看出，每个host都并发的执行了，不然错误应该不会交叉输出的

后面会记录一个完整版的fabric，能过链接正式生产环境的脚本实践实例。

Fabric 并发方式执行项目部署命令

Wed, 30 Jul 2025 10:40:13 +0800

最近做运维工作，遇到项目部署的问题，不过通过python库fabric也是可以解决问题的

而且还是很方便，大概的方式如下

强调下，这里使用的是fabric 2这个版本

原理也是简单就是，fabric提供了ThreadingGroup这个类，网上很少有人用吧，google很久才找到

先看下以前的并行的方式，是如何执行项目部署命令的

代码如下


import getpass
from fabric import Connection, task
from invoke import Responder

hosts = [
 # service online machine
 '127.0.0.1', # web1
 '127.0.0.2', # web2
 '127.0.0.3', # web3
]

user = input('Input username:')
auth_pass = getpass.getpass('Input password:')
sudo_pass = Responder(
 pattern=r'\[sudo\] password',
 response=auth_pass + '\n',
)

@task
def deploy_series(c):
 for host in hosts:
 conn = Connection('%s@%s' % (user, host),
 connect_kwargs={'password': auth_pass})
 command = 'ls -al /'
 res = conn.run(command, pty=True, watchers=[sudo_pass])
 print(res)

示例代码简单的执行了ls -al /命令

上面的方式就是一台跟着一台机器的进行命令的执行，总的时间是没台机器执行完的时间总和，着实有点慢，影响代码上线的效率

下面看下并行的方式，并发的方式是如何运行的

代码如下


import getpass
from fabric import Connection, task
from invoke import Responder
from fabric import SerialGroup, ThreadingGroup
from fabric.exceptions import GroupException

hosts = [
 # service online machine
 '127.0.0.1', # web1
 '127.0.0.2', # web2
 '127.0.0.3', # web3
]

user = input('Input username:')
auth_pass = getpass.getpass('Input password:')
sudo_pass = Responder(
 pattern=r'\[sudo\] password',
 response=auth_pass + '\n',
)

@task
def deploy_parallel(c):
 g = ThreadingGroup(*hosts,
 user=user,
 connect_kwargs={'password': auth_pass})
 try:
 command = 'ls -al /'
 res = g.run(command, pty=True, watchers=[sudo_pass])
 print(res)
 except GroupException as e:
 for c, r in e.result.items():
 print(c)
 print(r)

同样的也只是执行命令而已

但是执行的顺序是并发的方式，总的执行时间是执行时间最长的那台机器的时间，很大程度提高了上线代码的执行效率。

如何使用fabric 2.x使用并行方式和串行方式远程自动化运维部署

Wed, 30 Jul 2025 09:57:20 +0800

之前一篇文章介绍如何使用fabric进行远程自动化部署

fabric2.x使用指南

脚本如下


import getpass
from fabric import Connection, task
from invoke import Responder

hosts = ['10.0.0.1', '10.0.0.2', '10.0.0.3', '10.0.0.4']

user = raw_input('Input username: ')
project = raw_input('Input project dirname: ')
auth_pass = getpass.getpass('Input auth pass: ')

# 需要sudo权限的时候需要
sudo_pass = Responder(
 pattern=r'\[sudo\] password',
 response=auth_pass + '\n',
)

@task
def deploy(c):
 for h in hosts:
 conn = Connection('%s@%s' % (user, h), connect_kwargs={'password': auth_pass})
 command = 'ls -al'
 # sudo 权限可用下面的命令
 # conn.run(command, pty=True, watchers=[sudo_pass])
 # 非sudo权限可用下面的命令 - 这里使用非sudo权限
 conn.run(command)

串行方式如下


import getpass
from fabric import Connection, task, SerialGroup
from invoke import Responder

hosts = ['10.0.0.1', '10.0.0.2', '10.0.0.3', '10.0.0.4']

user = raw_input('Input username: ')
project = raw_input('Input project dirname: ')
auth_pass = getpass.getpass('Input auth pass: ')

# 需要sudo权限的时候需要
sudo_pass = Responder(
 pattern=r'\[sudo\] password',
 response=auth_pass + '\n',
)

@task
def deploy(c):
 g = SerialGroup(*hosts, user=user, connect_kwargs={'password': auth_pass})
 command = 'ls -al'
 # sudo 权限可用下面的命令
 # conn.run(command, pty=True, watchers=[sudo_pass])
 # 非sudo权限可用下面的命令 - 这里使用非sudo权限
 conn.run(command)

并行方式如下


import getpass
from fabric import Connection, task, SerialGroup
from invoke import Responder

hosts = ['10.0.0.1', '10.0.0.2', '10.0.0.3', '10.0.0.4']

user = raw_input('Input username: ')
project = raw_input('Input project dirname: ')
auth_pass = getpass.getpass('Input auth pass: ')

# 需要sudo权限的时候需要
sudo_pass = Responder(
 pattern=r'\[sudo\] password',
 response=auth_pass + '\n',
)

@task
def deploy(c):
 g = ThreadingGroup(*hosts, user=user, connect_kwargs={'password': auth_pass})
 command = 'ls -al'
 # sudo 权限可用下面的命令
 # conn.run(command, pty=True, watchers=[sudo_pass])
 # 非sudo权限可用下面的命令 - 这里使用非sudo权限
 conn.run(command)

节省掉了for循环的操作但是增加了排查问题的难度

这里举例如何处理异常


import socket, paramiko.ssh_exception
from fabric import SerialGroup, exceptions, runners
from fabric import task
from fabric.exceptions import GroupException

@task
def run(c):
 g = SerialGroup('localhost')
 try:
 res = g.run('hostname')
 # print(res)
 except GroupException as e:
 for c, r in e.result.items():
 print("{}".format(c.host))
 print(c)
 print(r)
 if isinstance(r, runners.Result):
 print(" SUCCESS, " + r.stdout.strip())
 elif isinstance(r, socket.gaierror):
 print("NetWork Error")
 elif isinstance(r, paramiko.ssh_exception.AuthenticationException):
 print("Auth failed")
 else:
 print('Other Error')

基础知识汇总

Fabric 提供了一个 fabric.group.Group 基类，并由其派生出两个子类，区别是：

SerialGroup(*hosts, **kwargs)：按串行方式执行操作
ThreadingGroup(*hosts, **kwargs)：按并发方式执行操作

参考资料：

https://cloud.tencent.com/developer/article/1590930

fabric2.x使用指南

Wed, 30 Jul 2025 09:56:44 +0800

之前在看flask1.0的文档，里面学到了一个自动部署的工具fabric，但是里面介绍的是1.0系列的使用指南，但是我安装的时候版本已经更新了，已经是fabric2.x了，so，没办法，直接使用fabric2.x的版本吧，但是文档是fabric1.0的版本确实挺难受，毕竟很多功能要靠自己去摸索，然后再一点一点的实现，刚开始也是一头雾水，没有思路，今天回过头一看其实很简单的，主要是远程连接这块，不在区分本地和远程连接了，fabric1.x版本的时候会有个local的方法，使用起来一目了然，就知道具体这个是本地的还是远程。然后有小伙伴说了，就使用这个版本不行吗，我说不行，具体可以去fabric官网看下升级的必要性说明，其他不多说了，下面看下我说如何使用fabric2.x实现具体细节的

代码如下


# -*- coding: utf-8 -*-
# @Author: durban.zhang
# @Date: 2019-12-04 16:52:35
# @Last Modified by: durban.zhang
# @Last Modified time: 2019-12-04 18:41:59

import getpass
from fabric import Connection, task

@task
def pack(c):
 # 这里的c参数我理解为是Connection连接的本地 然后根据setup.py进行项目打包
 c.run('python setup.py release sdist --format=gztar')

@task
def deploy(c):
 # 输入服务器的登录用户名
 user = raw_input('Input login user name: ')
 # 输入服务器的登录地址
 host = raw_input('Input login host: ')
 # 输入服务器的项目目录地址
 root = raw_input('Input project root path：')
 # 输入服务器的登录密码
 user_pass = getpass.getpass('Input login user pass：')
 # 获取包的全名称
 result = c.run('python setup.py --fullname', hide=True)
 dist = result.stdout.strip()
 filename = '%s.tar.gz' % dist

 # 获取包的名称 - 这个名称可以根据自己的需求来自定义，这里主要是为了下面supervisor启动时使用
 result = c.run('python setup.py --name', hide=True)
 name = result.stdout.strip()

 # 远端服务器连接创建
 remote = Connection('%s@%s' % (user, host),
 connect_kwargs={"password": user_pass})
 # 上传文件到远端服务器
 remote.put('./dist/%s' %
 filename, remote='%s' % root)

 # 在远端服务器上执行下面命令 - 这个会默认输出你在远端服务器展示的信息
 result = remote.run('cd %s &&\
 source .env/bin/activate &&\
 ls -al && type python &&\
 pip install %s &&\
 supervisorctl restart walkerfree' % (root, filename))

使用方式如下


fab pack deploy

这个命令其实也可以分布执行


fab pack
fab deploy

我上面的代码也可以将两个函数合并到一起在执行，分开的话主要是看起来思路比较清晰

使用Fabric自动化你的任务

Tue, 24 Jun 2025 11:24:20 +0000

fabric是什么？

Fabric是一个Python库，可以通过SSH在多个host上批量执行任务。你可以编写任务脚本，然后通过Fabric在本地就可以使用SSH在大量远程服务器上自动运行。这些功能非常适合应用的自动化部署，或者执行系统管理任务。

让我们首先看一个例子。我们知道在 *NIX 下面，uname命令是查看系统的发行版。可以写这样一个Fabric脚本：

from fabric.api import run
def host_type():
 run('uname -s')

将上面的脚本保存为fabfile.py，就可以通过fab命令在多个主机上执行host_type脚本了：

$ fab -H localhost,linuxbox host_type
[localhost] run: uname -s
[localhost] out: Darwin
[linuxbox] run: uname -s
[linuxbox] out: Linux

执行过程中可能需要你输入系统密码。

安装

如果你看到这里了，说明你开始对Fabric感兴趣了。但是上述操作在你那里无法执行，因为你还没有安装Fabric。安装Fabric很简单，可以用pip或者easy_install，也可以下载原代码安装。

任务函数

很好，安装Fabric并没有难住你。可能你已经成功的执行了前面的任务，现在让我们更深入一些。

Fabric中的任务就是一个python函数，姑且让我们称之为“任务函数”。既然是python函数，那么对函数的一些用法也适用于任务函数。比如传递参数、互相调用、返回值等等。首先看一个传递参数的例子：

def hello(name="world"):
 print("Hello %s!" % name)

在执行任务的时候，可以通过fab的命令行参数为任务函数传递参数：

$ fab hello:name=Holbrook
Hello Holbrook!

组合任务的例子如下：

from fabric.api import run
def host_type():
 run('uname -s')
def hello(name="world"):
 print("Hello %s!" % name)
def composite(name="world"):
 hello(name)
 host_type()

Fabric提供的命令

前面我们见过了fabric.api模块中的run函数，其功能是在远端主机上执行命令。fabric.api中还提供了local函数，用于执行本地（Fabric所在的主机）命令。如下：

from fabric.api import local
def lslocal():
 local('ls')

类似远端命令和本地命令，Fabric也区分远端目录和本地目录。Fabric提供的对远端和本地目录的操作分别是cd和lcd。如果你用过命令行的ftp，这很容易理解。让我们看一个例子：

def filepath():
 remote_dir = '/opt/xxx'
 with cd(remote_dir):
 run("touch README")

上面代码的功能是进入远端的/opt/xxx目录，并创建一个README文件。

Fabric还提供了很多的命令，比如文件操作等，可以参考Fabric的operations模块。

管理服务器连接

前面的例子中，都需要在fab命令行参数中指定server。当要管理大量服务器时很麻烦。Fabric提供了环境变量的字典env，其中就包含了hosts字典项，可以定义需要连接的server。如下：

from fabric.api import env, run
env.hosts = ['host1', 'host2']
def mytask():
 run('ls /var/www')

也可以为每个任务单独指定要执行该任务的host列表：

from fabric.api import env, run
def set_hosts():
 env.hosts = ['host1', 'host2']
def mytask():
 run('ls /var/www')

这样执行 fab set_hosts mytask时，就可以为set_hosts中指定的两个host执行mytask任务了。如果你懒得写函数，在fab命令行中指定也是一样的：

fab mytask:hosts="host1;host2"

为了更方便的执行批量任务，Fabric中还定义了Role，有兴趣可以阅读其官方文档。

管理SSH密码、用户、端口

尽管更推荐使用SSH公钥认证，但是Fabric还是提供了管理密码的机制。Fabric提供了两层密码。

如果你的server有相同的密码，可以在env.password中设置默认的密码；如果server密码不同，还可以在env.passwords中设置(host,password）对，为每个server设置单独的ssh密码。

上面的host字符串采用这种格式：username@hostname:port。所以，在指定ssh密码的同时，也就指定了ssh用户。同密码一样，你也可以在env.user中指定一个默认的用户。如果都没有指定，执行fab命令时会提示你输入密码。

小结

使用Fabric，你可以管理一系列host的SSH连接（包括主机名，用户，密码），定义一系列的任务函数，然后灵活的指定在哪些host上执行哪些任务。这非常使用于需要管理大量host的场景，比如运维，私有云管理，应用自动化部署等。

本文只是一篇入门文档，远没有体现出Fabric的强大。实际上，Fabric还包括大量的功能，比如Role的定义，远程交互及异常处理，并发执行，文件操作等，并且不仅仅局限于命令行方式，可以在你的应用中调用Fabric。

希望本文能够引起你对Fabric的兴趣，并在你的实际应用中解决问题。