diff --git a/README.md b/README.md index d64ebe5..0ca1bdf 100644 --- a/README.md +++ b/README.md @@ -180,8 +180,8 @@ Resource filters select which API types to watch. The controller reads, deletes, ### RBAC -By default, the Helm chart grants `get`, `list`, `watch`, `patch`, `update`, and `delete` on all resources and API groups through a `ClusterRole`. The chart also grants Event writes and namespaced leader-election permissions. +By default, the Helm chart watches standard workloads, ConfigMaps, Services, Ingresses, NetworkPolicies, PersistentVolumeClaims, HorizontalPodAutoscalers, PodDisruptionBudgets, Namespaces, and PersistentVolumes. It grants `get`, `list`, `watch`, `patch`, `update`, and `delete` for those resources, plus `Event` permissions and permissions for enabled leader-election and secure-metrics features. -Set `controllerManager.scope.watchResources` to exact resource names to narrow the generated resource grants. These grants still apply across all namespaces. The `watchNamespaces`, `ignoreNamespaces`, and `ignoreResources` scope values do not reduce the generated RBAC permissions. +A list of filtered namespaces creates a `Role` and `RoleBinding` in each watched namespace. Namespace patterns or leaving the list unset results in a `ClusterRole`. Namespace objects still require cluster permissions. -The chart supports exact resource and group names or Kubernetes `*` wildcards in RBAC rules. It does not expand arbitrary globs. For example, `deployment?.apps` can match a resource in the controller but does not authorize access to `deployments.apps`. Use exact names for chart-generated RBAC, or supply RBAC yourself. +For resource patterns such as `deploy*.apps`, set `rbac.create: false` and supply your own RBAC with explicit resource names. diff --git a/charts/lifecycle-controller/Chart.yaml b/charts/lifecycle-controller/Chart.yaml index 0016ae9..ad23a0f 100644 --- a/charts/lifecycle-controller/Chart.yaml +++ b/charts/lifecycle-controller/Chart.yaml @@ -2,8 +2,8 @@ apiVersion: v2 name: lifecycle-controller description: A Kubernetes controller to manage the lifecycle of standard resources through time-based annotations. type: application -version: 0.6.3 -appVersion: "v0.6.3" +version: 0.7.0 +appVersion: "v0.7.0" keywords: - kubernetes - controller diff --git a/charts/lifecycle-controller/templates/_rbac.tpl b/charts/lifecycle-controller/templates/_rbac.tpl new file mode 100644 index 0000000..beae95d --- /dev/null +++ b/charts/lifecycle-controller/templates/_rbac.tpl @@ -0,0 +1,106 @@ +{{/* Use the same resource list for watch flags and permissions. */}} +{{- define "lifecycle-controller.watchResources" -}} +{{- $scope := .Values.controllerManager.scope -}} +{{- if not (kindIs "slice" $scope.watchResources) -}} + {{- fail "controllerManager.scope.watchResources must be a list" -}} +{{- end -}} +{{- $resources := $scope.watchResources -}} +{{- if not (empty $scope.watchNamespaces) -}} + {{- $resources = without $resources "persistentvolumes" -}} + {{- if and (not (empty $scope.watchResources)) (empty $resources) -}} + {{- fail "namespace filters exclude PersistentVolumes, leaving no resources to watch" -}} + {{- end -}} +{{- end -}} +{{- toJson $resources -}} +{{- end -}} + +{{/* Derive permission scope from namespace filters. */}} +{{- define "lifecycle-controller.rbacScope" -}} +{{- $scope := .Values.controllerManager.scope -}} +{{- $exact := not (empty $scope.watchNamespaces) -}} +{{- range $scope.watchNamespaces -}} + {{- if regexMatch "[*?\\[\\]\\\\]" . -}} + {{- $exact = false -}} + {{- end -}} +{{- end -}} +{{- if $exact -}} + {{- $namespaces := include "lifecycle-controller.rbacNamespaces" . -}} +{{- end -}} +{{- ternary "namespaced" "cluster" $exact -}} +{{- end -}} + +{{/* Do not silently broaden grants when an ignore pattern cannot be represented. */}} +{{- define "lifecycle-controller.rbacNamespaces" -}} +{{- $scope := .Values.controllerManager.scope -}} +{{- range concat $scope.watchNamespaces $scope.ignoreNamespaces -}} + {{- if or (gt (len .) 63) (not (regexMatch "^[a-z0-9]([-a-z0-9]*[a-z0-9])?$" .)) -}} + {{- fail (printf "generated namespaced RBAC requires exact namespace names, got %q; use rbac.create: false for supplied RBAC" .) -}} + {{- end -}} +{{- end -}} +{{- $allowed := list -}} +{{- range uniq $scope.watchNamespaces -}} + {{- if not (has . $scope.ignoreNamespaces) -}} + {{- $allowed = append $allowed . -}} + {{- end -}} +{{- end -}} +{{- if empty $allowed -}} + {{- fail "namespaced RBAC requires at least one namespace after ignore rules" -}} +{{- end -}} +{{- toJson $allowed -}} +{{- end -}} + +{{/* Generate resource rules from exact names or a lone wildcard. */}} +{{- define "lifecycle-controller.resourceRules" -}} +{{- $scope := .Values.controllerManager.scope -}} +{{- $resources := include "lifecycle-controller.watchResources" . | fromJsonArray -}} +{{- $namespaced := eq (include "lifecycle-controller.rbacScope" .) "namespaced" -}} +{{- range $scope.ignoreResources -}} + {{- if regexMatch "[?\\[\\]\\\\]" . -}} + {{- fail "chart-generated RBAC requires exact ignoreResources entries or *; use rbac.create: false for supplied RBAC" -}} + {{- end -}} + {{- if and (contains "*" .) (ne . "*") -}} + {{- fail "chart-generated RBAC requires exact ignoreResources entries or *; use rbac.create: false for supplied RBAC" -}} + {{- end -}} +{{- end -}} +{{- if $resources -}} + {{- range uniq $resources -}} + {{- $entry := . -}} + {{- $parts := splitList "." . -}} + {{- $res := index $parts 0 -}} + {{- if eq $res "" -}} + {{- fail (printf "invalid controllerManager.scope.watchResources entry %q: resource segment cannot be empty" .) -}} + {{- end -}} + {{- $grp := "" -}} + {{- if gt (len $parts) 1 -}} + {{- $rest := rest $parts -}} + {{- if has "" $rest -}} + {{- fail (printf "invalid controllerManager.scope.watchResources entry %q: apiGroup segments cannot be empty" .) -}} + {{- end -}} + {{- $grp = join "." $rest -}} + {{- end -}} + {{- if or (and (ne $entry "*") (contains "*" $entry)) (not (regexMatch "^([a-z0-9-]+|\\*)$" $res)) (and (ne $grp "") (not (regexMatch "^[a-z0-9.-]+$" $grp))) -}} + {{- fail (printf "invalid controllerManager.scope.watchResources entry %q: chart-generated RBAC requires exact names or a lone *" .) -}} + {{- end -}} + {{- if eq $entry "*" -}}{{- $grp = "*" -}}{{- end -}} + {{- if and (not (has $entry $scope.ignoreResources)) (not (has "*" $scope.ignoreResources)) (not (and $namespaced (eq $entry "namespaces"))) }} +- apiGroups: [{{ $grp | quote }}] + resources: [{{ $res | quote }}] + verbs: ["delete", "get", "list", "patch", "update", "watch"] + {{- end -}} + {{- end -}} +{{- else if not (has "*" $scope.ignoreResources) }} +- apiGroups: ["*"] + resources: ["*"] + verbs: ["delete", "get", "list", "patch", "update", "watch"] +{{- end }} +{{- include "lifecycle-controller.eventRules" . | nindent 0 }} +{{- end -}} + +{{- define "lifecycle-controller.eventRules" -}} +- apiGroups: [""] + resources: ["events"] + verbs: ["create", "patch"] +- apiGroups: ["events.k8s.io"] + resources: ["events"] + verbs: ["create", "patch"] +{{- end -}} diff --git a/charts/lifecycle-controller/templates/deployment.yaml b/charts/lifecycle-controller/templates/deployment.yaml index 1da52e4..381ec29 100644 --- a/charts/lifecycle-controller/templates/deployment.yaml +++ b/charts/lifecycle-controller/templates/deployment.yaml @@ -54,7 +54,7 @@ spec: {{- end }} - --dry-run={{ .Values.controllerManager.dryRun }} - --zap-log-level={{ .Values.controllerManager.logLevel }} - {{- range .Values.controllerManager.scope.watchResources }} + {{- range (include "lifecycle-controller.watchResources" . | fromJsonArray) }} - --watch-resource={{ . }} {{- end }} {{- range .Values.controllerManager.scope.ignoreResources }} diff --git a/charts/lifecycle-controller/templates/leader-election-rbac.yaml b/charts/lifecycle-controller/templates/leader-election-rbac.yaml new file mode 100644 index 0000000..39b2d62 --- /dev/null +++ b/charts/lifecycle-controller/templates/leader-election-rbac.yaml @@ -0,0 +1,35 @@ +{{- if and .Values.rbac.create .Values.controllerManager.leaderElection.enabled }} +apiVersion: rbac.authorization.k8s.io/v1 +kind: Role +metadata: + name: {{ include "lifecycle-controller.fullname" . }}-leader-election-role + namespace: {{ .Release.Namespace }} + labels: + {{- include "lifecycle-controller.labels" . | nindent 4 }} +rules: +- apiGroups: ["coordination.k8s.io"] + resources: ["leases"] + verbs: ["get", "create", "update"] +- apiGroups: [""] + resources: ["events"] + verbs: ["create", "patch"] +- apiGroups: ["events.k8s.io"] + resources: ["events"] + verbs: ["create", "patch"] +--- +apiVersion: rbac.authorization.k8s.io/v1 +kind: RoleBinding +metadata: + name: {{ include "lifecycle-controller.fullname" . }}-leader-election-rolebinding + namespace: {{ .Release.Namespace }} + labels: + {{- include "lifecycle-controller.labels" . | nindent 4 }} +roleRef: + apiGroup: rbac.authorization.k8s.io + kind: Role + name: {{ include "lifecycle-controller.fullname" . }}-leader-election-role +subjects: +- kind: ServiceAccount + name: {{ include "lifecycle-controller.serviceAccountName" . }} + namespace: {{ .Release.Namespace }} +{{- end }} diff --git a/charts/lifecycle-controller/templates/metrics-rbac.yaml b/charts/lifecycle-controller/templates/metrics-rbac.yaml new file mode 100644 index 0000000..a09a7ea --- /dev/null +++ b/charts/lifecycle-controller/templates/metrics-rbac.yaml @@ -0,0 +1,30 @@ +{{- if and .Values.rbac.create .Values.metrics.enabled .Values.metrics.secure }} +apiVersion: rbac.authorization.k8s.io/v1 +kind: ClusterRole +metadata: + name: {{ include "lifecycle-controller.fullname" . }}-metrics-auth-role + labels: + {{- include "lifecycle-controller.labels" . | nindent 4 }} +rules: +- apiGroups: ["authentication.k8s.io"] + resources: ["tokenreviews"] + verbs: ["create"] +- apiGroups: ["authorization.k8s.io"] + resources: ["subjectaccessreviews"] + verbs: ["create"] +--- +apiVersion: rbac.authorization.k8s.io/v1 +kind: ClusterRoleBinding +metadata: + name: {{ include "lifecycle-controller.fullname" . }}-metrics-auth-rolebinding + labels: + {{- include "lifecycle-controller.labels" . | nindent 4 }} +roleRef: + apiGroup: rbac.authorization.k8s.io + kind: ClusterRole + name: {{ include "lifecycle-controller.fullname" . }}-metrics-auth-role +subjects: +- kind: ServiceAccount + name: {{ include "lifecycle-controller.serviceAccountName" . }} + namespace: {{ .Release.Namespace }} +{{- end }} diff --git a/charts/lifecycle-controller/templates/namespace-rbac.yaml b/charts/lifecycle-controller/templates/namespace-rbac.yaml new file mode 100644 index 0000000..f60ca3f --- /dev/null +++ b/charts/lifecycle-controller/templates/namespace-rbac.yaml @@ -0,0 +1,62 @@ +{{- if .Values.rbac.create -}} +{{- $scope := .Values.controllerManager.scope -}} +{{- $resources := include "lifecycle-controller.watchResources" . | fromJsonArray -}} +{{- if and (eq (include "lifecycle-controller.rbacScope" .) "namespaced") (has "namespaces" $resources) (not (has "namespaces" $scope.ignoreResources)) (not (has "*" $scope.ignoreResources)) }} +apiVersion: rbac.authorization.k8s.io/v1 +kind: ClusterRole +metadata: + name: {{ include "lifecycle-controller.fullname" . }}-namespace-role + labels: + {{- include "lifecycle-controller.labels" . | nindent 4 }} +rules: +- apiGroups: [""] + resources: ["namespaces"] + verbs: ["get", "list", "watch"] +- apiGroups: [""] + resources: ["namespaces"] + resourceNames: {{ include "lifecycle-controller.rbacNamespaces" . }} + verbs: ["delete", "patch", "update"] +--- +apiVersion: rbac.authorization.k8s.io/v1 +kind: ClusterRoleBinding +metadata: + name: {{ include "lifecycle-controller.fullname" . }}-namespace-rolebinding + labels: + {{- include "lifecycle-controller.labels" . | nindent 4 }} +roleRef: + apiGroup: rbac.authorization.k8s.io + kind: ClusterRole + name: {{ include "lifecycle-controller.fullname" . }}-namespace-role +subjects: +- kind: ServiceAccount + name: {{ include "lifecycle-controller.serviceAccountName" . }} + namespace: {{ .Release.Namespace }} +{{/* Kubernetes records Events for cluster objects in default. */}} +--- +apiVersion: rbac.authorization.k8s.io/v1 +kind: Role +metadata: + name: {{ include "lifecycle-controller.fullname" . }}-namespace-events-role + namespace: default + labels: + {{- include "lifecycle-controller.labels" . | nindent 4 }} +rules: + {{- include "lifecycle-controller.eventRules" . | nindent 0 }} +--- +apiVersion: rbac.authorization.k8s.io/v1 +kind: RoleBinding +metadata: + name: {{ include "lifecycle-controller.fullname" . }}-namespace-events-rolebinding + namespace: default + labels: + {{- include "lifecycle-controller.labels" . | nindent 4 }} +roleRef: + apiGroup: rbac.authorization.k8s.io + kind: Role + name: {{ include "lifecycle-controller.fullname" . }}-namespace-events-role +subjects: +- kind: ServiceAccount + name: {{ include "lifecycle-controller.serviceAccountName" . }} + namespace: {{ .Release.Namespace }} +{{- end -}} +{{- end -}} diff --git a/charts/lifecycle-controller/templates/rbac.yaml b/charts/lifecycle-controller/templates/rbac.yaml index 8c61a3d..bcd4933 100644 --- a/charts/lifecycle-controller/templates/rbac.yaml +++ b/charts/lifecycle-controller/templates/rbac.yaml @@ -1,93 +1,40 @@ {{- if .Values.rbac.create -}} +{{- $root := . -}} +{{- $namespaced := eq (include "lifecycle-controller.rbacScope" .) "namespaced" -}} +{{- $namespaces := list "" -}} +{{- if $namespaced -}} + {{- $namespaces = include "lifecycle-controller.rbacNamespaces" . | fromJsonArray -}} +{{- end -}} +{{- range $namespaces }} --- apiVersion: rbac.authorization.k8s.io/v1 -kind: ClusterRole +kind: {{ ternary "Role" "ClusterRole" $namespaced }} metadata: - name: {{ include "lifecycle-controller.fullname" . }}-manager-role - labels: - {{- include "lifecycle-controller.labels" . | nindent 4 }} -rules: -{{- if .Values.controllerManager.scope.watchResources }} - {{- range .Values.controllerManager.scope.watchResources }} - {{- $parts := splitList "." . }} - {{- $res := index $parts 0 }} - {{- if eq $res "" }} - {{- fail (printf "invalid controllerManager.scope.watchResources entry %q: resource segment cannot be empty" .) }} - {{- end }} - {{- $grp := "" }} - {{- if gt (len $parts) 1 }} - {{- $rest := rest $parts }} - {{- if has "" $rest }} - {{- fail (printf "invalid controllerManager.scope.watchResources entry %q: apiGroup segments cannot be empty" .) }} - {{- end }} - {{- $grp = join "." $rest }} - {{- end }} -- apiGroups: ["{{ $grp }}"] - resources: ["{{ $res }}"] - verbs: ["delete", "get", "list", "patch", "update", "watch"] + name: {{ include "lifecycle-controller.fullname" $root }}-manager-role + {{- if $namespaced }} + namespace: {{ . | quote }} {{- end }} -{{- else }} -- apiGroups: ["*"] - resources: ["*"] - verbs: ["delete", "get", "list", "patch", "update", "watch"] -{{- end }} -- apiGroups: [""] - resources: ["events"] - verbs: ["create", "patch"] -- apiGroups: ["events.k8s.io"] - resources: ["events"] - verbs: ["create", "patch"] ---- -apiVersion: rbac.authorization.k8s.io/v1 -kind: ClusterRoleBinding -metadata: - name: {{ include "lifecycle-controller.fullname" . }}-manager-rolebinding labels: - {{- include "lifecycle-controller.labels" . | nindent 4 }} -roleRef: - apiGroup: rbac.authorization.k8s.io - kind: ClusterRole - name: {{ include "lifecycle-controller.fullname" . }}-manager-role -subjects: -- kind: ServiceAccount - name: {{ include "lifecycle-controller.serviceAccountName" . }} - namespace: {{ .Release.Namespace }} ---- -# Permissions for leader election -apiVersion: rbac.authorization.k8s.io/v1 -kind: Role -metadata: - name: {{ include "lifecycle-controller.fullname" . }}-leader-election-role - namespace: {{ .Release.Namespace }} - labels: - {{- include "lifecycle-controller.labels" . | nindent 4 }} + {{- include "lifecycle-controller.labels" $root | nindent 4 }} rules: -- apiGroups: [""] - resources: ["configmaps"] - verbs: ["get", "list", "watch", "create", "update", "patch", "delete"] -- apiGroups: ["coordination.k8s.io"] - resources: ["leases"] - verbs: ["get", "list", "watch", "create", "update", "patch", "delete"] -- apiGroups: [""] - resources: ["events"] - verbs: ["create", "patch"] -- apiGroups: ["events.k8s.io"] - resources: ["events"] - verbs: ["create", "patch"] + {{- include "lifecycle-controller.resourceRules" $root | nindent 0 }} --- apiVersion: rbac.authorization.k8s.io/v1 -kind: RoleBinding +kind: {{ ternary "RoleBinding" "ClusterRoleBinding" $namespaced }} metadata: - name: {{ include "lifecycle-controller.fullname" . }}-leader-election-rolebinding - namespace: {{ .Release.Namespace }} + name: {{ include "lifecycle-controller.fullname" $root }}-manager-rolebinding + {{- if $namespaced }} + namespace: {{ . | quote }} + {{- end }} labels: - {{- include "lifecycle-controller.labels" . | nindent 4 }} + {{- include "lifecycle-controller.labels" $root | nindent 4 }} roleRef: apiGroup: rbac.authorization.k8s.io - kind: Role - name: {{ include "lifecycle-controller.fullname" . }}-leader-election-role + kind: {{ ternary "Role" "ClusterRole" $namespaced }} + name: {{ include "lifecycle-controller.fullname" $root }}-manager-role subjects: - kind: ServiceAccount - name: {{ include "lifecycle-controller.serviceAccountName" . }} - namespace: {{ .Release.Namespace }} + name: {{ include "lifecycle-controller.serviceAccountName" $root }} + namespace: {{ $root.Release.Namespace }} +{{- end }} {{- end -}} diff --git a/charts/lifecycle-controller/tests/rbac_watchresources_test.yaml b/charts/lifecycle-controller/tests/rbac_watchresources_test.yaml index 29899d5..be42893 100644 --- a/charts/lifecycle-controller/tests/rbac_watchresources_test.yaml +++ b/charts/lifecycle-controller/tests/rbac_watchresources_test.yaml @@ -1,90 +1,91 @@ -suite: RBAC watchResources parsing +suite: RBAC configuration templates: - templates/rbac.yaml + - templates/deployment.yaml + - templates/leader-election-rbac.yaml + - templates/metrics-rbac.yaml + - templates/namespace-rbac.yaml tests: - - it: renders core resource with empty apiGroup - set: - controllerManager: - scope: - watchResources: - - configmaps - documentSelector: - path: kind - value: ClusterRole - asserts: - - equal: - path: rules[0].apiGroups[0] - value: "" - - equal: - path: rules[0].resources[0] - value: configmaps - - equal: - path: rules[0].verbs - value: ["delete", "get", "list", "patch", "update", "watch"] - - - it: renders single-segment apiGroup - set: - controllerManager: - scope: - watchResources: - - deployments.apps - documentSelector: - path: kind - value: ClusterRole + - it: limits default grants to standard resources + template: templates/rbac.yaml + documentSelector: {path: kind, value: ClusterRole} asserts: - equal: - path: rules[0].apiGroups[0] - value: apps - - equal: - path: rules[0].resources[0] - value: deployments - - - it: renders dotted apiGroup fully - set: - controllerManager: - scope: - watchResources: - - ingresses.networking.k8s.io - documentSelector: - path: kind - value: ClusterRole + path: rules + value: + - {apiGroups: [""], resources: [pods], verbs: [delete, get, list, patch, update, watch]} + - {apiGroups: [apps], resources: [deployments], verbs: [delete, get, list, patch, update, watch]} + - {apiGroups: [apps], resources: [statefulsets], verbs: [delete, get, list, patch, update, watch]} + - {apiGroups: [apps], resources: [daemonsets], verbs: [delete, get, list, patch, update, watch]} + - {apiGroups: [batch], resources: [jobs], verbs: [delete, get, list, patch, update, watch]} + - {apiGroups: [batch], resources: [cronjobs], verbs: [delete, get, list, patch, update, watch]} + - {apiGroups: [""], resources: [configmaps], verbs: [delete, get, list, patch, update, watch]} + - {apiGroups: [""], resources: [services], verbs: [delete, get, list, patch, update, watch]} + - {apiGroups: [networking.k8s.io], resources: [ingresses], verbs: [delete, get, list, patch, update, watch]} + - {apiGroups: [networking.k8s.io], resources: [networkpolicies], verbs: [delete, get, list, patch, update, watch]} + - {apiGroups: [""], resources: [persistentvolumeclaims], verbs: [delete, get, list, patch, update, watch]} + - {apiGroups: [autoscaling], resources: [horizontalpodautoscalers], verbs: [delete, get, list, patch, update, watch]} + - {apiGroups: [policy], resources: [poddisruptionbudgets], verbs: [delete, get, list, patch, update, watch]} + - {apiGroups: [""], resources: [namespaces], verbs: [delete, get, list, patch, update, watch]} + - {apiGroups: [""], resources: [persistentvolumes], verbs: [delete, get, list, patch, update, watch]} + - {apiGroups: [""], resources: [events], verbs: [create, patch]} + - {apiGroups: [events.k8s.io], resources: [events], verbs: [create, patch]} + - it: watches the default resources + template: templates/deployment.yaml asserts: - equal: - path: rules[0].apiGroups[0] - value: networking.k8s.io - - equal: - path: rules[0].resources[0] - value: ingresses + path: spec.template.spec.containers[0].args + value: + - --health-probe-bind-address=:8081 + - --leader-elect + - --leader-election-id=RELEASE-NAME-lifecycle-controller + - --metrics-bind-address=:8443 + - --metrics-secure=true + - --dry-run=false + - --zap-log-level=info + - --watch-resource=pods + - --watch-resource=deployments.apps + - --watch-resource=statefulsets.apps + - --watch-resource=daemonsets.apps + - --watch-resource=jobs.batch + - --watch-resource=cronjobs.batch + - --watch-resource=configmaps + - --watch-resource=services + - --watch-resource=ingresses.networking.k8s.io + - --watch-resource=networkpolicies.networking.k8s.io + - --watch-resource=persistentvolumeclaims + - --watch-resource=horizontalpodautoscalers.autoscaling + - --watch-resource=poddisruptionbudgets.policy + - --watch-resource=namespaces + - --watch-resource=persistentvolumes - - it: renders one watch rule per entry + - it: replaces default grants with core and grouped resources plus Events + template: templates/rbac.yaml set: controllerManager: scope: watchResources: - configmaps + - deployments.apps - ingresses.networking.k8s.io documentSelector: path: kind value: ClusterRole asserts: - equal: - path: rules[0].apiGroups[0] - value: "" - - equal: - path: rules[0].resources[0] - value: configmaps - - equal: - path: rules[1].apiGroups[0] - value: networking.k8s.io - - equal: - path: rules[1].resources[0] - value: ingresses - - equal: - path: rules[2].resources[0] - value: events + path: rules + value: + - {apiGroups: [""], resources: [configmaps], verbs: [delete, get, list, patch, update, watch]} + - {apiGroups: [apps], resources: [deployments], verbs: [delete, get, list, patch, update, watch]} + - {apiGroups: [networking.k8s.io], resources: [ingresses], verbs: [delete, get, list, patch, update, watch]} + - {apiGroups: [""], resources: [events], verbs: [create, patch]} + - {apiGroups: [events.k8s.io], resources: [events], verbs: [create, patch]} - it: keeps wildcard rule when watchResources empty + template: templates/rbac.yaml + set: + controllerManager.scope.watchResources: [] documentSelector: path: kind value: ClusterRole @@ -96,22 +97,23 @@ tests: path: rules[0].resources[0] value: "*" - - it: grants structured event permissions - documentSelector: - path: kind - value: ClusterRole + - it: rejects a resource list supplied as a string + template: templates/rbac.yaml + set: + controllerManager.scope.watchResources: pods asserts: - - equal: - path: rules[2].apiGroups[0] - value: events.k8s.io - - equal: - path: rules[2].resources[0] - value: events - - equal: - path: rules[2].verbs - value: ["create", "patch"] + - failedTemplate: {errorPattern: watchResources must be a list} + + - it: rejects a namespace filter that excludes every selected resource + template: templates/rbac.yaml + set: + controllerManager.scope.watchResources: [persistentvolumes] + controllerManager.scope.watchNamespaces: [team-a] + asserts: + - failedTemplate: {errorPattern: leaving no resources to watch} - it: fails on malformed value with empty resource segment + template: templates/rbac.yaml set: controllerManager: scope: @@ -122,6 +124,7 @@ tests: errorPattern: "invalid controllerManager.scope.watchResources entry" - it: fails on malformed value with empty apiGroup segment + template: templates/rbac.yaml set: controllerManager: scope: @@ -130,3 +133,268 @@ tests: asserts: - failedTemplate: errorPattern: "invalid controllerManager.scope.watchResources entry" + + - it: grants access only in the selected namespaces + template: templates/rbac.yaml + set: + controllerManager.scope.watchNamespaces: [team-a, team-b] + asserts: + - hasDocuments: {count: 4} + - isKind: {of: Role} + documentIndex: 0 + - equal: {path: metadata.namespace, value: team-a} + documentIndex: 0 + - lengthEqual: {path: rules, count: 15} + documentIndex: 0 + - equal: {path: "rules[1].resources", value: [deployments]} + documentIndex: 0 + - equal: {path: "rules[13].resources", value: [events]} + documentIndex: 0 + - isKind: {of: RoleBinding} + documentIndex: 1 + - equal: {path: roleRef.kind, value: Role} + documentIndex: 1 + - equal: {path: "subjects[0].namespace", value: NAMESPACE} + documentIndex: 1 + - isKind: {of: Role} + documentIndex: 2 + - equal: {path: metadata.namespace, value: team-b} + documentIndex: 2 + - isKind: {of: RoleBinding} + documentIndex: 3 + - it: removes ignored namespaces and duplicates + template: templates/rbac.yaml + set: + controllerManager.scope.watchNamespaces: [team-a, team-b, team-a] + controllerManager.scope.ignoreNamespaces: [team-b] + asserts: + - hasDocuments: {count: 2} + - equal: {path: metadata.namespace, value: team-a} + documentIndex: 0 + - equal: {path: metadata.namespace, value: team-a} + documentIndex: 1 + - it: removes ignored resource grants + template: templates/rbac.yaml + set: + controllerManager.scope.watchResources: [configmaps, secrets, configmaps] + controllerManager.scope.ignoreResources: [secrets] + documentSelector: {path: kind, value: ClusterRole} + asserts: + - lengthEqual: {path: rules, count: 3} + - equal: {path: "rules[0].resources", value: [configmaps]} + - it: grants only event writes when all resource entries are ignored + template: templates/rbac.yaml + set: + controllerManager.scope.watchResources: [configmaps] + controllerManager.scope.ignoreResources: [configmaps] + documentSelector: {path: kind, value: ClusterRole} + asserts: + - lengthEqual: {path: rules, count: 2} + - equal: {path: "rules[0].resources", value: [events]} + - it: selects cluster RBAC automatically for namespace patterns + template: templates/rbac.yaml + set: + controllerManager.scope.watchNamespaces: [dev-*] + asserts: + - isKind: {of: ClusterRole} + documentIndex: 0 + - it: rejects an empty effective namespace list + template: templates/rbac.yaml + set: + controllerManager.scope.watchNamespaces: [team-a] + controllerManager.scope.ignoreNamespaces: [team-a] + asserts: + - failedTemplate: {errorPattern: at least one namespace after ignore rules} + - it: rejects ignore namespace patterns for generated namespaced RBAC + template: templates/rbac.yaml + set: + controllerManager.scope.watchNamespaces: [team-a] + controllerManager.scope.ignoreNamespaces: [dev-*] + asserts: + - failedTemplate: {errorPattern: generated namespaced RBAC requires exact namespace names} + - it: permits ignore namespace patterns with supplied RBAC + template: templates/deployment.yaml + set: + rbac.create: false + controllerManager.scope.watchNamespaces: [team-a] + controllerManager.scope.ignoreNamespaces: [dev-*] + asserts: + - contains: + path: spec.template.spec.containers[0].args + content: --ignore-namespace=dev-* + - it: keeps Namespaces but excludes PersistentVolumes with namespace filters + template: templates/deployment.yaml + set: + controllerManager.scope.watchNamespaces: [team-a] + asserts: + - contains: + path: spec.template.spec.containers[0].args + content: --watch-namespace=team-a + - contains: + path: spec.template.spec.containers[0].args + content: --watch-resource=pods + - contains: + path: spec.template.spec.containers[0].args + content: --watch-resource=namespaces + - notContains: + path: spec.template.spec.containers[0].args + content: --watch-resource=persistentvolumes + - it: rejects resource globs that RBAC cannot express + template: templates/rbac.yaml + set: + controllerManager.scope.watchResources: ["deployment?.apps"] + asserts: + - failedTemplate: {errorPattern: chart-generated RBAC requires exact names} + - it: rejects ignore resource globs for generated RBAC + template: templates/rbac.yaml + set: + controllerManager.scope.ignoreResources: [secr*] + asserts: + - failedTemplate: {errorPattern: chart-generated RBAC requires exact ignoreResources} + - it: rejects resource patterns with dotted group suffixes + template: templates/rbac.yaml + set: + controllerManager.scope.watchResources: ["*.k8s.io"] + asserts: + - failedTemplate: {errorPattern: chart-generated RBAC requires exact names} + - it: permits resource globs with supplied RBAC + template: templates/deployment.yaml + set: + rbac.create: false + controllerManager.scope.watchResources: ["deployment?.apps"] + asserts: + - contains: + path: spec.template.spec.containers[0].args + content: --watch-resource=deployment?.apps + - it: maps a full resource wildcard to all API groups + template: templates/rbac.yaml + set: + controllerManager.scope.watchResources: ["*"] + documentSelector: {path: kind, value: ClusterRole} + asserts: + - equal: {path: "rules[0].apiGroups", value: ["*"]} + + - it: grants lease election access in the release namespace + template: templates/leader-election-rbac.yaml + asserts: + - hasDocuments: {count: 2} + - equal: {path: metadata.namespace, value: NAMESPACE} + documentIndex: 0 + - equal: {path: "rules[0].resources", value: [leases]} + documentIndex: 0 + - equal: {path: "rules[0].verbs", value: [get, create, update]} + documentIndex: 0 + - it: omits election grants when election is disabled + template: templates/leader-election-rbac.yaml + set: + controllerManager.leaderElection.enabled: false + asserts: + - hasDocuments: {count: 0} + - it: grants only auth review creation for secure metrics + template: templates/metrics-rbac.yaml + asserts: + - hasDocuments: {count: 2} + - equal: + path: rules + value: + - apiGroups: [authentication.k8s.io] + resources: [tokenreviews] + verbs: [create] + - apiGroups: [authorization.k8s.io] + resources: [subjectaccessreviews] + verbs: [create] + documentIndex: 0 + - it: omits auth grants when metrics are disabled + template: templates/metrics-rbac.yaml + set: + metrics.enabled: false + asserts: + - hasDocuments: {count: 0} + - it: omits auth grants for insecure metrics + template: templates/metrics-rbac.yaml + set: + metrics.secure: false + asserts: + - hasDocuments: {count: 0} + - it: omits election grants with supplied RBAC + template: templates/leader-election-rbac.yaml + set: + rbac.create: false + asserts: + - hasDocuments: {count: 0} + - it: omits metrics grants with supplied RBAC + template: templates/metrics-rbac.yaml + set: + rbac.create: false + asserts: + - hasDocuments: {count: 0} + + - it: grants Namespace access from the default resource list + template: templates/namespace-rbac.yaml + set: + controllerManager.scope.watchNamespaces: [team-a] + asserts: + - hasDocuments: {count: 4} + - it: omits Namespace grants when explicitly ignored + template: templates/namespace-rbac.yaml + set: + controllerManager.scope.watchNamespaces: [team-a] + controllerManager.scope.watchResources: [namespaces] + controllerManager.scope.ignoreResources: [namespaces] + asserts: + - hasDocuments: {count: 0} + - it: restricts Namespace writes to effective exact names + template: templates/namespace-rbac.yaml + set: + controllerManager.scope.watchNamespaces: [team-a, team-b, team-a] + controllerManager.scope.ignoreNamespaces: [team-b] + controllerManager.scope.watchResources: [namespaces] + asserts: + - hasDocuments: {count: 4} + - isKind: {of: ClusterRole} + documentIndex: 0 + - equal: + path: rules + value: + - apiGroups: [""] + resources: [namespaces] + verbs: [get, list, watch] + - apiGroups: [""] + resources: [namespaces] + resourceNames: [team-a] + verbs: [delete, patch, update] + documentIndex: 0 + - isKind: {of: ClusterRoleBinding} + documentIndex: 1 + - equal: {path: "subjects[0].namespace", value: NAMESPACE} + documentIndex: 1 + - isKind: {of: Role} + documentIndex: 2 + - equal: {path: metadata.namespace, value: default} + documentIndex: 2 + - lengthEqual: {path: rules, count: 2} + documentIndex: 2 + - isKind: {of: RoleBinding} + documentIndex: 3 + - equal: {path: metadata.namespace, value: default} + documentIndex: 3 + - it: keeps Namespace rules out of namespaced manager Roles + template: templates/rbac.yaml + set: + controllerManager.scope.watchNamespaces: [team-a] + controllerManager.scope.watchResources: [namespaces, deployments.apps] + asserts: + - isKind: {of: Role} + documentIndex: 0 + - lengthEqual: {path: rules, count: 3} + documentIndex: 0 + - equal: {path: "rules[0].resources", value: [deployments]} + documentIndex: 0 + - it: omits Namespace grants with supplied RBAC + template: templates/namespace-rbac.yaml + set: + rbac.create: false + controllerManager.scope.watchNamespaces: [team-a] + controllerManager.scope.watchResources: [namespaces] + asserts: + - hasDocuments: {count: 0} diff --git a/charts/lifecycle-controller/values.yaml b/charts/lifecycle-controller/values.yaml index 113336f..73e4df3 100644 --- a/charts/lifecycle-controller/values.yaml +++ b/charts/lifecycle-controller/values.yaml @@ -18,7 +18,7 @@ serviceAccount: # If not set and create is true, a name is generated using the fullname template name: "" -# Create the necessary ClusterRole, ClusterRoleBinding, Role, and RoleBinding +# Create RBAC for the resource filters, namespace filters, and enabled features. rbac: create: true @@ -63,7 +63,25 @@ controllerManager: # Defines which resources and namespaces the controller should watch. scope: # List of glob patterns for resources to watch (e.g. ["deployments.apps", "pods", "*.k8s.io"]) - watchResources: [] + # Set [] to watch all eligible resources with wildcard permissions. + # Namespace filters exclude non-namespaced resources, such as PersistentVolumes. + # Namespace objects are supported when included in watchResources. + watchResources: + - pods + - deployments.apps + - statefulsets.apps + - daemonsets.apps + - jobs.batch + - cronjobs.batch + - configmaps + - services + - ingresses.networking.k8s.io + - networkpolicies.networking.k8s.io + - persistentvolumeclaims + - horizontalpodautoscalers.autoscaling + - poddisruptionbudgets.policy + - namespaces + - persistentvolumes # List of glob patterns for resources to ignore ignoreResources: [] # List of glob patterns for namespaces to watch (e.g. ["default", "dev-*"]) diff --git a/test/e2e-helm/e2e_helm_test.go b/test/e2e-helm/e2e_helm_test.go index bc1f049..fec1141 100644 --- a/test/e2e-helm/e2e_helm_test.go +++ b/test/e2e-helm/e2e_helm_test.go @@ -90,6 +90,21 @@ var _ = Describe("Lifecycle Controller Helm E2E", Ordered, func() { g.Expect(status).To(Equal("Running")) } Eventually(verifyControllerUp).WithTimeout(deploymentTimeout).WithPolling(pollInterval).Should(Succeed()) + + By("waiting for all default resource caches to synchronize") + _, err = utils.Run(exec.Command("kubectl", "rollout", "status", + "deployment/"+releaseName+"-lifecycle-controller", "-n", managerNamespace, "--timeout=120s")) + Expect(err).NotTo(HaveOccurred()) + By("checking the default resource permissions") + serviceAccount := "system:serviceaccount:" + managerNamespace + ":" + releaseName + "-lifecycle-controller" + for _, resource := range []string{ + "deployments.apps", "configmaps", "persistentvolumeclaims", "namespaces", "persistentvolumes", + } { + checkScopedAccess(serviceAccount, "delete", resource, managerNamespace, "yes") + } + for _, resource := range []string{"secrets", "nodes", "clusterroles.rbac.authorization.k8s.io"} { + checkScopedAccess(serviceAccount, "get", resource, managerNamespace, "no") + } }) It("should perform a basic lifecycle action (smoke test)", func() { @@ -207,77 +222,7 @@ stringData: }) It("should only process namespaces specified in watch-namespace", func() { - allowedNS := "e2e-allowed-ns" - ignoredNS := "e2e-ignored-ns" - - cmd := exec.Command("kubectl", "create", "ns", allowedNS) - utils.Run(cmd) - cmd = exec.Command("kubectl", "create", "ns", ignoredNS) - utils.Run(cmd) - - defer func() { - exec.Command("kubectl", "delete", "ns", allowedNS).Run() - exec.Command("kubectl", "delete", "ns", ignoredNS).Run() - }() - - By("installing the helm chart watching ONLY allowed-ns") - repoAndTag := strings.SplitN(projectImage, ":", 2) - repo, tag := repoAndTag[0], repoAndTag[1] - - cmd = exec.Command("helm", "install", scopedReleaseName, chartPath, - "--namespace", managerNamespace, - "--set", fmt.Sprintf("image.repository=%s", repo), - "--set", fmt.Sprintf("image.tag=%s", tag), - "--set", "image.pullPolicy=Never", - "--set", fmt.Sprintf("controllerManager.scope.watchNamespaces[0]=%s", allowedNS), - ) - _, err := utils.Run(cmd) - Expect(err).NotTo(HaveOccurred()) - - Eventually(func(g Gomega) { - pod := utils.GetPodForRelease(g, scopedReleaseName, managerNamespace) - g.Expect(pod.Status.Phase).To(Equal(corev1.PodRunning)) - }).WithTimeout(deploymentTimeout).WithPolling(pollInterval).Should(Succeed()) - - By("Creating ConfigMap in allowed NS") - allowedCM := "cm-allowed" - utils.ApplyYAML(fmt.Sprintf(` -apiVersion: v1 -kind: ConfigMap -metadata: - name: %s - namespace: %s - annotations: - lifecycle.cezary.dev/delete-after: "2s" -data: { key: val } -`, allowedCM, allowedNS)) - - By("Creating ConfigMap in ignored NS") - ignoredCM := "cm-ignored" - utils.ApplyYAML(fmt.Sprintf(` -apiVersion: v1 -kind: ConfigMap -metadata: - name: %s - namespace: %s - annotations: - lifecycle.cezary.dev/delete-after: "2s" -data: { key: val } -`, ignoredCM, ignoredNS)) - - By("Verifying allowed NS resource IS deleted") - Eventually(func(g Gomega) { - cmd := exec.Command("kubectl", "get", "cm", allowedCM, "-n", allowedNS) - _, err := utils.Run(cmd) - g.Expect(err).To(HaveOccurred()) - }).WithTimeout(safeTimeout).WithPolling(pollInterval).Should(Succeed()) - - By("Verifying ignored NS resource is NOT deleted") - Consistently(func(g Gomega) { - cmd := exec.Command("kubectl", "get", "cm", ignoredCM, "-n", ignoredNS) - _, err := utils.Run(cmd) - g.Expect(err).NotTo(HaveOccurred()) - }).WithTimeout(consistentDuration).WithPolling(pollInterval).Should(Succeed()) + verifyNamespaceScopedRBAC(chartPath, scopedReleaseName, managerNamespace) }) It("should prioritize ignore-resource over watch-resource (Precedence)", func() { diff --git a/test/e2e-helm/rbac_scope_test.go b/test/e2e-helm/rbac_scope_test.go new file mode 100644 index 0000000..2f4d415 --- /dev/null +++ b/test/e2e-helm/rbac_scope_test.go @@ -0,0 +1,108 @@ +//go:build e2e_helm + +package e2e_helm + +import ( + "fmt" + "os/exec" + "strings" + + . "github.com/onsi/ginkgo/v2" + . "github.com/onsi/gomega" + + "github.com/cstanislawski/lifecycle-controller/test/utils" +) + +func verifyNamespaceScopedRBAC(chartPath, release, manager string) { + GinkgoHelper() + const ( + allowedA = "e2e-allowed-ns" + allowedB = "e2e-allowed-ns-b" + denied = "e2e-ignored-ns" + ) + serviceAccount := "system:serviceaccount:" + manager + ":" + release + "-lifecycle-controller" + for _, namespace := range []string{allowedA, allowedB, denied} { + DeferCleanup(func() { + _, err := utils.Run(exec.Command("kubectl", "delete", "namespace", namespace, "--wait=false")) + Expect(err).NotTo(HaveOccurred()) + }) + _, err := utils.Run(exec.Command("kubectl", "create", "namespace", namespace)) + Expect(err).NotTo(HaveOccurred()) + } + DeferCleanup(func() { + if CurrentSpecReport().Failed() { + _, _ = utils.Run(exec.Command("kubectl", "logs", "deployment/"+release+"-lifecycle-controller", "-n", manager)) + } + }) + image := strings.SplitN(projectImage, ":", 2) + _, err := utils.Run(exec.Command("helm", "install", release, chartPath, "--namespace", manager, + "--set", "image.repository="+image[0], "--set", "image.tag="+image[1], + "--set", "image.pullPolicy=Never", + "--set", "controllerManager.scope.watchResources={configmaps,secrets}", + "--set", "controllerManager.scope.ignoreResources={secrets}", + "--set", "controllerManager.scope.watchNamespaces={"+allowedA+","+allowedB+","+denied+"}", + "--set", "controllerManager.scope.ignoreNamespaces={"+denied+"}")) + Expect(err).NotTo(HaveOccurred()) + By("waiting for the scoped cache and leader election") + _, err = utils.Run(exec.Command("kubectl", "rollout", "status", "deployment/"+release+"-lifecycle-controller", + "-n", manager, "--timeout=120s")) + Expect(err).NotTo(HaveOccurred()) + + By("checking effective permissions through the API server") + for _, namespace := range []string{allowedA, allowedB} { + checkScopedAccess(serviceAccount, "get", "secrets", namespace, "no") + checkScopedAccess(serviceAccount, "create", "events", namespace, "yes") + } + checkScopedAccess(serviceAccount, "delete", "configmaps", denied, "no") + checkScopedAccess(serviceAccount, "list", "configmaps", manager, "no") + checkScopedAccess(serviceAccount, "get", "namespaces", "", "no") + checkScopedAccess(serviceAccount, "create", "tokenreviews.authentication.k8s.io", "", "yes") + checkScopedAccess(serviceAccount, "create", "subjectaccessreviews.authorization.k8s.io", "", "yes") + output, err := utils.Run(exec.Command("kubectl", "get", "configmaps", "-n", denied, "--as="+serviceAccount)) + Expect(err).To(HaveOccurred()) + Expect(output).To(ContainSubstring("Forbidden")) + output, err = utils.Run(exec.Command("kubectl", "get", "configmaps", "--all-namespaces", "--as="+serviceAccount)) + Expect(err).To(HaveOccurred()) + Expect(output).To(ContainSubstring("Forbidden")) + + By("checking lifecycle actions in both permitted namespaces") + for _, namespace := range []string{allowedA, allowedB, denied} { + utils.ApplyYAML(fmt.Sprintf(`apiVersion: v1 +kind: ConfigMap +metadata: + name: rbac-delete + namespace: %s + annotations: + lifecycle.cezary.dev/delete-after: "2s" +data: {key: value} +`, namespace)) + } + for _, namespace := range []string{allowedA, allowedB} { + Eventually(func(g Gomega) { + output, err := utils.Run(exec.Command("kubectl", "get", "configmap", "rbac-delete", "-n", namespace)) + g.Expect(err).To(HaveOccurred()) + g.Expect(output).To(ContainSubstring("NotFound")) + }).WithTimeout(safeTimeout).WithPolling(pollInterval).Should(Succeed()) + } + Consistently(func(g Gomega) { + output, err := utils.Run(exec.Command("kubectl", "get", "configmap", "rbac-delete", "-n", denied, + "-o", "jsonpath={.metadata.annotations}")) + g.Expect(err).NotTo(HaveOccurred()) + g.Expect(output).To(ContainSubstring("delete-after")) + g.Expect(output).NotTo(ContainSubstring("delete-at")) + }).WithTimeout(consistentDuration).WithPolling(pollInterval).Should(Succeed()) +} + +func checkScopedAccess(serviceAccount, verb, resource, namespace, want string) { + args := []string{"auth", "can-i", verb, resource, "--as=" + serviceAccount} + if namespace != "" { + args = append(args, "--namespace", namespace) + } + output, err := utils.Run(exec.Command("kubectl", args...)) + if want == "yes" { + ExpectWithOffset(1, err).NotTo(HaveOccurred()) + } + lines := utils.GetNonEmptyLines(output) + ExpectWithOffset(1, lines).NotTo(BeEmpty()) + ExpectWithOffset(1, lines[len(lines)-1]).To(Equal(want), "%s %s in %s", verb, resource, namespace) +}