kubernetes – k8s.io/kubernetes/pkg/proxy Index | Files | Directories

package proxy

import "k8s.io/kubernetes/pkg/proxy"

Package proxy implements the layer-3 network proxy.

Index

Types

type BaseEndpointInfo 

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

BaseEndpointInfo contains base information that defines an endpoint. This could be used directly by proxier while processing endpoints, or can be used for constructing a more specific EndpointInfo struct defined by the proxier if needed.

func (*BaseEndpointInfo) IP 

func (info *BaseEndpointInfo) IP() string

IP returns just the IP part of the endpoint, it's a part of proxy.Endpoint interface.

func (*BaseEndpointInfo) IsLocal 

func (info *BaseEndpointInfo) IsLocal() bool

IsLocal is part of proxy.Endpoint interface.

func (*BaseEndpointInfo) IsReady 

func (info *BaseEndpointInfo) IsReady() bool

IsReady returns true if an endpoint is ready and not terminating.

func (*BaseEndpointInfo) IsServing 

func (info *BaseEndpointInfo) IsServing() bool

IsServing returns true if an endpoint is ready, regardless of if the endpoint is terminating.

func (*BaseEndpointInfo) IsTerminating 

func (info *BaseEndpointInfo) IsTerminating() bool

IsTerminating retruns true if an endpoint is terminating. For pods, that is any pod with a deletion timestamp.

func (*BaseEndpointInfo) NodeHints 

func (info *BaseEndpointInfo) NodeHints() sets.Set[string]

NodeHints returns the node hints for the endpoint.

func (*BaseEndpointInfo) Port 

func (info *BaseEndpointInfo) Port() int

Port returns just the Port part of the endpoint.

func (*BaseEndpointInfo) String 

func (info *BaseEndpointInfo) String() string

String is part of proxy.Endpoint interface.

func (*BaseEndpointInfo) ZoneHints 

func (info *BaseEndpointInfo) ZoneHints() sets.Set[string]

ZoneHints returns the zone hints for the endpoint.

type BaseServicePortInfo 

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

BaseServicePortInfo contains base information that defines a service. This could be used directly by proxier while processing services, or can be used for constructing a more specific ServiceInfo struct defined by the proxier if needed.

func (*BaseServicePortInfo) ClusterIP 

func (bsvcPortInfo *BaseServicePortInfo) ClusterIP() net.IP

ClusterIP is part of ServicePort interface.

func (*BaseServicePortInfo) ExternalIPs 

func (bsvcPortInfo *BaseServicePortInfo) ExternalIPs() []net.IP

ExternalIPs is part of ServicePort interface.

func (*BaseServicePortInfo) ExternalPolicyLocal 

func (bsvcPortInfo *BaseServicePortInfo) ExternalPolicyLocal() bool

ExternalPolicyLocal is part of ServicePort interface.

func (*BaseServicePortInfo) ExternallyAccessible 

func (bsvcPortInfo *BaseServicePortInfo) ExternallyAccessible() bool

ExternallyAccessible is part of ServicePort interface.

func (*BaseServicePortInfo) HealthCheckNodePort 

func (bsvcPortInfo *BaseServicePortInfo) HealthCheckNodePort() int

HealthCheckNodePort is part of ServicePort interface.

func (*BaseServicePortInfo) InternalPolicyLocal 

func (bsvcPortInfo *BaseServicePortInfo) InternalPolicyLocal() bool

InternalPolicyLocal is part of ServicePort interface

func (*BaseServicePortInfo) LoadBalancerSourceRanges 

func (bsvcPortInfo *BaseServicePortInfo) LoadBalancerSourceRanges() []*net.IPNet

LoadBalancerSourceRanges is part of ServicePort interface

func (*BaseServicePortInfo) LoadBalancerVIPs 

func (bsvcPortInfo *BaseServicePortInfo) LoadBalancerVIPs() []net.IP

LoadBalancerVIPs is part of ServicePort interface.

func (*BaseServicePortInfo) NodePort 

func (bsvcPortInfo *BaseServicePortInfo) NodePort() int

NodePort is part of the ServicePort interface.

func (*BaseServicePortInfo) Port 

func (bsvcPortInfo *BaseServicePortInfo) Port() int

Port is part of ServicePort interface.

func (*BaseServicePortInfo) Protocol 

func (bsvcPortInfo *BaseServicePortInfo) Protocol() v1.Protocol

Protocol is part of ServicePort interface.

func (*BaseServicePortInfo) SessionAffinityType 

func (bsvcPortInfo *BaseServicePortInfo) SessionAffinityType() v1.ServiceAffinity

SessionAffinityType is part of the ServicePort interface.

func (*BaseServicePortInfo) StickyMaxAgeSeconds 

func (bsvcPortInfo *BaseServicePortInfo) StickyMaxAgeSeconds() int

StickyMaxAgeSeconds is part of the ServicePort interface

func (*BaseServicePortInfo) String 

func (bsvcPortInfo *BaseServicePortInfo) String() string

String is part of ServicePort interface.

func (*BaseServicePortInfo) UsesClusterEndpoints 

func (bsvcPortInfo *BaseServicePortInfo) UsesClusterEndpoints() bool

UsesClusterEndpoints is part of ServicePort interface.

func (*BaseServicePortInfo) UsesLocalEndpoints 

func (bsvcPortInfo *BaseServicePortInfo) UsesLocalEndpoints() bool

UsesLocalEndpoints is part of ServicePort interface.

type Endpoint 

type Endpoint interface {
	// String returns endpoint string.  An example format can be: `IP:Port`.
	// We take the returned value as ServiceEndpoint.Endpoint.
	String() string
	// IP returns IP part of the endpoint.
	IP() string
	// Port returns the Port part of the endpoint.
	Port() int

	// IsLocal returns true if the endpoint is running on the same host as kube-proxy.
	IsLocal() bool
	// IsReady returns true if an endpoint is ready and not terminating, or
	// if PublishNotReadyAddresses is set on the service.
	IsReady() bool
	// IsServing returns true if an endpoint is ready. It does not account
	// for terminating state.
	IsServing() bool
	// IsTerminating returns true if an endpoint is terminating. For pods,
	// that is any pod with a deletion timestamp.
	IsTerminating() bool

	// ZoneHints returns the zone hint for the endpoint. This is based on
	// endpoint.hints.forZones[*].name in the EndpointSlice API.
	ZoneHints() sets.Set[string]
	// NodeHints returns the node hint for the endpoint. This is based on
	// endpoint.hints.forNodes[*].name in the EndpointSlice API.
	NodeHints() sets.Set[string]
}

Endpoint in an interface which abstracts information about an endpoint.

func CategorizeEndpoints 

func CategorizeEndpoints(endpoints []Endpoint, svcInfo ServicePort, nodeName string, nodeLabels map[string]string) (clusterEndpoints, localEndpoints, allReachableEndpoints []Endpoint, hasAnyEndpoints bool)

CategorizeEndpoints returns:

"Usable endpoints" means Ready endpoints by default, but will fall back to Serving-Terminating endpoints (independently for Cluster and Local) if no Ready endpoints are available.

type EndpointSliceCache 

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

EndpointSliceCache is used as a cache of EndpointSlice information.

func NewEndpointSliceCache 

func NewEndpointSliceCache(nodeName string, makeEndpointInfo makeEndpointFunc) *EndpointSliceCache

NewEndpointSliceCache initializes an EndpointSliceCache.

type EndpointsChangeTracker 

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

EndpointsChangeTracker carries state about uncommitted changes to an arbitrary number of Endpoints, keyed by their namespace and name.

func NewEndpointsChangeTracker 

func NewEndpointsChangeTracker(ipFamily v1.IPFamily, nodeName string, makeEndpointInfo makeEndpointFunc, processEndpointsMapChange processEndpointsMapChangeFunc) *EndpointsChangeTracker

NewEndpointsChangeTracker initializes an EndpointsChangeTracker

func (*EndpointsChangeTracker) EndpointSliceUpdate 

func (ect *EndpointsChangeTracker) EndpointSliceUpdate(endpointSlice *discovery.EndpointSlice, removeSlice bool) bool

EndpointSliceUpdate updates the EndpointsChangeTracker by adding/updating or removing endpointSlice (depending on removeSlice). It returns true if this update contained a change that needs to be synced; note that this is different from the return value of ServiceChangeTracker.Update().

type EndpointsMap 

type EndpointsMap map[ServicePortName][]Endpoint

EndpointsMap maps a service name to a list of all its Endpoints.

func (EndpointsMap) LocalReadyEndpoints 

func (em EndpointsMap) LocalReadyEndpoints() map[types.NamespacedName]int

LocalReadyEndpoints returns a map of Service names to the number of local ready endpoints for that service.

func (EndpointsMap) Update 

func (em EndpointsMap) Update(ect *EndpointsChangeTracker) UpdateEndpointsMapResult

Update updates em based on the changes in ect, returns information about the diff since the last Update, triggers processEndpointsMapChange on every change, and clears the changes map.

type NodeEligibleHandler 

type NodeEligibleHandler struct {
	HealthServer *healthcheck.ProxyHealthServer
}

NodeEligibleHandler handles the life cycle of the Node's eligibility, as determined by the health server for directing load balancer traffic.

func (*NodeEligibleHandler) OnNodeAdd 

func (n *NodeEligibleHandler) OnNodeAdd(node *v1.Node)

OnNodeAdd is a handler for Node creates.

func (*NodeEligibleHandler) OnNodeDelete 

func (n *NodeEligibleHandler) OnNodeDelete(node *v1.Node)

OnNodeDelete is a handler for Node deletes.

func (*NodeEligibleHandler) OnNodeSynced 

func (n *NodeEligibleHandler) OnNodeSynced()

OnNodeSynced is a handler for Node syncs.

func (*NodeEligibleHandler) OnNodeUpdate 

func (n *NodeEligibleHandler) OnNodeUpdate(_, node *v1.Node)

OnNodeUpdate is a handler for Node updates.

type NodePodCIDRHandler 

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

NodePodCIDRHandler handles the life cycle of kube-proxy based on the node PodCIDR assigned Implements the config.NodeHandler interface https://issues.k8s.io/111321

func NewNodePodCIDRHandler 

func NewNodePodCIDRHandler(ctx context.Context, podCIDRs []string) *NodePodCIDRHandler

func (*NodePodCIDRHandler) OnNodeAdd 

func (n *NodePodCIDRHandler) OnNodeAdd(node *v1.Node)

OnNodeAdd is a handler for Node creates.

func (*NodePodCIDRHandler) OnNodeDelete 

func (n *NodePodCIDRHandler) OnNodeDelete(node *v1.Node)

OnNodeDelete is a handler for Node deletes.

func (*NodePodCIDRHandler) OnNodeSynced 

func (n *NodePodCIDRHandler) OnNodeSynced()

OnNodeSynced is a handler for Node syncs.

func (*NodePodCIDRHandler) OnNodeUpdate 

func (n *NodePodCIDRHandler) OnNodeUpdate(_, node *v1.Node)

OnNodeUpdate is a handler for Node updates.

type Provider 

type Provider interface {
	config.EndpointSliceHandler
	config.ServiceHandler
	config.NodeHandler
	config.ServiceCIDRHandler

	// Sync immediately synchronizes the Provider's current state to proxy rules.
	Sync()
	// SyncLoop runs periodic work.
	// This is expected to run as a goroutine or as the main loop of the app.
	// It does not return.
	SyncLoop()
}

Provider is the interface provided by proxier implementations.

type ServiceChangeTracker 

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

ServiceChangeTracker carries state about uncommitted changes to an arbitrary number of Services, keyed by their namespace and name.

func NewServiceChangeTracker 

func NewServiceChangeTracker(ipFamily v1.IPFamily, makeServiceInfo makeServicePortFunc, processServiceMapChange processServiceMapChangeFunc) *ServiceChangeTracker

NewServiceChangeTracker initializes a ServiceChangeTracker

func (*ServiceChangeTracker) Update 

func (sct *ServiceChangeTracker) Update(previous, current *v1.Service) bool

Update updates the ServiceChangeTracker based on the <previous, current> service pair (where either previous or current, but not both, can be nil). It returns true if sct contains changes that need to be synced (whether or not those changes were caused by this update); note that this is different from the return value of EndpointChangeTracker.EndpointSliceUpdate().

type ServiceEndpoint 

type ServiceEndpoint struct {
	Endpoint        string
	ServicePortName ServicePortName
}

ServiceEndpoint is used to identify a service and one of its endpoint pair.

type ServicePort 

type ServicePort interface {
	// String returns service string.  An example format can be: `IP:Port/Protocol`.
	String() string
	// ClusterIP returns service cluster IP in net.IP format.
	ClusterIP() net.IP
	// Port returns service port if present. If return 0 means not present.
	Port() int
	// SessionAffinityType returns service session affinity type
	SessionAffinityType() v1.ServiceAffinity
	// StickyMaxAgeSeconds returns service max connection age
	StickyMaxAgeSeconds() int
	// ExternalIPs returns service ExternalIPs
	ExternalIPs() []net.IP
	// LoadBalancerVIPs returns service LoadBalancerIPs which are VIP mode
	LoadBalancerVIPs() []net.IP
	// Protocol returns service protocol.
	Protocol() v1.Protocol
	// LoadBalancerSourceRanges returns service LoadBalancerSourceRanges if present empty array if not
	LoadBalancerSourceRanges() []*net.IPNet
	// HealthCheckNodePort returns service health check node port if present.  If return 0, it means not present.
	HealthCheckNodePort() int
	// NodePort returns a service Node port if present. If return 0, it means not present.
	NodePort() int
	// ExternalPolicyLocal returns if a service has only node local endpoints for external traffic.
	ExternalPolicyLocal() bool
	// InternalPolicyLocal returns if a service has only node local endpoints for internal traffic.
	InternalPolicyLocal() bool
	// ExternallyAccessible returns true if the service port is reachable via something
	// other than ClusterIP (NodePort/ExternalIP/LoadBalancer)
	ExternallyAccessible() bool
	// UsesClusterEndpoints returns true if the service port ever sends traffic to
	// endpoints based on "Cluster" traffic policy
	UsesClusterEndpoints() bool
	// UsesLocalEndpoints returns true if the service port ever sends traffic to
	// endpoints based on "Local" traffic policy
	UsesLocalEndpoints() bool
}

ServicePort is an interface which abstracts information about a service.

type ServicePortMap 

type ServicePortMap map[ServicePortName]ServicePort

ServicePortMap maps a service to its ServicePort.

func (ServicePortMap) HealthCheckNodePorts 

func (sm ServicePortMap) HealthCheckNodePorts() map[types.NamespacedName]uint16

HealthCheckNodePorts returns a map of Service names to HealthCheckNodePort values for all Services in sm with non-zero HealthCheckNodePort.

func (ServicePortMap) Update 

func (sm ServicePortMap) Update(sct *ServiceChangeTracker) UpdateServiceMapResult

Update updates ServicePortMap base on the given changes, returns information about the diff since the last Update, triggers processServiceMapChange on every change, and clears the changes map.

type ServicePortName 

type ServicePortName struct {
	types.NamespacedName
	Port     string
	Protocol v1.Protocol
}

ServicePortName carries a namespace + name + portname. This is the unique identifier for a load-balanced service.

func (ServicePortName) String 

func (spn ServicePortName) String() string

type UpdateEndpointsMapResult 

type UpdateEndpointsMapResult struct {
	// UpdatedServices lists the names of all services with added/updated/deleted
	// endpoints since the last Update.
	UpdatedServices sets.Set[types.NamespacedName]
	// ConntrackCleanupRequired will be true if any UDP ServicePort changed endpoints, false otherwise.
	// It's used to minimise conntrack cleanup calls.
	ConntrackCleanupRequired bool
	// List of the trigger times for all endpoints objects that changed. It's used to export the
	// network programming latency.
	// NOTE(oxddr): this can be simplified to []time.Time if memory consumption becomes an issue.
	LastChangeTriggerTimes map[types.NamespacedName][]time.Time
}

UpdateEndpointsMapResult is the updated results after applying endpoints changes.

type UpdateServiceMapResult 

type UpdateServiceMapResult struct {
	// UpdatedServices lists the names of all services added/updated/deleted since the
	// last Update.
	UpdatedServices sets.Set[types.NamespacedName]
}

UpdateServiceMapResult is the updated results after applying service changes.

Source Files

doc.go endpoint.go endpointschangetracker.go endpointslicecache.go node.go servicechangetracker.go serviceport.go topology.go types.go

Directories

PathSynopsis
pkg/proxy/apis
pkg/proxy/apis/config
pkg/proxy/apis/config/fuzzer
pkg/proxy/apis/config/scheme
pkg/proxy/apis/config/v1alpha1
pkg/proxy/apis/config/validation
pkg/proxy/configPackage config provides decoupling between various configuration sources (etcd, files,...) and the pieces that actually care about them (loadbalancer, proxy).
pkg/proxy/conntrack
pkg/proxy/healthcheckPackage healthcheck provides tools for serving kube-proxy healthchecks.
pkg/proxy/iptables
pkg/proxy/ipvs
pkg/proxy/ipvs/ipset
pkg/proxy/ipvs/ipset/testing
pkg/proxy/ipvs/testing
pkg/proxy/ipvs/util
pkg/proxy/ipvs/util/testing
pkg/proxy/kubemark
pkg/proxy/metaproxier
pkg/proxy/metrics
pkg/proxy/nftables
pkg/proxy/util
pkg/proxy/util/nfacct
pkg/proxy/util/testing
pkg/proxy/winkernelPackage winkernel implements the Windows-kernel-based proxy
Version
v1.33.0 (latest)
Published
Apr 23, 2025
Platform
linux/amd64
Imports
22 packages
Last checked
3 hours ago –

Tools for package owners.