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..9e79326a2d 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,32 @@ 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. + // + // 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. + // + // 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 } func (x *TrafficPolicy) Reset() { @@ -647,6 +670,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 +1310,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 +1566,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 +1578,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 +1591,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 +1790,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 +1802,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 +1815,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 +1866,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 +1878,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 +1951,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 +1963,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 +2011,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 +2023,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 +2069,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 +2081,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 +2159,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 +2171,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 +2334,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 +2346,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 +2383,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 +2395,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 +2439,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 +2451,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 +2508,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 +2520,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 +2580,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 +2592,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 +2685,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 +2697,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 +2790,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 +2802,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 +2839,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 +3092,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 +3104,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 +3117,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 +3154,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 +3166,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 +3179,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 +3206,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 +3215,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 +3331,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 +3402,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 +3415,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 +3529,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 +3546,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..6e9b20fbca 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,33 @@

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.

+

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.

+

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”.

+ @@ -1470,6 +1497,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..01dff46a7a 100644 --- a/networking/v1alpha3/destination_rule.proto +++ b/networking/v1alpha3/destination_rule.proto @@ -307,6 +307,30 @@ 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. + // + // 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. + // + // 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; } // A subset of endpoints of a service. Subsets can be used for scenarios @@ -817,6 +841,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.
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%.

+