1、下载安装 pycrypto-2.6.1.tar.gz　　（apt-get install python-dev）

　　　　解压，进入，python setup.py build【编译】，python setup.py install 【安装】  ----》import Crypto

　　2、下载安装 paramiko-1.10.1.tar.gz　　

　　　　解压，进入，python setup.py build【编译】，python setup.py install 【安装】---》  import paramiko

1、连接远程服务器，并执行操作
用户名和密码连接1

  1. import paramiko
  2. ssh = paramiko.SSHClient()
  3. ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())
  4. ssh.connect('10.10.50.30', 22, 'root', '123456')
  5. stdin, stdout, stderr = ssh.exec_command('ifconfig')
  6. print stdout.read()
  7. ssh.close();
  1. 用户名和密码连接2  （SSHClient 封装 Transport）推荐
  1. transport = paramiko.Transport(('10.10.50.30', 22))
  2. transport.connect(username='root', password='jichuang')
  3. ssh = paramiko.SSHClient()
  4. ssh._transport = transport
  5. stdin, stdout, stderr = ssh.exec_command('ifconfig')
  6. print stdout.read()
  7. transport.close()
  1.  

公钥私钥链接
ssh-keygen -t rsa
ssh-copy-id -i .ssh/id_rsa.pub "-p 22 root@10.10.50.30"

  1. import paramiko
  2. private_key_path = '/root/.ssh/id_rsa' #本机私钥存放位置
  3. key = paramiko.RSAKey.from_private_key_file(private_key_path)
  4. ssh = paramiko.SSHClient()
  5. ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())
  6. ssh.connect('10.10.50.31 ', 22, 'root' ,pkey=key)
  7. stdin, stdout, stderr = ssh.exec_command('df')
  8. print stdout.read()
  9. ssh.close();

　　

公钥私钥链接2 （SSHClient 封装 Transport）推荐

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

　　

  1. 2、SFTP上传下载
  1. 基于用户名和密码
  1. import os,sys
  2. import paramiko
  3. t = paramiko.Transport(('10.10.50.30',22))
  4. t.connect(username='yangmv',password='123456')
  5. sftp = paramiko.SFTPClient.from_transport(t)
  6. sftp.put('C:\Users\yangmingwei\Desktop\error.jpg','/home/yangmv/error.jpg')
  7. #将error.jpg上传到服务器/home/yangmv目录
  8. sftp.get('/home/yangmv/sftp.txt','C:\Users\yangmingwei\Desktop\sftp.txt')
  9. #将sftp.txt下载到本机桌面
  10. t.close()

　　

  1. 基于公钥秘钥上传下载
  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='yangmv', pkey=private_key )
  7.  
  8. sftp = paramiko.SFTPClient.from_transport(transport)
  9. # 将location.py 上传至服务器 /tmp/test.py
  10. sftp.put('/tmp/location.py', '/tmp/test.py')
  11. # 将remove_path 下载到本地 local_path
  12. sftp.get('remove_path', 'local_path')
  13.  
  14. transport.close()

　　

 
 
Paramiko 批量执行命令
版本一：

缺点： 每次执行一个操作，就要进行一次连接

  1. import paramiko
  2. import uuid
  3. class Comm(object):
  4.     def __init__(self):     #初始化参数
  5. self.host = '10.10.50.30'
  6. self.port = 22
  7. self.username = 'root'
  8. self.pwd = '123456'
  9. self.file_name = ''
  10.  
  11. def create_file(self):  #本地创建文件
  12. file_name = str(uuid.uuid4())   #uuid创建一个不会重复的随机字符串作为文件名
  13. with open(file_name,'w') as f_obj:
  14.             f_obj.write('sb')
  15.         return file_name    #返回文件名
  16. def run(self):
  17.         self.upload()       #执行上传
  18. self.rename()       #执行重命名
  19.  
  20. def upload(self):       #用于上传
  21. self.file_name = self.create_file()
  22.         t = paramiko.Transport((self.host,self.port))
  23.         t.connect(username=self.username,password=self.pwd)
  24.         sftp = paramiko.SFTPClient.from_transport(t)
  25.         sftp.put(self.file_name,'/home/yangmv/%s'%self.file_name)
  26.         t.close()
  27.     def rename(self):       #用于重命名
  28. ssh = paramiko.SSHClient()
  29.         ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())
  30.         ssh.connect(self.host, self.port, self.username, self.pwd)
  31.         stdin, stdout, stderr = ssh.exec_command('mv /home/yangmv/%s /home/yangmv/xxxx.txt'%(self.file_name))
  32.         print stdout.read()
  33.         ssh.close();
  34. startcmd = Comm()
  35. startcmd.run()

　　

版本二：（推荐）
优点：不管执行多少个操作，都只连接一次
  1. import paramiko
  2. import uuid
  3. class Comm(object):
  4.     def __init__(self):     #初始化参数
  5. self.host = '10.10.50.30'
  6. self.port = 22
  7. self.username = 'root'
  8. self.pwd = '123456'
  9.  
  10. def create_file(self):  #本地创建文件
  11. file_name = str(uuid.uuid4())   #uuid创建一个不会重复的随机字符串作为文件名
  12. with open(file_name,'w') as f_obj:
  13.             f_obj.write('sb2')
  14.         return file_name    #返回文件名
  15. def run(self):
  16.         self.connect()
  17.         self.upload()       #执行上传
  18. self.rename()       #执行重命名
  19. self.close()
  20.  
  21.     def connect(self):        #用于ssh连接
  22. t = paramiko.Transport((self.host,self.port))
  23.         t.connect(username=self.username,password=self.pwd)
  24.         self.__transport = t
  25.     def close(self):          #用于ssh关闭
  26. self.__transport.close()
  27.     def upload(self):       #用于上传
  28. self.file_name = self.create_file()
  29.         sftp = paramiko.SFTPClient.from_transport(self.__transport)
  30.         sftp.put(self.file_name,'/home/yangmv/%s'%self.file_name)
  31.     def rename(self):       #用于重命名
  32. ssh = paramiko.SSHClient()
  33.         ssh._transport = self.__transport
  34.         stdin, stdout, stderr = ssh.exec_command('mv /home/yangmv/%s /home/yangmv/ssss.txt'%self.file_name)
  35.         result = stdout.read()
  36. startcmd = Comm()
  37. startcmd.run()

　　

 
Paramiko持续连接服务器1 select
  1. import paramiko
  2. import select   #无法在windows下操作
  3. import sys
  4. t = paramiko.Transport(('10.10.50.31', 22))
  5. t.start_client()
  6. #基于公钥验证
  7. ##default_path = os.path.join(os.environ['HOME'], '.ssh', 'id_rsa')
  8. #key = paramiko.RSAKey.from_private_key_file('/root/.ssh/id_rsa')
  9. #t.auth_publickey('root',key)
  10. #基于用户密码验证
  11. t.auth_password('root', '123456')
  12.  
  13. #打开一个通道
  14. chan = t.open_session()
  15. #获取一个终端
  16. chan.get_pty()
  17. #激活器
  18. chan.invoke_shell()
  19.  
  20. #########
  21. # 利用sys.stdin,肆意妄为执行操作
  22. # 用户在终端输入内容，并将内容发送至远程服务器
  23. # 远程服务器执行命令，并将结果返回
  24. # 用户终端显示内容
  25. while True:
  26.     # 监视用户输入和服务器返回数据
  27. # sys.stdin 处理用户输入
  28. # chan 是之前创建的通道，用于接收服务器返回信息
  29. r_list,w_list,error = select.select([chan,sys.stdin,],[],[],1)
  30.     if chan in r_list:                  #接收命令执行后返回的结果
  31. try:
  32.             x = chan.recv(1024)
  33.             if len(x) == 0:
  34.                 print '\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_list:             #用户输入
  41. inp = sys.stdin.readline()
  42.         chan.sendall(inp)               #把用户输入命令发送执行
  43. #########
  44. chan.close()
  45. t.close()

　　

  1. 成功登陆机器，并可以持续连接，不断输入命令，并到达返回结果

 
Paramiko持续连接服务器2 改进
1的缺点：

    输入端，以行为单位，敲回车后才执行命令     ( ls + 回车 → 发送远端）
    无法使用tab补全
2的改进：
    改变默认终端，由 行stdin， 一个字符stdin    ( l  → 发送远端，s → 发送远端  ) 
    每输入一次，向远端发送一次 
    无法使用tab补全
  1. import paramiko
  2. import select   #无法在windows下操作
  3. import sys
  4. import termios
  5. import tty
  6.  
  7. t = paramiko.Transport(('10.10.50.31', 22))
  8. t.start_client()
  9. #基于公钥验证
  10. ##default_path = os.path.join(os.environ['HOME'], '.ssh', 'id_rsa')
  11. #key = paramiko.RSAKey.from_private_key_file('/root/.ssh/id_rsa')
  12. #t.auth_publickey('root',key)
  13. #基于用户密码验证
  14. t.auth_password('root', '123456')
  15.  
  16. #打开一个通道
  17. chan = t.open_session()
  18. #获取一个终端
  19. chan.get_pty()
  20. #激活器
  21. chan.invoke_shell()
  22.  
  23. #########
  24. #获取原tty属性
  25. oldtty = termios.tcgetattr(sys.stdin)
  26. try:
  27.     # 为tty设置新属性
  28. # 默认当前tty设备属性：
  29. # 输入一行回车，执行
  30. # CTRL+C 进程退出，遇到特殊字符，特殊处理。
  31. # 这是为原始模式，不认识所有特殊符号
  32. # 放置特殊字符应用在当前终端，如此设置，将所有的用户输入均发送到远程服务器
  33. tty.setraw(sys.stdin.fileno())
  34.     chan.settimeout(0.0)
  35.     while True:
  36.         #监视用户输入和远程服务器的返回数据socket
  37.         #阻塞，直到句柄可用
  38. r_list,w_list,error = select.select([chan,sys.stdin,],[],[],1)
  39.         if chan in r_list:
  40.             try:
  41.                 x = chan.recv(1024)
  42.                 if len(x) == 0:
  43.                     print '\r\n*** EOF\r\n',
  44. break
  45. sys.stdout.write(x)
  46.                 sys.stdout.flush()
  47.             except socket.timeout:
  48.                 pass
  49.         if sys.stdin in r_list:
  50.             inp = sys.stdin.read(1)     #每次读1个字符
  51. if len(inp) == 0:
  52.                 break
  53. chan.sendall(inp)
  54. finally:
  55.     #退出后恢复终端属性
  56. termios.tcsetattr(sys.stdin,termios.TCSADRAIN,oldtty)
  57.  
  58. #########
  59. chan.close()
  60. t.close()

　　

  1.  
 
Paramiko持续连接服务器3  记录操作日志
  1. import paramiko
  2. import select   #无法在windows下操作
  3. import sys
  4. import termios
  5. import tty
  6.  
  7. t = paramiko.Transport(('10.10.50.31', 22))
  8. t.start_client()
  9. t.auth_password('root', '123456')
  10.  
  11. chan = t.open_session()
  12. chan.get_pty()
  13. chan.invoke_shell()
  14.  
  15. #########
  16. oldtty = termios.tcgetattr(sys.stdin)
  17. try:
  18.     tty.setraw(sys.stdin.fileno())
  19.     chan.settimeout(0.0)
  20.     f  = open('record.log','a')
  21.     records = []
  22.     while True:
  23.         r_list,w_list,error = select.select([chan,sys.stdin,],[],[],1)
  24.         if chan in r_list:
  25.             try:
  26.                 x = chan.recv(1024)
  27.                 if len(x) == 0:
  28.                     print '\r\n*** EOF\r\n',
  29. f.close()   #异常中断，或者exit退出时保存
  30. break
  31. sys.stdout.write(x)
  32.                 sys.stdout.flush()
  33.             except socket.timeout:
  34.                 pass
  35.         if sys.stdin in r_list:
  36.             inp = sys.stdin.read(1)
  37.             records.append(inp)  #把个字符键入列表暂时保存 ['l','s']
  38. if len(inp) == 0:
  39.                 break
  40.             if inp == '\t':     #tab键不记录
  41. pass
  42.             if inp == '\r':     #每次回车
  43. cmd = ''.join(records).replace('\r','\n') #[ls]+换行
  44. f.write(cmd)
  45.                 records = []    #每次记录一个条命令
  46. chan.sendall(inp)
  47. finally:
  48.     termios.tcsetattr(sys.stdin,termios.TCSADRAIN,oldtty)
  49. #########
  50. chan.close()
  51. t.close()

　　

  1. 成功记录

 
Paramiko持续连接服务器4 适用windows
  1. import paramiko
  2. import sys
  3. import threading
  4.  
  5. t = paramiko.Transport(('10.10.50.31', 22))
  6. t.start_client()
  7. t.auth_password('root', '123456')
  8.  
  9. chan = t.open_session()
  10. chan.get_pty()
  11. chan.invoke_shell()
  12.  
  13. #########
  14. sys.stdout.write("Line-buffered terminal emulation. Press F6 or ^Z to send EOF.\r\n\r\n")
  15. def writeall(sock):
  16.     while True:
  17.         data = sock.recv(256)
  18.         if not data:
  19.             sys.stdout.write('\r\n*** EOF ***\r\n\r\n')
  20.             sys.stdout.flush()
  21.             break
  22. sys.stdout.write(data)
  23.         sys.stdout.flush()
  24.  
  25. writer = threading.Thread(target=writeall, args=(chan,))
  26. writer.start()
  27.  
  28. try:
  29.     while True:
  30.         d = sys.stdin.read(1)
  31.         if not d:
  32.             break
  33. chan.send(d)
  34. except EOFError:
  35.     # user hit ^Z or F6
  36. pass
  37. #########
  38. chan.close()
  39. t.close()

　　

 
 
 
 

Paramiko使用的更多相关文章

  1. paramiko 的使用

    paramiko模块,该模块机遇SSH用于连接远程服务器并执行相关操作 SSHClient 用于远程连接机器执行基本命令,也可以执行shell脚本 基于用户名密码连接: def ssh_connect ...

  2. python+paramiko库+svn写的自动化部署脚本

    第一篇博文 直接开门见山的说了. 这是件什么事?:每次部署都是复制本地的文件粘贴到服务器端,因为路径复杂,所以费时且手工容易出漏洞. 一直在想有什么办法可以解决这种,因为以前在微软的一个牛人同事做过一 ...

  3. 离线安装 Python 2.7, paramiko 和 tornado

    无非就是离线安装, 步骤比较繁琐, 记录一下. 需求很简单, 一个离线安装的 Python, 能跑 tornado 和 paramiko 1. 离线安装 Python 2.7 .tgz cd Pyth ...

  4. CentOS 安装Paramiko模块

    转自:http://www.cnblogs.com/hyli/p/3910585.html 1.下载安装包: https://pypi.python.org/packages/source/p/par ...

  5. paramiko模块的安装

    1.找到自己python安装的目录(默认路径:C:\Users\zhangliyuan\AppData\Local\Programs\Python\Python35) 注:cmd中所有命令 2.进入S ...

  6. 使用paramiko如何连接服务器？

    本文和大家分享的是python开发中使用paramiko连接服务器的方法和步骤,希望通过本文的,对大家学习和使用paramiko有所帮助. ssh连接步骤 1.ssh server建立server p ...

  7. python paramiko 进行文件上传处理

    #!/usr/bin/env python # -*- coding:utf-8 -*- import paramiko import uuid class Ha(object): def __ini ...

  8. python远程连接paramiko 模块和堡垒机实现

    paramiko使用 paramiko模块是基于python实现了SSH2远程安全连接,支持认证和密钥方式,可以实现远程连接.命令执行.文件传输.中间SSH代理功能 安装 pip install pa ...

  9. 利用paramiko模块实现堡垒机+审计功能

    paramiko模块是一个远程连接服务器,全真模拟ssh2协议的python模块,借助paramiko源码包中的demos目录下:demo.py和interactive.py两个模块实现简单的堡垒机+ ...

  10. python之实现基于paramiko和mysql数据库的堡垒机

    一.堡垒机结构 堡垒机执行流程: 管理员为用户在服务器上创建账号(将公钥放置服务器,或者使用用户名密码) 用户登陆堡垒机,输入堡垒机用户名密码,现实当前用户管理的服务器列表 用户选择服务器,并自动登陆 ...

随机推荐

  1. 模板CodeTemplate

    /** * @author:dubbo@xxxx.com * @date: ${date} ${time} * @version: V1.0 * @review: dubbo/${date} ${ti ...

  2. BurpSuite 激活破解

    1.下载软件关于Burp Suite, 它是进行Web应用安全测试的一个集成平台,无缝融合各种安全工具并提供全面的接口适配,支持完整的Web应用测试流程,从最初的映射和应用程序的攻击面分析到发现和利用 ...

  3. 使用fabric1.14.0和fabric2.4.0

    fabric1.14.0(支持Python2.5-2.7版本): from  fabric.api import * env.gateway = '192.168.181.2'            ...

  4. Tomcat安装及配置详解

    Tomcat安装及配置详解   一,Tomcat简介 Tomcat 服务器是一个免费的开放源代码的Web 应用服务器,Tomcat是Apache 软件基金会(Apache Software Found ...

  5. iOS 关于MVC和MVVM设计模式的那些事

    一.概述 在 iOS 开发中,MVC(Model View Controller)是构建iOS App的标准模式,是苹果推荐的一个用来组织代码的权威范式.Apple甚至是这么说的.在MVC下,所有的对 ...

  6. python获取toast 验证

    appium版本 1.6.3  desired_caps['automationName']='uiautomator2'    def _find_toast(self,message,timeou ...

  7. DateTime Toxxx() 方法获取时间

    直接上代码 static void Main(string[] args) { DateTime time = DateTime.Now; Console.WriteLine("ToFile ...

  8. ZOJ1827_The Game of 31

    这是一个比较经典的博弈题目,今年网赛好像是南京赛上有一个类似的题目. 这种题目是没有一定公式或者函数的,需要自己dp或者搜索解决. 题意为分别给你4张写有1,2,3,4,5,6的卡片共24张,每次轮流 ...

  9. BZOJ4892 Tjoi2017dna（后缀数组）

    对每个子串暴力匹配至失配三次即可.可以用SA查lcp.然而在bzoj上被卡常了.当然也可以二分+哈希或者SAM甚至FFT. #include<iostream> #include<c ...

  10. 解题：JLOI 2016 侦查守卫

    题面 经典的$cov-unc$树形dp(这词是你自己造的吧=.=) 设$cov[i][j]$表示覆盖完$i$的子树后至少向外再覆盖$j$层的最小代价,$unc[i][j]$表示$i$的子树中还剩下至少 ...