Rollenbasierte Zugriffskontrolle (RBAC) in Kubernetes

Die rollenbasierte Zugriffskontrolle (RBAC) wird verwendet, um den Zugriff auf einen Computer oder Netzwerkressourcen im Kubernetes-Cluster zuzuweisen.

In diesem Artikel werden wir die Grundlagen von RBAC verstehen und die Objekte Role, ClusterRole, RoleBinding und ClusterRoleBinding erstellen.

Wir werden dann eine kubeconfig-Datei erstellen, um einem bestimmten Benutzer in einem ausgewählten Namensraum begrenzten Zugriff zu gewähren.

Doch bevor wir fortfahren, wollen wir zunächst die Grundlagen verstehen.

1. Eine Role oder ClusterRole enthält eine Reihe von Berechtigungen.
2. Eine Rolle legt Berechtigungen innerhalb eines bestimmten Namensraums fest, und ClusterRole ist eine Ressource ohne Namensraum.
3. Eine Rollenbindung gewährt einem Benutzer oder einer Gruppe von Benutzern die in einer Rolle definierten Berechtigungen, während ClusterRoleBinding diesen Zugriff clusterweit gewährt.
4. Ein RoleBinding kann auf jede Rolle im gleichen Namensraum verweisen. Alternativ kann ein RoleBinding auf eine ClusterRole verweisen und diese ClusterRole an den Namensraum des RoleBindin
5. Eine kubeconfig-Datei ist eine Datei, mit der der Zugriff auf Kubernetes über das kubectl-Befehlszeilen-Tool konfiguriert wird.

Um RBAC im Detail zu verstehen, besuchen Sie die offizielle Dokumentation von Kubernetes hier.

Note: Refer screenshots to avoid any confusion before executing the commands. ( ubuntu@master = master node and ubuntu@ip-172-31-25-70 = user machine)

Vorraussetzungen

1. Kubernetes Cluster mit mindestens 1 Worker-Knoten.
   Wenn Sie lernen möchten, wie man einen Kubernetes-Cluster erstellt, klicken Sie hier. Dieses Handbuch hilft Ihnen, einen Kubernetes-Cluster mit 1 Master- und 2 Worker-Knoten auf AWS Ubuntu 18.04 EC2-Instanzen zu erstellen.

Was werden wir tun?

1. Erstellen Sie die Objektdateien „Role“, „Role Binding“, „Cluster Role“, „Cluster Role Binding“.
2. Erstellen Sie Objekte in den Bereichen Rolle, Rollenbindung, Cluster-Rolle, Cluster-Rollenbindung im Cluster.
3. Bieten Sie Benutzern Zugriff über die Datei kubeconfig.
4. Zusammenfassung der Erstellung der kubeconfig-Datei.

Erstellen Sie eine Objektdatei „Role, Role Binding, Cluster Role, Cluster Role Binding“.

Erstellen Sie eine Datei, um eine Rolle im „Standard“-Namensraum zu erstellen, die verwendet werden kann, um dem get, watch und list Zugriff auf Pods zu gewähren.

vim my-role.yml

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

Erstellen Sie eine neue Datei, um ein RoleBinding zu erstellen, das dem Benutzer „jane“ innerhalb des „Standard“-Namensraums die „pod-reader“-Rolle erlaubt.

vim my-role-binding.yml

kind: RoleBinding
apiVersion: rbac.authorization.k8s.io/v1beta1
metadata:
  name: read-pods
  namespace: default
subjects:
- kind: User
  name: jane
  apiGroup: rbac.authorization.k8s.io
roleRef:
  kind: Role
  name: pod-reader
  apiGroup: rbac.authorization.k8s.io

Erstellen Sie eine Datei, um eine ClusterRole zu erstellen, die verwendet werden kann, um dem get, watch und list Zugriff auf Geheimnisse in einem bestimmten Namespace oder über alle Namespaces hinweg zu gewähren, je nachdem, wie sie gebunden ist.

vim my-cluster-role.yml

kind: ClusterRole
apiVersion: rbac.authorization.k8s.io/v1beta1
metadata:
  name: secret-reader
rules:
- apiGroups: [""]
  resources: ["secrets"]
  verbs: ["get", "watch", "list"]

Erstellen Sie eine neue Datei, um eine ClusterRoleBinding zu erstellen, die es jedem Benutzer in der Gruppe „manager“ ermöglicht, Geheimnisse in jedem Namensraum zu lesen.

vim my-cluster-role-binding.yml

kind: ClusterRoleBinding
apiVersion: rbac.authorization.k8s.io/v1beta1
metadata:
  name: read-secrets-global
subjects:
- kind: Group
  name: manager
  apiGroup: rbac.authorization.k8s.io
roleRef:
  kind: ClusterRole
  name: secret-reader
  apiGroup: rbac.authorization.k8s.io

Erstellen Sie eine Rolle, eine Rollenbindung, eine Cluster-Rolle, eine Cluster-Rollenbindung für Objekte.

Holen Sie eine Liste der vorhandenen Rollen und ClusterRoles aus dem Cluster.

kubectl  get roles

kubectl  get clusterroles

Erhalten Sie eine Liste der vorhandenen RoleBindings und ClusterRoleBindings aus dem Cluster.

kubectl  get rolebinding

kubectl  get clusterrolebinding

Erstellen Sie nun ein Role, RoleBinding und ClusterRole ClusterRoleBinding unter Verwendung der Dateien, die wir in den obigen Schritten erstellt haben.

kubectl create -f my-role.yml

kubectl create -f my-role-binding.yml

kubectl create -f my-cluster-role.yml

kubectl create -f my-cluster-role-binding.yml

Mit den folgenden Befehlen überprüfen Sie, ob die Objekte erstellt wurden.

kubectl  get roles | grep pod-reader

kubectl  get rolebinding | grep read-pods

kubectl  get clusterroles | grep secret-reader

kubectl  get clusterrolebinding | grep read-secrets-global

Im obigen Screenshot sehen Sie, dass die Role, RoleBinding und ClusterRole, ClusterRoleBinding erstellt wurde.

Bieten Sie den Benutzern Zugriff über die Datei kubeconfig(config).

In diesem Abschnitt werden wir nun eine Konfigurationsdatei erstellen, die mit einem Benutzer gemeinsam genutzt werden kann. Um dieses Szenario zu testen, werden wir hier einen Benutzer „bob“ auf dem Linux-Server erstellen und diese Konfigurationsdatei für den Benutzer „bob“ freigeben. Wir werden dann versuchen, Operationen durchzuführen, die für diesen Benutzer erlaubt und nicht erlaubt sind. Wir werden eine Admin-ClusterRole an den Benutzer „bob“ binden, die Zugriff auf alle Objekte im Namensraum „bob“ gewährt.

Erstellen Sie auf den Master-Knoten eine Schlüssel- und Zertifikatssignierungsanforderung (CSR) mit openssl.

pwd

mkdir user-bob

cd user-bob/

openssl req -new -newkey rsa:4096 -nodes -keyout bob-k8s.key -out bob-k8s.csr -subj "/CN=bob/O=devops"

cat bob-k8s.csr | base64 | tr -d '\n'

Erstellen Sie eine CertificateSigningRequest-Objektdefinitionsdatei, die die CSR enthält, die wir im obigen Schritt erzeugt haben. Fügen Sie in der folgenden Datei die Ausgabe des Befehls „cat bob-k8s.csr | base64 | tr -d ‚\n'“ zur Eigenschaft „request“ hinzu.

vim k8s-csr.yaml

apiVersion: certificates.k8s.io/v1beta1
kind: CertificateSigningRequest
metadata:
  name: bob-k8s-access
spec:
  groups:
  - system:authenticated
  request: # replace output of: cat bob-k8s.csr | base64 | tr -d '\n'
  usages:
  - client auth

cat k8s-csr.yaml

Erstellen Sie ein CertificateSigningRequest-Objekt innerhalb von Kubernetes, das die CSR enthält, die wir im obigen Schritt erzeugt haben.

kubectl  get csr

kubectl  create -f k8s-csr.yaml

kubectl  get csr

Nun wollen wir das CSR-Objekt (CertificateSigningRequest) genehmigen, das wir im obigen Schritt erstellt haben.

kubectl  get csr

kubectl certificate approve bob-k8s-access

kubectl  get csr

In der obigen Abbildung sehen Sie, dass der CSR genehmigt, ausgestellt wurde.

Rufen Sie das im Feld ’status.certificate‘ des CSR-Objekts verfügbare Zertifikat ab.

ls -lt

kubectl get csr bob-k8s-access -o jsonpath='{.status.certificate}' | base64 --decode > bob-k8s-access.crt

ls -lt

cat bob-k8s-access.crt

Rufen Sie das Cluster-CA-Zertifikat ab, das die nächste Voraussetzung für Bobs kubeconfig-Datei ist, und speichern Sie es in der Datei „k8s-ca.crt“.

ls -lt

kubectl config view -o jsonpath='{.clusters[0].cluster.certificate-authority-data}' --raw | base64 --decode - > k8s-ca.crt

ls -lt

cat k8s-ca.crt

Richten Sie die Cluster-Konfiguration in der kubeconfig-Datei von Bob ein. Alle diese Angaben werden aus unserer bestehenden kubeconfig-Datei mit dem untenstehenden Befehl übernommen.

ls -lt

kubectl config set-cluster $(kubectl config view -o jsonpath='{.clusters[0].name}') --server=$(kubectl config view -o jsonpath='{.clusters[0].cluster.server}') --certificate-authority=k8s-ca.crt --kubeconfig=bob-k8s-config --embed-certs

ls -lt

cat bob-k8s-config

Richten Sie den Benutzer ein, der Bobs Schlüssel und Zert in die Konfigurationsdatei importieren wird.

ls -lt

kubectl config set-credentials bob --client-certificate=bob-k8s-access.crt --client-key=bob-k8s.key --embed-certs --kubeconfig=bob-k8s-config

ls -lt

cat bob-k8s-config

Erstellen Sie einen Kontext für die Konfigurationsdatei „Bob’s“ mit dem folgenden Befehl.

ls -lt

kubectl config set-context bob --cluster=$(kubectl config view -o jsonpath='{.clusters[0].name}') --namespace=bob --user=bob --kubeconfig=bob-k8s-config

ls -lt

cat bob-k8s-config

Erstellen Sie einen Namensraum für Bob

kubectl  get ns

kubectl create ns bob

kubectl  get ns -o wide

kubectl label ns bob user=bob env=sandbox

kubectl  get ns -o wide

Geben Sie den Kontext an, den Bob für seine kubectl-Befehle verwenden wird.

cat bob-k8s-config

kubectl config use-context bob --kubeconfig=bob-k8s-config

cat bob-k8s-config

Kopieren Sie „bob-k8s-config“ vom Master-Knoten in die Datei „.kube/config“ in Bobs Home-Verzeichnis und testen Sie Bobs kubeconfig, indem Sie die ‚kubectl-Version‘ ausführen.

vim .kube/config #All the output of "cat bob-k8s-config" command ran on the master node and save it to /home/bob/.kube/config on the user machine.

kubectl version #Execute this on the user machine

Testen Sie Berechtigungen, indem Sie die folgenden Befehle vom Benutzerrechner aus ausführen.

kubectl  get nodes

kubectl  get pods

kubectl  get ns

kubectl  get deployments

kubectl  get all

Im obigen Screenshot sehen Sie, dass der Benutzer „Bob“ keine Operation ausführen kann, da er keinen Zugriff darauf erhalten hat.

Weisen Sie Bob die Standard-Clusterrolle „admin“ zu, um die meisten Typen von Kubernetes-Objekten in seinem Namensraum zu erstellen. Diese Rolle „bob-admin“ wird dem Benutzer „Bob“ im Namensraum „bob“ unter Verwendung der ClusterRolle „admin“ Admin-Zugriff gewähren.

Ausführen des folgenden Befehls auf dem Master-Knoten.

kubectl create rolebinding bob-admin --namespace=bob --clusterrole=admin --user=bob

kubectl  get rolebinding

kubectl  get clusterrole | grep  admin

Holen Sie die erstellten Namespaces an Bob.

Führen Sie nun alle folgenden Befehle von der Benutzermaschine aus.

kubectl  get ns

kubectl  get ns bob

Im obigen Screenshot sehen Sie, dass der Benutzer „Bob“ nicht in der Lage ist, „Namespace“-Ressourcen aufzulisten.

Erstellen Sie einen Pod im „bob“-Namensraum, der in Bobs kubeconfig-Datei als Standard-Namensraum festgelegt ist.

kubectl  run nginx --image=nginx

kubectl  get pods

kubectl  get pods -o wide

Überprüfen Sie den aktuellen Namensraum, der als Standard-Namensraum eingestellt ist.

kubectl config get-contexts

Im obigen Bildschirmfoto sehen Sie, dass „Bob“ in der Lage ist, einen Pod im Namensraum „bob“ zu erstellen, da wir die Rolle „admin“ an den Benutzer „Bob“ für den Namensraum „bob“ gebunden haben.

Versuchen Sie, einen Pod in einem „Standard“-Namensraum zu erstellen, in dem Bob keine Berechtigungen hat. Da wir dem Benutzer „Bob“ erlaubt haben, Objekte nur im Namensraum „bob“ zu erstellen, wird der Benutzer „Bob“ keine Ressourcen in einem anderen Namensraum als „bob“ erstellen können.

kubectl  run nginx-2 --image=nginx --namespace=default

Überprüfen Sie den in der kubeconfig-Datei als Standardnamensraum eingestellten Namensraum. Dies zeigt, dass der „bob“-Namensraum als Standard-Namensraum in der Konfigurationsdatei festgelegt ist.

kubectl config view --minify | grep namespace:

Zusammenfassung der Erstellung der Kubeconfig-Datei

1. Erstellen Sie eine Schlüssel- und Zertifikatssignierungsanforderung (CSR) mit openssl.
2. Erstellen Sie eine CertificateSigningRequest-Objektdefinitionsdatei.
3. Erstellen Sie ein CertificateSigningRequest-Objekt.
4. Genehmigen Sie die CSR (CertificateSigningRequest).
5. das Zertifikat des CSR-Objekts abzurufen.
6. das Cluster-CA-Zertifikat abzurufen.
7. Richten Sie die Cluster-Konfiguration in der Datei kubeconfig ein.
8. Richten Sie den Benutzer ein.
9. Erstellen Sie einen Kontext.
10. Erstellen Sie einen Namensraum für den Benutzer.
11. Geben Sie den Kontext in der kubeconfig-Datei an.
12. Geben Sie die kubeconfig-Datei an den Benutzer weiter.
13. Testen Sie die Berechtigungen mithilfe der Konfigurationsdatei des Benutzers
14. Weisen Sie dem Benutzer die Rolle zu
15. Testen Sie die Berechtigungen erneut anhand der Konfigurationsdatei des Benutzers.

Schlussfolgerung

In diesem Artikel sahen wir die Grundlagen von Role, RoleBinding und ClusterRole, ClusterRoleBinding, wir haben diese Objekte auch in unserem Cluster erstellt. Wir haben dann eine Konfigurationsdatei erstellt, die es einem bestimmten Benutzer erlaubt, Operationen in einem bestimmten Namensraum durchzuführen. Wir haben gesehen, wie RBAC uns helfen kann, den Zugriff auf den Kubernetes-Cluster einzuschränken.