python使用Fabric模块实现自动化运维
示例
编写一个fabfile.py文件html
vim fabfile.pypython
#!/usr/bin/env python
# -*- coding:utf-8 -*-
from fabric.api import run
#定义一个任务函数，经过run方法实现远程执行‘uname -s’命令
def host_type():
run('uname -s')
fab命令操做：mysql
fab -H localhost host_type #结果： [localhost] Executing task 'host_type' [localhost] run: uname -s [localhost] Login password for 'root': [localhost] out: Linux [localhost] out: Done. Disconnecting from localhost... done.
上面实例也能够写成一行代码：nginx
|
1
|
fab -p 123456 -H localhost --
'uname -s'
#--后面要加空格
|
fabfile文件的编写
fab命令是结合fabfile.py文件（其余文件经过-f filename 参数来引用）来搭配使用的。fab的部分命令行参数还能经过相应的方法来代替。web
如：redis
fab -H 192.168.1.21,192.168.1.22 ... ... #能够在fabfile.py文件中用env.hosts来实现，命令行中就能够不用写了 #能够在fabfile中这么写： env.hosts = ['192.168.1.21','192.168.1.22']
fabfile之env对象
env对象的做用是定义fabfile的全局设定，就像上面的举例。下面对各属性进行说明：sql
env.hosts #定义目标主机，能够用IP或主机名表示，以python的列表形式定义。如env.hosts=['192.168.1.21','192.168.1.22']
env.exclude_hosts #排除指定主机，如env.exclude_hosts=['192.168.1.21']
env.user #定义用户名，如env.user='root'
env.port #定义端口，默认为22，如env.port='22'
env.password #定义密码，如env.password='123456'
env.passwords #定义多个密码，不一样主机对应不一样密码，如：env.passwords = {'root@192.168.1.21:22':'123456','root@192.168.1.22:22':'654321'}
env.gateway #定义网关（中转、堡垒机）IP，如env.gateway='192.168.1.23
env.roledefs #定义角色分组，好比web组合db组主机区分开来：env.roledefs = {'webserver':['192.168.1.21','192.168.1.22'],'dbserver':['192.168.1.25','192.168.1.26']}
env.deploy_release_dir #自定义全局变量，格式：env. + '变量名称'，如env.age,env.sex等
env.roledefs的使用方法实例：vim
env.roledefs = {'webserver':['192.168.1.21','192.168.1.22'],'dbserver':['192.168.1.25','192.168.1.26']}
#引用分组时使用python装饰器方式来进行,如：
@roles('webserver')
def webtask():
run('/usr/local/nginx/sbin/nginx')
@roles('webserver','dbserver')
def publictask():
run('uptime')
Fabric经常使用API
最上面的简单实例中使用了api函数run,下面再列举几个经常使用的api。centos
local #执行本地命令，如local('uname -s')
lcd #切换本地目录，如lcd('/home')
cd #切换远程目录
run #执行远程命令
sudo #sudo方式执行远程命令，如sudo('/etc/init.d/httpd start')
put #上次本地文件导远程主机，如put('/home/user.info','/data/user.info')
get #从远程主机下载文件到本地，如：get('/data/user.info','/home/user.info')
prompt #得到用户输入信息，如：prompt('please input user password:')
confirm #得到提示信息确认，如：confirm('Test failed,Continue[Y/N]?')
reboot #重启远程主机，如：reboot()
@task #函数修饰符，标识的函数为fab可调用的，非标记对fab不可见，纯业务逻辑
@runs_once #函数修饰符，标识的函数只会执行一次，不受多台主机影响
Fabric应用示例说明
一、查看本地与远程主机信息
本示例调用local方法执行本地命令，添加@runs_once修饰符保证任务函数只执行一次，调用run方法执行远程命令。api
1 #!/usr/bin/env python 2 # -*- encoding: utf-8 -*- 3 4 from fabric.api import * 5 6 env.user = 'root' 7 env.hosts = ['192.168.1.22'] 8 env.password = '123456' 9 10 @runs_once #查看本地系统信息，当有多台主机时只运行一次 11 def local_task(): #本地任务函数 12 local('uname -a') 13 14 def remote_task(): 15 with cd('/var/logs'): #with的做用是让后面的表达式语句继承当前状态，实现：cd /var/logs && ls -l的效果 16 run('ls -l')
执行：
|
1
2
|
fab -f simple1.py local_task
fab -f simple1.py remote_task
|
二、动态获取远程目录列表
本例调用@task修饰符标志入口函数go()对外部可见，配合@runs_once修饰符接收用户输入，最后调用worktask()函数实现远程命令执行。
1 #!/usr/bin/env python 2 # -*- encoding: utf-8 -*- 3 4 from fabric.api import * 5 6 env.user = 'root' 7 env.hosts = ['192.168.1.22'] 8 env.password = '123456' 9 10 @runs_once #主机遍历过程当中，只有第一台触发此函数 11 def input_raw(): 12 return prompt('please input directoryname:',default='/root') 13 14 def worktask(dirname): 15 run('ls -l'+dirname) 16 17 @task #限定只有go函数对fab命令可见,其余没有使用@task标记的函数fab命令不可用 18 def go(): 19 getdirname = input_raw() 20 worktask(getdirname)
执行:
|
1
|
fab
-
f simple2.py go
|
对于上面的结果作了一些测试发现:
1.设置了默认值,不输入就是以默认值为准,若是不设置默认值,那么dirname就是空的,ls -l的就是你登陆用户的家目录,例如是root就是/root
2.对于写在go函数下的内容,有多少主机就会循环多少次,他是以主机为循环的.
3.这个脚本是对于全部的主机列出同一个目录,对于不一样的主机让选择不一样的目录,能够简单的修改成:
|
1
2
3
4
5
6
7
|
def
worktask(dirname):
run(
'ls -l '
+
dirname)
@task
def
go():
getdirname
=
raw_input
(
"please input directory:"
)
worktask(getdirname)
|
3.文件打包上传校验
1 #!/usr/bin/env python 2 from fabric.api import * 3 from fabric.colors import * 4 5 env.hosts=['192.168.56.30'] 6 env.user='root' 7 env.passwords={'root@192.168.56.30:22':'rooter'} 8 9 @runs_once 10 @task 11 def tarfile(): 12 print yellow('tar file ...') 13 #使用with lcd命令,不然须要写全路径,直接lcd没用 14 with lcd('/var/log'): 15 local('tar czf messages.tar.gz messages') 16 17 @task 18 def putfile(): 19 print blue('put file ...') 20 run('mkdir -p /tmp/log') 21 with cd('/tmp/log'): 22 #warn_only当出现异常的时候继续执行 23 with settings(warn_only=True): 24 result=put('/var/log/messages.tar.gz','/tmp/log') 25 if result.failed and not confirm('put file filed,Continue[Y/N]?'): 26 abort('Aborting file put task!') 27 28 @task 29 def checkfile(): 30 print red('check file ...') 31 with settings(warn_only=True): 32 #本地local命令须要配置capture=True才能获取返回值 33 lmd5=local('md5sum /var/log/messages.tar.gz',capture=True).split(' ')[0] 34 rmd5=run('md5sum /tmp/log/messages.tar.gz').split(' ')[0] 35 if lmd5==rmd5: 36 print 'ok' 37 else: 38 print 'error' 39 40 @task 41 def go(): 42 tarfile() 43 putfile() 44 checkfile()
下面是运行结果，有颜色的区别:
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
|
[
192.168
.
56.30
] Executing task
'go'
tar
file
...
[localhost] local: tar czf messages.tar.gz messages
put
file
...
[
192.168
.
56.30
] run: mkdir
-
p
/
tmp
/
log
[
192.168
.
56.30
] put:
/
var
/
log
/
messages.tar.gz
-
>
/
tmp
/
log
/
messages.tar.gz
check
file
...
[localhost] local: md5sum
/
var
/
log
/
messages.tar.gz
[
192.168
.
56.30
] run: md5sum
/
tmp
/
log
/
messages.tar.gz
[
192.168
.
56.30
] out:
958b813fd7bdaa61cc206aa1012d8129
/
tmp
/
log
/
messages.tar.gz
[
192.168
.
56.30
] out:
ok
Done.
Disconnecting
from
192.168
.
56.30
... done
|
四、网关模式文件上传与执行
本例经过定义env.gateway网关模式，即俗称的中转、堡垒机环境。经过网关对其余主机进行文件上传和执行。
1 #!/usr/bin/env python 2 # -*- encoding: utf-8 -*- 3 4 from fabric.api import * 5 from fabric.context_managers import * 6 from fabric.contrib.console import confirm 7 8 env.user = 'root' 9 env.gateway = '192.168.1.23' #定义堡垒机IP，做为文件上传、执行的中转设置 10 env.hosts = ['192.168.1.21','192.168.1.22'] 11 env.passwords = { 12 'root@192.168.1.21:22':'123456', 13 'root@192.168.1.22:22':'abcdef', 14 'root@192.168.1.23:22':'123abc', #堡垒机帐号信息 15 } 16 17 lpackpath = '/home/install/lnmp.tar.gz' #本地安装包路径 18 rpackpath = '/tmp/install' #远程安装包路径 19 20 21 @task 22 def put_task(): #上传文件 23 run('mkdir -p /tmp/install') 24 #默认状况下，当命令执行失败时，Fabric会中止执行后续命令。有时，咱们容许忽略失败的命令继续执行，好比run(‘rm /tmp/abc')在文件不存在的时候有可能失败，这时能够用with settings(warn_only=True):执行命令，这样Fabric只会打出警告信息而不会中断执行。 25 with settings(warn_only=True): 26 result = put(lpackpath,rpackpath) #上传 27 if result.failed and not confirm('put file failed,Continue[Y/N]?'): 28 abort('Aborting file put task!') 29 30 @task 31 def run_task(): #安装 32 with cd('/tmp/install'): 33 run('tar -zxvf lnmp.tar.gz') 34 with cd('lnmp/'): #使用with继承/tmp/install目录位置状态 35 run('./centos.sh') 36 37 38 @task 39 def go(): #上传、安装组合命令 40 put_task() 41 run_task()
执行:
|
1
2
3
4
5
6
|
#上传文件
fab simple3.py put_task
#执行文件
fab simple3.py run_task
#上传并执行
fab simple3.py go
|
执行模式
- 执行模式可让你在多个主机上执行多个任务。
执行策略：
- 默认fabric是单个有序地执行方法，其行为以下：
1. 建立一系列任务，经过fab任务执行要执行的任务；
2. 根据主机列表定义，去执行每个任务；
3. 没有主机定义的任务，将在本地执行一次。
如：
from fabric.api import run, env
env.hosts = ['host1', 'host2']
def taskA():
run('ls')
def taskB():
run('whoami')
# 将在host1, host2都执行taskA, taskB
$ fab taskA taskB
# 执行顺序以下
taskA executed on host1
taskA executed on host2
taskB executed on host1
taskB executed on host2
定义任务：
- 如何定义任务，详情可见这里。
定义主机列表：
- 大多数时候你都须要根据目标，来定义多个远程主机，而不是仅在本地。
主机：
- python定义的主机字符串为:
username@hostname:port #用户名和端口均可以省略
- 主机定义也支持IPV6格式，如：
::1, [::1]:1222 user@2001:db8::1 user@[2001:db8::1]:1222
角色：
- 角色提供了能够定义一个字符串对应于一组主机列表，而不是每次都针对的是整个主机列表，如：
from fabric.api import env
#假如www1, www2, www3是你的web服务器, 你能够指定任务由特定的角色来执行
env.roledefs['webservers'] = ['www1', 'www2', 'www3']
# 定义多个角色
env.roledefs = {
'web': ['www1', 'www2', 'www3'],
'dns': ['ns1', 'ns2']
}
怎么构建hosts:
- 经过全局的env:
from fabric.api import env, run
env.hosts = ['host1', 'host2']
def mytask():
run('ls /var/www')
- env配置会被每一个任务检查，所以你彻底能够在方法中设置env，如：
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
- 经过命令行参数指定：
$ fab -H host1,host2 mytask #会被env.hosts所重写，相似角色也能够经过-R role1, role2, ...来定义
- 你也能够扩展命令行定义的主机，如：
from fabric.api import env, run
env.hosts.extend(['host3', 'host4'])
def mytask():
run('ls /var/www')
# 那么执行主机将merge为host1,host2,host3,host4
fab -H host1, host2 mytask
|
1
|
<span style
=
"font-family: verdana, Arial, Helvetica, sans-serif; font-size: 14px; line-height: 1.5;"
>NOTE: env.hosts是python的
list
对象，因此你能够用
list
.append()方法添加host，或者其余方法。<
/
span>
|
- 针对每一个任务的命令行参数：这是fabric提供一种更细粒度的定制：
from fabric.api import run
def mytask():
run('ls /var/www')
# 该定义将重写其余任何hosts定义，mytask仅会在host1，host2上执行
fab mytask:hosts="host1;host2"
- 针对每一个任务进行修饰：
from fabric.api import hosts, run
@hosts('host1', 'host2')
def mytask():
run('ls /var/www')
# 或者
my_hosts = ('host1', 'host2')
@hosts(my_hosts)
def mytask():
# ...
# 这种修饰将重写env.hosts设置, 但不会重写上面经过命令行定义的任务。
- 总结下上面这些host与task绑定定义的优先级：
# 由高到低
1. 命令行 fab mytask:host=host1
2. fabfile中修饰任务@hosts('host1')
3. 在fabfile中设置env.hosts = ['host1']
4. 在命令行中-H host1,host2,...
- 主机列表组合
from fabric.api import env, hosts, roles, run
env.roledefs = {'role1': ['b', 'c']}
@hosts('a', 'b')
@roles('role1')
def mytask():
run('ls /var/www')
# 若命令行不包含task定义，则上面的mytask家在a, b, c主机上执行
- 排除特定的主机
# 若myrole被定义运行[host1, host2,...,host15], 则该命令将排除host2,host5 $ fab -R myrole -x host2,host5 mytask #该-x并不会修改env.hosts
用Execute智能地执行任务：
- 看这么一个例子：
from fabric.api import run, roles
env.roledefs = {
'db': ['db1', 'db2'],
'web': ['web1', 'web2', 'web3'],
}
@roles('db')
def migrate():
# Database stuff here.
pass
@roles('web')
def update():
# Code updates here.
pass
# 在fabric1.2以前，咱们须要fab migrate update来执行这两个任务,
# 在fabric1.2以后，咱们能够经过execute函数来执行这两个任务:
from fabric.api import run, roles, execute
def deploy():
execute(migrate)
execute(update)
经过Execute访问多主机的结果：
- 一个范例
from fabric.api import env, roles, task, execute, run, runs_once
env.roledefs = {
'zoo': ['zooserver'],
'mysql': ['mysqlmaster'],
}
@task
def workhorse():
return run("uname -a")
@roles('zoo')
@task
@runs_once
def go():
results = execute(workhorse)
print results
#执行
fab go
用Execute动态设置host列表：
- 咱们能够经过传递参数，动态设置hosts，如：
from fabric.api import run, execute, task
# For example, code talking to an HTTP API, or a database, or ...
from mylib import external_datastore
# This is the actual algorithm involved. It does not care about host
# lists at all.
def do_work():
run("something interesting on a host")
# This is the user-facing task invoked on the command line.
@task
def deploy(lookup_param):
# This is the magic you don't get with @hosts or @roles.
# Even lazy-loading roles require you to declare available roles
# beforehand. Here, the sky is the limit.
host_list = external_datastore.query(lookup_param)
# Put this dynamically generated host list together with the work to be
# done.
execute(do_work, hosts=host_list)
# 调用
fab deploy:app
fab deploy:other
- 一个替代的方法：
from fabric.api import run, task
from mylib import external_datastore
# Marked as a publicly visible task, but otherwise unchanged: still just
# "do the work, let somebody else worry about what hosts to run on".
@task
def do_work():
run("something interesting on a host")
@task
def set_hosts(lookup_param):
# Update env.hosts instead of calling execute()
env.hosts = external_datastore.query(lookup_param)
#调用
fab set_hosts:app do_work
＃相比上一种方法，该方法能够轻易替换其余任务，如
fab set_hosts:db snapshot
fab set_hosts:cassandra,cluster2 repair_ring
fab set_hosts:redis,environ=prod status
故障处理：
- 故障处理也是一个比较实用的东西，fabric默认是"快速失败"的，一旦出现错误，就当即中止。
- 咱们能够经过settings上下文中的env.warn_only＝True来临时指定，失败也继续执行。
链接：
- fab自己是不对任何主机作远程链接的，她只会设置env.host_string的值(即当前的host)。
- NOTE: 链接对象Connection会保存在fabric.state.connections中，并作缓存，以减小建立新链接的消耗。
懒链接：
- fab在执行远程操做前，并不会事先去链接远程主机，如：
from fabric.api import *
@hosts('host1')
def clean_and_upload():
local('find assets/ -name "*.DS_Store" -exec rm '{}' \;')
local('tar czf /tmp/assets.tgz assets/')
put('/tmp/assets.tgz', '/tmp/assets.tgz') //这里才会开始进行远程链接相关的操做:cache.get() == null?new : cache.get()
with cd('/var/www/myapp/'):
run('tar xzf /tmp/assets.tgz')
关闭链接：
- 链接缓存并不会关闭链接。fab工具会帮你管理链接，它会遍历全部链接，并在其退出前关闭链接。你也能够调用fabric.network.disconnect_all()来确保关闭全部链接。
屡次链接尝试和跳过错误的主机：
- fabric在链接远程主机出错以前，会尝试屡次(env.connection_attempts,默认为1)链接，每次链接超时env.timeout 秒(默认为10)。
密码管理：
- Fabric在内存中维护了两层的密码缓存管理，会记住你登陆的密码和sudo时的密码，以避免之后再次输入。
- 第一层密码由 env.password保存，其值为ssh默认密码或sudo提示输入密码。第二层密码保存在env.passwords中，主要用于缓存user/host/port:password。
- Fabric仍是建议使用密钥进行ssh访问，如无密登陆。
使用本地的SSH配置文件：
- 你能够为Fabric指定特定的ssh配置文件(--ssh-config-path/env.ssh_config_path.)，但默认Fabric并无开启加载配置文件，须要设置env.use_ssh_config为True。
- 若开启了Fabric加载配置文件的选项，则Fabric为使用如下一些配置项：
User/Port ，HostName, IdentityFile, ForwardAgent, ProxyCommand。
1. Fabric的任务运行规则
根据Fabric Execution model的说明,fabric默认以串行方式运行tasks,具体而言:
1)在fabfile及其import文件中定义的task对象依次被建立(只是建立对象,并未真正执行),任务之间保持其定义的前后顺序。
2)对于每一个task,生成将要运行该task的目标机器列表。
3)fab执行tasks时,按任务被指定的顺序依次执行这些任务;针对每一个任务,依次在其指定的目标机器运行且只运行一次。
4)未指定目标机器的task被看成本地任务运行,且只会被运行一次。
假设在fabfile.py中定义了以下tasks:
from fabric.api import run, envenv.hosts = ['host1', 'host2']def taskA(): run('ls')def taskB(): run('whoami')
在终端运行fab –list时,咱们会看到taskA和taskB两个任务,运行之:
$ fab taskA taskB
结果示例以下:
taskA executed on host1taskA executed on host2taskB executed on host1taskB executed on host2
经过上面的实例,你们应该能够明白fabric默认的串行执行策略是怎么回事。
Fabric还容许咱们指定以并行方式(借助multiprocessing模块实现多个进程并行执行)在多台机器上并行地运行任务,甚至还可在同一个fabfile文件中指定某些task以并行方式运行,而某些task以默认的串行方式运行。具体地,能够借助@parallel或@serial指定任务的运行模式,还能够在命令行中经过-P参数指定任务是否要并性执行。示例以下:
from fabric.api import *@paralleldef runs_in_parallel(): passdef runs_serially(): pass
当运行以下命令时:
$ fab -H host1,host2,host3 runs_in_parallel runs_serially
执行结果示例以下:
runs_in_parallel on host1, host2, and host3runs_serially on host1runs_serially on host2runs_serially on host3
此外,还能够经过对@parallel传入pool_size参数来控制并行进程数以防并行进程太多把机器拖垮。
2. 为task指定目标机器
有多种方式能够指定任务的将要运行的目标机器,下面分别进行说明。
1)经过env.hosts或env.roles进行全局指定
Fabric的env模块中定义了一系列全局变量,能够将其理解为能够控制fabric行为的环境变量。其中env.hosts和env.roles能够用来全局指定task的目标机器列表,这两个“环境变量”的默认值都是空列表[]。
env.hosts的元素是fabric约定的”host strings”,每一个host strings由aliyunzixun@xxx.com:port三部分构成,其中username和port部分能够缺省。本篇笔记前面的第1个代码实例其实已经说明了如何用env.hosts全局地指定task的目标机器列表,这里再也不赘述。
env.roles则是在配置了env.roledefs的状况下才有用武之地。在不少时候,不一样的机器有着不一样的角色,若有些是接入层,有些是业务层,有些是数据存储层。env.roledefs能够用来组织这些机器列表以体现其角色,示例以下:
from fabric.api import envenv.roledefs = { 'web': { 'hosts': ['www1', 'www2', 'www3'], }, 'db': { 'hosts': ['db1', 'db2'], }}@roles('web')def mytask(): run('ls /var/www')
上例经过env.roledefs配置了两个角色web和db,分别包含3台、2台机器,并借助@roles为mytask指定了目标机器列表。
2)经过命令行进行全局指定
$ fab -H host1,host2 mytask
须要注意的是,命令行经过-H参数指定的机器列表在fabfile脚本load前被解释,故若是fabfile中从新配置了env.hosts或env.roles,则命令行指定的机器列表会被覆盖。为了不fabfile覆盖命令行参数,在fabfile中应该借助list.extend()指定env.hosts或env.roles,示例以下:
from fabric.api import env, runenv.hosts.extend(['host3', 'host4'])def mytask(): run('ls /var/www')
此时,当咱们运行”fab -H host1,host2 mytask”时,env.hosts包含来自命令行和fabfile的4台机器。
3)经过命令行为每一个任务指定机器列表
$ fab mytask:hosts="host1;host2"
上述方式会覆盖全局指定的机器列表,确保mytask只会在host1, host2上执行。
4)借助装饰器@hosts为每一个任务指定目标机器
from fabric.api import hosts, run@hosts('host1', 'host2')def mytask(): run('ls /var/www')
或者:
my_hosts = ('host1', 'host2')@hosts(my_hosts)def mytask(): # ...
每一个任务的@hosts装饰器指定的机器列表会覆盖全局目标机器列表,但不会覆盖经过命令行为该任务单独指定的目标机器列表。
上述4种为task指定目标机器列表的方式之间的优先级规则总结以下:
1) Per-task, command-line host lists (fab mytask:host=host1) override absolutely everything else.
2) Per-task, decorator-specified host lists (@hosts(‘host1’)) override the env variables.
3) Globally specified host lists set in the fabfile (env.hosts = [‘host1’]) can override such lists set on the command-line, but only if you’re not careful (or want them to.)
4) Globally specified host lists set on the command-line (–hosts=host1) will initialize the env variables, but that’s it.
截止目前,咱们能够看到,fabric容许咱们混合使用上面列出的几种目标机器指定方式,可是咱们要明白混合的结果是否符合预期。
此外,fabric默认会对经过不一样来源出现屡次的同一个目标机器作去重,固然,能够经过设置env.dedupe_hosts为False来关闭默认的去重策略。甚至还能够指定任务须要跳过的机器列表。具体细节能够参考Fabric Execution model的说明,这里不赘述。
3. 任务执行时,目标机器的密码管理
若是你亲自运行上面的示例代码,就会发现,每次在目标机器远程执行task时,fabric均会要求输入目标机器的登陆名及密码。若是要在多台机器上执行task,那这些密码输入的过程能够自动化吗?
答案是确定的。实现方式有两种,下面分别进行说明。
1)经过env.password或env.passwords配置目标机器的登陆信息
下面的示例说明了如何经过env.passwords配置多台机器的登陆信息:
#!/bin/env python#-*- encoding: utf-8 -*-from fabric.api import run, env, hosts## 须要注意的是,这里的host strings必须由aliyunzixun@xxx.com:port三部分构成,缺一不可,不然运行时仍是会要求输入密码env.passwords = { 'aliyunzixun@xxx.com:22': 'xxx', 'aliyunzixun@xxx.com:23': 'yyy',}@hosts('10.123.11.209', '10.123.11.210')def host_os_type(): run('uname -a')
因为经过env.passwords配置了目标机器的登陆用户名/密码,因此,当咱们在终端运行fab host_os_type时,会发现不用手动输入密码了,大大方便了脚本远程自动执行。
可是,这种明文指定登陆名/密码的方式存在安全性问题,因此,fabric还支持以ssh key认证的方式免密在远程机器执行任务。
在具体实现上,须要事先在目标机器上生成ssh public key并配置在~/.ssh/config文件中,而后在定义任务的fabfile中将env.use_ssh_config设置为True来启用基于ssh public key方式的身份认证,以便实现免密码远程执行任务
1、fab的经常使用参数
fab做为Fabric程序的命令入口，提供了丰富的参数调用，命令格式以下：
fab [options] <command>[:arg1,arg2=val2,host=foo,hosts='h1;h2',....]
下面列举了经常使用的几个参数，更多参数可以使用fab -help查看.
-l,显示定义好的任务函数名；
-f,指定fab入口文件，默认入口文件名为fabfile.py；
-g,指定网关设备，好比堡垒机环境，填写堡垒机IP便可；
-H,指定目标主机，多台主机用','号分隔；
-P，以异步并行方式运行多个主机任务，默认为串行运行；
-R，指定role(角色)，以角色名区分不一样业务组设备；
-t,设置设备链接超时时间；
-T，设置远程主机命令执行超时时间；
-w,当命令执行失败，发出警告，而非默认终止任务
2、fabfile的编写
fab命令是结合咱们编写的fabfile.py(其余文件名必须添加-f filename引用)来搭配使用，部分命令行参数能够经过相应的方法来代替，使之更加灵活，列如"-H 192.168.1.23,192.168.1.24",咱们能够经过定义env.hosts来实现，如"env.hosts=[192.168.1.23,192.168.1.24]".fabfile的主体由多个自定义的任务函数组成，不一样任务函数实现不一样的操做逻辑，下面详细介绍
3、全局属性设定
env对象的做用是定义fabfile的全局设定，支持多个属性，包括目标主机，用户，密码角色，各属性说明以下:
复制代码 代码以下:
env.host,定义目标主机，能够用IP或主机名表示，以Python的列表形式定义，如env.hosts=['192.168.1.23,192.168.1.24'].
env.exculde_hosts,排除指定主机，如env.exclude_hosts=['192.168.1.23']
env.user,定义用户名，如env.user="root"
env.port,定义目标主机端口,如env.port = '22'
env.password,定义密码,如env.password='123456'
env.passwords,与password功能同样，区别在于不一样主机不一样密码的应用场景，须要注意的是，配置passwords时须要配置用户，主机，端口等信息，如:env.passwords = {'root@192.168.1.21:22':'123456',
'root@192.168.1.23:22':'3234234',
'root@192.168.1.24:23':'09887',
}
env.gateway，定义网关(中转，堡垒机)IP,如env.gateway = '192.168.1.1'
env.roledefs,定义角色分组，好比web组与db组主机区分开来，定义以下：
env.roledefs = {
'webservers':['192.168.1.21','192.168.1.22','192.168.1.23'],
'dbservers':['192.168.1.24','192.168.1.25'],
}
引用时使用python修饰符的形式进行，角色修饰符下面的任务函数为其做用域，下面来看一个示例：
@roles('webservers')
def webtask():
run('/etc/init.d/nginx start')
@roles('dbservers'):
def dbtask():
run('/etc/init.d/mysql start')
@roles('webservers','dbservers')
def publictask():
run('uptime')
def deploy():
execute(webtask)
execute(dbtask)
execute(publictask)
在命令执行fab deploy就能够实现不一样角色执行不一样的任务函数。
经常使用API
Fabric提供了一组简单但功能强大的fabric.api命令集，简单地调用这样API就能完成大部分应用场景需求，Fabric支持经常使用的方法及说明以下:
复制代码 代码以下:
local,执行本地命令，如local:('uname -s');lcd,切换本地目录，如lcd:('/home');cd,切换远程目录，如cd:('/data/logs/');run,执行远程命令,如:run('free -m')sudo,sudo方式执行远程命令,如:sudo('/etc/init.d/httpd start');put,上传本地文件到远程主机,如:put('/home/user.info','/data/user.info');get,从远程主机下载文件到本地,如:get('/home/user.info','/data/user.info');prompt,得到用户输入信息,如:prompt('please input user password:');confirm,得到提示信息确认，如:confirm('Test failed,Continue[Y/N]');reboot,重启远程主机，如reboot();@task,函数修饰符，标识符的函数为fab可调用，非标记对fab不可见，纯业务逻辑；@runs_once，函数修饰符，标识符的函数只会执行一次，不受多台主机影响；示例1：查看本地与远程主机信息本示例调用local()方法执行本地命令，添加"@runs_once"修饰保证该任务函数只执行一次。调用run()方法执行远程命令，#!/usr/bin/env python# -*- coding: utf-8 -*-from fabric.api import *env.user = 'root'env.hosts = ['192.168.1.43','192.168.1.23','192.168.1.24']env.port = '22'env.password = '123456' @runs_once #查看本地系统信息,当有多台主机时只运行一次def local_task(): #本地任务函数 local('uname -a') def remote_task(): with cd('/data'): #with的做用是让后面的表达式语句继承当前状态，实现cd /var && ls -l的效果 run('ls -l')经过fab命令分别调用local_task任务函数运行效果以下图所示201608281657386.jpg结果中显示了[192.168.1.23] Executing task 'local_task',但事实上并不是在主机192.168.1.23上执行任务，而是返回Fabric主机本地的'uname -a'的执行效果调用remtoe_task任务函数的执行结果以下图所示201608281657387.jpg示例2；动态获取远程目录列表本示例使用"@task"修饰符标志入口函数go()对外部能够，配合"@runs_once"符等待接受用户输入，最后调用worktask()任务函数实现远程命令执行，#!/usr/bin/env python# -*- coding: utf-8 -*-from fabric.api import *env.user = 'root'env.hosts = ['192.168.1.23','192.168.1.24']env.password = '123456'@runs_once #在主机遍历过程当中，只有一台出发此函数def input_raw(): return prompt("please input direcotry name:",default="/home") def worktask(dirname): run("ls -l %s" %dirname) @taskdef go(): getdirname = input_raw() worktask(getdirname)该示例实现了一个动态输入远程目录名称，在获取目录列表的功能，因为咱们只要求输入一次，再显示全部主机上该目录的列表信息，调用了一个子函数input_raw(同时配置)@runs_once修饰符来达到此目的，执行结果以下图201608281657388.jpg文件上传与执行#!/usr/bin/env python# -*- coding: utf-8 -*-from fabric.api import *from fabric.context_managers import *from fabric.contrib.console import confirmenv.hosts=['192.168.1.23','192.168.1.24']#假如全部主机密码都不同，能够经过env.passwords字典变量一一指定env.passwords = { 'root@192.168.1.23:22': '123456', 'root@192.168.1.24:22': '123456',} lpackpath="/home/a.tar.gz"rpackpath="/tmp/install" @taskdef put_task(): run("mkdir -p /tmp/install") with settings(warn_only=True): result = put(lpackpath, rpackpath) if result.failed and not confirm("put file failed, Continue[Y/N]?"): abort("Aborting file put task!") @taskdef run_task(): with cd("/tmp/install"): run("tar -zxvf a.tar.gz") @taskdef go(): put_task() run_task()
- 1. 使用puppet实现自动化运维
- 2. Python自动化运维工具-Fabric部署及使用总结
- 3. Python自动化运维之经常使用模块—logging
- 4. 10.Python之Ansible自动化运维经常使用模块
- 5. Python自动化运维之经常使用模块—OS
- 6. Python自动化运维之模块与包的使用
- 7. python实现自动化运维资料
- 8. 自动化运维工具Ansible实战---经常使用模块
- 9. CrazyWing：Python自动化运维开发实战 十5、Python模块
- 10. 实用自动化运维Python脚本
- 更多相关文章...
- • Maven 自动化部署 - Maven教程
- • Lua 模块与包 - Lua 教程
- • Git可视化极简易教程 — Git GUI使用方法
- • ☆基于Java Instrument的Agent实现
-
每一个你不满意的现在，都有一个你没有努力的曾经。