commonv3

package
v1.36.11-2026011520535... Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: unknown License: Apache-2.0 Imports: 12 Imported by: 0

Documentation

Index

Constants

View Source 
const LocalityLbConfig_LocalityConfigSpecifier_not_set_case case_LocalityLbConfig_LocalityConfigSpecifier = 0
View Source 
const LocalityLbConfig_LocalityWeightedLbConfig_case case_LocalityLbConfig_LocalityConfigSpecifier = 2
View Source 
const LocalityLbConfig_ZoneAwareLbConfig_case case_LocalityLbConfig_LocalityConfigSpecifier = 1

Variables

View Source 
var (
	LocalityLbConfig_ZoneAwareLbConfig_LocalityBasis_name = map[int32]string{
		0: "HEALTHY_HOSTS_NUM",
		1: "HEALTHY_HOSTS_WEIGHT",
	}
	LocalityLbConfig_ZoneAwareLbConfig_LocalityBasis_value = map[string]int32{
		"HEALTHY_HOSTS_NUM":    0,
		"HEALTHY_HOSTS_WEIGHT": 1,
	}
)

Enum value maps for LocalityLbConfig_ZoneAwareLbConfig_LocalityBasis.

View Source 
var File_envoy_extensions_load_balancing_policies_common_v3_common_proto protoreflect.FileDescriptor

Functions

This section is empty.

Types

type ConsistentHashingLbConfig 

type ConsistentHashingLbConfig struct {

	// If set to “true“, the cluster will use hostname instead of the resolved
	// address as the key to consistently hash to an upstream host. Only valid for StrictDNS clusters with hostnames which resolve to a single IP address.
	UseHostnameForHashing bool `` /* 129-byte string literal not displayed */
	// Configures percentage of average cluster load to bound per upstream host. For example, with a value of 150
	// no upstream host will get a load more than 1.5 times the average load of all the hosts in the cluster.
	// If not specified, the load is not bounded for any upstream host. Typical value for this parameter is between 120 and 200.
	// Minimum is 100.
	//
	// Applies to both Ring Hash and Maglev load balancers.
	//
	// This is implemented based on the method described in the paper https://arxiv.org/abs/1608.01350. For the specified
	// “hash_balance_factor“, requests to any upstream host are capped at “hash_balance_factor/100“ times the average number of requests
	// across the cluster. When a request arrives for an upstream host that is currently serving at its max capacity, linear probing
	// is used to identify an eligible host. Further, the linear probe is implemented using a random jump in hosts ring/table to identify
	// the eligible host (this technique is as described in the paper https://arxiv.org/abs/1908.08762 - the random jump avoids the
	// cascading overflow effect when choosing the next host in the ring/table).
	//
	// If weights are specified on the hosts, they are respected.
	//
	// This is an O(N) algorithm, unlike other load balancers. Using a lower “hash_balance_factor“ results in more hosts
	// being probed, so use a higher value if you require better performance.
	HashBalanceFactor *wrapperspb.UInt32Value `protobuf:"bytes,2,opt,name=hash_balance_factor,json=hashBalanceFactor,proto3" json:"hash_balance_factor,omitempty"`
	//	Specifies a list of hash policies to use for ring hash load balancing. If “hash_policy“ is
	//
	// set, then
	// :ref:`route level hash policy <envoy_v3_api_field_config.route.v3.RouteAction.hash_policy>`
	// will be ignored.
	HashPolicy []*v32.RouteAction_HashPolicy `protobuf:"bytes,3,rep,name=hash_policy,json=hashPolicy,proto3" json:"hash_policy,omitempty"`
	// contains filtered or unexported fields
}

Common Configuration for all consistent hashing load balancers (MaglevLb, RingHashLb, etc.)

func (*ConsistentHashingLbConfig) ClearHashBalanceFactor 

func (x *ConsistentHashingLbConfig) ClearHashBalanceFactor()

func (*ConsistentHashingLbConfig) GetHashBalanceFactor 

func (x *ConsistentHashingLbConfig) GetHashBalanceFactor() *wrapperspb.UInt32Value

func (*ConsistentHashingLbConfig) GetHashPolicy 

func (x *ConsistentHashingLbConfig) GetHashPolicy() []*v32.RouteAction_HashPolicy

func (*ConsistentHashingLbConfig) GetUseHostnameForHashing 

func (x *ConsistentHashingLbConfig) GetUseHostnameForHashing() bool

func (*ConsistentHashingLbConfig) HasHashBalanceFactor 

func (x *ConsistentHashingLbConfig) HasHashBalanceFactor() bool

func (*ConsistentHashingLbConfig) ProtoMessage 

func (*ConsistentHashingLbConfig) ProtoMessage()

func (*ConsistentHashingLbConfig) ProtoReflect 

func (x *ConsistentHashingLbConfig) ProtoReflect() protoreflect.Message

func (*ConsistentHashingLbConfig) Reset 

func (x *ConsistentHashingLbConfig) Reset()

func (*ConsistentHashingLbConfig) SetHashBalanceFactor 

func (x *ConsistentHashingLbConfig) SetHashBalanceFactor(v *wrapperspb.UInt32Value)

func (*ConsistentHashingLbConfig) SetHashPolicy 

func (x *ConsistentHashingLbConfig) SetHashPolicy(v []*v32.RouteAction_HashPolicy)

func (*ConsistentHashingLbConfig) SetUseHostnameForHashing 

func (x *ConsistentHashingLbConfig) SetUseHostnameForHashing(v bool)

func (*ConsistentHashingLbConfig) String 

func (x *ConsistentHashingLbConfig) String() string

type ConsistentHashingLbConfig_builder 

type ConsistentHashingLbConfig_builder struct {

	// If set to “true“, the cluster will use hostname instead of the resolved
	// address as the key to consistently hash to an upstream host. Only valid for StrictDNS clusters with hostnames which resolve to a single IP address.
	UseHostnameForHashing bool
	// Configures percentage of average cluster load to bound per upstream host. For example, with a value of 150
	// no upstream host will get a load more than 1.5 times the average load of all the hosts in the cluster.
	// If not specified, the load is not bounded for any upstream host. Typical value for this parameter is between 120 and 200.
	// Minimum is 100.
	//
	// Applies to both Ring Hash and Maglev load balancers.
	//
	// This is implemented based on the method described in the paper https://arxiv.org/abs/1608.01350. For the specified
	// “hash_balance_factor“, requests to any upstream host are capped at “hash_balance_factor/100“ times the average number of requests
	// across the cluster. When a request arrives for an upstream host that is currently serving at its max capacity, linear probing
	// is used to identify an eligible host. Further, the linear probe is implemented using a random jump in hosts ring/table to identify
	// the eligible host (this technique is as described in the paper https://arxiv.org/abs/1908.08762 - the random jump avoids the
	// cascading overflow effect when choosing the next host in the ring/table).
	//
	// If weights are specified on the hosts, they are respected.
	//
	// This is an O(N) algorithm, unlike other load balancers. Using a lower “hash_balance_factor“ results in more hosts
	// being probed, so use a higher value if you require better performance.
	HashBalanceFactor *wrapperspb.UInt32Value
	//	Specifies a list of hash policies to use for ring hash load balancing. If “hash_policy“ is
	//
	// set, then
	// :ref:`route level hash policy <envoy_v3_api_field_config.route.v3.RouteAction.hash_policy>`
	// will be ignored.
	HashPolicy []*v32.RouteAction_HashPolicy
	// contains filtered or unexported fields
}

func (ConsistentHashingLbConfig_builder) Build 

func (b0 ConsistentHashingLbConfig_builder) Build() *ConsistentHashingLbConfig

type LocalityLbConfig 

type LocalityLbConfig struct {

	// Types that are valid to be assigned to LocalityConfigSpecifier:
	//
	//	*LocalityLbConfig_ZoneAwareLbConfig_
	//	*LocalityLbConfig_LocalityWeightedLbConfig_
	LocalityConfigSpecifier isLocalityLbConfig_LocalityConfigSpecifier `protobuf_oneof:"locality_config_specifier"`
	// contains filtered or unexported fields
}

func (*LocalityLbConfig) ClearLocalityConfigSpecifier 

func (x *LocalityLbConfig) ClearLocalityConfigSpecifier()

func (*LocalityLbConfig) ClearLocalityWeightedLbConfig 

func (x *LocalityLbConfig) ClearLocalityWeightedLbConfig()

func (*LocalityLbConfig) ClearZoneAwareLbConfig 

func (x *LocalityLbConfig) ClearZoneAwareLbConfig()

func (*LocalityLbConfig) GetLocalityConfigSpecifier 

func (x *LocalityLbConfig) GetLocalityConfigSpecifier() isLocalityLbConfig_LocalityConfigSpecifier

func (*LocalityLbConfig) GetLocalityWeightedLbConfig 

func (x *LocalityLbConfig) GetLocalityWeightedLbConfig() *LocalityLbConfig_LocalityWeightedLbConfig

func (*LocalityLbConfig) GetZoneAwareLbConfig 

func (x *LocalityLbConfig) GetZoneAwareLbConfig() *LocalityLbConfig_ZoneAwareLbConfig

func (*LocalityLbConfig) HasLocalityConfigSpecifier 

func (x *LocalityLbConfig) HasLocalityConfigSpecifier() bool

func (*LocalityLbConfig) HasLocalityWeightedLbConfig 

func (x *LocalityLbConfig) HasLocalityWeightedLbConfig() bool

func (*LocalityLbConfig) HasZoneAwareLbConfig 

func (x *LocalityLbConfig) HasZoneAwareLbConfig() bool

func (*LocalityLbConfig) ProtoMessage 

func (*LocalityLbConfig) ProtoMessage()

func (*LocalityLbConfig) ProtoReflect 

func (x *LocalityLbConfig) ProtoReflect() protoreflect.Message

func (*LocalityLbConfig) Reset 

func (x *LocalityLbConfig) Reset()

func (*LocalityLbConfig) SetLocalityWeightedLbConfig 

func (x *LocalityLbConfig) SetLocalityWeightedLbConfig(v *LocalityLbConfig_LocalityWeightedLbConfig)

func (*LocalityLbConfig) SetZoneAwareLbConfig 

func (x *LocalityLbConfig) SetZoneAwareLbConfig(v *LocalityLbConfig_ZoneAwareLbConfig)

func (*LocalityLbConfig) String 

func (x *LocalityLbConfig) String() string

func (*LocalityLbConfig) WhichLocalityConfigSpecifier 

func (x *LocalityLbConfig) WhichLocalityConfigSpecifier() case_LocalityLbConfig_LocalityConfigSpecifier

type LocalityLbConfig_LocalityWeightedLbConfig 

type LocalityLbConfig_LocalityWeightedLbConfig struct {
	// contains filtered or unexported fields
}

Configuration for :ref:`locality weighted load balancing <arch_overview_load_balancing_locality_weighted_lb>`

func (*LocalityLbConfig_LocalityWeightedLbConfig) ProtoMessage 

func (*LocalityLbConfig_LocalityWeightedLbConfig) ProtoMessage()

func (*LocalityLbConfig_LocalityWeightedLbConfig) ProtoReflect 

func (x *LocalityLbConfig_LocalityWeightedLbConfig) ProtoReflect() protoreflect.Message

func (*LocalityLbConfig_LocalityWeightedLbConfig) Reset 

func (x *LocalityLbConfig_LocalityWeightedLbConfig) Reset()

func (*LocalityLbConfig_LocalityWeightedLbConfig) String 

func (x *LocalityLbConfig_LocalityWeightedLbConfig) String() string

type LocalityLbConfig_LocalityWeightedLbConfig_ 

type LocalityLbConfig_LocalityWeightedLbConfig_ struct {
	// Enable locality weighted load balancing.
	LocalityWeightedLbConfig *LocalityLbConfig_LocalityWeightedLbConfig `protobuf:"bytes,2,opt,name=locality_weighted_lb_config,json=localityWeightedLbConfig,proto3,oneof"`
}

type LocalityLbConfig_LocalityWeightedLbConfig_builder 

type LocalityLbConfig_LocalityWeightedLbConfig_builder struct {
	// contains filtered or unexported fields
}

func (LocalityLbConfig_LocalityWeightedLbConfig_builder) Build 

func (b0 LocalityLbConfig_LocalityWeightedLbConfig_builder) Build() *LocalityLbConfig_LocalityWeightedLbConfig

type LocalityLbConfig_ZoneAwareLbConfig 

type LocalityLbConfig_ZoneAwareLbConfig struct {

	// Configures percentage of requests that will be considered for zone aware routing
	// if zone aware routing is configured. If not specified, the default is 100%.
	// * :ref:`runtime values <config_cluster_manager_cluster_runtime_zone_routing>`.
	// * :ref:`Zone aware routing support <arch_overview_load_balancing_zone_aware_routing>`.
	RoutingEnabled *v31.Percent `protobuf:"bytes,1,opt,name=routing_enabled,json=routingEnabled,proto3" json:"routing_enabled,omitempty"`
	// Configures minimum upstream cluster size required for zone aware routing
	// If upstream cluster size is less than specified, zone aware routing is not performed
	// even if zone aware routing is configured. If not specified, the default is 6.
	// * :ref:`runtime values <config_cluster_manager_cluster_runtime_zone_routing>`.
	// * :ref:`Zone aware routing support <arch_overview_load_balancing_zone_aware_routing>`.
	MinClusterSize *wrapperspb.UInt64Value `protobuf:"bytes,2,opt,name=min_cluster_size,json=minClusterSize,proto3" json:"min_cluster_size,omitempty"`
	// If set to true, Envoy will not consider any hosts when the cluster is in :ref:`panic
	// mode<arch_overview_load_balancing_panic_threshold>`. Instead, the cluster will fail all
	// requests as if all hosts are unhealthy. This can help avoid potentially overwhelming a
	// failing service.
	FailTrafficOnPanic bool `protobuf:"varint,3,opt,name=fail_traffic_on_panic,json=failTrafficOnPanic,proto3" json:"fail_traffic_on_panic,omitempty"`
	// If set to true, Envoy will force LocalityDirect routing if a local locality exists.
	//
	// Deprecated: Marked as deprecated in envoy/extensions/load_balancing_policies/common/v3/common.proto.
	ForceLocalityDirectRouting bool                                               `` /* 144-byte string literal not displayed */
	ForceLocalZone             *LocalityLbConfig_ZoneAwareLbConfig_ForceLocalZone `protobuf:"bytes,5,opt,name=force_local_zone,json=forceLocalZone,proto3" json:"force_local_zone,omitempty"`
	// Determines how locality percentages are computed:
	// - HEALTHY_HOSTS_NUM: proportional to the count of healthy hosts.
	// - HEALTHY_HOSTS_WEIGHT: proportional to the weights of healthy hosts.
	// Default value is HEALTHY_HOSTS_NUM if unset.
	LocalityBasis LocalityLbConfig_ZoneAwareLbConfig_LocalityBasis `` /* 206-byte string literal not displayed */
	// contains filtered or unexported fields
}

Configuration for :ref:`zone aware routing <arch_overview_load_balancing_zone_aware_routing>`. [#next-free-field: 7]

func (*LocalityLbConfig_ZoneAwareLbConfig) ClearForceLocalZone 

func (x *LocalityLbConfig_ZoneAwareLbConfig) ClearForceLocalZone()

func (*LocalityLbConfig_ZoneAwareLbConfig) ClearMinClusterSize 

func (x *LocalityLbConfig_ZoneAwareLbConfig) ClearMinClusterSize()

func (*LocalityLbConfig_ZoneAwareLbConfig) ClearRoutingEnabled 

func (x *LocalityLbConfig_ZoneAwareLbConfig) ClearRoutingEnabled()

func (*LocalityLbConfig_ZoneAwareLbConfig) GetFailTrafficOnPanic 

func (x *LocalityLbConfig_ZoneAwareLbConfig) GetFailTrafficOnPanic() bool

func (*LocalityLbConfig_ZoneAwareLbConfig) GetForceLocalZone 

func (x *LocalityLbConfig_ZoneAwareLbConfig) GetForceLocalZone() *LocalityLbConfig_ZoneAwareLbConfig_ForceLocalZone

func (*LocalityLbConfig_ZoneAwareLbConfig) GetForceLocalityDirectRouting deprecated 

func (x *LocalityLbConfig_ZoneAwareLbConfig) GetForceLocalityDirectRouting() bool

Deprecated: Marked as deprecated in envoy/extensions/load_balancing_policies/common/v3/common.proto.

func (*LocalityLbConfig_ZoneAwareLbConfig) GetLocalityBasis 

func (x *LocalityLbConfig_ZoneAwareLbConfig) GetLocalityBasis() LocalityLbConfig_ZoneAwareLbConfig_LocalityBasis

func (*LocalityLbConfig_ZoneAwareLbConfig) GetMinClusterSize 

func (x *LocalityLbConfig_ZoneAwareLbConfig) GetMinClusterSize() *wrapperspb.UInt64Value

func (*LocalityLbConfig_ZoneAwareLbConfig) GetRoutingEnabled 

func (x *LocalityLbConfig_ZoneAwareLbConfig) GetRoutingEnabled() *v31.Percent

func (*LocalityLbConfig_ZoneAwareLbConfig) HasForceLocalZone 

func (x *LocalityLbConfig_ZoneAwareLbConfig) HasForceLocalZone() bool

func (*LocalityLbConfig_ZoneAwareLbConfig) HasMinClusterSize 

func (x *LocalityLbConfig_ZoneAwareLbConfig) HasMinClusterSize() bool

func (*LocalityLbConfig_ZoneAwareLbConfig) HasRoutingEnabled 

func (x *LocalityLbConfig_ZoneAwareLbConfig) HasRoutingEnabled() bool

func (*LocalityLbConfig_ZoneAwareLbConfig) ProtoMessage 

func (*LocalityLbConfig_ZoneAwareLbConfig) ProtoMessage()

func (*LocalityLbConfig_ZoneAwareLbConfig) ProtoReflect 

func (x *LocalityLbConfig_ZoneAwareLbConfig) ProtoReflect() protoreflect.Message

func (*LocalityLbConfig_ZoneAwareLbConfig) Reset 

func (x *LocalityLbConfig_ZoneAwareLbConfig) Reset()

func (*LocalityLbConfig_ZoneAwareLbConfig) SetFailTrafficOnPanic 

func (x *LocalityLbConfig_ZoneAwareLbConfig) SetFailTrafficOnPanic(v bool)

func (*LocalityLbConfig_ZoneAwareLbConfig) SetForceLocalZone 

func (x *LocalityLbConfig_ZoneAwareLbConfig) SetForceLocalZone(v *LocalityLbConfig_ZoneAwareLbConfig_ForceLocalZone)

func (*LocalityLbConfig_ZoneAwareLbConfig) SetForceLocalityDirectRouting deprecated 

func (x *LocalityLbConfig_ZoneAwareLbConfig) SetForceLocalityDirectRouting(v bool)

Deprecated: Marked as deprecated in envoy/extensions/load_balancing_policies/common/v3/common.proto.

func (*LocalityLbConfig_ZoneAwareLbConfig) SetLocalityBasis 

func (x *LocalityLbConfig_ZoneAwareLbConfig) SetLocalityBasis(v LocalityLbConfig_ZoneAwareLbConfig_LocalityBasis)

func (*LocalityLbConfig_ZoneAwareLbConfig) SetMinClusterSize 

func (x *LocalityLbConfig_ZoneAwareLbConfig) SetMinClusterSize(v *wrapperspb.UInt64Value)

func (*LocalityLbConfig_ZoneAwareLbConfig) SetRoutingEnabled 

func (x *LocalityLbConfig_ZoneAwareLbConfig) SetRoutingEnabled(v *v31.Percent)

func (*LocalityLbConfig_ZoneAwareLbConfig) String 

func (x *LocalityLbConfig_ZoneAwareLbConfig) String() string

type LocalityLbConfig_ZoneAwareLbConfig_ 

type LocalityLbConfig_ZoneAwareLbConfig_ struct {
	// Configuration for local zone aware load balancing.
	ZoneAwareLbConfig *LocalityLbConfig_ZoneAwareLbConfig `protobuf:"bytes,1,opt,name=zone_aware_lb_config,json=zoneAwareLbConfig,proto3,oneof"`
}

type LocalityLbConfig_ZoneAwareLbConfig_ForceLocalZone 

type LocalityLbConfig_ZoneAwareLbConfig_ForceLocalZone struct {

	// Configures the minimum number of upstream hosts in the local zone required when force_local_zone
	// is enabled. If the number of upstream hosts in the local zone is less than the specified value,
	// Envoy will fall back to the default proportional-based distribution across localities.
	// If not specified, the default is 1.
	// * :ref:`runtime values <config_cluster_manager_cluster_runtime_zone_routing>`.
	// * :ref:`Zone aware routing support <arch_overview_load_balancing_zone_aware_routing>`.
	MinSize *wrapperspb.UInt32Value `protobuf:"bytes,1,opt,name=min_size,json=minSize,proto3" json:"min_size,omitempty"`
	// contains filtered or unexported fields
}

Configures Envoy to always route requests to the local zone regardless of the upstream zone structure. In Envoy's default configuration, traffic is distributed proportionally across all upstream hosts while trying to maximize local routing when possible. The approach with force_local_zone aims to be more predictable and if there are upstream hosts in the local zone, they will receive all traffic. * :ref:`runtime values <config_cluster_manager_cluster_runtime_zone_routing>`. * :ref:`Zone aware routing support <arch_overview_load_balancing_zone_aware_routing>`.

func (*LocalityLbConfig_ZoneAwareLbConfig_ForceLocalZone) ClearMinSize 

func (x *LocalityLbConfig_ZoneAwareLbConfig_ForceLocalZone) ClearMinSize()

func (*LocalityLbConfig_ZoneAwareLbConfig_ForceLocalZone) GetMinSize 

func (x *LocalityLbConfig_ZoneAwareLbConfig_ForceLocalZone) GetMinSize() *wrapperspb.UInt32Value

func (*LocalityLbConfig_ZoneAwareLbConfig_ForceLocalZone) HasMinSize 

func (x *LocalityLbConfig_ZoneAwareLbConfig_ForceLocalZone) HasMinSize() bool

func (*LocalityLbConfig_ZoneAwareLbConfig_ForceLocalZone) ProtoMessage 

func (*LocalityLbConfig_ZoneAwareLbConfig_ForceLocalZone) ProtoMessage()

func (*LocalityLbConfig_ZoneAwareLbConfig_ForceLocalZone) ProtoReflect 

func (x *LocalityLbConfig_ZoneAwareLbConfig_ForceLocalZone) ProtoReflect() protoreflect.Message

func (*LocalityLbConfig_ZoneAwareLbConfig_ForceLocalZone) Reset 

func (x *LocalityLbConfig_ZoneAwareLbConfig_ForceLocalZone) Reset()

func (*LocalityLbConfig_ZoneAwareLbConfig_ForceLocalZone) SetMinSize 

func (x *LocalityLbConfig_ZoneAwareLbConfig_ForceLocalZone) SetMinSize(v *wrapperspb.UInt32Value)

func (*LocalityLbConfig_ZoneAwareLbConfig_ForceLocalZone) String 

func (x *LocalityLbConfig_ZoneAwareLbConfig_ForceLocalZone) String() string

type LocalityLbConfig_ZoneAwareLbConfig_ForceLocalZone_builder 

type LocalityLbConfig_ZoneAwareLbConfig_ForceLocalZone_builder struct {

	// Configures the minimum number of upstream hosts in the local zone required when force_local_zone
	// is enabled. If the number of upstream hosts in the local zone is less than the specified value,
	// Envoy will fall back to the default proportional-based distribution across localities.
	// If not specified, the default is 1.
	// * :ref:`runtime values <config_cluster_manager_cluster_runtime_zone_routing>`.
	// * :ref:`Zone aware routing support <arch_overview_load_balancing_zone_aware_routing>`.
	MinSize *wrapperspb.UInt32Value
	// contains filtered or unexported fields
}

func (LocalityLbConfig_ZoneAwareLbConfig_ForceLocalZone_builder) Build 

func (b0 LocalityLbConfig_ZoneAwareLbConfig_ForceLocalZone_builder) Build() *LocalityLbConfig_ZoneAwareLbConfig_ForceLocalZone

type LocalityLbConfig_ZoneAwareLbConfig_LocalityBasis 

type LocalityLbConfig_ZoneAwareLbConfig_LocalityBasis int32

Basis for computing per-locality percentages in zone-aware routing. 

const (
	// Use the number of healthy hosts in each locality.
	LocalityLbConfig_ZoneAwareLbConfig_HEALTHY_HOSTS_NUM LocalityLbConfig_ZoneAwareLbConfig_LocalityBasis = 0
	// Use the weights of healthy hosts in each locality.
	LocalityLbConfig_ZoneAwareLbConfig_HEALTHY_HOSTS_WEIGHT LocalityLbConfig_ZoneAwareLbConfig_LocalityBasis = 1
)

func (LocalityLbConfig_ZoneAwareLbConfig_LocalityBasis) Descriptor 

func (LocalityLbConfig_ZoneAwareLbConfig_LocalityBasis) Descriptor() protoreflect.EnumDescriptor

func (LocalityLbConfig_ZoneAwareLbConfig_LocalityBasis) Enum 

func (x LocalityLbConfig_ZoneAwareLbConfig_LocalityBasis) Enum() *LocalityLbConfig_ZoneAwareLbConfig_LocalityBasis

func (LocalityLbConfig_ZoneAwareLbConfig_LocalityBasis) Number 

func (x LocalityLbConfig_ZoneAwareLbConfig_LocalityBasis) Number() protoreflect.EnumNumber

func (LocalityLbConfig_ZoneAwareLbConfig_LocalityBasis) String 

func (x LocalityLbConfig_ZoneAwareLbConfig_LocalityBasis) String() string

func (LocalityLbConfig_ZoneAwareLbConfig_LocalityBasis) Type 

func (LocalityLbConfig_ZoneAwareLbConfig_LocalityBasis) Type() protoreflect.EnumType

type LocalityLbConfig_ZoneAwareLbConfig_builder 

type LocalityLbConfig_ZoneAwareLbConfig_builder struct {

	// Configures percentage of requests that will be considered for zone aware routing
	// if zone aware routing is configured. If not specified, the default is 100%.
	// * :ref:`runtime values <config_cluster_manager_cluster_runtime_zone_routing>`.
	// * :ref:`Zone aware routing support <arch_overview_load_balancing_zone_aware_routing>`.
	RoutingEnabled *v31.Percent
	// Configures minimum upstream cluster size required for zone aware routing
	// If upstream cluster size is less than specified, zone aware routing is not performed
	// even if zone aware routing is configured. If not specified, the default is 6.
	// * :ref:`runtime values <config_cluster_manager_cluster_runtime_zone_routing>`.
	// * :ref:`Zone aware routing support <arch_overview_load_balancing_zone_aware_routing>`.
	MinClusterSize *wrapperspb.UInt64Value
	// If set to true, Envoy will not consider any hosts when the cluster is in :ref:`panic
	// mode<arch_overview_load_balancing_panic_threshold>`. Instead, the cluster will fail all
	// requests as if all hosts are unhealthy. This can help avoid potentially overwhelming a
	// failing service.
	FailTrafficOnPanic bool
	// If set to true, Envoy will force LocalityDirect routing if a local locality exists.
	//
	// Deprecated: Marked as deprecated in envoy/extensions/load_balancing_policies/common/v3/common.proto.
	ForceLocalityDirectRouting bool
	ForceLocalZone             *LocalityLbConfig_ZoneAwareLbConfig_ForceLocalZone
	// Determines how locality percentages are computed:
	// - HEALTHY_HOSTS_NUM: proportional to the count of healthy hosts.
	// - HEALTHY_HOSTS_WEIGHT: proportional to the weights of healthy hosts.
	// Default value is HEALTHY_HOSTS_NUM if unset.
	LocalityBasis LocalityLbConfig_ZoneAwareLbConfig_LocalityBasis
	// contains filtered or unexported fields
}

func (LocalityLbConfig_ZoneAwareLbConfig_builder) Build 

func (b0 LocalityLbConfig_ZoneAwareLbConfig_builder) Build() *LocalityLbConfig_ZoneAwareLbConfig

type LocalityLbConfig_builder 

type LocalityLbConfig_builder struct {

	// Fields of oneof LocalityConfigSpecifier:
	// Configuration for local zone aware load balancing.
	ZoneAwareLbConfig *LocalityLbConfig_ZoneAwareLbConfig
	// Enable locality weighted load balancing.
	LocalityWeightedLbConfig *LocalityLbConfig_LocalityWeightedLbConfig
	// contains filtered or unexported fields
}

func (LocalityLbConfig_builder) Build 

func (b0 LocalityLbConfig_builder) Build() *LocalityLbConfig

type SlowStartConfig 

type SlowStartConfig struct {

	// Represents the size of slow start window.
	// If set, the newly created host remains in slow start mode starting from its creation time
	// for the duration of slow start window.
	SlowStartWindow *durationpb.Duration `protobuf:"bytes,1,opt,name=slow_start_window,json=slowStartWindow,proto3" json:"slow_start_window,omitempty"`
	// This parameter controls the speed of traffic increase over the slow start window. Defaults to 1.0,
	// so that endpoint would get linearly increasing amount of traffic.
	// When increasing the value for this parameter, the speed of traffic ramp-up increases non-linearly.
	// The value of aggression parameter should be greater than 0.0.
	// By tuning the parameter, is possible to achieve polynomial or exponential shape of ramp-up curve.
	//
	// During slow start window, effective weight of an endpoint would be scaled with time factor and aggression:
	// “new_weight = weight * max(min_weight_percent, time_factor ^ (1 / aggression))“,
	// where “time_factor=(time_since_start_seconds / slow_start_time_seconds)“.
	//
	// As time progresses, more and more traffic would be sent to endpoint, which is in slow start window.
	// Once host exits slow start, time_factor and aggression no longer affect its weight.
	Aggression *v3.RuntimeDouble `protobuf:"bytes,2,opt,name=aggression,proto3" json:"aggression,omitempty"`
	// Configures the minimum percentage of origin weight that avoids too small new weight,
	// which may cause endpoints in slow start mode receive no traffic in slow start window.
	// If not specified, the default is 10%.
	MinWeightPercent *v31.Percent `protobuf:"bytes,3,opt,name=min_weight_percent,json=minWeightPercent,proto3" json:"min_weight_percent,omitempty"`
	// contains filtered or unexported fields
}

Configuration for :ref:`slow start mode <arch_overview_load_balancing_slow_start>`.

func (*SlowStartConfig) ClearAggression 

func (x *SlowStartConfig) ClearAggression()

func (*SlowStartConfig) ClearMinWeightPercent 

func (x *SlowStartConfig) ClearMinWeightPercent()

func (*SlowStartConfig) ClearSlowStartWindow 

func (x *SlowStartConfig) ClearSlowStartWindow()

func (*SlowStartConfig) GetAggression 

func (x *SlowStartConfig) GetAggression() *v3.RuntimeDouble

func (*SlowStartConfig) GetMinWeightPercent 

func (x *SlowStartConfig) GetMinWeightPercent() *v31.Percent

func (*SlowStartConfig) GetSlowStartWindow 

func (x *SlowStartConfig) GetSlowStartWindow() *durationpb.Duration

func (*SlowStartConfig) HasAggression 

func (x *SlowStartConfig) HasAggression() bool

func (*SlowStartConfig) HasMinWeightPercent 

func (x *SlowStartConfig) HasMinWeightPercent() bool

func (*SlowStartConfig) HasSlowStartWindow 

func (x *SlowStartConfig) HasSlowStartWindow() bool

func (*SlowStartConfig) ProtoMessage 

func (*SlowStartConfig) ProtoMessage()

func (*SlowStartConfig) ProtoReflect 

func (x *SlowStartConfig) ProtoReflect() protoreflect.Message

func (*SlowStartConfig) Reset 

func (x *SlowStartConfig) Reset()

func (*SlowStartConfig) SetAggression 

func (x *SlowStartConfig) SetAggression(v *v3.RuntimeDouble)

func (*SlowStartConfig) SetMinWeightPercent 

func (x *SlowStartConfig) SetMinWeightPercent(v *v31.Percent)

func (*SlowStartConfig) SetSlowStartWindow 

func (x *SlowStartConfig) SetSlowStartWindow(v *durationpb.Duration)

func (*SlowStartConfig) String 

func (x *SlowStartConfig) String() string

type SlowStartConfig_builder 

type SlowStartConfig_builder struct {

	// Represents the size of slow start window.
	// If set, the newly created host remains in slow start mode starting from its creation time
	// for the duration of slow start window.
	SlowStartWindow *durationpb.Duration
	// This parameter controls the speed of traffic increase over the slow start window. Defaults to 1.0,
	// so that endpoint would get linearly increasing amount of traffic.
	// When increasing the value for this parameter, the speed of traffic ramp-up increases non-linearly.
	// The value of aggression parameter should be greater than 0.0.
	// By tuning the parameter, is possible to achieve polynomial or exponential shape of ramp-up curve.
	//
	// During slow start window, effective weight of an endpoint would be scaled with time factor and aggression:
	// “new_weight = weight * max(min_weight_percent, time_factor ^ (1 / aggression))“,
	// where “time_factor=(time_since_start_seconds / slow_start_time_seconds)“.
	//
	// As time progresses, more and more traffic would be sent to endpoint, which is in slow start window.
	// Once host exits slow start, time_factor and aggression no longer affect its weight.
	Aggression *v3.RuntimeDouble
	// Configures the minimum percentage of origin weight that avoids too small new weight,
	// which may cause endpoints in slow start mode receive no traffic in slow start window.
	// If not specified, the default is 10%.
	MinWeightPercent *v31.Percent
	// contains filtered or unexported fields
}

func (SlowStartConfig_builder) Build 

func (b0 SlowStartConfig_builder) Build() *SlowStartConfig

Source Files

  • common.pb.go

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.