0
0

Python中的SSH、SFTP和FTP操作详解

  1.     大家好，在网络编程中，安全地连接到远程服务器并执行操作是一项常见任务。Python 提供了多种库来实现这一目标，其中 Paramiko 是一个功能强大的工具，可以轻松地在 Python 中执行 SSH、SFTP 和 FTP 操作。本文将介绍如何使用 Paramiko 库来进行这些操作。

一、使用 Paramiko 执行 SSH 远程命令

  1.     使用 Python 的 Paramiko 模块可以方便地执行 SSH 远程命令。Paramiko 是一个纯 Python 实现的 SSHv2 协议，它提供了一个简单而强大的 API，可以连接到远程服务器并执行命令，以及传输文件等。

1、安装 Paramiko 模块

可以使用 pip 命令来安装：

  1. pip install paramiko

2、导入 Paramiko 模块

在 Python 脚本中导入 Paramiko 模块：

  1. import paramiko

3、连接到远程服务器

创建一个 SSHClient 对象，并使用 connect() 方法连接到远程服务器：

  1. # 创建 SSHClient 对象
  2. ssh_client = paramiko.SSHClient()
  4. # 添加远程服务器的主机密钥（如果首次连接，需要添加）
  5. ssh_client.set_missing_host_key_policy(paramiko.AutoAddPolicy())
  7. # 连接到远程服务器
  8. ssh_client.connect(hostname='your_remote_server', port=22, username='your_username', password='your_password')

4、执行远程命令

使用 exec_command() 方法执行远程命令：

  1. # 执行远程命令
  2. stdin, stdout, stderr = ssh_client.exec_command('ls -l')
  4. # 读取命令执行结果
  5. output = stdout.read().decode('utf-8')
  6. error = stderr.read().decode('utf-8')
  8. # 打印执行结果或错误信息
  9. print("Command Output:", output)
  10. print("Command Error:", error)

5、关闭 SSH 连接

执行完远程命令后，记得关闭 SSH 连接：

  1. # 关闭 SSH 连接
  2. ssh_client.close()

6、示例

下面是一个完整的示例，演示了如何使用 Paramiko 执行 SSH 远程命令：

  1. import paramiko
  3. # 远程服务器的信息
  4. hostname = 'your-remote-server'
  5. port = 22
  6. username = 'your-username'
  7. password = 'your-password'
  9. # 创建 SSHClient 对象
  10. ssh_client = paramiko.SSHClient()
  12. try:
  13.     # 添加远程服务器的主机密钥（如果首次连接，需要添加）
  14.     ssh_client.set_missing_host_key_policy(paramiko.AutoAddPolicy())
  16.     # 连接到远程服务器
  17.     ssh_client.connect(hostname, port, username, password)
  19.     # 执行远程命令
  20.     command = 'ls -l'
  21.     stdin, stdout, stderr = ssh_client.exec_command(command)
  23.     # 获取命令执行结果
  24.     output = stdout.read().decode('utf-8')
  25.     error = stderr.read().decode('utf-8')
  27.     if output:
  28.         print("命令执行结果：")
  29.         print(output)
  30.     else:
  31.         print("错误信息：")
  32.         print(error)
  34. finally:
  35.     # 关闭 SSH 连接
  36.     ssh_client.close()

二、使用 Paramiko 的 SFTP

  1.     Paramiko 的 SFTP（SSH 文件传输协议）功能使得在 Python 中进行安全文件传输变得非常简单。通过 SFTP，你可以连接到远程服务器，上传文件、下载文件、创建目录、删除文件等。

1、导入 Paramiko 模块

首先，在 Python 脚本中导入 Paramiko 模块：

  1. import paramiko

2、连接到远程服务器

创建一个 SSHClient 对象，并使用 connect() 方法连接到远程服务器：

  1. # 创建 SSHClient 对象
  2. ssh_client = paramiko.SSHClient()
  4. # 添加远程服务器的主机密钥（如果首次连接，需要添加）
  5. ssh_client.set_missing_host_key_policy(paramiko.AutoAddPolicy())
  7. # 连接到远程服务器
  8. ssh_client.connect(hostname='your_remote_server', port=22, username='your_username', password='your_password')

3、创建 SFTP 客户端

通过 SSHClient 的 open_sftp() 方法创建 SFTP 客户端：

  1. # 创建 SFTP 客户端
  2. sftp_client = ssh_client.open_sftp()

4、执行 SFTP 操作

现在，可以使用 SFTP 客户端执行各种操作，比如上传文件、下载文件、创建目录、删除文件等。以下是一些常见操作的示例：

上传文件

使用 put() 方法上传本地文件到远程服务器：

  1. local_file = '/path/to/local/file.txt'
  2. remote_file = '/path/to/remote/file.txt'
  3. sftp_client.put(local_file, remote_file)

下载文件

使用 get() 方法从远程服务器下载文件到本地：

  1. remote_file = '/path/to/remote/file.txt'
  2. local_file = '/path/to/local/file.txt'
  3. sftp_client.get(remote_file, local_file)

创建目录

使用 mkdir() 方法在远程服务器上创建目录：

  1. remote_dir = '/path/to/remote/directory'
  2. sftp_client.mkdir(remote_dir)

删除文件

使用 remove() 方法删除远程服务器上的文件：

  1. remote_file = '/path/to/remote/file.txt'
  2. sftp_client.remove(remote_file)

5、关闭 SFTP 连接

执行完 SFTP 操作后，记得关闭 SFTP 连接：

  1. # 关闭 SFTP 连接
  2. sftp_client.close()

6、关闭 SSH 连接

最后，关闭 SSH 连接：

  1. # 关闭 SSH 连接
  2. ssh_client.close()

7、示例

以下是一个完整的示例，演示了如何使用 Paramiko 进行 SFTP 文件传输：

  1. import paramiko
  3. # 远程服务器的信息
  4. hostname = 'your-remote-server'
  5. port = 22
  6. username = 'your-username'
  7. password = 'your-password'
  9. # 远程文件和本地文件的路径
  10. remote_file_path = '/path/to/remote/file.txt'
  11. local_file_path = '/path/to/local/file.txt'
  13. # 创建 SSHClient 对象
  14. ssh_client = paramiko.SSHClient()
  16. try:
  17.     # 添加远程服务器的主机密钥（如果首次连接，需要添加）
  18.     ssh_client.set_missing_host_key_policy(paramiko.AutoAddPolicy())
  20.     # 连接到远程服务器
  21.     ssh_client.connect(hostname, port, username, password)
  23.     # 创建 SFTP 客户端
  24.     sftp_client = ssh_client.open_sftp()
  26.     # 上传文件到远程服务器
  27.     sftp_client.put(local_file_path, remote_file_path)
  28.     print("文件成功上传到远程服务器")
  30.     # 下载文件到本地
  31.     sftp_client.get(remote_file_path, local_file_path)
  32.     print("文件成功从远程服务器下载到本地")
  34. finally:
  35.     # 关闭 SFTP 连接
  36.     sftp_client.close()
  38.     # 关闭 SSH 连接
  39.     ssh_client.close()

三、Paramiko 远程命令与文件的函数封装

  1. # -*- coding: utf-8 -*-
  2. import paramiko
  3. import threading
  4. import logging as logger
  6. logger.basicConfig(level=logger.INFO)
  8. def remote_command(host_ip, host_port, username, password, command):
  9.     """
  10.     远程执行Linux命令
  11.     :param host_ip: 主机IP地址
  12.     :type host_ip: str
  13.     :param host_port: 主机SSH端口号
  14.     :type host_port: int
  15.     :param username: SSH用户名
  16.     :type username: str
  17.     :param password: SSH密码
  18.     :type password: str
  19.     :param command: 要执行的命令
  20.     :type command: str
  21.     """
  22.     client = None
  23.     try:
  24.         # 创建SSH客户端
  25.         client = paramiko.SSHClient()
  26.         # 第一次SSH远程连接时会提示输入yes或者no
  27.         client.set_missing_host_key_policy(paramiko.AutoAddPolicy())
  28.         client.connect(host_ip, host_port, username=username, password=password, timeout=10)
  29.         logger.info(f"开始在远程服务器 {host_ip} 上执行命令: {command}")
  30.         # 执行命令
  31.         stdin, stdout, stderr = client.exec_command(command, get_pty=True)
  32.         # 获取命令执行结果，返回的数据是一个字符串
  33.         result = stdout.read().decode('utf-8')
  34.         logger.info(f"{host_ip} 执行结果: {result}")
  36.         error = stderr.read().decode('utf-8')
  37.         if error != "":
  38.             logger.info(f"{host_ip} 错误信息: {error}")
  39.         else:
  40.             pass
  41.     except Exception as e:
  42.         logger.error(e)
  43.     finally:
  44.         client.close()
  46. def batch_remote_command(host_list, host_port, username, password, command):
  47.     """
  48.     批量远程执行Linux命令
  49.     :param host_list: 主机IP地址列表
  50.     :type host_list: list
  51.     :param host_port: 主机SSH端口号
  52.     :type host_port: int
  53.     :param username: SSH用户名
  54.     :type username: str
  55.     :param password: SSH密码
  56.     :type password: str
  57.     :param command: 要执行的命令
  58.     :type command: str
  59.     """
  60.     thread_list = []
  61.     for ip in host_list:
  62.         thread = threading.Thread(target=remote_command, args=(ip, host_port, username, password, command))
  63.         # 将生成的线程添加到列表中
  64.         thread_list.append(thread)
  65.     for t in thread_list:
  66.         # 开始执行线程
  67.         t.start()
  68.     for t in thread_list:
  69.         # 挂起线程，等待所有线程结束
  70.         t.join()
  72. def upload_file_to_remote_server(host, port, username, password, local_path, remote_path):
  73.     """
  74.     上传文件从本地到远程服务器
  75.     Args:
  76.         host (str): 远程服务器的IP地址或主机名
  77.         port (int): 远程服务器的端口
  78.         username (str): 远程服务器的用户名
  79.         password (str): 远程服务器的密码
  80.         local_path (str): 本地文件路径，要上传的文件
  81.         remote_path (str): 远程文件路径，上传的目标位置
  82.     """
  83.     # 连接远程服务器
  84.     ssh = paramiko.SSHClient()
  85.     ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())
  86.     ssh.connect(hostname=host, port=port, username=username, password=password)
  87.     # 打开SFTP客户端
  88.     sftp = ssh.open_sftp()
  89.     # 上传本地文件至远程服务器
  90.     sftp.put(local_path, remote_path)
  91.     # 关闭SFTP客户端和SSH连接
  92.     sftp.close()
  93.     ssh.close()
  95. def download_file_from_remote_server(host, port, username, password, remote_path, local_path):
  96.     """
  97.     从远程服务器下载文件到本地
  98.     Args:
  99.         host (str): 远程服务器的IP地址或主机名
  100.         port (int): 远程服务器的端口
  101.         username (str): 远程服务器的用户名
  102.         password (str): 远程服务器的密码
  103.         remote_path (str): 远程文件路径，要下载的文件
  104.         local_path (str): 本地文件路径，下载的目标位置
  105.     """
  106.     # 连接远程服务器
  107.     ssh = paramiko.SSHClient()
  108.     ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())
  109.     ssh.connect(hostname=host, port=port, username=username, password=password)
  110.     # 打开SFTP客户端
  111.     sftp = ssh.open_sftp()
  112.     # 下载远程服务器文件至本地
  113.     sftp.get(remote_path, local_path)
  114.     # 关闭SFTP客户端和SSH连接
  115.     sftp.close()
  116.     ssh.close()

四、使用

  1. ftplib 访问 FTP 服务
  1.     ftplib

是 Python 标准库中的一个模块，用于实现 FTP（文件传输协议）客户端。通过 

  1. ftplib

模块，你可以编写 Python 程序来连接到 FTP 服务器，上传文件、下载文件、列出目录等。

1、连接到 FTP 服务器

  1.     要连接到 FTP 服务器，首先需要导入 
  1. ftplib

模块，然后使用 

  1. FTP

类创建一个 FTP 对象，并通过 

  1. connect(host, port)

方法连接到服务器。

  1. from ftplib import FTP
  3. ftp = FTP()
  4. ftp.connect('ftp.example.com', 21)

2、登录到 FTP 服务器

  1.     成功连接到 FTP 服务器后，需要登录以进行后续操作。可以使用 
  1. login(user, passwd)

方法登录到服务器。

  1. ftp.login('username', 'password')

3、获取目录列表

可以使用 

  1. nlst()

方法获取当前目录的文件列表。

  1. file_list = ftp.nlst()
  2. print(file_list)

4、切换目录

可以使用 

  1. cwd(path)

方法切换到指定的目录。

  1. ftp.cwd('/path/to/directory')

5、下载文件

要从服务器下载文件，可以使用 

  1. retrbinary(command, callback, blocksize, rest)

方法。

  1. local_filename = 'file_to_download.txt'
  3. with open(local_filename, 'wb') as file:
  4.     ftp.retrbinary('RETR file_to_download.txt', file.write)

6、上传文件

要将文件上传到服务器，可以使用 

  1. storbinary(command, file, blocksize, callback, rest)

方法。

  1. local_filename = 'file_to_upload.txt'
  3. with open(local_filename, 'rb') as file:
  4.     ftp.storbinary('STOR file_to_upload.txt', file)

7、删除文件

可以使用 

  1. delete(filename)

方法从服务器上删除文件。

  1. ftp.delete('file_to_delete.txt')

8、断开连接

完成所有操作后，记得断开与服务器的连接。

  1. ftp.quit()

9、示例

以下是一个完整的示例，演示了如何使用 Python 的 ftplib 模块访问 FTP 服务：

  1. from ftplib import FTP
  3. # FTP 服务器的地址和端口
  4. ftp_host = 'ftp.example.com'
  5. ftp_port = 21
  7. # FTP 服务器的用户名和密码
  8. ftp_username = 'your-username'
  9. ftp_password = 'your-password'
  11. # 连接到 FTP 服务器
  12. ftp = FTP()
  13. ftp.connect(ftp_host, ftp_port)
  15. # 登录到 FTP 服务器
  16. ftp.login(ftp_username, ftp_password)
  18. # 列出当前目录的文件列表
  19. file_list = ftp.nlst()
  20. print("当前目录的文件列表：", file_list)
  22. # 切换到指定目录
  23. ftp.cwd('/path/to/directory')
  25. # 上传文件到服务器
  26. local_filename = 'file_to_upload.txt'
  27. remote_filename = 'uploaded_file.txt'
  28. with open(local_filename, 'rb') as file:
  29.     ftp.storbinary('STOR ' + remote_filename, file)
  31. print("文件成功上传到服务器")
  33. # 下载文件到本地
  34. local_filename = 'downloaded_file.txt'
  35. remote_filename = 'file_to_download.txt'
  36. with open(local_filename, 'wb') as file:
  37.     ftp.retrbinary('RETR ' + remote_filename, file.write)
  39. print("文件成功从服务器下载到本地")
  41. # 删除服务器上的文件
  42. ftp.delete(remote_filename)
  43. print("文件成功从服务器删除")
  45. # 断开与 FTP 服务器的连接
  46. ftp.quit()
  47. print("FTP连接已断开")
  1.     以上是对 
  1. ftplib

模块的介绍。使用这个模块，可以轻松地编写 Python 脚本来管理 FTP 服务器上的文件。请注意，在使用 

  1. ftplib

模块时要小心处理敏感信息（如用户名和密码），以确保安全性。

标签： ssh 运维 python
本文转载自: https://blog.csdn.net/xiangxi1204/article/details/139237381
版权归原作者 寒秋丶 所有， 如有侵权，请联系我们删除。
登录后发布评论

“Python中的SSH、SFTP和FTP操作详解”的评论:

还没有评论
关于作者
...
overfit同步小助手
文章同步
相关阅读

网络安全法-网络运行安全

使用selenium/drissionpage时如何阻止chrome自动跳转http到https

docker desktop 里部署的Open WebUI 管理员密码忘记了的处理方法

在ubuntu20.04中搭建onsite比赛运行环境

利用开源的低代码表单设计器FcDesigner高效管理和渲染复杂表单结构

Kafka学习笔记

【前端】浏览器输入url到页面呈现发生了什么？