如何在不共享模块文件的前提下从另一Docker调用自定义Python模块

下面是几种成熟的实现方案，无需直接共享模块文件，完全通过通信机制实现跨镜像调用：

1. 封装成HTTP API服务（最通用） #

把你的Python模块包装成HTTP接口，通过网络请求实现调用，这是最易上手的方案：

• 模块镜像端操作：用FastAPI或Flask搭建简单API服务，示例用FastAPI：

from fastapi import FastAPI
import your_python_module  # 你的功能模块

app = FastAPI()

# 定义接口，映射到模块功能
@app.post("/invoke/process-data")
def process_data(input_str: str):
    result = your_python_module.process(input_str)
    return {"output": result}

启动容器时暴露端口（比如docker run -p 8000:8000 --name module-api your-module-image），同时建议把容器加入自定义Docker网络（docker network create app-net，启动时加--net app-net）。

• 调用方镜像端操作：用requests库发送HTTP请求即可，无需任何模块文件：

import requests

# 同一网络内直接用容器名访问，跨主机则用宿主机IP+端口
response = requests.post(
    "http://module-api:8000/invoke/process-data",
    json={"input_str": "test data"}
)
print(response.json()["output"])

2. 使用gRPC实现高效RPC调用 #

如果对通信性能要求高（比如大量数据交互），gRPC比HTTP更高效：

• 定义服务协议：先写.proto文件描述服务和方法：

syntax = "proto3";

service ModuleService {
  rpc ProcessData (DataRequest) returns (DataResponse);
}

message DataRequest {
  string input = 1;
}

message DataResponse {
  string output = 1;
}

• 模块镜像端：用grpcio-tools生成服务端代码，实现功能并启动服务：

import grpc
import concurrent.futures as futures
from your_proto_module import module_service_pb2, module_service_pb2_grpc
import your_python_module

class ModuleService(module_service_pb2_grpc.ModuleServiceServicer):
    def ProcessData(self, request, context):
        result = your_python_module.process(request.input)
        return module_service_pb2.DataResponse(output=result)

def serve():
    server = grpc.server(futures.ThreadPoolExecutor(max_workers=10))
    module_service_pb2_grpc.add_ModuleServiceServicer_to_server(ModuleService(), server)
    server.add_insecure_port("[::]:50051")
    server.start()
    server.wait_for_termination()

if __name__ == "__main__":
    serve()

• 调用方镜像端：生成客户端代码，发起gRPC调用：

import grpc
from your_proto_module import module_service_pb2, module_service_pb2_grpc

def run():
    with grpc.insecure_channel("module-grpc:50051") as channel:
        stub = module_service_pb2_grpc.ModuleServiceStub(channel)
        response = stub.ProcessData(module_service_pb2.DataRequest(input="test data"))
    print("Received result:", response.output)

if __name__ == "__main__":
    run()

3. 同一宿主机内用Unix套接字通信 #

如果两个容器在同一宿主机，Unix套接字是轻量无端口的通信方式：

• 模块镜像端：基于Unix套接字实现服务：

import socket
import your_python_module

# 定义套接字路径，注意要挂载到宿主机共享目录
SOCKET_PATH = "/shared/socket/module.sock"

# 启动套接字服务
sock = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
sock.bind(SOCKET_PATH)
sock.listen(1)

while True:
    conn, addr = sock.accept()
    try:
        data = conn.recv(1024).decode("utf-8")
        result = your_python_module.process(data)
        conn.sendall(result.encode("utf-8"))
    finally:
        conn.close()

启动容器时挂载宿主机目录：docker run -v /host/shared/socket:/shared/socket --name module-socket your-module-image

• 调用方镜像端：同样挂载该目录，连接套接字发起请求：

import socket

SOCKET_PATH = "/shared/socket/module.sock"

sock = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
sock.connect(SOCKET_PATH)
sock.sendall("test data".encode("utf-8"))
result = sock.recv(1024).decode("utf-8")
print("Result:", result)
sock.close()

关键注意事项 #

• 权限控制：不管用哪种方式，都要加认证（比如API加API Key、gRPC加TLS、套接字设置文件权限），防止未授权调用
• 网络配置：优先使用Docker自定义网络，比默认bridge网络更安全，且支持容器名解析
• 跨主机场景：HTTP/gRPC方案更适合，可配合反向代理或容器编排工具（K8s/Swarm）做服务发现

内容的提问来源于stack exchange，提问作者Arun Kumar