如何在Node.js的gRPC中实现重试机制？相关疑问求助

一、原生重试机制状态 #

当前官方的@grpc/grpc-js（新版Node.js gRPC库）已经原生支持重试功能，2018年的Stack Overflow回答针对的是早期开发版本，目前原生重试已正式落地，但官方文档的Node.js相关内容确实不够完善。

原生重试仅支持非流式Unary RPC，配置方式如下：

const grpc = require('@grpc/grpc-js');
const protoLoader = require('@grpc/proto-loader');

// 加载编译后的proto或直接加载proto文件
const packageDefinition = protoLoader.loadSync('your_service.proto');
const serviceProto = grpc.loadPackageDefinition(packageDefinition);

// 构造客户端时配置重试策略
const client = new serviceProto.YourService('localhost:50051', grpc.credentials.createInsecure(), {
  retryPolicy: {
    maxAttempts: 3,                // 最大重试次数
    initialBackoff: '1s',          // 初始退避时间
    maxBackoff: '5s',              // 退避时间上限
    backoffMultiplier: 2,          // 退避时间乘数（指数退避）
    retryableStatusCodes: [        // 触发重试的gRPC状态码
      grpc.status.UNAVAILABLE,
      grpc.status.RESOURCE_EXHAUSTED
    ]
  }
});

二、自定义拦截器实现重试（适用于流式RPC/复杂逻辑） #

如果原生配置无法满足需求（比如流式RPC、自定义重试判断逻辑），可以通过客户端拦截器实现重试：

Unary RPC 重试拦截器示例 #

function createUnaryRetryInterceptor(maxAttempts = 3) {
  return {
    async interceptUnary(next, request, metadata, options) {
      let attempt = 0;
      while (attempt < maxAttempts) {
        try {
          return await next(request, metadata, options);
        } catch (err) {
          attempt++;
          // 达到最大重试次数，抛出原始错误
          if (attempt >= maxAttempts) throw err;
          // 仅对指定状态码重试
          if (![grpc.status.UNAVAILABLE, grpc.status.RESOURCE_EXHAUSTED].includes(err.code)) {
            throw err;
          }
          // 指数退避延迟
          const delay = Math.pow(2, attempt) * 1000;
          await new Promise(resolve => setTimeout(resolve, delay));
        }
      }
    }
  };
}

// 使用拦截器创建客户端
const client = new serviceProto.YourService('localhost:50051', grpc.credentials.createInsecure(), {
  interceptors: [createUnaryRetryInterceptor(3)]
});

流式RPC 重试拦截器示例（简化版） #

function createStreamRetryInterceptor(maxAttempts = 3) {
  return {
    interceptStream(next, metadata, options) {
      let retryCount = 0;
      let originalRequest;
      let stream = next(metadata, options);

      const handleRetry = async () => {
        if (retryCount >= maxAttempts) return;
        retryCount++;
        const delay = Math.pow(2, retryCount) * 1000;
        await new Promise(resolve => setTimeout(resolve, delay));
        // 重新创建流并重发请求
        stream = next(metadata, options);
        stream.write(originalRequest);
      };

      stream.on('error', async (err) => {
        if ([grpc.status.UNAVAILABLE, grpc.status.RESOURCE_EXHAUSTED].includes(err.code)) {
          await handleRetry();
        }
      });

      // 保存原始请求用于重试
      const originalWrite = stream.write.bind(stream);
      stream.write = (req) => {
        originalRequest = req;
        return originalWrite(req);
      };

      return stream;
    }
  };
}

三、nice-grpc-client-middleware-retry 问题排查 #

如果使用该中间件失败，常见原因及解决方式：

• 版本不兼容：确保nice-grpc与中间件版本匹配，建议使用最新稳定版
• 配置错误：正确指定重试触发条件，示例配置：

import { createClient } from 'nice-grpc';
import { retryMiddleware } from 'nice-grpc-client-middleware-retry';
import { YourServiceDefinition } from './compiled_proto';

const client = createClient(YourServiceDefinition, 'localhost:50051', {
  middleware: [
    retryMiddleware({
      maxAttempts: 3,
      retryOn: (err) => err.code === grpc.status.UNAVAILABLE || err.code === grpc.status.RESOURCE_EXHAUSTED,
      delayMs: (attempt) => Math.pow(2, attempt) * 1000,
    }),
  ],
});

• 流式RPC支持：该中间件对Unary RPC支持更完善，流式RPC需额外适配流的重连逻辑

四、编译后的JavaScript proto文件的影响 #

编译后的proto文件仅负责定义服务结构和消息类型，不会影响重试机制的实现——无论是原生重试、自定义拦截器还是第三方中间件，都是基于gRPC客户端的配置逻辑，与proto的编译方式无关。

内容的提问来源于stack exchange，提问作者Kartik Chauhan