Webhook Mode

A WebHook is an HTTP callback: an HTTP POST that occurs when something happens; a simple event-notification via HTTP POST. A web application implementing WebHooks will POST a message to a URL when certain things happen.

When specified, mode Webhook causes Kubernetes to query an outside REST service when determining user privileges.

Configuration File Format

Mode Webhook requires a file for HTTP configuration, specify by the --authorization-webhook-config-file=SOME_FILENAME flag.

The configuration file uses the kubeconfig file format. Within the file “users” refers to the API Server webhook and “clusters” refers to the remote service.

A configuration example which uses HTTPS client auth:

  1. # Kubernetes API version
  2. apiVersion: v1
  3. # kind of the API object
  4. kind: Config
  5. # clusters refers to the remote service.
  6. clusters:
  7.   - name: name-of-remote-authz-service
  8.     cluster:
  9.       # CA for verifying the remote service.
  10.       certificate-authority: /path/to/ca.pem
  11.       # URL of remote service to query. Must use 'https'. May not include parameters.
  12.       server: https://authz.example.com/authorize
  14. # users refers to the API Server's webhook configuration.
  15. users:
  16.   - name: name-of-api-server
  17.     user:
  18.       client-certificate: /path/to/cert.pem # cert for the webhook plugin to use
  19.       client-key: /path/to/key.pem          # key matching the cert
  21. # kubeconfig files require a context. Provide one for the API Server.
  22. current-context: webhook
  23. contexts:
  24. - context:
  25.     cluster: name-of-remote-authz-service
  26.     user: name-of-api-server
  27.   name: webhook

Request Payloads

When faced with an authorization decision, the API Server POSTs a JSON- serialized authorization.k8s.io/v1beta1 SubjectAccessReview object describing the action. This object contains fields describing the user attempting to make the request, and either details about the resource being accessed or requests attributes.

Note that webhook API objects are subject to the same versioning compatibility rules as other Kubernetes API objects. Implementers should be aware of looser compatibility promises for beta objects and check the “apiVersion” field of the request to ensure correct deserialization. Additionally, the API Server must enable the authorization.k8s.io/v1beta1 API extensions group (--runtime-config=authorization.k8s.io/v1beta1=true).

An example request body:

  1. {
  2.   "apiVersion": "authorization.k8s.io/v1beta1",
  3.   "kind": "SubjectAccessReview",
  4.   "spec": {
  5.     "resourceAttributes": {
  6.       "namespace": "kittensandponies",
  7.       "verb": "get",
  8.       "group": "unicorn.example.org",
  9.       "resource": "pods"
  10.     },
  11.     "user": "jane",
  12.     "group": [
  13.       "group1",
  14.       "group2"
  15.     ]
  16.   }
  17. }

The remote service is expected to fill the status field of the request and respond to either allow or disallow access. The response body’s spec field is ignored and may be omitted. A permissive response would return:

  1. {
  2.   "apiVersion": "authorization.k8s.io/v1beta1",
  3.   "kind": "SubjectAccessReview",
  4.   "status": {
  5.     "allowed": true
  6.   }
  7. }

For disallowing access there are two methods.

The first method is preferred in most cases, and indicates the authorization webhook does not allow, or has “no opinion” about the request, but if other authorizers are configured, they are given a chance to allow the request. If there are no other authorizers, or none of them allow the request, the request is forbidden. The webhook would return:

  1. {
  2.   "apiVersion": "authorization.k8s.io/v1beta1",
  3.   "kind": "SubjectAccessReview",
  4.   "status": {
  5.     "allowed": false,
  6.     "reason": "user does not have read access to the namespace"
  7.   }
  8. }

The second method denies immediately, short-circuiting evaluation by other configured authorizers. This should only be used by webhooks that have detailed knowledge of the full authorizer configuration of the cluster. The webhook would return:

  1. {
  2.   "apiVersion": "authorization.k8s.io/v1beta1",
  3.   "kind": "SubjectAccessReview",
  4.   "status": {
  5.     "allowed": false,
  6.     "denied": true,
  7.     "reason": "user does not have read access to the namespace"
  8.   }
  9. }

Access to non-resource paths are sent as:

  1. {
  2.   "apiVersion": "authorization.k8s.io/v1beta1",
  3.   "kind": "SubjectAccessReview",
  4.   "spec": {
  5.     "nonResourceAttributes": {
  6.       "path": "/debug",
  7.       "verb": "get"
  8.     },
  9.     "user": "jane",
  10.     "group": [
  11.       "group1",
  12.       "group2"
  13.     ]
  14.   }
  15. }

Non-resource paths include: /api, /apis, /metrics, /logs, /debug, /healthz, /livez, /openapi/v2, /readyz, and /version. Clients require access to /api, /api/*, /apis, /apis/*, and /version to discover what resources and versions are present on the server. Access to other non-resource paths can be disallowed without restricting access to the REST api.

For further documentation refer to the authorization.v1beta1 API objects and webhook.go.