Сетевые взаимодействия в Python: основные подходы

Асинхронный TCP сервер на asyncio

Для обработки множества клиентов без потоков используется asyncio. Пример эхо-сервера:

import asyncio

async def handle_client(reader, writer):
    data = await reader.read(100)
    message = data.decode()
    addr = writer.get_extra_info('peername')
    print(f'Получено от {addr}: {message}')
    writer.write(data)
    await writer.drain()
    writer.close()

async def main():
    server = await asyncio.start_server(handle_client, 'localhost', 9090)
    print('Сервер запущен')
    async with server:
        await server.serve_forever()

asyncio.run(main())

Результат (при подключении клиента):
Получено от ('127.0.0.1', 54321): Hello

Клиент для асинхронного сервера можно написать также с asyncio, используя asyncio.open_connection.

Передача больших файлов с разбиением на чанки

Для передачи файлов размером > 1 МБ данные отправляют частями. Пример сервера, принимающего файл и сохраняющего его:

# Сервер
import socket

HOST = 'localhost'
PORT = 9090
CHUNK_SIZE = 4096

sock = socket.socket()
sock.bind((HOST, PORT))
sock.listen(1)
print('Сервер ожидает файл...')
conn, addr = sock.accept()
with conn:
    with open('received_file.bin', 'wb') as f:
        while True:
            chunk = conn.recv(CHUNK_SIZE)
            if not chunk:
                break
            f.write(chunk)
print('Файл сохранён')

# Клиент
import socket, os

HOST = 'localhost'
PORT = 9090
CHUNK_SIZE = 4096

with open('large_file.bin', 'rb') as f:
    sock = socket.socket()
    sock.connect((HOST, PORT))
    while True:
        chunk = f.read(CHUNK_SIZE)
        if not chunk:
            break
        sock.sendall(chunk)
    sock.close()
print('Файл отправлен')

Шифрование данных с помощью SSL

Для безопасной передачи данных поверх TCP используется SSL/TLS. Пример клиента и сервера с самоподписанным сертификатом:

# Генерация сертификата (в командной строке):
# openssl req -x509 -newkey rsa:4096 -keyout key.pem -out cert.pem -days 365 -nodes

# Сервер
import socket, ssl

context = ssl.SSLContext(ssl.PROTOCOL_TLS_SERVER)
context.load_cert_chain('cert.pem', 'key.pem')

bindsocket = socket.socket()
bindsocket.bind(('localhost', 9090))
bindsocket.listen(5)

while True:
    newsocket, fromaddr = bindsocket.accept()
    conn = context.wrap_socket(newsocket, server_side=True)
    try:
        data = conn.recv(1024)
        print('Получено:', data.decode())
        conn.send(b'Hello, secure world!')
    finally:
        conn.shutdown(socket.SHUT_RDWR)
        conn.close()

# Клиент
import socket, ssl

context = ssl.create_default_context()
context.check_hostname = False
context.verify_mode = ssl.CERT_NONE  # для самоподписанного сертификата

sock = socket.socket()
conn = context.wrap_socket(sock, server_hostname='localhost')
conn.connect(('localhost', 9090))
conn.send(b'Secret message')
response = conn.recv(1024)
print('Ответ:', response.decode())
conn.close()

Передача объектов через pickle

Модуль pickle позволяет сериализовать произвольные объекты Python. Пример:

import socket, pickle

class MyData:
    def __init__(self, name, value):
        self.name = name
        self.value = value

obj = MyData('test', 42)
data = pickle.dumps(obj)

sock = socket.socket()
sock.connect(('localhost', 9090))
sock.sendall(data)

На стороне сервера объект восстанавливается через pickle.loads.

Многопоточный сервер для множества клиентов

Каждое соединение обрабатывается в отдельном потоке. Пример:

import socket, threading

def handle_client(conn):
    with conn:
        data = conn.recv(1024)
        print(f'Обработано: {data.decode()}')
        conn.sendall(data)
    print('Соединение закрыто')

sock = socket.socket()
sock.bind(('localhost', 9090))
sock.listen(5)
print('Сервер слушает...')
while True:
    conn, addr = sock.accept()
    threading.Thread(target=handle_client, args=(conn,)).start()

Клиент может подключаться несколько раз одновременно.