paramiko_paramiko 提高速度 - CSDN
精华内容
参与话题
  • python中paramiko模块祥解

    千次阅读 2018-09-13 13:04:06
    paramiko模块 paramiko是一个用于做远程控制的模块,使用该模块可以对远程服务器进行命令或文件操作,基于linux中的ssh服务 paramiko属于第三方模块,需要安装导入 pip install paramiko 1) 远程密码连接 ...

    一 paramiko模块
    paramiko是一个用于做远程控制的模块,使用该模块可以对远程服务器进行命令或文件操作,基于linux中的ssh服务
    paramiko属于第三方模块,需要安装导入

    pip install paramiko

    1) 远程密码连接

    import paramiko
    #创建一个ssh对象
    client=paramiko.SSHClient()
    #如果之前没有连接过的ip,会出现 Are you sure you want to continue connecting (yes/no)? yes
    #自动选择yes
    client.set_missing_host_key_policy(paramiko.AutoAddPolicy())
    #连接服务器
    client.connect(hostname='172.25.254.169',
                   port=22,
                   username='root',
                   password='redhat')
    #执行操作
    stdin,stdout,stderr=client.exec_command('hostname')  #exec_command返回的为一个元组
    #获取命令的执行结果
    # result=stdout.read() 为2进制的对象,因此
    result=stdout.read().decode('utf-8')  #decode('utf-8') 对2进制的对象进行转换
    print(result)
    #关闭连接
    client.close()

    这里写图片描述
    2) 批量远程密码连接

    def conn(cmd,host,port=22,user='root',passwd='westos'):
        #基于ssh命令用于连接远程服务器作操作:远程执行命令 上传 下载
        import paramiko
        #创建一个ssh对象
        client=paramiko.SSHClient()
        #如果之前没有连接过的ip,会出现 Are you sure you want to continue connecting (yes/no)? yes
        #自动选择yes
        client.set_missing_host_key_policy(paramiko.AutoAddPolicy())
        try:
            #连接服务器
            client.connect(hostname=host,
                           port=port,
                           username=user,
                           password=passwd)
        except :
            print('连接%s\tip失败'%(host))
        else:
            print('连接%s\tip成功'%(host))
            #执行操作
            stdin,stdout,stderr=client.exec_command(cmd)  #exec_command返回的为一个元组
            #获取命令的执行结果
            # result=stdout.read() 为2进制的对象,因此
            result=stdout.read().decode('utf-8')  #decode('utf-8') 对2进制的对象进行转换
            print(result)
        finally:
            #关闭连接
            client.close()
    if __name__=='__main__':
        with open('ip.txt')as f:
            for line in f:
                line=line.strip()
                host,port,user,passwd=line.split(':')
                print(host.center(50,'*'))
                conn('hostname',host,port,user,passwd)

    这里写图片描述
    3) 基于公钥密钥的连接

    from paramiko.ssh_exception import NoValidConnectionsError
    
    
    def conn(cmd,host,port=22,user='root'):
        #基于ssh命令用于连接远程服务器作操作:远程执行命令 上传 下载
        import paramiko
        #创建一个ssh对象
        client=paramiko.SSHClient()
        #如果之前没有连接过的ip,会出现 Are you sure you want to continue connecting (yes/no)? yes
        #自动选择yes
        client.set_missing_host_key_policy(paramiko.AutoAddPolicy())
        #创建一个私钥
        private_key=paramiko.RSAKey.from_private_key_file('id_rsa.txt')
        try:
            #连接服务器
            client.connect(hostname=host,
                           port=port,
                           username=user,
                           pkey=private_key)
        except NoValidConnectionsError as e:
            print('连接%s失败'%(host))
        else:
            #执行操作
            stdin,stdout,stderr=client.exec_command(cmd)  #exec_command返回的为一个元组
            #获取命令的执行结果
            # result=stdout.read() 为2进制的对象,因此
            result=stdout.read().decode('utf-8')  #decode('utf-8') 对2进制的对象进行转换
            print(result)
        finally:
            #关闭连接
            client.close()
    
    host='172.25.254.169'
    print(host.center(50,'*'))
    conn('uname',host)

    这里写图片描述
    4) 基于密码的上传,下载
    注意:上传,下载这里还有个默认的ftplib模块定义了FTP类

    import paramiko
    transport=paramiko.Transport('172.25.254.169',22)
    transport.connect(username='root',password='redhat')
    sftp=paramiko.SFTPClient.from_transport(transport)
    #上传,下载文件  包含文件名
    sftp.put('/mnt/passwd','/mnt/put_passwd')
    sftp.get('/mnt/put_passwd','/home/kiosk/Desktop/get_passwd')
    transport.close()

    上传:
    这里写图片描述
    下载:
    这里写图片描述
    5) 基于密钥的上传下载

    import  paramiko
    
    # 返回一个私钥对象
    private_key = paramiko.RSAKey.from_private_key_file('id_rsa')
    
    transport = paramiko.Transport(('172.25.254.169', 22))
    transport.connect(username='root',pkey=private_key)
    sftp = paramiko.SFTPClient.from_transport(transport)
    # 上传文件, 包含文件名
    sftp.put('/mnt/passwd','/mnt/put_passwd')
    sftp.get('/mnt/put_passwd','/home/kiosk/Desktop/get_passwd')
    transport.close()

    二 paramiko再次封装
    先选择不同的机组,再对机组里面的主机进行操作
    这里写图片描述
    不同的机组文件里面,存储着不同的主机信息

    import paramiko
    from paramiko import SSHException
    
    
    class SshRemoteHost(object):
        def __init__(self, hostname, port, user, passwd, cmd):
            self.hostname = hostname
            self.port = port
            self.user = user
            self.passwd = passwd
            self.cmd = cmd
    
        def run(self):
            """默认调用的内容"""
            # cmd hostname
            cmd_str = self.cmd.split()[0]  # cmd
            if hasattr(self, 'do_' + cmd_str):  # do_cmd
                getattr(self, 'do_' + cmd_str)()
            else:
                print('不支持此命令...')
    
        def do_cmd(self):
            """执行指定的命令"""
            # 创建一个ssh对象
            client = paramiko.SSHClient()
            # 如果之前没有连接过的ip,会出现 Are you sure you want to continue connecting (yes/no)? yes
            # 自动选择yes
            client.set_missing_host_key_policy(paramiko.AutoAddPolicy())
            try:
                # 连接服务器
                client.connect(hostname=self.hostname,
                               port=self.port,
                               username=self.user,
                               password=self.passwd)
            except:
                print('连接%s\tip失败' % (self.hostname))
            else:
                print('连接%s\tip成功' % (self.hostname))
                # 执行操作
                cmd = ''.join(self.cmd.split()[1:])
                stdin, stdout, stderr = client.exec_command(cmd)  # exec_command返回的为一个元组
                # 获取命令的执行结果
                # result=stdout.read() 为2进制的对象,因此
                result = stdout.read().decode('utf-8')  # decode('utf-8') 对2进制的对象进行转换
                print(result)
            finally:
                # 关闭连接
                client.close()
    
        def do_put(self):
            print('正在上传...')
            try:
                transport = paramiko.Transport(self.hostname, int(self.port))
                transport.connect(username=self.user, password=self.passwd)
            except SSHException as e:
                print('%s主机连接失败...'%(self.hostname))
            else:
                sftp = paramiko.SFTPClient.from_transport(transport)
                newCmd = self.cmd.split()[1:]
                if len(newCmd) == 2:
                    sftp.put(newCmd[0], newCmd[1])
                    print('%s文件上传到%s主机的%s文件成功!' % (newCmd[0], self.hostname, newCmd[1]))
                else:
                    print('上传文件信息错误')
                transport.close()
    
        def do_get(self):
            print('正在下载...')
            try:
                transport = paramiko.Transport(self.hostname, int(self.port))
                transport.connect(username=self.user, password=self.passwd)
            except SSHException as e:
                print('连接失败...')
            else:
                sftp = paramiko.SFTPClient.from_transport(transport)
                newCmd = self.cmd.split()[1:]
                if len(newCmd) == 2:
                    sftp.put(newCmd[0], newCmd[1])
                    print('从%s主机下载的%s文件到本主机的%s文件成功!' % (self.hostname, newCmd[0], newCmd[1]))
                else:
                    print('下载文件信息错误')
                transport.close()
                # 1)选择操作的主机组:web,mysql,ftp
                # 主机信息的存储:将不同的主机信息存放到不同的文件中
                # 2)根据选择的主机组,显示包含的主机IP/主机名
                # 3)让用户确认信息,选择需要批量执行的命令:
                # cmd shell命令
                # put 命令
                # get 命令
    
    
    import os
    def main():
        # 1)选择操作的主机组:web,mysql,ftp
        groups = [file.rstrip('.conf') for file in os.listdir('conf')]
        print('主机组显示:'.center(50, '*'))
        for group in groups: print('\t', group)
        choiceGroup = input('请选择批量操作的主机组: ')
        # 2)根据选择的主机组,显示包含的主机IP/主机名
        # 打开文件/home/kiosk/PycharmProjects/python/conf
        # 依次读取文件每一行
        # 拿出IP
        print('主机组包含的主机: '.center(50, '*'))
        with open('conf/%s.conf' % (choiceGroup))as f:
            for line in f:
                print(line.split(':')[0])
            f.seek(0, 0)
            hostinfos = [line.strip() for line in f.readlines()]
        # 3)让用户确认信息,选择需要批量执行的命令
        print('批量执行命令中...'.center(50, '*'))
        while True:
            cmd = input('>>:').strip()  # cmd uname
            if cmd:
                if cmd == 'exit' or cmd == 'quit':
                    print('执行结束,退出中...')
                    break
                # 依次让该主机组的所有主机执行
                for info in hostinfos:
                    host, port, user, passwd = info.split(':')
                    clientObj = SshRemoteHost(host, port, user, passwd, cmd)
                    clientObj.run()
    if __name__ == '__main__':
        main()
    

    这里写图片描述
    封装后的代码支持远程批量的命令操作,以及上传与下载

    展开全文
  • paramiko 详解

    万次阅读 2018-06-05 16:39:56
    最近在测试服务器那块,看了下Paramiko模块,一直都是用FileZilla工具,想了想,持续集成,更新代码可以用Parmmiko完成,还是不错的 Paramiko是用python语言写的一个模块,远程连接到Linux服务器,查看上面的日志...

    最近在测试服务器那块,看了下Paramiko模块,一直都是用FileZilla工具,想了想,持续集成,更新代码可以用Parmmiko完成,还是不错的

    Paramiko是用python语言写的一个模块,远程连接到Linux服务器,查看上面的日志状态,批量配置远程服务器,文件上传,文件下载等

    初始化一些参数:

    host = "120.24.239.214"
    port = 22
    timeout = 30
    user = "root"
    password = "******"
      Paramiko远程执行linux命令:
      # -*- coding:utf-8 -*-
      import paramiko
      
      def sftp_exec_command(command):
          try:
              ssh_client = paramiko.SSHClient()
              ssh_client.set_missing_host_key_policy(paramiko.AutoAddPolicy())
              ssh_client.connect(host, 22, user, password)
              std_in, std_out, std_err = ssh_client.exec_command(command)
              for line in std_out:
                  print line.strip("\n")
              ssh_client.close()
          except Exception, e:
              print e
      
      if __name__ == '__main__':
          sftp_exec_command("ls -l")
        Paramiko上传文件:
        # -*- coding:utf-8 -*-
        import paramiko
        
        def sftp_upload_file(server_path, local_path):
            try:
                t = paramiko.Transport((host, 22))
                t.connect(username=user, password=password)
                sftp = paramiko.SFTPClient.from_transport(t)
                sftp.put(local_path, server_path)
                t.close()
            except Exception, e:
                print e
        
        if __name__ == '__main__':
            sftp_upload_file("/root/bug.txt", "D:/bug.txt")

          Paramiko下载文件:

          # -*- coding:utf-8 -*-
          import paramiko
          
          def sftp_down_file(server_path, local_path):
              try:
                  t = paramiko.Transport((host, 22))
                  t.connect(username=user, password=password)
                  sftp = paramiko.SFTPClient.from_transport(t)
                  sftp.get(server_path, local_path)
                  t.close()
              except Exception, e:
                  print e
          
          if __name__ == '__main__':
              sftp_down_file("/root/test.txt", "D:/text.txt")

            Python还有个默认的ftplib模块定义了FTP类,其中函数有限,可用来实现简单的ftp客户端,用于上传或下载文件

            ftp相关命令操作:

            ftp.cwd(pathname)   #设置FTP当前操作的路径
            ftp.dir()   #显示目录下文件信息
            ftp.nlst()  #获取目录下的文件
            ftp.mkd(pathname)   #新建远程目录
            ftp.pwd()    #返回当前所在位置
            ftp.rmd(dirname)    #删除远程目录
            ftp.delete(filename)    #删除远程文件
            ftp.rename(fromname, toname)    #将fromname修改名称为toname。
            ftp.storbinaly("STOR filename.txt",file_handel,bufsize)     #上传目标文件
            ftp.retrbinary("RETR filename.txt",file_handel,bufsize)     #下载FTP文件

              一些小例子:

              # -*- coding:utf-8 -*-
              from ftplib import FTP, all_errors
              import paramiko
              import sys, os
              import getpass
              
              def ftp_main():
                  try:
                      f = FTP("ftp.ibiblio.org")
                      print f.getwelcome()
                      f.login()
                      print f.pwd()
                      f.quit()
                  except Exception, e:
                      print all_errors, e
              
              
              def ftp_down_file():
                  try:
                      f = FTP("ftp.kernel.org")
                      f.login()
                      f.cwd("/pub/linux/kernel/v1.0")
                      fd = open("patch8.gz", "wb")
                      # 以ASCII模式下载文件
                      # f.retrlines("RETE patch8.gz", writeline)
                      # 以二进制模式下载文件
                      f.retrbinary("RETE patch8.gz", fd.write)
                      fd.close()
                      f.quit()
                  except Exception, e:
                      print all_errors, e
              
              
              def ftp_up_file():
                  try:
                      host2, username, local_path, server_path = sys.argv[1:]
                      password2 = getpass.getpass("Enter passworf for %s on %s:" % (username, host2))
                      f = FTP(host2)
                      f.login(user=username, passwd=password2)
                      f.cwd(server_path)
                      fd = open(local_path, "rb")
                      f.storbinary("STOR %s" % os.path.basename(local_path), fd)
                      fd.close()
                      f.quit()
                  except Exception, e:
                      print all_errors, e

                总结:

                Parmmiko很好的完成sftp文件传输操作,可以用在SVN管理代码项目中进行持续集成开发或者测试

                原文链接:http://blog.csdn.net/Temanm/article/details/50607741


                这里还有一篇讲得更详细的,这在这里一并发过来,有助于加深理解。

                paramiko模块提供了ssh及sft进行远程登录服务器执行命令和上传下载文件的功能。这是一个第三方的软件包,使用之前需要安装。

                1 基于用户名和密码的 sshclient 方式登录

                # 建立一个sshclient对象
                ssh = paramiko.SSHClient()
                # 允许将信任的主机自动加入到host_allow 列表,此方法必须放在connect方法的前面
                ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())
                # 调用connect方法连接服务器
                ssh.connect(hostname='192.168.2.129', port=22, username='super', password='super')
                # 执行命令
                stdin, stdout, stderr = ssh.exec_command('df -hl')
                # 结果放到stdout中,如果有错误将放到stderr中
                print(stdout.read().decode())
                # 关闭连接
                ssh.close()

                  2 基于用户名和密码的 transport 方式登录 
                  方法1是传统的连接服务器、执行命令、关闭的一个操作,有时候需要登录上服务器执行多个操作,比如执行命令、上传/下载文件,方法1则无法实现,可以通过如下方式来操作

                  # 实例化一个transport对象
                  trans = paramiko.Transport(('192.168.2.129', 22))
                  # 建立连接
                  trans.connect(username='super', password='super')
                  
                  # 将sshclient的对象的transport指定为以上的trans
                  ssh = paramiko.SSHClient()
                  ssh._transport = trans
                  # 执行命令,和传统方法一样
                  stdin, stdout, stderr = ssh.exec_command('df -hl')
                  print(stdout.read().decode())
                  
                  # 关闭连接
                  trans.close()

                    3 基于公钥密钥的 SSHClient 方式登录

                    # 指定本地的RSA私钥文件,如果建立密钥对时设置的有密码,password为设定的密码,如无不用指定password参数
                    pkey = paramiko.RSAKey.from_private_key_file('/home/super/.ssh/id_rsa', password='12345')
                    # 建立连接
                    ssh = paramiko.SSHClient()
                    ssh.connect(hostname='192.168.2.129',
                                port=22,
                                username='super',
                                pkey=pkey)
                    # 执行命令
                    stdin, stdout, stderr = ssh.exec_command('df -hl')
                    # 结果放到stdout中,如果有错误将放到stderr中
                    print(stdout.read().decode())
                    # 关闭连接
                    ssh.close()

                      4 基于密钥的 Transport 方式登录

                      # 指定本地的RSA私钥文件,如果建立密钥对时设置的有密码,password为设定的密码,如无不用指定password参数
                      pkey = paramiko.RSAKey.from_private_key_file('/home/super/.ssh/id_rsa', password='12345')
                      # 建立连接
                      trans = paramiko.Transport(('192.168.2.129', 22))
                      trans.connect(username='super', pkey=pkey)
                      
                      # 将sshclient的对象的transport指定为以上的trans
                      ssh = paramiko.SSHClient()
                      ssh._transport = trans
                      
                      # 执行命令,和传统方法一样
                      stdin, stdout, stderr = ssh.exec_command('df -hl')
                      print(stdout.read().decode())
                      
                      # 关闭连接
                      trans.close()

                    传文件 SFTP ###########
                    # 实例化一个trans对象# 实例化一个transport对象
                    trans = paramiko.Transport(('192.168.2.129', 22))
                    # 建立连接
                    trans.connect(username='super', password='super')
                    
                    # 实例化一个 sftp对象,指定连接的通道
                    sftp = paramiko.SFTPClient.from_transport(trans)
                    # 发送文件
                    sftp.put(localpath='/tmp/11.txt', remotepath='/tmp/22.txt')
                    # 下载文件
                    # sftp.get(remotepath, localpath)
                    trans.close()

                      5 实现输入命令立马返回结果的功能 
                      以上操作都是基本的连接,如果我们想实现一个类似xshell工具的功能,登录以后可以输入命令回车后就返回结果:

                      import paramiko
                      import os
                      import select
                      import sys
                      
                      # 建立一个socket
                      trans = paramiko.Transport(('192.168.2.129', 22))
                      # 启动一个客户端
                      trans.start_client()
                      
                      # 如果使用rsa密钥登录的话
                      '''
                      default_key_file = os.path.join(os.environ['HOME'], '.ssh', 'id_rsa')
                      prikey = paramiko.RSAKey.from_private_key_file(default_key_file)
                      trans.auth_publickey(username='super', key=prikey)
                      '''
                      # 如果使用用户名和密码登录
                      trans.auth_password(username='super', password='super')
                      # 打开一个通道
                      channel = trans.open_session()
                      # 获取终端
                      channel.get_pty()
                      # 激活终端,这样就可以登录到终端了,就和我们用类似于xshell登录系统一样
                      channel.invoke_shell()
                      # 下面就可以执行你所有的操作,用select实现
                      # 对输入终端sys.stdin和 通道进行监控,
                      # 当用户在终端输入命令后,将命令交给channel通道,这个时候sys.stdin就发生变化,select就可以感知
                      # channel的发送命令、获取结果过程其实就是一个socket的发送和接受信息的过程
                      while True:
                          readlist, writelist, errlist = select.select([channel, sys.stdin,], [], [])
                          # 如果是用户输入命令了,sys.stdin发生变化
                          if sys.stdin in readlist:
                              # 获取输入的内容
                              input_cmd = sys.stdin.read(1)
                              # 将命令发送给服务器
                              channel.sendall(input_cmd)
                      
                          # 服务器返回了结果,channel通道接受到结果,发生变化 select感知到
                          if channel in readlist:
                              # 获取结果
                              result = channel.recv(1024)
                              # 断开连接后退出
                              if len(result) == 0:
                                  print("\r\n**** EOF **** \r\n")
                                  break
                              # 输出到屏幕
                              sys.stdout.write(result.decode())
                              sys.stdout.flush()
                      
                      # 关闭通道
                      channel.close()
                      # 关闭链接
                      trans.close()

                        6 支持tab自动补全

                        import paramiko
                        import os
                        import select
                        import sys
                        import tty
                        import termios
                        
                        '''
                        实现一个xshell登录系统的效果,登录到系统就不断输入命令同时返回结果
                        支持自动补全,直接调用服务器终端
                        
                        '''
                        # 建立一个socket
                        trans = paramiko.Transport(('192.168.2.129', 22))
                        # 启动一个客户端
                        trans.start_client()
                        
                        # 如果使用rsa密钥登录的话
                        '''
                        default_key_file = os.path.join(os.environ['HOME'], '.ssh', 'id_rsa')
                        prikey = paramiko.RSAKey.from_private_key_file(default_key_file)
                        trans.auth_publickey(username='super', key=prikey)
                        '''
                        # 如果使用用户名和密码登录
                        trans.auth_password(username='super', password='super')
                        # 打开一个通道
                        channel = trans.open_session()
                        # 获取终端
                        channel.get_pty()
                        # 激活终端,这样就可以登录到终端了,就和我们用类似于xshell登录系统一样
                        channel.invoke_shell()
                        
                        # 获取原操作终端属性
                        oldtty = termios.tcgetattr(sys.stdin)
                        try:
                            # 将现在的操作终端属性设置为服务器上的原生终端属性,可以支持tab了
                            tty.setraw(sys.stdin)
                            channel.settimeout(0)
                        
                            while True:
                                readlist, writelist, errlist = select.select([channel, sys.stdin,], [], [])
                                # 如果是用户输入命令了,sys.stdin发生变化
                                if sys.stdin in readlist:
                                    # 获取输入的内容,输入一个字符发送1个字符
                                    input_cmd = sys.stdin.read(1)
                                    # 将命令发送给服务器
                                    channel.sendall(input_cmd)
                        
                                # 服务器返回了结果,channel通道接受到结果,发生变化 select感知到
                                if channel in readlist:
                                    # 获取结果
                                    result = channel.recv(1024)
                                    # 断开连接后退出
                                    if len(result) == 0:
                                        print("\r\n**** EOF **** \r\n")
                                        break
                                    # 输出到屏幕
                                    sys.stdout.write(result.decode())
                                    sys.stdout.flush()
                        finally:
                            # 执行完后将现在的终端属性恢复为原操作终端属性
                            termios.tcsetattr(sys.stdin, termios.TCSADRAIN, oldtty)
                        
                        # 关闭通道
                        channel.close()
                        # 关闭链接
                        trans.close()

                        原文链接:http://blog.csdn.net/songfreeman/article/details/50920767


                        其实,看这些中文版教程,如果能解决你的问题也确实是比较方便、快捷。然而,一旦遇到问题,出现各种异常的时候,看这些中文教程也就不知道如何去着手解决了,所以还是要养成一开始先搜素互联网,看有哪些方式(python的哪些模块,哪些方法)能解决类似的问题,然后查阅具体的官方API,这样具体的方法、参数、使用方式都一目了然,而且记忆会更加深刻,解决问题后也更有成就感。所以,还是比较提倡去官方API查阅具体的使用方式的,遇到问题不能解决的时候,也不放回过头来,重新翻看官方API,相信在这里一定会发现问题的端倪,从而解决掉问题的。

                        展开全文
                      • python模块paramiko与ssh安装配置教程

                        千次阅读 2015-04-14 11:11:17
                        paramiko是用python语言写的一个模块,遵循SSH2协议,支持以加密和认证的方式,进行远程服务器的连接了,下面我们就来给各位一起验证一下python模块paramiko与ssh安装与使用示例吧。 一、paramiko模块的安装 ...

                        paramiko是用python语言写的一个模块,遵循SSH2协议,支持以加密和认证的方式,进行远程服务器的连接了,下面我们就来给各位一起验证一下python模块paramiko与ssh安装与使用示例吧。

                        一、paramiko模块的安装
                        paramiko模块依赖PyCrypto模块,而PyCrypto需要GCC库编译,不过一般发行版的源里带有该模块。这里以centos6为例,直接借助以下命令可以直接完成安装:

                         代码如下 复制代码
                        # yum install gcc python-crypto python-paramiko python-devel  -y 

                        windows版下可以安装windows版的GCC(MinGW),然后编辑安装pycrypto和paramiko ,下载安成后,直接运行python.exe setup.py build 和 python.exe setup.py install 就可以了。

                        二、paramiko的连接
                        使用paramiko模块有两种连接方式,一种是通过paramiko.SSHClient()函数,另外一种是通过paramiko.Transport()函数。

                        方法一:

                         代码如下 复制代码
                        import paramiko
                        ssh = paramiko.SSHClient()
                        ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())
                        ssh.connect("某IP地址",22,"用户名", "口令")

                        上面的第二行代码的作用是允许连接不在know_hosts文件中的主机。

                        方法二:

                         代码如下 复制代码
                        import paramiko
                        t = paramiko.Transport(("主机","端口"))
                        t.connect(username = "用户名", password = "口令")

                        如果连接远程主机需要提供密钥,上面第二行代码可改成:

                         代码如下 复制代码
                        t.connect(username = "用户名", password = "口令", hostkey="密钥")

                        三、paramiko ssh连接
                        以下是一个简单的通过paramiko模块定义的ssh连接并执行命令的函数,如下:

                         代码如下 复制代码
                        #!/usr/bin/python
                        #-*- coding: utf-8 -*-
                        import paramiko
                        #paramiko.util.log_to_file('/tmp/sshout')
                        def ssh2(ip,username,passwd,cmd):
                            try:
                                ssh = paramiko.SSHClient()
                                ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())
                                ssh.connect(ip,22,username,passwd,timeout=5)
                                stdin,stdout,stderr = ssh.exec_command(cmd)
                        #           stdin.write("Y")   #简单交互,输入 ‘Y’
                                print stdout.read()
                        #        for x in  stdout.readlines():
                        #          print x.strip("\n")
                                print '%s\tOK\n'%(ip)
                                ssh.close()
                            except :
                                print '%s\tError\n'%(ip)
                        ssh2("192.168.0.102","root","361way","hostname;ifconfig")
                        ssh2("192.168.0.107","root","123456","ifconfig")

                        其中第四行的日志部分,是记录ssh连接交互时的一些信息,可以看做是类似于debug的输出,一般情况下不需要开启。

                        stdin.write部分是用于交互情况下,通过该命令可以执行交互。注意这里可能会引起歧义,这里的交互并不是ssh连接过程中出现的让输入yes的交互,因为paramiko模块在连接过程中会自动处理好yes确认。这里的交互是指后面的cmd需要的执行的程序可能出现交互的情况下,可以通过该参数进行交互。

                        stdout标准输出,在输出内容比较少时,可以通过直接使用read读取出所有的输出;但在输出内容比较多时,建议通过按行读取进行处理。不过按行读取时,每行结尾会有换行符\n,这样输出的结果很不美观。可以通过strip进行字符串的处理。

                        在函数调用过程中需要注意的是,IP、username、passwd都是属于字符串型的,所以需要加引号。后面执行的cmd,如果有多个命令需要操作时,需要通过分号进行分割。

                        四、paramiko sftp示例
                        单个文件小传下载的示例:

                         代码如下 复制代码
                        import paramiko
                        #建立一个加密的管道
                        scp=paramiko.Transport(('192.168.0.102',22))
                        #建立连接
                        scp.connect(username='root',password='361way')
                        #建立一个sftp客户端对象,通过ssh transport操作远程文件
                        sftp=paramiko.SFTPClient.from_transport(scp)
                        #Copy a remote file (remotepath) from the SFTP server to the local host
                        sftp.get('/root/testfile','/tmp/361way')
                        #Copy a local file (localpath) to the SFTP server as remotepath
                        sftp.put('/root/crash-6.1.6.tar.gz','/tmp/crash-6.1.6.tar.gz')
                        scp.close()

                        一个目录下多个文件上传下载的示例:

                         代码如下 复制代码
                        #!/usr/bin/env python
                        #-*- coding: utf-8 -*-
                        import paramiko,datetime,os
                        hostname='192.168.0.102'
                        username='root'
                        password='361way'
                        port=22
                        local_dir='/tmp/getfile'
                        remote_dir='/tmp/abc'
                        try:
                            t=paramiko.Transport((hostname,port))
                            t.connect(username=username,password=password)
                            sftp=paramiko.SFTPClient.from_transport(t)
                            #files=sftp.listdir(dir_path)
                            files=sftp.listdir(remote_dir)
                            for f in files:
                                print ''
                                print '#########################################'
                                print 'Beginning to download file  from %s  %s ' % (hostname,datetime.datetime.now())
                                print 'Downloading file:',os.path.join(remote_dir,f)
                                sftp.get(os.path.join(remote_dir,f),os.path.join(local_dir,f))#下载
                                #sftp.put(os.path.join(local_dir,f),os.path.join(remote_dir,f))#上传
                                print 'Download file success %s ' % datetime.datetime.now()
                                print ''
                                print '##########################################'
                            t.close()
                        except Exception:
                               print "connect error!" 

                        注:本处的目录下所有文件进行下载或上传的示例中,在遇到目录下还有嵌套的目录存在时,会将目录也当做文件进行处理,所以如果想要更加的完美的话,可以通过引入stat模块下的S_ISDIR方法进行处理

                        paramiko.transport对象也支持以socket的方式进行连接,如下示例:

                         代码如下 复制代码

                        import paramiko
                        transport = paramiko.Transport(('localhost',22))
                        transport.connect(username='root', password = 'password')
                        sftp = paramiko.SFTPClient.from_transport(transport)
                        sftp.get(remotefile,localfile)
                        #如果是上传则用:
                        #sftp.put(localfile, remotefile)
                        transport.close()
                        #用socket连接
                        tcpsock = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
                        tcpsock.settimeout(5)
                        tcpsock.connect((ip,22),)
                        ssh = paramiko.Transport(tcpsock)
                        ssh.connect(username=user,password=password)
                        sftpConnect=paramiko.SFTPClient.from_transport(ssh)

                        五、利用paramiko实现ssh的交互式连接
                        以下是通过paramiko模块直接用ssh协议登陆到远程服务器的操作代码,这里先定义一个interactive模块,代码如下:

                         代码如下 复制代码
                        import socket
                        import sys
                        # 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)
                                while True:
                                    r, w, e = select.select([chan, sys.stdin], [], [])
                                    if chan in r:
                                        try:
                                            x = 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)
                        # thanks to Mike Looijmans for this code
                        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

                        代码内容可以从paramiko 在github项目上的demo里获取。再另外写一个ssh_inter.py的交互主程序,内容如下:

                         代码如下 复制代码
                        import paramiko
                        import interactive
                        #记录日志
                        paramiko.util.log_to_file('/tmp/test')
                        #建立ssh连接
                        ssh=paramiko.SSHClient()
                        ssh.load_system_host_keys()
                        ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())
                        ssh.connect('192.168.0.102',port=22,username='root',password='xxxxxx',compress=True)
                        #建立交互式shell连接
                        channel=ssh.invoke_shell()
                        #建立交互式管道
                        interactive.interactive_shell(channel)
                        #关闭连接
                        channel.close()
                        ssh.close()

                        执行效果就像我们平时直接使用ssh登录一样。

                        六、总结
                        paramiko模块是一个比较强大的ssh连接模块,以上的示例只是列出了该模块的一些简单的使用方法,还可以使用threading模块加块程序并发的速度;也可以使用configparser模块处理配置文件,而我们将所有IP、用户信息操作都放入配置文件;使用setproctitle模块为执行的程序加一个容易区分的title等。

                        同样,虽然连fabric这样大名鼎鼎的软件使用的ssh都是用paramiko模块进行的封装,不过你依然可以选择不使用它,你也可以选择pexpect模块实现封装一个简易的ssh连接工具、或者使用同样比较火的salt-ssh模块。

                        原文转自:361way.com 感谢站长

                        展开全文
                      • python模块之 paramiko

                        万次阅读 多人点赞 2017-10-24 22:07:10
                        paramiko模块提供了ssh及sft进行远程登录服务器执行命令和上传下载文件的功能。这是一个第三方的软件包,使用之前需要安装。1 基于用户名和密码的 sshclient 方式登录# 建立一个sshclient对象 ssh = paramiko.SSH...

                        paramiko模块提供了ssh及sft进行远程登录服务器执行命令和上传下载文件的功能。这是一个第三方的软件包,使用之前需要安装。

                        1 基于用户名和密码的 sshclient 方式登录

                        # 建立一个sshclient对象
                        ssh = paramiko.SSHClient()
                        # 允许将信任的主机自动加入到host_allow 列表,此方法必须放在connect方法的前面
                        ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())
                        # 调用connect方法连接服务器
                        ssh.connect(hostname='192.168.2.129', port=22, username='super', password='super')
                        # 执行命令
                        stdin, stdout, stderr = ssh.exec_command('df -hl')
                        # 结果放到stdout中,如果有错误将放到stderr中
                        print(stdout.read().decode())
                        # 关闭连接
                        ssh.close()

                        2 基于用户名和密码的 transport 方式登录
                        方法1是传统的连接服务器、执行命令、关闭的一个操作,有时候需要登录上服务器执行多个操作,比如执行命令、上传/下载文件,方法1则无法实现,可以通过如下方式来操作

                        # 实例化一个transport对象
                        trans = paramiko.Transport(('192.168.2.129', 22))
                        # 建立连接
                        trans.connect(username='super', password='super')
                        
                        # 将sshclient的对象的transport指定为以上的trans
                        ssh = paramiko.SSHClient()
                        ssh._transport = trans
                        # 执行命令,和传统方法一样
                        stdin, stdout, stderr = ssh.exec_command('df -hl')
                        print(stdout.read().decode())
                        
                        # 关闭连接
                        trans.close()

                        3 基于公钥密钥的 SSHClient 方式登录

                        # 指定本地的RSA私钥文件,如果建立密钥对时设置的有密码,password为设定的密码,如无不用指定password参数
                        pkey = paramiko.RSAKey.from_private_key_file('/home/super/.ssh/id_rsa', password='12345')
                        # 建立连接
                        ssh = paramiko.SSHClient()
                        ssh.connect(hostname='192.168.2.129',
                                    port=22,
                                    username='super',
                                    pkey=pkey)
                        # 执行命令
                        stdin, stdout, stderr = ssh.exec_command('df -hl')
                        # 结果放到stdout中,如果有错误将放到stderr中
                        print(stdout.read().decode())
                        # 关闭连接
                        ssh.close()

                        以上需要确保被访问的服务器对应用户.ssh目录下有authorized_keys文件,也就是将服务器上生成的公钥文件保存为authorized_keys。并将私钥文件作为paramiko的登陆密钥
                        4 基于密钥的 Transport 方式登录

                        # 指定本地的RSA私钥文件,如果建立密钥对时设置的有密码,password为设定的密码,如无不用指定password参数
                        pkey = paramiko.RSAKey.from_private_key_file('/home/super/.ssh/id_rsa', password='12345')
                        # 建立连接
                        trans = paramiko.Transport(('192.168.2.129', 22))
                        trans.connect(username='super', pkey=pkey)
                        
                        # 将sshclient的对象的transport指定为以上的trans
                        ssh = paramiko.SSHClient()
                        ssh._transport = trans
                        
                        # 执行命令,和传统方法一样
                        stdin, stdout, stderr = ssh.exec_command('df -hl')
                        print(stdout.read().decode())
                        
                        # 关闭连接
                        trans.close()

                        ##### 传文件 SFTP ###########

                        # 实例化一个trans对象# 实例化一个transport对象
                        trans = paramiko.Transport(('192.168.2.129', 22))
                        # 建立连接
                        trans.connect(username='super', password='super')
                        
                        # 实例化一个 sftp对象,指定连接的通道
                        sftp = paramiko.SFTPClient.from_transport(trans)
                        # 发送文件
                        sftp.put(localpath='/tmp/11.txt', remotepath='/tmp/22.txt')
                        # 下载文件
                        # sftp.get(remotepath, localpath)
                        trans.close()

                        5 实现输入命令立马返回结果的功能
                        以上操作都是基本的连接,如果我们想实现一个类似xshell工具的功能,登录以后可以输入命令回车后就返回结果:

                        import paramiko
                        import os
                        import select
                        import sys
                        
                        # 建立一个socket
                        trans = paramiko.Transport(('192.168.2.129', 22))
                        # 启动一个客户端
                        trans.start_client()
                        
                        # 如果使用rsa密钥登录的话
                        '''
                        default_key_file = os.path.join(os.environ['HOME'], '.ssh', 'id_rsa')
                        prikey = paramiko.RSAKey.from_private_key_file(default_key_file)
                        trans.auth_publickey(username='super', key=prikey)
                        '''
                        # 如果使用用户名和密码登录
                        trans.auth_password(username='super', password='super')
                        # 打开一个通道
                        channel = trans.open_session()
                        # 获取终端
                        channel.get_pty()
                        # 激活终端,这样就可以登录到终端了,就和我们用类似于xshell登录系统一样
                        channel.invoke_shell()
                        # 下面就可以执行你所有的操作,用select实现
                        # 对输入终端sys.stdin和 通道进行监控,
                        # 当用户在终端输入命令后,将命令交给channel通道,这个时候sys.stdin就发生变化,select就可以感知
                        # channel的发送命令、获取结果过程其实就是一个socket的发送和接受信息的过程
                        while True:
                            readlist, writelist, errlist = select.select([channel, sys.stdin,], [], [])
                            # 如果是用户输入命令了,sys.stdin发生变化
                            if sys.stdin in readlist:
                                # 获取输入的内容
                                input_cmd = sys.stdin.read(1)
                                # 将命令发送给服务器
                                channel.sendall(input_cmd)
                        
                            # 服务器返回了结果,channel通道接受到结果,发生变化 select感知到
                            if channel in readlist:
                                # 获取结果
                                result = channel.recv(1024)
                                # 断开连接后退出
                                if len(result) == 0:
                                    print("\r\n**** EOF **** \r\n")
                                    break
                                # 输出到屏幕
                                sys.stdout.write(result.decode())
                                sys.stdout.flush()
                        
                        # 关闭通道
                        channel.close()
                        # 关闭链接
                        trans.close()

                        6 支持tab自动补全

                        import paramiko
                        import os
                        import select
                        import sys
                        import tty
                        import termios
                        
                        '''
                        实现一个xshell登录系统的效果,登录到系统就不断输入命令同时返回结果
                        支持自动补全,直接调用服务器终端
                        
                        '''
                        # 建立一个socket
                        trans = paramiko.Transport(('192.168.2.129', 22))
                        # 启动一个客户端
                        trans.start_client()
                        
                        # 如果使用rsa密钥登录的话
                        '''
                        default_key_file = os.path.join(os.environ['HOME'], '.ssh', 'id_rsa')
                        prikey = paramiko.RSAKey.from_private_key_file(default_key_file)
                        trans.auth_publickey(username='super', key=prikey)
                        '''
                        # 如果使用用户名和密码登录
                        trans.auth_password(username='super', password='super')
                        # 打开一个通道
                        channel = trans.open_session()
                        # 获取终端
                        channel.get_pty()
                        # 激活终端,这样就可以登录到终端了,就和我们用类似于xshell登录系统一样
                        channel.invoke_shell()
                        
                        # 获取原操作终端属性
                        oldtty = termios.tcgetattr(sys.stdin)
                        try:
                            # 将现在的操作终端属性设置为服务器上的原生终端属性,可以支持tab了
                            tty.setraw(sys.stdin)
                            channel.settimeout(0)
                        
                            while True:
                                readlist, writelist, errlist = select.select([channel, sys.stdin,], [], [])
                                # 如果是用户输入命令了,sys.stdin发生变化
                                if sys.stdin in readlist:
                                    # 获取输入的内容,输入一个字符发送1个字符
                                    input_cmd = sys.stdin.read(1)
                                    # 将命令发送给服务器
                                    channel.sendall(input_cmd)
                        
                                # 服务器返回了结果,channel通道接受到结果,发生变化 select感知到
                                if channel in readlist:
                                    # 获取结果
                                    result = channel.recv(1024)
                                    # 断开连接后退出
                                    if len(result) == 0:
                                        print("\r\n**** EOF **** \r\n")
                                        break
                                    # 输出到屏幕
                                    sys.stdout.write(result.decode())
                                    sys.stdout.flush()
                        finally:
                            # 执行完后将现在的终端属性恢复为原操作终端属性
                            termios.tcsetattr(sys.stdin, termios.TCSADRAIN, oldtty)
                        
                        # 关闭通道
                        channel.close()
                        # 关闭链接
                        trans.close()
                        展开全文
                      • python之paramiko模块

                        万次阅读 2018-09-09 16:49:07
                        paramiko是一个用于做远程控制的模块,使用该模块可以对远程服务器进行命令或文件操作,paramiko是用python语言写的一个模块,遵循SSH2协议,支持以加密和认证的方式,进行远程服务器的连接。 由于使用的是python...
                      • python中的Paramiko模块(实现用户切换) 1. paramiko介绍   ssh是一个协议,OpenSSH是其中一个开源实现,paramiko是Python的一个库,实现了SSHv2协议(底层使用cryptography)。   有了Paramiko以后,我们就可以在...
                      • python安装paramiko

                        万次阅读 2018-04-28 14:37:57
                        今天在最小化安装的centos7.2上安装使用paramiko库。记录遇到的问题和流程。 部分概念 paramiko是一个python第三方库,使用python来实现了SSH2,使用条件2.6+/3.3+.官方站点是https://www.lag.net/ 应该是这个...
                      • paramiko-简介

                        千次阅读 2018-06-07 11:52:21
                        paramiko是SSHv2协议的Python实现,提供了客户端与服务器功能。虽然它利用Python C扩展进行低级加密,但paramiko本身是一个围绕SSH网络概念的纯Python接口。 paramiko最开始是用Python对ssh进行的一个封装,封装...
                      • 我们知道,通过SSH服务可以远程连接到Linux服务器,查看上面的日志状态,批量配置远程服务器,文件上传,文件下载等,Python的paramiko模块同样实现了这一功能。 首先我们需要安装这一模块,pycharm环境中如下操作 ...
                      • paramiko的安装

                        千次阅读 2018-06-04 19:53:18
                        import paramiko 出错直接通过下列代码即可,无需安装VS之类的pip install paramiko
                      • python - ImportError: No module named paramiko  提示没安装paramiko模块。 解决方法: Python中使用SSH需要用到OpenSSH,而OpenSSH依赖于paramiko模块,而paramiko模块又依赖于pycrypto模块,因此要在Python中...
                      • 进行如下操作: 上边这个问题解决了:
                      • python安装pip request paramiko

                        千次阅读 2016-12-02 11:41:01
                        python安装pip request paramiko
                      • paramiko安装&错误解决

                        千次阅读 2016-10-12 15:41:28
                        错误提示: RuntimeoutError 错误提示:ReadTimeoutError: HTTPSConnectionPool(host='pypi.python.org', port=443): Readtimed out. 解决方法:在命令中添加 --default-timeout=100 延长超时时间即可。...
                      • paramiko使用

                        千次阅读 2019-09-16 16:28:11
                        paramiko使用paramiko使用密码登录paramiko使用秘钥登录paramiko上传文件...import paramiko transport = paramiko.Transport('xx.xx.xx.xx', 22) transport.connect(username='root', password='xxx') clie...
                      • 安装python3并安装paramiko

                        千次阅读 2018-09-04 16:52:55
                        进入python官网 ...   下载然后安装,我下载的是3.6的版本 然后配置环境变量 ...C:\Users\Administrator\AppData\Local\Programs\Python\Python36 ...C:\Users\Administrator\AppData\Local\Programs\Python\Py...
                      • 如果我们想要远程拷贝服务器上面的文件,或者对远程服务器进行相关操作的话,使用paramiko可以很好的解决以上问题。它仅需要在本地上安装相应的软件(python、PyCrypto、ecdsa),对远程服务器没有配置要求,对于...
                      • import paramiko   hostname = '121.40.100.198' port = 22 username = 'root' key_file = '/root/.ssh/id_rsa' key = paramiko.RSAKey.from_private_key_file(key_file)  s = paramiko.SSH
                      • python在windows安装paramiko模块

                        千次阅读 2014-03-20 23:40:56
                        今天抽时间倒腾了一下ST,发现当前的ST工程只能在linux下运行,但部门的人都不怎么会使用ST来保障代码质量。于是就想移植到windows下使用,首先就牵涉到了windows上远程执行命令及收集执行结果,脚本自动上传,日志...
                      • Python3.6 安装paramiko及填坑

                        千次阅读 2018-07-14 17:57:01
                        paramiko -安装直接 pip install paramiko,相应依赖包会直接安装不用提前安装,可以避免不必要的坑。 离线安装坑多需要依赖pycrypto,pycrypto需要依赖vcvarsall.bat,要安装Visual Studio 此方法未验证。安装成功...
                      1 2 3 4 5 ... 20
                      收藏数 9,815
                      精华内容 3,926
                      关键字:

                      paramiko