Role-Based Access Control

This page provides an overview for role-based access control in Kubernetes Engine.

Overview

Kubernetes Engine's role-based access control (RBAC) lets you exercise fine-grained control over how users access the Kubernetes API resources running on your container cluster. You can use RBAC to dynamically configure permissions for your cluster's users and define the kinds of resources with which they can interact.

You can create RBAC permissions that apply to your entire cluster, or to specific namespaces within your cluster. Cluster-wide permissions are useful for limiting certain users' access to specific API resources (such as security policies or Secrets). Namespace-specific permissions are useful if, for example, you have multiple groups of users operating within their own respective namespaces. RBAC can help you ensure that users only have access to cluster resources within their own namespace.

Interaction with Identity and Access Management

Kubernetes Engine also uses Identity and Access Management (IAM) to control access to your container cluster. However, IAM works on a per-project basis—that is, users require IAM-level permissions to access any cluster in a given Cloud Platform project.

RBAC permissions provide finer-grained control over access to resources within each cluster. As such, IAM and RBAC can work in concert, and a user must have sufficient permissions at either level to work with resources in your cluster.

Prerequisites for using Role-Based Access Control

For Kubernetes Engine clusters running Kubernetes versions 1.6 or 1.7, you must create or update your cluster with the option --no-enable-legacy-authorization to ensure that your role-based access control permissions take effect.

Once the cluster has the legacy authorizer disabled, you must grant your user the ability to create authorization roles by running the following Kubernetes command:

kubectl create clusterrolebinding cluster-admin-binding --clusterrole=cluster-admin [--user=<user-name>]

Kubernetes Engine clusters running Kubernetes version 1.8 and later disable the legacy authorization system by default, and thus role-based access control permissions take effect with no special action required.

Setting up Role-Based Access Control

You define your RBAC permissions by creating objects from the rbac.authorization.k8s.io API group in your cluster. You can create the objects using the kubectl command-line interface, or programmatically.

You'll need to create two kinds of objects:

  1. A Role or ClusterRole object that defines what resource types and operations are allowed for a set of users.
  2. A RoleBinding or ClusterRoleBinding that associates the Role (or ClusterRole) with one or more specific users.

RBAC permissions are purely additive--there are no "deny" rules. When structuring your RBAC permissions, you should think in terms of "granting" users access to cluster resources.

Defining Permissions in a Role

You define permissions within a Kubernetes Role or ClusterRole API object. A Role grants access to resources within a single namespace, while a ClusterRole grants access to resources in the entire cluster.

Within your Role (or ClusterRole) object, you define the permissions as a set of rules. The rules determine the namespace, resource type, and allowable operations for that role. For example, you can create a Role that grants read access (operations such as get, watch, and list) for all Pod resources in a given namespace.

Role vs. ClusterRole

Because ClusterRole permissions apply across the entire cluster, you can use them to control access to different kinds of resources than you can with a Role. These include:

  • Cluster-scoped resources such as Nodes
  • Non-resource Endpoints such as /healthz
  • Namespaced resources across all namespaces (for example, all Pods across the entire cluster, regardless of namespace)

Assigning Permissions to Users with RoleBinding

Once you've created the Role (or ClusterRole), you must create a RoleBinding (or ClusterRoleBinding) object to grant the permissions in the Role (or ClusterRole) to a set of users. The users can be individual users, or Kubernetes service accounts.

The RoleBinding (or ClusterRoleBinding) contains a list of the users, and a reference to the Role (or ClusterRole) being granted to those users.

API Usage and Examples

For complete information on using the Kubernetes API to create the necessary Role, ClusterRole, RoleBinding, and ClusterRoleBinding objects for RBAC, see Using Role-Based Access Control Authorization in the Kubernetes documentation.

What's next

Send feedback about...

Kubernetes Engine