From aac1d4b4474f1a71adc531016877b02383c31281 Mon Sep 17 00:00:00 2001 From: Prashanth Josyula Date: Thu, 5 Mar 2026 18:20:14 -0800 Subject: [PATCH 1/3] Add AdaptiveConcurrency to DestinationRule TrafficPolicy Adds AdaptiveConcurrency message to the DestinationRule proto, enabling configuration of Envoy's adaptive concurrency filter via TrafficPolicy. The message structure mirrors Envoy's v3 AdaptiveConcurrency proto with GradientControllerConfig, ConcurrencyLimitCalculationParams, and MinimumRTTCalculationParams. Field names and numbers are aligned with the upstream Envoy proto. --- kubernetes/customresourcedefinitions.gen.yaml | 624 +++++++++++++++++ networking/v1/destination_rule_alias.gen.go | 55 ++ networking/v1alpha3/destination_rule.pb.go | 655 ++++++++++++++---- networking/v1alpha3/destination_rule.pb.html | 251 ++++++- networking/v1alpha3/destination_rule.proto | 114 +++ .../v1alpha3/destination_rule_deepcopy.gen.go | 84 +++ .../v1alpha3/destination_rule_json.gen.go | 44 ++ .../v1beta1/destination_rule_alias.gen.go | 55 ++ ...ptive-concurrency-to-destination-rule.yaml | 11 + 9 files changed, 1768 insertions(+), 125 deletions(-) create mode 100644 releasenotes/notes/add-adaptive-concurrency-to-destination-rule.yaml diff --git a/kubernetes/customresourcedefinitions.gen.yaml b/kubernetes/customresourcedefinitions.gen.yaml index dea2de3fcc..411bf7652f 100644 --- a/kubernetes/customresourcedefinitions.gen.yaml +++ b/kubernetes/customresourcedefinitions.gen.yaml @@ -432,6 +432,113 @@ spec: trafficPolicy: description: Traffic policies that apply to this subset. properties: + adaptiveConcurrency: + description: Adaptive concurrency settings for dynamically + adjusting the allowed number of outstanding requests based + on sampled latencies. + oneOf: + - not: + anyOf: + - required: + - gradientControllerConfig + - required: + - gradientControllerConfig + properties: + concurrencyLimitExceededStatus: + description: Custom HTTP response status code to the + downstream client when the concurrency limit has been + exceeded. + maximum: 4294967295 + minimum: 0 + type: integer + enabled: + description: If set to false, the adaptive concurrency + filter will operate as a pass-through filter. + type: boolean + gradientControllerConfig: + description: Gradient concurrency control will be used. + properties: + concurrencyLimitParams: + description: Parameters for periodic recalculation + of the concurrency limit. + properties: + concurrencyUpdateInterval: + description: The period of time samples are + taken to recalculate the concurrency limit. + type: string + x-kubernetes-validations: + - message: must be a valid duration greater + than 1ms + rule: duration(self) >= duration('1ms') + maxConcurrencyLimit: + description: The allowed upper-bound on the + calculated concurrency limit. + maximum: 4294967295 + minimum: 0 + nullable: true + type: integer + required: + - concurrencyUpdateInterval + type: object + minRttCalcParams: + description: Parameters for periodic minRTT recalculation. + properties: + buffer: + description: Amount added to the measured minRTT + to add stability to the concurrency limit + during natural variability in latency. + format: double + nullable: true + type: number + fixedValue: + description: The fixed value for the minRTT. + type: string + x-kubernetes-validations: + - message: must be a valid duration greater + than 1ms + rule: duration(self) >= duration('1ms') + interval: + description: The time interval between recalculating + the minimum request round-trip time. + type: string + x-kubernetes-validations: + - message: must be a valid duration greater + than 1ms + rule: duration(self) >= duration('1ms') + jitter: + description: Randomized time delta that will + be introduced to the start of the minRTT calculation + window. + format: double + nullable: true + type: number + minConcurrency: + description: The concurrency limit set while + measuring the minRTT. + maximum: 4294967295 + minimum: 0 + nullable: true + type: integer + requestCount: + description: The number of requests to aggregate/sample + during the minRTT recalculation window before + updating. + maximum: 4294967295 + minimum: 0 + nullable: true + type: integer + type: object + sampleAggregatePercentile: + description: The percentile to use when summarizing + aggregated samples. + format: double + nullable: true + type: number + required: + - concurrencyLimitParams + - minRttCalcParams + type: object + type: object connectionPool: properties: http: @@ -1375,6 +1482,107 @@ spec: description: Traffic policies to apply (load balancing policy, connection pool sizes, outlier detection). properties: + adaptiveConcurrency: + description: Adaptive concurrency settings for dynamically adjusting + the allowed number of outstanding requests based on sampled + latencies. + oneOf: + - not: + anyOf: + - required: + - gradientControllerConfig + - required: + - gradientControllerConfig + properties: + concurrencyLimitExceededStatus: + description: Custom HTTP response status code to the downstream + client when the concurrency limit has been exceeded. + maximum: 4294967295 + minimum: 0 + type: integer + enabled: + description: If set to false, the adaptive concurrency filter + will operate as a pass-through filter. + type: boolean + gradientControllerConfig: + description: Gradient concurrency control will be used. + properties: + concurrencyLimitParams: + description: Parameters for periodic recalculation of + the concurrency limit. + properties: + concurrencyUpdateInterval: + description: The period of time samples are taken + to recalculate the concurrency limit. + type: string + x-kubernetes-validations: + - message: must be a valid duration greater than 1ms + rule: duration(self) >= duration('1ms') + maxConcurrencyLimit: + description: The allowed upper-bound on the calculated + concurrency limit. + maximum: 4294967295 + minimum: 0 + nullable: true + type: integer + required: + - concurrencyUpdateInterval + type: object + minRttCalcParams: + description: Parameters for periodic minRTT recalculation. + properties: + buffer: + description: Amount added to the measured minRTT to + add stability to the concurrency limit during natural + variability in latency. + format: double + nullable: true + type: number + fixedValue: + description: The fixed value for the minRTT. + type: string + x-kubernetes-validations: + - message: must be a valid duration greater than 1ms + rule: duration(self) >= duration('1ms') + interval: + description: The time interval between recalculating + the minimum request round-trip time. + type: string + x-kubernetes-validations: + - message: must be a valid duration greater than 1ms + rule: duration(self) >= duration('1ms') + jitter: + description: Randomized time delta that will be introduced + to the start of the minRTT calculation window. + format: double + nullable: true + type: number + minConcurrency: + description: The concurrency limit set while measuring + the minRTT. + maximum: 4294967295 + minimum: 0 + nullable: true + type: integer + requestCount: + description: The number of requests to aggregate/sample + during the minRTT recalculation window before updating. + maximum: 4294967295 + minimum: 0 + nullable: true + type: integer + type: object + sampleAggregatePercentile: + description: The percentile to use when summarizing aggregated + samples. + format: double + nullable: true + type: number + required: + - concurrencyLimitParams + - minRttCalcParams + type: object + type: object connectionPool: properties: http: @@ -2433,6 +2641,113 @@ spec: trafficPolicy: description: Traffic policies that apply to this subset. properties: + adaptiveConcurrency: + description: Adaptive concurrency settings for dynamically + adjusting the allowed number of outstanding requests based + on sampled latencies. + oneOf: + - not: + anyOf: + - required: + - gradientControllerConfig + - required: + - gradientControllerConfig + properties: + concurrencyLimitExceededStatus: + description: Custom HTTP response status code to the + downstream client when the concurrency limit has been + exceeded. + maximum: 4294967295 + minimum: 0 + type: integer + enabled: + description: If set to false, the adaptive concurrency + filter will operate as a pass-through filter. + type: boolean + gradientControllerConfig: + description: Gradient concurrency control will be used. + properties: + concurrencyLimitParams: + description: Parameters for periodic recalculation + of the concurrency limit. + properties: + concurrencyUpdateInterval: + description: The period of time samples are + taken to recalculate the concurrency limit. + type: string + x-kubernetes-validations: + - message: must be a valid duration greater + than 1ms + rule: duration(self) >= duration('1ms') + maxConcurrencyLimit: + description: The allowed upper-bound on the + calculated concurrency limit. + maximum: 4294967295 + minimum: 0 + nullable: true + type: integer + required: + - concurrencyUpdateInterval + type: object + minRttCalcParams: + description: Parameters for periodic minRTT recalculation. + properties: + buffer: + description: Amount added to the measured minRTT + to add stability to the concurrency limit + during natural variability in latency. + format: double + nullable: true + type: number + fixedValue: + description: The fixed value for the minRTT. + type: string + x-kubernetes-validations: + - message: must be a valid duration greater + than 1ms + rule: duration(self) >= duration('1ms') + interval: + description: The time interval between recalculating + the minimum request round-trip time. + type: string + x-kubernetes-validations: + - message: must be a valid duration greater + than 1ms + rule: duration(self) >= duration('1ms') + jitter: + description: Randomized time delta that will + be introduced to the start of the minRTT calculation + window. + format: double + nullable: true + type: number + minConcurrency: + description: The concurrency limit set while + measuring the minRTT. + maximum: 4294967295 + minimum: 0 + nullable: true + type: integer + requestCount: + description: The number of requests to aggregate/sample + during the minRTT recalculation window before + updating. + maximum: 4294967295 + minimum: 0 + nullable: true + type: integer + type: object + sampleAggregatePercentile: + description: The percentile to use when summarizing + aggregated samples. + format: double + nullable: true + type: number + required: + - concurrencyLimitParams + - minRttCalcParams + type: object + type: object connectionPool: properties: http: @@ -3376,6 +3691,107 @@ spec: description: Traffic policies to apply (load balancing policy, connection pool sizes, outlier detection). properties: + adaptiveConcurrency: + description: Adaptive concurrency settings for dynamically adjusting + the allowed number of outstanding requests based on sampled + latencies. + oneOf: + - not: + anyOf: + - required: + - gradientControllerConfig + - required: + - gradientControllerConfig + properties: + concurrencyLimitExceededStatus: + description: Custom HTTP response status code to the downstream + client when the concurrency limit has been exceeded. + maximum: 4294967295 + minimum: 0 + type: integer + enabled: + description: If set to false, the adaptive concurrency filter + will operate as a pass-through filter. + type: boolean + gradientControllerConfig: + description: Gradient concurrency control will be used. + properties: + concurrencyLimitParams: + description: Parameters for periodic recalculation of + the concurrency limit. + properties: + concurrencyUpdateInterval: + description: The period of time samples are taken + to recalculate the concurrency limit. + type: string + x-kubernetes-validations: + - message: must be a valid duration greater than 1ms + rule: duration(self) >= duration('1ms') + maxConcurrencyLimit: + description: The allowed upper-bound on the calculated + concurrency limit. + maximum: 4294967295 + minimum: 0 + nullable: true + type: integer + required: + - concurrencyUpdateInterval + type: object + minRttCalcParams: + description: Parameters for periodic minRTT recalculation. + properties: + buffer: + description: Amount added to the measured minRTT to + add stability to the concurrency limit during natural + variability in latency. + format: double + nullable: true + type: number + fixedValue: + description: The fixed value for the minRTT. + type: string + x-kubernetes-validations: + - message: must be a valid duration greater than 1ms + rule: duration(self) >= duration('1ms') + interval: + description: The time interval between recalculating + the minimum request round-trip time. + type: string + x-kubernetes-validations: + - message: must be a valid duration greater than 1ms + rule: duration(self) >= duration('1ms') + jitter: + description: Randomized time delta that will be introduced + to the start of the minRTT calculation window. + format: double + nullable: true + type: number + minConcurrency: + description: The concurrency limit set while measuring + the minRTT. + maximum: 4294967295 + minimum: 0 + nullable: true + type: integer + requestCount: + description: The number of requests to aggregate/sample + during the minRTT recalculation window before updating. + maximum: 4294967295 + minimum: 0 + nullable: true + type: integer + type: object + sampleAggregatePercentile: + description: The percentile to use when summarizing aggregated + samples. + format: double + nullable: true + type: number + required: + - concurrencyLimitParams + - minRttCalcParams + type: object + type: object connectionPool: properties: http: @@ -4434,6 +4850,113 @@ spec: trafficPolicy: description: Traffic policies that apply to this subset. properties: + adaptiveConcurrency: + description: Adaptive concurrency settings for dynamically + adjusting the allowed number of outstanding requests based + on sampled latencies. + oneOf: + - not: + anyOf: + - required: + - gradientControllerConfig + - required: + - gradientControllerConfig + properties: + concurrencyLimitExceededStatus: + description: Custom HTTP response status code to the + downstream client when the concurrency limit has been + exceeded. + maximum: 4294967295 + minimum: 0 + type: integer + enabled: + description: If set to false, the adaptive concurrency + filter will operate as a pass-through filter. + type: boolean + gradientControllerConfig: + description: Gradient concurrency control will be used. + properties: + concurrencyLimitParams: + description: Parameters for periodic recalculation + of the concurrency limit. + properties: + concurrencyUpdateInterval: + description: The period of time samples are + taken to recalculate the concurrency limit. + type: string + x-kubernetes-validations: + - message: must be a valid duration greater + than 1ms + rule: duration(self) >= duration('1ms') + maxConcurrencyLimit: + description: The allowed upper-bound on the + calculated concurrency limit. + maximum: 4294967295 + minimum: 0 + nullable: true + type: integer + required: + - concurrencyUpdateInterval + type: object + minRttCalcParams: + description: Parameters for periodic minRTT recalculation. + properties: + buffer: + description: Amount added to the measured minRTT + to add stability to the concurrency limit + during natural variability in latency. + format: double + nullable: true + type: number + fixedValue: + description: The fixed value for the minRTT. + type: string + x-kubernetes-validations: + - message: must be a valid duration greater + than 1ms + rule: duration(self) >= duration('1ms') + interval: + description: The time interval between recalculating + the minimum request round-trip time. + type: string + x-kubernetes-validations: + - message: must be a valid duration greater + than 1ms + rule: duration(self) >= duration('1ms') + jitter: + description: Randomized time delta that will + be introduced to the start of the minRTT calculation + window. + format: double + nullable: true + type: number + minConcurrency: + description: The concurrency limit set while + measuring the minRTT. + maximum: 4294967295 + minimum: 0 + nullable: true + type: integer + requestCount: + description: The number of requests to aggregate/sample + during the minRTT recalculation window before + updating. + maximum: 4294967295 + minimum: 0 + nullable: true + type: integer + type: object + sampleAggregatePercentile: + description: The percentile to use when summarizing + aggregated samples. + format: double + nullable: true + type: number + required: + - concurrencyLimitParams + - minRttCalcParams + type: object + type: object connectionPool: properties: http: @@ -5377,6 +5900,107 @@ spec: description: Traffic policies to apply (load balancing policy, connection pool sizes, outlier detection). properties: + adaptiveConcurrency: + description: Adaptive concurrency settings for dynamically adjusting + the allowed number of outstanding requests based on sampled + latencies. + oneOf: + - not: + anyOf: + - required: + - gradientControllerConfig + - required: + - gradientControllerConfig + properties: + concurrencyLimitExceededStatus: + description: Custom HTTP response status code to the downstream + client when the concurrency limit has been exceeded. + maximum: 4294967295 + minimum: 0 + type: integer + enabled: + description: If set to false, the adaptive concurrency filter + will operate as a pass-through filter. + type: boolean + gradientControllerConfig: + description: Gradient concurrency control will be used. + properties: + concurrencyLimitParams: + description: Parameters for periodic recalculation of + the concurrency limit. + properties: + concurrencyUpdateInterval: + description: The period of time samples are taken + to recalculate the concurrency limit. + type: string + x-kubernetes-validations: + - message: must be a valid duration greater than 1ms + rule: duration(self) >= duration('1ms') + maxConcurrencyLimit: + description: The allowed upper-bound on the calculated + concurrency limit. + maximum: 4294967295 + minimum: 0 + nullable: true + type: integer + required: + - concurrencyUpdateInterval + type: object + minRttCalcParams: + description: Parameters for periodic minRTT recalculation. + properties: + buffer: + description: Amount added to the measured minRTT to + add stability to the concurrency limit during natural + variability in latency. + format: double + nullable: true + type: number + fixedValue: + description: The fixed value for the minRTT. + type: string + x-kubernetes-validations: + - message: must be a valid duration greater than 1ms + rule: duration(self) >= duration('1ms') + interval: + description: The time interval between recalculating + the minimum request round-trip time. + type: string + x-kubernetes-validations: + - message: must be a valid duration greater than 1ms + rule: duration(self) >= duration('1ms') + jitter: + description: Randomized time delta that will be introduced + to the start of the minRTT calculation window. + format: double + nullable: true + type: number + minConcurrency: + description: The concurrency limit set while measuring + the minRTT. + maximum: 4294967295 + minimum: 0 + nullable: true + type: integer + requestCount: + description: The number of requests to aggregate/sample + during the minRTT recalculation window before updating. + maximum: 4294967295 + minimum: 0 + nullable: true + type: integer + type: object + sampleAggregatePercentile: + description: The percentile to use when summarizing aggregated + samples. + format: double + nullable: true + type: number + required: + - concurrencyLimitParams + - minRttCalcParams + type: object + type: object connectionPool: properties: http: diff --git a/networking/v1/destination_rule_alias.gen.go b/networking/v1/destination_rule_alias.gen.go index 76c48e73fd..655beb2875 100644 --- a/networking/v1/destination_rule_alias.gen.go +++ b/networking/v1/destination_rule_alias.gen.go @@ -318,6 +318,61 @@ const ConnectionPoolSettings_HTTPSettings_UPGRADE ConnectionPoolSettings_HTTPSet // ``` type OutlierDetection = v1alpha3.OutlierDetection +// Adaptive concurrency settings for dynamically adjusting the allowed number of +// outstanding requests based on sampled latencies. See Envoy's +// [adaptive concurrency filter](https://www.envoyproxy.io/docs/envoy/latest/configuration/http/http_filters/adaptive_concurrency_filter) +// for more details. +// +// The following example configures adaptive concurrency for the my-service +// service with a gradient controller: +// +// ```yaml +// apiVersion: networking.istio.io/v1 +// kind: DestinationRule +// metadata: +// +// name: my-service-adaptive +// +// spec: +// +// host: my-service.default.svc.cluster.local +// trafficPolicy: +// adaptiveConcurrency: +// enabled: true +// gradientControllerConfig: +// sampleAggregatePercentile: 50 +// concurrencyLimitParams: +// maxConcurrencyLimit: 1000 +// concurrencyUpdateInterval: 100ms +// minRttCalcParams: +// interval: 60s +// requestCount: 50 +// jitter: 10 +// minConcurrency: 3 +// buffer: 25 +// concurrencyLimitExceededStatus: 503 +// +// ``` +type AdaptiveConcurrency = v1alpha3.AdaptiveConcurrency + +// Configuration parameters for the gradient concurrency controller. +// The gradient controller makes forwarding decisions based on a periodically +// measured ideal round-trip time (minRTT) for an upstream. +type AdaptiveConcurrency_GradientControllerConfig = v1alpha3.AdaptiveConcurrency_GradientControllerConfig + +// Parameters controlling the periodic recalculation of the concurrency limit +// from sampled request latencies. +type AdaptiveConcurrency_GradientControllerConfig_ConcurrencyLimitCalculationParams = v1alpha3.AdaptiveConcurrency_GradientControllerConfig_ConcurrencyLimitCalculationParams + +// Parameters controlling the periodic minRTT recalculation. +// The minRTT is periodically measured by allowing only a very low outstanding +// request count to an upstream cluster and measuring the latency under +// these ideal conditions. +type AdaptiveConcurrency_GradientControllerConfig_MinimumRTTCalculationParams = v1alpha3.AdaptiveConcurrency_GradientControllerConfig_MinimumRTTCalculationParams + +// Gradient concurrency control will be used. +type AdaptiveConcurrency_GradientControllerConfig_ = v1alpha3.AdaptiveConcurrency_GradientControllerConfig_ + // SSL/TLS related settings for upstream connections. See Envoy's [TLS // context](https://www.envoyproxy.io/docs/envoy/latest/api-v3/extensions/transport_sockets/tls/v3/common.proto.html#common-tls-configuration) // for more details. These settings are common to both HTTP and TCP upstreams. diff --git a/networking/v1alpha3/destination_rule.pb.go b/networking/v1alpha3/destination_rule.pb.go index c2a1474e78..76437450a9 100644 --- a/networking/v1alpha3/destination_rule.pb.go +++ b/networking/v1alpha3/destination_rule.pb.go @@ -384,7 +384,7 @@ func (x ClientTLSSettings_TLSmode) Number() protoreflect.EnumNumber { // Deprecated: Use ClientTLSSettings_TLSmode.Descriptor instead. func (ClientTLSSettings_TLSmode) EnumDescriptor() ([]byte, []int) { - return file_networking_v1alpha3_destination_rule_proto_rawDescGZIP(), []int{7, 0} + return file_networking_v1alpha3_destination_rule_proto_rawDescGZIP(), []int{8, 0} } // DestinationRule defines policies that apply to traffic intended for a service @@ -556,9 +556,13 @@ type TrafficPolicy struct { // The upstream PROXY protocol settings. ProxyProtocol *TrafficPolicy_ProxyProtocol `protobuf:"bytes,7,opt,name=proxy_protocol,json=proxyProtocol,proto3" json:"proxy_protocol,omitempty"` // Specifies a limit on concurrent retries in relation to the number of active requests. - RetryBudget *TrafficPolicy_RetryBudget `protobuf:"bytes,8,opt,name=retry_budget,json=retryBudget,proto3" json:"retry_budget,omitempty"` - unknownFields protoimpl.UnknownFields - sizeCache protoimpl.SizeCache + RetryBudget *TrafficPolicy_RetryBudget `protobuf:"bytes,8,opt,name=retry_budget,json=retryBudget,proto3" json:"retry_budget,omitempty"` + // Adaptive concurrency settings for dynamically adjusting the allowed number of + // outstanding requests based on sampled latencies. This enables the Envoy + // adaptive concurrency filter for the destination. + AdaptiveConcurrency *AdaptiveConcurrency `protobuf:"bytes,9,opt,name=adaptive_concurrency,json=adaptiveConcurrency,proto3" json:"adaptive_concurrency,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache } func (x *TrafficPolicy) Reset() { @@ -647,6 +651,13 @@ func (x *TrafficPolicy) GetRetryBudget() *TrafficPolicy_RetryBudget { return nil } +func (x *TrafficPolicy) GetAdaptiveConcurrency() *AdaptiveConcurrency { + if x != nil { + return x.AdaptiveConcurrency + } + return nil +} + // A subset of endpoints of a service. Subsets can be used for scenarios // like A/B testing, or routing to a specific version of a service. Refer // to [VirtualService](https://istio.io/docs/reference/config/networking/virtual-service/#VirtualService) documentation for examples of using @@ -1280,6 +1291,131 @@ func (x *OutlierDetection) GetMinHealthPercent() int32 { return 0 } +// Adaptive concurrency settings for dynamically adjusting the allowed number of +// outstanding requests based on sampled latencies. See Envoy's +// [adaptive concurrency filter](https://www.envoyproxy.io/docs/envoy/latest/configuration/http/http_filters/adaptive_concurrency_filter) +// for more details. +// +// The following example configures adaptive concurrency for the my-service +// service with a gradient controller: +// +// ```yaml +// apiVersion: networking.istio.io/v1 +// kind: DestinationRule +// metadata: +// +// name: my-service-adaptive +// +// spec: +// +// host: my-service.default.svc.cluster.local +// trafficPolicy: +// adaptiveConcurrency: +// enabled: true +// gradientControllerConfig: +// sampleAggregatePercentile: 50 +// concurrencyLimitParams: +// maxConcurrencyLimit: 1000 +// concurrencyUpdateInterval: 100ms +// minRttCalcParams: +// interval: 60s +// requestCount: 50 +// jitter: 10 +// minConcurrency: 3 +// buffer: 25 +// concurrencyLimitExceededStatus: 503 +// +// ``` +type AdaptiveConcurrency struct { + state protoimpl.MessageState `protogen:"open.v1"` + // Types that are valid to be assigned to ConcurrencyControllerConfig: + // + // *AdaptiveConcurrency_GradientControllerConfig_ + ConcurrencyControllerConfig isAdaptiveConcurrency_ConcurrencyControllerConfig `protobuf_oneof:"concurrency_controller_config"` + // If set to false, the adaptive concurrency filter will operate as a pass-through + // filter. If unspecified, the filter will be enabled. + Enabled bool `protobuf:"varint,2,opt,name=enabled,proto3" json:"enabled,omitempty"` + // Custom HTTP response status code to the downstream client when + // the concurrency limit has been exceeded. + // Defaults to 503 (Service Unavailable). + // Note: If this is set to < 400, 503 will be used instead. + ConcurrencyLimitExceededStatus uint32 `protobuf:"varint,3,opt,name=concurrency_limit_exceeded_status,json=concurrencyLimitExceededStatus,proto3" json:"concurrency_limit_exceeded_status,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *AdaptiveConcurrency) Reset() { + *x = AdaptiveConcurrency{} + mi := &file_networking_v1alpha3_destination_rule_proto_msgTypes[7] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *AdaptiveConcurrency) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*AdaptiveConcurrency) ProtoMessage() {} + +func (x *AdaptiveConcurrency) ProtoReflect() protoreflect.Message { + mi := &file_networking_v1alpha3_destination_rule_proto_msgTypes[7] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use AdaptiveConcurrency.ProtoReflect.Descriptor instead. +func (*AdaptiveConcurrency) Descriptor() ([]byte, []int) { + return file_networking_v1alpha3_destination_rule_proto_rawDescGZIP(), []int{7} +} + +func (x *AdaptiveConcurrency) GetConcurrencyControllerConfig() isAdaptiveConcurrency_ConcurrencyControllerConfig { + if x != nil { + return x.ConcurrencyControllerConfig + } + return nil +} + +func (x *AdaptiveConcurrency) GetGradientControllerConfig() *AdaptiveConcurrency_GradientControllerConfig { + if x != nil { + if x, ok := x.ConcurrencyControllerConfig.(*AdaptiveConcurrency_GradientControllerConfig_); ok { + return x.GradientControllerConfig + } + } + return nil +} + +func (x *AdaptiveConcurrency) GetEnabled() bool { + if x != nil { + return x.Enabled + } + return false +} + +func (x *AdaptiveConcurrency) GetConcurrencyLimitExceededStatus() uint32 { + if x != nil { + return x.ConcurrencyLimitExceededStatus + } + return 0 +} + +type isAdaptiveConcurrency_ConcurrencyControllerConfig interface { + isAdaptiveConcurrency_ConcurrencyControllerConfig() +} + +type AdaptiveConcurrency_GradientControllerConfig_ struct { + // Gradient concurrency control will be used. + GradientControllerConfig *AdaptiveConcurrency_GradientControllerConfig `protobuf:"bytes,1,opt,name=gradient_controller_config,json=gradientControllerConfig,proto3,oneof"` +} + +func (*AdaptiveConcurrency_GradientControllerConfig_) isAdaptiveConcurrency_ConcurrencyControllerConfig() { +} + // SSL/TLS related settings for upstream connections. See Envoy's [TLS // context](https://www.envoyproxy.io/docs/envoy/latest/api-v3/extensions/transport_sockets/tls/v3/common.proto.html#common-tls-configuration) // for more details. These settings are common to both HTTP and TCP upstreams. @@ -1411,7 +1547,7 @@ type ClientTLSSettings struct { func (x *ClientTLSSettings) Reset() { *x = ClientTLSSettings{} - mi := &file_networking_v1alpha3_destination_rule_proto_msgTypes[7] + mi := &file_networking_v1alpha3_destination_rule_proto_msgTypes[8] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -1423,7 +1559,7 @@ func (x *ClientTLSSettings) String() string { func (*ClientTLSSettings) ProtoMessage() {} func (x *ClientTLSSettings) ProtoReflect() protoreflect.Message { - mi := &file_networking_v1alpha3_destination_rule_proto_msgTypes[7] + mi := &file_networking_v1alpha3_destination_rule_proto_msgTypes[8] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -1436,7 +1572,7 @@ func (x *ClientTLSSettings) ProtoReflect() protoreflect.Message { // Deprecated: Use ClientTLSSettings.ProtoReflect.Descriptor instead. func (*ClientTLSSettings) Descriptor() ([]byte, []int) { - return file_networking_v1alpha3_destination_rule_proto_rawDescGZIP(), []int{7} + return file_networking_v1alpha3_destination_rule_proto_rawDescGZIP(), []int{8} } func (x *ClientTLSSettings) GetMode() ClientTLSSettings_TLSmode { @@ -1635,7 +1771,7 @@ type LocalityLoadBalancerSetting struct { func (x *LocalityLoadBalancerSetting) Reset() { *x = LocalityLoadBalancerSetting{} - mi := &file_networking_v1alpha3_destination_rule_proto_msgTypes[8] + mi := &file_networking_v1alpha3_destination_rule_proto_msgTypes[9] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -1647,7 +1783,7 @@ func (x *LocalityLoadBalancerSetting) String() string { func (*LocalityLoadBalancerSetting) ProtoMessage() {} func (x *LocalityLoadBalancerSetting) ProtoReflect() protoreflect.Message { - mi := &file_networking_v1alpha3_destination_rule_proto_msgTypes[8] + mi := &file_networking_v1alpha3_destination_rule_proto_msgTypes[9] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -1660,7 +1796,7 @@ func (x *LocalityLoadBalancerSetting) ProtoReflect() protoreflect.Message { // Deprecated: Use LocalityLoadBalancerSetting.ProtoReflect.Descriptor instead. func (*LocalityLoadBalancerSetting) Descriptor() ([]byte, []int) { - return file_networking_v1alpha3_destination_rule_proto_rawDescGZIP(), []int{8} + return file_networking_v1alpha3_destination_rule_proto_rawDescGZIP(), []int{9} } func (x *LocalityLoadBalancerSetting) GetDistribute() []*LocalityLoadBalancerSetting_Distribute { @@ -1711,7 +1847,7 @@ type TrafficPolicy_PortTrafficPolicy struct { func (x *TrafficPolicy_PortTrafficPolicy) Reset() { *x = TrafficPolicy_PortTrafficPolicy{} - mi := &file_networking_v1alpha3_destination_rule_proto_msgTypes[9] + mi := &file_networking_v1alpha3_destination_rule_proto_msgTypes[10] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -1723,7 +1859,7 @@ func (x *TrafficPolicy_PortTrafficPolicy) String() string { func (*TrafficPolicy_PortTrafficPolicy) ProtoMessage() {} func (x *TrafficPolicy_PortTrafficPolicy) ProtoReflect() protoreflect.Message { - mi := &file_networking_v1alpha3_destination_rule_proto_msgTypes[9] + mi := &file_networking_v1alpha3_destination_rule_proto_msgTypes[10] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -1796,7 +1932,7 @@ type TrafficPolicy_TunnelSettings struct { func (x *TrafficPolicy_TunnelSettings) Reset() { *x = TrafficPolicy_TunnelSettings{} - mi := &file_networking_v1alpha3_destination_rule_proto_msgTypes[10] + mi := &file_networking_v1alpha3_destination_rule_proto_msgTypes[11] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -1808,7 +1944,7 @@ func (x *TrafficPolicy_TunnelSettings) String() string { func (*TrafficPolicy_TunnelSettings) ProtoMessage() {} func (x *TrafficPolicy_TunnelSettings) ProtoReflect() protoreflect.Message { - mi := &file_networking_v1alpha3_destination_rule_proto_msgTypes[10] + mi := &file_networking_v1alpha3_destination_rule_proto_msgTypes[11] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -1856,7 +1992,7 @@ type TrafficPolicy_ProxyProtocol struct { func (x *TrafficPolicy_ProxyProtocol) Reset() { *x = TrafficPolicy_ProxyProtocol{} - mi := &file_networking_v1alpha3_destination_rule_proto_msgTypes[11] + mi := &file_networking_v1alpha3_destination_rule_proto_msgTypes[12] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -1868,7 +2004,7 @@ func (x *TrafficPolicy_ProxyProtocol) String() string { func (*TrafficPolicy_ProxyProtocol) ProtoMessage() {} func (x *TrafficPolicy_ProxyProtocol) ProtoReflect() protoreflect.Message { - mi := &file_networking_v1alpha3_destination_rule_proto_msgTypes[11] + mi := &file_networking_v1alpha3_destination_rule_proto_msgTypes[12] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -1914,7 +2050,7 @@ type TrafficPolicy_RetryBudget struct { func (x *TrafficPolicy_RetryBudget) Reset() { *x = TrafficPolicy_RetryBudget{} - mi := &file_networking_v1alpha3_destination_rule_proto_msgTypes[12] + mi := &file_networking_v1alpha3_destination_rule_proto_msgTypes[13] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -1926,7 +2062,7 @@ func (x *TrafficPolicy_RetryBudget) String() string { func (*TrafficPolicy_RetryBudget) ProtoMessage() {} func (x *TrafficPolicy_RetryBudget) ProtoReflect() protoreflect.Message { - mi := &file_networking_v1alpha3_destination_rule_proto_msgTypes[12] + mi := &file_networking_v1alpha3_destination_rule_proto_msgTypes[13] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -2004,7 +2140,7 @@ type LoadBalancerSettings_ConsistentHashLB struct { func (x *LoadBalancerSettings_ConsistentHashLB) Reset() { *x = LoadBalancerSettings_ConsistentHashLB{} - mi := &file_networking_v1alpha3_destination_rule_proto_msgTypes[14] + mi := &file_networking_v1alpha3_destination_rule_proto_msgTypes[15] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -2016,7 +2152,7 @@ func (x *LoadBalancerSettings_ConsistentHashLB) String() string { func (*LoadBalancerSettings_ConsistentHashLB) ProtoMessage() {} func (x *LoadBalancerSettings_ConsistentHashLB) ProtoReflect() protoreflect.Message { - mi := &file_networking_v1alpha3_destination_rule_proto_msgTypes[14] + mi := &file_networking_v1alpha3_destination_rule_proto_msgTypes[15] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -2179,7 +2315,7 @@ type LoadBalancerSettings_ConsistentHashLB_RingHash struct { func (x *LoadBalancerSettings_ConsistentHashLB_RingHash) Reset() { *x = LoadBalancerSettings_ConsistentHashLB_RingHash{} - mi := &file_networking_v1alpha3_destination_rule_proto_msgTypes[15] + mi := &file_networking_v1alpha3_destination_rule_proto_msgTypes[16] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -2191,7 +2327,7 @@ func (x *LoadBalancerSettings_ConsistentHashLB_RingHash) String() string { func (*LoadBalancerSettings_ConsistentHashLB_RingHash) ProtoMessage() {} func (x *LoadBalancerSettings_ConsistentHashLB_RingHash) ProtoReflect() protoreflect.Message { - mi := &file_networking_v1alpha3_destination_rule_proto_msgTypes[15] + mi := &file_networking_v1alpha3_destination_rule_proto_msgTypes[16] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -2228,7 +2364,7 @@ type LoadBalancerSettings_ConsistentHashLB_MagLev struct { func (x *LoadBalancerSettings_ConsistentHashLB_MagLev) Reset() { *x = LoadBalancerSettings_ConsistentHashLB_MagLev{} - mi := &file_networking_v1alpha3_destination_rule_proto_msgTypes[16] + mi := &file_networking_v1alpha3_destination_rule_proto_msgTypes[17] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -2240,7 +2376,7 @@ func (x *LoadBalancerSettings_ConsistentHashLB_MagLev) String() string { func (*LoadBalancerSettings_ConsistentHashLB_MagLev) ProtoMessage() {} func (x *LoadBalancerSettings_ConsistentHashLB_MagLev) ProtoReflect() protoreflect.Message { - mi := &file_networking_v1alpha3_destination_rule_proto_msgTypes[16] + mi := &file_networking_v1alpha3_destination_rule_proto_msgTypes[17] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -2284,7 +2420,7 @@ type LoadBalancerSettings_ConsistentHashLB_HTTPCookie struct { func (x *LoadBalancerSettings_ConsistentHashLB_HTTPCookie) Reset() { *x = LoadBalancerSettings_ConsistentHashLB_HTTPCookie{} - mi := &file_networking_v1alpha3_destination_rule_proto_msgTypes[17] + mi := &file_networking_v1alpha3_destination_rule_proto_msgTypes[18] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -2296,7 +2432,7 @@ func (x *LoadBalancerSettings_ConsistentHashLB_HTTPCookie) String() string { func (*LoadBalancerSettings_ConsistentHashLB_HTTPCookie) ProtoMessage() {} func (x *LoadBalancerSettings_ConsistentHashLB_HTTPCookie) ProtoReflect() protoreflect.Message { - mi := &file_networking_v1alpha3_destination_rule_proto_msgTypes[17] + mi := &file_networking_v1alpha3_destination_rule_proto_msgTypes[18] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -2353,7 +2489,7 @@ type LoadBalancerSettings_ConsistentHashLB_HTTPCookie_Attribute struct { func (x *LoadBalancerSettings_ConsistentHashLB_HTTPCookie_Attribute) Reset() { *x = LoadBalancerSettings_ConsistentHashLB_HTTPCookie_Attribute{} - mi := &file_networking_v1alpha3_destination_rule_proto_msgTypes[18] + mi := &file_networking_v1alpha3_destination_rule_proto_msgTypes[19] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -2365,7 +2501,7 @@ func (x *LoadBalancerSettings_ConsistentHashLB_HTTPCookie_Attribute) String() st func (*LoadBalancerSettings_ConsistentHashLB_HTTPCookie_Attribute) ProtoMessage() {} func (x *LoadBalancerSettings_ConsistentHashLB_HTTPCookie_Attribute) ProtoReflect() protoreflect.Message { - mi := &file_networking_v1alpha3_destination_rule_proto_msgTypes[18] + mi := &file_networking_v1alpha3_destination_rule_proto_msgTypes[19] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -2425,7 +2561,7 @@ type ConnectionPoolSettings_TCPSettings struct { func (x *ConnectionPoolSettings_TCPSettings) Reset() { *x = ConnectionPoolSettings_TCPSettings{} - mi := &file_networking_v1alpha3_destination_rule_proto_msgTypes[19] + mi := &file_networking_v1alpha3_destination_rule_proto_msgTypes[20] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -2437,7 +2573,7 @@ func (x *ConnectionPoolSettings_TCPSettings) String() string { func (*ConnectionPoolSettings_TCPSettings) ProtoMessage() {} func (x *ConnectionPoolSettings_TCPSettings) ProtoReflect() protoreflect.Message { - mi := &file_networking_v1alpha3_destination_rule_proto_msgTypes[19] + mi := &file_networking_v1alpha3_destination_rule_proto_msgTypes[20] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -2530,7 +2666,7 @@ type ConnectionPoolSettings_HTTPSettings struct { func (x *ConnectionPoolSettings_HTTPSettings) Reset() { *x = ConnectionPoolSettings_HTTPSettings{} - mi := &file_networking_v1alpha3_destination_rule_proto_msgTypes[20] + mi := &file_networking_v1alpha3_destination_rule_proto_msgTypes[21] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -2542,7 +2678,7 @@ func (x *ConnectionPoolSettings_HTTPSettings) String() string { func (*ConnectionPoolSettings_HTTPSettings) ProtoMessage() {} func (x *ConnectionPoolSettings_HTTPSettings) ProtoReflect() protoreflect.Message { - mi := &file_networking_v1alpha3_destination_rule_proto_msgTypes[20] + mi := &file_networking_v1alpha3_destination_rule_proto_msgTypes[21] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -2635,7 +2771,7 @@ type ConnectionPoolSettings_TCPSettings_TcpKeepalive struct { func (x *ConnectionPoolSettings_TCPSettings_TcpKeepalive) Reset() { *x = ConnectionPoolSettings_TCPSettings_TcpKeepalive{} - mi := &file_networking_v1alpha3_destination_rule_proto_msgTypes[21] + mi := &file_networking_v1alpha3_destination_rule_proto_msgTypes[22] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -2647,7 +2783,7 @@ func (x *ConnectionPoolSettings_TCPSettings_TcpKeepalive) String() string { func (*ConnectionPoolSettings_TCPSettings_TcpKeepalive) ProtoMessage() {} func (x *ConnectionPoolSettings_TCPSettings_TcpKeepalive) ProtoReflect() protoreflect.Message { - mi := &file_networking_v1alpha3_destination_rule_proto_msgTypes[21] + mi := &file_networking_v1alpha3_destination_rule_proto_msgTypes[22] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -2684,6 +2820,235 @@ func (x *ConnectionPoolSettings_TCPSettings_TcpKeepalive) GetInterval() *duratio return nil } +// Configuration parameters for the gradient concurrency controller. +// The gradient controller makes forwarding decisions based on a periodically +// measured ideal round-trip time (minRTT) for an upstream. +type AdaptiveConcurrency_GradientControllerConfig struct { + state protoimpl.MessageState `protogen:"open.v1"` + // The percentile to use when summarizing aggregated samples. Defaults to p50. + // Value should be between 0 and 100. + SampleAggregatePercentile *wrappers.DoubleValue `protobuf:"bytes,1,opt,name=sample_aggregate_percentile,json=sampleAggregatePercentile,proto3" json:"sample_aggregate_percentile,omitempty"` + // Parameters for periodic recalculation of the concurrency limit. + ConcurrencyLimitParams *AdaptiveConcurrency_GradientControllerConfig_ConcurrencyLimitCalculationParams `protobuf:"bytes,2,opt,name=concurrency_limit_params,json=concurrencyLimitParams,proto3" json:"concurrency_limit_params,omitempty"` + // Parameters for periodic minRTT recalculation. + MinRttCalcParams *AdaptiveConcurrency_GradientControllerConfig_MinimumRTTCalculationParams `protobuf:"bytes,3,opt,name=min_rtt_calc_params,json=minRttCalcParams,proto3" json:"min_rtt_calc_params,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *AdaptiveConcurrency_GradientControllerConfig) Reset() { + *x = AdaptiveConcurrency_GradientControllerConfig{} + mi := &file_networking_v1alpha3_destination_rule_proto_msgTypes[23] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *AdaptiveConcurrency_GradientControllerConfig) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*AdaptiveConcurrency_GradientControllerConfig) ProtoMessage() {} + +func (x *AdaptiveConcurrency_GradientControllerConfig) ProtoReflect() protoreflect.Message { + mi := &file_networking_v1alpha3_destination_rule_proto_msgTypes[23] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use AdaptiveConcurrency_GradientControllerConfig.ProtoReflect.Descriptor instead. +func (*AdaptiveConcurrency_GradientControllerConfig) Descriptor() ([]byte, []int) { + return file_networking_v1alpha3_destination_rule_proto_rawDescGZIP(), []int{7, 0} +} + +func (x *AdaptiveConcurrency_GradientControllerConfig) GetSampleAggregatePercentile() *wrappers.DoubleValue { + if x != nil { + return x.SampleAggregatePercentile + } + return nil +} + +func (x *AdaptiveConcurrency_GradientControllerConfig) GetConcurrencyLimitParams() *AdaptiveConcurrency_GradientControllerConfig_ConcurrencyLimitCalculationParams { + if x != nil { + return x.ConcurrencyLimitParams + } + return nil +} + +func (x *AdaptiveConcurrency_GradientControllerConfig) GetMinRttCalcParams() *AdaptiveConcurrency_GradientControllerConfig_MinimumRTTCalculationParams { + if x != nil { + return x.MinRttCalcParams + } + return nil +} + +// Parameters controlling the periodic recalculation of the concurrency limit +// from sampled request latencies. +type AdaptiveConcurrency_GradientControllerConfig_ConcurrencyLimitCalculationParams struct { + state protoimpl.MessageState `protogen:"open.v1"` + // The allowed upper-bound on the calculated concurrency limit. Defaults to 1000. + MaxConcurrencyLimit *wrappers.UInt32Value `protobuf:"bytes,2,opt,name=max_concurrency_limit,json=maxConcurrencyLimit,proto3" json:"max_concurrency_limit,omitempty"` + // The period of time samples are taken to recalculate the concurrency limit. + // This is required. + ConcurrencyUpdateInterval *duration.Duration `protobuf:"bytes,3,opt,name=concurrency_update_interval,json=concurrencyUpdateInterval,proto3" json:"concurrency_update_interval,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *AdaptiveConcurrency_GradientControllerConfig_ConcurrencyLimitCalculationParams) Reset() { + *x = AdaptiveConcurrency_GradientControllerConfig_ConcurrencyLimitCalculationParams{} + mi := &file_networking_v1alpha3_destination_rule_proto_msgTypes[24] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *AdaptiveConcurrency_GradientControllerConfig_ConcurrencyLimitCalculationParams) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*AdaptiveConcurrency_GradientControllerConfig_ConcurrencyLimitCalculationParams) ProtoMessage() { +} + +func (x *AdaptiveConcurrency_GradientControllerConfig_ConcurrencyLimitCalculationParams) ProtoReflect() protoreflect.Message { + mi := &file_networking_v1alpha3_destination_rule_proto_msgTypes[24] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use AdaptiveConcurrency_GradientControllerConfig_ConcurrencyLimitCalculationParams.ProtoReflect.Descriptor instead. +func (*AdaptiveConcurrency_GradientControllerConfig_ConcurrencyLimitCalculationParams) Descriptor() ([]byte, []int) { + return file_networking_v1alpha3_destination_rule_proto_rawDescGZIP(), []int{7, 0, 0} +} + +func (x *AdaptiveConcurrency_GradientControllerConfig_ConcurrencyLimitCalculationParams) GetMaxConcurrencyLimit() *wrappers.UInt32Value { + if x != nil { + return x.MaxConcurrencyLimit + } + return nil +} + +func (x *AdaptiveConcurrency_GradientControllerConfig_ConcurrencyLimitCalculationParams) GetConcurrencyUpdateInterval() *duration.Duration { + if x != nil { + return x.ConcurrencyUpdateInterval + } + return nil +} + +// Parameters controlling the periodic minRTT recalculation. +// The minRTT is periodically measured by allowing only a very low outstanding +// request count to an upstream cluster and measuring the latency under +// these ideal conditions. +type AdaptiveConcurrency_GradientControllerConfig_MinimumRTTCalculationParams struct { + state protoimpl.MessageState `protogen:"open.v1"` + // The time interval between recalculating the minimum request round-trip time. + // Has to be positive. If set to zero, dynamic sampling of the minRTT is disabled. + Interval *duration.Duration `protobuf:"bytes,1,opt,name=interval,proto3" json:"interval,omitempty"` + // The fixed value for the minRTT. This value is used when minRTT is not sampled + // dynamically. If dynamic sampling of the minRTT is disabled (i.e. `interval` is + // set to zero), this field must be set. + FixedValue *duration.Duration `protobuf:"bytes,6,opt,name=fixed_value,json=fixedValue,proto3" json:"fixed_value,omitempty"` + // The number of requests to aggregate/sample during the minRTT recalculation + // window before updating. Defaults to 50. + RequestCount *wrappers.UInt32Value `protobuf:"bytes,2,opt,name=request_count,json=requestCount,proto3" json:"request_count,omitempty"` + // Randomized time delta that will be introduced to the start of the minRTT + // calculation window. This is represented as a percentage of the interval duration. + // Defaults to 15%. This is recommended to prevent all hosts in a cluster from + // being in a minRTT calculation window at the same time. + Jitter *wrappers.DoubleValue `protobuf:"bytes,3,opt,name=jitter,proto3" json:"jitter,omitempty"` + // The concurrency limit set while measuring the minRTT. Defaults to 3. + MinConcurrency *wrappers.UInt32Value `protobuf:"bytes,4,opt,name=min_concurrency,json=minConcurrency,proto3" json:"min_concurrency,omitempty"` + // Amount added to the measured minRTT to add stability to the concurrency limit + // during natural variability in latency. This is expressed as a percentage of the + // measured value and can be adjusted to allow more or less tolerance to the sampled + // latency values. Defaults to 25%. + Buffer *wrappers.DoubleValue `protobuf:"bytes,5,opt,name=buffer,proto3" json:"buffer,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *AdaptiveConcurrency_GradientControllerConfig_MinimumRTTCalculationParams) Reset() { + *x = AdaptiveConcurrency_GradientControllerConfig_MinimumRTTCalculationParams{} + mi := &file_networking_v1alpha3_destination_rule_proto_msgTypes[25] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *AdaptiveConcurrency_GradientControllerConfig_MinimumRTTCalculationParams) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*AdaptiveConcurrency_GradientControllerConfig_MinimumRTTCalculationParams) ProtoMessage() {} + +func (x *AdaptiveConcurrency_GradientControllerConfig_MinimumRTTCalculationParams) ProtoReflect() protoreflect.Message { + mi := &file_networking_v1alpha3_destination_rule_proto_msgTypes[25] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use AdaptiveConcurrency_GradientControllerConfig_MinimumRTTCalculationParams.ProtoReflect.Descriptor instead. +func (*AdaptiveConcurrency_GradientControllerConfig_MinimumRTTCalculationParams) Descriptor() ([]byte, []int) { + return file_networking_v1alpha3_destination_rule_proto_rawDescGZIP(), []int{7, 0, 1} +} + +func (x *AdaptiveConcurrency_GradientControllerConfig_MinimumRTTCalculationParams) GetInterval() *duration.Duration { + if x != nil { + return x.Interval + } + return nil +} + +func (x *AdaptiveConcurrency_GradientControllerConfig_MinimumRTTCalculationParams) GetFixedValue() *duration.Duration { + if x != nil { + return x.FixedValue + } + return nil +} + +func (x *AdaptiveConcurrency_GradientControllerConfig_MinimumRTTCalculationParams) GetRequestCount() *wrappers.UInt32Value { + if x != nil { + return x.RequestCount + } + return nil +} + +func (x *AdaptiveConcurrency_GradientControllerConfig_MinimumRTTCalculationParams) GetJitter() *wrappers.DoubleValue { + if x != nil { + return x.Jitter + } + return nil +} + +func (x *AdaptiveConcurrency_GradientControllerConfig_MinimumRTTCalculationParams) GetMinConcurrency() *wrappers.UInt32Value { + if x != nil { + return x.MinConcurrency + } + return nil +} + +func (x *AdaptiveConcurrency_GradientControllerConfig_MinimumRTTCalculationParams) GetBuffer() *wrappers.DoubleValue { + if x != nil { + return x.Buffer + } + return nil +} + // Describes how traffic originating in the 'from' zone or sub-zone is // distributed over a set of 'to' zones. Syntax for specifying a zone is // {region}/{zone}/{sub-zone} and terminal wildcards are allowed on any @@ -2708,7 +3073,7 @@ type LocalityLoadBalancerSetting_Distribute struct { func (x *LocalityLoadBalancerSetting_Distribute) Reset() { *x = LocalityLoadBalancerSetting_Distribute{} - mi := &file_networking_v1alpha3_destination_rule_proto_msgTypes[22] + mi := &file_networking_v1alpha3_destination_rule_proto_msgTypes[26] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -2720,7 +3085,7 @@ func (x *LocalityLoadBalancerSetting_Distribute) String() string { func (*LocalityLoadBalancerSetting_Distribute) ProtoMessage() {} func (x *LocalityLoadBalancerSetting_Distribute) ProtoReflect() protoreflect.Message { - mi := &file_networking_v1alpha3_destination_rule_proto_msgTypes[22] + mi := &file_networking_v1alpha3_destination_rule_proto_msgTypes[26] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -2733,7 +3098,7 @@ func (x *LocalityLoadBalancerSetting_Distribute) ProtoReflect() protoreflect.Mes // Deprecated: Use LocalityLoadBalancerSetting_Distribute.ProtoReflect.Descriptor instead. func (*LocalityLoadBalancerSetting_Distribute) Descriptor() ([]byte, []int) { - return file_networking_v1alpha3_destination_rule_proto_rawDescGZIP(), []int{8, 0} + return file_networking_v1alpha3_destination_rule_proto_rawDescGZIP(), []int{9, 0} } func (x *LocalityLoadBalancerSetting_Distribute) GetFrom() string { @@ -2770,7 +3135,7 @@ type LocalityLoadBalancerSetting_Failover struct { func (x *LocalityLoadBalancerSetting_Failover) Reset() { *x = LocalityLoadBalancerSetting_Failover{} - mi := &file_networking_v1alpha3_destination_rule_proto_msgTypes[23] + mi := &file_networking_v1alpha3_destination_rule_proto_msgTypes[27] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -2782,7 +3147,7 @@ func (x *LocalityLoadBalancerSetting_Failover) String() string { func (*LocalityLoadBalancerSetting_Failover) ProtoMessage() {} func (x *LocalityLoadBalancerSetting_Failover) ProtoReflect() protoreflect.Message { - mi := &file_networking_v1alpha3_destination_rule_proto_msgTypes[23] + mi := &file_networking_v1alpha3_destination_rule_proto_msgTypes[27] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -2795,7 +3160,7 @@ func (x *LocalityLoadBalancerSetting_Failover) ProtoReflect() protoreflect.Messa // Deprecated: Use LocalityLoadBalancerSetting_Failover.ProtoReflect.Descriptor instead. func (*LocalityLoadBalancerSetting_Failover) Descriptor() ([]byte, []int) { - return file_networking_v1alpha3_destination_rule_proto_rawDescGZIP(), []int{8, 1} + return file_networking_v1alpha3_destination_rule_proto_rawDescGZIP(), []int{9, 1} } func (x *LocalityLoadBalancerSetting_Failover) GetFrom() string { @@ -2822,7 +3187,7 @@ const file_networking_v1alpha3_destination_rule_proto_rawDesc = "" + "\x0etraffic_policy\x18\x02 \x01(\v2(.istio.networking.v1alpha3.TrafficPolicyR\rtrafficPolicy\x12;\n" + "\asubsets\x18\x03 \x03(\v2!.istio.networking.v1alpha3.SubsetR\asubsets\x12\x1b\n" + "\texport_to\x18\x04 \x03(\tR\bexportTo\x12Q\n" + - "\x11workload_selector\x18\x05 \x01(\v2$.istio.type.v1beta1.WorkloadSelectorR\x10workloadSelector\"\xed\v\n" + + "\x11workload_selector\x18\x05 \x01(\v2$.istio.type.v1beta1.WorkloadSelectorR\x10workloadSelector\"\xd0\f\n" + "\rTrafficPolicy\x12T\n" + "\rload_balancer\x18\x01 \x01(\v2/.istio.networking.v1alpha3.LoadBalancerSettingsR\floadBalancer\x12Z\n" + "\x0fconnection_pool\x18\x02 \x01(\v21.istio.networking.v1alpha3.ConnectionPoolSettingsR\x0econnectionPool\x12X\n" + @@ -2831,7 +3196,8 @@ const file_networking_v1alpha3_destination_rule_proto_rawDesc = "" + "\x13port_level_settings\x18\x05 \x03(\v2:.istio.networking.v1alpha3.TrafficPolicy.PortTrafficPolicyR\x11portLevelSettings\x12O\n" + "\x06tunnel\x18\x06 \x01(\v27.istio.networking.v1alpha3.TrafficPolicy.TunnelSettingsR\x06tunnel\x12]\n" + "\x0eproxy_protocol\x18\a \x01(\v26.istio.networking.v1alpha3.TrafficPolicy.ProxyProtocolR\rproxyProtocol\x12W\n" + - "\fretry_budget\x18\b \x01(\v24.istio.networking.v1alpha3.TrafficPolicy.RetryBudgetR\vretryBudget\x1a\x9c\x03\n" + + "\fretry_budget\x18\b \x01(\v24.istio.networking.v1alpha3.TrafficPolicy.RetryBudgetR\vretryBudget\x12a\n" + + "\x14adaptive_concurrency\x18\t \x01(\v2..istio.networking.v1alpha3.AdaptiveConcurrencyR\x13adaptiveConcurrency\x1a\x9c\x03\n" + "\x11PortTrafficPolicy\x12;\n" + "\x04port\x18\x01 \x01(\v2'.istio.networking.v1alpha3.PortSelectorR\x04port\x12T\n" + "\rload_balancer\x18\x02 \x01(\v2/.istio.networking.v1alpha3.LoadBalancerSettingsR\floadBalancer\x12Z\n" + @@ -2946,7 +3312,28 @@ const file_networking_v1alpha3_destination_rule_proto_rawDesc = "" + "\binterval\x18\x02 \x01(\v2\x19.google.protobuf.DurationR\binterval\x12G\n" + "\x12base_ejection_time\x18\x03 \x01(\v2\x19.google.protobuf.DurationR\x10baseEjectionTime\x120\n" + "\x14max_ejection_percent\x18\x04 \x01(\x05R\x12maxEjectionPercent\x12,\n" + - "\x12min_health_percent\x18\x05 \x01(\x05R\x10minHealthPercent\"\xe4\x03\n" + + "\x12min_health_percent\x18\x05 \x01(\x05R\x10minHealthPercent\"\xc9\n" + + "\n" + + "\x13AdaptiveConcurrency\x12\x87\x01\n" + + "\x1agradient_controller_config\x18\x01 \x01(\v2G.istio.networking.v1alpha3.AdaptiveConcurrency.GradientControllerConfigH\x00R\x18gradientControllerConfig\x12\x18\n" + + "\aenabled\x18\x02 \x01(\bR\aenabled\x12I\n" + + "!concurrency_limit_exceeded_status\x18\x03 \x01(\rR\x1econcurrencyLimitExceededStatus\x1a\xa1\b\n" + + "\x18GradientControllerConfig\x12\\\n" + + "\x1bsample_aggregate_percentile\x18\x01 \x01(\v2\x1c.google.protobuf.DoubleValueR\x19sampleAggregatePercentile\x12\xa9\x01\n" + + "\x18concurrency_limit_params\x18\x02 \x01(\v2i.istio.networking.v1alpha3.AdaptiveConcurrency.GradientControllerConfig.ConcurrencyLimitCalculationParamsB\x04\xe2A\x01\x02R\x16concurrencyLimitParams\x12\x98\x01\n" + + "\x13min_rtt_calc_params\x18\x03 \x01(\v2c.istio.networking.v1alpha3.AdaptiveConcurrency.GradientControllerConfig.MinimumRTTCalculationParamsB\x04\xe2A\x01\x02R\x10minRttCalcParams\x1a\xd6\x01\n" + + "!ConcurrencyLimitCalculationParams\x12P\n" + + "\x15max_concurrency_limit\x18\x02 \x01(\v2\x1c.google.protobuf.UInt32ValueR\x13maxConcurrencyLimit\x12_\n" + + "\x1bconcurrency_update_interval\x18\x03 \x01(\v2\x19.google.protobuf.DurationB\x04\xe2A\x01\x02R\x19concurrencyUpdateInterval\x1a\x86\x03\n" + + "\x1bMinimumRTTCalculationParams\x125\n" + + "\binterval\x18\x01 \x01(\v2\x19.google.protobuf.DurationR\binterval\x12:\n" + + "\vfixed_value\x18\x06 \x01(\v2\x19.google.protobuf.DurationR\n" + + "fixedValue\x12A\n" + + "\rrequest_count\x18\x02 \x01(\v2\x1c.google.protobuf.UInt32ValueR\frequestCount\x124\n" + + "\x06jitter\x18\x03 \x01(\v2\x1c.google.protobuf.DoubleValueR\x06jitter\x12E\n" + + "\x0fmin_concurrency\x18\x04 \x01(\v2\x1c.google.protobuf.UInt32ValueR\x0eminConcurrency\x124\n" + + "\x06buffer\x18\x05 \x01(\v2\x1c.google.protobuf.DoubleValueR\x06bufferB\x1f\n" + + "\x1dconcurrency_controller_config\"\xe4\x03\n" + "\x11ClientTLSSettings\x12H\n" + "\x04mode\x18\x01 \x01(\x0e24.istio.networking.v1alpha3.ClientTLSSettings.TLSmodeR\x04mode\x12-\n" + "\x12client_certificate\x18\x02 \x01(\tR\x11clientCertificate\x12\x1f\n" + @@ -2996,7 +3383,7 @@ func file_networking_v1alpha3_destination_rule_proto_rawDescGZIP() []byte { } var file_networking_v1alpha3_destination_rule_proto_enumTypes = make([]protoimpl.EnumInfo, 4) -var file_networking_v1alpha3_destination_rule_proto_msgTypes = make([]protoimpl.MessageInfo, 25) +var file_networking_v1alpha3_destination_rule_proto_msgTypes = make([]protoimpl.MessageInfo, 29) var file_networking_v1alpha3_destination_rule_proto_goTypes = []any{ (TrafficPolicy_ProxyProtocol_VERSION)(0), // 0: istio.networking.v1alpha3.TrafficPolicy.ProxyProtocol.VERSION (LoadBalancerSettings_SimpleLB)(0), // 1: istio.networking.v1alpha3.LoadBalancerSettings.SimpleLB @@ -3009,91 +3396,108 @@ var file_networking_v1alpha3_destination_rule_proto_goTypes = []any{ (*WarmupConfiguration)(nil), // 8: istio.networking.v1alpha3.WarmupConfiguration (*ConnectionPoolSettings)(nil), // 9: istio.networking.v1alpha3.ConnectionPoolSettings (*OutlierDetection)(nil), // 10: istio.networking.v1alpha3.OutlierDetection - (*ClientTLSSettings)(nil), // 11: istio.networking.v1alpha3.ClientTLSSettings - (*LocalityLoadBalancerSetting)(nil), // 12: istio.networking.v1alpha3.LocalityLoadBalancerSetting - (*TrafficPolicy_PortTrafficPolicy)(nil), // 13: istio.networking.v1alpha3.TrafficPolicy.PortTrafficPolicy - (*TrafficPolicy_TunnelSettings)(nil), // 14: istio.networking.v1alpha3.TrafficPolicy.TunnelSettings - (*TrafficPolicy_ProxyProtocol)(nil), // 15: istio.networking.v1alpha3.TrafficPolicy.ProxyProtocol - (*TrafficPolicy_RetryBudget)(nil), // 16: istio.networking.v1alpha3.TrafficPolicy.RetryBudget - nil, // 17: istio.networking.v1alpha3.Subset.LabelsEntry - (*LoadBalancerSettings_ConsistentHashLB)(nil), // 18: istio.networking.v1alpha3.LoadBalancerSettings.ConsistentHashLB - (*LoadBalancerSettings_ConsistentHashLB_RingHash)(nil), // 19: istio.networking.v1alpha3.LoadBalancerSettings.ConsistentHashLB.RingHash - (*LoadBalancerSettings_ConsistentHashLB_MagLev)(nil), // 20: istio.networking.v1alpha3.LoadBalancerSettings.ConsistentHashLB.MagLev - (*LoadBalancerSettings_ConsistentHashLB_HTTPCookie)(nil), // 21: istio.networking.v1alpha3.LoadBalancerSettings.ConsistentHashLB.HTTPCookie - (*LoadBalancerSettings_ConsistentHashLB_HTTPCookie_Attribute)(nil), // 22: istio.networking.v1alpha3.LoadBalancerSettings.ConsistentHashLB.HTTPCookie.Attribute - (*ConnectionPoolSettings_TCPSettings)(nil), // 23: istio.networking.v1alpha3.ConnectionPoolSettings.TCPSettings - (*ConnectionPoolSettings_HTTPSettings)(nil), // 24: istio.networking.v1alpha3.ConnectionPoolSettings.HTTPSettings - (*ConnectionPoolSettings_TCPSettings_TcpKeepalive)(nil), // 25: istio.networking.v1alpha3.ConnectionPoolSettings.TCPSettings.TcpKeepalive - (*LocalityLoadBalancerSetting_Distribute)(nil), // 26: istio.networking.v1alpha3.LocalityLoadBalancerSetting.Distribute - (*LocalityLoadBalancerSetting_Failover)(nil), // 27: istio.networking.v1alpha3.LocalityLoadBalancerSetting.Failover - nil, // 28: istio.networking.v1alpha3.LocalityLoadBalancerSetting.Distribute.ToEntry - (*v1beta1.WorkloadSelector)(nil), // 29: istio.type.v1beta1.WorkloadSelector - (*duration.Duration)(nil), // 30: google.protobuf.Duration - (*wrappers.DoubleValue)(nil), // 31: google.protobuf.DoubleValue - (*wrappers.UInt32Value)(nil), // 32: google.protobuf.UInt32Value - (*wrappers.BoolValue)(nil), // 33: google.protobuf.BoolValue - (*PortSelector)(nil), // 34: istio.networking.v1alpha3.PortSelector + (*AdaptiveConcurrency)(nil), // 11: istio.networking.v1alpha3.AdaptiveConcurrency + (*ClientTLSSettings)(nil), // 12: istio.networking.v1alpha3.ClientTLSSettings + (*LocalityLoadBalancerSetting)(nil), // 13: istio.networking.v1alpha3.LocalityLoadBalancerSetting + (*TrafficPolicy_PortTrafficPolicy)(nil), // 14: istio.networking.v1alpha3.TrafficPolicy.PortTrafficPolicy + (*TrafficPolicy_TunnelSettings)(nil), // 15: istio.networking.v1alpha3.TrafficPolicy.TunnelSettings + (*TrafficPolicy_ProxyProtocol)(nil), // 16: istio.networking.v1alpha3.TrafficPolicy.ProxyProtocol + (*TrafficPolicy_RetryBudget)(nil), // 17: istio.networking.v1alpha3.TrafficPolicy.RetryBudget + nil, // 18: istio.networking.v1alpha3.Subset.LabelsEntry + (*LoadBalancerSettings_ConsistentHashLB)(nil), // 19: istio.networking.v1alpha3.LoadBalancerSettings.ConsistentHashLB + (*LoadBalancerSettings_ConsistentHashLB_RingHash)(nil), // 20: istio.networking.v1alpha3.LoadBalancerSettings.ConsistentHashLB.RingHash + (*LoadBalancerSettings_ConsistentHashLB_MagLev)(nil), // 21: istio.networking.v1alpha3.LoadBalancerSettings.ConsistentHashLB.MagLev + (*LoadBalancerSettings_ConsistentHashLB_HTTPCookie)(nil), // 22: istio.networking.v1alpha3.LoadBalancerSettings.ConsistentHashLB.HTTPCookie + (*LoadBalancerSettings_ConsistentHashLB_HTTPCookie_Attribute)(nil), // 23: istio.networking.v1alpha3.LoadBalancerSettings.ConsistentHashLB.HTTPCookie.Attribute + (*ConnectionPoolSettings_TCPSettings)(nil), // 24: istio.networking.v1alpha3.ConnectionPoolSettings.TCPSettings + (*ConnectionPoolSettings_HTTPSettings)(nil), // 25: istio.networking.v1alpha3.ConnectionPoolSettings.HTTPSettings + (*ConnectionPoolSettings_TCPSettings_TcpKeepalive)(nil), // 26: istio.networking.v1alpha3.ConnectionPoolSettings.TCPSettings.TcpKeepalive + (*AdaptiveConcurrency_GradientControllerConfig)(nil), // 27: istio.networking.v1alpha3.AdaptiveConcurrency.GradientControllerConfig + (*AdaptiveConcurrency_GradientControllerConfig_ConcurrencyLimitCalculationParams)(nil), // 28: istio.networking.v1alpha3.AdaptiveConcurrency.GradientControllerConfig.ConcurrencyLimitCalculationParams + (*AdaptiveConcurrency_GradientControllerConfig_MinimumRTTCalculationParams)(nil), // 29: istio.networking.v1alpha3.AdaptiveConcurrency.GradientControllerConfig.MinimumRTTCalculationParams + (*LocalityLoadBalancerSetting_Distribute)(nil), // 30: istio.networking.v1alpha3.LocalityLoadBalancerSetting.Distribute + (*LocalityLoadBalancerSetting_Failover)(nil), // 31: istio.networking.v1alpha3.LocalityLoadBalancerSetting.Failover + nil, // 32: istio.networking.v1alpha3.LocalityLoadBalancerSetting.Distribute.ToEntry + (*v1beta1.WorkloadSelector)(nil), // 33: istio.type.v1beta1.WorkloadSelector + (*duration.Duration)(nil), // 34: google.protobuf.Duration + (*wrappers.DoubleValue)(nil), // 35: google.protobuf.DoubleValue + (*wrappers.UInt32Value)(nil), // 36: google.protobuf.UInt32Value + (*wrappers.BoolValue)(nil), // 37: google.protobuf.BoolValue + (*PortSelector)(nil), // 38: istio.networking.v1alpha3.PortSelector } var file_networking_v1alpha3_destination_rule_proto_depIdxs = []int32{ 5, // 0: istio.networking.v1alpha3.DestinationRule.traffic_policy:type_name -> istio.networking.v1alpha3.TrafficPolicy 6, // 1: istio.networking.v1alpha3.DestinationRule.subsets:type_name -> istio.networking.v1alpha3.Subset - 29, // 2: istio.networking.v1alpha3.DestinationRule.workload_selector:type_name -> istio.type.v1beta1.WorkloadSelector + 33, // 2: istio.networking.v1alpha3.DestinationRule.workload_selector:type_name -> istio.type.v1beta1.WorkloadSelector 7, // 3: istio.networking.v1alpha3.TrafficPolicy.load_balancer:type_name -> istio.networking.v1alpha3.LoadBalancerSettings 9, // 4: istio.networking.v1alpha3.TrafficPolicy.connection_pool:type_name -> istio.networking.v1alpha3.ConnectionPoolSettings 10, // 5: istio.networking.v1alpha3.TrafficPolicy.outlier_detection:type_name -> istio.networking.v1alpha3.OutlierDetection - 11, // 6: istio.networking.v1alpha3.TrafficPolicy.tls:type_name -> istio.networking.v1alpha3.ClientTLSSettings - 13, // 7: istio.networking.v1alpha3.TrafficPolicy.port_level_settings:type_name -> istio.networking.v1alpha3.TrafficPolicy.PortTrafficPolicy - 14, // 8: istio.networking.v1alpha3.TrafficPolicy.tunnel:type_name -> istio.networking.v1alpha3.TrafficPolicy.TunnelSettings - 15, // 9: istio.networking.v1alpha3.TrafficPolicy.proxy_protocol:type_name -> istio.networking.v1alpha3.TrafficPolicy.ProxyProtocol - 16, // 10: istio.networking.v1alpha3.TrafficPolicy.retry_budget:type_name -> istio.networking.v1alpha3.TrafficPolicy.RetryBudget - 17, // 11: istio.networking.v1alpha3.Subset.labels:type_name -> istio.networking.v1alpha3.Subset.LabelsEntry - 5, // 12: istio.networking.v1alpha3.Subset.traffic_policy:type_name -> istio.networking.v1alpha3.TrafficPolicy - 1, // 13: istio.networking.v1alpha3.LoadBalancerSettings.simple:type_name -> istio.networking.v1alpha3.LoadBalancerSettings.SimpleLB - 18, // 14: istio.networking.v1alpha3.LoadBalancerSettings.consistent_hash:type_name -> istio.networking.v1alpha3.LoadBalancerSettings.ConsistentHashLB - 12, // 15: istio.networking.v1alpha3.LoadBalancerSettings.locality_lb_setting:type_name -> istio.networking.v1alpha3.LocalityLoadBalancerSetting - 30, // 16: istio.networking.v1alpha3.LoadBalancerSettings.warmup_duration_secs:type_name -> google.protobuf.Duration - 8, // 17: istio.networking.v1alpha3.LoadBalancerSettings.warmup:type_name -> istio.networking.v1alpha3.WarmupConfiguration - 30, // 18: istio.networking.v1alpha3.WarmupConfiguration.duration:type_name -> google.protobuf.Duration - 31, // 19: istio.networking.v1alpha3.WarmupConfiguration.minimum_percent:type_name -> google.protobuf.DoubleValue - 31, // 20: istio.networking.v1alpha3.WarmupConfiguration.aggression:type_name -> google.protobuf.DoubleValue - 23, // 21: istio.networking.v1alpha3.ConnectionPoolSettings.tcp:type_name -> istio.networking.v1alpha3.ConnectionPoolSettings.TCPSettings - 24, // 22: istio.networking.v1alpha3.ConnectionPoolSettings.http:type_name -> istio.networking.v1alpha3.ConnectionPoolSettings.HTTPSettings - 32, // 23: istio.networking.v1alpha3.OutlierDetection.consecutive_local_origin_failures:type_name -> google.protobuf.UInt32Value - 32, // 24: istio.networking.v1alpha3.OutlierDetection.consecutive_gateway_errors:type_name -> google.protobuf.UInt32Value - 32, // 25: istio.networking.v1alpha3.OutlierDetection.consecutive_5xx_errors:type_name -> google.protobuf.UInt32Value - 30, // 26: istio.networking.v1alpha3.OutlierDetection.interval:type_name -> google.protobuf.Duration - 30, // 27: istio.networking.v1alpha3.OutlierDetection.base_ejection_time:type_name -> google.protobuf.Duration - 3, // 28: istio.networking.v1alpha3.ClientTLSSettings.mode:type_name -> istio.networking.v1alpha3.ClientTLSSettings.TLSmode - 33, // 29: istio.networking.v1alpha3.ClientTLSSettings.insecure_skip_verify:type_name -> google.protobuf.BoolValue - 26, // 30: istio.networking.v1alpha3.LocalityLoadBalancerSetting.distribute:type_name -> istio.networking.v1alpha3.LocalityLoadBalancerSetting.Distribute - 27, // 31: istio.networking.v1alpha3.LocalityLoadBalancerSetting.failover:type_name -> istio.networking.v1alpha3.LocalityLoadBalancerSetting.Failover - 33, // 32: istio.networking.v1alpha3.LocalityLoadBalancerSetting.enabled:type_name -> google.protobuf.BoolValue - 34, // 33: istio.networking.v1alpha3.TrafficPolicy.PortTrafficPolicy.port:type_name -> istio.networking.v1alpha3.PortSelector - 7, // 34: istio.networking.v1alpha3.TrafficPolicy.PortTrafficPolicy.load_balancer:type_name -> istio.networking.v1alpha3.LoadBalancerSettings - 9, // 35: istio.networking.v1alpha3.TrafficPolicy.PortTrafficPolicy.connection_pool:type_name -> istio.networking.v1alpha3.ConnectionPoolSettings - 10, // 36: istio.networking.v1alpha3.TrafficPolicy.PortTrafficPolicy.outlier_detection:type_name -> istio.networking.v1alpha3.OutlierDetection - 11, // 37: istio.networking.v1alpha3.TrafficPolicy.PortTrafficPolicy.tls:type_name -> istio.networking.v1alpha3.ClientTLSSettings - 0, // 38: istio.networking.v1alpha3.TrafficPolicy.ProxyProtocol.version:type_name -> istio.networking.v1alpha3.TrafficPolicy.ProxyProtocol.VERSION - 31, // 39: istio.networking.v1alpha3.TrafficPolicy.RetryBudget.percent:type_name -> google.protobuf.DoubleValue - 21, // 40: istio.networking.v1alpha3.LoadBalancerSettings.ConsistentHashLB.http_cookie:type_name -> istio.networking.v1alpha3.LoadBalancerSettings.ConsistentHashLB.HTTPCookie - 19, // 41: istio.networking.v1alpha3.LoadBalancerSettings.ConsistentHashLB.ring_hash:type_name -> istio.networking.v1alpha3.LoadBalancerSettings.ConsistentHashLB.RingHash - 20, // 42: istio.networking.v1alpha3.LoadBalancerSettings.ConsistentHashLB.maglev:type_name -> istio.networking.v1alpha3.LoadBalancerSettings.ConsistentHashLB.MagLev - 30, // 43: istio.networking.v1alpha3.LoadBalancerSettings.ConsistentHashLB.HTTPCookie.ttl:type_name -> google.protobuf.Duration - 22, // 44: istio.networking.v1alpha3.LoadBalancerSettings.ConsistentHashLB.HTTPCookie.attributes:type_name -> istio.networking.v1alpha3.LoadBalancerSettings.ConsistentHashLB.HTTPCookie.Attribute - 30, // 45: istio.networking.v1alpha3.ConnectionPoolSettings.TCPSettings.connect_timeout:type_name -> google.protobuf.Duration - 25, // 46: istio.networking.v1alpha3.ConnectionPoolSettings.TCPSettings.tcp_keepalive:type_name -> istio.networking.v1alpha3.ConnectionPoolSettings.TCPSettings.TcpKeepalive - 30, // 47: istio.networking.v1alpha3.ConnectionPoolSettings.TCPSettings.max_connection_duration:type_name -> google.protobuf.Duration - 30, // 48: istio.networking.v1alpha3.ConnectionPoolSettings.TCPSettings.idle_timeout:type_name -> google.protobuf.Duration - 30, // 49: istio.networking.v1alpha3.ConnectionPoolSettings.HTTPSettings.idle_timeout:type_name -> google.protobuf.Duration - 2, // 50: istio.networking.v1alpha3.ConnectionPoolSettings.HTTPSettings.h2_upgrade_policy:type_name -> istio.networking.v1alpha3.ConnectionPoolSettings.HTTPSettings.H2UpgradePolicy - 30, // 51: istio.networking.v1alpha3.ConnectionPoolSettings.TCPSettings.TcpKeepalive.time:type_name -> google.protobuf.Duration - 30, // 52: istio.networking.v1alpha3.ConnectionPoolSettings.TCPSettings.TcpKeepalive.interval:type_name -> google.protobuf.Duration - 28, // 53: istio.networking.v1alpha3.LocalityLoadBalancerSetting.Distribute.to:type_name -> istio.networking.v1alpha3.LocalityLoadBalancerSetting.Distribute.ToEntry - 54, // [54:54] is the sub-list for method output_type - 54, // [54:54] is the sub-list for method input_type - 54, // [54:54] is the sub-list for extension type_name - 54, // [54:54] is the sub-list for extension extendee - 0, // [0:54] is the sub-list for field type_name + 12, // 6: istio.networking.v1alpha3.TrafficPolicy.tls:type_name -> istio.networking.v1alpha3.ClientTLSSettings + 14, // 7: istio.networking.v1alpha3.TrafficPolicy.port_level_settings:type_name -> istio.networking.v1alpha3.TrafficPolicy.PortTrafficPolicy + 15, // 8: istio.networking.v1alpha3.TrafficPolicy.tunnel:type_name -> istio.networking.v1alpha3.TrafficPolicy.TunnelSettings + 16, // 9: istio.networking.v1alpha3.TrafficPolicy.proxy_protocol:type_name -> istio.networking.v1alpha3.TrafficPolicy.ProxyProtocol + 17, // 10: istio.networking.v1alpha3.TrafficPolicy.retry_budget:type_name -> istio.networking.v1alpha3.TrafficPolicy.RetryBudget + 11, // 11: istio.networking.v1alpha3.TrafficPolicy.adaptive_concurrency:type_name -> istio.networking.v1alpha3.AdaptiveConcurrency + 18, // 12: istio.networking.v1alpha3.Subset.labels:type_name -> istio.networking.v1alpha3.Subset.LabelsEntry + 5, // 13: istio.networking.v1alpha3.Subset.traffic_policy:type_name -> istio.networking.v1alpha3.TrafficPolicy + 1, // 14: istio.networking.v1alpha3.LoadBalancerSettings.simple:type_name -> istio.networking.v1alpha3.LoadBalancerSettings.SimpleLB + 19, // 15: istio.networking.v1alpha3.LoadBalancerSettings.consistent_hash:type_name -> istio.networking.v1alpha3.LoadBalancerSettings.ConsistentHashLB + 13, // 16: istio.networking.v1alpha3.LoadBalancerSettings.locality_lb_setting:type_name -> istio.networking.v1alpha3.LocalityLoadBalancerSetting + 34, // 17: istio.networking.v1alpha3.LoadBalancerSettings.warmup_duration_secs:type_name -> google.protobuf.Duration + 8, // 18: istio.networking.v1alpha3.LoadBalancerSettings.warmup:type_name -> istio.networking.v1alpha3.WarmupConfiguration + 34, // 19: istio.networking.v1alpha3.WarmupConfiguration.duration:type_name -> google.protobuf.Duration + 35, // 20: istio.networking.v1alpha3.WarmupConfiguration.minimum_percent:type_name -> google.protobuf.DoubleValue + 35, // 21: istio.networking.v1alpha3.WarmupConfiguration.aggression:type_name -> google.protobuf.DoubleValue + 24, // 22: istio.networking.v1alpha3.ConnectionPoolSettings.tcp:type_name -> istio.networking.v1alpha3.ConnectionPoolSettings.TCPSettings + 25, // 23: istio.networking.v1alpha3.ConnectionPoolSettings.http:type_name -> istio.networking.v1alpha3.ConnectionPoolSettings.HTTPSettings + 36, // 24: istio.networking.v1alpha3.OutlierDetection.consecutive_local_origin_failures:type_name -> google.protobuf.UInt32Value + 36, // 25: istio.networking.v1alpha3.OutlierDetection.consecutive_gateway_errors:type_name -> google.protobuf.UInt32Value + 36, // 26: istio.networking.v1alpha3.OutlierDetection.consecutive_5xx_errors:type_name -> google.protobuf.UInt32Value + 34, // 27: istio.networking.v1alpha3.OutlierDetection.interval:type_name -> google.protobuf.Duration + 34, // 28: istio.networking.v1alpha3.OutlierDetection.base_ejection_time:type_name -> google.protobuf.Duration + 27, // 29: istio.networking.v1alpha3.AdaptiveConcurrency.gradient_controller_config:type_name -> istio.networking.v1alpha3.AdaptiveConcurrency.GradientControllerConfig + 3, // 30: istio.networking.v1alpha3.ClientTLSSettings.mode:type_name -> istio.networking.v1alpha3.ClientTLSSettings.TLSmode + 37, // 31: istio.networking.v1alpha3.ClientTLSSettings.insecure_skip_verify:type_name -> google.protobuf.BoolValue + 30, // 32: istio.networking.v1alpha3.LocalityLoadBalancerSetting.distribute:type_name -> istio.networking.v1alpha3.LocalityLoadBalancerSetting.Distribute + 31, // 33: istio.networking.v1alpha3.LocalityLoadBalancerSetting.failover:type_name -> istio.networking.v1alpha3.LocalityLoadBalancerSetting.Failover + 37, // 34: istio.networking.v1alpha3.LocalityLoadBalancerSetting.enabled:type_name -> google.protobuf.BoolValue + 38, // 35: istio.networking.v1alpha3.TrafficPolicy.PortTrafficPolicy.port:type_name -> istio.networking.v1alpha3.PortSelector + 7, // 36: istio.networking.v1alpha3.TrafficPolicy.PortTrafficPolicy.load_balancer:type_name -> istio.networking.v1alpha3.LoadBalancerSettings + 9, // 37: istio.networking.v1alpha3.TrafficPolicy.PortTrafficPolicy.connection_pool:type_name -> istio.networking.v1alpha3.ConnectionPoolSettings + 10, // 38: istio.networking.v1alpha3.TrafficPolicy.PortTrafficPolicy.outlier_detection:type_name -> istio.networking.v1alpha3.OutlierDetection + 12, // 39: istio.networking.v1alpha3.TrafficPolicy.PortTrafficPolicy.tls:type_name -> istio.networking.v1alpha3.ClientTLSSettings + 0, // 40: istio.networking.v1alpha3.TrafficPolicy.ProxyProtocol.version:type_name -> istio.networking.v1alpha3.TrafficPolicy.ProxyProtocol.VERSION + 35, // 41: istio.networking.v1alpha3.TrafficPolicy.RetryBudget.percent:type_name -> google.protobuf.DoubleValue + 22, // 42: istio.networking.v1alpha3.LoadBalancerSettings.ConsistentHashLB.http_cookie:type_name -> istio.networking.v1alpha3.LoadBalancerSettings.ConsistentHashLB.HTTPCookie + 20, // 43: istio.networking.v1alpha3.LoadBalancerSettings.ConsistentHashLB.ring_hash:type_name -> istio.networking.v1alpha3.LoadBalancerSettings.ConsistentHashLB.RingHash + 21, // 44: istio.networking.v1alpha3.LoadBalancerSettings.ConsistentHashLB.maglev:type_name -> istio.networking.v1alpha3.LoadBalancerSettings.ConsistentHashLB.MagLev + 34, // 45: istio.networking.v1alpha3.LoadBalancerSettings.ConsistentHashLB.HTTPCookie.ttl:type_name -> google.protobuf.Duration + 23, // 46: istio.networking.v1alpha3.LoadBalancerSettings.ConsistentHashLB.HTTPCookie.attributes:type_name -> istio.networking.v1alpha3.LoadBalancerSettings.ConsistentHashLB.HTTPCookie.Attribute + 34, // 47: istio.networking.v1alpha3.ConnectionPoolSettings.TCPSettings.connect_timeout:type_name -> google.protobuf.Duration + 26, // 48: istio.networking.v1alpha3.ConnectionPoolSettings.TCPSettings.tcp_keepalive:type_name -> istio.networking.v1alpha3.ConnectionPoolSettings.TCPSettings.TcpKeepalive + 34, // 49: istio.networking.v1alpha3.ConnectionPoolSettings.TCPSettings.max_connection_duration:type_name -> google.protobuf.Duration + 34, // 50: istio.networking.v1alpha3.ConnectionPoolSettings.TCPSettings.idle_timeout:type_name -> google.protobuf.Duration + 34, // 51: istio.networking.v1alpha3.ConnectionPoolSettings.HTTPSettings.idle_timeout:type_name -> google.protobuf.Duration + 2, // 52: istio.networking.v1alpha3.ConnectionPoolSettings.HTTPSettings.h2_upgrade_policy:type_name -> istio.networking.v1alpha3.ConnectionPoolSettings.HTTPSettings.H2UpgradePolicy + 34, // 53: istio.networking.v1alpha3.ConnectionPoolSettings.TCPSettings.TcpKeepalive.time:type_name -> google.protobuf.Duration + 34, // 54: istio.networking.v1alpha3.ConnectionPoolSettings.TCPSettings.TcpKeepalive.interval:type_name -> google.protobuf.Duration + 35, // 55: istio.networking.v1alpha3.AdaptiveConcurrency.GradientControllerConfig.sample_aggregate_percentile:type_name -> google.protobuf.DoubleValue + 28, // 56: istio.networking.v1alpha3.AdaptiveConcurrency.GradientControllerConfig.concurrency_limit_params:type_name -> istio.networking.v1alpha3.AdaptiveConcurrency.GradientControllerConfig.ConcurrencyLimitCalculationParams + 29, // 57: istio.networking.v1alpha3.AdaptiveConcurrency.GradientControllerConfig.min_rtt_calc_params:type_name -> istio.networking.v1alpha3.AdaptiveConcurrency.GradientControllerConfig.MinimumRTTCalculationParams + 36, // 58: istio.networking.v1alpha3.AdaptiveConcurrency.GradientControllerConfig.ConcurrencyLimitCalculationParams.max_concurrency_limit:type_name -> google.protobuf.UInt32Value + 34, // 59: istio.networking.v1alpha3.AdaptiveConcurrency.GradientControllerConfig.ConcurrencyLimitCalculationParams.concurrency_update_interval:type_name -> google.protobuf.Duration + 34, // 60: istio.networking.v1alpha3.AdaptiveConcurrency.GradientControllerConfig.MinimumRTTCalculationParams.interval:type_name -> google.protobuf.Duration + 34, // 61: istio.networking.v1alpha3.AdaptiveConcurrency.GradientControllerConfig.MinimumRTTCalculationParams.fixed_value:type_name -> google.protobuf.Duration + 36, // 62: istio.networking.v1alpha3.AdaptiveConcurrency.GradientControllerConfig.MinimumRTTCalculationParams.request_count:type_name -> google.protobuf.UInt32Value + 35, // 63: istio.networking.v1alpha3.AdaptiveConcurrency.GradientControllerConfig.MinimumRTTCalculationParams.jitter:type_name -> google.protobuf.DoubleValue + 36, // 64: istio.networking.v1alpha3.AdaptiveConcurrency.GradientControllerConfig.MinimumRTTCalculationParams.min_concurrency:type_name -> google.protobuf.UInt32Value + 35, // 65: istio.networking.v1alpha3.AdaptiveConcurrency.GradientControllerConfig.MinimumRTTCalculationParams.buffer:type_name -> google.protobuf.DoubleValue + 32, // 66: istio.networking.v1alpha3.LocalityLoadBalancerSetting.Distribute.to:type_name -> istio.networking.v1alpha3.LocalityLoadBalancerSetting.Distribute.ToEntry + 67, // [67:67] is the sub-list for method output_type + 67, // [67:67] is the sub-list for method input_type + 67, // [67:67] is the sub-list for extension type_name + 67, // [67:67] is the sub-list for extension extendee + 0, // [0:67] is the sub-list for field type_name } func init() { file_networking_v1alpha3_destination_rule_proto_init() } @@ -3106,7 +3510,10 @@ func file_networking_v1alpha3_destination_rule_proto_init() { (*LoadBalancerSettings_Simple)(nil), (*LoadBalancerSettings_ConsistentHash)(nil), } - file_networking_v1alpha3_destination_rule_proto_msgTypes[14].OneofWrappers = []any{ + file_networking_v1alpha3_destination_rule_proto_msgTypes[7].OneofWrappers = []any{ + (*AdaptiveConcurrency_GradientControllerConfig_)(nil), + } + file_networking_v1alpha3_destination_rule_proto_msgTypes[15].OneofWrappers = []any{ (*LoadBalancerSettings_ConsistentHashLB_HttpHeaderName)(nil), (*LoadBalancerSettings_ConsistentHashLB_HttpCookie)(nil), (*LoadBalancerSettings_ConsistentHashLB_UseSourceIp)(nil), @@ -3120,7 +3527,7 @@ func file_networking_v1alpha3_destination_rule_proto_init() { GoPackagePath: reflect.TypeOf(x{}).PkgPath(), RawDescriptor: unsafe.Slice(unsafe.StringData(file_networking_v1alpha3_destination_rule_proto_rawDesc), len(file_networking_v1alpha3_destination_rule_proto_rawDesc)), NumEnums: 4, - NumMessages: 25, + NumMessages: 29, NumExtensions: 0, NumServices: 0, }, diff --git a/networking/v1alpha3/destination_rule.pb.html b/networking/v1alpha3/destination_rule.pb.html index d465b81f6a..781f85bc15 100644 --- a/networking/v1alpha3/destination_rule.pb.html +++ b/networking/v1alpha3/destination_rule.pb.html @@ -6,7 +6,7 @@ generator: protoc-gen-docs schema: istio.networking.v1alpha3.DestinationRule aliases: [/docs/reference/config/networking/v1alpha3/destination-rule] -number_of_entries: 28 +number_of_entries: 32 ---

DestinationRule defines policies that apply to traffic intended for a service after routing has occurred. These rules specify configuration @@ -276,6 +276,17 @@

TrafficPolicy

Specifies a limit on concurrent retries in relation to the number of active requests.

+ + + +
adaptiveConcurrency
+
AdaptiveConcurrency
+
+ +

Adaptive concurrency settings for dynamically adjusting the allowed number of +outstanding requests based on sampled latencies. This enables the Envoy +adaptive concurrency filter for the destination.

+ @@ -1470,6 +1481,244 @@

OutlierDetection

disabled by setting it to 0%. The default is 0% as it’s not typically applicable in k8s environments with few pods per service.

+ + + + + +

AdaptiveConcurrency

+
+

Adaptive concurrency settings for dynamically adjusting the allowed number of +outstanding requests based on sampled latencies. See Envoy’s +adaptive concurrency filter +for more details.

+

The following example configures adaptive concurrency for the my-service +service with a gradient controller:

+
apiVersion: networking.istio.io/v1
+kind: DestinationRule
+metadata:
+  name: my-service-adaptive
+spec:
+  host: my-service.default.svc.cluster.local
+  trafficPolicy:
+    adaptiveConcurrency:
+      enabled: true
+      gradientControllerConfig:
+        sampleAggregatePercentile: 50
+        concurrencyLimitParams:
+          maxConcurrencyLimit: 1000
+          concurrencyUpdateInterval: 100ms
+        minRttCalcParams:
+          interval: 60s
+          requestCount: 50
+          jitter: 10
+          minConcurrency: 3
+          buffer: 25
+      concurrencyLimitExceededStatus: 503
+
+ + + + + + + + + + + + + + + + + + + + + + +
FieldDescription
gradientControllerConfig
+
GradientControllerConfig (oneof)
+
 +

Gradient concurrency control will be used.

+ +
enabled
+
bool
+
 +

If set to false, the adaptive concurrency filter will operate as a pass-through +filter. If unspecified, the filter will be enabled.

+ +
concurrencyLimitExceededStatus
+
uint32
+
 +

Custom HTTP response status code to the downstream client when +the concurrency limit has been exceeded. +Defaults to 503 (Service Unavailable). +Note: If this is set to < 400, 503 will be used instead.

+ +
+
+

GradientControllerConfig

+
+

Configuration parameters for the gradient concurrency controller. +The gradient controller makes forwarding decisions based on a periodically +measured ideal round-trip time (minRTT) for an upstream.

+ + + + + + + + + + + + + + + + + + + + + + +
FieldDescription
sampleAggregatePercentile
+
DoubleValue
+
 +

The percentile to use when summarizing aggregated samples. Defaults to p50. +Value should be between 0 and 100.

+ +
concurrencyLimitParams
+
ConcurrencyLimitCalculationParams
+
Required
+
 +

Parameters for periodic recalculation of the concurrency limit.

+ +
minRttCalcParams
+
MinimumRTTCalculationParams
+
Required
+
 +

Parameters for periodic minRTT recalculation.

+ +
+
+

ConcurrencyLimitCalculationParams

+
+

Parameters controlling the periodic recalculation of the concurrency limit +from sampled request latencies.

+ + + + + + + + + + + + + + + + + + +
FieldDescription
maxConcurrencyLimit
+
UInt32Value
+
 +

The allowed upper-bound on the calculated concurrency limit. Defaults to 1000.

+ +
concurrencyUpdateInterval
+
Duration
+
Required
+
 +

The period of time samples are taken to recalculate the concurrency limit. +This is required.

+ +
+
+

MinimumRTTCalculationParams

+
+

Parameters controlling the periodic minRTT recalculation. +The minRTT is periodically measured by allowing only a very low outstanding +request count to an upstream cluster and measuring the latency under +these ideal conditions.

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/networking/v1alpha3/destination_rule.proto b/networking/v1alpha3/destination_rule.proto index d2589a87aa..0cf1803aa3 100644 --- a/networking/v1alpha3/destination_rule.proto +++ b/networking/v1alpha3/destination_rule.proto @@ -307,6 +307,11 @@ message TrafficPolicy { // Specifies a limit on concurrent retries in relation to the number of active requests. RetryBudget retry_budget = 8; + + // Adaptive concurrency settings for dynamically adjusting the allowed number of + // outstanding requests based on sampled latencies. This enables the Envoy + // adaptive concurrency filter for the destination. + AdaptiveConcurrency adaptive_concurrency = 9; } // A subset of endpoints of a service. Subsets can be used for scenarios @@ -817,6 +822,115 @@ message OutlierDetection { int32 min_health_percent = 5; } +// Adaptive concurrency settings for dynamically adjusting the allowed number of +// outstanding requests based on sampled latencies. See Envoy's +// [adaptive concurrency filter](https://www.envoyproxy.io/docs/envoy/latest/configuration/http/http_filters/adaptive_concurrency_filter) +// for more details. +// +// The following example configures adaptive concurrency for the my-service +// service with a gradient controller: +// +// ```yaml +// apiVersion: networking.istio.io/v1 +// kind: DestinationRule +// metadata: +// name: my-service-adaptive +// spec: +// host: my-service.default.svc.cluster.local +// trafficPolicy: +// adaptiveConcurrency: +// enabled: true +// gradientControllerConfig: +// sampleAggregatePercentile: 50 +// concurrencyLimitParams: +// maxConcurrencyLimit: 1000 +// concurrencyUpdateInterval: 100ms +// minRttCalcParams: +// interval: 60s +// requestCount: 50 +// jitter: 10 +// minConcurrency: 3 +// buffer: 25 +// concurrencyLimitExceededStatus: 503 +// ``` +// +message AdaptiveConcurrency { + // Configuration parameters for the gradient concurrency controller. + // The gradient controller makes forwarding decisions based on a periodically + // measured ideal round-trip time (minRTT) for an upstream. + message GradientControllerConfig { + // Parameters controlling the periodic recalculation of the concurrency limit + // from sampled request latencies. + message ConcurrencyLimitCalculationParams { + // The allowed upper-bound on the calculated concurrency limit. Defaults to 1000. + google.protobuf.UInt32Value max_concurrency_limit = 2; + + // The period of time samples are taken to recalculate the concurrency limit. + // This is required. + google.protobuf.Duration concurrency_update_interval = 3 [(google.api.field_behavior) = REQUIRED]; + } + + // Parameters controlling the periodic minRTT recalculation. + // The minRTT is periodically measured by allowing only a very low outstanding + // request count to an upstream cluster and measuring the latency under + // these ideal conditions. + message MinimumRTTCalculationParams { + // The time interval between recalculating the minimum request round-trip time. + // Has to be positive. If set to zero, dynamic sampling of the minRTT is disabled. + google.protobuf.Duration interval = 1; + + // The fixed value for the minRTT. This value is used when minRTT is not sampled + // dynamically. If dynamic sampling of the minRTT is disabled (i.e. `interval` is + // set to zero), this field must be set. + google.protobuf.Duration fixed_value = 6; + + // The number of requests to aggregate/sample during the minRTT recalculation + // window before updating. Defaults to 50. + google.protobuf.UInt32Value request_count = 2; + + // Randomized time delta that will be introduced to the start of the minRTT + // calculation window. This is represented as a percentage of the interval duration. + // Defaults to 15%. This is recommended to prevent all hosts in a cluster from + // being in a minRTT calculation window at the same time. + google.protobuf.DoubleValue jitter = 3; + + // The concurrency limit set while measuring the minRTT. Defaults to 3. + google.protobuf.UInt32Value min_concurrency = 4; + + // Amount added to the measured minRTT to add stability to the concurrency limit + // during natural variability in latency. This is expressed as a percentage of the + // measured value and can be adjusted to allow more or less tolerance to the sampled + // latency values. Defaults to 25%. + google.protobuf.DoubleValue buffer = 5; + } + + // The percentile to use when summarizing aggregated samples. Defaults to p50. + // Value should be between 0 and 100. + google.protobuf.DoubleValue sample_aggregate_percentile = 1; + + // Parameters for periodic recalculation of the concurrency limit. + ConcurrencyLimitCalculationParams concurrency_limit_params = 2 [(google.api.field_behavior) = REQUIRED]; + + // Parameters for periodic minRTT recalculation. + MinimumRTTCalculationParams min_rtt_calc_params = 3 [(google.api.field_behavior) = REQUIRED]; + } + + oneof concurrency_controller_config { + // Gradient concurrency control will be used. + GradientControllerConfig gradient_controller_config = 1; + } + + // If set to false, the adaptive concurrency filter will operate as a pass-through + // filter. If unspecified, the filter will be enabled. + bool enabled = 2; + + // Custom HTTP response status code to the downstream client when + // the concurrency limit has been exceeded. + // Defaults to 503 (Service Unavailable). + // Note: If this is set to < 400, 503 will be used instead. + uint32 concurrency_limit_exceeded_status = 3; +} + // SSL/TLS related settings for upstream connections. See Envoy's [TLS // context](https://www.envoyproxy.io/docs/envoy/latest/api-v3/extensions/transport_sockets/tls/v3/common.proto.html#common-tls-configuration) // for more details. These settings are common to both HTTP and TCP upstreams. diff --git a/networking/v1alpha3/destination_rule_deepcopy.gen.go b/networking/v1alpha3/destination_rule_deepcopy.gen.go index 6931985ff1..117dbecd49 100644 --- a/networking/v1alpha3/destination_rule_deepcopy.gen.go +++ b/networking/v1alpha3/destination_rule_deepcopy.gen.go @@ -404,6 +404,90 @@ func (in *OutlierDetection) DeepCopyInterface() interface{} { return in.DeepCopy() } +// DeepCopyInto supports using AdaptiveConcurrency within kubernetes types, where deepcopy-gen is used. +func (in *AdaptiveConcurrency) DeepCopyInto(out *AdaptiveConcurrency) { + p := proto.Clone(in).(*AdaptiveConcurrency) + *out = *p +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new AdaptiveConcurrency. Required by controller-gen. +func (in *AdaptiveConcurrency) DeepCopy() *AdaptiveConcurrency { + if in == nil { + return nil + } + out := new(AdaptiveConcurrency) + in.DeepCopyInto(out) + return out +} + +// DeepCopyInterface is an autogenerated deepcopy function, copying the receiver, creating a new AdaptiveConcurrency. Required by controller-gen. +func (in *AdaptiveConcurrency) DeepCopyInterface() interface{} { + return in.DeepCopy() +} + +// DeepCopyInto supports using AdaptiveConcurrency_GradientControllerConfig within kubernetes types, where deepcopy-gen is used. +func (in *AdaptiveConcurrency_GradientControllerConfig) DeepCopyInto(out *AdaptiveConcurrency_GradientControllerConfig) { + p := proto.Clone(in).(*AdaptiveConcurrency_GradientControllerConfig) + *out = *p +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new AdaptiveConcurrency_GradientControllerConfig. Required by controller-gen. +func (in *AdaptiveConcurrency_GradientControllerConfig) DeepCopy() *AdaptiveConcurrency_GradientControllerConfig { + if in == nil { + return nil + } + out := new(AdaptiveConcurrency_GradientControllerConfig) + in.DeepCopyInto(out) + return out +} + +// DeepCopyInterface is an autogenerated deepcopy function, copying the receiver, creating a new AdaptiveConcurrency_GradientControllerConfig. Required by controller-gen. +func (in *AdaptiveConcurrency_GradientControllerConfig) DeepCopyInterface() interface{} { + return in.DeepCopy() +} + +// DeepCopyInto supports using AdaptiveConcurrency_GradientControllerConfig_ConcurrencyLimitCalculationParams within kubernetes types, where deepcopy-gen is used. +func (in *AdaptiveConcurrency_GradientControllerConfig_ConcurrencyLimitCalculationParams) DeepCopyInto(out *AdaptiveConcurrency_GradientControllerConfig_ConcurrencyLimitCalculationParams) { + p := proto.Clone(in).(*AdaptiveConcurrency_GradientControllerConfig_ConcurrencyLimitCalculationParams) + *out = *p +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new AdaptiveConcurrency_GradientControllerConfig_ConcurrencyLimitCalculationParams. Required by controller-gen. +func (in *AdaptiveConcurrency_GradientControllerConfig_ConcurrencyLimitCalculationParams) DeepCopy() *AdaptiveConcurrency_GradientControllerConfig_ConcurrencyLimitCalculationParams { + if in == nil { + return nil + } + out := new(AdaptiveConcurrency_GradientControllerConfig_ConcurrencyLimitCalculationParams) + in.DeepCopyInto(out) + return out +} + +// DeepCopyInterface is an autogenerated deepcopy function, copying the receiver, creating a new AdaptiveConcurrency_GradientControllerConfig_ConcurrencyLimitCalculationParams. Required by controller-gen. +func (in *AdaptiveConcurrency_GradientControllerConfig_ConcurrencyLimitCalculationParams) DeepCopyInterface() interface{} { + return in.DeepCopy() +} + +// DeepCopyInto supports using AdaptiveConcurrency_GradientControllerConfig_MinimumRTTCalculationParams within kubernetes types, where deepcopy-gen is used. +func (in *AdaptiveConcurrency_GradientControllerConfig_MinimumRTTCalculationParams) DeepCopyInto(out *AdaptiveConcurrency_GradientControllerConfig_MinimumRTTCalculationParams) { + p := proto.Clone(in).(*AdaptiveConcurrency_GradientControllerConfig_MinimumRTTCalculationParams) + *out = *p +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new AdaptiveConcurrency_GradientControllerConfig_MinimumRTTCalculationParams. Required by controller-gen. +func (in *AdaptiveConcurrency_GradientControllerConfig_MinimumRTTCalculationParams) DeepCopy() *AdaptiveConcurrency_GradientControllerConfig_MinimumRTTCalculationParams { + if in == nil { + return nil + } + out := new(AdaptiveConcurrency_GradientControllerConfig_MinimumRTTCalculationParams) + in.DeepCopyInto(out) + return out +} + +// DeepCopyInterface is an autogenerated deepcopy function, copying the receiver, creating a new AdaptiveConcurrency_GradientControllerConfig_MinimumRTTCalculationParams. Required by controller-gen. +func (in *AdaptiveConcurrency_GradientControllerConfig_MinimumRTTCalculationParams) DeepCopyInterface() interface{} { + return in.DeepCopy() +} + // DeepCopyInto supports using ClientTLSSettings within kubernetes types, where deepcopy-gen is used. func (in *ClientTLSSettings) DeepCopyInto(out *ClientTLSSettings) { p := proto.Clone(in).(*ClientTLSSettings) diff --git a/networking/v1alpha3/destination_rule_json.gen.go b/networking/v1alpha3/destination_rule_json.gen.go index 9b6392b137..cca1e7b686 100644 --- a/networking/v1alpha3/destination_rule_json.gen.go +++ b/networking/v1alpha3/destination_rule_json.gen.go @@ -215,6 +215,50 @@ func (this *OutlierDetection) UnmarshalJSON(b []byte) error { return DestinationRuleUnmarshaler.Unmarshal(bytes.NewReader(b), this) } +// MarshalJSON is a custom marshaler for AdaptiveConcurrency +func (this *AdaptiveConcurrency) MarshalJSON() ([]byte, error) { + str, err := DestinationRuleMarshaler.MarshalToString(this) + return []byte(str), err +} + +// UnmarshalJSON is a custom unmarshaler for AdaptiveConcurrency +func (this *AdaptiveConcurrency) UnmarshalJSON(b []byte) error { + return DestinationRuleUnmarshaler.Unmarshal(bytes.NewReader(b), this) +} + +// MarshalJSON is a custom marshaler for AdaptiveConcurrency_GradientControllerConfig +func (this *AdaptiveConcurrency_GradientControllerConfig) MarshalJSON() ([]byte, error) { + str, err := DestinationRuleMarshaler.MarshalToString(this) + return []byte(str), err +} + +// UnmarshalJSON is a custom unmarshaler for AdaptiveConcurrency_GradientControllerConfig +func (this *AdaptiveConcurrency_GradientControllerConfig) UnmarshalJSON(b []byte) error { + return DestinationRuleUnmarshaler.Unmarshal(bytes.NewReader(b), this) +} + +// MarshalJSON is a custom marshaler for AdaptiveConcurrency_GradientControllerConfig_ConcurrencyLimitCalculationParams +func (this *AdaptiveConcurrency_GradientControllerConfig_ConcurrencyLimitCalculationParams) MarshalJSON() ([]byte, error) { + str, err := DestinationRuleMarshaler.MarshalToString(this) + return []byte(str), err +} + +// UnmarshalJSON is a custom unmarshaler for AdaptiveConcurrency_GradientControllerConfig_ConcurrencyLimitCalculationParams +func (this *AdaptiveConcurrency_GradientControllerConfig_ConcurrencyLimitCalculationParams) UnmarshalJSON(b []byte) error { + return DestinationRuleUnmarshaler.Unmarshal(bytes.NewReader(b), this) +} + +// MarshalJSON is a custom marshaler for AdaptiveConcurrency_GradientControllerConfig_MinimumRTTCalculationParams +func (this *AdaptiveConcurrency_GradientControllerConfig_MinimumRTTCalculationParams) MarshalJSON() ([]byte, error) { + str, err := DestinationRuleMarshaler.MarshalToString(this) + return []byte(str), err +} + +// UnmarshalJSON is a custom unmarshaler for AdaptiveConcurrency_GradientControllerConfig_MinimumRTTCalculationParams +func (this *AdaptiveConcurrency_GradientControllerConfig_MinimumRTTCalculationParams) UnmarshalJSON(b []byte) error { + return DestinationRuleUnmarshaler.Unmarshal(bytes.NewReader(b), this) +} + // MarshalJSON is a custom marshaler for ClientTLSSettings func (this *ClientTLSSettings) MarshalJSON() ([]byte, error) { str, err := DestinationRuleMarshaler.MarshalToString(this) diff --git a/networking/v1beta1/destination_rule_alias.gen.go b/networking/v1beta1/destination_rule_alias.gen.go index e4ba6cb84e..d13bc4ca27 100644 --- a/networking/v1beta1/destination_rule_alias.gen.go +++ b/networking/v1beta1/destination_rule_alias.gen.go @@ -318,6 +318,61 @@ const ConnectionPoolSettings_HTTPSettings_UPGRADE ConnectionPoolSettings_HTTPSet // ``` type OutlierDetection = v1alpha3.OutlierDetection +// Adaptive concurrency settings for dynamically adjusting the allowed number of +// outstanding requests based on sampled latencies. See Envoy's +// [adaptive concurrency filter](https://www.envoyproxy.io/docs/envoy/latest/configuration/http/http_filters/adaptive_concurrency_filter) +// for more details. +// +// The following example configures adaptive concurrency for the my-service +// service with a gradient controller: +// +// ```yaml +// apiVersion: networking.istio.io/v1 +// kind: DestinationRule +// metadata: +// +// name: my-service-adaptive +// +// spec: +// +// host: my-service.default.svc.cluster.local +// trafficPolicy: +// adaptiveConcurrency: +// enabled: true +// gradientControllerConfig: +// sampleAggregatePercentile: 50 +// concurrencyLimitParams: +// maxConcurrencyLimit: 1000 +// concurrencyUpdateInterval: 100ms +// minRttCalcParams: +// interval: 60s +// requestCount: 50 +// jitter: 10 +// minConcurrency: 3 +// buffer: 25 +// concurrencyLimitExceededStatus: 503 +// +// ``` +type AdaptiveConcurrency = v1alpha3.AdaptiveConcurrency + +// Configuration parameters for the gradient concurrency controller. +// The gradient controller makes forwarding decisions based on a periodically +// measured ideal round-trip time (minRTT) for an upstream. +type AdaptiveConcurrency_GradientControllerConfig = v1alpha3.AdaptiveConcurrency_GradientControllerConfig + +// Parameters controlling the periodic recalculation of the concurrency limit +// from sampled request latencies. +type AdaptiveConcurrency_GradientControllerConfig_ConcurrencyLimitCalculationParams = v1alpha3.AdaptiveConcurrency_GradientControllerConfig_ConcurrencyLimitCalculationParams + +// Parameters controlling the periodic minRTT recalculation. +// The minRTT is periodically measured by allowing only a very low outstanding +// request count to an upstream cluster and measuring the latency under +// these ideal conditions. +type AdaptiveConcurrency_GradientControllerConfig_MinimumRTTCalculationParams = v1alpha3.AdaptiveConcurrency_GradientControllerConfig_MinimumRTTCalculationParams + +// Gradient concurrency control will be used. +type AdaptiveConcurrency_GradientControllerConfig_ = v1alpha3.AdaptiveConcurrency_GradientControllerConfig_ + // SSL/TLS related settings for upstream connections. See Envoy's [TLS // context](https://www.envoyproxy.io/docs/envoy/latest/api-v3/extensions/transport_sockets/tls/v3/common.proto.html#common-tls-configuration) // for more details. These settings are common to both HTTP and TCP upstreams. diff --git a/releasenotes/notes/add-adaptive-concurrency-to-destination-rule.yaml b/releasenotes/notes/add-adaptive-concurrency-to-destination-rule.yaml new file mode 100644 index 0000000000..efdc8fd5ca --- /dev/null +++ b/releasenotes/notes/add-adaptive-concurrency-to-destination-rule.yaml @@ -0,0 +1,11 @@ +apiVersion: release-notes/v2 + +kind: feature +area: traffic-management +issue: [] + +releaseNotes: +- | + **Added** adaptive concurrency filter configuration to DestinationRule TrafficPolicy API. + This enables dynamic concurrency limiting for upstream services based on sampled latency + measurements using Envoy's gradient controller. From 61833a00db0d9e6d085370cee6ead134aed1caeb Mon Sep 17 00:00:00 2001 From: Prashanth Josyula Date: Fri, 6 Mar 2026 09:18:48 -0800 Subject: [PATCH 2/3] Updating the comment for adaptive_concurrency field --- networking/v1alpha3/destination_rule.pb.go | 12 ++++++++++++ networking/v1alpha3/destination_rule.pb.html | 10 ++++++++++ networking/v1alpha3/destination_rule.proto | 12 ++++++++++++ 3 files changed, 34 insertions(+) diff --git a/networking/v1alpha3/destination_rule.pb.go b/networking/v1alpha3/destination_rule.pb.go index 76437450a9..797a55e970 100644 --- a/networking/v1alpha3/destination_rule.pb.go +++ b/networking/v1alpha3/destination_rule.pb.go @@ -560,6 +560,18 @@ type TrafficPolicy struct { // Adaptive concurrency settings for dynamically adjusting the allowed number of // outstanding requests based on sampled latencies. This enables the Envoy // adaptive concurrency filter for the destination. + // + // Note: This operates independently from circuit breaker thresholds (e.g. + // max_connections). Both mechanisms can reject requests, but they act at + // different layers: adaptive concurrency limits outstanding requests at + // the HTTP filter level before routing, while circuit breakers limit + // connections and requests at the cluster connection pool level. When both + // are configured, the more restrictive limit is the effective constraint. + // + // Requests rejected by adaptive concurrency will NOT be reflected in + // circuit breaker statistics (e.g. upstream_cx_overflow). They are tracked + // separately via the adaptive_concurrency.gradient_controller.rq_blocked + // counter. AdaptiveConcurrency *AdaptiveConcurrency `protobuf:"bytes,9,opt,name=adaptive_concurrency,json=adaptiveConcurrency,proto3" json:"adaptive_concurrency,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache diff --git a/networking/v1alpha3/destination_rule.pb.html b/networking/v1alpha3/destination_rule.pb.html index 781f85bc15..6892bbd204 100644 --- a/networking/v1alpha3/destination_rule.pb.html +++ b/networking/v1alpha3/destination_rule.pb.html @@ -286,6 +286,16 @@

TrafficPolicy

Adaptive concurrency settings for dynamically adjusting the allowed number of outstanding requests based on sampled latencies. This enables the Envoy adaptive concurrency filter for the destination.

+

Note: This operates independently from circuit breaker thresholds (e.g. +max_connections). Both mechanisms can reject requests, but they act at +different layers: adaptive concurrency limits outstanding requests at +the HTTP filter level before routing, while circuit breakers limit +connections and requests at the cluster connection pool level. When both +are configured, the more restrictive limit is the effective constraint.

+

Requests rejected by adaptive concurrency will NOT be reflected in +circuit breaker statistics (e.g. upstream_cx_overflow). They are tracked +separately via the adaptive_concurrency.gradient_controller.rq_blocked +counter.

diff --git a/networking/v1alpha3/destination_rule.proto b/networking/v1alpha3/destination_rule.proto index 0cf1803aa3..b437433a42 100644 --- a/networking/v1alpha3/destination_rule.proto +++ b/networking/v1alpha3/destination_rule.proto @@ -311,6 +311,18 @@ message TrafficPolicy { // Adaptive concurrency settings for dynamically adjusting the allowed number of // outstanding requests based on sampled latencies. This enables the Envoy // adaptive concurrency filter for the destination. + // + // Note: This operates independently from circuit breaker thresholds (e.g. + // max_connections). Both mechanisms can reject requests, but they act at + // different layers: adaptive concurrency limits outstanding requests at + // the HTTP filter level before routing, while circuit breakers limit + // connections and requests at the cluster connection pool level. When both + // are configured, the more restrictive limit is the effective constraint. + // + // Requests rejected by adaptive concurrency will NOT be reflected in + // circuit breaker statistics (e.g. upstream_cx_overflow). They are tracked + // separately via the adaptive_concurrency.gradient_controller.rq_blocked + // counter. AdaptiveConcurrency adaptive_concurrency = 9; } From 9e0d05c86d6b810b44c9b971ea88ae238b282fd7 Mon Sep 17 00:00:00 2001 From: Prashanth Josyula Date: Fri, 6 Mar 2026 09:22:55 -0800 Subject: [PATCH 3/3] Updating the comment for adaptive_concurrency field --- networking/v1alpha3/destination_rule.pb.go | 7 +++++++ networking/v1alpha3/destination_rule.pb.html | 6 ++++++ networking/v1alpha3/destination_rule.proto | 7 +++++++ 3 files changed, 20 insertions(+) diff --git a/networking/v1alpha3/destination_rule.pb.go b/networking/v1alpha3/destination_rule.pb.go index 797a55e970..9e79326a2d 100644 --- a/networking/v1alpha3/destination_rule.pb.go +++ b/networking/v1alpha3/destination_rule.pb.go @@ -572,6 +572,13 @@ type TrafficPolicy struct { // circuit breaker statistics (e.g. upstream_cx_overflow). They are tracked // separately via the adaptive_concurrency.gradient_controller.rq_blocked // counter. + // + // Unlike circuit breaker overflows, responses rejected by adaptive concurrency + // will NOT include the x-envoy-overloaded header. Clients or sidecars that + // rely on this header to detect overload-induced 503s (e.g. for retry + // decisions or backoff) should be aware of this difference. The response body + // will be "reached concurrency limit" and the response details will be + // "reached_concurrency_limit". AdaptiveConcurrency *AdaptiveConcurrency `protobuf:"bytes,9,opt,name=adaptive_concurrency,json=adaptiveConcurrency,proto3" json:"adaptive_concurrency,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache diff --git a/networking/v1alpha3/destination_rule.pb.html b/networking/v1alpha3/destination_rule.pb.html index 6892bbd204..6e9b20fbca 100644 --- a/networking/v1alpha3/destination_rule.pb.html +++ b/networking/v1alpha3/destination_rule.pb.html @@ -296,6 +296,12 @@

TrafficPolicy

circuit breaker statistics (e.g. upstream_cx_overflow). They are tracked separately via the adaptive_concurrency.gradient_controller.rq_blocked counter.

+

Unlike circuit breaker overflows, responses rejected by adaptive concurrency +will NOT include the x-envoy-overloaded header. Clients or sidecars that +rely on this header to detect overload-induced 503s (e.g. for retry +decisions or backoff) should be aware of this difference. The response body +will be “reached concurrency limit” and the response details will be +“reached_concurrency_limit”.

diff --git a/networking/v1alpha3/destination_rule.proto b/networking/v1alpha3/destination_rule.proto index b437433a42..01dff46a7a 100644 --- a/networking/v1alpha3/destination_rule.proto +++ b/networking/v1alpha3/destination_rule.proto @@ -323,6 +323,13 @@ message TrafficPolicy { // circuit breaker statistics (e.g. upstream_cx_overflow). They are tracked // separately via the adaptive_concurrency.gradient_controller.rq_blocked // counter. + // + // Unlike circuit breaker overflows, responses rejected by adaptive concurrency + // will NOT include the x-envoy-overloaded header. Clients or sidecars that + // rely on this header to detect overload-induced 503s (e.g. for retry + // decisions or backoff) should be aware of this difference. The response body + // will be "reached concurrency limit" and the response details will be + // "reached_concurrency_limit". AdaptiveConcurrency adaptive_concurrency = 9; }
FieldDescription
interval
+
Duration
+
 +

The time interval between recalculating the minimum request round-trip time. +Has to be positive. If set to zero, dynamic sampling of the minRTT is disabled.

+ +
fixedValue
+
Duration
+
 +

The fixed value for the minRTT. This value is used when minRTT is not sampled +dynamically. If dynamic sampling of the minRTT is disabled (i.e. interval is +set to zero), this field must be set.

+ +
requestCount
+
UInt32Value
+
 +

The number of requests to aggregate/sample during the minRTT recalculation +window before updating. Defaults to 50.

+ +
jitter
+
DoubleValue
+
 +

Randomized time delta that will be introduced to the start of the minRTT +calculation window. This is represented as a percentage of the interval duration. +Defaults to 15%. This is recommended to prevent all hosts in a cluster from +being in a minRTT calculation window at the same time.

+ +
minConcurrency
+
UInt32Value
+
 +

The concurrency limit set while measuring the minRTT. Defaults to 3.

+ +
buffer
+
DoubleValue
+
 +

Amount added to the measured minRTT to add stability to the concurrency limit +during natural variability in latency. This is expressed as a percentage of the +measured value and can be adjusted to allow more or less tolerance to the sampled +latency values. Defaults to 25%.

+