Package controllerruntime

import (
	ctrl "sigs.k8s.io/controller-runtime"
)

log := ctrl.Log.WithName("builder-examples")

manager, err := ctrl.NewManager(ctrl.GetConfigOrDie(), ctrl.Options{})
if err != nil {
    log.Error(err, "could not create manager")
    os.Exit(1)
}

err = ctrl.
    NewControllerManagedBy(manager). // Create the Controller
    For(&appsv1.ReplicaSet{}).       // ReplicaSet is the Application API
    Owns(&corev1.Pod{}).             // ReplicaSet owns Pods created by it
    Complete(&ReplicaSetReconciler{Client: manager.GetClient()})
if err != nil {
    log.Error(err, "could not create controller")
    os.Exit(1)
}

if err := manager.Start(ctrl.SetupSignalHandler()); err != nil {
    log.Error(err, "could not start manager")
    os.Exit(1)
}

log := ctrl.Log.WithName("builder-examples")

manager, err := ctrl.NewManager(ctrl.GetConfigOrDie(), ctrl.Options{})
if err != nil {
    log.Error(err, "could not create manager")
    os.Exit(1)
}

err = ctrl.
    NewControllerManagedBy(manager).
    For(&ExampleCRDWithConfigMapRef{}).
    Watches(&corev1.ConfigMap{}, handler.EnqueueRequestsFromMapFunc(func(ctx context.Context, cm client.Object) []ctrl.Request {
        // map a change from referenced configMap to ExampleCRDWithConfigMapRef, which causes its re-reconcile
        crList := &ExampleCRDWithConfigMapRefList{}
        if err := manager.GetClient().List(ctx, crList); err != nil {
            manager.GetLogger().Error(err, "while listing ExampleCRDWithConfigMapRefs")
            return nil
        }

        reqs := make([]ctrl.Request, 0, len(crList.Items))
        for _, item := range crList.Items {
            if item.ConfigMapRef.Name == cm.GetName() {
                reqs = append(reqs, ctrl.Request{
                    NamespacedName: types.NamespacedName{
                        Namespace: item.GetNamespace(),
                        Name:      item.GetName(),
                    },
                })
            }
        }

        return reqs
    })).
    Complete(reconcile.Func(func(ctx context.Context, r reconcile.Request) (reconcile.Result, error) {
        // Your business logic to implement the API by creating, updating, deleting objects goes here.
        return reconcile.Result{}, nil
    }))
if err != nil {
    log.Error(err, "could not create controller")
    os.Exit(1)
}

if err := manager.Start(ctrl.SetupSignalHandler()); err != nil {
    log.Error(err, "could not start manager")
    os.Exit(1)
}

log := ctrl.Log.WithName("builder-examples")
leaseDuration := 100 * time.Second
renewDeadline := 80 * time.Second
retryPeriod := 20 * time.Second
manager, err := ctrl.NewManager(
    ctrl.GetConfigOrDie(),
    ctrl.Options{
        LeaseDuration: &leaseDuration,
        RenewDeadline: &renewDeadline,
        RetryPeriod:   &retryPeriod,
    })
if err != nil {
    log.Error(err, "could not create manager")
    os.Exit(1)
}

err = ctrl.
    NewControllerManagedBy(manager). // Create the Controller
    For(&appsv1.ReplicaSet{}).       // ReplicaSet is the Application API
    Owns(&corev1.Pod{}).             // ReplicaSet owns Pods created by it
    Complete(&ReplicaSetReconciler{Client: manager.GetClient()})
if err != nil {
    log.Error(err, "could not create controller")
    os.Exit(1)
}

if err := manager.Start(ctrl.SetupSignalHandler()); err != nil {
    log.Error(err, "could not start manager")
    os.Exit(1)
}

Variables

var (
    // RegisterFlags registers flag variables to the given FlagSet if not already registered.
    // It uses the default command line FlagSet, if none is provided. Currently, it only registers the kubeconfig flag.
    RegisterFlags = config.RegisterFlags

    // GetConfigOrDie creates a *rest.Config for talking to a Kubernetes apiserver.
    // If --kubeconfig is set, will use the kubeconfig file at that location.  Otherwise will assume running
    // in cluster and use the cluster provided kubeconfig.
    //
    // Will log an error and exit if there is an error creating the rest.Config.
    GetConfigOrDie = config.GetConfigOrDie

    // GetConfig creates a *rest.Config for talking to a Kubernetes apiserver.
    // If --kubeconfig is set, will use the kubeconfig file at that location.  Otherwise will assume running
    // in cluster and use the cluster provided kubeconfig.
    //
    // Config precedence
    //
    // * --kubeconfig flag pointing at a file
    //
    // * KUBECONFIG environment variable pointing at a file
    //
    // * In-cluster config if running in cluster
    //
    // * $HOME/.kube/config if exists.
    GetConfig = config.GetConfig

    // NewControllerManagedBy returns a new controller builder that will be started by the provided Manager.
    NewControllerManagedBy = builder.ControllerManagedBy

    // NewWebhookManagedBy returns a new webhook builder that will be started by the provided Manager.
    NewWebhookManagedBy = builder.WebhookManagedBy

    // NewManager returns a new Manager for creating Controllers.
    // Note that if ContentType in the given config is not set, "application/vnd.kubernetes.protobuf"
    // will be used for all built-in resources of Kubernetes, and "application/json" is for other types
    // including all CRD resources.
    NewManager = manager.New

    // CreateOrUpdate creates or updates the given object obj in the Kubernetes
    // cluster. The object's desired state should be reconciled with the existing
    // state using the passed in ReconcileFn. obj must be a struct pointer so that
    // obj can be updated with the content returned by the Server.
    //
    // It returns the executed operation and an error.
    CreateOrUpdate = controllerutil.CreateOrUpdate

    // SetControllerReference sets owner as a Controller OwnerReference on owned.
    // This is used for garbage collection of the owned object and for
    // reconciling the owner object on changes to owned (with a Watch + EnqueueRequestForOwner).
    // Since only one OwnerReference can be a controller, it returns an error if
    // there is another OwnerReference with Controller flag set.
    SetControllerReference = controllerutil.SetControllerReference

    // SetupSignalHandler registered for SIGTERM and SIGINT. A stop channel is returned
    // which is closed on one of these signals. If a second signal is caught, the program
    // is terminated with exit code 1.
    SetupSignalHandler = signals.SetupSignalHandler

    // Log is the base logger used by controller-runtime.  It delegates
    // to another logr.Logger.  You *must* call SetLogger to
    // get any actual logging.
    Log = log.Log

    // LoggerFrom returns a logger with predefined values from a context.Context.
    // The logger, when used with controllers, can be expected to contain basic information about the object
    // that's being reconciled like:
    // - `reconciler group` and `reconciler kind` coming from the For(...) object passed in when building a controller.
    // - `name` and `namespace` from the reconciliation request.
    //
    // This is meant to be used with the context supplied in a struct that satisfies the Reconciler interface.
    LoggerFrom = log.FromContext

    // LoggerInto takes a context and sets the logger as one of its keys.
    //
    // This is meant to be used in reconcilers to enrich the logger within a context with additional values.
    LoggerInto = log.IntoContext

    // SetLogger sets a concrete logging implementation for all deferred Loggers.
    SetLogger = log.SetLogger
)

type Builder ¶

Builder builds an Application ControllerManagedBy (e.g. Operator) and returns a manager.Manager to start it.

type Builder = builder.Builder

type GroupResource ¶

GroupResource specifies a Group and a Resource, but does not force a version. This is useful for identifying concepts during lookup stages without having partially valid types.

type GroupResource = schema.GroupResource

type GroupVersion ¶

GroupVersion contains the "group" and the "version", which uniquely identifies the API.

type GroupVersion = schema.GroupVersion

type Manager ¶

Manager initializes shared dependencies such as Caches and Clients, and provides them to Runnables. A Manager is required to create Controllers.

type Manager = manager.Manager

type ObjectMeta ¶

ObjectMeta is metadata that all persisted resources must have, which includes all objects users must create.

type ObjectMeta = metav1.ObjectMeta

type Options ¶

Options are the arguments for creating a new Manager.

type Options = manager.Options

type Request ¶

Request contains the information necessary to reconcile a Kubernetes object. This includes the information to uniquely identify the object - its Name and Namespace. It does NOT contain information about any specific Event or the object contents itself.

type Request = reconcile.Request

type Result ¶

Result contains the result of a Reconciler invocation.

type Result = reconcile.Result

type SchemeBuilder ¶

SchemeBuilder builds a new Scheme for mapping go types to Kubernetes GroupVersionKinds.

type SchemeBuilder = scheme.Builder

type TypeMeta ¶

TypeMeta describes an individual object in an API response or request with strings representing the type of the object and its API schema version. Structures that are versioned or persisted should inline TypeMeta.

+k8s:deepcopy-gen=false

type TypeMeta = metav1.TypeMeta

Subdirectories