Aller au contenu principal

Lab 9.1 - Création de Roles et RoleBindings

Objectifs du Lab​

À la fin de ce lab, vous serez capable de:

  • Comprendre le concept de RBAC dans Kubernetes.
  • Créer un Role avec des permissions spécifiques.
  • Créer un RoleBinding pour lier un utilisateur à un Role.
  • Tester les permissions avec kubectl auth can-i.
  • Comprendre la différence entre Role et ClusterRole.

Durée Estimée​

45-60 minutes

Prérequis​

  • kubectl installé et configuré.
  • Cluster Kubernetes local fonctionnel.
  • Connaissances sur RBAC (Chapitre 9.1).

Partie 1: Comprendre RBAC​

RBAC (Role-Based Access Control) permet de contrôler qui peut faire quoi dans Kubernetes.

Concepts:​

  • Role: Définit des permissions dans un namespace.
  • ClusterRole: Définit des permissions au niveau du cluster.
  • RoleBinding: Lie un utilisateur/groupe/ServiceAccount à un Role (dans un namespace).
  • ClusterRoleBinding: Lie un utilisateur/groupe/ServiceAccount à un ClusterRole (cluster-wide).

Partie 2: Création d'un Role​

Nous allons créer un Role qui permet de lire et créer des Pods dans un namespace.

Étape 2.1: Créer un Namespace de Test​

Créez un namespace pour le test:

kubectl create namespace rbac-test

Étape 2.2: Créer un Role​

Créez role-pod-manager.yaml:

apiVersion: rbac.authorization.k8s.io/v1
kind: Role
metadata:
  namespace: rbac-test
  name: pod-manager
rules:
- apiGroups: [""] # Groupe API core (v1)
  resources: ["pods"]
  verbs: ["get", "list", "watch", "create", "update", "patch", "delete"]
- apiGroups: [""]
  resources: ["pods/status"]
  verbs: ["get"]

Explication:

  • apiGroups: [""]: Groupe API core (ressources comme Pods, Services, etc.).
  • resources: ["pods"]: Ressource sur laquelle les permissions s'appliquent.
  • verbs: Actions autorisées (get, list, watch, create, update, patch, delete).

Appliquez le Role:

kubectl apply -f role-pod-manager.yaml

Vérifiez:

kubectl get role -n rbac-test
kubectl describe role pod-manager -n rbac-test

Partie 3: Création d'un RoleBinding​

Nous allons créer un RoleBinding qui lie un ServiceAccount au Role.

Étape 3.1: Créer un ServiceAccount​

Créez un ServiceAccount:

kubectl create serviceaccount pod-manager-sa -n rbac-test

Étape 3.2: Créer le RoleBinding​

Créez rolebinding-pod-manager.yaml:

apiVersion: rbac.authorization.k8s.io/v1
kind: RoleBinding
metadata:
  name: pod-manager-binding
  namespace: rbac-test
subjects:
- kind: ServiceAccount
  name: pod-manager-sa
  namespace: rbac-test
roleRef:
  kind: Role
  name: pod-manager
  apiGroup: rbac.authorization.k8s.io

Explication:

  • subjects: À qui les permissions sont accordées (ServiceAccount, User, Group).
  • roleRef: Référence au Role (ou ClusterRole) à utiliser.

Appliquez le RoleBinding:

kubectl apply -f rolebinding-pod-manager.yaml

Vérifiez:

kubectl get rolebinding -n rbac-test
kubectl describe rolebinding pod-manager-binding -n rbac-test

Partie 4: Test des Permissions​

Étape 4.1: Obtenir le Token du ServiceAccount​

Pour tester les permissions, nous devons utiliser le token du ServiceAccount:

# Obtenir le nom du Secret du ServiceAccount
SECRET_NAME=$(kubectl get serviceaccount pod-manager-sa -n rbac-test -o jsonpath='{.secrets[0].name}')

# Extraire le token
TOKEN=$(kubectl get secret $SECRET_NAME -n rbac-test -o jsonpath='{.data.token}' | base64 -d)

# Obtenir le certificat CA
CA_CERT=$(kubectl get secret $SECRET_NAME -n rbac-test -o jsonpath='{.data.ca\.crt}')

Étape 4.2: Tester avec kubectl auth can-i​

Testez les permissions avec votre contexte actuel (admin):

# Vérifier si vous pouvez créer des Pods
kubectl auth can-i create pods --namespace=rbac-test

# Vérifier si vous pouvez supprimer des Pods
kubectl auth can-i delete pods --namespace=rbac-test

# Vérifier si vous pouvez lister les Services (devrait être non)
kubectl auth can-i list services --namespace=rbac-test

Étape 4.3: Tester avec le ServiceAccount​

Créez un Pod qui utilise le ServiceAccount:

apiVersion: v1
kind: Pod
metadata:
  name: test-pod
  namespace: rbac-test
spec:
  serviceAccountName: pod-manager-sa
  containers:
  - name: test
    image: bitnami/kubectl:latest
    command: ["sleep", "3600"]

Appliquez le Pod:

kubectl apply -f test-pod.yaml

Exécutez des commandes dans le Pod pour tester les permissions:

# Tester la création d'un Pod (devrait fonctionner)
kubectl exec -n rbac-test test-pod -- kubectl create pod test-pod-2 --image=busybox --dry-run=client -o yaml

# Tester la liste des Pods (devrait fonctionner)
kubectl exec -n rbac-test test-pod -- kubectl get pods

# Tester la liste des Services (devrait échouer)
kubectl exec -n rbac-test test-pod -- kubectl get services

Partie 5: Création d'un ClusterRole​

Un ClusterRole s'applique au niveau du cluster entier.

Étape 5.1: Créer un ClusterRole​

Créez clusterrole-node-viewer.yaml:

apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRole
metadata:
  name: node-viewer
rules:
- apiGroups: [""]
  resources: ["nodes"]
  verbs: ["get", "list", "watch"]

Appliquez le ClusterRole:

kubectl apply -f clusterrole-node-viewer.yaml

Partie 6: Nettoyage​

Supprimez les ressources créées:

kubectl delete pod test-pod -n rbac-test
kubectl delete rolebinding pod-manager-binding -n rbac-test
kubectl delete role pod-manager -n rbac-test
kubectl delete serviceaccount pod-manager-sa -n rbac-test
kubectl delete clusterrole node-viewer
kubectl delete namespace rbac-test

Résumé du Lab​

Dans ce lab, vous avez créé des Roles et RoleBindings pour implémenter RBAC. Vous avez appris à définir des permissions avec des Roles, à lier des utilisateurs/ServiceAccounts avec des RoleBindings, et à tester les permissions.

Prochaines Étapes​

Le prochain lab vous montrera comment utiliser les Service Accounts et leurs permissions dans les Pods.

Lab 9.2: Service Accounts et Permissions

Lab créé le: Décembre 2024