Controllo degli accessi basato sui ruoli (RBAC)

Welcome to Role-Based Access Control (RBAC)! In Kubernetes, RBAC is a method for regulating access to computer or network resources based on the roles of individual users within your organization.

Think of it as the security guard for your cluster: it decides who can do what.

RBAC is critical for cluster security and operational integrity. Without it, any user or process with access could potentially perform any action, leading to security vulnerabilities or accidental misconfigurations.

• Security: Prevents unauthorized access.
• Least Privilege: Ensures users/applications only have necessary permissions.
• Compliance: Helps meet regulatory requirements for access control.

In RBAC, a Subject is 'who' is performing an action. Kubernetes identifies three types of subjects:

• Users: Human users (often managed externally).
• Service Accounts: Identities for processes running in Pods. These are Kubernetes-native.
• Groups: Collections of Users or Service Accounts.

We'll focus on Service Accounts as they are central to application security within Kubernetes.

A Role defines 'what' actions can be performed. Roles are always namespace-scoped, meaning the permissions they grant apply only within a specific namespace.

A Role contains rules, which are sets of permissions. Each rule specifies:

• apiGroups: The API group the resource belongs to (e.g., "" for core, apps for deployments).
• resources: The specific resource types (e.g., pods, deployments).
• verbs: The actions allowed (e.g., get, list, create, delete).

Similar to Roles, a ClusterRole also defines 'what' actions can be performed, but it is cluster-scoped. This means its permissions apply across the entire cluster.

ClusterRoles are used for:

• Granting access to cluster-scoped resources (like nodes).
• Granting access to resources across all namespaces.
• Granting access to non-resource endpoints (like /healthz).

A RoleBinding is 'how' permissions are granted. It links a Subject (User, ServiceAccount, or Group) to a Role.

Like Roles, RoleBindings are namespace-scoped. This means the binding grants the permissions defined in the Role to the Subject, but only within that specific namespace.

A ClusterRoleBinding links a Subject to a ClusterRole. Because ClusterRoles are cluster-scoped, a ClusterRoleBinding grants permissions across the entire cluster.

Use ClusterRoleBindings carefully, as they grant broad access. They are typically used for cluster administrators or system-level components.

Let's create a Service Account named my-app-sa in the default namespace. This Service Account will be the identity for a future application pod.

Run this command in your terminal:

Now, let's define a Role called pod-reader in the default namespace. This Role will allow subjects to get, list, and watch pods.

Save this YAML as pod-reader-role.yaml and apply it using kubectl apply -f pod-reader-role.yaml:

Finally, let's create a RoleBinding named read-pods-binding that links our my-app-sa Service Account to the pod-reader Role in the default namespace.

Save this YAML as pod-reader-binding.yaml and apply it:

You've learned the fundamentals of Kubernetes RBAC!

• Subjects: Who is acting (Users, Service Accounts, Groups).
• Roles/ClusterRoles: What actions are allowed (namespace-scoped vs. cluster-scoped).
• RoleBindings/ClusterRoleBindings: How subjects are linked to permissions (namespace-scoped vs. cluster-scoped).

Mastering RBAC is crucial for securing your Kubernetes applications and infrastructure. Keep practicing with different permission sets!