python如何通过代码自动免密登陆ssh

在网上看带不少ssh免密登陆的类容，基本上都是要自己手配很多东西所以自己就将代码经行修改，完成自动化免密登陆ssh

#!/usr/bin/env python
# _*_ coding:utf-8 _*_

# 代码启动方式， ip.txt:目标机器的IP/passwd
# python py文件 -m ip/passwd -s ip,ip -f ip.txt -p passswd
# python py文件 -m ip/passwd -s ip,ip -f ip.txt -p passswd -c 校验是否成功
import argparse
import collections
import subprocess

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

# 存放错误信息的csv文件
FILE_NAME = 'ssh_test_{}_error.csv'.format(datetime.now().strftime('%Y-%m-%d %H:%M:%S'))

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

# 这两个变量可以不用，之前我一直以为要配置/ect/hosts文件，其实不用
# 本机的ip
HOSTS_IP = '你自己的ip'
# 本机的主机名称
HOSTS_NAME = '你自己的主机名'


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, hosts_passwd=None):
    """
    使用 ssh 连接服务器
    :param ip: 目标服务器的ip地址
    :param user: 一般ssh免密登录使用的是 root 用户
    :param passwd: 目标服务器的密码
    :param hosts_passwd: 本机密码
    :return:
    """
    # hosts文件在这里配置，其实不用配置
    if hosts_passwd:
        try:
            host = Connection(ip, user=user, connect_kwargs={'password': hosts_passwd, 'timeout': 30})
            host_info = host.run('cat /etc/hosts', hide=True, warn=True)
            if f'{HOSTS_IP} {HOSTS_NAME}' in host_info.stdout:
                pass
            else:
                host_name = host.run('cat /etc/hostname', hide=True, warn=True)
                host.run(f'echo {HOSTS_IP} {HOSTS_NAME}>>/etc/hosts', hide=True, warn=True)
                host.run(f'echo {ip} {host_name.stdout.strip()}>>/etc/hosts', hide=True, warn=True)
        except Exception as e:
            return e
    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


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 / -name "id_rsa.pub"'
    # 执行 Linux命令，判断是否存在 id_rsa.pub文件
    result = host.run(command, hide=True, warn=True)
    if len(result.stdout.strip()) == 0:
        id_rsa_path = result.stdout.strip()
        id_rsa = Responder(
            pattern=id_rsa_path,
            response='
'
        )
        passphrase = Responder(
            pattern=r'passphrase',
            response='
'
        )
        yes = Responder(
            pattern=r'(y/n)',
            response='y
'
        )
        # 执行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)

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


def reload_ssh(node_list):
    """
    重启ssh
    :param node_list:
    :return:
    """
    for node in node_list:
        host = ssh_connect(node.ip, passwd=node.passwd)
        host.run('sudo  service  shhd restart', hide=True, warn=True, timeout=20)


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 + '
'
        )
        yes = Responder(
            pattern=r'(yes/no)',
            response='yes
'
        )
        # 清除 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)
        # 分发证书的 Linux命令
        data = host.run('find / -name "id_rsa.pub"', hide=True, warn=True)
        path = data.stdout.strip()
        scp_crt_command = 'ssh-copy-id -i root@{}'.format(node.ip)
        try:
            # pty=True 这个参数会影响是否能分发成功
            result = host.run(scp_crt_command, pty=True, watchers=[passwd, yes], hide=True, warn=True, timeout=20)
            print(result.stderr)
            if result.ok:
                return '{} - 证书分发- {} - 成功'.format(master.ip, node.ip)
            else:
                msg = '{} - 证书分发- {} - 不成功'.format(master.ip, node.ip)
                logging_error(msg)
            host.run('chmod  -R 700 .ssh/', hide=True, warn=True, timeout=20)
            host.run('sudo chmod 600 .ssh/authorized_keys', hide=True, warn=True, timeout=20)
            # host.run('sudo  service  shhd restart', hide=True, warn=True) # Centos6的命令
            # host.run('service sshd start', hide=True, warn=True)  # 如果报错就用这条命名centos7
        except Exception as e:
            msg = '{} - 证书分发- {} - 成功 {}'.format(master.ip, node.ip, e.message)
            logging_error(msg)
    # 其实配置免密登陆可以不用重启ssh
    # reload_ssh(node_list)

    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:
                print('{} 登录{}成功'.format(master.ip, node))
                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:
    """
    # 存放节点服务器的列表记录错误信息的函数
    #     :param msg: 错误信息
    #     :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(',')
    
    node_result = []
    # 对节点服务器文件的处理
    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:
            for ip in f.readlines():
                ip, passwd = ip.split('/')
                nodelist.append(ip)
　　　　　　　　　 #在自己不断尝试后发现不用配置节点的/etc/hosts文件也可以免密登陆
                # ssh_connect(ip.strip(), user='root', hosts_passwd=passwd.strip())
                host_info = HOST_RESULT(ip=ip.strip(), passwd=passwd.strip())
                node_result.append(host_info)

    # 没有节点  和 节点文件传入，做出的处理
    if not args.nodes and not args.nodefile:
        # print('需指定分发证书节点  --nodes  or --nodefile')
        return False

    # 进行测试
    if args.check:
        # 检查证书是否可用
        check_ssh_login(master_node, nodelist)
        return
    # 生成秘钥
    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()