api

package
v3.0.0-beta.0+incompat... Latest Latest
Warning

This package is not in the latest version of its module.

Go to latest
Published: Mar 31, 2017 License: Apache-2.0 Imports: 9 Imported by: 0

Documentation

Overview

Example (EmptyConfig)
defaultConfig := NewConfig()

output, err := yaml.Marshal(defaultConfig)
if err != nil {
	fmt.Printf("Unexpected error: %v", err)
}

fmt.Printf("%v", string(output))
Output:

clusters: {}
contexts: {}
current-context: ""
preferences: {}
users: {}
Example (MinifyAndShorten)
certFile, _ := ioutil.TempFile("", "")
defer os.Remove(certFile.Name())
keyFile, _ := ioutil.TempFile("", "")
defer os.Remove(keyFile.Name())
caFile, _ := ioutil.TempFile("", "")
defer os.Remove(caFile.Name())

certData := "cert"
keyData := "key"
caData := "ca"

config := newMergedConfig(certFile.Name(), certData, keyFile.Name(), keyData, caFile.Name(), caData, nil)

MinifyConfig(&config)
ShortenConfig(&config)

output, _ := yaml.Marshal(config)
fmt.Printf("%s", string(output))
Output:

clusters:
  cow-cluster:
    LocationOfOrigin: ""
    certificate-authority-data: REDACTED
    server: http://cow.org:8080
contexts:
  federal-context:
    LocationOfOrigin: ""
    cluster: cow-cluster
    user: red-user
current-context: federal-context
preferences: {}
users:
  red-user:
    LocationOfOrigin: ""
    client-certificate-data: REDACTED
    client-key-data: REDACTED
    token: red-token
Example (OfOptionsConfig)
defaultConfig := NewConfig()
defaultConfig.Preferences.Colors = true
defaultConfig.Clusters["alfa"] = &Cluster{
	Server:                "https://alfa.org:8080",
	InsecureSkipTLSVerify: true,
	CertificateAuthority:  "path/to/my/cert-ca-filename",
}
defaultConfig.Clusters["bravo"] = &Cluster{
	Server:                "https://bravo.org:8080",
	InsecureSkipTLSVerify: false,
}
defaultConfig.AuthInfos["white-mage-via-cert"] = &AuthInfo{
	ClientCertificate: "path/to/my/client-cert-filename",
	ClientKey:         "path/to/my/client-key-filename",
}
defaultConfig.AuthInfos["red-mage-via-token"] = &AuthInfo{
	Token: "my-secret-token",
}
defaultConfig.AuthInfos["black-mage-via-auth-provider"] = &AuthInfo{
	AuthProvider: &AuthProviderConfig{
		Name: "gcp",
		Config: map[string]string{
			"foo":   "bar",
			"token": "s3cr3t-t0k3n",
		},
	},
}
defaultConfig.Contexts["bravo-as-black-mage"] = &Context{
	Cluster:   "bravo",
	AuthInfo:  "black-mage-via-auth-provider",
	Namespace: "yankee",
}
defaultConfig.Contexts["alfa-as-black-mage"] = &Context{
	Cluster:   "alfa",
	AuthInfo:  "black-mage-via-auth-provider",
	Namespace: "zulu",
}
defaultConfig.Contexts["alfa-as-white-mage"] = &Context{
	Cluster:  "alfa",
	AuthInfo: "white-mage-via-cert",
}
defaultConfig.CurrentContext = "alfa-as-white-mage"

output, err := yaml.Marshal(defaultConfig)
if err != nil {
	fmt.Printf("Unexpected error: %v", err)
}

fmt.Printf("%v", string(output))
Output:

clusters:
  alfa:
    LocationOfOrigin: ""
    certificate-authority: path/to/my/cert-ca-filename
    insecure-skip-tls-verify: true
    server: https://alfa.org:8080
  bravo:
    LocationOfOrigin: ""
    server: https://bravo.org:8080
contexts:
  alfa-as-black-mage:
    LocationOfOrigin: ""
    cluster: alfa
    namespace: zulu
    user: black-mage-via-auth-provider
  alfa-as-white-mage:
    LocationOfOrigin: ""
    cluster: alfa
    user: white-mage-via-cert
  bravo-as-black-mage:
    LocationOfOrigin: ""
    cluster: bravo
    namespace: yankee
    user: black-mage-via-auth-provider
current-context: alfa-as-white-mage
preferences:
  colors: true
users:
  black-mage-via-auth-provider:
    LocationOfOrigin: ""
    auth-provider:
      config:
        foo: bar
        token: s3cr3t-t0k3n
      name: gcp
  red-mage-via-token:
    LocationOfOrigin: ""
    token: my-secret-token
  white-mage-via-cert:
    LocationOfOrigin: ""
    client-certificate: path/to/my/client-cert-filename
    client-key: path/to/my/client-key-filename

Index

Examples

Constants

This section is empty.

Variables

View Source
var (
	SchemeBuilder = runtime.NewSchemeBuilder(addKnownTypes)
	AddToScheme   = SchemeBuilder.AddToScheme
)
View Source
var SchemeGroupVersion = schema.GroupVersion{Group: "", Version: runtime.APIVersionInternal}

SchemeGroupVersion is group version used to register these objects TODO this should be in the "kubeconfig" group

Functions

func FlattenConfig

func FlattenConfig(config *Config) error

Flatten changes the config object into a self contained config (useful for making secrets)

func FlattenContent

func FlattenContent(path *string, contents *[]byte, baseDir string) error

func IsConfigEmpty

func IsConfigEmpty(config *Config) bool

IsConfigEmpty returns true if the config is empty.

func MakeAbs

func MakeAbs(path, base string) (string, error)

func MinifyConfig

func MinifyConfig(config *Config) error

MinifyConfig read the current context and uses that to keep only the relevant pieces of config This is useful for making secrets based on kubeconfig files

func ResolvePath

func ResolvePath(path string, base string) string

ResolvePath returns the path as an absolute paths, relative to the given base directory

func ShortenConfig

func ShortenConfig(config *Config)

Flatten redacts raw data entries from the config object for a human-readable view.

Types

type AuthInfo

type AuthInfo struct {
	// LocationOfOrigin indicates where this object came from.  It is used for round tripping config post-merge, but never serialized.
	LocationOfOrigin string
	// ClientCertificate is the path to a client cert file for TLS.
	// +optional
	ClientCertificate string `json:"client-certificate,omitempty"`
	// ClientCertificateData contains PEM-encoded data from a client cert file for TLS. Overrides ClientCertificate
	// +optional
	ClientCertificateData []byte `json:"client-certificate-data,omitempty"`
	// ClientKey is the path to a client key file for TLS.
	// +optional
	ClientKey string `json:"client-key,omitempty"`
	// ClientKeyData contains PEM-encoded data from a client key file for TLS. Overrides ClientKey
	// +optional
	ClientKeyData []byte `json:"client-key-data,omitempty"`
	// Token is the bearer token for authentication to the kubernetes cluster.
	// +optional
	Token string `json:"token,omitempty"`
	// TokenFile is a pointer to a file that contains a bearer token (as described above).  If both Token and TokenFile are present, Token takes precedence.
	// +optional
	TokenFile string `json:"tokenFile,omitempty"`
	// Impersonate is the username to act-as.
	// +optional
	Impersonate string `json:"act-as,omitempty"`
	// Username is the username for basic authentication to the kubernetes cluster.
	// +optional
	Username string `json:"username,omitempty"`
	// Password is the password for basic authentication to the kubernetes cluster.
	// +optional
	Password string `json:"password,omitempty"`
	// AuthProvider specifies a custom authentication plugin for the kubernetes cluster.
	// +optional
	AuthProvider *AuthProviderConfig `json:"auth-provider,omitempty"`
	// Extensions holds additional information. This is useful for extenders so that reads and writes don't clobber unknown fields
	// +optional
	Extensions map[string]runtime.Object `json:"extensions,omitempty"`
}

AuthInfo contains information that describes identity information. This is use to tell the kubernetes cluster who you are.

func NewAuthInfo

func NewAuthInfo() *AuthInfo

NewConfig is a convenience function that returns a new Config object with non-nil maps

type AuthProviderConfig

type AuthProviderConfig struct {
	Name string `json:"name"`
	// +optional
	Config map[string]string `json:"config,omitempty"`
}

AuthProviderConfig holds the configuration for a specified auth provider.

type Cluster

type Cluster struct {
	// LocationOfOrigin indicates where this object came from.  It is used for round tripping config post-merge, but never serialized.
	LocationOfOrigin string
	// Server is the address of the kubernetes cluster (https://hostname:port).
	Server string `json:"server"`
	// APIVersion is the preferred api version for communicating with the kubernetes cluster (v1, v2, etc).
	// +optional
	APIVersion string `json:"api-version,omitempty"`
	// InsecureSkipTLSVerify skips the validity check for the server's certificate. This will make your HTTPS connections insecure.
	// +optional
	InsecureSkipTLSVerify bool `json:"insecure-skip-tls-verify,omitempty"`
	// CertificateAuthority is the path to a cert file for the certificate authority.
	// +optional
	CertificateAuthority string `json:"certificate-authority,omitempty"`
	// CertificateAuthorityData contains PEM-encoded certificate authority certificates. Overrides CertificateAuthority
	// +optional
	CertificateAuthorityData []byte `json:"certificate-authority-data,omitempty"`
	// Extensions holds additional information. This is useful for extenders so that reads and writes don't clobber unknown fields
	// +optional
	Extensions map[string]runtime.Object `json:"extensions,omitempty"`
}

Cluster contains information about how to communicate with a kubernetes cluster

func NewCluster

func NewCluster() *Cluster

NewConfig is a convenience function that returns a new Config object with non-nil maps

type Config

type Config struct {
	// Legacy field from pkg/api/types.go TypeMeta.
	// TODO(jlowdermilk): remove this after eliminating downstream dependencies.
	// +optional
	Kind string `json:"kind,omitempty"`
	// DEPRECATED: APIVersion is the preferred api version for communicating with the kubernetes cluster (v1, v2, etc).
	// Because a cluster can run multiple API groups and potentially multiple versions of each, it no longer makes sense to specify
	// a single value for the cluster version.
	// This field isn't really needed anyway, so we are deprecating it without replacement.
	// It will be ignored if it is present.
	// +optional
	APIVersion string `json:"apiVersion,omitempty"`
	// Preferences holds general information to be use for cli interactions
	Preferences Preferences `json:"preferences"`
	// Clusters is a map of referencable names to cluster configs
	Clusters map[string]*Cluster `json:"clusters"`
	// AuthInfos is a map of referencable names to user configs
	AuthInfos map[string]*AuthInfo `json:"users"`
	// Contexts is a map of referencable names to context configs
	Contexts map[string]*Context `json:"contexts"`
	// CurrentContext is the name of the context that you would like to use by default
	CurrentContext string `json:"current-context"`
	// Extensions holds additional information. This is useful for extenders so that reads and writes don't clobber unknown fields
	// +optional
	Extensions map[string]runtime.Object `json:"extensions,omitempty"`
}

Config holds the information needed to build connect to remote kubernetes clusters as a given user IMPORTANT if you add fields to this struct, please update IsConfigEmpty()

func NewConfig

func NewConfig() *Config

NewConfig is a convenience function that returns a new Config object with non-nil maps

func (*Config) GetObjectKind

func (obj *Config) GetObjectKind() schema.ObjectKind

func (*Config) GroupVersionKind

func (obj *Config) GroupVersionKind() schema.GroupVersionKind

func (*Config) SetGroupVersionKind

func (obj *Config) SetGroupVersionKind(gvk schema.GroupVersionKind)

type Context

type Context struct {
	// LocationOfOrigin indicates where this object came from.  It is used for round tripping config post-merge, but never serialized.
	LocationOfOrigin string
	// Cluster is the name of the cluster for this context
	Cluster string `json:"cluster"`
	// AuthInfo is the name of the authInfo for this context
	AuthInfo string `json:"user"`
	// Namespace is the default namespace to use on unspecified requests
	// +optional
	Namespace string `json:"namespace,omitempty"`
	// Extensions holds additional information. This is useful for extenders so that reads and writes don't clobber unknown fields
	// +optional
	Extensions map[string]runtime.Object `json:"extensions,omitempty"`
}

Context is a tuple of references to a cluster (how do I communicate with a kubernetes cluster), a user (how do I identify myself), and a namespace (what subset of resources do I want to work with)

func NewContext

func NewContext() *Context

NewConfig is a convenience function that returns a new Config object with non-nil maps

type Preferences

type Preferences struct {
	// +optional
	Colors bool `json:"colors,omitempty"`
	// Extensions holds additional information. This is useful for extenders so that reads and writes don't clobber unknown fields
	// +optional
	Extensions map[string]runtime.Object `json:"extensions,omitempty"`
}

IMPORTANT if you add fields to this struct, please update IsConfigEmpty()

func NewPreferences

func NewPreferences() *Preferences

NewConfig is a convenience function that returns a new Config object with non-nil maps

Directories

Path Synopsis

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL