Rolgebaseerde toegangscontrole (RBAC) in Kubernetes

Rolgebaseerde toegangscontrole (RBAC) wordt gebruikt om toegang toe te wijzen tot een computer of netwerk middelen in de Kubernetes Cluster.

In dit artikel zullen we de basisprincipes van RBAC begrijpen en Role, ClusterRole, RoleBinding en ClusterRoleBinding Objecten maken.

We zullen dan een kubeconfig bestand maken om beperkte toegang te geven aan een bepaalde gebruiker op een geselecteerde namespace.

Maar voor we verder gaan laten we eerst de basis begrijpen.

  1. Een Role of ClusterRole bevat een set rechten.
  2. Een Role stelt permissies in binnen een bepaalde namespace en ClusterRole is een niet-namespaced resource.
  3. Een rolbinding verleent de in een rol gedefinieerde permissies aan een gebruiker of een groep gebruikers, terwijl een ClusterRoleBinding die toegang clusterbreed verleent
  4. Een RolBinding kan verwijzen naar elke Rol in dezelfde namespace. Als alternatief kan een RoleBinding verwijzen naar een ClusterRole en die ClusterRole binden aan de namespace van de RoleBindingin
  5. Een kubeconfig bestand is een bestand dat gebruikt wordt om toegang tot Kubernetes te configureren vanuit het kubectl command-line gereedschap.

Om RBAC in detail te begrijpen, bezoek je de officiƫle documentatie van Kubernetes hier.

Note: Refer screenshots to avoid any confusion before executing the commands. ( [email protected] = master node and [email protected] = user machine)

Vereisten

  1. Kubernetes Cluster met minstens 1 worker node.
    Als je wilt leren hoe je een Kubernetes Cluster maakt, klik danhier. Deze gids helpt je een Kubernetes cluster te maken met 1 Master en 2 Nodes op AWS Ubuntu 18.04 EC2 Instances.

Wat zullen we doen?

  1. Maak Role, Role Binding, Cluster Role, Cluster Role Binding object bestanden.
  2. Maak Role, Role Binding, Cluster Role, Cluster Role Binding objecten in het cluster.
  3. Geef toegang aan gebruikers met behulp van het kubeconfig bestand.
  4. Samenvatting van het maken van een kubeconfig bestand.

Maak een Role, Role Binding, Cluster Role, Cluster Role Binding object bestanden.

Maak een bestand om in de “standaard” naamruimte een Role aan te maken die gebruikt kan worden om toegang tot pods te krijgen, te kijken en te lijsten.

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"]

my-role

Maak een nieuw bestand om een RoleBinding te maken die de “pod-reader” Rol toestaat aan de gebruiker “jane” binnen de “default” namespace.

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

mijn-rol-binding

Maak een bestand om een ClusterRole te maken die gebruikt kan worden om toegang te krijgen, te kijken en te lijsten tot geheimen in een bepaalde namespace, of over alle namespaces, afhankelijk van hoe hij gebonden is.

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"]

mijn-cluster-rol

Maak een nieuw bestand om een ClusterRoleBinding te maken waarmee elke gebruiker in de groep “manager” geheimen kan lezen in elke willekeurige namespace.

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

mijn-cluster-rol-binding

Maak een object Role, Role Binding, Cluster Role, Cluster Role Binding.

Verkrijg een lijst van bestaande Rollen en ClusterRollen uit het cluster.

kubectl  get roles
kubectl  get clusterroles

get-default-role-clusterrole

Haal een lijst van bestaande RoleBindingen en ClusterRoleBindingen op uit het cluster.

kubectl  get rolebinding
kubectl  get clusterrolebinding

get-default-rol-binding-clusterrol-binding

Maak nu een Role, RoleBinding en ClusterRole ClusterRoleBinding met behulp van de bestanden die we in de bovenstaande stappen maakten.

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

creëer-rol-en-binding-objecten

Controleer met de volgende commando’s of de objecten zijn aangemaakt.

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

get-role-and-binding-objects

In de bovenstaande schermafbeelding kun je zien dat de Role, RoleBinding en ClusterRole, ClusterRoleBinding zijn aangemaakt.

Geef toegang aan gebruikers met het kubeconfig(config) bestand.

Nu, in dit onderdeel, zullen we een config bestand maken dat met een gebruiker gedeeld kan worden. Om dit scenario te testen maken we hier op de Linux server een gebruiker “bob” aan en delen dit config bestand met de gebruiker “bob”. We zullen dan proberen bewerkingen uit te voeren die aan die gebruiker wel en niet zijn toegestaan. We binden een admin ClusterRole aan de “bob” gebruiker die toegang geeft op alle objecten binnen de “bob” namespace.

Maak op de master-nodes een sleutel en een certificate signing request (CSR) met 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'

Maak een objectdefinitiebestand CertificateSigningRequest met daarin het CSR dat we in de bovenstaande stap gegenereerd hebben. Voeg in het onderstaande bestand de uitvoer van “cat bob-k8s.csr | base64 | tr -d ‘\n'” commando toe aan “request” eigenschap.

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

maak-sleutel-en-schep-certificaat-teken-request-object-bestand

Maak binnen Kubernetes een CertificateSigningRequest object aan met daarin het CSR dat we in de bovenstaande stap gegenereerd hebben.

kubectl  get csr
kubectl  create -f k8s-csr.yaml
kubectl  get csr

Nu willen we het CSR (CertificateSigningRequest) object dat we in de bovenstaande stap maakten goedkeuren.

kubectl  get csr
kubectl certificate approve bob-k8s-access
kubectl  get csr

goedkeuren-certificaat-tekeningsverzoek

In de bovenstaande schermafbeelding zie je dat het CSR is goedgekeurd, uitgegeven.

Haal het certificaat op dat beschikbaar is in het veld ‘status.certificaat’ van het CSR object.

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

haal-de-certificaat op

Haal het cluster CA certificaat op dat de volgende vereiste is voor Bob’s kubeconfig bestand en sla het op in het bestand “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

get-cluster-CA-certificate

Zet de cluster configuratie op in Bob’s kubeconfig bestand. Al deze gegevens worden uit onze bestaande kubeconfig gezet met het onderstaande commando.

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

stel-de-cluster-configuratie-voor-bob in

Stel de gebruiker in die Bob’s sleutel en cert in het config bestand zal importeren.

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

set-up-de-gebruiker-bob-configuratie

Maak een context voor “Bob’s” config bestand met het volgende commando.

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

installeer-de-contex-voor-bob-configuratie

Maak een namespace voor 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

maak-een-naamruimte-en-label-it

Specificeer de context die Bob zal gebruiken voor zijn kubectl commando’s.

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

set-current-context

Kopieer “bob-k8s-config” van de master node naar het “.kube/config” bestand in Bob’s thuismap en test Bob’s kubeconfig door de ‘kubectl versie’ uit te voeren.

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

deel-de-config-file-met-bob-gebruiker

Test de toestemmingen door de volgende commando’s uit te voeren vanaf de gebruikersmachine.

kubectl  get nodes
kubectl  get pods
kubectl  get ns
kubectl  get deployments
kubectl  get all

bob-heeft-nog-geen-permissies-net

In de bovenstaande schermafbeelding zie je dat de gebruiker “Bob” geen enkele bewerking kan uitvoeren omdat hem geen toegang gegeven is.

Ken de standaard ‘admin’ clusterrol aan Bob toe om de meeste soorten Kubernetes objecten binnen zijn namespace te kunnen maken. Deze rol “bob-admin” zal admin toegang geven aan “Bob” gebruiker op “bob” namespace met behulp van “admin” ClusterRole.

Voer het volgende commando uit op de master node.

kubectl create rolebinding bob-admin --namespace=bob --clusterrole=admin --user=bob 
kubectl  get rolebinding
kubectl  get clusterrole | grep  admin

creëer-rolbinding-met-admin-clusterrol-voor-bob-namespace-only

Krijg namespaces aangemaakt aan Bob.

Voer nu alle volgende commando’s uit vanaf de gebruikersmachine.

kubectl  get ns
kubectl  get ns bob

valideer-toegang-op-bob-namespace

In de bovenstaande schermafbeelding zie je dat de gebruiker “Bob” niet in staat is de “namespace” bronnen op te sommen.

Maak een Pod in “bob” namespace, ingesteld als de standaard namespace in Bob’s kubeconfig bestand.

kubectl  run nginx --image=nginx
kubectl  get pods
kubectl  get pods -o wide

Controleer de huidige namespace die als standaard namespace is ingesteld

kubectl config get-contexts

creëer-pod-in-toegestane-namespace

In de bovenstaande schermafbeelding zie je dat “Bob” een Pod kan maken in “bob” namespace omdat we de rol “admin” aan “Bob” gebruiker gebonden hebben voor “bob” namespace.

Probeer een pod te maken in een “standaard” namespace waarop Bob geen rechten heeft. Omdat we de gebruiker “Bob” alleen toestemming gegeven hebben om objecten te maken in de “bob” naamruimte, zal de gebruiker Bob geen van de middelen kunnen maken in een andere naamruimte dan “bob”.

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

pod-creatie-fouten-in-andere-namespace

Controleer de namespace die als standaard namespace is ingesteld in het kubeconfig bestand. Hieruit blijkt dat de “bob” namespace als standaard namespace is ingesteld in het config bestand.

kubectl config view --minify | grep namespace:

check-current-namespace-set-as-default-namespace-in-config-bestand

Samenvatting van het aanmaken van het kubeconfig bestand

  1. Maak een sleutel en een certificate signing request (CSR) met openssl.
  2. Maak een CertificateSigningRequest object definitie bestand.
  3. Maak een CertificateSigningRequest object.
  4. Goedkeur het CSR (CertificateSigningRequest).
  5. Haal het certificaat van het CSR object op.
  6. Haal het certificaat van de cluster CA op.
  7. Stel de clusterconfiguratie in kubeconfig bestand in.
  8. Stel de gebruiker in.
  9. Maak een context aan.
  10. Maak een namespace voor de gebruiker.
  11. Specificeer de context in het kubeconfig bestand.
  12. Geef de kubeconfig aan de gebruiker door.
  13. Test de machtigingen met behulp van het config-bestand van de gebruiker.
  14. Wijs de rol toe aan de gebruiker
  15. Test de permissies opnieuw met behulp van het config bestand van de gebruiker.

Conclusie

In dit artikel zagen we de basisprincipes van Role, RoleBinding en ClusterRole, ClusterRoleBinding, we maakten deze objecten ook aan in ons cluster. Daarna maakten we een config bestand dat een bepaalde gebruiker toestaat bewerkingen uit te voeren in een bepaalde namespace. We zagen hoe RBAC ons kan helpen de toegang tot het Kubernetes cluster te beperken.