FastAPI + gRPC 全栈实践：Windows 开发到 Ubuntu 部署全指南

技术博客标题：

《FastAPI + gRPC 全栈实践：Windows 开发到 Ubuntu 部署全指南》

---

环境搭建与开发流程

一、Windows 11 开发环境搭建

1. 安装 Python 3.9+

   • 官网下载安装包：Python Downloads
   • 勾选 Add Python to PATH

2. 创建虚拟环境

   python -m venv fastenv
   fastenv\Scripts\activate
   

3. 安装依赖

   pip install fastapi uvicorn[standard] grpcio grpcio-tools protobuf requests
   

---

二、项目结构

FASTAPI_GRPC_DEMO/
├── server/                  # 服务端代码
│   ├── main.py              # FastAPI 主入口
│   ├── grpc_server.py       # gRPC 服务实现
│   └── protos/              # Proto 文件目录
│       └── demo.proto
├── client/                  # 客户端代码
│   ├── rest_client.py       # REST 测试客户端
│   └── grpc_client.py       # gRPC 测试客户端
└── generated/               # 自动生成的 gRPC 代码

---

三、服务端开发

1. 定义 gRPC Proto 文件 (server/protos/demo.proto)

syntax = "proto3";

package demo;

service DemoService {
  rpc GetMessage (Request) returns (Response) {}
}

message Request {
  string name = 1;
}

message Response {
  string message = 1;
}

2. 生成 gRPC 代码

python -m grpc_tools.protoc -I server/protos/ \
  --python_out=generated \
  --grpc_python_out=generated \
  server/protos/demo.proto

3. 实现 gRPC 服务 (server/grpc_server.py)

from concurrent import futures
import grpc
from generated import demo_pb2, demo_pb2_grpc

class DemoService(demo_pb2_grpc.DemoServiceServicer):
    def GetMessage(self, request, context):
        return demo_pb2.Response(
            message=f"gRPC: Hello {request.name}!"
        )

def serve():
    server = grpc.server(futures.ThreadPoolExecutor(max_workers=10))
    demo_pb2_grpc.add_DemoServiceServicer_to_server(DemoService(), server)
    server.add_insecure_port("[::]:50051")
    server.start()
    print("gRPC Server running on port 50051")
    server.wait_for_termination()

4. 实现 REST 服务 (server/main.py)

from fastapi import FastAPI
import threading
from grpc_server import serve as run_grpc_server

app = FastAPI()

# 启动 gRPC 服务的线程
grpc_thread = threading.Thread(target=run_grpc_server, daemon=True)
grpc_thread.start()

@app.get("/hello/{name}")
async def hello(name: str):
    return {"message": f"REST: Hello {name}!"}

---

四、客户端测试

1. REST 客户端 (client/rest_client.py)

import requests

response = requests.get("http://localhost:8000/hello/FastAPI")
print("REST Response:", response.json())

2. gRPC 客户端 (client/grpc_client.py)

import grpc
from generated import demo_pb2, demo_pb2_grpc

channel = grpc.insecure_channel('localhost:50051')
stub = demo_pb2_grpc.DemoServiceStub(channel)
response = stub.GetMessage(demo_pb2.Request(name="gRPC"))
print("gRPC Response:", response.message)

---

五、运行与测试

1. 启动服务端

   uvicorn server.main:app --reload --port 8000
   

   • 输出：gRPC Server running on port 50051

2. 测试 REST API

   python client/rest_client.py
   # 输出: REST Response: {'message': 'REST: Hello FastAPI!'}
   

3. 测试 gRPC

   python client/grpc_client.py
   # 输出: gRPC Response: gRPC: Hello gRPC!
   

---

六、Ubuntu 24 部署

1. 服务器准备

# 更新系统
sudo apt update && sudo apt upgrade -y

# 安装 Python
sudo apt install python3.10-venv python3-pip -y

2. 部署应用

# 克隆代码
git clone https://your-repo-url.git
cd FASTAPI_GRPC_DEMO

# 创建虚拟环境
python3 -m venv venv
source venv/bin/activate

# 安装依赖
pip install -r requirements.txt

# 生成 gRPC 代码
python -m grpc_tools.protoc -I server/protos/ \
  --python_out=generated \
  --grpc_python_out=generated \
  server/protos/demo.proto

3. 使用 Systemd 管理服务

创建服务文件 /etc/systemd/system/fastapi-grpc.service：

[Unit]
Description=FastAPI + gRPC Service
After=network.target

[Service]
User=ubuntu
WorkingDirectory=/opt/FASTAPI_GRPC_DEMO
ExecStart=/opt/FASTAPI_GRPC_DEMO/venv/bin/uvicorn server.main:app \
  --host 0.0.0.0 --port 8000
Restart=always

[Install]
WantedBy=multi-user.target

4. 启动服务

sudo systemctl daemon-reload
sudo systemctl start fastapi-grpc
sudo systemctl enable fastapi-grpc

---

七、供 .NET Core 调用的接口说明

1. REST API

• Endpoint: GET /hello/{name}
• 请求示例:

  using var client = new HttpClient();
  var response = await client.GetAsync("http://your-ip:8000/hello/NetCore");
  var content = await response.Content.ReadAsStringAsync();
  // 输出: {"message": "REST: Hello NetCore!"}
  

2. gRPC 调用

1. 将 demo.proto 添加到 .NET 项目
2. 安装 NuGet 包：

   Install-Package Grpc.Net.Client
   Install-Package Google.Protobuf
   

3. 调用示例:

   using var channel = GrpcChannel.ForAddress("http://your-ip:50051");
   var client = new DemoService.DemoServiceClient(channel);
   var reply = client.GetMessage(new Request { Name = "NetCore" });
   Console.WriteLine(reply.Message); // 输出: "gRPC: Hello NetCore!"
   

---

关键点说明

1. 双协议支持：
   • REST 使用 FastAPI 原生支持
   • gRPC 通过独立线程运行
2. 跨平台部署：
   • Windows 开发环境快速测试
   • Ubuntu 生产环境用 Systemd 守护进程
3. .NET Core 集成：
   • REST 直接通过 HTTP 调用
   • gRPC 需通过 Proto 文件生成客户端