0Pricing
Docker & Kubernetes for Developers · Lektion

Rollenbasierte Zugriffskontrolle (RBAC)

Konfigurieren Sie RBAC, um Berechtigungen von Benutzern und Servicekonten in Ihrem Kubernetes-Cluster sicher zu verwalten.

Rollenbasierte Zugriffskontrolle (RBAC) ist eine kostenlose Docker & Kubernetes for Developers-Lektion auf CoddyKit. Dies ist Lektion 1 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des Docker & Kubernetes for Developers-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der Docker & Kubernetes for Developers-Kurs umfasst insgesamt 4 Lektionen.

Teile dieser Lektion wurden noch nicht übersetzt und werden auf Englisch angezeigt.

What is Kubernetes 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.

Why RBAC is Essential

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.

RBAC Core Concepts: Subjects

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.

RBAC Core Concepts: Roles

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).

RBAC Core Concepts: ClusterRoles

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).

RBAC Core Concepts: RoleBindings

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.

RBAC Core Concepts: ClusterRoleBindings

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.

Example: Creating a Service Account

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:

kubectl create serviceaccount my-app-sa -n default

Example: Defining a Pod Reader Role

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:

apiVersion: rbac.authorization.k8s.io/v1
kind: Role
metadata:
  name: pod-reader
  namespace: default
rules:
- apiGroups: [""] # Core API group
  resources: ["pods", "pods/log"]
  verbs: ["get", "list", "watch"]

Example: Binding the Role

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:

apiVersion: rbac.authorization.k8s.io/v1
kind: RoleBinding
metadata:
  name: read-pods-binding
  namespace: default
subjects:
- kind: ServiceAccount
  name: my-app-sa
  namespace: default
roleRef:
  kind: Role
  name: pod-reader
  apiGroup: rbac.authorization.k8s.io

Quick Check: RBAC Resources

Which Kubernetes resource is used to grant cluster-wide permissions to a Service Account?

RBAC: Key Takeaways

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!

Häufig gestellte Fragen

Ist die Lektion „Rollenbasierte Zugriffskontrolle (RBAC)“ kostenlos?

Ja — der vollständige Text von „Rollenbasierte Zugriffskontrolle (RBAC)“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des Docker & Kubernetes for Developers-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der Docker & Kubernetes for Developers-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „Rollenbasierte Zugriffskontrolle (RBAC)“?

Konfigurieren Sie RBAC, um Berechtigungen von Benutzern und Servicekonten in Ihrem Kubernetes-Cluster sicher zu verwalten. Du übst Docker & Kubernetes for Developers mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um Docker & Kubernetes for Developers zu starten?

Keine Vorkenntnisse erforderlich. Docker & Kubernetes for Developers auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 1 von 4.

Wie lange dauert die Lektion „Rollenbasierte Zugriffskontrolle (RBAC)“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser Docker & Kubernetes for Developers-Lektion Code schreiben und ausführen?

Ja. Jede Docker & Kubernetes for Developers-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

  1. Rollenbasierte Zugriffskontrolle (RBAC)
  2. Pod-Sicherheit und Image-Scanning
  3. Kubernetes-Netzwerkverkehr absichern
  4. Secrets sicher mit externen Secret Stores verwalten
← Zurück zu Docker & Kubernetes for Developers