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

Introduction

Dans un cluster Kubernetes, le contrôle d'accès basé sur les rôles (Role-Based Access Control, RBAC) est utilisé pour contrôler l'accès aux ressources et aux opérations au sein du cluster. Le RBAC permet aux administrateurs de cluster de définir des rôles et des autorisations pour les utilisateurs, les groupes et les comptes de service afin de contrôler l'accès aux ressources et aux opérations au sein du cluster. Dans ce labo (LabEx), vous apprendrez à utiliser le RBAC pour contrôler l'accès aux ressources dans un cluster Kubernetes.

Démarrer le cluster Minikube

Avant de créer des ressources, vous avez besoin d'un cluster Kubernetes en cours d'exécution. Minikube est un environnement Kubernetes léger qui s'exécute sur votre machine locale.

1. Accédez à votre répertoire de travail :

   Ouvrez le terminal et accédez au dossier de projet par défaut :

   cd /home/labex/project

2. Démarrez Minikube :

   Démarrez Minikube pour initialiser un cluster Kubernetes :

   minikube start

   • Cette commande configure un cluster Kubernetes mono - nœud sur votre machine locale.
   • Minikube peut prendre quelques minutes à démarrer en fonction des performances de votre système.

3. Vérifiez que Minikube est en cours d'exécution :

   Vérifiez l'état du cluster Minikube :

   minikube status

   • Recherchez des composants tels que kubelet et apiserver listés comme Running (en cours d'exécution).
   • Si le cluster n'est pas en cours d'exécution, relancez la commande minikube start.

Si vous rencontrez des problèmes lors du démarrage de Minikube, utilisez minikube delete pour réinitialiser l'environnement si nécessaire.

Créer un espace de noms (Namespace)

Créez un nouvel espace de noms appelé myapp en utilisant la commande suivante :

kubectl create namespace myapp

Créer un Rôle (Role)

Créez un nouveau rôle appelé myapp-reader dans l'espace de noms (namespace) myapp qui permet aux utilisateurs de lire les pods et les services dans cet espace de noms en utilisant le fichier YAML suivant appelé myapp-reader-role.yaml :

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

Ce rôle permet aux utilisateurs de lire (obtenir, surveiller et lister) les pods et les services dans l'espace de noms myapp.

Créez le rôle en utilisant la commande suivante :

kubectl apply -f myapp-reader-role.yaml

Créer une liaison de rôle (Role Binding)

Créez une liaison de rôle qui lie le rôle (Role) myapp-reader à un utilisateur ou un groupe dans l'espace de noms (namespace) myapp. Par exemple, pour lier le rôle myapp-reader à l'utilisateur developer dans l'espace de noms myapp, créez le fichier YAML suivant appelé myapp-reader-binding.yaml :

kind: RoleBinding
apiVersion: rbac.authorization.k8s.io/v1
metadata:
  name: myapp-reader-binding
  namespace: myapp
subjects:
  - kind: User
    name: developer
    apiGroup: rbac.authorization.k8s.io
roleRef:
  kind: Role
  name: myapp-reader
  apiGroup: rbac.authorization.k8s.io

Cette liaison de rôle lie le rôle myapp-reader à l'utilisateur developer dans l'espace de noms myapp.

Créez la liaison de rôle en utilisant la commande suivante :

kubectl apply -f myapp-reader-binding.yaml

Tester l'accès

Testez l'accès à l'espace de noms (namespace) myapp en essayant d'obtenir la liste des pods dans cet espace de noms en utilisant la commande suivante :

kubectl get pods -n myapp --as developer

Vous devriez voir un message indiquant qu'il n'y a pas de ressources dans l'espace de noms myapp, car vous n'avez peut - être pas de pods dans votre cluster. Lorsque vous aurez terminé le laboratoire, en utilisant cette commande, vous devriez voir une liste de pods dans l'espace de noms myapp.

Testez l'accès à l'espace de noms default en essayant d'obtenir la liste des pods dans cet espace de noms en utilisant la commande suivante :

kubectl get pods --as developer

Vous devriez voir un message d'erreur indiquant que vous n'avez pas accès à l'espace de noms default.

Créer un rôle de cluster (ClusterRole)

Créez un nouveau rôle de cluster appelé myapp-admin qui permet aux utilisateurs de créer, supprimer et mettre à jour les pods et les services dans tous les espaces de noms (namespaces) en utilisant le fichier YAML suivant appelé myapp-admin-clusterrole.yaml :

kind: ClusterRole
apiVersion: rbac.authorization.k8s.io/v1
metadata:
  name: myapp-admin
rules:
  - apiGroups: [""]
    resources: ["pods", "services"]
    verbs: ["get", "list", "watch", "create", "update", "delete"]

Ce rôle de cluster permet aux utilisateurs d'effectuer toutes les opérations (obtenir, lister, surveiller, créer, mettre à jour et supprimer) sur les pods et les services dans tous les espaces de noms.

Créez le rôle de cluster en utilisant la commande suivante :

kubectl apply -f myapp-admin-clusterrole.yaml

Créer une liaison de rôle de cluster (ClusterRole Binding)

Créez une liaison de rôle de cluster qui lie le rôle de cluster (ClusterRole) myapp-admin à un utilisateur ou un groupe dans le cluster. Par exemple, pour lier le rôle de cluster myapp-admin à l'utilisateur cluster-admin, créez le fichier YAML suivant appelé myapp-admin-binding.yaml :

kind: ClusterRoleBinding
apiVersion: rbac.authorization.k8s.io/v1
metadata:
  name: myapp-admin-binding
subjects:
  - kind: User
    name: cluster-admin
    apiGroup: rbac.authorization.k8s.io
roleRef:
  kind: ClusterRole
  name: myapp-admin
  apiGroup: rbac.authorization.k8s.io

Cette liaison de rôle de cluster lie le rôle de cluster myapp-admin à l'utilisateur cluster-admin.

Créez la liaison de rôle de cluster en utilisant la commande suivante :

kubectl apply -f myapp-admin-binding.yaml

Tester l'accès

Testez l'accès pour créer un pod dans l'espace de noms (namespace) myapp en créant un pod en utilisant le fichier YAML suivant appelé myapp-pod.yaml :

apiVersion: v1
kind: Pod
metadata:
  name: myapp-pod
  namespace: myapp
spec:
  containers:
    - name: myapp-container
      image: nginx
      ports:
        - containerPort: 80

Créez le pod en utilisant la commande suivante :

kubectl apply -f myapp-pod.yaml --as cluster-admin

Vous devriez voir un message indiquant que le pod a été créé.

Testez l'accès pour créer un déploiement (deployment) dans l'espace de noms myapp en créant un déploiement en utilisant le fichier YAML suivant myapp-deployment.yaml :

apiVersion: apps/v1
kind: Deployment
metadata:
  name: myapp-deployment
  namespace: myapp
spec:
  replicas: 1
  selector:
    matchLabels:
      app: myapp-deployment
  template:
    metadata:
      labels:
        app: myapp-deployment
    spec:
      containers:
        - name: nginx
          image: nginx:latest
          ports:
            - containerPort: 80

Créez le pod en utilisant la commande suivante :

kubectl apply -f myapp-deployment.yaml --as cluster-admin

Vous devriez voir un message d'erreur indiquant que vous n'avez pas accès pour créer un déploiement dans l'espace de noms myapp.

Résumé

Dans ce laboratoire, vous avez appris à utiliser le contrôle d'accès basé sur les rôles (Role-Based Access Control - RBAC) dans Kubernetes pour contrôler l'accès aux ressources et aux opérations au sein du cluster. Vous avez créé un espace de noms (namespace), un rôle (Role) et une liaison de rôle (Role Binding) pour contrôler l'accès aux ressources dans un espace de noms spécifique. Vous avez également créé un rôle de cluster (ClusterRole) et une liaison de rôle de cluster (ClusterRole Binding) pour contrôler l'accès aux ressources dans tous les espaces de noms. À la fin de ce laboratoire, vous devriez bien comprendre comment utiliser le RBAC pour contrôler l'accès aux ressources et aux opérations dans un cluster Kubernetes.