Python для SFTP: безопасная передача файлов между серверами

pip install paramiko

import paramiko

# Инициализация клиента
ssh_client = paramiko.SSHClient()

# Добавление ключа хоста автоматически (в продакшене требуется более безопасный подход)
ssh_client.set_missing_host_key_policy(paramiko.AutoAddPolicy())

# Подключение к серверу
ssh_client.connect(
hostname='example.com',
username='user',
password='password',
port=22 # Стандартный порт SSH
)

# Открытие SFTP-сессии
sftp_client = ssh_client.open_sftp()

# После выполнения операций не забудьте закрыть соединения
sftp_client.close()
ssh_client.close()

import paramiko

ssh_client = paramiko.SSHClient()
ssh_client.set_missing_host_key_policy(paramiko.AutoAddPolicy())

# Подключение с использованием SSH-ключа
ssh_client.connect(
hostname='example.com',
username='user',
key_filename='/path/to/private_key',
port=22
)

sftp_client = ssh_client.open_sftp()

import paramiko
import socket

try:
ssh_client = paramiko.SSHClient()
ssh_client.set_missing_host_key_policy(paramiko.AutoAddPolicy())

ssh_client.connect(
hostname='example.com',
username='user',
key_filename='/path/to/private_key',
port=22,
timeout=10 # Установка таймаута для подключения
)

sftp_client = ssh_client.open_sftp()

# Операции с файлами

except paramiko.AuthenticationException:
print("Ошибка аутентификации. Проверьте учетные данные.")
except paramiko.SSHException as ssh_ex:
print(f"Ошибка SSH: {str(ssh_ex)}")
except socket.timeout:
print("Тайм-аут при подключении к серверу")
except Exception as e:
print(f"Непредвиденная ошибка: {str(e)}")
finally:
if 'sftp_client' in locals() and sftp_client:
sftp_client.close()
if 'ssh_client' in locals() and ssh_client:
ssh_client.close()

import paramiko
import os

ssh_client = paramiko.SSHClient()
ssh_client.set_missing_host_key_policy(paramiko.AutoAddPolicy())
ssh_client.connect(hostname='example.com', username='user', password='password')

sftp_client = ssh_client.open_sftp()

# Загрузка файла на сервер (put)
local_path = 'local_file.txt'
remote_path = '/remote/path/remote_file.txt'
sftp_client.put(local_path, remote_path)

# Скачивание файла с сервера (get)
sftp_client.get('/remote/path/download.txt', 'local_download.txt')

# Список файлов в директории
file_list = sftp_client.listdir('/remote/directory')
for file in file_list:
print(file)

# Получение подробной информации о файле (атрибуты)
file_attr = sftp_client.stat('/remote/path/file.txt')
print(f"Размер файла: {file_attr.st_size} байт")
print(f"Время модификации: {file_attr.st_mtime}")
print(f"Права доступа: {oct(file_attr.st_mode)}")

# Создание директории
sftp_client.mkdir('/remote/new_directory')

# Изменение текущей директории
sftp_client.chdir('/remote/directory')

# Удаление файла
sftp_client.remove('/remote/path/unwanted_file.txt')

# Удаление пустой директории
sftp_client.rmdir('/remote/empty_directory')

# Переименование файла или директории
sftp_client.rename('/remote/old_name.txt', '/remote/new_name.txt')

# Закрытие соединения
sftp_client.close()
ssh_client.close()

import paramiko
import os
import sys

def progress_callback(bytes_transferred, total_bytes):
percentage = (bytes_transferred / total_bytes) * 100
sys.stdout.write(f"\rПрогресс: {percentage:.2f}% ({bytes_transferred}/{total_bytes} байт)")
sys.stdout.flush()

ssh_client = paramiko.SSHClient()
ssh_client.set_missing_host_key_policy(paramiko.AutoAddPolicy())
ssh_client.connect(hostname='example.com', username='user', password='password')

sftp_client = ssh_client.open_sftp()

# Получение размера файла
file_size = os.path.getsize('large_file.iso')

# Загрузка с отслеживанием прогресса
sftp_client.put(
'large_file.iso', 
'/remote/large_file.iso',
callback=lambda x, y: progress_callback(x, file_size)
)

print("\nЗагрузка завершена!")

sftp_client.close()
ssh_client.close()

import paramiko
import os

def upload_directory(sftp, local_dir, remote_dir):
os.makedirs(local_dir, exist_ok=True)

try:
sftp.stat(remote_dir)
except IOError:
sftp.mkdir(remote_dir)

for item in os.listdir(local_dir):
local_path = os.path.join(local_dir, item)
remote_path = remote_dir + '/' + item

if os.path.isfile(local_path):
sftp.put(local_path, remote_path)
print(f"Загружен файл: {local_path} -> {remote_path}")
elif os.path.isdir(local_path):
upload_directory(sftp, local_path, remote_path)

def download_directory(sftp, remote_dir, local_dir):
os.makedirs(local_dir, exist_ok=True)

for item in sftp.listdir(remote_dir):
remote_path = remote_dir + '/' + item
local_path = os.path.join(local_dir, item)

try:
# Проверяем, является ли элемент директорией
sftp.stat(remote_path)
try:
# Попытка изменить директорию для проверки, является ли элемент папкой
sftp.chdir(remote_path)
sftp.chdir('..') # Возвращаемся назад
# Если это директория, рекурсивно скачиваем
download_directory(sftp, remote_path, local_path)
except IOError:
# Если не можем изменить директорию, это файл
sftp.get(remote_path, local_path)
print(f"Скачан файл: {remote_path} -> {local_path}")
except IOError:
print(f"Ошибка при обработке {remote_path}")

import asyncio
import asyncssh
import os

async def upload_file(host, username, password, local_path, remote_path):
async with asyncssh.connect(
host=host, 
username=username, 
password=password, 
known_hosts=None # Не для продакшена!
) as conn:
async with conn.start_sftp_client() as sftp:
await sftp.put(local_path, remote_path)
print(f"Загружен файл: {local_path}")

async def main():
# Список задач для параллельной обработки
tasks = []

# Формируем задачи для загрузки
for i in range(10):
file_name = f"file_{i}.txt"
task = upload_file(
'example.com', 
'user', 
'password', 
file_name, 
f"/remote/path/{file_name}"
)
tasks.append(task)

# Запускаем все задачи параллельно
await asyncio.gather(*tasks)

# Запуск асинхронного кода
asyncio.run(main())

import paramiko
import os
import tempfile
import shutil

def atomic_upload(sftp, local_path, remote_path):
# Создаем временное имя файла на удаленной системе
temp_path = remote_path + '.tmp'

# Загружаем во временный файл
sftp.put(local_path, temp_path)

# Переименовываем файл (атомарная операция в большинстве файловых систем)
sftp.rename(temp_path, remote_path)
print(f"Файл {local_path} успешно загружен как {remote_path}")

ssh_client = paramiko.SSHClient()
ssh_client.set_missing_host_key_policy(paramiko.AutoAddPolicy())
ssh_client.connect(hostname='example.com', username='user', password='password')

sftp_client = ssh_client.open_sftp()
atomic_upload(sftp_client, 'important_data.csv', '/remote/data.csv')

sftp_client.close()
ssh_client.close()

import paramiko
import contextlib

@contextlib.contextmanager
def sftp_connection(host, username, password=None, key_path=None):
ssh_client = paramiko.SSHClient()
ssh_client.set_missing_host_key_policy(paramiko.AutoAddPolicy())

connect_kwargs = {
'hostname': host,
'username': username,
}

if password:
connect_kwargs['password'] = password
elif key_path:
connect_kwargs['key_filename'] = key_path

try:
ssh_client.connect(**connect_kwargs)
sftp_client = ssh_client.open_sftp()
yield sftp_client
finally:
if 'sftp_client' in locals():
sftp_client.close()
ssh_client.close()

# Использование контекстного менеджера
with sftp_connection('example.com', 'user', password='password') as sftp:
sftp.put('local_file.txt', '/remote/file.txt')
print("Файл загружен")
# При выходе из блока with соединения будут автоматически закрыты

import paramiko
import io

ssh_client = paramiko.SSHClient()
ssh_client.set_missing_host_key_policy(paramiko.AutoAddPolicy())
ssh_client.connect(hostname='example.com', username='user', password='password')

sftp_client = ssh_client.open_sftp()

# Открытие удаленного файла для потокового чтения
with sftp_client.open('/remote/large_file.dat', 'rb') as remote_file:
# Обработка файла по частям
chunk_size = 8192 # 8 KB
data = remote_file.read(chunk_size)

while data:
# Обработка блока данных
process_data(data) # Замените на вашу логику обработки

# Чтение следующего блока
data = remote_file.read(chunk_size)

# Потоковая запись на сервер
with sftp_client.open('/remote/output_file.txt', 'w') as remote_file:
for i in range(1000):
line = f"Строка данных {i}\n"
remote_file.write(line)

sftp_client.close()
ssh_client.close()

import paramiko
import os
from dotenv import load_dotenv

# Загрузка переменных окружения из .env файла
load_dotenv()

host = os.getenv('SFTP_HOST')
username = os.getenv('SFTP_USERNAME')
password = os.getenv('SFTP_PASSWORD')

ssh_client = paramiko.SSHClient()
ssh_client.set_missing_host_key_policy(paramiko.AutoAddPolicy())
ssh_client.connect(hostname=host, username=username, password=password)

# Остальной код...

import paramiko
import hvac # Клиент для HashiCorp Vault

# Подключение к Vault
vault_client = hvac.Client(
url='https://vault.example.com:8200',
token='your-vault-token'
)

# Получение секретов
secrets = vault_client.secrets.kv.v2.read_secret_version(
path='sftp-credentials',
mount_point='secret'
)

host = secrets['data']['data']['host']
username = secrets['data']['data']['username']
password = secrets['data']['data']['password']

# Использование полученных учетных данных
ssh_client = paramiko.SSHClient()
ssh_client.set_missing_host_key_policy(paramiko.AutoAddPolicy())
ssh_client.connect(hostname=host, username=username, password=password)

# Остальной код...

#!/usr/bin/env python3
# daily_backup.py

import paramiko
import os
import datetime
import logging
from dotenv import load_dotenv

# Настройка логирования
logging.basicConfig(
filename='sftp_backup.log',
level=logging.INFO,
format='%(asctime)s – %(levelname)s – %(message)s'
)

load_dotenv()

try:
# Текущая дата для имени файла резервной копии
current_date = datetime.datetime.now().strftime('%Y-%m-%d')
backup_filename = f"backup_{current_date}.zip"

# Подключение к серверу
ssh_client = paramiko.SSHClient()
ssh_client.set_missing_host_key_policy(paramiko.AutoAddPolicy())
ssh_client.connect(
hostname=os.getenv('SFTP_HOST'),
username=os.getenv('SFTP_USERNAME'),
password=os.getenv('SFTP_PASSWORD')
)

sftp_client = ssh_client.open_sftp()

# Загрузка резервной копии
sftp_client.put(
f"/local/backups/{backup_filename}", 
f"/remote/backups/{backup_filename}"
)

# Очистка старых резервных копий (оставляем только 7 последних)
backup_list = sftp_client.listdir('/remote/backups/')
backup_files = [f for f in backup_list if f.startswith('backup_') and f.endswith('.zip')]

# Сортировка по дате (имена файлов содержат дату)
backup_files.sort()

# Удаление старых файлов, если их больше 7
if len(backup_files) > 7:
files_to_delete = backup_files[:-7] # Все кроме 7 последних
for file in files_to_delete:
sftp_client.remove(f"/remote/backups/{file}")
logging.info(f"Удален устаревший файл резервной копии: {file}")

sftp_client.close()
ssh_client.close()
logging.info(f"Резервное копирование успешно завершено: {backup_filename}")

except Exception as e:
logging.error(f"Ошибка при выполнении резервного копирования: {str(e)}")
# Возможно, отправка уведомления об ошибке

import paramiko
import time
import random
import logging

def sftp_operation_with_retry(max_retries=5, initial_backoff=1, max_backoff=60):
retry_count = 0

while retry_count < max_retries:
try:
# Подключение к серверу
ssh_client = paramiko.SSHClient()
ssh_client.set_missing_host_key_policy(paramiko.AutoAddPolicy())
ssh_client.connect(
hostname='example.com',
username='user',
password='password',
timeout=10
)

sftp_client = ssh_client.open_sftp()

# Выполнение SFTP операций
sftp_client.put('local_file.txt', '/remote/file.txt')

# Если операция успешна, выходим из цикла
sftp_client.close()
ssh_client.close()
return True

except (paramiko.SSHException, socket.error) as e:
retry_count += 1

if retry_count >= max_retries:
logging.error(f"Превышено максимальное количество попыток. Последняя ошибка: {str(e)}")
return False

# Экспоненциальное отступление с рандомным фактором
backoff = min(max_backoff, initial_backoff * (2 ** (retry_count – 1)))
# Добавляем случайный "шум" для предотвращения коллизий
jitter = random.uniform(0, 0.3 * backoff)
sleep_time = backoff + jitter

logging.warning(f"Попытка {retry_count} не удалась: {str(e)}. Следующая попытка через {sleep_time:.2f} секунд.")
time.sleep(sleep_time)