gardener: github.com/gardener/gardener/pkg/client/kubernetes Index | Files

package kubernetes

import "github.com/gardener/gardener/pkg/client/kubernetes"

Index

Package Files

admissionplugins.go apply.go chartapplier.go client.go clientset.go options.go pods.go scaling.go types.go

Constants

const KubeConfig = "kubeconfig"

KubeConfig is the key to the kubeconfig

Variables

var (
    // GardenScheme is the scheme used in the Garden cluster.
    GardenScheme = runtime.NewScheme()
    // SeedScheme is the scheme used in the Seed cluster.
    SeedScheme = runtime.NewScheme()
    // ShootScheme is the scheme used in the Shoot cluster.
    ShootScheme = runtime.NewScheme()
    // PlantScheme is the scheme used in the Plant cluster
    PlantScheme = runtime.NewScheme()

    // DefaultDeleteOptions use foreground propagation policy and grace period of 60 seconds.
    DefaultDeleteOptions = []client.DeleteOption{
        client.PropagationPolicy(metav1.DeletePropagationForeground),
        client.GracePeriodSeconds(60),
    }
    // ForceDeleteOptions use background propagation policy and grace period of 0 seconds.
    ForceDeleteOptions = []client.DeleteOption{
        client.PropagationPolicy(metav1.DeletePropagationBackground),
        client.GracePeriodSeconds(0),
    }
)
var DefaultApplierOptions = ApplierOptions{
    MergeFuncs: map[schema.GroupKind]MergeFunc{
        corev1.SchemeGroupVersion.WithKind("Service").GroupKind(): func(newObj, oldObj *unstructured.Unstructured) {

            oldPorts := oldObj.Object["spec"].(map[string]interface{})["ports"].([]interface{})
            newPorts := newObj.Object["spec"].(map[string]interface{})["ports"].([]interface{})
            ports := []map[string]interface{}{}

            for _, newPort := range newPorts {
                np := newPort.(map[string]interface{})

                for _, oldPort := range oldPorts {
                    op := oldPort.(map[string]interface{})

                    if fmt.Sprintf("%v", np["port"]) == fmt.Sprintf("%v", op["port"]) {
                        if nodePort, ok := op["nodePort"]; ok {
                            np["nodePort"] = nodePort
                        }
                    }
                }
                ports = append(ports, np)
            }

            newObj.Object["spec"].(map[string]interface{})["clusterIP"] = oldObj.Object["spec"].(map[string]interface{})["clusterIP"]
            newObj.Object["spec"].(map[string]interface{})["healthCheckNodePort"] = oldObj.Object["spec"].(map[string]interface{})["healthCheckNodePort"]
            newObj.Object["spec"].(map[string]interface{})["ports"] = ports
        },
        corev1.SchemeGroupVersion.WithKind("ServiceAccount").GroupKind(): func(newObj, oldObj *unstructured.Unstructured) {

            newObj.Object["secrets"] = oldObj.Object["secrets"]
            newObj.Object["imagePullSecrets"] = oldObj.Object["imagePullSecrets"]
        },
        {Group: "autoscaling.k8s.io", Kind: "VerticalPodAutoscaler"}: func(newObj, oldObj *unstructured.Unstructured) {

            newObj.Object["status"] = oldObj.Object["status"]
        },
    },
}

DefaultApplierOptions contains options for common k8s objects, e.g. Service, ServiceAccount.

var NewControllerClient = newControllerClient

NewControllerClient instantiates a new client.Client.

func GetAdmissionPluginsForVersion Uses

func GetAdmissionPluginsForVersion(v string) []gardencorev1beta1.AdmissionPlugin

GetAdmissionPluginsForVersion returns the set of default admission plugins for the given Kubernetes version. If the given Kubernetes version does not explicitly define admission plugins the set of names for the next available version will be returned (e.g., for version X not defined the set of version X-1 will be returned).

func GetPodLogs Uses

func GetPodLogs(podInterface corev1client.PodInterface, name string, options *corev1.PodLogOptions) ([]byte, error)

GetPodLogs retrieves the pod logs of the pod of the given name with the given options.

func NewRuntimeClientForConfig Uses

func NewRuntimeClientForConfig(fns ...ConfigFunc) (client.Client, error)

NewRuntimeClientForConfig returns a new controller runtime client from a config.

func NewRuntimeClientFromBytes Uses

func NewRuntimeClientFromBytes(kubeconfig []byte, fns ...ConfigFunc) (client.Client, error)

NewRuntimeClientFromBytes creates a new controller runtime Client struct for a given kubeconfig byte slice.

func NewRuntimeClientFromSecret Uses

func NewRuntimeClientFromSecret(secret *corev1.Secret, fns ...ConfigFunc) (client.Client, error)

NewRuntimeClientFromSecret creates a new controller runtime Client struct for a given secret.

func RESTConfigFromClientConnectionConfiguration Uses

func RESTConfigFromClientConnectionConfiguration(cfg *componentbaseconfig.ClientConnectionConfiguration, kubeconfig []byte) (*rest.Config, error)

RESTConfigFromClientConnectionConfiguration creates a *rest.Config from a componentbaseconfig.ClientConnectionConfiguration & the configured kubeconfig

func ScaleDeployment Uses

func ScaleDeployment(ctx context.Context, c client.Client, key client.ObjectKey, replicas int32) error

ScaleDeployment scales a Deployment.

func ScaleStatefulSet Uses

func ScaleStatefulSet(ctx context.Context, c client.Client, key client.ObjectKey, replicas int32) error

ScaleStatefulSet scales a StatefulSet.

func ValidateConfig Uses

func ValidateConfig(config clientcmdapi.Config) error

ValidateConfig validates that the auth info of a given kubeconfig doesn't have unsupported fields.

type Applier Uses

type Applier struct {
    // contains filtered or unexported fields
}

Applier is a default implementation of the ApplyInterface. It applies objects with by first checking whether they exist and then either creating / updating them (update happens with a predefined merge logic).

func NewApplierForConfig Uses

func NewApplierForConfig(config *rest.Config) (*Applier, error)

NewApplierForConfig creates and returns a new Applier for the given rest.Config.

func NewApplierInternal Uses

func NewApplierInternal(config *rest.Config, discoveryClient discovery.CachedDiscoveryInterface) (*Applier, error)

NewApplierInternal constructs a new Applier from the given config and DiscoveryInterface. This method should only be used for testing.

func (*Applier) ApplyManifest Uses

func (c *Applier) ApplyManifest(ctx context.Context, r UnstructuredReader, options ApplierOptions) error

ApplyManifest is a function which does the same like `kubectl apply -f <file>`. It takes a bunch of manifests <m>, all concatenated in a byte slice, and sends them one after the other to the API server. If a resource already exists at the API server, it will update it. It returns an error as soon as the first error occurs.

func (*Applier) DeleteManifest Uses

func (c *Applier) DeleteManifest(ctx context.Context, r UnstructuredReader) error

DeleteManifest is a function which does the same like `kubectl delete -f <file>`. It takes a bunch of manifests <m>, all concatenated in a byte slice, and sends them one after the other to the API server for deletion. It returns an error as soon as the first error occurs.

type ApplierInterface Uses

type ApplierInterface interface {
    ApplyManifest(ctx context.Context, unstructured UnstructuredReader, options ApplierOptions) error
    DeleteManifest(ctx context.Context, unstructured UnstructuredReader) error
}

ApplierInterface is an interface which describes declarative operations to apply multiple Kubernetes objects.

type ApplierOptions Uses

type ApplierOptions struct {
    MergeFuncs map[schema.GroupKind]MergeFunc
}

ApplierOptions contains options used by the Applier.

func CopyApplierOptions Uses

func CopyApplierOptions(in ApplierOptions) ApplierOptions

CopyApplierOptions returns a copies of the provided applier options.

type ChartApplier Uses

type ChartApplier interface {
    chartrenderer.Interface
    ApplierInterface

    ApplyChartWithOptions(ctx context.Context, chartPath, namespace, name string, defaultValues, additionalValues map[string]interface{}, options ApplierOptions) error
    ApplyChart(ctx context.Context, chartPath, namespace, name string, defaultValues, additionalValues map[string]interface{}) error
    ApplyChartInNamespaceWithOptions(ctx context.Context, chartPath, namespace, name string, defaultValues, additionalValues map[string]interface{}, options ApplierOptions) error
    ApplyChartInNamespace(ctx context.Context, chartPath, namespace, name string, defaultValues, additionalValues map[string]interface{}) error

    DeleteChart(ctx context.Context, chartPath, namespace, name string, defaultValues, additionalValues map[string]interface{}) error
}

ChartApplier is an interface that describes needed methods that render and apply Helm charts in Kubernetes clusters.

func NewChartApplier Uses

func NewChartApplier(renderer chartrenderer.Interface, applier ApplierInterface) ChartApplier

NewChartApplier returns a new chart applier.

func NewChartApplierForConfig Uses

func NewChartApplierForConfig(config *rest.Config) (ChartApplier, error)

NewChartApplierForConfig returns a new chart applier based on the given REST config.

type Clientset Uses

type Clientset struct {
    // contains filtered or unexported fields
}

Clientset is a struct containing the configuration for the respective Kubernetes cluster, the collection of Kubernetes clients <Clientset> containing all REST clients for the built-in Kubernetes API groups, and the Garden which is a REST clientset for the Garden API group. The RESTClient itself is a normal HTTP client for the respective Kubernetes cluster, allowing requests to arbitrary URLs. The version string contains only the major/minor part in the form <major>.<minor>.

func (*Clientset) APIExtension Uses

func (c *Clientset) APIExtension() apiextensionclientset.Interface

APIExtension will return the apiextensionsClientset attribute of the Client object.

func (*Clientset) APIRegistration Uses

func (c *Clientset) APIRegistration() apiregistrationclientset.Interface

APIRegistration will return the apiregistration attribute of the Client object.

func (*Clientset) Applier Uses

func (c *Clientset) Applier() ApplierInterface

Applier returns the applier of this Clientset.

func (*Clientset) CheckForwardPodPort Uses

func (c *Clientset) CheckForwardPodPort(namespace, name string, local, remote int) error

CheckForwardPodPort tries to forward the <remote> port of the pod with name <name> in namespace <namespace> to the <local> port. If <local> equals zero, a free port will be chosen randomly. It returns true if the port forward connection has been established successfully or false otherwise.

func (*Clientset) Client Uses

func (c *Clientset) Client() client.Client

Client returns the client of this Clientset.

func (*Clientset) ForwardPodPort Uses

func (c *Clientset) ForwardPodPort(namespace, name string, local, remote int) (chan struct{}, error)

ForwardPodPort tries to forward the <remote> port of the pod with name <name> in namespace <namespace> to the <local> port. If <local> equals zero, a free port will be chosen randomly. It returns the stop channel which must be closed when the port forward connection should be terminated.

func (*Clientset) GardenCore Uses

func (c *Clientset) GardenCore() gardencoreclientset.Interface

GardenCore will return the gardenCore attribute of the Client object.

func (*Clientset) Kubernetes Uses

func (c *Clientset) Kubernetes() kubernetes.Interface

Kubernetes will return the kubernetes attribute of the Client object.

func (*Clientset) RESTClient Uses

func (c *Clientset) RESTClient() rest.Interface

RESTClient will return the restClient attribute of the Client object.

func (*Clientset) RESTConfig Uses

func (c *Clientset) RESTConfig() *rest.Config

RESTConfig will return the config attribute of the Client object.

func (*Clientset) RESTMapper Uses

func (c *Clientset) RESTMapper() meta.RESTMapper

RESTMapper returns the restMapper of this Clientset.

func (*Clientset) Version Uses

func (c *Clientset) Version() string

Version returns the GitVersion of the Kubernetes client stored on the object.

type ConfigFunc Uses

type ConfigFunc func(config *config) error

ConfigFunc is a function that mutates a Config struct. It implements the functional options pattern. See https://github.com/tmrts/go-patterns/blob/master/idiom/functional-options.md.

func WithClientConnectionOptions Uses

func WithClientConnectionOptions(cfg baseconfig.ClientConnectionConfiguration) ConfigFunc

WithClientConnectionOptions returns a ConfigFunc that transfers settings from the passed ClientConnectionConfiguration. The kubeconfig location in ClientConnectionConfiguration is disregarded, though!

func WithClientOptions Uses

func WithClientOptions(opt client.Options) ConfigFunc

WithClientOptions returns a ConfigFunc that sets the passed Options on the config object.

func WithRESTConfig Uses

func WithRESTConfig(restConfig *rest.Config) ConfigFunc

WithRESTConfig returns a ConfigFunc that sets the passed rest.Config on the config object.

type Interface Uses

type Interface interface {
    RESTConfig() *rest.Config
    RESTMapper() meta.RESTMapper
    RESTClient() rest.Interface

    Client() client.Client
    Applier() ApplierInterface

    Kubernetes() kubernetesclientset.Interface
    GardenCore() gardencoreclientset.Interface
    APIExtension() apiextensionsclientset.Interface
    APIRegistration() apiregistrationclientset.Interface

    // Deprecated: Use `Client()` and utils instead.
    ForwardPodPort(string, string, int, int) (chan struct{}, error)
    CheckForwardPodPort(string, string, int, int) error

    Version() string
}

Interface is used to wrap the interactions with a Kubernetes cluster (which are performed with the help of kubernetes/client-go) in order to allow the implementation of several Kubernetes versions.

func NewClientFromBytes Uses

func NewClientFromBytes(kubeconfig []byte, fns ...ConfigFunc) (Interface, error)

NewClientFromBytes creates a new Client struct for a given kubeconfig byte slice.

func NewClientFromFile Uses

func NewClientFromFile(masterURL, kubeconfigPath string, fns ...ConfigFunc) (Interface, error)

NewClientFromFile creates a new Client struct for a given kubeconfig. The kubeconfig will be read from the filesystem at location <kubeconfigPath>. If given, <masterURL> overrides the master URL in the kubeconfig. If no filepath is given, the in-cluster configuration will be taken into account.

func NewClientFromSecret Uses

func NewClientFromSecret(k8sClient Interface, namespace, secretName string, fns ...ConfigFunc) (Interface, error)

NewClientFromSecret creates a new Client struct for a given kubeconfig stored as a Secret in an existing Kubernetes cluster. This cluster will be accessed by the <k8sClient>. It will read the Secret <secretName> in <namespace>. The Secret must contain a field "kubeconfig" which will be used.

func NewClientFromSecretObject Uses

func NewClientFromSecretObject(secret *corev1.Secret, fns ...ConfigFunc) (Interface, error)

NewClientFromSecretObject creates a new Client struct for a given Kubernetes Secret object. The Secret must contain a field "kubeconfig" which will be used.

func NewWithConfig Uses

func NewWithConfig(fns ...ConfigFunc) (Interface, error)

NewWithConfig returns a new Kubernetes base client.

type MergeFunc Uses

type MergeFunc func(newObj, oldObj *unstructured.Unstructured)

MergeFunc determines how oldOj is merged into new oldObj.

type PodExecutor Uses

type PodExecutor interface {
    Execute(ctx context.Context, namespace, name, containerName, command string) (io.Reader, error)
}

PodExecutor is the pod executor interface

func NewPodExecutor Uses

func NewPodExecutor(config *rest.Config) PodExecutor

NewPodExecutor returns a podExecutor

type UnstructuredReader Uses

type UnstructuredReader interface {
    Read() (*unstructured.Unstructured, error)
}

UnstructuredReader an interface that all manifest readers should implement

func NewManifestReader Uses

func NewManifestReader(manifest []byte) UnstructuredReader

NewManifestReader initializes a reader for yaml manifests

func NewNamespaceSettingReader Uses

func NewNamespaceSettingReader(mReader UnstructuredReader, namespace string) UnstructuredReader

NewNamespaceSettingReader initializes a reader for yaml manifests with support for setting the namespace

func NewObjectReferenceReader Uses

func NewObjectReferenceReader(objectReference *corev1.ObjectReference) UnstructuredReader

NewObjectReferenceReader initializes a reader from ObjectReference

Package kubernetes imports 51 packages (graph) and is imported by 56 packages. Updated 2020-02-20. Refresh now. Tools for package owners.