Contrôle d’accès basé sur les rôles (RBAC) dans Kubernetes

Le contrôle d’accès basé sur les rôles (RBAC) est utilisé pour attribuer l’accès à un ordinateur ou à des ressources réseau dans le cluster Kubernetes.

Dans cet article, nous allons comprendre les bases du RBAC et créer des objets Role, ClusterRole, RoleBinding et ClusterRoleBinding.

Nous créerons ensuite un fichier kubeconfig pour donner un accès limité à un utilisateur particulier sur un espace de noms sélectionné.

Mais avant de continuer, comprenons d’abord les bases.

  1. Un Role ou ClusterRole contient un ensemble de permissions.
  2. Un Rôle définit les permissions dans un espace de noms particulier et un ClusterRole est une ressource sans espace de noms.
  3. Un RoleBinding accorde les permissions définies dans un rôle à un utilisateur ou à un ensemble d’utilisateurs, tandis que le ClusterRoleBinding accorde cet accès à l’échelle du cluster.
  4. Un RoleBinding peut faire référence à n’importe quel Role dans le même espace de noms. Sinon, un RoleBinding peut faire référence à un ClusterRole et lier ce ClusterRole à l’espace de nom du RoleBindin.
  5. Un fichier kubeconfig est un fichier utilisé pour configurer l’accès à Kubernetes à partir de l’outil de ligne de commande kubectl.

Pour comprendre RBAC en détail, visite la documentation officielle de Kubernetes ici.

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

Pré-requis

  1. Cluster Kubernetes avec au moins 1 nœud de travail.
    Si tu veux apprendre à créer un Cluster Kubernetes, cliqueici. Ce guide t’aidera à créer un cluster Kubernetes avec 1 Maître et 2 Nœuds sur des Instances EC2 AWS Ubuntu 18.04.

Que ferons-nous ?

  1. Créer des fichiers d’objets Role, Role Binding, Cluster Role, Cluster Role Binding.
  2. Créer des objets Role, Role Binding, Cluster Role, Cluster Role Binding dans le cluster.
  3. Donne accès aux utilisateurs à l’aide du fichier kubeconfig.
  4. Résumé de la création du fichier kubeconfig.

Créer des fichiers d’objets Role, Role Binding, Cluster Role, Cluster Role Binding.

Crée un fichier pour créer un Rôle dans l’espace de noms « default » qui peut être utilisé pour accorder l’accès get, watch et list aux pods.

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

mon-rôle

Crée un nouveau fichier pour créer un RoleBinding qui permet d’attribuer le rôle « pod-reader » à l’utilisateur « jane » dans l’espace de noms « default ».

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

mon-role-liaison

Crée un fichier pour créer un ClusterRole qui peut être utilisé pour accorder l’accès get, watch et list aux secrets dans un espace de noms particulier, ou dans tous les espaces de noms selon la façon dont il est lié.

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

my-cluster-role

Crée un nouveau fichier pour créer un ClusterRoleBinding qui permettra à tout utilisateur du groupe « manager » de lire les secrets dans n’importe quel espace de noms.

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

mon-cluster-role-binding

Crée un objet Rôle, Role Binding, Cluster Role, Cluster Role Binding.

Obtiens une liste des Roles et ClusterRoles existants du cluster.

kubectl  get roles
kubectl  get clusterroles

get-default-role-clusterrole

Récupère une liste des RoleBindings et ClusterRoleBindings existants dans le cluster.

kubectl  get rolebinding
kubectl  get clusterrolebinding

get-default-role-binding-clusterrole-binding

Crée maintenant un Rôle, un RoleBinding et un ClusterRoleBinding en utilisant les fichiers que nous avons créés dans les étapes précédentes.

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

create-role-and-binding-objects

À l’aide des commandes suivantes, vérifie si les objets ont été créés.

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

Dans la capture d’écran ci-dessus, tu peux voir que le Role, RoleBinding et le ClusterRole, ClusterRoleBinding ont été créés.

Donne accès aux utilisateurs à l’aide du fichier kubeconfig(config).

Maintenant, dans cette section, nous allons créer un fichier de configuration qui peut être partagé avec un utilisateur. Ici, pour tester ce scénario, nous allons créer un utilisateur « bob » sur le serveur Linux et partager ce fichier de configuration avec l’utilisateur « bob ». Nous allons ensuite essayer d’effectuer des opérations qui sont autorisées et interdites à cet utilisateur. Nous lierons un ClusterRole admin à l’utilisateur « bob », ce qui lui donnera accès à tous les objets de l’espace de noms « bob ».

Sur les nœuds maîtres, crée une clé et une demande de signature de certificat (CSR) en utilisant 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'

Crée un fichier de définition d’objet CertificateSigningRequest contenant la CSR que nous avons générée à l’étape précédente. Dans le fichier ci-dessous, ajoute la sortie de la commande « cat bob-k8s.csr | base64 | tr -d ‘\n' » à la propriété « request ».

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

Créer un fichier d'objets de signature de certificats et de clés

Crée un objet CertificateSigningRequest dans Kubernetes contenant la RSC que nous avons générée à l’étape ci-dessus.

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

Nous voulons maintenant approuver l’objet CSR (CertificateSigningRequest) que nous avons créé à l’étape précédente.

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

approuver la demande de signature de certificat

Dans la capture d’écran ci-dessus, tu peux voir que le CSR a été approuvé et émis.

Récupère le certificat disponible dans le champ ‘status.certificate’ de l’objet CSR.

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

Récupérer le certificat

Récupère le certificat CA du cluster qui est la prochaine exigence pour le fichier kubeconfig de Bob et enregistre-le dans le fichier « 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

Configure le cluster dans le fichier kubeconfig de Bob. Tous ces détails seront mis à partir de notre kubeconfig existant à l’aide de la commande ci-dessous.

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

Installer la configuration du cluster pour Bob

Configure l’utilisateur qui importera la clé et le cert de Bob dans le fichier de configuration.

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

Configuration de l'utilisateur-bob

Crée un contexte pour le fichier de configuration de « Bob » à l’aide de la commande suivante.

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

mettre en place le contexte pour la configuration de Bob

Crée un espace de nom pour 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

créer un espace-nom et l'étiqueter

Spécifie le contexte que Bob utilisera pour ses commandes kubectl.

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

set-current-context

Copie le fichier « bob-k8s-config » du nœud maître dans le fichier « .kube/config » du répertoire personnel de Bob et teste la kubeconfig de Bob en exécutant la ‘version kubectl’.

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

Partager le fichier de configuration avec l'utilisateur Bob

Teste les permissions en exécutant les commandes suivantes depuis la machine de l’utilisateur.

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

bob-does-not-have-permissions-yet

Dans la capture d’écran ci-dessus, tu peux voir que l’utilisateur « Bob » ne peut effectuer aucune opération car aucun accès ne lui a été accordé.

Attribue le rôle de cluster ‘admin’ par défaut à Bob pour créer la plupart des types d’objets Kubernetes dans son espace de noms. Ce rôle « bob-admin » donnera un accès admin à l’utilisateur « Bob » sur l’espace de noms « bob » en utilisant le ClusterRole « admin ».

Exécute la commande suivante sur le nœud maître.

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

create-rolebinding-with-admin-clusterrole-for-bob-namespace-only

Obtiens les espaces de noms créés pour Bob.

Maintenant, exécute toutes les commandes suivantes depuis la machine de l’utilisateur.

kubectl  get ns
kubectl  get ns bob

validate-access-on-bob-namespace

Dans la capture d’écran ci-dessus, tu peux voir que l’utilisateur « Bob » est incapable de répertorier les ressources « namespace ».

Crée un Pod dans l’espace de noms « bob » défini comme l’espace de noms par défaut dans le fichier kubeconfig de Bob.

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

Vérifie l’espace de noms actuel défini comme l’espace de noms par défaut.

kubectl config get-contexts

create-pod-in-allowed-namespace

Dans la capture d’écran ci-dessus, tu peux voir que « Bob » est capable de créer un Pod dans l’espace de noms « bob » car nous avons lié le rôle « admin » à l’utilisateur « Bob » pour l’espace de noms « bob ».

Essaie de créer un pod dans un espace de nom « default » sur lequel « Bob » n’a aucune autorisation. Comme nous avons autorisé l’utilisateur « Bob » à créer des objets uniquement dans l’espace de noms « bob », l’utilisateur Bob ne pourra pas créer de ressources dans un autre espace de noms que « bob ».

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

pod-creation-fails-in-other-namespace

Vérifie l’espace de noms défini comme espace de noms par défaut dans le fichier kubeconfig. Cela montre que l’espace de noms « bob » est défini comme espace de noms par défaut dans le fichier de configuration.

kubectl config view --minify | grep namespace:

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

Résumé de la création du fichier Kubeconfig

  1. Crée une clé et une demande de signature de certificat (CSR) en utilisant openssl.
  2. Crée un fichier de définition d’objet CertificateSigningRequest.
  3. Crée un objet CertificateSigningRequest.
  4. Approuve la CSR (CertificateSigningRequest).
  5. Récupère le certificat de l’objet CSR.
  6. Récupère le certificat de l’AC du cluster.
  7. Configurer le cluster dans le fichier kubeconfig.
  8. Configurer l’utilisateur.
  9. Créer un contexte.
  10. Crée un espace de nom pour l’utilisateur.
  11. Spécifie le contexte dans le fichier kubeconfig.
  12. Transmets le fichier kubeconfig à l’utilisateur.
  13. Teste les autorisations à l’aide du fichier de configuration de l’utilisateur.
  14. Attribue le rôle à l’utilisateur
  15. Teste à nouveau les autorisations à l’aide du fichier de configuration de l’utilisateur.

Conclusion

Dans cet article, nous avons vu les bases de Role, RoleBinding et ClusterRole, ClusterRoleBinding, nous avons également créé ces objets dans notre cluster. Nous avons ensuite créé un fichier de configuration qui permet à un utilisateur particulier d’effectuer des opérations dans un espace de nom particulier. Nous avons vu comment RBAC peut nous aider à restreindre l’accès au cluster Kubernetes.

Vous aimerez aussi...