master

Documentation

Overview

Package master contains code for setting up and running a Kubernetes cluster master.

Index

• Constants
• func DefaultAPIResourceConfigSource() *genericapiserver.ResourceConfig
• func DefaultServiceIPRange(passedServiceClusterIPRange net.IPNet) (net.IPNet, net.IP, error)
• func NewMasterCountEndpointReconciler(masterCount int, endpointClient coreclient.EndpointsGetter) *masterCountEndpointReconciler
• type Config
  • func (c *Config) Complete() completedConfig
  • func (c *Config) NewBootstrapController(legacyRESTStorage corerest.LegacyRESTStorage, ...) *Controller
  • func (c *Config) SkipComplete() completedConfig
• type Controller
  • func (c *Controller) CreateNamespaceIfNeeded(ns string) error
  • func (c *Controller) CreateOrUpdateMasterServiceIfNeeded(serviceName string, serviceIP net.IP, servicePorts []api.ServicePort, ...) error
  • func (c *Controller) PostStartHook(hookContext genericapiserver.PostStartHookContext) error
  • func (c *Controller) RunKubernetesNamespaces(ch chan struct{})
  • func (c *Controller) RunKubernetesService(ch chan struct{})
  • func (c *Controller) Start()
  • func (c *Controller) UpdateKubernetesService(reconcile bool) error
• type EndpointReconciler
• type EndpointReconcilerConfig
• type Master
  • func (m *Master) InstallAPIs(apiResourceConfigSource genericapiserver.APIResourceConfigSource, ...)
  • func (m *Master) InstallLegacyAPI(c *Config, restOptionsGetter generic.RESTOptionsGetter, ...)
• type RESTStorageProvider

Constants

const (
	// DefaultEndpointReconcilerInterval is the default amount of time for how often the endpoints for
	// the kubernetes Service are reconciled.
	DefaultEndpointReconcilerInterval = 10 * time.Second
)

Functions

func DefaultAPIResourceConfigSource

func DefaultAPIResourceConfigSource() *genericapiserver.ResourceConfig

func DefaultServiceIPRange

func DefaultServiceIPRange(passedServiceClusterIPRange net.IPNet) (net.IPNet, net.IP, error)

DefaultServiceIPRange takes a the serviceIPRange flag and returns the defaulted service ip range (if needed), api server service IP, and an error TODO move this out of the genericapiserver package

func NewMasterCountEndpointReconciler

func NewMasterCountEndpointReconciler(masterCount int, endpointClient coreclient.EndpointsGetter) *masterCountEndpointReconciler

NewMasterCountEndpointReconciler creates a new EndpointReconciler that reconciles based on a specified expected number of masters.

Types

type Config

type Config struct {
	GenericConfig *genericapiserver.Config

	APIResourceConfigSource  genericapiserver.APIResourceConfigSource
	StorageFactory           genericapiserver.StorageFactory
	EnableCoreControllers    bool
	EndpointReconcilerConfig EndpointReconcilerConfig
	EventTTL                 time.Duration
	KubeletClientConfig      kubeletclient.KubeletClientConfig

	// Used to start and monitor tunneling
	Tunneler          tunneler.Tunneler
	EnableUISupport   bool
	EnableLogsSupport bool
	ProxyTransport    http.RoundTripper

	// Values to build the IP addresses used by discovery
	// The range of IPs to be assigned to services with type=ClusterIP or greater
	ServiceIPRange net.IPNet
	// The IP address for the GenericAPIServer service (must be inside ServiceIPRange)
	APIServerServiceIP net.IP
	// Port for the apiserver service.
	APIServerServicePort int

	// The range of ports to be assigned to services with type=NodePort or greater
	ServiceNodePortRange utilnet.PortRange
	// Additional ports to be exposed on the GenericAPIServer service
	// extraServicePorts is injectable in the event that more ports
	// (other than the default 443/tcp) are exposed on the GenericAPIServer
	// and those ports need to be load balanced by the GenericAPIServer
	// service because this pkg is linked by out-of-tree projects
	// like openshift which want to use the GenericAPIServer but also do
	// more stuff.
	ExtraServicePorts []api.ServicePort
	// Additional ports to be exposed on the GenericAPIServer endpoints
	// Port names should align with ports defined in ExtraServicePorts
	ExtraEndpointPorts []api.EndpointPort
	// If non-zero, the "kubernetes" services uses this port as NodePort.
	KubernetesServiceNodePort int

	// Number of masters running; all masters must be started with the
	// same value for this field. (Numbers > 1 currently untested.)
	MasterCount int
}

func (*Config) Complete

func (c *Config) Complete() completedConfig

Complete fills in any fields not set that are required to have valid data. It's mutating the receiver.

func (*Config) NewBootstrapController

func (c *Config) NewBootstrapController(legacyRESTStorage corerest.LegacyRESTStorage, serviceClient coreclient.ServicesGetter, nsClient coreclient.NamespacesGetter) *Controller

NewBootstrapController returns a controller for watching the core capabilities of the master

func (*Config) SkipComplete

func (c *Config) SkipComplete() completedConfig

SkipComplete provides a way to construct a server instance without config completion.

type Controller

type Controller struct {
	ServiceClient   coreclient.ServicesGetter
	NamespaceClient coreclient.NamespacesGetter

	ServiceClusterIPRegistry rangeallocation.RangeRegistry
	ServiceClusterIPInterval time.Duration
	ServiceClusterIPRange    net.IPNet

	ServiceNodePortRegistry rangeallocation.RangeRegistry
	ServiceNodePortInterval time.Duration
	ServiceNodePortRange    utilnet.PortRange

	EndpointReconciler EndpointReconciler
	EndpointInterval   time.Duration

	SystemNamespaces         []string
	SystemNamespacesInterval time.Duration

	PublicIP net.IP

	// ServiceIP indicates where the kubernetes service will live.  It may not be nil.
	ServiceIP                 net.IP
	ServicePort               int
	ExtraServicePorts         []api.ServicePort
	ExtraEndpointPorts        []api.EndpointPort
	PublicServicePort         int
	KubernetesServiceNodePort int
	// contains filtered or unexported fields
}

Controller is the controller manager for the core bootstrap Kubernetes controller loops, which manage creating the "kubernetes" service, the "default", "kube-system" and "kube-public" namespaces, and provide the IP repair check on service IPs

func (*Controller) CreateNamespaceIfNeeded

func (c *Controller) CreateNamespaceIfNeeded(ns string) error

CreateNamespaceIfNeeded will create a namespace if it doesn't already exist

func (*Controller) CreateOrUpdateMasterServiceIfNeeded

func (c *Controller) CreateOrUpdateMasterServiceIfNeeded(serviceName string, serviceIP net.IP, servicePorts []api.ServicePort, serviceType api.ServiceType, reconcile bool) error

CreateMasterServiceIfNeeded will create the specified service if it doesn't already exist.

func (*Controller) PostStartHook

func (c *Controller) PostStartHook(hookContext genericapiserver.PostStartHookContext) error

func (*Controller) RunKubernetesNamespaces

func (c *Controller) RunKubernetesNamespaces(ch chan struct{})

RunKubernetesNamespaces periodically makes sure that all internal namespaces exist

func (*Controller) RunKubernetesService

func (c *Controller) RunKubernetesService(ch chan struct{})

RunKubernetesService periodically updates the kubernetes service

func (*Controller) Start

func (c *Controller) Start()

Start begins the core controller loops that must exist for bootstrapping a cluster.

func (*Controller) UpdateKubernetesService

func (c *Controller) UpdateKubernetesService(reconcile bool) error

UpdateKubernetesService attempts to update the default Kube service.

type EndpointReconciler

type EndpointReconciler interface {
	// ReconcileEndpoints sets the endpoints for the given apiserver service (ro or rw).
	// ReconcileEndpoints expects that the endpoints objects it manages will all be
	// managed only by ReconcileEndpoints; therefore, to understand this, you need only
	// understand the requirements.
	//
	// Requirements:
	//  * All apiservers MUST use the same ports for their {rw, ro} services.
	//  * All apiservers MUST use ReconcileEndpoints and only ReconcileEndpoints to manage the
	//      endpoints for their {rw, ro} services.
	//  * ReconcileEndpoints is called periodically from all apiservers.
	ReconcileEndpoints(serviceName string, ip net.IP, endpointPorts []api.EndpointPort, reconcilePorts bool) error
}

EndpointReconciler knows how to reconcile the endpoints for the apiserver service.

type EndpointReconcilerConfig

type EndpointReconcilerConfig struct {
	Reconciler EndpointReconciler
	Interval   time.Duration
}

EndpointReconcilerConfig holds the endpoint reconciler and endpoint reconciliation interval to be used by the master.

type Master

type Master struct {
	GenericAPIServer *genericapiserver.GenericAPIServer
}

Master contains state for a Kubernetes cluster master/api server.

func (*Master) InstallAPIs

func (m *Master) InstallAPIs(apiResourceConfigSource genericapiserver.APIResourceConfigSource, restOptionsGetter generic.RESTOptionsGetter, restStorageProviders ...RESTStorageProvider)

InstallAPIs will install the APIs for the restStorageProviders if they are enabled.

func (*Master) InstallLegacyAPI

func (m *Master) InstallLegacyAPI(c *Config, restOptionsGetter generic.RESTOptionsGetter, legacyRESTStorageProvider corerest.LegacyRESTStorageProvider)

type RESTStorageProvider

type RESTStorageProvider interface {
	GroupName() string
	NewRESTStorage(apiResourceConfigSource genericapiserver.APIResourceConfigSource, restOptionsGetter generic.RESTOptionsGetter) (genericapiserver.APIGroupInfo, bool)
}

RESTStorageProvider is a factory type for REST storage.