webhook

Documentation

Overview

Package webhook provides methods to build and bootstrap a webhook server.

Currently, it only supports admission webhooks. It will support CRD conversion webhooks in the near future.

Example

This example registers a webhooks to a webhook server that gets ran by a controller manager.

// Create a manager
// Note: GetConfigOrDie will os.Exit(1) w/o any message if no kube-config can be found
mgr, err := ctrl.NewManager(ctrl.GetConfigOrDie(), ctrl.Options{})
if err != nil {
	panic(err)
}

// Create a webhook server.
hookServer := &Server{
	Port: 8443,
}
if err := mgr.Add(hookServer); err != nil {
	panic(err)
}

// Register the webhooks in the server.
hookServer.Register("/mutating", mutatingHook)
hookServer.Register("/validating", validatingHook)

// Start the server by starting a previously-set-up manager
err = mgr.Start(ctrl.SetupSignalHandler())
if err != nil {
	// handle error
	panic(err)
}

Index

• Variables
• type Admission
• type AdmissionDecoder
• type AdmissionHandler
• type AdmissionRequest
• type AdmissionResponse
• type Defaulter
• type JSONPatchOp
• type Server
  • func (s *Server) InjectFunc(f inject.Func) error
  • func (*Server) NeedLeaderElection() bool
  • func (s *Server) Register(path string, hook http.Handler)
  • func (s *Server) Start(ctx context.Context) error
  • func (s *Server) StartStandalone(ctx context.Context, scheme *runtime.Scheme) error
• type Validator

Examples

• Package
• Server.StartStandalone

Variables

var (
	// Allowed indicates that the admission request should be allowed for the given reason.
	Allowed = admission.Allowed

	// Denied indicates that the admission request should be denied for the given reason.
	Denied = admission.Denied

	// Patched indicates that the admission request should be allowed for the given reason,
	// and that the contained object should be mutated using the given patches.
	Patched = admission.Patched

	// Errored indicates that an error occurred in the admission request.
	Errored = admission.Errored
)

var DefaultPort = 9443

DefaultPort is the default port that the webhook server serves.

Types

type Admission

type Admission = admission.Webhook

Admission is webhook suitable for registration with the server an admission webhook that validates API operations and potentially mutates their contents.

type AdmissionDecoder

type AdmissionDecoder = admission.Decoder

AdmissionDecoder knows how to decode objects from admission requests.

type AdmissionHandler

type AdmissionHandler = admission.Handler

AdmissionHandler knows how to process admission requests, validating them, and potentially mutating the objects they contain.

type AdmissionRequest

type AdmissionRequest = admission.Request

AdmissionRequest defines the input for an admission handler. It contains information to identify the object in question (group, version, kind, resource, subresource, name, namespace), as well as the operation in question (e.g. Get, Create, etc), and the object itself.

type AdmissionResponse

type AdmissionResponse = admission.Response

AdmissionResponse is the output of an admission handler. It contains a response indicating if a given operation is allowed, as well as a set of patches to mutate the object in the case of a mutating admission handler.

type Defaulter

type Defaulter = admission.Defaulter

Defaulter defines functions for setting defaults on resources

type JSONPatchOp

type JSONPatchOp = jsonpatch.Operation

JSONPatchOp represents a single JSONPatch patch operation.

type Server

type Server struct {
	// Host is the address that the server will listen on.
	// Defaults to "" - all addresses.
	Host string

	// Port is the port number that the server will serve.
	// It will be defaulted to 9443 if unspecified.
	Port int

	// CertDir is the directory that contains the server key and certificate. The
	// server key and certificate.
	CertDir string

	// CertName is the server certificate name. Defaults to tls.crt.
	CertName string

	// KeyName is the server key name. Defaults to tls.key.
	KeyName string

	// ClientCAName is the CA certificate name which server used to verify remote(client)'s certificate.
	// Defaults to "", which means server does not verify client's certificate.
	ClientCAName string

	// WebhookMux is the multiplexer that handles different webhooks.
	WebhookMux *http.ServeMux
	// contains filtered or unexported fields
}

Server is an admission webhook server that can serve traffic and generates related k8s resources for deploying.

TLS is required for a webhook to be accessed by kubernetes, so you must provide a CertName and KeyName or have valid cert/key at the default locations (tls.crt and tls.key). If you do not want to configure TLS (i.e for testing purposes) run an admission.StandaloneWebhook in your own server.

func (*Server) InjectFunc

func (s *Server) InjectFunc(f inject.Func) error

InjectFunc injects the field setter into the server.

func (*Server) NeedLeaderElection

func (*Server) NeedLeaderElection() bool

NeedLeaderElection implements the LeaderElectionRunnable interface, which indicates the webhook server doesn't need leader election.

func (*Server) Register

func (s *Server) Register(path string, hook http.Handler)

Register marks the given webhook as being served at the given path. It panics if two hooks are registered on the same path.

func (*Server) Start

func (s *Server) Start(ctx context.Context) error

Start runs the server. It will install the webhook related resources depend on the server configuration.

func (*Server) StartStandalone

func (s *Server) StartStandalone(ctx context.Context, scheme *runtime.Scheme) error

StartStandalone runs a webhook server without a controller manager.

Example

This example creates a webhook server that can be ran without a controller manager.

Note that this assumes and requires a valid TLS cert and key at the default locations tls.crt and tls.key

// Create a webhook server
hookServer := &Server{
	Port: 8443,
}

// Register the webhooks in the server.
hookServer.Register("/mutating", mutatingHook)
hookServer.Register("/validating", validatingHook)

// Start the server without a manger
err := hookServer.StartStandalone(signals.SetupSignalHandler(), scheme.Scheme)
if err != nil {
	// handle error
	panic(err)
}

type Validator

type Validator = admission.Validator

Validator defines functions for validating an operation