Python----Paramiko模块和堡垒机实战

最新推荐文章于 2024-06-17 17:35:06 发布
最新推荐文章于 2024-06-17 17:35:06 发布
阅读量84 收藏
点赞数
文章标签： python linux ssh java jedis
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40895017/article/details/117377595
版权
paramiko模块

　　paramiko是一个用于做远程控制的模块，使用该模块可以对远程服务器进行命令或文件操作，值得一说的是，fabric和ansible内部的远程管理就是使用的paramiko来现实。其实它的底层是对ssh的上层代码的一个封装

一、下载安装

1
2
3
#pycrypto，由于 paramiko 模块内部依赖pycrypto，所以先下载安装pycrypto
tomcat@node:~$ pip install pycrypto
tomcat@node:~$ pip install paramiko

二、模块使用

1、SSHClient 用于连接远程服务器并执行基本命令

(1)基于用户名密码连接两种方式：

-->第一种

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
import  paramiko
# 创建SSH对象
ssh  =  paramiko.SSHClient()
# 允许连接不在know_hosts文件中的主机
ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())
# 连接服务器
ssh.connect(hostname = '192.168.1.21' , port = 22 , username = 'root' , password = '123456' )
# 执行命令
stdin, stdout, stderr  =  ssh.exec_command( 'ls' )
# 获取命令结果
result  =  stdout.read()
# 关闭连接
ssh.close()

-->二种：SSHClient 封装 Transport　　

1
2
3
4
5
6
7
8
9
10
11
12
import  paramiko
transport  =  paramiko.Transport(( '192.168.1.21' ,  22 ))
transport.connect(username = 'root' , password = '123456' )
ssh  =  paramiko.SSHClient()
ssh._transport  =  transport
stdin, stdout, stderr  =  ssh.exec_command( 'df' )
print  stdout.read()
transport.close()

(2)基于公钥密钥连接的两种方式：

-->第一种　　

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
import  paramiko
private_key  =  paramiko.RSAKey.from_private_key_file( '/root/.ssh/id_rsa' )
# 创建SSH对象
ssh  =  paramiko.SSHClient()
# 允许连接不在know_hosts文件中的主机
ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())
# 连接服务器
ssh.connect(hostname = '192.168.1.21' , port = 22 , username = 'root' , key = private_key)
# 执行命令
stdin, stdout, stderr  =  ssh.exec_command( 'df' )
# 获取命令结果
result  =  stdout.read()
# 关闭连接
ssh.close()

-->第二种：SSHClient 封装 Transport　　

1
2
3
4
5
6
7
8
9
10
11
12
13
import  paramiko
private_key  =  paramiko.RSAKey.from_private_key_file( '/root/.ssh/id_rsa' )
transport  =  paramiko.Transport(( '192.168.1.21' ,  22 ))
transport.connect(username = 'root' , pkey = private_key)
ssh  =  paramiko.SSHClient()
ssh._transport  =  transport
stdin, stdout, stderr  =  ssh.exec_command( 'df' )
transport.close()

2、SFTPClient用于连接远程服务器并执行上传下载

(1)基于用户名密码上传下载：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
import  paramiko
transport  =  paramiko.Transport(( '192.168.1.21' , 22 ))
transport.connect(username = 'root' ,password = '123456' )
sftp  =  paramiko.SFTPClient.from_transport(transport)
# 将location.py 上传至服务器 /tmp/test.py
sftp.put( '/tmp/location.py' ,  '/tmp/test.py' )
# 将remove_path 下载到本地 local_path
sftp.get( 'remove_path' ,  'local_path' )
transport.close()

(2)基于公钥密钥上传下载：　　

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
import  paramiko
private_key  =  paramiko.RSAKey.from_private_key_file( '/root/.ssh/id_rsa' )
transport  =  paramiko.Transport(( '192.168.1.21' ,  22 ))
transport.connect(username = 'root' , pkey = private_key )
sftp  =  paramiko.SFTPClient.from_transport(transport)
# 将location.py 上传至服务器 /tmp/test.py
sftp.put( '/tmp/location.py' ,  '/tmp/test.py' )
# 将remove_path 下载到本地 local_path
sftp.get( 'remove_path' ,  'local_path' )
transport.close()

3、实例：通过transport实现远程执行命令和上传文件　　

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

class SSHConnection(object):

    def __init__(self, host='172.16.103.191', port=22, username='wupeiqi',pwd='123'):
        self.host = host
        self.port = port
        self.username = username
        self.pwd = pwd
        self.__k = None

    def create_file(self):
        file_name = str(uuid.uuid4())
        with open(file_name,'w') as f:
            f.write('sb')
        return file_name

    def run(self):
        self.connect()
        self.upload('/home/wupeiqi/tttttttttttt.py')
        self.rename('/home/wupeiqi/tttttttttttt.py', '/home/wupeiqi/ooooooooo.py)
        self.close()

    def connect(self):
        transport = paramiko.Transport((self.host,self.port))
        transport.connect(username=self.username,password=self.pwd)
        self.__transport = transport

    def close(self):

        self.__transport.close()

    def upload(self,target_path):
        # 连接，上传
        file_name = self.create_file()

        sftp = paramiko.SFTPClient.from_transport(self.__transport)
        # 将location.py 上传至服务器 /tmp/test.py
        sftp.put(file_name, target_path)

    def rename(self, old_path, new_path):

        ssh = paramiko.SSHClient()
        ssh._transport = self.__transport
        # 执行命令
        cmd = "mv %s %s" % (old_path, new_path,)
        stdin, stdout, stderr = ssh.exec_command(cmd)
        # 获取命令结果
        result = stdout.read()

    def cmd(self, command):
        ssh = paramiko.SSHClient()
        ssh._transport = self.__transport
        # 执行命令
        stdin, stdout, stderr = ssh.exec_command(command)
        # 获取命令结果
        result = stdout.read()
        return result
        


ha = SSHConnection()
ha.run()
1
2
3
4
5
6
# 对于更多限制命令，需要在系统中设置
/ etc / sudoers
Defaults    requiretty
Defaults:cmdb    !requiretty
  Demo

堡垒机

堡垒机执行流程：

  1. 管理员为用户在服务器上创建账号(将公钥放置服务器，或者使用用户名密码)
  2. 用户登陆堡垒机，输入堡垒机用户名密码，现实当前用户管理的服务器列表
  3. 用户选择服务器，并自动登陆
  4. 执行操作并同时将用户操作记录

注：配置.brashrc实现ssh登陆后自动执行脚本，如：/usr/bin/python /home/wupeiqi/menu.py

实现过程(前戏)

# 利用sys.stdin,肆意妄为执行操作
# 用户在终端输入内容，并将内容发送至远程服务器
# 远程服务器执行命令，并将结果返回
# 用户终端显示内容

版本一：能连上远程服务器在终端任意输入命令，但无法做到tab键补全命令

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

版本二：在版本一上增加了命令补全功能和命令记录　

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

版本三：windows、linux通用版本

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
import  paramiko
import  sys
import  os
import  socket
import  getpass
from  paramiko.py3compat  import  u
# windows does not have termios...
try :
     import  termios
     import  tty
     has_termios  =  True
except  ImportError:
     has_termios  =  False
def  interactive_shell(chan):
     if  has_termios:
         posix_shell(chan)
     else :
         windows_shell(chan)
def  posix_shell(chan):
     import  select
     oldtty  =  termios.tcgetattr(sys.stdin)
     try :
         tty.setraw(sys.stdin.fileno())
         tty.setcbreak(sys.stdin.fileno())
         chan.settimeout( 0.0 )
         log  =  open ( 'handle.log' ,  'a+' , encoding = 'utf-8' )
         flag  =  False
         temp_list  =  []
         while  True :
             r, w, e  =  select.select([chan, sys.stdin], [], [])
             if  chan  in  r:
                 try :
                     x  =  u(chan.recv( 1024 ))
                     if  len (x)  = =  0 :
                         sys.stdout.write( '\r\n*** EOF\r\n' )
                         break
                     if  flag:
                         if  x.startswith( '\r\n' ):
                             pass
                         else :
                             temp_list.append(x)
                         flag  =  False
                     sys.stdout.write(x)
                     sys.stdout.flush()
                 except  socket.timeout:
                     pass
             if  sys.stdin  in  r:
                 x  =  sys.stdin.read( 1 )
                 import  json
                 if  len (x)  = =  0 :
                     break
                 if  x  = =  '\t' :
                     flag  =  True
                 else :
                     temp_list.append(x)
                 if  x  = =  '\r' :
                     log.write(''.join(temp_list))
                     log.flush()
                     temp_list.clear()
                 chan.send(x)
     finally :
         termios.tcsetattr(sys.stdin, termios.TCSADRAIN, oldtty)
def  windows_shell(chan):
     import  threading
     sys.stdout.write( "Line-buffered terminal emulation. Press F6 or ^Z to send EOF.\r\n\r\n" )
     def  writeall(sock):
         while  True :
             data  =  sock.recv( 256 )
             if  not  data:
                 sys.stdout.write( '\r\n*** EOF ***\r\n\r\n' )
                 sys.stdout.flush()
                 break
             sys.stdout.write(data)
             sys.stdout.flush()
     writer  =  threading.Thread(target = writeall, args = (chan,))
     writer.start()
     try :
         while  True :
             d  =  sys.stdin.read( 1 )
             if  not  d:
                 break
             chan.send(d)
     except  EOFError:
         # user hit ^Z or F6
         pass
def  run():
     default_username  =  getpass.getuser()
     username  =  input ( 'Username [%s]: '  %  default_username)
     if  len (username)  = =  0 :
         username  =  default_username
     hostname  =  input ( 'Hostname: ' )
     if  len (hostname)  = =  0 :
         print ( '*** Hostname required.' )
         sys.exit( 1 )
     tran  =  paramiko.Transport((hostname,  22 ,))
     tran.start_client()
     default_auth  =  "p"
     auth  =  input ( 'Auth by (p)assword or (r)sa key[%s] '  %  default_auth)
     if  len (auth)  = =  0 :
         auth  =  default_auth
     if  auth  = =  'r' :
         default_path  =  os.path.join(os.environ[ 'HOME' ],  '.ssh' ,  'id_rsa' )
         path  =  input ( 'RSA key [%s]: '  %  default_path)
         if  len (path)  = =  0 :
             path  =  default_path
         try :
             key  =  paramiko.RSAKey.from_private_key_file(path)
         except  paramiko.PasswordRequiredException:
             password  =  getpass.getpass( 'RSA key password: ' )
             key  =  paramiko.RSAKey.from_private_key_file(path, password)
         tran.auth_publickey(username, key)
     else :
         pw  =  getpass.getpass( 'Password for %s@%s: '  %  (username, hostname))
         tran.auth_password(username, pw)
     # 打开一个通道
     chan  =  tran.open_session()
     # 获取一个终端
     chan.get_pty()
     # 激活器
     chan.invoke_shell()
     interactive_shell(chan)
     chan.close()
     tran.close()
if  __name__  = =  '__main__' :
     run()

更多参见：paramoko源码 https://github.com/paramiko/paramiko 

Alex堡垒机：http://www.cnblogs.com/alex3714/articles/5286889.html 

୧⍤⃝py化功大法
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
linux-运维自动化之ansible
m0_71514530的博客
09-12 321
YAML是一个可读性高的用来表达资料序列的格式。YAML参考了其他多种语言，包括：XML、C语言、Python、Perl以及电子邮件格式RFC2822等。Clark Evans在2001年在首次发表了这种语言，另外Ingy döt Net与Oren Ben-Kiki也是这语言的共同设计者YAML Ain't Markup Language，即YAML不是XML。不过，在开发的这种语言时，YAML的意思其实是："Yet Another Markup Language"（仍是一种标记语言）特性。
Python-基于Redis与Paramiko的系统监控运维程序
08-10
基于Redis与Paramiko的系统监控运维程序
Python自动化运维之19、Paramiko模块和堡垒机实战
weixin_34226706的博客
08-31 144
paramiko模块 　　paramiko是一个用于做远程控制的模块，使用该模块可以对远程服务器进行命令或文件操作，值得一说的是，fabric和ansible内部的远程管理就是使用的paramiko来现实。其实它的底层是对ssh的上层代码的一个封装 一、下载安装 #pycrypto，由于 paramiko 模块内部依赖pycrypto，所以先下载安装pycrypto tomcat@no...
python画城堡_Python 13 简单项目-堡垒机
weixin_39573981的博客
12-04 130
本节内容项目实战：运维堡垒机开发前景介绍到目前为止，很多公司对堡垒机依然不太感冒，其实是没有充分认识到堡垒机在IT管理中的重要作用的，很多人觉得，堡垒机就是跳板机，其实这个认识是不全面的，跳板功能只是堡垒机所具备的功能属性中的其中一项而已，下面我就给大家介绍一下堡垒机的重要性，以帮助大家参考自己公司的业务是否需要部署堡垒机。堡垒机有以下两个至关重要的功能：权限管理当你公司的服务器变的越来越多后，需...
Python 13 简单项目-堡垒机
weixin_30544657的博客
11-19 80
本节内容 项目实战：运维堡垒机开发 前景介绍 到目前为止，很多公司对堡垒机依然不太感冒，其实是没有充分认识到堡垒机在IT管理中的重要作用的，很多人觉得，堡垒机就是跳板机，其实这个认识是不全面的，跳板功能只是堡垒机所具备的功能属性中的其中一项而已，下面我就给大家介绍一下堡垒机的重要性，以帮助大家参考自己公司的业务是否需要部署堡垒机。 堡垒机有以下两个至关重要的功能： 权限管理 ...
Python之路,Day13 - 堡垒机
weixin_30718391的博客
11-03 74
项目实战：运维堡垒机开发 前景介绍 到目前为止，很多公司对堡垒机依然不太感冒，其实是没有充分认识到堡垒机在IT管理中的重要作用的，很多人觉得，堡垒机就是跳板机，其实这个认识是不全面的，跳板功能只是堡垒机所具备的功能属性中的其中一项而已，下面我就给大家介绍一下堡垒机的重要性，以帮助大家参考自己公司的业务是否需要部署堡垒机。 堡垒机有以下两个至关重要的功能： 权限管理 当你公司的服务器...
IronFort---基于Django2.0和Websocket的堡垒机
weixin_30750335的博客
01-30 485
原创内容，转载需在顶部明显位置注明来源及作者！侵权必究！ 该实战项目已经录制视频教程，并与网易云课堂合作，直达链接 WebSSH有很多，基于Django的Web服务也有很多，使用Paramiko在Python中进行SSH访问的就更多了。但是通过gevent将三者结合起来，实现通过浏览器访问的堡垒机就很少见了。本文将简要介绍下我开发的IronFort堡垒机，其详细内容在http://study.1...
OLDboy-python第八期运维教程
fefeiduomeizi的博客
06-15 451
从0基础开始讲解Python语法、流程控制、函数式编程、面向对象开发等最重要的PYTHON开发必备基础知识课程目录：L01-Python8期VIP视频-Day101-开课介绍02-学生介绍03-课程内容介绍04-Python的发展05-Python特性介绍及与其它语言对比06-Python安装及环境准备07-编程风格要求08-Python的数据类型和运算符09-单行和多行注释10-理解ASSIC ...
021-python基础-python介绍及课程简介
weixin_30455365的博客
02-14 231
一、PYTHON擅长的领域 WEB开发 Django\pyramid\Tornado\Bottle\Flask\WebPy 网络编程 　　Twisted\Requests\Scrapy\Paramiko 科学运算 　　SciPY\Pandas\Ipython GUI图形开发 　　wxPython\PyQT\Kivy 运维自动化 　　OpenStack\SaltS...
python网络运维案例代码库_OLDboy-python第八期运维教程
weixin_39614521的博客
01-14 148
课程目录：L01-Python8期VIP视频-Day101-开课介绍02-学生介绍03-课程内容介绍04-Python的发展05-Python特性介绍及与其它语言对比06-Python安装及环境准备07-编程风格要求08-Python的数据类型和运算符09-单行和多行注释10-理解ASSIC Unicode UTF-8编码11-使用和导入模块12-用户交互和格式化输出13-流程控制if for循环...
python-paramiko-2.1.1-9.el7.noarch.rpm
12-13
官方离线安装包，亲测可用。使用rpm -ivh [rpm完整包名] 进行安装
python 中的paramiko模块简介及安装过程
09-17
主要介绍了python 中的paramiko模块简介及安装过程，通过实例详解给大家介绍的非常详细，具有一定的参考借鉴价值，需要的朋友参考下吧
python-paramiko-2.1.1-3.el7.noarch.rpm
12-13
官方离线安装包，亲测可用。使用rpm -ivh [rpm完整包名] 进行安装
windows下python安装paramiko模块和pycrypto模块（简单三步）
09-21
主要给大家介绍了通过简单的三个步骤在windows下python中安装paramiko模块和pycrypto模块的相关资料，文中安装的步骤，简单而且又易于大家理解，需要的朋友们下面跟着小编一起来学习学习吧。
GLM+vLLM 部署调用
qq_38915354的博客
06-13 1155
vLLM 框架是一个高效的大型语言模型（LLM）推理和部署服务系统
找出Python潜在的编程问题
svygh123的专栏
06-13 1064
Pylint 是一个非常强大的静态代码分析工具，主要用于检查 Python 代码的语法错误、代码风格问题以及潜在的编程错误。它是 Open Source Initiative 认证的开源软件，由 Logilab 团队开发维护。
第9章 类
最新发布
我走的每一步都算数
06-17 720
让一个类继承另一个类后，就可以添加区分子类和父类所需的新属性和新方法了。class Car:class ElectricCar(Car): # 继承Carself.battery = 85 # 新属性mycar = ElectricCar(2024, 'Au', 'A7') # 创建实例mycar.prt_battery() # 新方法熟悉Python 提供的选项，这样才能确定哪种组织方式是最佳的，并能理解别人开发的项目。
python迁移数据教程
2402_85292291的博客
06-13 698
if os.path.isfile(src_item_path): dest_item_path = os.path.join(dest_folder, item) shutil.copy2(src_item_path, dest_item_path) # 如果item是目录，递归调用migrate_data函数。2. 准备源文件夹和目标文件夹： 在您的计算机上创建两个文件夹，分别为源文件夹（source_folder）和目标文件夹（destination_folder）。将您希望迁移的数据放入源文件夹。
python paramiko模块安装
02-07
Python Paramiko模块是一个用于SSH（Secure Shell）协议的Python实现，它提供了一个简单而强大的接口，用于在远程服务器上执行命令、传输文件等操作。要安装Paramiko模块，可以按照以下步骤进行： 1. 确保你已经...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值