README
¶
k8sleaderelection
This directory is a fork of the Kubernetes leader election package that includes prioritized leader election. These changes are required in order to make it so that the default revision wins leader elections and steals locks from non-default revisions. The changes were not upstreamed to k8s in time for the Istio 1.12 release.
Ideally, prioritized leader election gets upstreamed in the near future (KEP), and hopefully what gets merged isn't too far from what we have forked here (if it is, we'd have to potentially maintain migration code in our fork for a few releases before abandoning). Once merged we can abandon this forked code and use upstream again.
Documentation
¶
Overview ¶
Package leaderelection implements leader election of a set of endpoints. It uses an annotation in the endpoints object to store the record of the election state. This implementation does not guarantee that only one client is acting as a leader (a.k.a. fencing).
A client only acts on timestamps captured locally to infer the state of the leader election. The client does not consider timestamps in the leader election record to be accurate because these timestamps may not have been produced by a local clock. The implementation does not depend on their accuracy and only uses their change to indicate that another client has renewed the leader lease. Thus the implementation is tolerant to arbitrary clock skew, but is not tolerant to arbitrary clock skew rate.
However the level of tolerance to skew rate can be configured by setting RenewDeadline and LeaseDuration appropriately. The tolerance expressed as a maximum tolerated ratio of time passed on the fastest node to time passed on the slowest node can be approximately achieved with a configuration that sets the same ratio of LeaseDuration to RenewDeadline. For example if a user wanted to tolerate some nodes progressing forward in time twice as fast as other nodes, the user could set LeaseDuration to 60 seconds and RenewDeadline to 30 seconds.
While not required, some method of clock synchronization between nodes in the cluster is highly recommended. It's important to keep in mind when configuring this client that the tolerance to skew rate varies inversely to master availability.
Larger clusters often have a more lenient SLA for API latency. This should be taken into account when configuring the client. The rate of leader transitions should be monitored and RetryPeriod and LeaseDuration should be increased until the rate is stable and acceptably low. It's important to keep in mind when configuring this client that the tolerance to API latency varies inversely to master availability.
DISCLAIMER: this is an alpha API. This library will likely change significantly or even be removed entirely in subsequent releases. Depend on this API at your own risk. nolint
Index ¶
Constants ¶
const (
JitterFactor = 1.2
)
Variables ¶
This section is empty.
Functions ¶
func RunOrDie ¶
func RunOrDie(ctx context.Context, lec LeaderElectionConfig)
RunOrDie starts a client with the provided config or panics if the config fails to validate. RunOrDie blocks until leader election loop is stopped by ctx or it has stopped holding the leader lease
func SetProvider ¶
func SetProvider(metricsProvider MetricsProvider)
SetProvider sets the metrics provider for all subsequently created work queues. Only the first call has an effect.
Types ¶
type HealthzAdaptor ¶
type HealthzAdaptor struct {
// contains filtered or unexported fields
}
HealthzAdaptor associates the /healthz endpoint with the LeaderElection object. It helps deal with the /healthz endpoint being set up prior to the LeaderElection. This contains the code needed to act as an adaptor between the leader election code the health check code. It allows us to provide health status about the leader election. Most specifically about if the leader has failed to renew without exiting the process. In that case we should report not healthy and rely on the kubelet to take down the process.
func NewLeaderHealthzAdaptor ¶
func NewLeaderHealthzAdaptor(timeout time.Duration) *HealthzAdaptor
NewLeaderHealthzAdaptor creates a basic healthz adaptor to monitor a leader election. timeout determines the time beyond the lease expiry to be allowed for timeout. checks within the timeout period after the lease expires will still return healthy.
func (*HealthzAdaptor) Check ¶
func (l *HealthzAdaptor) Check(req *http.Request) error
Check is called by the healthz endpoint handler. It fails (returns an error) if we own the lease but had not been able to renew it.
func (*HealthzAdaptor) Name ¶
func (l *HealthzAdaptor) Name() string
Name returns the name of the health check we are implementing.
func (*HealthzAdaptor) SetLeaderElection ¶
func (l *HealthzAdaptor) SetLeaderElection(le *LeaderElector)
SetLeaderElection ties a leader election object to a HealthzAdaptor
type KeyComparisonFunc ¶
type LeaderCallbacks ¶
type LeaderCallbacks struct {
// OnStartedLeading is called when a LeaderElector client starts leading
OnStartedLeading func(context.Context)
// OnStoppedLeading is called when a LeaderElector client stops leading
OnStoppedLeading func()
// OnNewLeader is called when the client observes a leader that is
// not the previously observed leader. This includes the first observed
// leader when the client starts.
OnNewLeader func(identity string)
}
LeaderCallbacks are callbacks that are triggered during certain lifecycle events of the LeaderElector. These are invoked asynchronously.
possible future callbacks:
- OnChallenge()
type LeaderElectionConfig ¶
type LeaderElectionConfig struct {
// Lock is the resource that will be used for locking
Lock k8sresourcelock.Interface
// LeaseDuration is the duration that non-leader candidates will
// wait to force acquire leadership. This is measured against time of
// last observed ack.
//
// A client needs to wait a full LeaseDuration without observing a change to
// the record before it can attempt to take over. When all clients are
// shutdown and a new set of clients are started with different names against
// the same leader record, they must wait the full LeaseDuration before
// attempting to acquire the lease. Thus LeaseDuration should be as short as
// possible (within your tolerance for clock skew rate) to avoid a possible
// long waits in the scenario.
//
// Core clients default this value to 15 seconds.
LeaseDuration time.Duration
// RenewDeadline is the duration that the acting master will retry
// refreshing leadership before giving up.
//
// Core clients default this value to 10 seconds.
RenewDeadline time.Duration
// RetryPeriod is the duration the LeaderElector clients should wait
// between tries of actions.
//
// Core clients default this value to 2 seconds.
RetryPeriod time.Duration
// KeyComparison defines a function to compare the existing leader's key to our own.
// If the function returns true, indicating our key has high precedence, we will take over
// leadership even if their is another un-expired leader.
//
// This can be used to implemented a prioritized leader election. For example, if multiple
// versions of the same application run simultaneously, we can ensure the newest version
// will become the leader.
//
// It is the responsibility of the caller to ensure that all KeyComparison functions are
// logically consistent between all clients participating in the leader election to avoid multiple
// clients claiming to have high precedence and constantly pre-empting the existing leader.
//
// KeyComparison functions should ensure they handle an empty existingKey, as "key" is not a required field.
//
// Warning: when a lock is stolen (from KeyComparison returning true), the old leader may not
// immediately be notified they have lost the leader election.
KeyComparison KeyComparisonFunc
// Callbacks are callbacks that are triggered during certain lifecycle
// events of the LeaderElector
Callbacks LeaderCallbacks
// WatchDog is the associated health checker
// WatchDog may be null if its not needed/configured.
WatchDog *HealthzAdaptor
// ReleaseOnCancel should be set true if the lock should be released
// when the run context is canceled. If you set this to true, you must
// ensure all code guarded by this lease has successfully completed
// prior to canceling the context, or you may have two processes
// simultaneously acting on the critical path.
ReleaseOnCancel bool
// Name is the name of the resource lock for debugging
Name string
}
type LeaderElector ¶
type LeaderElector struct {
// contains filtered or unexported fields
}
LeaderElector is a leader election client.
func NewLeaderElector ¶
func NewLeaderElector(lec LeaderElectionConfig) (*LeaderElector, error)
NewLeaderElector creates a LeaderElector from a LeaderElectionConfig
func (*LeaderElector) Check ¶
func (le *LeaderElector) Check(maxTolerableExpiredLease time.Duration) error
Check will determine if the current lease is expired by more than timeout.
func (*LeaderElector) GetLeader ¶
func (le *LeaderElector) GetLeader() string
GetLeader returns the identity of the last observed leader or returns the empty string if no leader has yet been observed. This function is for informational purposes. (e.g. monitoring, logs, etc.)
func (*LeaderElector) IsLeader ¶
func (le *LeaderElector) IsLeader() bool
IsLeader returns true if the last observed leader was this client else returns false.
func (*LeaderElector) Run ¶
func (le *LeaderElector) Run(ctx context.Context)
Run starts the leader election loop. Run will not return before leader election loop is stopped by ctx or it has stopped holding the leader lease
type MetricsProvider ¶
type MetricsProvider interface {
NewLeaderMetric() SwitchMetric
}
MetricsProvider generates various metrics used by the leader election.
type SwitchMetric ¶
GaugeMetric represents a single numerical value that can arbitrarily go up and down.
Source Files
Directories