上面只是对 ssh的基本操作，在Linux上实现，那么我们要批量实现ssh免密登录呢？下面介绍下使用 Python脚本实现免密登录的过程。

import argparse
import collections
import subprocess


import os
from datetime import datetime
from fabric import Connection
from invoke import Responder

# 存放目标服务器的密码
HOST_PASSWDS = ['xxxx1','xxxx2','xxxx3']
# 存放错误信息的csv文件
FILE_NAME = 'ssh_test_{}_error.scv'.format(datetime.now().strftime('%Y-%m-%d %H:%M:%S'))

# 全局变量,我这使用的是 命名元祖
HOST_RESULT = collections.namedtuple('Host',['ip','passwd'])

def logging_error(msg):
    '''
    记录错误信息的函数
    :param msg: 错误信息
    :return:
    '''
    base_dir = os.getcwd()
    full_filename = os.path.join(base_dir,FILE_NAME)
    command = "echo '{}'  >> {} ".format(msg,full_filename)
    subprocess.check_call(command,shell=True)

def ssh_connect(ip,user='root',passwd=None,try_passwd=False):
    '''
    使用 ssh 连接服务器
    :param ip: 目标服务器的ip地址
    :param user: 一般ssh免密登录使用的是 root 用户
    :param passwd: 目标服务器的密码，我们统一放入列表中
    :param try_passwd: True  or  False
    :return:
    '''
    if passwd:
        try:
            host = Connection(ip,user=user,connect_kwargs={'password':passwd,'timeout':30})
            host.run('ls',hide=True,warn=True)
            if host.is_connected:
                return host
        except Exception as e:
            return e

    # 测试密码
    if try_passwd:
        for passwd in HOST_PASSWDS:
            try:
                host = Connection(ip,user=user,connect_kwargs={'password':passwd})
                host.run('ls',hide=True,warn=True)
                if host.is_connected:
                    return host
            except Exception as e:
                return False




def check_host_passwd(iplist):
    '''
    检测密码是否可用
    :param iplist: ip列表
    :return: 存放ip和passwd的列表
    '''
    host_list = []
    for ip in iplist:
        host = ssh_connect(ip,try_passwd=True)
        if not host:
            msg = "{} - 登录失败！".format(ip)
            logging_error(msg)
            continue
        host_info = HOST_RESULT(ip=ip,passwd=host.connect_kwargs.get('password'))
        host_list.append(host_info)
    return host_list



def gen_master_ssh_key(master_node):
    '''生成秘钥
    :param master_node: 主服务器的ip和密码组成的元祖类型
    :return:
    '''
    host = ssh_connect(master_node.ip,passwd=master_node.passwd)
    if not host:
        return False,"{}.master主机登录失败".format(master_node.ip)

    # 启动ssh服务
    host.run('service sshd start',hide=True,warn=True)
    command = 'find /root.ssh/ -name "id_rsa.pub"'
    # 执行 Linux命令，判断是否存在 id_rsa.pub文件
    result = host.run(command,hide=True,warn=True)
    if len(result.stdout.strip()) == 0:
        id_rsa = Responder(
            pattern = r'/root/.ssh/id_rsa',
            response = '\r\n'
        )
        passphrase = Responder(
            pattern = r'passphrase',
            response = '\r\n'
        )
        yes = Responder(
            pattern = r'(y/n)',
            response = 'y\n'
        )
        # 执行Linux 的 生成秘钥的命令
        result = host.run('ssh-keygen -t rsa',hide=True,warn=True,watchers=[id_rsa,passphrase,yes],timeout=10)
        if not result.ok:
            return False,"{}-生成ssh证书失败".format(master_node.ip)
        # print "[info]ip:{}-生成证书文件成功".format(master_node.ip)
        # else:
        #     print "[info] {} - master证书存在，不需要生成".format(master_node.ip)


    host.close()
    return True,'生成证书完成'


def ssh_test_to_other(master,node_list):
    '''
    把生成的证书分发给下面的免密的服务器
    :param master: 主服务器 元祖
    :param node_list: 节点列表
    :return:
    '''
    host = ssh_connect(master.ip,passwd=master.passwd)
    if not host:
        return False,'{} - master 登录失败'.format(master.ip)
    for node in node_list:
        passwd = Responder(
            pattern=r'[Pp]assword:',
            response = node.passwd + '\n'
        )
        yes = Responder(
            pattern = r'(yes/no)',
            response = 'yes\n'
        )
        # 清除 known_hosts文件
        clean_command = "ssh-keygen -f '/root/.ssh/known_hosts' -R {}".format(node.ip)
        result = host.run(clean_command,hide=True,warn=True,timeout=30)
        if result.ok:
            return 'known_hosts 记录清理'
        else:
            return 'konwn_hosts 无需清理'

        # 分发证书的 Linux命令
        scp_crt_command = 'ssh-copy-id -i /root/.ssh/id_rsa.pub {}'.format(node.ip)
        try:
            result = host.run(scp_crt_command,watchers=[passwd,yes],hide=True,warn=True,timeout=20)
            if result.ok:
                return '{} - 证书分发- {} - 成功'.format(master.ip,node.ip)
            else:
                msg = '{} - 证书分发- {} - 不成功'.format(master.ip,node.ip)
                logging_error(msg)
        except Exception as e:
            msg = '{} - 证书分发- {} - 成功 {}'.format(master.ip,node.ip,e.message)
            logging_error(msg)

    return True,''


# 参数解析
def parser_cla():
    '''
    对传入 Python脚本的参数做解析
    :return:
    '''
    parse = argparse.ArgumentParser()
    #  传入的服务器的ip/passwd 的格式，主服务器的ip和密码
    parse.add_argument('-m','--master',help='this ip of master usage:ip/passwd')

    # 节点服务器的ip，用逗号分隔开，可以是单个ip，也可以是多个ip
    parse.add_argument('-s','--nodes',help='this ip of node multiple host split by “，”')

    # 节点文件。可以把多个ip放入文件内，脚本自动读取文件
    parse.add_argument('-f','--nodefile',help='the full path of node file like /tmp/node.txt')

    # 测试 节点是否可以免密登录的参数
    parse.add_argument('-c','--check',action='store_true',help='check the nodes is can be ssh login')

    # 密码的参数，是节点服务器的密码，可以不输入，默认使用 HOST_PASSWD中的密码
    parse.add_argument('-p','--passwd',help='add other passwd for nodes')

    args = parse.parse_args()
    return args


def check_ssh_login(master,nodes):
    '''
    测试免密登录是否实现的函数
    :param master: 主服务器
    :param nodes: 节点服务器
    :return:
    '''
    # 主服务器的连接
    host = ssh_connect(master.ip,passwd=master.passwd)
    if not host:
        return False,'{} - master 登录失败'.format(master.ip)

    # 遍历节点服务器列表，对每一个ip进行测试
    for node in nodes:
        ssh_command = 'ssh {} echo "ok" '.format(node)
        try:
            result = host.run(ssh_command,pty=True,hide=True,warn=True,timeout=5)
            if result.ok:
                return True,'{} 登录{}成功'.format(master.ip,node)
            else:
                msg = '{} 登录{}失败--{}'.format(master.ip,node,result.stdout)
                logging_error(msg)

        except Exception as e:
            msg = '{} - master登录{} 失败--{}'.format(master.ip,node,e)
            logging_error(msg)

    return True,''

def main():
    '''
    运行函数
    :return:
    '''
    # 存放节点服务器的列表
    nodelist = []
    # 对参数的解析
    args = parser_cla()
    # 有主服务器，需指定主服务器的格式
    if args.master:
        try:
            master_ip,master_passwd = args.master.split('/')
        except Exception as e:
            # print '输入指定格式 --master   master_ip/passwd'
            return False
        # print 'master:{},passwd{}'.format(master_ip,master_passwd)
        master_node = HOST_RESULT(ip=master_ip,passwd=master_passwd)
    else:
        # print '需指定master主机  --master_ip/passwd'
        return False

    #对传入节点服务器ip进行分割
    if args.nodes:
        nodelist = args.nodes.split(',')
        # print 'nodes:{}'.format(nodelist)

    # 对节点服务器文件的处理
    if args.nodefile:
        file_name = args.nodefile
        base_dir = os.getcwd()
        full_path = os.path.join(base_dir,file_name)
        with open(full_path,'r')as f:
            nodelist = [ip.strip() for ip in f.readline()]
        # print 'nodes:{}'.format(nodelist)
    # 没有节点  和 节点文件传入，做出的处理
    if not args.nodes and not args.nodefile:
        # print '需指定分发证书节点  --nodes  or --nodefile'
        return False

    # 对参数密码的处理，可以输入多个密码，逗号分割
    if args.passwd:
        passwds = args.passwd.split(',')
        for i in passwds:
            HOST_PASSWDS.insert(0,i)

    #进行测试
    if args.check:
        # 检查证书是否可用
        check_ssh_login(master_node,nodelist)
        return

    # 登录主机生成秘钥，获取密码
    node_result = check_host_passwd(nodelist)
    if len(node_result) == 0:
        # print '无可用节点'
        return False
    status,msg = gen_master_ssh_key(master_node)
    if not status:
        logging_error(msg)
    
    # 分发所有master主机证书到node 
    ssh_test_to_other(master_node,node_result)


if __name__ == '__main__':
    main()