1 import paramiko
 2 
 3 transport = paramiko.Transport((‘hostname‘, 22))
 4 transport.connect(username=‘wupeiqi‘, password=‘123‘)
 5 
 6 ssh = paramiko.SSHClient()
 7 ssh._transport = transport
 8 
 9 stdin, stdout, stderr = ssh.exec_command(‘df‘)
10 print stdout.read()
11 
12 transport.close()
13 
14 SSHClient 封装 Transport

 1 import paramiko
 2 
 3 private_key = paramiko.RSAKey.from_private_key_file(‘/home/auto/.ssh/id_rsa‘)
 4 
 5 transport = paramiko.Transport((‘hostname‘, 22))
 6 transport.connect(username=‘wupeiqi‘, pkey=private_key)
 7 
 8 ssh = paramiko.SSHClient()
 9 ssh._transport = transport
10 
11 stdin, stdout, stderr = ssh.exec_command(‘df‘)
12 
13 transport.close()
14 
15 SSHClient 封装 Transport

 1 import paramiko
 2 from io import StringIO
 3 
 4 key_str = """-----BEGIN RSA PRIVATE KEY-----
 5 MIIEpQIBAAKCAQEAq7gLsqYArAFco02/55IgNg0r7NXOtEM3qXpb/dabJ5Uyky/8
 6 NEHhFiQ7deHIRIuTW5Zb0kD6h6EBbVlUMBmwJrC2oSzySLU1w+ZNfH0PE6W6fans
 7 H80whhuc/YgP+fjiO+VR/gFcqib8Rll5UfYzf5H8uuOnDeIXGCVgyHQSmt8if1+e
 8 7hn1MVO1Lrm9Fco8ABI7dyv8/ZEwoSfh2C9rGYgA58LT1FkBRkOePbHD43xNfAYC
 9 tfLvz6LErMnwdOW4sNMEWWAWv1fsTB35PAm5CazfKzmam9n5IQXhmUNcNvmaZtvP
10 c4f4g59mdsaWNtNaY96UjOfx83Om86gmdkKcnwIDAQABAoIBAQCnDBGFJuv8aA7A
11 ZkBLe+GN815JtOyye7lIS1n2I7En3oImoUWNaJEYwwJ8+LmjxMwDCtAkR0XwbvY+
12 c+nsKPEtkjb3sAu6I148RmwWsGncSRqUaJrljOypaW9dS+GO4Ujjz3/lw1lrxSUh
13 IqVc0E7kyRW8kP3QCaNBwArYteHreZFFp6XmtKMtXaEA3saJYILxaaXlYkoRi4k8
14 S2/K8aw3ZMR4tDCOfB4o47JaeiA/e185RK3A+mLn9xTDhTdZqTQpv17/YRPcgmwz
15 zu30fhVXQT/SuI0sO+bzCO4YGoEwoBX718AWhdLJFoFq1B7k2ZEzXTAtjEXQEWm6
16 01ndU/jhAasdfasdasdfasdfa3eraszxqwefasdfadasdffsFIfAsjQb4HdkmHuC
17 OeJrJOd+CYvdEeqJJNnF6AbHyYHIECkj0Qq1kEfLOEsqzd5nDbtkKBte6M1trbjl
18 HtJ2Yb8w6o/q/6Sbj7wf/cW3LIYEdeVCjScozVcQ9R83ea05J+QOAr4nAoGBAMaq
19 UzLJfLNWZ5Qosmir2oHStFlZpxspax/ln7DlWLW4wPB4YJalSVovF2Buo8hr8X65
20 lnPiE41M+G0Z7icEXiFyDBFDCtzx0x/RmaBokLathrFtI81UCx4gQPLaSVNMlvQA
21 539GsubSrO4LpHRNGg/weZ6EqQOXvHvkUkm2bDDJAoGATytFNxen6GtC0ZT3SRQM
22 WYfasdf3xbtuykmnluiofasd2sfmjnljkt7khghmghdasSDFGQfgaFoKfaawoYeH
23 C2XasVUsVviBn8kPSLSVBPX4JUfQmA6h8HsajeVahxN1U9e0nYJ0sYDQFUMTS2t8
24 RT57+WK/0ONwTWHdu+KnaJECgYEAid/ta8LQC3p82iNAZkpWlGDSD2yb/8rH8NQg
25 9tjEryFwrbMtfX9qn+8srx06B796U3OjifstjJQNmVI0qNlsJpQK8fPwVxRxbJS/
26 pMbNICrf3sUa4sZgDOFfkeuSlgACh4cVIozDXlR59Z8Y3CoiW0uObEgvMDIfenAj
27 98pl3ZkCgYEAj/UCSni0dwX4pnKNPm6LUgiS7QvIgM3H9piyt8aipQuzBi5LUKWw
28 DlQC4Zb73nHgdREtQYYXTu7p27Bl0Gizz1sW2eSgxFU8eTh+ucfVwOXKAXKU5SeI
29 +MbuBfUYQ4if2N/BXn47+/ecf3A4KgB37Le5SbLDddwCNxGlBzbpBa0=
30 -----END RSA PRIVATE KEY-----"""
31 
32 private_key = paramiko.RSAKey(file_obj=StringIO(key_str))
33 transport = paramiko.Transport((‘10.0.1.40‘, 22))
34 transport.connect(username=‘wupeiqi‘, pkey=private_key)
35 
36 ssh = paramiko.SSHClient()
37 ssh._transport = transport
38 
39 stdin, stdout, stderr = ssh.exec_command(‘df‘)
40 result = stdout.read()
41 
42 transport.close()
43 
44 print(result)
45 
46 基于私钥字符进行连接

 1 #!/usr/bin/env python
 2 # -*- coding:utf-8 -*-
 3 import paramiko
 4 import uuid
 5 
 6 class SSHConnection(object):
 7 
 8     def __init__(self, host=‘172.16.103.191‘, port=22, username=‘wupeiqi‘,pwd=‘123‘):
 9         self.host = host
10         self.port = port
11         self.username = username
12         self.pwd = pwd
13         self.__k = None
14 
15     def create_file(self):
16         file_name = str(uuid.uuid4())
17         with open(file_name,‘w‘) as f:
18             f.write(‘sb‘)
19         return file_name
20 
21     def run(self):
22         self.connect()
23         self.upload(‘/home/wupeiqi/tttttttttttt.py‘)
24         self.rename(‘/home/wupeiqi/tttttttttttt.py‘, ‘/home/wupeiqi/ooooooooo.py)
25         self.close()
26 
27     def connect(self):
28         transport = paramiko.Transport((self.host,self.port))
29         transport.connect(username=self.username,password=self.pwd)
30         self.__transport = transport
31 
32     def close(self):
33 
34         self.__transport.close()
35 
36     def upload(self,target_path):
37         # 连接，上传
38         file_name = self.create_file()
39 
40         sftp = paramiko.SFTPClient.from_transport(self.__transport)
41         # 将location.py 上传至服务器 /tmp/test.py
42         sftp.put(file_name, target_path)
43 
44     def rename(self, old_path, new_path):
45 
46         ssh = paramiko.SSHClient()
47         ssh._transport = self.__transport
48         # 执行命令
49         cmd = "mv %s %s" % (old_path, new_path,)
50         stdin, stdout, stderr = ssh.exec_command(cmd)
51         # 获取命令结果
52         result = stdout.read()
53 
54     def cmd(self, command):
55         ssh = paramiko.SSHClient()
56         ssh._transport = self.__transport
57         # 执行命令
58         stdin, stdout, stderr = ssh.exec_command(command)
59         # 获取命令结果
60         result = stdout.read()
61         return result
62         
63 
64 
65 ha = SSHConnection()
66 ha.run()
67 
68 Demo

1 # 对于更多限制命令，需要在系统中设置
2 /etc/sudoers
3   
4 Defaults    requiretty
5 Defaults:cmdb    !requiretty

 1 import paramiko
 2 import uuid
 3 
 4 class SSHConnection(object):
 5 
 6     def __init__(self, host=‘192.168.11.61‘, port=22, username=‘alex‘,pwd=‘alex3714‘):
 7         self.host = host
 8         self.port = port
 9         self.username = username
10         self.pwd = pwd
11         self.__k = None
12 
13     def run(self):
14         self.connect()
15         pass
16         self.close()
17 
18     def connect(self):
19         transport = paramiko.Transport((self.host,self.port))
20         transport.connect(username=self.username,password=self.pwd)
21         self.__transport = transport
22 
23     def close(self):
24         self.__transport.close()
25 
26     def cmd(self, command):
27         ssh = paramiko.SSHClient()
28         ssh._transport = self.__transport
29         # 执行命令
30         stdin, stdout, stderr = ssh.exec_command(command)
31         # 获取命令结果
32         result = stdout.read()
33         return result
34 
35     def upload(self,local_path, target_path):
36         # 连接，上传
37         sftp = paramiko.SFTPClient.from_transport(self.__transport)
38         # 将location.py 上传至服务器 /tmp/test.py
39         sftp.put(local_path, target_path)
40 
41 ssh = SSHConnection()
42 ssh.connect()
43 r1 = ssh.cmd(‘df‘)
44 ssh.upload(‘s2.py‘, "/home/alex/s7.py")
45 ssh.close()
46 
47 Demo

 1 #!/usr/bin/env python
 2 # -*- coding:utf-8 -*-
 3 
 4 from sqlalchemy import create_engine, and_, or_, func, Table
 5 from sqlalchemy.ext.declarative import declarative_base
 6 from sqlalchemy import Column, Integer, String, ForeignKey, UniqueConstraint, DateTime
 7 from sqlalchemy.orm import sessionmaker, relationship
 8 
 9 Base = declarative_base()  # 生成一个SqlORM 基类
10 
11 
12 class Host(Base):
13     __tablename__ = ‘host‘
14     id = Column(Integer, primary_key=True, autoincrement=True)
15     hostname = Column(String(64), unique=True, nullable=False)
16     ip_addr = Column(String(128), unique=True, nullable=False)
17     port = Column(Integer, default=22)
18 
19 
20 class HostUser(Base):
21     __tablename__ = ‘host_user‘
22     id = Column(Integer, primary_key=True, autoincrement=True)
23     username = Column(String(64), unique=True, nullable=False)
24     AuthTypes = [
25         (‘p‘, ‘SSH/Password‘),
26         (‘r‘, ‘SSH/KEY‘),
27     ]
28     auth_type = Column(String(16))
29     cert = Column(String(255))
30 
31     host_id = Column(Integer, ForeignKey(‘host.id‘))
32 
33     __table_args__ = (
34         UniqueConstraint(‘host_id‘, ‘username‘, name=‘_host_username_uc‘),
35     )
36 
37 
38 class Group(Base):
39     __tablename__ = ‘group‘
40     id = Column(Integer, primary_key=True, autoincrement=True)
41     name = Column(String(64), unique=True, nullable=False)
42 
43 
44 class UserProfile(Base):
45     __tablename__ = ‘user_profile‘
46     id = Column(Integer, primary_key=True, autoincrement=True)
47     username = Column(String(64), unique=True, nullable=False)
48     password = Column(String(255), nullable=False)
49 
50 
51 class Group2UserProfile(Base):
52     __tablename__ = ‘group_2_user_profile‘
53     id = Column(Integer, primary_key=True, autoincrement=True)
54     user_profile_id = Column(Integer, ForeignKey(‘user_profile.id‘))
55     group_id = Column(Integer, ForeignKey(‘group.id‘))
56     __table_args__ = (
57         UniqueConstraint(‘user_profile_id‘, ‘group_id‘, name=‘ux_user_group‘),
58     )
59 
60 
61 class Group2HostUser(Base):
62     __tablename__ = ‘group_2_host_user‘
63     id = Column(Integer, primary_key=True, autoincrement=True)
64     host_user_id = Column(Integer, ForeignKey(‘host_user.id‘))
65     group_id = Column(Integer, ForeignKey(‘group.id‘))
66     __table_args__ = (
67         UniqueConstraint(‘group_id‘, ‘host_user_id‘, name=‘ux_group_host_user‘),
68     )
69 
70 
71 class UserProfile2HostUser(Base):
72     __tablename__ = ‘user_profile_2_host_user‘
73     id = Column(Integer, primary_key=True, autoincrement=True)
74     host_user_id = Column(Integer, ForeignKey(‘host_user.id‘))
75     user_profile_id = Column(Integer, ForeignKey(‘user_profile.id‘))
76     __table_args__ = (
77         UniqueConstraint(‘user_profile_id‘, ‘host_user_id‘, name=‘ux_user_host_user‘),
78     )
79 
80 
81 class AuditLog(Base):
82     __tablename__ = ‘audit_log‘
83     id = Column(Integer, primary_key=True, autoincrement=True)
84 
85     action_choices2 = [
86         (u‘cmd‘, u‘CMD‘),
87         (u‘login‘, u‘Login‘),
88         (u‘logout‘, u‘Logout‘),
89     ]
90     action_type = Column(String(16))
91     cmd = Column(String(255))
92     date = Column(DateTime)
93     user_profile_id = Column(Integer, ForeignKey(‘user_profile.id‘))
94     host_user_id = Column(Integer, ForeignKey(‘host_user.id‘))
95 
96 表结构示例

 1 import paramiko
 2 import sys
 3 import os
 4 import socket
 5 import select
 6 import getpass
 7 from paramiko.py3compat import u
 8  
 9 tran = paramiko.Transport((‘10.211.55.4‘, 22,))
10 tran.start_client()
11 tran.auth_password(‘wupeiqi‘, ‘123‘)
12  
13 # 打开一个通道
14 chan = tran.open_session()
15 # 获取一个终端
16 chan.get_pty()
17 # 激活器
18 chan.invoke_shell()
19  
20 while True:
21     # 监视用户输入和服务器返回数据
22     # sys.stdin 处理用户输入
23     # chan 是之前创建的通道，用于接收服务器返回信息
24     readable, writeable, error = select.select([chan, sys.stdin, ],[],[],1)
25     if chan in readable:
26         try:
27             x = u(chan.recv(1024))
28             if len(x) == 0:
29                 print(‘\r\n*** EOF\r\n‘)
30                 break
31             sys.stdout.write(x)
32             sys.stdout.flush()
33         except socket.timeout:
34             pass
35     if sys.stdin in readable:
36         inp = sys.stdin.readline()
37         chan.sendall(inp)
38  
39 chan.close()
40 tran.close()

 1 #!/usr/bin/env python
 2 # -*- coding:utf-8 -*-
 3 
 4 import paramiko
 5 import sys
 6 import os
 7 import socket
 8 import select
 9 import getpass
10 from paramiko.py3compat import u
11 
12 
13 default_username = getpass.getuser()
14 username = input(‘Username [%s]: ‘ % default_username)
15 if len(username) == 0:
16     username = default_username
17 
18 
19 hostname = input(‘Hostname: ‘)
20 if len(hostname) == 0:
21     print(‘*** Hostname required.‘)
22     sys.exit(1)
23 
24 tran = paramiko.Transport((hostname, 22,))
25 tran.start_client()
26 
27 default_auth = "p"
28 auth = input(‘Auth by (p)assword or (r)sa key[%s] ‘ % default_auth)
29 if len(auth) == 0:
30     auth = default_auth
31 
32 if auth == ‘r‘:
33     default_path = os.path.join(os.environ[‘HOME‘], ‘.ssh‘, ‘id_rsa‘)
34     path = input(‘RSA key [%s]: ‘ % default_path)
35     if len(path) == 0:
36         path = default_path
37     try:
38         key = paramiko.RSAKey.from_private_key_file(path)
39     except paramiko.PasswordRequiredException:
40         password = getpass.getpass(‘RSA key password: ‘)
41         key = paramiko.RSAKey.from_private_key_file(path, password)
42     tran.auth_publickey(username, key)
43 else:
44     pw = getpass.getpass(‘Password for %s@%s: ‘ % (username, hostname))
45     tran.auth_password(username, pw)
46 
47 
48 
49 # 打开一个通道
50 chan = tran.open_session()
51 # 获取一个终端
52 chan.get_pty()
53 # 激活器
54 chan.invoke_shell()
55 
56 while True:
57     # 监视用户输入和服务器返回数据
58     # sys.stdin 处理用户输入
59     # chan 是之前创建的通道，用于接收服务器返回信息
60     readable, writeable, error = select.select([chan, sys.stdin, ],[],[],1)
61     if chan in readable:
62         try:
63             x = u(chan.recv(1024))
64             if len(x) == 0:
65                 print(‘\r\n*** EOF\r\n‘)
66                 break
67             sys.stdout.write(x)
68             sys.stdout.flush()
69         except socket.timeout:
70             pass
71     if sys.stdin in readable:
72         inp = sys.stdin.readline()
73         chan.sendall(inp)
74 
75 chan.close()
76 tran.close()
77 
78 完整示例（一）

 1 import paramiko
 2 import sys
 3 import os
 4 import socket
 5 import select
 6 import getpass
 7 import termios
 8 import tty
 9 from paramiko.py3compat import u
10  
11 tran = paramiko.Transport((‘10.211.55.4‘, 22,))
12 tran.start_client()
13 tran.auth_password(‘wupeiqi‘, ‘123‘)
14  
15 # 打开一个通道
16 chan = tran.open_session()
17 # 获取一个终端
18 chan.get_pty()
19 # 激活器
20 chan.invoke_shell()
21  
22  
23 # 获取原tty属性
24 oldtty = termios.tcgetattr(sys.stdin)
25 try:
26     # 为tty设置新属性
27     # 默认当前tty设备属性：
28     #   输入一行回车，执行
29     #   CTRL+C 进程退出，遇到特殊字符，特殊处理。
30  
31     # 这是为原始模式，不认识所有特殊符号
32     # 放置特殊字符应用在当前终端，如此设置，将所有的用户输入均发送到远程服务器
33     tty.setraw(sys.stdin.fileno())
34     chan.settimeout(0.0)
35  
36     while True:
37         # 监视 用户输入 和 远程服务器返回数据（socket）
38         # 阻塞，直到句柄可读
39         r, w, e = select.select([chan, sys.stdin], [], [], 1)
40         if chan in r:
41             try:
42                 x = u(chan.recv(1024))
43                 if len(x) == 0:
44                     print(‘\r\n*** EOF\r\n‘)
45                     break
46                 sys.stdout.write(x)
47                 sys.stdout.flush()
48             except socket.timeout:
49                 pass
50         if sys.stdin in r:
51             x = sys.stdin.read(1)
52             if len(x) == 0:
53                 break
54             chan.send(x)
55  
56 finally:
57     # 重新设置终端属性
58     termios.tcsetattr(sys.stdin, termios.TCSADRAIN, oldtty)
59  
60  
61 chan.close()
62 tran.close()

 1 #!/usr/bin/env python
 2 # -*- coding:utf-8 -*-
 3 import paramiko
 4 import sys
 5 import os
 6 import socket
 7 import getpass
 8 import termios
 9 import tty
10 import select
11 from paramiko.py3compat import u
12 
13 
14 def interactive_shell(chan):
15     # 获取原tty属性
16     oldtty = termios.tcgetattr(sys.stdin)
17     try:
18         # 为tty设置新属性
19         # 默认当前tty设备属性：
20         #   输入一行回车，执行
21         #   CTRL+C 进程退出，遇到特殊字符，特殊处理。
22 
23         # 这是为原始模式，不认识所有特殊符号
24         # 放置特殊字符应用在当前终端，如此设置，将所有的用户输入均发送到远程服务器
25         tty.setraw(sys.stdin.fileno())
26         tty.setcbreak(sys.stdin.fileno())
27         chan.settimeout(0.0)
28         while True:
29             r, w, e = select.select([chan, sys.stdin], [], [])
30             if chan in r:
31                 try:
32                     x = u(chan.recv(1024))
33                     if len(x) == 0:
34                         sys.stdout.write(‘\r\n*** EOF\r\n‘)
35                         break
36                     sys.stdout.write(x)
37                     sys.stdout.flush()
38                 except socket.timeout:
39                     pass
40             if sys.stdin in r:
41                 x = sys.stdin.read(1)
42                 if len(x) == 0:
43                     break
44                 chan.send(x)
45 
46     finally:
47         # 重新设置终端属性
48         termios.tcsetattr(sys.stdin, termios.TCSADRAIN, oldtty)
49 
50 
51 def run():
52     hostname = input(‘请输入主机名: ‘)
53     tran = paramiko.Transport((hostname, 22,))
54     tran.start_client()
55 
56     username = input(‘请输入用户名: ‘)
57     auth = input(‘请输入密码进行验证(p) 或 (r)sa Key进行验证?‘)
58     if auth == ‘r‘:
59         path = input(‘请输入RSA key 路径: ‘)
60         try:
61             key = paramiko.RSAKey.from_private_key_file(path)
62         except paramiko.PasswordRequiredException:
63             password = getpass.getpass(‘RSA key password: ‘)
64             key = paramiko.RSAKey.from_private_key_file(path, password)
65         tran.auth_publickey(username, key)
66     else:
67         pw = getpass.getpass(‘请输入密码 %s@%s: ‘ % (username, hostname))
68         tran.auth_password(username, pw)
69 
70     # 打开一个通道
71     chan = tran.open_session()
72     # 获取一个终端
73     chan.get_pty()
74     # 激活器
75     chan.invoke_shell()
76 
77     interactive_shell(chan)
78 
79     chan.close()
80     tran.close()
81 
82 
83 if __name__ == ‘__main__‘:
84     run()
85 
86 基于Passwd或者RSA进行登陆操作

 1 #!/usr/bin/env python
 2 # -*- coding:utf-8 -*-
 3 import paramiko
 4 import sys
 5 import os
 6 import socket
 7 import getpass
 8 import termios
 9 import tty
10 import select
11 from paramiko.py3compat import u
12 
13 
14 def interactive_shell(chan):
15     # 获取原tty属性
16     oldtty = termios.tcgetattr(sys.stdin)
17     try:
18         # 为tty设置新属性
19         # 默认当前tty设备属性：
20         # 输入一行回车，执行
21         # CTRL+C 进程退出，遇到特殊字符，特殊处理。
22 
23         # 这是为原始模式，不认识所有特殊符号
24         # 放置特殊字符应用在当前终端，如此设置，将所有的用户输入均发送到远程服务器
25         tty.setraw(sys.stdin.fileno())
26         tty.setcbreak(sys.stdin.fileno())
27         chan.settimeout(0.0)
28         while True:
29             r, w, e = select.select([chan, sys.stdin], [], [])
30             if chan in r:
31                 try:
32                     x = u(chan.recv(1024))
33                     if len(x) == 0:
34                         sys.stdout.write(‘\r\n*** EOF\r\n‘)
35                         break
36                     sys.stdout.write(x)
37                     sys.stdout.flush()
38                 except socket.timeout:
39                     pass
40             if sys.stdin in r:
41                 x = sys.stdin.read(1)
42                 if len(x) == 0:
43                     break
44                 chan.send(x)
45 
46     finally:
47         # 重新设置终端属性
48         termios.tcsetattr(sys.stdin, termios.TCSADRAIN, oldtty)
49 
50 
51 def run():
52     db_dict = {
53         ‘c1.salt.com‘: {
54             ‘root‘: {‘user‘: ‘root‘, ‘auth‘: ‘r‘, "cert": ‘key路径‘},
55             ‘alex‘: {‘user‘: ‘alex‘, ‘auth‘: ‘p‘, "cert": ‘密码‘},
56         },
57         ‘c2.salt.com‘: {
58             ‘alex‘: {‘user‘: ‘alex‘, ‘auth‘: ‘p‘, "cert": ‘密码‘},
59         },
60 
61     }
62 
63     for row in db_dict.keys():
64         print(row)
65 
66     hostname = input(‘请选择主机: ‘)
67     tran = paramiko.Transport((hostname, 22,))
68     tran.start_client()
69 
70     for item in db_dict[hostname].keys():
71         print(item)
72 
73     username = input(‘请输入用户: ‘)
74 
75     user_dict = db_dict[hostname][username]
76     if username[‘auth‘] == ‘r‘:
77         key = paramiko.RSAKey.from_private_key_file(user_dict[‘cert‘])
78         tran.auth_publickey(username, key)
79     else:
80         pw = user_dict[‘cert‘]
81         tran.auth_password(username, pw)
82 
83     # 打开一个通道
84     chan = tran.open_session()
85     # 获取一个终端
86     chan.get_pty()
87     # 激活器
88     chan.invoke_shell()
89 
90     interactive_shell(chan)
91 
92     chan.close()
93     tran.close()
94 
95 
96 if __name__ == ‘__main__‘:
97     run()
98 
99 提示用户选择主机和用户

  1 #!/usr/bin/env python
  2 # -*- coding:utf-8 -*-
  3 import paramiko
  4 import sys
  5 import os
  6 import socket
  7 import getpass
  8 import termios
  9 import tty
 10 import select
 11 from paramiko.py3compat import u
 12 
 13 
 14 def interactive_shell(chan):
 15     # 获取原tty属性
 16     oldtty = termios.tcgetattr(sys.stdin)
 17     try:
 18         # 为tty设置新属性
 19         # 默认当前tty设备属性：
 20         # 输入一行回车，执行
 21         # CTRL+C 进程退出，遇到特殊字符，特殊处理。
 22 
 23         # 这是为原始模式，不认识所有特殊符号
 24         # 放置特殊字符应用在当前终端，如此设置，将所有的用户输入均发送到远程服务器
 25         tty.setraw(sys.stdin.fileno())
 26         tty.setcbreak(sys.stdin.fileno())
 27         chan.settimeout(0.0)
 28 
 29         log = open(‘handle.log‘, ‘a+‘, encoding=‘utf-8‘)
 30         flag = False
 31         temp_list = []
 32 
 33         while True:
 34             r, w, e = select.select([chan, sys.stdin], [], [])
 35             if chan in r:
 36                 try:
 37                     x = u(chan.recv(1024))
 38                     if len(x) == 0:
 39                         sys.stdout.write(‘\r\n*** EOF\r\n‘)
 40                         break
 41                     # 如果用户上一次点击的是tab键，则获取返回的内容写入在记录中
 42                     if flag:
 43                         if x.startswith(‘\r\n‘):
 44                             pass
 45                         else:
 46                             temp_list.append(x)
 47                         flag = False
 48                     sys.stdout.write(x)
 49                     sys.stdout.flush()
 50                 except socket.timeout:
 51                     pass
 52             if sys.stdin in r:
 53                 # 读取用户在终端数据每一个字符
 54                 x = sys.stdin.read(1)
 55                 if len(x) == 0:
 56                     break
 57                 # 如果用户点击TAB键
 58                 if x == ‘\t‘:
 59                     flag = True
 60                 else:
 61                     # 未点击TAB键，则将每个操作字符记录添加到列表中，以便之后写入文件
 62                     temp_list.append(x)
 63 
 64                 # 如果用户敲回车，则将操作记录写入文件
 65                 if x == ‘\r‘:
 66                     log.write(‘‘.join(temp_list))
 67                     log.flush()
 68                     temp_list.clear()
 69                 chan.send(x)
 70 
 71     finally:
 72         # 重新设置终端属性
 73         termios.tcsetattr(sys.stdin, termios.TCSADRAIN, oldtty)
 74 
 75 
 76 def run():
 77     db_dict = {
 78         ‘c1.salt.com‘: {
 79             ‘root‘: {‘user‘: ‘root‘, ‘auth‘: ‘r‘, "cert": ‘key路径‘},
 80             ‘alex‘: {‘user‘: ‘alex‘, ‘auth‘: ‘p‘, "cert": ‘密码‘},
 81         },
 82         ‘c2.salt.com‘: {
 83             ‘root‘: {‘user‘: ‘root‘, ‘auth‘: ‘r‘, "cert": ‘key路径‘},
 84             ‘alex‘: {‘user‘: ‘alex‘, ‘auth‘: ‘p‘, "cert": ‘密码‘},
 85         },
 86 
 87     }
 88 
 89     for row in db_dict.keys():
 90         print(row)
 91 
 92     hostname = input(‘请选择主机: ‘)
 93     tran = paramiko.Transport((hostname, 22,))
 94     tran.start_client()
 95 
 96     for item in db_dict[hostname].keys():
 97         print(item)
 98 
 99     username = input(‘请输入用户: ‘)
100 
101     user_dict = db_dict[hostname][username]
102     if username[‘auth‘] == ‘r‘:
103         key = paramiko.RSAKey.from_private_key_file(user_dict[‘cert‘])
104         tran.auth_publickey(username, key)
105     else:
106         pw = user_dict[‘cert‘]
107         tran.auth_password(username, pw)
108 
109     # 打开一个通道
110     chan = tran.open_session()
111     # 获取一个终端
112     chan.get_pty()
113     # 激活器
114     chan.invoke_shell()
115 
116     interactive_shell(chan)
117 
118     chan.close()
119     tran.close()
120 
121 
122 if __name__ == ‘__main__‘:
123     run()
124 
125 提示用户选择主机和用户（记录操作日志）