CODEWITHSUNDEEP
gogrpcgrpc-go
Satyajit Das
Satyajit Das

Reputation: 2920

grpc: received message larger than max (8653851 vs. 4194304)

The problem:

I am getting this error while receiving message in grpc:

rpc error: code = ResourceExhausted desc = grpc: received message larger than max (8653851 vs. 4194304)

What I tried:

I gave the option to increase the size of the message to be received but it still gave the same error which means this setting of maximum size didn't work: 

size := 1024 * 1024 * 12
opts = append(opts, grpc.WithDefaultCallOptions(grpc.MaxCallRecvMsgSize(size)))
conn, err := grpc.Dial(address, opts...)

Comments:

The default limit is 1024 * 1024 * 4 = 4194304 which is shown in the error message. I was expecting this limit to increase to 1024 * 1024 * 12 = 12582912 but clearly it didn't.

Upvotes: 25

Views: 57404

Answers (3)

Patric
Patric

Reputation: 21

I met the same question. My DialOption below sets MaxCallRecvMsgSize to be math.MaxInt64. But it doesn't work.

The reason is grpc.WithChainUnaryInterceptor(chains...) appended will be executed firstly when the client call GRPC functons, and the client will jump over the grpc.WithDefaultCallOptions. So you should set MaxCallRecvMsgSize in chains or remove grpc.WithChainUnaryInterceptor.

func NewClient() (promotion.PromotionClient, error) {
    conn, err := grpc.Dial("address", DialogOptions()...)
    if err != nil {
        return nil, err
    }
    return promotion.NewPromotionClient(conn), nil
}

func DialogOptions(chains ...grpc.UnaryClientInterceptor) []grpc.DialOption {
    chains = append(chains, userinfo.UnaryClientInterceptor())
    return []grpc.DialOption{
        grpc.WithDefaultCallOptions(
            grpc.MaxCallRecvMsgSize(math.MaxInt64),
            grpc.MaxCallSendMsgSize(math.MaxInt64),
        ),
        grpc.WithChainUnaryInterceptor(chains...),
    }
}

Upvotes: 1

jchavannes
jchavannes

Reputation: 2710

Call options can be passed with each request.

For example, if your package is called queue and your method is called GetItems, then you would pass in the MaxCallRecvMsgSize option when calling GetItems.

Protobuf:

package queue;

service Queue {
    rpc GetItems (Request) returns (Items) {
    }
}

Go:

conn, err := grpc.Dial(address, opts...)
c := queue.NewQueueClient(s.Conn)
maxSizeOption := grpc.MaxCallRecvMsgSize(32*10e6)
items, err := c.GetItems(ctx, &queue.Request{}, maxSizeOption)

Upvotes: 4

Sudhanshu Ambastha
Sudhanshu Ambastha

Reputation: 121

Please try updating grpc.MaxCallSendMsgSize(s int) on your client to enable your client send larger message. This worked for me.

Upvotes: 12

Related Questions