gRPC 安全

概述

gRPC 是 Google 开源的高性能远程过程调用（RPC）框架，基于 Protocol Buffers（protobuf）进行序列化，运行于 HTTP/2 协议之上。与传统的 RESTful API 相比，gRPC 在安全层面既有天然的协议优势，也面临独特的挑战。

gRPC 与 REST 的安全差异点：

维度	REST（HTTP/1.1）	gRPC（HTTP/2）
传输层	可选 TLS，可明文	强制或强烈建议 TLS
序列化	JSON（文本，可读）	Protobuf（二进制，难阅读）
接口契约	OpenAPI 文档（描述性）	protobuf 定义（强制性）
认证方式	Header/Bearer Token	拦截器 + Metadata
消息边界	请求/响应一一对应	Stream 多消息复用

gRPC 基于 HTTP/2 的隐式安全特性包括：二进制分帧层天然防止 HTTP 请求走私、头部压缩（HPACK）降低信息泄露风险、单连接多路复用减少连接劫持面。然而，这些仅是传输层面的基础保障，生产中仍需构建完整的纵深防御体系。

---

TLS 双向认证（mTLS）

概述

TLS（Transport Layer Security）是 gRPC 通信加密的基础。与 HTTPS 类似，gRPC 使用 TLS 保护数据传输的机密性和完整性。双向 TLS（mTLS）在此之上要求客户端也出示证书，实现服务端与客户端的双向身份验证。

证书体系

在 mTLS 架构中，需要三组证书：

• CA 根证书（ca.crt）：签发服务端和客户端证书的根证书颁发机构
• 服务端证书（server.crt + server.key）：由 CA 签发，用于验证服务端身份
• 客户端证书（client.crt + client.key）：由 CA 签发，用于验证客户端身份

证书链验证

gRPC 在握手阶段执行以下验证：

1. 服务端向客户端出示 server.crt，客户端使用 ca.crt 验证其合法性
2. 客户端向服务端出示 client.crt，服务端使用 ca.crt 验证其合法性
3. 双方校验证书的 CN/SAN 是否匹配目标主机名
4. 验证证书有效期、吊销状态等

服务端 mTLS 配置示例

Go 语言

package main

import (
    "crypto/tls"
    "crypto/x509"
    "google.golang.org/grpc"
    "google.golang.org/grpc/credentials"
    "os"
)

func loadServerTLSCredentials() (credentials.TransportCredentials, error) {
    // 加载 CA 根证书，用于验证客户端证书
    caCert, err := os.ReadFile("certs/ca.crt")
    if err != nil {
        return nil, err
    }
    caCertPool := x509.NewCertPool()
    caCertPool.AppendCertsFromPEM(caCert)

    // 加载服务端证书和私钥
    serverCert, err := tls.LoadX509KeyPair("certs/server.crt", "certs/server.key")
    if err != nil {
        return nil, err
    }

    tlsConfig := &tls.Config{
        Certificates: []tls.Certificate{serverCert},
        ClientAuth:   tls.RequireAndVerifyClientCert, // 要求并验证客户端证书
        ClientCAs:    caCertPool,
        MinVersion:   tls.VersionTLS12,
    }

    return credentials.NewTLS(tlsConfig), nil
}

func main() {
    tlsCreds, err := loadServerTLSCredentials()
    if err != nil {
        panic(err)
    }

    s := grpc.NewServer(
        grpc.Creds(tlsCreds),
    )
    // 注册服务...
}

Java 语言

import io.grpc.Server;
import io.grpc.netty.shaded.io.grpc.netty.GrpcSslContexts;
import io.grpc.netty.shaded.io.grpc.netty.NettyServerBuilder;
import io.netty.handler.ssl.ClientAuth;
import io.netty.handler.ssl.SslContextBuilder;
import java.io.File;

public class GrpcMtlsServer {

    public static void main(String[] args) throws Exception {
        SslContextBuilder sslContext = GrpcSslContexts.forServer(
                new File("certs/server.crt"),
                new File("certs/server.key")
            )
            .trustManager(new File("certs/ca.crt"))
            .clientAuth(ClientAuth.REQUIRE);

        Server server = NettyServerBuilder.forPort(8443)
            .sslContext(sslContext.build())
            .addService(new GreetingServiceImpl())
            .build()
            .start();

        System.out.println("gRPC mTLS 服务端已启动，端口: 8443");
        server.awaitTermination();
    }
}

客户端 mTLS 配置示例

Go 语言

package main

import (
    "crypto/tls"
    "crypto/x509"
    "google.golang.org/grpc"
    "google.golang.org/grpc/credentials"
    "os"
)

func loadClientTLSCredentials() (credentials.TransportCredentials, error) {
    // 加载 CA 证书用于验证服务端
    caCert, err := os.ReadFile("certs/ca.crt")
    if err != nil {
        return nil, err
    }
    caCertPool := x509.NewCertPool()
    caCertPool.AppendCertsFromPEM(caCert)

    // 加载客户端证书（发给服务端验证）
    clientCert, err := tls.LoadX509KeyPair("certs/client.crt", "certs/client.key")
    if err != nil {
        return nil, err
    }

    tlsConfig := &tls.Config{
        Certificates: []tls.Certificate{clientCert},
        RootCAs:      caCertPool,
        MinVersion:   tls.VersionTLS12,
        ServerName:   "grpc.example.com", // 必须与证书 CN/SAN 一致
    }

    return credentials.NewTLS(tlsConfig), nil
}

func main() {
    tlsCreds, err := loadClientTLSCredentials()
    if err != nil {
        panic(err)
    }

    conn, err := grpc.Dial("server.example.com:8443",
        grpc.WithTransportCredentials(tlsCreds),
    )
    if err != nil {
        panic(err)
    }
    defer conn.Close()
    // 通过 conn 发起 RPC 调用...
}

Java 语言

import io.grpc.ManagedChannel;
import io.grpc.netty.shaded.io.grpc.netty.GrpcSslContexts;
import io.grpc.netty.shaded.io.grpc.netty.NettyChannelBuilder;
import io.netty.handler.ssl.SslContextBuilder;
import java.io.File;

public class GrpcMtlsClient {

    public static void main(String[] args) throws Exception {
        SslContextBuilder sslContext = GrpcSslContexts.forClient()
            .trustManager(new File("certs/ca.crt"))
            .keyManager(
                new File("certs/client.crt"),
                new File("certs/client.key")
            );

        ManagedChannel channel = NettyChannelBuilder
            .forAddress("server.example.com", 8443)
            .sslContext(sslContext.build())
            .overrideAuthority("grpc.example.com")
            .build();

        // 通过 channel 发起 RPC 调用...
        channel.shutdown();
    }
}

---

拦截器鉴权（Interceptor）

概述

gRPC 拦截器（Interceptor）是 AOP（面向切面编程）在 gRPC 中的实现，允许在 RPC 调用前后注入横切逻辑。拦截器是实现认证鉴权的核心机制，分为两种类型：

• Unary 拦截器：拦截一元 RPC 调用（请求-响应模式）
• Stream 拦截器：拦截流式 RPC 调用（服务端流、客户端流、双向流）

JWT 令牌验证流程

1. 客户端在 Metadata 中携带 JWT Token
2. 服务端拦截器提取 Metadata 中的 Authorization 头
3. 验证 JWT 签名、有效期、签发者等声明
4. 将解析后的用户信息注入 Context 上下文
5. 业务方法从 Context 中获取用户身份

Go Unary 拦截器实现

package interceptor

import (
    "context"
    "strings"
    "google.golang.org/grpc"
    "google.golang.org/grpc/codes"
    "google.golang.org/grpc/metadata"
    "google.golang.org/grpc/status"
)

// AuthInterceptor 认证拦截器
type AuthInterceptor struct {
    jwtSecret     string
    adminMethods  map[string]bool // 需要管理员权限的方法
}

func NewAuthInterceptor(secret string) *AuthInterceptor {
    return &AuthInterceptor{
        jwtSecret:    secret,
        adminMethods: make(map[string]bool),
    }
}

// Unary 返回一元拦截器
func (a *AuthInterceptor) Unary() grpc.UnaryServerInterceptor {
    return func(ctx context.Context, req interface{},
        info *grpc.UnaryServerInfo, handler grpc.UnaryHandler) (interface{}, error) {

        md, ok := metadata.FromIncomingContext(ctx)
        if !ok {
            return nil, status.Errorf(codes.Unauthenticated, "缺少 Metadata")
        }

        token, err := extractToken(md)
        if err != nil {
            return nil, status.Errorf(codes.Unauthenticated, "缺少令牌: %v", err)
        }

        // 验证 JWT（此处为简化示例，生产应使用库如 golang-jwt）
        claims, err := validateJWT(token, a.jwtSecret)
        if err != nil {
            return nil, status.Errorf(codes.Unauthenticated, "令牌无效: %v", err)
        }

        // RBAC 权限校验
        if a.adminMethods[info.FullMethod] && claims.Role != "admin" {
            return nil, status.Errorf(codes.PermissionDenied, "权限不足")
        }

        // 将用户信息注入 Context
        newCtx := context.WithValue(ctx, "user_id", claims.UserID)
        newCtx = context.WithValue(newCtx, "role", claims.Role)

        return handler(newCtx, req)
    }
}

func extractToken(md metadata.MD) (string, error) {
    values := md.Get("authorization")
    if len(values) == 0 {
        return "", status.Errorf(codes.Unauthenticated, "authorization 头缺失")
    }
    token := values[0]
    if strings.HasPrefix(token, "Bearer ") {
        return token[7:], nil
    }
    return token, nil
}

Go Stream 拦截器实现

func (a *AuthInterceptor) Stream() grpc.StreamServerInterceptor {
    return func(srv interface{}, stream grpc.ServerStream,
        info *grpc.StreamServerInfo, handler grpc.StreamHandler) error {

        ctx := stream.Context()
        md, ok := metadata.FromIncomingContext(ctx)
        if !ok {
            return status.Errorf(codes.Unauthenticated, "缺少 Metadata")
        }

        token, err := extractToken(md)
        if err != nil {
            return err
        }

        claims, err := validateJWT(token, a.jwtSecret)
        if err != nil {
            return status.Errorf(codes.Unauthenticated, "令牌无效: %v", err)
        }

        // 包装 stream，使业务方法可读取用户信息
        wrapped := &wrappedStream{
            ServerStream: stream,
            ctx:          context.WithValue(ctx, "user_id", claims.UserID),
        }
        return handler(srv, wrapped)
    }
}

type wrappedStream struct {
    grpc.ServerStream
    ctx context.Context
}

func (w *wrappedStream) Context() context.Context {
    return w.ctx
}

Java Unary 拦截器实现

import io.grpc.*;
import io.jsonwebtoken.Claims;
import io.jsonwebtoken.Jws;
import io.jsonwebtoken.Jwts;
import io.jsonwebtoken.security.Keys;
import javax.crypto.SecretKey;
import java.nio.charset.StandardCharsets;

public class AuthInterceptor implements ServerInterceptor {

    private final SecretKey secretKey;
    private final Set<String> adminMethods;

    public AuthInterceptor(String jwtSecret, Set<String> adminMethods) {
        this.secretKey = Keys.hmacShaKeyFor(jwtSecret.getBytes(StandardCharsets.UTF_8));
        this.adminMethods = adminMethods;
    }

    @Override
    public <ReqT, RespT> ServerCall.Listener<ReqT> interceptCall(
            ServerCall<ReqT, RespT> call,
            Metadata headers,
            ServerCallHandler<ReqT, RespT> next) {

        // 提取 Authorization 头
        String authHeader = headers.get(Metadata.Key.of(
            "authorization", Metadata.ASCII_STRING_MARSHALLER));
        if (authHeader == null || !authHeader.startsWith("Bearer ")) {
            call.close(Status.UNAUTHENTICATED.withDescription("缺少令牌"), new Metadata());
            return new ServerCall.Listener<ReqT>() {};
        }

        String token = authHeader.substring(7);
        try {
            Jws<Claims> jws = Jwts.parser()
                .verifyWith(secretKey)
                .build()
                .parseSignedClaims(token);

            Claims claims = jws.getPayload();
            String role = claims.get("role", String.class);
            String methodName = call.getMethodDescriptor().getFullMethodName();

            // RBAC 权限校验
            if (adminMethods.contains(methodName) && !"admin".equals(role)) {
                call.close(Status.PERMISSION_DENIED.withDescription("权限不足"), new Metadata());
                return new ServerCall.Listener<ReqT>() {};
            }

            // 将用户信息存入 Context
            Context context = Context.current()
                .withValue(USER_ID_KEY, claims.getSubject())
                .withValue(ROLE_KEY, role);

            return Contexts.interceptCall(context, call, headers, next);

        } catch (Exception e) {
            call.close(Status.UNAUTHENTICATED
                .withDescription("令牌无效: " + e.getMessage()), new Metadata());
            return new ServerCall.Listener<ReqT>() {};
        }
    }

    private static final Context.Key<String> USER_ID_KEY =
        Context.keyWithDefault("user-id", "unknown");
    private static final Context.Key<String> ROLE_KEY =
        Context.keyWithDefault("role", "anonymous");
}

Java 服务端注册拦截器

import io.grpc.Server;
import io.grpc.ServerInterceptors;
import java.util.Set;

public class GrpcServerWithAuth {

    public static void main(String[] args) throws Exception {
        AuthInterceptor authInterceptor = new AuthInterceptor(
            "your-256-bit-secret",
            Set.of("proto.GreetingService/SayHello")
        );

        Server server = ServerBuilder.forPort(8443)
            .addService(ServerInterceptors.intercept(
                new GreetingServiceImpl(), authInterceptor))
            .build()
            .start();

        server.awaitTermination();
    }
}

客户端携带 Token

Go 客户端

import (
    "context"
    "google.golang.org/grpc"
    "google.golang.org/grpc/metadata"
)

func unaryCallWithToken(conn *grpc.ClientConn, token string) error {
    md := metadata.Pairs(
        "authorization", "Bearer " + token,
    )
    ctx := metadata.NewOutgoingContext(context.Background(), md)

    client := pb.NewGreetingServiceClient(conn)
    _, err := client.SayHello(ctx, &pb.HelloRequest{Name: "Alice"})
    return err
}

Java 客户端

import io.grpc.ManagedChannel;
import io.grpc.ManagedChannelBuilder;
import io.grpc.Metadata;
import io.grpc.stub.MetadataUtils;

public class GrpcClientWithAuth {

    public static void main(String[] args) {
        ManagedChannel channel = ManagedChannelBuilder
            .forAddress("localhost", 8443)
            .usePlaintext()
            .build();

        Metadata headers = new Metadata();
        headers.put(
            Metadata.Key.of("authorization", Metadata.ASCII_STRING_MARSHALLER),
            "Bearer your-jwt-token"
        );

        GreetingServiceGrpc.GreetingServiceBlockingStub stub =
            GreetingServiceGrpc.newBlockingStub(channel)
                .withInterceptors(MetadataUtils.newAttachHeadersInterceptor(headers));

        HelloResponse response = stub.sayHello(
            HelloRequest.newBuilder().setName("Alice").build());
    }
}

---

安全网关

gRPC-Web 安全考虑

gRPC-Web 允许浏览器端通过 HTTP/1.1 调用 gRPC 服务，但引入了一些安全约束：

• CORS 配置：必须正确设置跨域规则，限制来源域
• TLS 终端：gRPC-Web 代理应在边缘层终止 TLS 并提供证书
• 不支持客户端流：浏览器客户端仅支持一元和服务端流，减少了攻击面
• Token 传递：通过 Authorization 头传递凭据，需防范 XSS 窃取

Envoy gRPC 代理安全配置

Envoy 是 Istio 数据平面的核心代理，也常作为 gRPC 的反向代理。以下是一个融合了 TLS 与 RBAC 的配置片段：

static_resources:
  listeners:
  - name: grpc_listener
    address:
      socket_address: { address: 0.0.0.0, port_value: 443 }
    filter_chains:
    - filter_chain_match:
        transport_protocol: tls
      transport_socket:
        name: envoy.transport_sockets.tls
        typed_config:
          "@type": type.googleapis.com/envoy.extensions.transport_sockets.tls.v3.DownstreamTlsContext
          common_tls_context:
            tls_certificates:
            - certificate_chain: { filename: "/etc/envoy/certs/server.crt" }
              private_key: { filename: "/etc/envoy/certs/server.key" }
            validation_context:
              trusted_ca: { filename: "/etc/envoy/certs/ca.crt" }
      filters:
      - name: envoy.filters.network.rbac
        typed_config:
          "@type": type.googleapis.com/envoy.extensions.filters.network.rbac.v3.RBAC
          rules:
            action: ALLOW
            policies:
              allow_grpc_clients:
                permissions:
                - any: true
                principals:
                - authenticated:
                    principal_name:
                      exact: "spiffe://example.com/client"
      - name: envoy.filters.network.http_connection_manager
        typed_config:
          "@type": type.googleapis.com/envoy.extensions.filters.network.http_connection_manager.v3.HttpConnectionManager
          codec_type: AUTO
          stat_prefix: grpc
          route_config:
            name: local_route
            virtual_hosts:
            - name: grpc
              domains: ["*"]
              routes:
              - match: { prefix: "/" }
                route:
                  cluster: grpc_backend
                  timeout: 30s
          http_filters:
          - name: envoy.filters.http.router

该配置实现了：

• 下游（客户端到 Envoy）TLS 终止
• 基于 SPIFFE 身份的 RBAC 访问控制
• gRPC 请求路由到后端集群

gRPC Gateway

gRPC Gateway 是将 RESTful JSON API 转换为 gRPC 调用的代理工具。在安全层面需关注：

• TLS 转换：Gateway 既可作为 TLS 终端，也可在向后转发时启用 mTLS
• 认证透传：将 REST 请求的 JWT/ApiKey 映射为 gRPC Metadata
• 输入校验：REST 接口接收 JSON，转换为 protobuf 时的字段校验不容忽视，防止畸形数据绕过验证

---

传输安全

HTTP/2 的 TLS 强制

虽然 HTTP/2 规范定义了对明文（h2c）的支持，但所有主流浏览器和 gRPC 实现均要求或强烈建议使用 TLS。gRPC 官方仅支持基于 TLS 的 HTTP/2，明文仅用于开发调试。

生产环境必须启用 TLS，且禁止降级到 h2c。Go 中可通过 grpc.WithTransportCredentials(insecure.NewCredentials()) 明确禁止明文连接。

ALPN 协商

ALPN（Application-Layer Protocol Negotiation）是 TLS 扩展，允许客户端和服务器在 TLS 握手时协商应用层协议。gRPC 使用 h2 作为 ALPN 标识符：

Client: ALPN = ["h2", "http/1.1"]
Server: ALPN = ["h2"]  → 协商结果为 h2（HTTP/2）

Go 中配置 ALPN：

tlsConfig := &tls.Config{
    NextProtos: []string{"h2", "http/1.1"},
    // ...
}

Java Netty 中默认启用 ALPN 协商，无需手动配置。

Cipher Suite 配置

选择安全的密码套件是 TLS 配置的核心环节。推荐使用的 cipher suite：

推荐套件（Go 示例）：

tlsConfig := &tls.Config{
    CipherSuites: []uint16{
        tls.TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256,
        tls.TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384,
        tls.TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256,
        tls.TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384,
        tls.TLS_CHACHA20_POLY1305_SHA256,
    },
    MinVersion: tls.VersionTLS12,
    MaxVersion: tls.VersionTLS13,
}

需禁用的弱套件：

• TLS_RSA_WITH_AES_128_CBC_SHA（不支持前向安全）
• TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA（CBC 模式易受 Padding Oracle 攻击）
• 所有 RC4、3DES、RC2 套件

Java Netty 中设置 cipher suite：

SslContextBuilder builder = GrpcSslContexts.forServer(cert, key)
    .ciphers(Arrays.asList(
        "TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256",
        "TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384",
        "TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256",
        "TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384"
    ), IdentityCipherSuiteFilter.INSTANCE)
    .protocols("TLSv1.2", "TLSv1.3");

---

请求验证

Protobuf 字段校验

gRPC 在反序列化阶段会进行 protobuf 定义的类型校验，但这不足以应对业务安全需求。推荐使用 protoc-gen-validate（PGV）生成字段校验规则。

定义带校验规则的 protobuf：

syntax = "proto3";

package example;

import "validate/validate.proto";

service UserService {
    rpc CreateUser (CreateUserRequest) returns (CreateUserResponse);
}

message CreateUserRequest {
    string username = 1 [(validate.rules).string = {
        min_len: 3,
        max_len: 32,
        pattern: "^[a-zA-Z0-9_]+$"
    }];
    string email = 2 [(validate.rules).string.email = true];
    int32  age    = 3 [(validate.rules).int32 = {gte: 1, lte: 150}];
    string phone  = 4 [(validate.rules).string = {
        pattern: "^1[3-9]\\d{9}$"
    }];
}

Go 中使用 PGV 校验

import (
    "context"
    "google.golang.org/grpc/codes"
    "google.golang.org/grpc/status"
    "example.com/proto"
)

func (s *UserServer) CreateUser(ctx context.Context, req *pb.CreateUserRequest) (*pb.CreateUserResponse, error) {
    // 自动调用 protoc-gen-validate 生成的 Validate 方法
    if err := req.Validate(); err != nil {
        return nil, status.Errorf(codes.InvalidArgument,
            "请求参数校验失败: %v", err)
    }
    // 业务逻辑...
}

Java 中使用 PGV 校验

import io.grpc.Status;
import io.grpc.StatusRuntimeException;

public class UserServiceImpl extends UserServiceGrpc.UserServiceImplBase {

    @Override
    public void createUser(CreateUserRequest request,
                           StreamObserver<CreateUserResponse> responseObserver) {
        try {
            // protoc-gen-validate 生成的校验方法
            com.example.validator.UserValidator.validateCreateUserRequest(request);
        } catch (Exception e) {
            responseObserver.onError(
                Status.INVALID_ARGUMENT
                    .withDescription("参数校验失败: " + e.getMessage())
                    .asRuntimeException()
            );
            return;
        }
        // 业务逻辑...
    }
}

自定义验证规则

对于 PGV 无法覆盖的场景（如数据库唯一性校验、跨字段依赖校验），可通过拦截器或业务层实现：

func validateCreateUser(req *pb.CreateUserRequest) error {
    if req.Username == req.Email {
        return status.Errorf(codes.InvalidArgument,
            "用户名不能与邮箱相同")
    }
    return nil
}

拒绝无效/超大数据包

gRPC 默认消息大小为 4 MB。应根据业务场景调整限制，防止内存耗尽攻击：

Go 设置消息大小限制：

import "google.golang.org/grpc"

// 服务端限制
s := grpc.NewServer(
    grpc.MaxRecvMsgSize(1024 * 1024),       // 1 MB 接收限制
    grpc.MaxSendMsgSize(1024 * 1024),       // 1 MB 发送限制
)

// 客户端限制
conn, err := grpc.Dial("server:8443",
    grpc.WithDefaultCallOptions(
        grpc.MaxCallRecvMsgSize(1024 * 1024),
        grpc.MaxCallSendMsgSize(512 * 1024),
    ),
)

Java 设置消息大小限制：

Server server = NettyServerBuilder.forPort(8443)
    .maxInboundMessageSize(1024 * 1024) // 1 MB
    .build();

ManagedChannel channel = NettyChannelBuilder.forAddress("server", 8443)
    .maxInboundMessageSize(1024 * 1024)
    .build();

---

限流与熔断

gRPC 内置重试策略

gRPC 支持客户端内置重试和 hedging（对冲请求），需谨慎配置以防止放大攻击负载：

Go 重试配置：

import (
    "google.golang.org/grpc"
    "google.golang.org/grpc/credentials/insecure"
    "google.golang.org/grpc/keepalive"
)

conn, err := grpc.Dial("server:8443",
    grpc.WithTransportCredentials(insecure.NewCredentials()),
    grpc.WithDefaultServiceConfig(`{
        "methodConfig": [{
            "name": [{"service": "example.UserService"}],
            "retryPolicy": {
                "maxAttempts": 3,
                "initialBackoff": "0.1s",
                "maxBackoff": "1s",
                "backoffMultiplier": 2,
                "retryableStatusCodes": ["UNAVAILABLE"]
            }
        }]
    }`),
)

注意事项：

• 重试仅对幂等方法启用
• 限制最大尝试次数（通常不超过 3 次）
• 设置指数退避，避免重试风暴
• 不可对 Unavailable 以外的错误码启用重试

自适应限流

gRPC 提供了基于客户端视野的自适应限流（Client-Side Adaptive Throttling），算法源自 Google SRE 实践：

import (
    "google.golang.org/grpc"
    "google.golang.org/grpc/balancer"
)

// 启用自适应限流
conn, err := grpc.Dial("server:8443",
    grpc.WithDefaultServiceConfig(`{
        "loadBalancingConfig": [{
            "round_robin": {}
        }],
        "methodConfig": [{
            "name": [{"service": ""}],
            "retryThrottling": {
                "maxTokens": 10,
                "tokenRatio": 0.5
            }
        }]
    }`),
)

服务端也可以基于令牌桶（Token Bucket）算法限流，防止单个客户端耗尽资源：

Java 服务端限流（基于 RateLimiter）：

import com.google.common.util.concurrent.RateLimiter;
import io.grpc.*;

public class RateLimitInterceptor implements ServerInterceptor {

    private final RateLimiter rateLimiter;

    public RateLimitInterceptor(double permitsPerSecond) {
        this.rateLimiter = RateLimiter.create(permitsPerSecond);
    }

    @Override
    public <ReqT, RespT> ServerCall.Listener<ReqT> interceptCall(
            ServerCall<ReqT, RespT> call,
            Metadata headers,
            ServerCallHandler<ReqT, RespT> next) {

        if (!rateLimiter.tryAcquire()) {
            call.close(Status.RESOURCE_EXHAUSTED
                .withDescription("请求过于频繁，请稍后再试"), new Metadata());
            return new ServerCall.Listener<ReqT>() {};
        }
        return next.startCall(call, headers);
    }
}

连接池管理

适当的连接池配置可避免资源耗尽：

Go 连接配置：

import (
    "google.golang.org/grpc"
    "google.golang.org/grpc/keepalive"
    "time"
)

conn, err := grpc.Dial("server:8443",
    grpc.WithKeepaliveParams(keepalive.ClientParameters{
        Time:                10 * time.Second,  // 每 10s 发送 ping
        Timeout:             1 * time.Second,   // ping 超时
        PermitWithoutStream: false,             // 无活动流时不发 ping
    }),
    grpc.WithConnectionTimeout(5 * time.Second),
)

Java 连接配置：

ManagedChannel channel = NettyChannelBuilder.forAddress("server", 8443)
    .keepAliveTime(10, java.util.concurrent.TimeUnit.SECONDS)
    .keepAliveTimeout(1, java.util.concurrent.TimeUnit.SECONDS)
    .keepAliveWithoutCalls(false)
    .idleTimeout(30, java.util.concurrent.TimeUnit.MINUTES)
    .build();

服务端同样需要配置 keepalive 策略，拒绝长时间无活动的连接：

import "google.golang.org/grpc/keepalive"

s := grpc.NewServer(
    grpc.KeepaliveParams(keepalive.ServerParameters{
        MaxConnectionIdle:     5 * time.Minute,   // 空闲 5 分钟断开
        MaxConnectionAge:      30 * time.Minute,   // 最长存活 30 分钟
        MaxConnectionAgeGrace: 5 * time.Second,    // 宽限期
        Time:                  2 * time.Hour,      // ping 间隔
        Timeout:               20 * time.Second,   // ping 超时
    }),
    grpc.KeepaliveEnforcementPolicy(keepalive.EnforcementPolicy{
        MinTime:             5 * time.Second,      // 最小 ping 间隔
        PermitWithoutStream: false,
    }),
)

---

总结

gRPC 安全是一个系统工程，贯穿传输层、身份层、授权层和业务层。生产环境中应遵循以下原则：

1. 传输层：强制 TLS 1.2+，使用强 cipher suite，可选 mTLS 实现双向认证
2. 身份层：通过拦截器统一处理 JWT/OAuth2 认证，避免认证逻辑散落在业务方法中
3. 授权层：实现 RBAC 或 ABAC 权限模型，在拦截器层面统一校验
4. 网关层：在边缘代理（Envoy/Nginx）上实现 TLS 终止和访问控制，降低内部服务安全负担
5. 业务层：利用 protoc-gen-validate 做字段校验，设置合理的消息大小上限
6. 弹性层：配置限流、重试（指数退避）和连接管理策略，防止资源耗尽

纵深防御、最小权限、默认安全——这三个原则贯穿了 gRPC 安全体系的所有环节，也是保障微服务通信安全的基石。