Mastering Knative Serving SDK: Build Serverless Apps with Go Context

Golang Context Overview

Go introduced the Context type in version 1.7 to simplify propagation of cancellation signals, deadlines, and request‑scoped values across goroutine boundaries. The interface provides four methods:

type Context interface {
    Deadline() (deadline time.Time, ok bool) // returns the deadline, if set
    Done() <-chan struct{}                // closed when the context is cancelled
    Err() error                           // reason for cancellation
    Value(key interface{}) interface{}    // retrieves a value stored with a key
}

Typical usage includes creating a cancellable context with context.WithCancel or context.WithTimeout, passing it through function calls, and checking ctx.Done() to stop work early.

Knative Serving SDK Initialization

Knative Serving relies on the injection framework to wire core objects (informers, client, logger) into a Context. Each informer’s constructor registers a factory function in injection.Default during its init(). When SetupInformers is invoked, the factories create a SharedInformerFactory and a Kubernetes client, then store them in the context via context.WithValue:

ctx = context.WithValue(ctx, Key{}, inf)
inf.Informer()

The same pattern is used for the logger, which is later retrieved with logging.FromContext(ctx). This design makes the SDK “context‑centric”: any component can obtain required dependencies by extracting them from the passed Context.

Logging from Context

logger := logging.FromContext(ctx)

The logger is pre‑configured for trace‑aware output. Example JSON log entry (truncated):

{"level":"info","ts":"2019-08-28T20:24:39.871+0800","caller":"controller/service.go:67","msg":"Reconcile: default/helloworld-go","knative.dev/traceid":"be5ec711-6ca3-493c-80ed-dddfa21fd576","knative.dev/key":"default/helloworld-go"}

Typical Controller Workflow with the Knative Serving SDK

Load configuration and create a logger. A *zap.SugaredLogger is usually built from the Knative config.

Create a root context that handles OS signals. Use ctx := signals.NewContext() – this context’s Done() channel is closed on SIGINT (Ctrl+C).

Set up informers and inject them into the context.

ctx, informers = injection.Default.SetupInformers(ctx, cfg)

The call returns a new context containing the shared informer factory, client, and logger.

Start all informers and wait for synchronization.

// Start all informers and wait for them to sync.
logger.Info("Starting informers.")
if err := controller.StartInformers(ctx.Done(), informers...); err != nil {
    logger.Fatalw("Failed to start informers", err)
}

Retrieve specific informers from the context when needed. Example (pseudo‑code):

serviceInformer := injection.GetInformer(ctx, &servingv1.Service{})
serviceLister := serviceInformer.Lister()

Implement the Reconciler interface.

type Reconciler interface {
    Reconcile(ctx context.Context, key string) error
}

The shared controller will invoke Reconcile for each queued key.

Operate on Knative resources inside Reconcile . Use listers obtained from informers, e.g.:

svc, err := c.serviceLister.Services(namespace).Get(name)
if err != nil {
    return err
}
// manipulate svc as needed

Reference Implementation

A complete, runnable example of a Knative Serving controller is available at:

https://github.com/knative-sample/serving-controller

Key source files: cmd/app/app.go – entry point that builds the config, logger, and root context. pkg/controller/controller.go – calls SetupInformers, starts them, and registers the reconciler. pkg/controller/service.go – implements Reconcile and demonstrates resource CRUD via listers.

Important Source Links

Service informer constructor (v0.8.0): https://github.com/knative/serving/blob/v0.8.0/pkg/client/injection/informers/serving/v1alpha1/service/service.go#L31

Factory that creates the shared informer factory: https://github.com/knative/serving/blob/v0.8.0/pkg/client/injection/informers/serving/factory/servingfactory.go#L31

Summary

The Knative Serving SDK adopts a context‑driven programming model: core objects such as informers, the Kubernetes client, and a logger are injected into a Context during initialization and later extracted where needed. By following the workflow above—creating a signal‑aware root context, setting up informers, starting them, and implementing a Reconciler —developers can build serverless controllers that interact with Knative resources in a clean, testable manner.