0Pricing
Docker & Kubernetes for Developers · Pelajaran

Kontrol Akses Berbasis Peran (RBAC)

Konfigurasikan RBAC untuk mengelola izin pengguna dan akun layanan di dalam klaster Kubernetes Anda secara aman.

Kontrol Akses Berbasis Peran (RBAC) adalah pelajaran Docker & Kubernetes for Developers gratis di CoddyKit. Ini adalah pelajaran 1 dari 4. Kamu bisa membaca pelajaran lengkapnya di bawah secara gratis — lalu praktikkan langsung di browser dengan editor kode bawaan dan tutor AI 24/7. Ini adalah bagian dari jalur belajar Docker & Kubernetes for Developers, dan progresmu tersinkronisasi di web dan aplikasi CoddyKit. Kursus Docker & Kubernetes for Developers mencakup 4 pelajaran total.

Bagian dari pelajaran ini belum diterjemahkan dan ditampilkan dalam bahasa Inggris.

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!

Pertanyaan yang Sering Diajukan

Apakah pelajaran “Kontrol Akses Berbasis Peran (RBAC)” gratis?

Ya — teks lengkap “Kontrol Akses Berbasis Peran (RBAC)” gratis dibaca di sini di web. Untuk praktiknya secara interaktif (editor kode bawaan dan tutor AI 24/7) dan buka sisa kursus Docker & Kubernetes for Developers, upgrade ke CoddyKit PRO. Kursus Docker & Kubernetes for Developers mencakup 4 pelajaran total.

Apa yang akan aku pelajari di “Kontrol Akses Berbasis Peran (RBAC)”?

Konfigurasikan RBAC untuk mengelola izin pengguna dan akun layanan di dalam klaster Kubernetes Anda secara aman. Kamu berlatih Docker & Kubernetes for Developers dengan kode praktik yang langsung kamu jalankan di browser, dan tutor AI 24/7 menjawab pertanyaanmu saat kamu mengerjakan pelajaran ini.

Apakah aku perlu pengalaman untuk memulai Docker & Kubernetes for Developers?

Tidak diperlukan pengalaman sebelumnya. Docker & Kubernetes for Developers di CoddyKit dirancang untuk pemula hingga pelajar tingkat lanjut, jadi kamu bisa memulai di sini atau dari awal dan belajar sesuai kecepatan kamu sendiri. Ini adalah pelajaran 1 dari 4.

Berapa lama pelajaran “Kontrol Akses Berbasis Peran (RBAC)” memakan waktu?

Sebagian besar pelajaran CoddyKit memakan waktu sekitar 5–10 menit. Setiap pelajaran ringkas dan interaktif, jadi kamu membuat kemajuan stabil dan melanjutkan dari tempat kamu tinggalkan di web dan aplikasi.

Bisakah aku menulis dan menjalankan kode dalam pelajaran Docker & Kubernetes for Developers ini?

Ya. Setiap pelajaran Docker & Kubernetes for Developers menyertakan editor kode bawaan, jadi kamu menulis dan menjalankan kode nyata langsung di browser dan mendapatkan umpan balik AI instan — tidak diperlukan penyiapan lokal.

Semua pelajaran dalam kursus ini

  1. Kontrol Akses Berbasis Peran (RBAC)
  2. Keamanan Pod dan Pemindaian Image
  3. Mengamankan Lalu Lintas Jaringan Kubernetes
  4. Mengelola Secret dengan Aman melalui Penyimpanan Secret Eksternal
← Kembali ke Docker & Kubernetes for Developers