install

Documentation

Overview

Package install provides the functionality for installing a Kismatic cluster.

Index

• func GenerateKubeconfig(p *Plan, generatedAssetsDir string) error
• func ValidateNode(node *Node) (bool, []error)
• func ValidatePlan(p *Plan) (bool, []error)
• func ValidatePlanSSHConnection(p *Plan) (bool, []error)
• func ValidateSSHConnection(con *SSHConnection, prefix string) (bool, []error)
• func WritePlanTemplate(p Plan, w PlanReadWriter) error
• type CertsConfig
• type Cluster
• type ConfigOptions
• type DockerRegistry
• type Executor
  • func NewExecutor(stdout io.Writer, errOut io.Writer, options ExecutorOptions) (Executor, error)
• type ExecutorOptions
• type FilePlanner
  • func (fp *FilePlanner) PlanExists() bool
  • func (fp *FilePlanner) Read() (*Plan, error)
  • func (fp *FilePlanner) Write(p *Plan) error
• type LocalPKI
  • func (lp *LocalPKI) CertificateAuthorityExists() (bool, error)
  • func (lp *LocalPKI) GenerateClusterCA(p *Plan) (*tls.CA, error)
  • func (lp *LocalPKI) GenerateClusterCertificates(p *Plan, ca *tls.CA, users []string) error
  • func (lp *LocalPKI) GenerateNodeCertificate(plan *Plan, node Node, ca *tls.CA) error
  • func (lp *LocalPKI) GetClusterCA() (*tls.CA, error)
  • func (lp *LocalPKI) NodeCertificateExists(node Node) (bool, error)
• type MasterNodeGroup
• type NetworkConfig
• type Node
• type NodeGroup
• type OptionalNodeGroup
• type PKI
• type Plan
• type PlanReadWriter
• type Planner
• type PreFlightExecutor
  • func NewPreFlightExecutor(stdout io.Writer, errOut io.Writer, options ExecutorOptions) (PreFlightExecutor, error)
• type SSHConfig
• type SSHConnection

Functions

func GenerateKubeconfig

func GenerateKubeconfig(p *Plan, generatedAssetsDir string) error

GenerateKubeconfig generate a kubeconfig file for a specific user

func ValidateNode

func ValidateNode(node *Node) (bool, []error)

ValidateNode runs validation against the given node.

func ValidatePlan

func ValidatePlan(p *Plan) (bool, []error)

ValidatePlan runs validation against the installation plan to ensure that the plan contains valid user input. Returns true, nil if the validation is successful. Otherwise, returns false and a collection of validation errors.

func ValidatePlanSSHConnection

func ValidatePlanSSHConnection(p *Plan) (bool, []error)

ValidatePlanSSHConnection tries to establish SSH connections to all nodes in the cluster

func ValidateSSHConnection

func ValidateSSHConnection(con *SSHConnection, prefix string) (bool, []error)

ValidateSSHConnection tries to establish SSH connection with the details provieded

func WritePlanTemplate

func WritePlanTemplate(p Plan, w PlanReadWriter) error

WritePlanTemplate writes an installation plan with pre-filled defaults.

Types

type CertsConfig

type CertsConfig struct {
	Expiry string
}

CertsConfig describes the cluster's trust and certificate configuration

type Cluster

type Cluster struct {
	Name                     string
	AdminPassword            string `yaml:"admin_password"`
	AllowPackageInstallation bool   `yaml:"allow_package_installation"`
	Networking               NetworkConfig
	Certificates             CertsConfig
	SSH                      SSHConfig
}

Cluster describes a Kubernetes cluster

type ConfigOptions

type ConfigOptions struct {
	CA      string
	Server  string
	Cluster string
	User    string
	Context string
	Cert    string
	Key     string
}

ConfigOptions sds

type DockerRegistry

type DockerRegistry struct {
	SetupInternal bool `yaml:"setup_internal"`
	Address       string
	Port          int
	CAPath        string `yaml:"CA"`
}

DockerRegistry details for docker registry, either confgiured by the cli or customer provided

type Executor

type Executor interface {
	PreFlightExecutor
	Install(p *Plan) error
	RunSmokeTest(*Plan) error
	AddWorker(*Plan, Node) (*Plan, error)
	RunTask(string, *Plan) error
}

The Executor will carry out the installation plan

func NewExecutor

func NewExecutor(stdout io.Writer, errOut io.Writer, options ExecutorOptions) (Executor, error)

NewExecutor returns an executor for performing installations according to the installation plan.

type ExecutorOptions

type ExecutorOptions struct {
	// SkipCAGeneration determines whether the Certificate Authority should
	// be generated. If false, an existing CA file must exist.
	SkipCAGeneration bool
	// GeneratedAssetsDirectory is the location where generated assets
	// are to be stored
	GeneratedAssetsDirectory string
	// RestartServices determines whether the cluster services should be
	// restarted during the installation.
	RestartServices bool
	// OutputFormat sets the format of the executor
	OutputFormat string
	// Verbose output from the executor
	Verbose bool
	// RunsDirectory is where information about installation runs is kept
	RunsDirectory string
}

ExecutorOptions are used to configure the executor

type FilePlanner

type FilePlanner struct {
	File string
}

FilePlanner is a file-based installation planner

func (*FilePlanner) PlanExists

func (fp *FilePlanner) PlanExists() bool

PlanExists return true if the plan exists on the file system

func (*FilePlanner) Read

func (fp *FilePlanner) Read() (*Plan, error)

Read the plan from the file system

func (*FilePlanner) Write

func (fp *FilePlanner) Write(p *Plan) error

Write the plan to the file system

type LocalPKI

type LocalPKI struct {
	CACsr                   string
	CAConfigFile            string
	CASigningProfile        string
	GeneratedCertsDirectory string
	Log                     io.Writer
}

LocalPKI is a file-based PKI

func (*LocalPKI) CertificateAuthorityExists

func (lp *LocalPKI) CertificateAuthorityExists() (bool, error)

CertificateAuthorityExists returns true if the CA for the cluster exists

func (*LocalPKI) GenerateClusterCA

func (lp *LocalPKI) GenerateClusterCA(p *Plan) (*tls.CA, error)

GenerateClusterCA creates a Certificate Authority for the cluster

func (*LocalPKI) GenerateClusterCertificates

func (lp *LocalPKI) GenerateClusterCertificates(p *Plan, ca *tls.CA, users []string) error

GenerateClusterCertificates creates a Certificates for all nodes on the cluster

func (*LocalPKI) GenerateNodeCertificate

func (lp *LocalPKI) GenerateNodeCertificate(plan *Plan, node Node, ca *tls.CA) error

GenerateNodeCertificate creates a private key and certificate for the given node

func (*LocalPKI) GetClusterCA

func (lp *LocalPKI) GetClusterCA() (*tls.CA, error)

GetClusterCA returns the cluster CA

func (*LocalPKI) NodeCertificateExists

func (lp *LocalPKI) NodeCertificateExists(node Node) (bool, error)

NodeCertificateExists returns true if the node's key and certificate exist

type MasterNodeGroup

type MasterNodeGroup struct {
	ExpectedCount         int    `yaml:"expected_count"`
	LoadBalancedFQDN      string `yaml:"load_balanced_fqdn"`
	LoadBalancedShortName string `yaml:"load_balanced_short_name"`
	Nodes                 []Node
}

MasterNodeGroup is the collection of master nodes

type NetworkConfig

type NetworkConfig struct {
	Type             string
	PodCIDRBlock     string `yaml:"pod_cidr_block"`
	ServiceCIDRBlock string `yaml:"service_cidr_block"`
	PolicyEnabled    bool   `yaml:"policy_enabled"`
	UpdateHostsFiles bool   `yaml:"update_hosts_files"`
}

NetworkConfig describes the cluster's networking configuration

type Node

type Node struct {
	Host       string
	IP         string
	InternalIP string
}

A Node is a compute unit, virtual or physical, that is part of the cluster

type NodeGroup

type NodeGroup struct {
	ExpectedCount int `yaml:"expected_count"`
	Nodes         []Node
}

A NodeGroup is a collection of nodes

type OptionalNodeGroup

type OptionalNodeGroup NodeGroup

An OptionalNodeGroup is a collection of nodes that can be empty

type PKI

type PKI interface {
	CertificateAuthorityExists() (bool, error)
	NodeCertificateExists(node Node) (bool, error)
	GenerateNodeCertificate(plan *Plan, node Node, ca *tls.CA) error
	GetClusterCA() (*tls.CA, error)
	GenerateClusterCA(p *Plan) (*tls.CA, error)
	GenerateClusterCertificates(p *Plan, ca *tls.CA, users []string) error
}

The PKI provides a way for generating certificates for the cluster described by the Plan

type Plan

type Plan struct {
	Cluster        Cluster
	DockerRegistry DockerRegistry `yaml:"docker_registry"`
	Etcd           NodeGroup
	Master         MasterNodeGroup
	Worker         NodeGroup
	Ingress        OptionalNodeGroup
}

Plan is the installation plan that the user intends to execute

type PlanReadWriter

type PlanReadWriter interface {
	Read() (*Plan, error)
	Write(*Plan) error
}

PlanReadWriter is capable of reading/writing a Plan

type Planner

type Planner interface {
	PlanReadWriter
	PlanExists() bool
}

Planner is used to plan the installation

type PreFlightExecutor

type PreFlightExecutor interface {
	RunPreFlightCheck(*Plan) error
}

The PreFlightExecutor will run pre-flight checks against the environment defined in the plan file

func NewPreFlightExecutor

func NewPreFlightExecutor(stdout io.Writer, errOut io.Writer, options ExecutorOptions) (PreFlightExecutor, error)

NewPreFlightExecutor returns an executor for running preflight

type SSHConfig

type SSHConfig struct {
	User string
	Key  string `yaml:"ssh_key"`
	Port int    `yaml:"ssh_port"`
}

SSHConfig describes the cluster's SSH configuration for accessing nodes

type SSHConnection

type SSHConnection struct {
	SSHConfig *SSHConfig
	Nodes     []Node
}