python | rpyc，一个超实用的 Python 库！

本文来源公众号“python”，仅用于学术分享，侵权删，干货满满。

原文链接：rpyc，一个超实用的 Python 库！

大家好，今天为大家分享一个超实用的 Python 库 - rpyc。

Github地址：https://github.com/tomerfiliba-org/rpyc

在分布式系统开发中，远程过程调用(RPC)是一项核心技术。Python的rpyc库提供了一个透明且强大的RPC实现，它允许一个Python程序无缝地调用另一个Python程序中的对象和函数，就像调用本地对象一样。这种透明性使得分布式系统的开发变得简单直观，同时保持了强大的功能性和灵活性。rpyc特别适合构建分布式应用、微服务架构以及远程管理系统。

安装

基础安装

使用pip包管理器可以简单快速地完成rpyc的安装：

pip install rpyc

基本功能

创建简单服务器

rpyc服务器是分布式系统的基础组件，它通过网络为客户端提供可调用的服务。使用ThreadedServer类可以支持多个客户端并发连接，每个连接在独立线程中处理，确保了系统的响应性。通过exposed_前缀标记的方法自动对客户端可见，提供了简单而安全的方法暴露机制。

import rpyc
from rpyc.utils.server import ThreadedServer

class CalculatorService(rpyc.Service):
    def exposed_add(self, a, b):
        return a + b
    
    def exposed_multiply(self, a, b):
        return a * b
    
    def exposed_divide(self, a, b):
        if b == 0:
            raise ValueError("除数不能为零")
        return a / b

# 启动服务器
server = ThreadedServer(CalculatorService, port=18861)
server.start()

客户端连接

rpyc客户端通过简单的网络连接访问远程服务。连接建立后，可以直接调用服务器暴露的方法，就像使用本地对象一样。系统自动处理了网络通信和错误处理，使开发者专注于业务逻辑实现而不是底层细节。

import rpyc

# 连接到远程服务器
conn = rpyc.connect("localhost", 18861)

# 调用远程服务
result_add = conn.root.add(5, 3)
print(f"5 + 3 = {result_add}")

result_multiply = conn.root.multiply(4, 6)
print(f"4 * 6 = {result_multiply}")

try:
    result_divide = conn.root.divide(10, 2)
    print(f"10 / 2 = {result_divide}")
except:
    print("计算出错")

# 关闭连接
conn.close()

异步操作

rpyc支持异步调用机制，适用于处理耗时操作。通过回调函数，客户端可以在等待远程操作完成时继续执行其他任务，提高了系统响应性和资源利用率。异步操作特别适合处理网络请求、文件操作或复杂计算等场景。

import rpyc
import time

class AsyncService(rpyc.Service):
    def exposed_long_operation(self):
        time.sleep(3)  # 模拟耗时操作
        return "操作完成"

    def exposed_async_operation(self, callback):
        def worker():
            time.sleep(3)  # 模拟耗时操作
            callback("异步操作完成")
        
        rpyc.spawn(worker)
        return "异步操作已启动"

# 客户端代码
def handle_result(result):
    print(f"收到结果: {result}")

conn = rpyc.connect("localhost", 18861)
async_result = conn.root.async_operation(handle_result)
print("继续执行其他操作...")

高级功能

服务注册与发现

在大型分布式系统中，服务的动态发现至关重要。rpyc提供了服务注册和发现机制，支持服务器自动注册到注册中心，客户端可以动态发现可用服务。这种机制简化了系统配置，提高了系统的可扩展性和容错能力。

import rpyc
from rpyc.utils.registry import UDPRegistryClient
from rpyc.utils.registry import REGISTRY_PORT

class RegisteredService(rpyc.Service):
    def exposed_get_service_name(self):
        return "计算服务"

def register_service():
    registry_client = UDPRegistryClient(port=REGISTRY_PORT)
    server = ThreadedServer(RegisteredService, 
                          port=18861,
                          auto_register=True)
    server.start()

# 客户端发现服务
def discover_services():
    registry_client = UDPRegistryClient(port=REGISTRY_PORT)
    services = registry_client.discover("计算服务")
    return services

安全配置

安全性是生产环境中的重要考虑因素。rpyc提供了全面的安全配置选项，包括SSL/TLS加密、身份认证和访问控制。通过这些机制，可以确保只有授权的客户端能够访问服务，并且所有通信都经过加密保护。

import rpyc
from rpyc.utils.authenticators import SSLAuthenticator

class SecureService(rpyc.Service):
    def exposed_secure_operation(self):
        return "安全操作执行完成"

def create_secure_server():
    # 配置SSL认证
    authenticator = SSLAuthenticator(
        "server.key",
        "server.crt",
        cert_reqs=ssl.CERT_REQUIRED,
        ca_certs="ca.crt"
    )
    
    server = ThreadedServer(
        SecureService,
        port=18861,
        authenticator=authenticator
    )
    server.start()

实际应用场景

分布式计算系统

在企业环境中，分布式计算系统可以有效处理大规模计算任务。使用rpyc可以构建任务分发和结果收集系统，支持动态任务分配和负载均衡。系统通过任务状态追踪和结果缓存确保可靠性，特别适合数据分析等计算密集型应用。

import rpyc
import multiprocessing

class ComputeService(rpyc.Service):
    def __init__(self):
        self.tasks = {}
        self.results = {}
        
    def exposed_submit_task(self, task_id, data):
        def process_task(data):
            # 模拟复杂计算
            result = sum(x * x for x in data)
            self.results[task_id] = result
            
        self.tasks[task_id] = multiprocessing.Process(
            target=process_task,
            args=(data,)
        )
        self.tasks[task_id].start()
        return f"任务 {task_id} 已提交"
    
    def exposed_get_result(self, task_id):
        if task_id in self.results:
            return self.results[task_id]
        elif task_id in self.tasks:
            return "处理中"
        return "任务不存在"

# 使用示例
class ComputeClient:
    def __init__(self, host, port):
        self.conn = rpyc.connect(host, port)
        
    def submit_computation(self, task_id, data):
        return self.conn.root.submit_task(task_id, data)
        
    def check_result(self, task_id):
        return self.conn.root.get_result(task_id)

远程监控系统

远程监控系统是企业级应用中的重要组成部分。使用rpyc可以构建集中化的系统监控平台，实时监控服务器状态、资源使用和进程运行情况。系统支持远程管理操作，通过权限控制和审计机制确保安全性。

import rpyc
import psutil
import platform

class MonitoringService(rpyc.Service):
    def exposed_get_system_info(self):
        return {
            "platform": platform.platform(),
            "cpu_count": psutil.cpu_count(),
            "memory_total": psutil.virtual_memory().total,
            "disk_usage": psutil.disk_usage('/').percent
        }
    
    def exposed_get_process_list(self):
        processes = []
        for proc in psutil.process_iter(['pid', 'name', 'cpu_percent']):
            try:
                processes.append(proc.info)
            except (psutil.NoSuchProcess, psutil.AccessDenied):
                pass
        return processes
    
    def exposed_kill_process(self, pid):
        try:
            psutil.Process(pid).terminate()
            return f"进程 {pid} 已终止"
        except psutil.NoSuchProcess:
            return f"进程 {pid} 不存在"

# 监控客户端
class MonitorClient:
    def __init__(self, host, port):
        self.conn = rpyc.connect(host, port)
        
    def monitor_system(self):
        system_info = self.conn.root.get_system_info()
        processes = self.conn.root.get_process_list()
        return system_info, processes
        
    def terminate_process(self, pid):
        return self.conn.root.kill_process(pid)

总结

Python rpyc库为分布式系统开发提供了一个强大而灵活的解决方案。它的透明远程调用机制简化了分布式编程的复杂性，使开发者能够专注于业务逻辑而不是底层实现细节。通过提供服务注册、安全认证等高级特性，rpyc能够满足各种企业级应用的需求。对于需要构建分布式系统的Python开发者来说，rpyc是一个值得信赖的工具库，它不仅提高了开发效率，还确保了系统的可靠性和可扩展性。

THE END !

文章结束，感谢阅读。您的点赞，收藏，评论是我继续更新的动力。大家有推荐的公众号可以评论区留言，共同学习，一起进步。