kubernetes: github.com/ramr/kubernetes/pkg/master Index | Files | Directories

package master

import "github.com/ramr/kubernetes/pkg/master"

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

Index

Package Files

controller.go doc.go master.go

Constants

const (
    DefaultEtcdPathPrefix = "/registry"
)

func NewEtcdStorage Uses

func NewEtcdStorage(client tools.EtcdClient, interfacesFunc meta.VersionInterfacesFunc, version, prefix string) (etcdStorage storage.Interface, err error)

NewEtcdStorage returns a storage.Interface for the provided arguments or an error if the version is incorrect.

func NewHandlerContainer Uses

func NewHandlerContainer(mux *http.ServeMux) *restful.Container

type Config Uses

type Config struct {
    DatabaseStorage    storage.Interface
    ExpDatabaseStorage storage.Interface
    EventTTL           time.Duration
    MinionRegexp       string
    KubeletClient      client.KubeletClient
    // allow downstream consumers to disable the core controller loops
    EnableCoreControllers bool
    EnableLogsSupport     bool
    EnableUISupport       bool
    // allow downstream consumers to disable swagger
    EnableSwaggerSupport bool
    // allow api versions to be conditionally disabled
    DisableV1 bool
    EnableExp bool
    // allow downstream consumers to disable the index route
    EnableIndex           bool
    EnableProfiling       bool
    APIPrefix             string
    ExpAPIPrefix          string
    CorsAllowedOriginList util.StringList
    Authenticator         authenticator.Request
    // TODO(roberthbailey): Remove once the server no longer supports http basic auth.
    SupportsBasicAuth      bool
    Authorizer             authorizer.Authorizer
    AdmissionControl       admission.Interface
    MasterServiceNamespace string

    // Map requests to contexts. Exported so downstream consumers can provider their own mappers
    RequestContextMapper api.RequestContextMapper

    // If specified, all web services will be registered into this container
    RestfulContainer *restful.Container

    // If specified, requests will be allocated a random timeout between this value, and twice this value.
    // Note that it is up to the request handlers to ignore or honor this timeout. In seconds.
    MinRequestTimeout int

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

    // The port on PublicAddress where a read-write server will be installed.
    // Defaults to 6443 if not set.
    ReadWritePort int

    // ExternalHost is the host name to use for external (public internet) facing URLs (e.g. Swagger)
    ExternalHost string

    // PublicAddress is the IP address where members of the cluster (kubelet,
    // kube-proxy, services, etc.) can reach the master.
    // If nil or 0.0.0.0, the host's default interface will be used.
    PublicAddress net.IP

    // Control the interval that pod, node IP, and node heath status caches
    // expire.
    CacheTimeout time.Duration

    // The name of the cluster.
    ClusterName string

    // The range of IPs to be assigned to services with type=ClusterIP or greater
    ServiceClusterIPRange *net.IPNet

    // The IP address for the master service (must be inside ServiceClusterIPRange
    ServiceReadWriteIP net.IP

    // The range of ports to be assigned to services with type=NodePort or greater
    ServiceNodePortRange util.PortRange

    // Used for secure proxy.  If empty, don't use secure proxy.
    SSHUser       string
    SSHKeyfile    string
    InstallSSHKey InstallSSHKey
}

Config is a structure used to configure a Master.

type Controller Uses

type Controller struct {
    NamespaceRegistry namespace.Registry
    ServiceRegistry   service.Registry
    // TODO: MasterCount is yucky
    MasterCount int

    ServiceClusterIPRegistry service.RangeRegistry
    ServiceClusterIPInterval time.Duration
    ServiceClusterIPRange    *net.IPNet

    ServiceNodePortRegistry service.RangeRegistry
    ServiceNodePortInterval time.Duration
    ServiceNodePortRange    util.PortRange

    EndpointRegistry endpoint.Registry
    EndpointInterval time.Duration

    PublicIP net.IP

    ServiceIP         net.IP
    ServicePort       int
    PublicServicePort 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" namespace, and provide the IP repair check on service IPs

func (*Controller) CreateMasterServiceIfNeeded Uses

func (c *Controller) CreateMasterServiceIfNeeded(serviceName string, serviceIP net.IP, servicePort int) error

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

func (*Controller) CreateNamespaceIfNeeded Uses

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

CreateNamespaceIfNeeded will create the namespace that contains the master services if it doesn't already exist

func (*Controller) RunKubernetesService Uses

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

RunKubernetesService periodically updates the kubernetes service

func (*Controller) SetEndpoints Uses

func (c *Controller) SetEndpoints(serviceName string, ip net.IP, port int) error

SetEndpoints sets the endpoints for the given apiserver service (ro or rw). SetEndpoints expects that the endpoints objects it manages will all be managed only by SetEndpoints; therefore, to understand this, you need only understand the requirements and the body of this function.

Requirements:

* All apiservers MUST use the same ports for their {rw, ro} services.
* All apiservers MUST use SetEndpoints and only SetEndpoints to manage the
    endpoints for their {rw, ro} services.
* All apiservers MUST know and agree on the number of apiservers expected
    to be running (c.masterCount).
* SetEndpoints is called periodically from all apiservers.

func (*Controller) Start Uses

func (c *Controller) Start()

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

func (*Controller) UpdateKubernetesService Uses

func (c *Controller) UpdateKubernetesService() error

UpdateKubernetesService attempts to update the default Kube service.

type InstallSSHKey Uses

type InstallSSHKey func(user string, data []byte) error

type Master Uses

type Master struct {

    // "Outputs"
    Handler         http.Handler
    InsecureHandler http.Handler
    // contains filtered or unexported fields
}

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

func New Uses

func New(c *Config) *Master

New returns a new instance of Master from the given config. Certain config fields will be set to a default value if unset, including:

ServiceClusterIPRange
ServiceNodePortRange
MasterCount
ReadWritePort
PublicAddress

Certain config fields must be specified, including:

KubeletClient

Public fields:

Handler -- The returned master has a field TopHandler which is an
http.Handler which handles all the endpoints provided by the master,
including the API, the UI, and miscelaneous debugging endpoints.  All
these are subject to authorization and authentication.
InsecureHandler -- an http.Handler which handles all the same
endpoints as Handler, but no authorization and authentication is done.

Public methods:

HandleWithAuth -- Allows caller to add an http.Handler for an endpoint
that uses the same authentication and authorization (if any is configured)
as the master's built-in endpoints.
If the caller wants to add additional endpoints not using the master's
auth, then the caller should create a handler for those endpoints, which delegates the
any unhandled paths to "Handler".

func (*Master) Dial Uses

func (m *Master) Dial(net, addr string) (net.Conn, error)

func (*Master) HandleFuncWithAuth Uses

func (m *Master) HandleFuncWithAuth(pattern string, handler func(http.ResponseWriter, *http.Request))

HandleFuncWithAuth adds an http.Handler for pattern to an http.ServeMux Applies the same authentication and authorization (if any is configured) to the request is used for the master's built-in endpoints.

func (*Master) HandleWithAuth Uses

func (m *Master) HandleWithAuth(pattern string, handler http.Handler)

HandleWithAuth adds an http.Handler for pattern to an http.ServeMux Applies the same authentication and authorization (if any is configured) to the request is used for the master's built-in endpoints.

func (*Master) InstallSwaggerAPI Uses

func (m *Master) InstallSwaggerAPI()

InstallSwaggerAPI installs the /swaggerapi/ endpoint to allow schema discovery and traversal. It is optional to allow consumers of the Kubernetes master to register their own web services into the Kubernetes mux prior to initialization of swagger, so that other resource types show up in the documentation.

func (*Master) IsTunnelSyncHealthy Uses

func (m *Master) IsTunnelSyncHealthy(req *http.Request) error

func (*Master) NewBootstrapController Uses

func (m *Master) NewBootstrapController() *Controller

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

Directories

PathSynopsis
portsPackage ports defines ports used by various pieces of the kubernetes infrastructure.

Package master imports 68 packages (graph). Updated 2017-07-01. Refresh now. Tools for package owners. This is an inactive package (no imports and no commits in at least two years).