如何通过gRPC对接外部REST API？用Protobuf减少样板代码

Absolutely! You’re exactly asking about reverse gRPC gateway tools—solutions that bridge external REST APIs to your internal gRPC/Protobuf stack, eliminating the need to write tedious boilerplate for serialization, HTTP calls, and response parsing. These tools let you define your desired internal gRPC service interface, then handle all the translation between gRPC/Protobuf and external REST under the hood.

Here are the most practical options to achieve this:

1. Buf Connect #

Buf Connect is a modern, lightweight framework that supports bidirectional conversion between gRPC and REST. It’s perfect for your use case because it lets you:

• Define your gRPC service using standard Protobuf syntax (including google.api.http annotations, just like grpc-gateway).
• Generate a gRPC client that automatically converts gRPC method calls into REST requests (GET/POST/PUT/etc.), handles Protobuf ↔ JSON conversion, and maps HTTP responses back to Protobuf messages.
• Use interceptors to add common logic like authentication headers, error handling, or retries without touching your core application code.

Quick Example Workflow: #

1. Define your Protobuf service with REST mappings:

syntax = "proto3";

import "google/api/annotations.proto";

service ExternalUserService {
  rpc FetchUser(FetchUserRequest) returns (FetchUserResponse) {
    option (google.api.http) = {
      get: "/external-api/users/{user_id}"
    };
  }
}

message FetchUserRequest {
  string user_id = 1;
}

message FetchUserResponse {
  string full_name = 1;
  string email = 2;
  int32 age = 3;
}

2. Use Buf’s CLI to generate the client code for your language (Go, TypeScript, etc.).
3. In your internal app, call the generated gRPC client just like any other gRPC service:

client := externaluserserviceconnect.NewExternalUserServiceClient(
  http.DefaultClient,
  "https://external-api.example.com",
)

resp, err := client.FetchUser(ctx, connect.NewRequest(&FetchUserRequest{UserId: "123"}))
// resp.Msg is a fully deserialized FetchUserResponse Protobuf message

2. Envoy Proxy (For Service Mesh Scenarios) #

If you’re working in a service mesh environment, Envoy Proxy can act as a reverse gRPC gateway. You can configure Envoy to:

• Accept gRPC requests from your internal services.
• Translate them into REST requests to external APIs.
• Convert JSON responses back to Protobuf before sending them to your internal app.

This is ideal if you want centralized control over API traffic (rate limiting, authentication, logging) across all your external REST integrations.

3. Custom Protobuf Plugins #

If you need full control over the translation logic, you can use or build a Protobuf plugin to generate REST client code tied to your gRPC service definition. Community-maintained tools like protoc-gen-go-http can generate Go HTTP clients that mirror your gRPC service methods, handling all the serialization and HTTP call logic automatically.

Key Benefits of This Approach: #

• You maintain a single source of truth (your Protobuf definitions) for both internal gRPC contracts and external REST API integrations.
• No manual writing of HTTP clients, JSON unmarshaling, or Protobuf conversion code.
• Easy to update integrations: just modify the Protobuf definition and regenerate the client code.

Practical Tips #

• Use google.api.http annotations consistently to map gRPC methods to REST endpoints—this keeps your definitions clear and aligns with the same syntax grpc-gateway uses.
• Add interceptors to handle cross-cutting concerns: for example, inject API keys into HTTP headers, convert HTTP error codes to gRPC status codes, or add retries for flaky external APIs.
• Validate that the external REST API’s JSON schema aligns with your Protobuf definitions to avoid conversion issues—schema validation tools can help catch mismatches early.

内容的提问来源于stack exchange，提问作者Patrick Collins