Что такое RPC?

RPC: удалённый вызов процедур

RPC (Remote Procedure Call) — это механизм, который позволяет программе вызывать функции (процедуры) на удалённом компьютере так, как будто они вызываются локально. Это абстракция сетевого взаимодействия, скрывающая сложность сетевого протокола под простым интерфейсом функций.

Суть RPC

Вместо того, чтобы вручную отправлять сетевые пакеты и обрабатывать ответы, программист просто пишет:

# Локально выглядит просто
result = remote_server.calculate(a=10, b=20)
print(result)  # 30

Под капотом RPC:

1. Сериализует аргументы (10, 20)
2. Отправляет запрос по сети
3. Удалённый сервер вызывает функцию
4. Возвращает результат
5. Десериализует и возвращает клиенту

Как RPC работает (клиент-серверная модель)

Клиент                              Сервер
  │                                   │
  ├─ calculate(a=10, b=20)           │
  │  (сериализация аргументов)       │
  ├─ Отправляет HTTP/TCP запрос ────→│
  │                                   ├─ Десериализует
  │                                   ├─ Вызывает calculate(10, 20)
  │                                   ├─ Получает result = 30
  │                                   ├─ Сериализует ответ
  │                    ←──── Отправляет ответ
  ├─ Получает и десериализует        │
  │  result = 30                      │
  │                                   │

Примеры RPC в реальной жизни

1. XML-RPC (старый стандарт)

# Клиент
import xmlrpc.client

server = xmlrpc.client.ServerProxy('http://localhost:8000')
print(server.add(2, 3))  # 5

# Сервер
from xmlrpc.server import SimpleXMLRPCServer

def add(a, b):
    return a + b

server = SimpleXMLRPCServer(('localhost', 8000))
server.register_function(add, 'add')
server.serve_forever()

2. JSON-RPC 2.0 (современный стандарт)

Отправляется запрос:

{
  "jsonrpc": "2.0",
  "method": "subtract",
  "params": [42, 23],
  "id": 1
}

Получается ответ:

{
  "jsonrpc": "2.0",
  "result": 19,
  "id": 1
}

Пример с Python:

import requests
import json

# Клиент
def call_rpc(method, params):
    payload = {
        "jsonrpc": "2.0",
        "method": method,
        "params": params,
        "id": 1
    }
    response = requests.post('http://localhost:8000', json=payload)
    return response.json()['result']

result = call_rpc('subtract', [42, 23])
print(result)  # 19

3. gRPC (Google RPC, современный и быстрый)

gRPC использует Protocol Buffers и HTTP/2 для высокой производительности:

# Определение сервиса (service.proto)
service Calculator {
  rpc Add(Numbers) returns (Result) {}
}

message Numbers {
  int32 a = 1;
  int32 b = 2;
}

message Result {
  int32 value = 1;
}

# Сервер
from concurrent import futures
import grpc
from service_pb2_grpc import CalculatorServicer

class CalculatorService(CalculatorServicer):
    def Add(self, request, context):
        return Result(value=request.a + request.b)

server = grpc.server(futures.ThreadPoolExecutor(max_workers=10))
server.add_CalculatorServicer_to_server(CalculatorService(), server)
server.add_insecure_port('[::]:50051')
server.start()
server.wait_for_termination()

# Клиент
import grpc
from service_pb2 import Numbers

channel = grpc.insecure_channel('localhost:50051')
stub = CalculatorStub(channel)
response = stub.Add(Numbers(a=10, b=20))
print(response.value)  # 30

RPC vs REST API

RPC подход:

# Всё через вызовы методов
result = server.calculate(10, 20)
user = server.get_user(user_id=123)
server.delete_user(user_id=123)

REST подход:

# Всё через HTTP методы на ресурсы
result = POST /api/calculate {"a": 10, "b": 20}
user = GET /api/users/123
DELETE /api/users/123

Таблица сравнения:

Когда использовать RPC

Хорошо для:

• Внутренних сервисов (микросервисы)
• Высокопроизводительных систем (gRPC)
• Простых CRUD операций
• Интеграция с наследованными системами

Плохо для:

• Публичных API
• Кэширования
• Если нужна самодокументируемость

Проблемы RPC

1. Сетевые ошибки — что если сервер недоступен?

try:
    result = server.calculate(10, 20)
except ConnectionError:
    print("Сервер недоступен")

1. Latency — сетевой запрос медленнее, чем локальный вызов

2. Версионирование — как обновить API без наличия клиентов?

Современные RPC-подобные технологии

• gRPC — высокопроизводительный RPC (Protocol Buffers + HTTP/2)
• GraphQL — гибридный подход (запрашиваешь нужные данные)
• OpenRPC — стандартизация JSON-RPC API
• tRPC — типизированный RPC для TypeScript

Вывод

RPC — это удобный способ скрыть сетевое взаимодействие под локальным интерфейсом функций. В современном веке gRPC вытесняет старые XML-RPC и JSON-RPC благодаря высокой производительности, но REST API остаются стандартом для публичных интернет-сервисов.