Python gRPC 微服务实践:构建高性能分布式服务架构

Python gRPC 在高性能微服务架构中的实践 gRPC 是一种现代的远程过程调用(Remote Procedure Call, RPC)框架,它基于 HTTP/2 协议,支持多种编程语言。与传统的 RESTful API 不同,gRPC 使用 Protocol Buffers(简称 Protobuf)作为接口定义语言(IDL),并通过代码生成工具自动生成客户端和服务端的代码。这种机制不仅提高了开发效率,还保证了跨语言调用的一致性。Protobuf 是一种高效的数据序列化格式,相比于 JSON 或 XML,它具有更小的体积和更快的解析速度。 阅读详情

Python gRPC 微服务实践:构建高性能分布式服务架构

引言

在现代微服务架构中,gRPC已成为高性能服务间通信的首选方案。作为一名从Rust转向Python的后端开发者,我深刻体会到gRPC在构建高效、跨语言微服务方面的优势。gRPC基于HTTP/2协议,提供了强大的性能和丰富的功能特性。

gRPC 核心概念

什么是gRPC

gRPC是一个高性能、开源的远程过程调用(RPC)框架,具有以下特点:

  • 高性能:基于HTTP/2协议,支持多路复用和流传输
  • 强类型:使用Protocol Buffers定义接口,提供编译时类型检查
  • 跨语言:支持多种编程语言,便于多语言微服务协作
  • 双向流:支持客户端和服务端的双向流式通信

架构设计

┌─────────────────────────────────────────────────────────────┐
│                    gRPC 客户端                              │
│  ┌─────────────────────────────────────────────────────┐   │
│  │  调用 stub.方法名(request)                         │   │
│  └─────────────────────────┬─────────────────────────┘   │
└─────────────────────────────┼─────────────────────────────┘
                              │ HTTP/2 请求
                              ▼
┌─────────────────────────────────────────────────────────────┐
│                    gRPC 服务端                              │
│  ┌─────────────────────────────────────────────────────┐   │
│  │  实现 service 接口 → 处理请求 → 返回响应            │   │
│  └─────────────────────────────────────────────────────┘   │
└─────────────────────────────────────────────────────────────┘

环境搭建与基础配置

安装依赖

pip install grpcio grpcio-tools

定义 Proto 文件

// service.proto
syntax = "proto3";

package example;

service UserService {
  rpc GetUser(GetUserRequest) returns (UserResponse);
  rpc CreateUser(CreateUserRequest) returns (UserResponse);
  rpc UpdateUser(UpdateUserRequest) returns (UserResponse);
  rpc DeleteUser(DeleteUserRequest) returns (DeleteUserResponse);
  rpc ListUsers(ListUsersRequest) returns (stream UserResponse);
  rpc BatchCreateUsers(stream CreateUserRequest) returns (BatchCreateResponse);
}

message User {
  string id = 1;
  string name = 2;
  string email = 3;
  int32 age = 4;
  string created_at = 5;
}

message GetUserRequest {
  string user_id = 1;
}

message UserResponse {
  User user = 1;
}

message CreateUserRequest {
  string name = 1;
  string email = 2;
  int32 age = 3;
}

message UpdateUserRequest {
  string user_id = 1;
  optional string name = 2;
  optional string email = 3;
  optional int32 age = 4;
}

message DeleteUserRequest {
  string user_id = 1;
}

message DeleteUserResponse {
  bool success = 1;
}

message ListUsersRequest {
  int32 page = 1;
  int32 page_size = 2;
}

message BatchCreateResponse {
  int32 created_count = 1;
  repeated User users = 2;
}

生成代码

python -m grpc_tools.protoc -I./protos \
  --python_out=. \
  --grpc_python_out=. \
  ./protos/service.proto

服务端实现

基础服务实现

import grpc
from concurrent import futures
import time
import service_pb2
import service_pb2_grpc

class UserService(service_pb2_grpc.UserServiceServicer):
    def __init__(self):
        self.users = {}
        self.counter = 0
    
    def GetUser(self, request, context):
        user_id = request.user_id
        if user_id not in self.users:
            context.set_code(grpc.StatusCode.NOT_FOUND)
            context.set_details("User not found")
            return service_pb2.UserResponse()
        
        user = self.users[user_id]
        return service_pb2.UserResponse(
            user=service_pb2.User(
                id=user['id'],
                name=user['name'],
                email=user['email'],
                age=user['age'],
                created_at=user['created_at']
            )
        )
    
    def CreateUser(self, request, context):
        self.counter += 1
        user_id = f"user-{self.counter}"
        user = {
            'id': user_id,
            'name': request.name,
            'email': request.email,
            'age': request.age,
            'created_at': time.strftime("%Y-%m-%dT%H:%M:%SZ")
        }
        self.users[user_id] = user
        
        return service_pb2.UserResponse(
            user=service_pb2.User(**user)
        )
    
    def UpdateUser(self, request, context):
        user_id = request.user_id
        if user_id not in self.users:
            context.set_code(grpc.StatusCode.NOT_FOUND)
            context.set_details("User not found")
            return service_pb2.UserResponse()
        
        user = self.users[user_id]
        if request.name:
            user['name'] = request.name
        if request.email:
            user['email'] = request.email
        if request.age:
            user['age'] = request.age
        
        return service_pb2.UserResponse(
            user=service_pb2.User(**user)
        )
    
    def DeleteUser(self, request, context):
        user_id = request.user_id
        if user_id not in self.users:
            context.set_code(grpc.StatusCode.NOT_FOUND)
            context.set_details("User not found")
            return service_pb2.DeleteUserResponse(success=False)
        
        del self.users[user_id]
        return service_pb2.DeleteUserResponse(success=True)

def serve():
    server = grpc.server(futures.ThreadPoolExecutor(max_workers=10))
    service_pb2_grpc.add_UserServiceServicer_to_server(UserService(), server)
    server.add_insecure_port('[::]:50051')
    server.start()
    print("Server started on port 50051")
    server.wait_for_termination()

if __name__ == '__main__':
    serve()

客户端实现

同步客户端

import grpc
import service_pb2
import service_pb2_grpc

def run():
    with grpc.insecure_channel('localhost:50051') as channel:
        stub = service_pb2_grpc.UserServiceStub(channel)
        
        # 创建用户
        create_response = stub.CreateUser(
            service_pb2.CreateUserRequest(
                name="张三",
                email="zhangsan@example.com",
                age=25
            )
        )
        print(f"创建用户: {create_response.user.id}, {create_response.user.name}")
        
        # 获取用户
        get_response = stub.GetUser(
            service_pb2.GetUserRequest(user_id=create_response.user.id)
        )
        print(f"获取用户: {get_response.user.name}, {get_response.user.email}")
        
        # 更新用户
        update_response = stub.UpdateUser(
            service_pb2.UpdateUserRequest(
                user_id=create_response.user.id,
                name="李四",
                age=26
            )
        )
        print(f"更新用户: {update_response.user.name}, {update_response.user.age}")
        
        # 删除用户
        delete_response = stub.DeleteUser(
            service_pb2.DeleteUserRequest(user_id=create_response.user.id)
        )
        print(f"删除用户: {delete_response.success}")

if __name__ == '__main__':
    run()

流式传输实战

服务端流式RPC

def ListUsers(self, request, context):
    page = request.page
    page_size = request.page_size
    start = (page - 1) * page_size
    end = start + page_size
    
    user_list = list(self.users.values())[start:end]
    
    for user in user_list:
        yield service_pb2.UserResponse(
            user=service_pb2.User(**user)
        )

客户端流式RPC

def BatchCreateUsers(self, request_iterator, context):
    created_users = []
    
    for request in request_iterator:
        self.counter += 1
        user_id = f"user-{self.counter}"
        user = {
            'id': user_id,
            'name': request.name,
            'email': request.email,
            'age': request.age,
            'created_at': time.strftime("%Y-%m-%dT%H:%M:%SZ")
        }
        self.users[user_id] = user
        created_users.append(service_pb2.User(**user))
    
    return service_pb2.BatchCreateResponse(
        created_count=len(created_users),
        users=created_users
    )

双向流式RPC

# 服务端
def Chat(self, request_iterator, context):
    for request in request_iterator:
        yield service_pb2.ChatResponse(
            message=f"Received: {request.message}",
            timestamp=time.strftime("%Y-%m-%dT%H:%M:%SZ")
        )

# 客户端
def chat():
    channel = grpc.insecure_channel('localhost:50051')
    stub = service_pb2_grpc.ChatServiceStub(channel)
    
    def generate_messages():
        messages = ["Hello", "How are you?", "Goodbye"]
        for msg in messages:
            yield service_pb2.ChatRequest(message=msg)
    
    responses = stub.Chat(generate_messages())
    for response in responses:
        print(f"Server: {response.message}")

高级特性

认证与授权

def authenticate(context):
    metadata = dict(context.invocation_metadata())
    if 'authorization' not in metadata:
        context.set_code(grpc.StatusCode.UNAUTHENTICATED)
        context.set_details("Missing authorization token")
        return None
    
    token = metadata['authorization'].replace('Bearer ', '')
    # 验证token
    if token != 'valid-token':
        context.set_code(grpc.StatusCode.PERMISSION_DENIED)
        context.set_details("Invalid token")
        return None
    
    return token

class UserService(service_pb2_grpc.UserServiceServicer):
    def GetUser(self, request, context):
        token = authenticate(context)
        if not token:
            return service_pb2.UserResponse()
        
        # 正常处理逻辑
        ...

超时与重试

# 客户端设置超时
channel = grpc.insecure_channel('localhost:50051')
stub = service_pb2_grpc.UserServiceStub(channel)

try:
    response = stub.GetUser(
        service_pb2.GetUserRequest(user_id='user-1'),
        timeout=5  # 5秒超时
    )
except grpc.RpcError as e:
    if e.code() == grpc.StatusCode.DEADLINE_EXCEEDED:
        print("请求超时")
    else:
        print(f"RPC错误: {e}")

拦截器

class LoggingInterceptor(grpc.ServerInterceptor):
    def intercept_service(self, continuation, handler_call_details):
        print(f"Received request: {handler_call_details.method}")
        start_time = time.time()
        
        response = continuation(handler_call_details)
        
        elapsed = time.time() - start_time
        print(f"Request completed in {elapsed:.2f}s")
        
        return response

server = grpc.server(
    futures.ThreadPoolExecutor(max_workers=10),
    interceptors=[LoggingInterceptor()]
)

实际业务场景

场景一:订单服务

class OrderService(service_pb2_grpc.OrderServiceServicer):
    def __init__(self):
        self.user_stub = service_pb2_grpc.UserServiceStub(
            grpc.insecure_channel('user-service:50051')
        )
    
    def CreateOrder(self, request, context):
        # 调用用户服务验证用户
        try:
            user_response = self.user_stub.GetUser(
                service_pb2.GetUserRequest(user_id=request.user_id)
            )
        except grpc.RpcError as e:
            context.set_code(grpc.StatusCode.FAILED_PRECONDITION)
            context.set_details("User not found")
            return service_pb2.OrderResponse()
        
        # 创建订单
        order = {
            'id': f"order-{time.time()}",
            'user_id': request.user_id,
            'items': request.items,
            'total_amount': sum(item.price * item.quantity for item in request.items),
            'status': 'pending'
        }
        
        return service_pb2.OrderResponse(order=service_pb2.Order(**order))

场景二:分布式追踪

import opentelemetry
from opentelemetry import trace
from opentelemetry.sdk.trace import TracerProvider
from opentelemetry.instrumentation.grpc import GrpcInstrumentor

trace.set_tracer_provider(TracerProvider())
tracer = trace.get_tracer(__name__)

GrpcInstrumentor().instrument()

with tracer.start_as_current_span("create-order"):
    response = stub.CreateOrder(request)

性能优化

连接池配置

options = [
    ('grpc.max_send_message_length', 1024 * 1024 * 100),  # 100MB
    ('grpc.max_receive_message_length', 1024 * 1024 * 100),
    ('grpc.keepalive_time_ms', 30000),
    ('grpc.keepalive_timeout_ms', 5000)
]

channel = grpc.insecure_channel('localhost:50051', options=options)

异步客户端

import asyncio
import grpc
from grpc.experimental import aio

async def async_client():
    async with aio.insecure_channel('localhost:50051') as channel:
        stub = service_pb2_grpc.UserServiceStub(channel)
        response = await stub.GetUser(
            service_pb2.GetUserRequest(user_id='user-1')
        )
        print(f"User: {response.user.name}")

asyncio.run(async_client())

总结

gRPC为Python后端开发者提供了构建高性能微服务的强大工具。通过Protocol Buffers的强类型定义和HTTP/2的高效传输,gRPC在性能和开发体验上都表现出色。从Rust开发者的角度来看,gRPC的类型安全和高性能特性与Rust的设计理念非常契合。

在实际项目中,建议合理设计服务接口,使用流式RPC处理大数据传输,并结合监控和追踪工具保证系统的可观测性。

Golang 结合 gRPC:构建高可用的分布式服务 在当今的软件开发领域,分布式系统变得越来越重要。随着业务规模的不断扩大,单体应用逐渐难以满足高并发、高可用和可扩展性的需求。Golang 作为一种高效、简洁且并发性能优秀的编程语言,与 gRPC 这一高性能、开源的远程过程调用(RPC)框架相结合,可以为构建高可用的分布式服务提供强大的支持。本文的目的是全面介绍如何使用 Golang 结合 gRPC 来构建高可用的分布式服务。我们将涵盖从基础概念到实际项目开发的各个方面,包括 gRPC 的原理、核心算法、数学模型、项目实战以及实际应用场景等内容。 阅读详情

相关推荐

Python 解析 gRPC 在高性能 API 设计中的应用

gRPC 是由 Google 开发的一种远程过程调用(RPC)框架,它允许客户端和服务端通过定义好的接口进行通信。gRPC 支持多种编程语言,包括 Python、Java、Go 等。基于 HTTP/2 协议,支持双向流和多路复用。使用 Protobuf 定义服务接口和数据结构。跨语言支持,方便不同语言的服务端和客户端进行交互。强大的错误处理机制和元数据支持。首先,我们需要定义一个 .proto 文件来描述服务接口和数据结构。

2501_91163674的博客 1792

构建高性能微服务架构:基于Kubernetes与gRPC的深度实践

本文探讨了如何通过gRPC+Kubernetes构建高性能微服务架构,解决企业级应用面临的五大核心挑战。文章提出四层解耦模型,包括协议解耦(API Gateway处理HTTP/1.1,内部采用gRPC)、控制平面分离、数据平面增强和基础设施抽象。通过双流程图对比展示gRPC相比REST在性能上的显著优势(延迟降低300%,带宽消耗减少315%),并提供了Python gRPC服务端和TypeScript客户端的实现示例。该架构已在金融科技领域生产环境验证,有效提升了微服务通信效率和系统稳定性。

嵌入式毕设/课设资料清单(速查手册·文档模板·题库,持续更新)→ 见最新文章 869

并行计算:从概念起源到多层次架构设计及其发展历程的全面解析

20世纪70年代,第一台并行计算机于1972年产生(ILLIAC IV,伊利诺依大学),由64个处理器组成,可扩展性好,但可编程性差。如有21亩地需要除草,一个人一天只能除一亩地的草,那么需要21天才能除完草,这在现实中是不太可能的,因庄稼是有时间段的。其二是机群系统是高性能计算机的一种,它的技术基础和工业基础都是商品化和标准化。之所以称为“专用”,并不是说它们只能运行某种应用,是指它们的组成部件是专门设计的,它们的CPU板、内存板和I/O板,甚至操作系统,都是不能在其它系统中使用的。

1656

Python的微服务架构:如何使用gRPC和Protocol Buffers构建高性能微服务。

我们了解了 gRPC 和 Protocol Buffers 的优势,学习了如何定义服务接口和数据结构,如何生成 gRPC 代码,如何实现 gRPC 服务端和客户端,以及如何使用流式传输。掌握这些知识,你就可以开始构建自己的高性能微服务应用了。gRPC 是一个高性能、开源的通用 RPC 框架,而 Protocol Buffers 是一种高效的序列化协议,它们是构建高效微服务架构的理想选择。通过清晰的 API 定义、高效的通信协议和强大的代码生成能力,它们简化了微服务开发,并提高了应用的整体性能。

weixin_41455464的博客 702

ArcGIS+PLUS+InVEST三件套实战:从零搞定土地利用变化与碳储量预测(附完整数据包)

本文详细介绍了如何整合ArcGIS、PLUS模型和InVEST模型,构建土地利用变化与碳储量预测的完整研究流水线。通过多情景模拟和生态系统服务评估,提供从数据准备到结果验证的实战指南,助力研究者高效完成生态评估项目。

weixin_30399821的博客 545

STM32G0——USB虚拟串口

STM32G0用cubeMX配置实现USB虚拟串口

阿昌 2323

Python微服务架构与gRPC

1.背景介绍 1. 背景介绍 微服务架构是一种软件架构风格,它将单个应用程序拆分成多个小服务,每个服务运行在自己的进程中,通过网络间通信来协同工作。这种架构风格的出现,主要是为了解决传统大型单体应用程序的一些问题,如可扩展性、可维护性、稳定性等。 gRPC是一种高性能、开源的RPC(远程过程调用)框架,它使用Protocol Buffers作为接口定义语言,可以在多种编程语言间进行无缝通信。...

AI天才研究院 899

PR控制以及使用PR控制用于单相离/并网逆变器

最近想学习一下并网逆变器,需要用到PR控制,全网找遍了许多学习资料,终于掌握的差不多了,在此做个记录,以及个人对PR(Proportional Resonant)控制的理解。在去年7月准备电赛的时候偶然看到有几篇讲解数字滤波器,第一次接触传递函数离散化,深刻被数字时代的数字方式折服,改改代码,就可以实现不同的截至频率,甚至不同阶数,而模拟方式还要改元器件。当时就感觉这玩意太他妈牛逼了,很想学懂它,奈何学不会呀。后面全身心做电赛,就忘了这事儿。直至最近学习PR控制,当初的感觉又回来了,一股劲儿吃下来了。

xht2403267701的博客 3万+

掌握 gRPC:从安装到构建第一个C++ 和Python微服务

文章首先介绍了 gRPC 的基本概念和与传统通信方法的对比,然后详细指导如何在不同操作系统上安装 gRPC。通过具体的 C++ 和 Python 项目案例,我们展示了如何编写、编译和运行 gRPC 服务端和客户端,为读者提供了实际的操作步骤和代码示例。

m0_51661400的博客 5626

机器学习预测土壤养分:从电导率、pH到随机森林与神经网络的农业实践

在智慧农业与精准农业领域,机器学习已成为处理复杂农业数据、挖掘潜在规律的关键技术。其核心原理在于通过算法从多维数据中自动学习特征与目标变量之间的映射关系,尤其擅长捕捉非线性关联。这项技术的核心价值在于能够将传统上依赖昂贵、耗时实验室分析的问题(如土壤养分检测),转化为基于易获取传感器数据(如电导率、pH值)的快速、低成本预测任务,为农业生产的实时决策与资源优化提供了全新可能。其典型应用场景包括作物生长监测、产量预测以及精准施肥管理等。本文聚焦于利用随机森林和神经网络等回归算法,构建通过土壤物理参数预测氮磷钾

weixin_33693070的博客 670

如何在R语言中使用Logistic回归模型

在日常学习或工作中经常会使用线性回归模型对某一事物进行预测,例如预测房价、身高、GDP、学生成绩等,发现这些被预测的变量都属于连续型变量。然而有些情况下,被预测变量可能是二元变量,即成功或失败、流失或不流失、涨或跌等,对于这类问题,线性回归将束手无策。这个时候就需要另一种回归方法进行预测,即Logistic回归。 在实际应用中,Logistic模型主要有三大用途: 1)寻找危险因素,找到某些影响...

weixin_34056162的博客 9552

从0到1:用Protocol Buffers与gRPC构建高性能微服务架构

你是否还在为JSON序列化的性能瓶颈而烦恼?是否在寻找一种跨语言、易维护的服务通信方案?本文将带你一文掌握Protocol Buffers(协议缓冲区)与gRPC的核心技术,通过实战案例实现微服务架构的性能飞跃。读完本文你将获得: - 掌握Protobuf数据结构定义与代码生成 - 实现基于gRPC的同步/异步服务调用 - 构建支持多语言的微服务通信层 - 性能优化与生产环境部署最佳实践 ##

gitblog_00383的博客 1067

手把手教你 Ubuntu 24.04 离线安装 Ollama

本文介绍 Ubuntu 下离线安装 Ollama 并使用 Ollama 部署 llama3.1-70b 大模型

举世誉之而不加劝,举世非之而不加沮,定乎内外之分,辩乎荣辱之境,斯已矣。 1021

NGINX Ingress Controller gRPC服务支持:构建高性能微服务架构

在当今云原生和微服务架构盛行的时代,**gRPC**已经成为构建高性能分布式系统的首选协议。NGINX Ingress Controller通过其强大的**gRPC服务支持**功能,为Kubernetes环境中的微服务提供了完整的负载均衡和流量管理解决方案。 ## 为什么选择gRPC进行微服务通信? gRPC作为现代微服务架构的核心通信协议,具有以下显著优势: - **高性能**:基于HTT

gitblog_00470的博客 699

2025年华为杯中国研究生数学建模竞赛C题 围岩裂隙精准识别与三维模型重构 思路+代码

report += f"**位置 {i+1}**: ({loc[0]:.1f}, {loc[1]:.1f}, {loc[2]:.1f})\n"# ==================== 高级U-Net模型 ====================# ==================== 数据预处理与增强 ====================# ==================== 采样方法比较分析 ====================

YOLO 1528

LinePhone3.2.7(android端最新版本) sip客户端

SIP客户端For android:LinePhone3.2.7(最新版本),官网地址:http://www.linphone.org/

组网第63课:安全域划分——Trust/Untrust/DMZ、区域模型、与 VLAN 的关系

一组接口 + 一组策略 + 一条默认拒绝。一组接口:这个域包含哪些物理口、VLAN、子接口;一组策略:这个域到别的域放行什么、拒绝什么;一条默认拒绝:没写进策略的,一律不通。第三条最关键。没有默认拒绝,前面划的域全是装饰。

qq_36765170的博客 572

老版QQ原生表情gif动态

这是老版的QQ表情,不过全是动态的的,Windows照片查看器是不会动的,可以右击用浏览器打开查看,再说一遍是老版的,只是分享给宁愿用老版也要动态的人。

上一篇: Python Kafka 消息队列实战:构建高可用分布式消息系统
下一篇: Python etcd 配置中心实战:构建分布式配置管理系统
第一程序员
博客等级 码龄1年 1万+粉丝 1827原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值