backends

Documentation

Index

• Constants
• type Backends
  • func NewPool(cloud *gce.Cloud, namer namer.BackendNamer) *Backends
  • func (b *Backends) Create(sp utils.ServicePort, hcLink string) (*composite.BackendService, error)
  • func (b *Backends) Delete(name string, version meta.Version, scope meta.KeyType) error
  • func (b *Backends) EnsureL4BackendService(name, hcLink, protocol, sessionAffinity, scheme string, ...) (*composite.BackendService, error)
  • func (b *Backends) Get(name string, version meta.Version, scope meta.KeyType) (*composite.BackendService, error)
  • func (b *Backends) Health(name string, version meta.Version, scope meta.KeyType) (string, error)
  • func (b *Backends) List(key *meta.Key, version meta.Version) ([]*composite.BackendService, error)
  • func (b *Backends) Update(be *composite.BackendService) error
• type BalancingMode
• type FakeProbeProvider
  • func NewFakeProbeProvider(probes map[utils.ServicePort]*api_v1.Probe) *FakeProbeProvider
  • func (pp *FakeProbeProvider) GetProbe(port utils.ServicePort) (*api_v1.Probe, error)
• type GroupKey
• type Linker
  • func NewInstanceGroupLinker(instancePool instances.NodePool, backendPool Pool) Linker
  • func NewNEGLinker(backendPool Pool, negGetter NEGGetter, cloud *gce.Cloud) Linker
• type NEGGetter
• type Pool
• type ProbeProvider
• type Syncer
  • func NewBackendSyncer(backendPool Pool, healthChecker healthchecks.HealthChecker, cloud *gce.Cloud) Syncer

Constants

const (
	DefaultConnectionDrainingTimeoutSeconds = 30
)

Types

type Backends

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

Backends handles CRUD operations for backends.

func NewPool

func NewPool(cloud *gce.Cloud, namer namer.BackendNamer) *Backends

NewPool returns a new backend pool. - cloud: implements BackendServices - namer: produces names for backends.

func (*Backends) Create

func (b *Backends) Create(sp utils.ServicePort, hcLink string) (*composite.BackendService, error)

Create implements Pool.

func (*Backends) Delete

func (b *Backends) Delete(name string, version meta.Version, scope meta.KeyType) error

Delete implements Pool.

func (*Backends) EnsureL4BackendService

func (b *Backends) EnsureL4BackendService(name, hcLink, protocol, sessionAffinity, scheme string, nm types.NamespacedName, version meta.Version) (*composite.BackendService, error)

EnsureL4BackendService creates or updates the backend service with the given name.

func (*Backends) Get

func (b *Backends) Get(name string, version meta.Version, scope meta.KeyType) (*composite.BackendService, error)

Get implements Pool.

func (*Backends) Health

func (b *Backends) Health(name string, version meta.Version, scope meta.KeyType) (string, error)

Health implements Pool.

func (*Backends) List

func (b *Backends) List(key *meta.Key, version meta.Version) ([]*composite.BackendService, error)

List lists all backends managed by this controller.

func (*Backends) Update

func (b *Backends) Update(be *composite.BackendService) error

Update implements Pool.

type BalancingMode

type BalancingMode string

BalancingMode represents the loadbalancing configuration of an individual Backend in a BackendService. This is *effectively* a cluster wide setting since you can't mix modes across Backends pointing to the same IG, and you can't have a single node in more than 1 loadbalanced IG.

const (
	// Rate balances incoming requests based on observed RPS.
	// As of this writing, it's the only balancing mode supported by GCE's
	// internal LB. This setting doesn't make sense for Kubernetes clusters
	// because requests can get proxied between instance groups in different
	// zones by kube-proxy without GCE even knowing it. Setting equal RPS on
	// all IGs should achieve roughly equal distribution of requests.
	Rate BalancingMode = "RATE"
	// Utilization balances incoming requests based on observed utilization.
	// This mode is only useful if you want to divert traffic away from IGs
	// running other compute intensive workloads. Utilization statistics are
	// aggregated per instances, not per container, and requests can get proxied
	// between instance groups in different zones by kube-proxy without GCE even
	// knowing about it.
	Utilization BalancingMode = "UTILIZATION"
	// Connections balances incoming requests based on a connection counter.
	// This setting currently doesn't make sense for Kubernetes clusters,
	// because we use NodePort Services as HTTP LB backends, so GCE's connection
	// counters don't accurately represent connections per container.
	Connections BalancingMode = "CONNECTION"
)

type FakeProbeProvider

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

FakeProbeProvider implements the probeProvider interface for tests.

func NewFakeProbeProvider

func NewFakeProbeProvider(probes map[utils.ServicePort]*api_v1.Probe) *FakeProbeProvider

NewFakeProbeProvider returns a struct which satisfies probeProvider interface

func (*FakeProbeProvider) GetProbe

func (pp *FakeProbeProvider) GetProbe(port utils.ServicePort) (*api_v1.Probe, error)

GetProbe returns the probe for a given nodePort

type GroupKey

type GroupKey struct {
	Zone string
	Name string
}

GroupKey represents a single group for a backend. The implementation of this Group could be InstanceGroup or NEG.

type Linker

type Linker interface {
	// Link a BackendService to its groups.
	Link(sp utils.ServicePort, groups []GroupKey) error
}

Linker is an interface to link backends with their associated groups.

func NewInstanceGroupLinker

func NewInstanceGroupLinker(
	instancePool instances.NodePool,
	backendPool Pool) Linker

func NewNEGLinker

func NewNEGLinker(
	backendPool Pool,
	negGetter NEGGetter,
	cloud *gce.Cloud) Linker

type NEGGetter

type NEGGetter interface {
	GetNetworkEndpointGroup(name string, zone string, version meta.Version) (*composite.NetworkEndpointGroup, error)
}

NEGGetter is an interface to retrieve NEG object

type Pool

type Pool interface {
	// Get a composite BackendService given a required version.
	Get(name string, version meta.Version, scope meta.KeyType) (*composite.BackendService, error)
	// Create a composite BackendService and returns it.
	Create(sp utils.ServicePort, hcLink string) (*composite.BackendService, error)
	// Update a BackendService given the composite type.
	Update(be *composite.BackendService) error
	// Delete a BackendService given its name.
	Delete(name string, version meta.Version, scope meta.KeyType) error
	// Get the health of a BackendService given its name.
	Health(name string, version meta.Version, scope meta.KeyType) (string, error)
	// Get a list of BackendService names that are managed by this pool.
	List(key *meta.Key, version meta.Version) ([]*composite.BackendService, error)
}

Pool is an interface to perform CRUD operations on a pool of GCE Backend Services.

type ProbeProvider

type ProbeProvider interface {
	GetProbe(sp utils.ServicePort) (*api_v1.Probe, error)
}

ProbeProvider retrieves a probe struct given a nodePort

type Syncer

type Syncer interface {
	// Init an implementation of ProbeProvider.
	Init(p ProbeProvider)
	// Sync a BackendService. Implementations should only create the BackendService
	// but not its groups.
	Sync(svcPorts []utils.ServicePort) error
	// GC garbage collects unused BackendService's
	GC(svcPorts []utils.ServicePort) error
	// Status returns the status of a BackendService given its name.
	Status(name string, version meta.Version, scope meta.KeyType) (string, error)
	// Shutdown cleans up all BackendService's previously synced.
	Shutdown() error
}

Syncer is an interface to sync Kubernetes services to GCE BackendServices.

func NewBackendSyncer

func NewBackendSyncer(
	backendPool Pool,
	healthChecker healthchecks.HealthChecker,
	cloud *gce.Cloud) Syncer