feat: request buffer limit

api/v1alpha1/backendtrafficpolicy_types.go

@@ -138,6 +138,32 @@ type BackendTrafficPolicySpec struct {
 	//
 	// +optional
 	RequestBuffer *RequestBuffer `json:"requestBuffer,omitempty"`
+
+	// RequestBodyBufferLimit specifies the maximum size in bytes that Envoy may buffer for request bodies.
+	// This configures Envoy's request body buffer limit without enabling full request buffering.
+	//
+	// This Request body buffer limit is independent of the connection buffer limits configured by
+	// ClientTrafficPolicy and BackendTrafficPolicy. The connection buffer limits control downstream
+	// and upstream connection read/write buffering and back pressure, while this field sets the
+	// maximum size of an individual request body that Envoy may buffer for HTTP processing.
+	//
+	// For HTTP/1, connection buffer limits can still affect how request body data is read and buffered
+	// before or while the request body limit is enforced. Configure connection buffer limits large
+	// enough for the request body buffering you expect to allow on those connections.
+	//
+	// For HTTP/2, initial stream and connection window sizes control HTTP/2 flow control: how much data
+	// can be in flight before back pressure applies. They affect upload throughput and buffering
+	// behavior, but they are not a replacement for this request body size limit.
+	//
+	// If exceeded, the request will be rejected with HTTP 413 Content Too Large.
+	//
+	// Accepts values in resource.Quantity format (e.g., "10Mi", "500Ki").
+	//
+	// +kubebuilder:validation:XIntOrString
+	// +kubebuilder:validation:Pattern="^[1-9]+[0-9]*([EPTGMK]i|[EPTGMk])?$"
+	// +optional
+	RequestBodyBufferLimit *resource.Quantity `json:"requestBodyBufferLimit,omitempty"`
+
 	// Telemetry configures the telemetry settings for the policy target (Gateway or xRoute).
 	// This will override the telemetry settings in the EnvoyProxy resource.
 	//

charts/gateway-crds-helm/templates/generated/gateway.envoyproxy.io_backendtrafficpolicies.yaml

@@ -2305,6 +2305,34 @@ spec:
                     - Local
                     type: string
                 type: object
+              requestBodyBufferLimit:
+                allOf:
+                - pattern: ^(\+|-)?(([0-9]+(\.[0-9]*)?)|(\.[0-9]+))(([KMGTPE]i)|[numkMGTPE]|([eE](\+|-)?(([0-9]+(\.[0-9]*)?)|(\.[0-9]+))))?$
+                - pattern: ^[1-9]+[0-9]*([EPTGMK]i|[EPTGMk])?$
+                anyOf:
+                - type: integer
+                - type: string
+                description: |-
+                  RequestBodyBufferLimit specifies the maximum size in bytes that Envoy may buffer for request bodies.
+                  This configures Envoy's request body buffer limit without enabling full request buffering.
+
+                  This Request body buffer limit is independent of the connection buffer limits configured by
+                  ClientTrafficPolicy and BackendTrafficPolicy. The connection buffer limits control downstream
+                  and upstream connection read/write buffering and back pressure, while this field sets the
+                  maximum size of an individual request body that Envoy may buffer for HTTP processing.
+
+                  For HTTP/1, connection buffer limits can still affect how request body data is read and buffered
+                  before or while the request body limit is enforced. Configure connection buffer limits large
+                  enough for the request body buffering you expect to allow on those connections.
+
+                  For HTTP/2, initial stream and connection window sizes control HTTP/2 flow control: how much data
+                  can be in flight before back pressure applies. They affect upload throughput and buffering
+                  behavior, but they are not a replacement for this request body size limit.
+
+                  If exceeded, the request will be rejected with HTTP 413 Content Too Large.
+
+                  Accepts values in resource.Quantity format (e.g., "10Mi", "500Ki").
+                x-kubernetes-int-or-string: true
               requestBuffer:
                 description: |-
                   RequestBuffer allows the gateway to buffer and fully receive each request from a client before continuing to send the request

charts/gateway-helm/charts/crds/crds/generated/gateway.envoyproxy.io_backendtrafficpolicies.yaml

@@ -2304,6 +2304,34 @@ spec:
                     - Local
                     type: string
                 type: object
+              requestBodyBufferLimit:
+                allOf:
+                - pattern: ^(\+|-)?(([0-9]+(\.[0-9]*)?)|(\.[0-9]+))(([KMGTPE]i)|[numkMGTPE]|([eE](\+|-)?(([0-9]+(\.[0-9]*)?)|(\.[0-9]+))))?$
+                - pattern: ^[1-9]+[0-9]*([EPTGMK]i|[EPTGMk])?$
+                anyOf:
+                - type: integer
+                - type: string
+                description: |-
+                  RequestBodyBufferLimit specifies the maximum size in bytes that Envoy may buffer for request bodies.
+                  This configures Envoy's request body buffer limit without enabling full request buffering.
+
+                  This Request body buffer limit is independent of the connection buffer limits configured by
+                  ClientTrafficPolicy and BackendTrafficPolicy. The connection buffer limits control downstream
+                  and upstream connection read/write buffering and back pressure, while this field sets the
+                  maximum size of an individual request body that Envoy may buffer for HTTP processing.
+
+                  For HTTP/1, connection buffer limits can still affect how request body data is read and buffered
+                  before or while the request body limit is enforced. Configure connection buffer limits large
+                  enough for the request body buffering you expect to allow on those connections.
+
+                  For HTTP/2, initial stream and connection window sizes control HTTP/2 flow control: how much data
+                  can be in flight before back pressure applies. They affect upload throughput and buffering
+                  behavior, but they are not a replacement for this request body size limit.
+
+                  If exceeded, the request will be rejected with HTTP 413 Content Too Large.
+
+                  Accepts values in resource.Quantity format (e.g., "10Mi", "500Ki").
+                x-kubernetes-int-or-string: true
               requestBuffer:
                 description: |-
                   RequestBuffer allows the gateway to buffer and fully receive each request from a client before continuing to send the request

internal/gatewayapi/backendtrafficpolicy.go

@@ -15,6 +15,7 @@ import (
 
 	perr "github.com/pkg/errors"
 	corev1 "k8s.io/api/core/v1"
+	apiresource "k8s.io/apimachinery/pkg/api/resource"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/apimachinery/pkg/types"
 	"k8s.io/apimachinery/pkg/util/sets"
@@ -1070,6 +1071,7 @@ func (t *Translator) buildTrafficFeatures(policy *egv1a1.BackendTrafficPolicy, o
 		h2          *ir.HTTP2Settings
 		ro          *ir.ResponseOverride
 		rb          *ir.RequestBuffer
+		rbbl        *uint64
 		cp          []*ir.Compression
 		httpUpgrade []ir.HTTPUpgradeConfig
 		err, errs   error
@@ -1138,6 +1140,11 @@ func (t *Translator) buildTrafficFeatures(policy *egv1a1.BackendTrafficPolicy, o
 		errs = errors.Join(errs, err)
 	}
 
+	if rbbl, err = buildRequestBodyBufferLimit(policy.Spec.RequestBodyBufferLimit); err != nil {
+		err = perr.WithMessage(err, "RequestBodyBufferLimit")
+		errs = errors.Join(errs, err)
+	}
+
 	if err = validateTelemetry(policy.Spec.Telemetry); err != nil {
 		err = perr.WithMessage(err, "Telemetry")
 		errs = errors.Join(errs, err)
@@ -1154,25 +1161,26 @@ func (t *Translator) buildTrafficFeatures(policy *egv1a1.BackendTrafficPolicy, o
 	ds = translateDNS(&policy.Spec.ClusterSettings, utils.NamespacedName(policy).String())
 
 	return &ir.TrafficFeatures{
-		RateLimit:         rl,
-		BandwidthLimit:    bl,
-		LoadBalancer:      lb,
-		ProxyProtocol:     pp,
-		HealthCheck:       hc,
-		CircuitBreaker:    cb,
-		FaultInjection:    fi,
-		AdmissionControl:  ac,
-		TCPKeepalive:      ka,
-		Retry:             rt,
-		BackendConnection: bc,
-		HTTP2:             h2,
-		DNS:               ds,
-		Timeout:           to,
-		ResponseOverride:  ro,
-		RequestBuffer:     rb,
-		Compression:       cp,
-		HTTPUpgrade:       httpUpgrade,
-		Telemetry:         buildBackendTelemetry(policy.Spec.Telemetry),
+		RateLimit:              rl,
+		BandwidthLimit:         bl,
+		LoadBalancer:           lb,
+		ProxyProtocol:          pp,
+		HealthCheck:            hc,
+		CircuitBreaker:         cb,
+		FaultInjection:         fi,
+		AdmissionControl:       ac,
+		TCPKeepalive:           ka,
+		Retry:                  rt,
+		BackendConnection:      bc,
+		HTTP2:                  h2,
+		DNS:                    ds,
+		Timeout:                to,
+		ResponseOverride:       ro,
+		RequestBuffer:          rb,
+		RequestBodyBufferLimit: rbbl,
+		Compression:            cp,
+		HTTPUpgrade:            httpUpgrade,
+		Telemetry:              buildBackendTelemetry(policy.Spec.Telemetry),
 	}, errs
 }
 
@@ -1906,6 +1914,25 @@ func buildRequestBuffer(spec *egv1a1.RequestBuffer) (*ir.RequestBuffer, error) {
 	}, nil
 }
 
+// buildRequestBodyBufferLimit converts the request body buffer limit Quantity into a byte count.
+func buildRequestBodyBufferLimit(limit *apiresource.Quantity) (*uint64, error) {
+	if limit == nil {
+		return nil, nil
+	}
+
+	v, ok := limit.AsInt64()
+	if !ok {
+		return nil, fmt.Errorf("invalid RequestBodyBufferLimit value %s", limit.String())
+	}
+
+	if v < 0 {
+		return nil, fmt.Errorf("RequestBodyBufferLimit value %s is out of range, must be >= 0", limit.String())
+	}
+
+	out := uint64(v)
+	return &out, nil
+}
+
 func (t *Translator) buildResponseOverride(policy *egv1a1.BackendTrafficPolicy, owners *backendTrafficPolicyOwners) (*ir.ResponseOverride, error) {
 	if len(policy.Spec.ResponseOverride) == 0 {
 		return nil, nil

internal/gatewayapi/testdata/backendtrafficpolicy-request-body-buffer-limit.in.yaml

@@ -0,0 +1,91 @@
+gateways:
+- apiVersion: gateway.networking.k8s.io/v1
+  kind: Gateway
+  metadata:
+    namespace: envoy-gateway
+    name: gateway-1
+  spec:
+    gatewayClassName: envoy-gateway-class
+    listeners:
+    - name: http
+      protocol: HTTP
+      port: 80
+      allowedRoutes:
+        namespaces:
+          from: All
+- apiVersion: gateway.networking.k8s.io/v1
+  kind: Gateway
+  metadata:
+    namespace: envoy-gateway
+    name: gateway-2
+  spec:
+    gatewayClassName: envoy-gateway-class
+    listeners:
+    - name: http
+      protocol: HTTP
+      port: 8080
+      allowedRoutes:
+        namespaces:
+          from: All
+httpRoutes:
+- apiVersion: gateway.networking.k8s.io/v1
+  kind: HTTPRoute
+  metadata:
+    namespace: default
+    name: httproute-1
+  spec:
+    hostnames:
+    - gateway.envoyproxy.io
+    parentRefs:
+    - namespace: envoy-gateway
+      name: gateway-1
+      sectionName: http
+    rules:
+    - matches:
+      - path:
+          value: "/foo"
+      backendRefs:
+      - name: service-1
+        port: 8080
+- apiVersion: gateway.networking.k8s.io/v1
+  kind: HTTPRoute
+  metadata:
+    namespace: default
+    name: httproute-2
+  spec:
+    hostnames:
+    - gateway.envoyproxy.io
+    parentRefs:
+    - namespace: envoy-gateway
+      name: gateway-2
+      sectionName: http
+    rules:
+    - matches:
+      - path:
+          value: "/foo"
+      backendRefs:
+      - name: service-2
+        port: 8080
+backendTrafficPolicies:
+- apiVersion: gateway.envoyproxy.io/v1alpha1
+  kind: BackendTrafficPolicy
+  metadata:
+    name: policy-for-route
+    namespace: default
+  spec:
+    targetRef:
+      group: gateway.networking.k8s.io
+      kind: HTTPRoute
+      name: httproute-2
+    requestBodyBufferLimit: 4Mi
+- apiVersion: gateway.envoyproxy.io/v1alpha1
+  kind: BackendTrafficPolicy
+  metadata:
+    name: policy-for-gateway
+    namespace: envoy-gateway
+  spec:
+    targetRef:
+      group: gateway.networking.k8s.io
+      kind: Gateway
+      name: gateway-1
+    requestBodyBufferLimit: 4Mi