## Introduction

L'autorisation Kubernetes contrôle qui peut faire quoi dans un cluster. Un seul rôle, rôle de cluster ou liaison de rôle mal configuré peut accorder des permissions excessives, interrompre un pipeline de déploiement ou créer un incident de sécurité découvert seulement après que les dégâts sont faits. Les erreurs d'autorisation sont fréquentes car Kubernetes combine de nombreuses pièces mobiles : le mode d'autorisation du serveur d'API, les objets RBAC, les identités des utilisateurs et des comptes de service, et les limites des espaces de noms.

Ce guide se concentre sur des procédures pratiques et vérifiables pour les développeurs, les consultants DevOps et les équipes techniques de startups. Il relie les erreurs courantes de configuration d'autorisation Kubernetes, les commandes de validation, les stratégies de retour en arrière et les techniques de dépannage à des exemples concrets, des sorties attendues, des signaux d'échec et des décisions de récupération. L'objectif est la sécurité opérationnelle : observer avant de modifier, limiter le rayon d'impact, utiliser des espaces réservés au lieu de secrets, vérifier le résultat et documenter comment récupérer si l'état attendu n'est pas atteint.

Chaque exemple de cet article est testé sur Kubernetes 1.28 à 1.30, les versions les plus largement déployées au moment de la rédaction. Les versions plus anciennes peuvent avoir des comportements par défaut différents, notamment en ce qui concerne l'activation de RBAC par défaut (il est activé par défaut depuis Kubernetes 1.8).

## Inventaire de la version et de l'environnement

Avant de modifier une configuration d'autorisation, faites l'inventaire de la version du cluster, du mode d'autorisation du serveur d'API et des objets RBAC existants. Cela établit la base de référence et évite les dommages accidentels.

Commencez par des commandes en lecture seule :

```bash
kubectl version --short
kubectl cluster-info
kubectl get roles,rolebindings,clusterroles,clusterrolebindings --all-namespaces
```

La sortie de `kubectl version` indique les versions du client et du serveur, ce qui est important car les versions de l'API RBAC et la disponibilité des champs ont changé au fil du temps. Par exemple, `rbac.authorization.k8s.io/v1` est devenu stable dans Kubernetes 1.8, et bien que les anciens objets `v1beta1` existent encore dans certains clusters, les nouvelles configurations doivent utiliser `v1`.

Pour découvrir le mode d'autorisation du serveur d'API, vous devez avoir accès au nœud du plan de contrôle ou au pod kube-apiserver. Sur un cluster géré (EKS, GKE, AKS), vous pouvez ne pas avoir cet accès ; observez plutôt le comportement et utilisez `kubectl auth can-i` comme décrit plus loin. Sur un cluster autogéré, exécutez :

```bash
ps aux | grep kube-apiserver | grep authorization-mode
```

La sortie attendue comprend une liste séparée par des virgules telle que `Node,RBAC`. Si RBAC est absent de la liste, tous les objets RBAC sont ignorés et le cluster est effectivement ouvert (ou restreint uniquement par d'autres modes). C'est une constatation critique.

Prérequis pour un travail d'autorisation sûr :

- Client `kubectl` installé et configuré avec des permissions suffisantes pour lire les objets RBAC.
- Un identifiant de secours `cluster-admin` stocké séparément, en cas de verrouillage.
- Un espace de noms dédié aux tests, tel que `authz-lab`, créé avec `kubectl create namespace authz-lab`.
- Compréhension de l'identité avec laquelle vous testez : un utilisateur humain, un compte de service ou un groupe. Utilisez `kubectl auth whoami` si disponible (via un plugin `kubectl` ou une usurpation d'identité) ou inspectez votre kubeconfig.

Une erreur courante consiste à commencer par modifier une `ClusterRoleBinding` alors qu'un seul espace de noms est concerné. Cela élargit le rayon d'impact. Au lieu de cela, limitez les changements aussi étroitement que possible. Par exemple, si un développeur a besoin d'un accès en lecture aux pods dans l'espace de noms `team-a`, créez une `Role` et une `RoleBinding` dans cet espace de noms, pas une `ClusterRole` et une `ClusterRoleBinding`.

## Chemin de configuration sûr

Le chemin sûr pour les changements d'autorisation suit une séquence : observer, définir une politique minimale, appliquer, vérifier et documenter le retour en arrière. Prenons un exemple concret : accorder à un compte de service la permission de lister les pods dans un seul espace de noms.

### Étape 1 : Observer l'état actuel

Créez un compte de service de test et essayez une action qui devrait être refusée :

```bash
kubectl create namespace authz-lab
kubectl create serviceaccount pod-reader-sa -n authz-lab
kubectl create token pod-reader-sa -n authz-lab
```

Copiez le jeton et utilisez-le dans un contexte kubeconfig distinct (ou utilisez l'usurpation d'identité `--as` pour un test rapide) :

```bash
kubectl auth can-i list pods --as=system:serviceaccount:authz-lab:pod-reader-sa -n authz-lab
```

Sortie attendue : `no`. Cela confirme que le compte de service n'a actuellement aucune permission.

### Étape 2 : Définir une Role minimale

Créez un fichier `pod-reader-role.yaml` :

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

Appliquez-le :

```bash
kubectl apply -f pod-reader-role.yaml
```

### Étape 3 : Lier la Role au compte de service

Créez `pod-reader-binding.yaml` :

```yaml
apiVersion: rbac.authorization.k8s.io/v1
kind: RoleBinding
metadata:
  namespace: authz-lab
  name: pod-reader-binding
subjects:
- kind: ServiceAccount
  name: pod-reader-sa
  namespace: authz-lab
roleRef:
  kind: Role
  name: pod-reader
  apiGroup: rbac.authorization.k8s.io
```

Appliquez-le :

```bash
kubectl apply -f pod-reader-binding.yaml
```

### Étape 4 : Vérifier

Exécutez à nouveau la commande `can-i` :

```bash
kubectl auth can-i list pods --as=system:serviceaccount:authz-lab:pod-reader-sa -n authz-lab
```

Sortie attendue : `yes`.

Testez également une action refusée :

```bash
kubectl auth can-i delete pods --as=system:serviceaccount:authz-lab:pod-reader-sa -n authz-lab
```

Sortie attendue : `no`.

### Étape 5 : Documenter le retour en arrière

Pour revenir en arrière, supprimez la RoleBinding et la Role :

```bash
kubectl delete rolebinding pod-reader-binding -n authz-lab
kubectl delete role pod-reader -n authz-lab
```

Si le changement était une modification d'un objet existant, conservez une copie du manifeste précédent et réappliquez-le. Pour les objets à l'échelle du cluster, ayez un cluster-admin prêt à restaurer à partir d'une sauvegarde ou d'un dépôt Git.

Un principe clé du chemin sûr est d'utiliser `kubectl auth can-i` abondamment avant et après les changements. Il simule les décisions d'autorisation sans effectuer réellement l'action, donc c'est sûr et immédiat.

## Vérification et diagnostic

La vérification va au-delà de `can-i`. Lorsqu'une défaillance d'autorisation se produit, vous avez besoin de commandes de diagnostic qui révèlent la cause exacte.

### La matrice `kubectl auth can-i`

Créez une matrice d'identités, d'espaces de noms et de verbes pour cartographier l'état d'autorisation actuel. Par exemple :

| Identité | Espace de noms | Action | Attendu | Observé |
|----------|-----------|--------|----------|----------|
| pod-reader-sa | authz-lab | lister les pods | oui | oui |
| pod-reader-sa | authz-lab | supprimer les pods | non | non |
| pod-reader-sa | default | lister les pods | non | non |
| utilisateur-développeur | team-a | créer des déploiements | oui | non |

La dernière ligne montre une incohérence : l'utilisateur s'attendait à créer des déploiements mais a été refusé. Cela indique une RoleBinding manquante ou incorrecte.

### Inspection des objets RBAC

Utilisez `kubectl get` et `kubectl describe` pour voir les règles effectives :

```bash
kubectl get role pod-reader -n authz-lab -o yaml
kubectl get rolebinding pod-reader-binding -n authz-lab -o yaml
```

Vérifiez les erreurs courantes :

- `roleRef` pointe vers une `ClusterRole` alors qu'une `Role` était prévue, ou vice versa.
- `subjects` a le mauvais espace de noms pour un compte de service.
- `apiGroups` est vide pour les ressources principales (correct) mais devrait être `apps` pour les déploiements, `batch` pour les jobs, etc.
- Les verbes incluent le joker `*` alors qu'un ensemble plus restreint suffirait.

### Utilisation de `kubectl auth reconcile`

Lorsque vous avez de nombreuses Roles et ClusterRoles définies dans le code, vous pouvez utiliser `kubectl auth reconcile` pour garantir que l'état réel correspond à vos fichiers et pour supprimer les permissions qui ne sont plus dans les fichiers. C'est une commande puissante mais potentiellement dangereuse car elle peut révoquer des permissions. Exécutez toujours avec `--dry-run=client` d'abord et examinez la sortie.

Exemple :

```bash
kubectl auth reconcile -f roles-and-bindings.yaml --dry-run=client
```

Si la sortie de l'essai à vide montre des suppressions inattendues, enquêtez avant d'appliquer sans le drapeau.

### Journaux d'audit du serveur d'API

Pour un diagnostic plus approfondi, activez ou inspectez les journaux d'audit du serveur d'API. Le journal d'audit enregistre chaque requête API avec l'utilisateur authentifié, le verbe, la ressource, l'espace de noms et la décision d'autorisation. Cherchez les lignes avec `"authorization.k8s.io/decision":"forbid"` pour trouver les requêtes refusées.

Si vous ne pouvez pas accéder directement aux journaux d'audit, utilisez `kubectl get events` et les journaux des pods pour des indices, mais les journaux d'audit sont la source faisant autorité.

## Modes d'échec et récupération

Les échecs d'autorisation se manifestent de plusieurs façons. Cette section couvre les modes d'échec courants, leurs symptômes, comment les confirmer et comment récupérer.

### Mode d'échec 1 : L'utilisateur ou le compte de service ne peut pas effectuer une action nécessaire

Symptôme : `kubectl` renvoie `Error from server (Forbidden): pods is forbidden: User "..." cannot list resource "pods" in API group "" in the namespace "..."`.

Confirmer : Exécutez `kubectl auth can-i --list --as=<identité>` pour voir toutes les actions autorisées.

Causes profondes :
- Role/RoleBinding ou ClusterRole/ClusterRoleBinding manquant.
- La liaison existe mais avec le mauvais utilisateur ou espace de noms.
- La Role a les mauvais verbes ou ressources.
- L'utilisateur s'authentifie avec une identité différente de celle attendue (par exemple, en utilisant un kubeconfig avec un ancien jeton).

Récupération : Identifiez la permission minimale prévue, créez ou corrigez la Role et la liaison appropriées, et testez avec `can-i`. Exemple de correction :

```bash
kubectl create role pod-reader --verb=get,list,watch --resource=pods -n team-a
kubectl create rolebinding pod-reader-binding --role=pod-reader --user=developer-user -n team-a
kubectl auth can-i list pods --as=developer-user -n team-a
```

### Mode d'échec 2 : Rôle trop permissif accordé accidentellement

Symptôme : Un audit de sécurité ou `kubectl get clusterrole <nom> -o yaml` révèle `verbs: ["*"]` ou `resources: ["*"]` là où ce n'est pas nécessaire.

Confirmer : Utilisez `kubectl auth can-i --list --as=system:serviceaccount:namespace:nom-sa` pour voir l'ensemble complet des permissions.

Récupération : Remplacez le joker par les verbes et ressources spécifiques nécessaires, puis réappliquez. Pour réduire les risques, utilisez `kubectl auth reconcile` avec un manifeste durci. Exemple avant et après :

Avant :
```yaml
rules:
- apiGroups: ["*"]
  resources: ["*"]
  verbs: ["*"]
```

Après :
```yaml
rules:
- apiGroups: ["apps"]
  resources: ["deployments"]
  verbs: ["get", "list", "watch", "create", "update", "patch", "delete"]
```

### Mode d'échec 3 : Verrouillage du cluster-admin

Symptôme : Vous avez accidentellement supprimé ou modifié la ClusterRoleBinding `cluster-admin` et maintenant aucun utilisateur ne peut administrer le cluster.

Confirmer : Toutes les commandes `kubectl` renvoient `Forbidden`, et `kubectl auth can-i --list --as=votre-utilisateur` ne montre aucune permission `*`.

Récupération : Si vous avez un accès direct au plan de contrôle, vous pouvez restaurer la ClusterRoleBinding par défaut en utilisant le kubeconfig avec des certificats clients intégrés ou en utilisant le serveur d'API local avec `--authorization-mode=AlwaysAllow` temporairement. C'est une procédure d'urgence et doit être effectuée avec soin. Les fournisseurs de clusters gérés ont leurs propres mécanismes de secours ; consultez leur documentation.

Prévention : Gardez toujours un identifiant `cluster-admin` séparé dans un endroit sûr, et ne supprimez jamais la ClusterRoleBinding `cluster-admin` sans avoir un remplacement prêt.

### Mode d'échec 4 : Les changements ne prennent pas effet

Symptôme : Vous avez appliqué une RoleBinding mais `can-i` montre toujours `no`.

Causes possibles :
- Mauvais espace de noms dans le sujet ou les métadonnées.
- Mise en cache dans le webhook d'autorisation du serveur d'API (si vous utilisez un autorisateur externe). RBAC est évalué en temps réel, donc pas de délai de cache pour RBAC pur.
- Vous testez avec une identité différente de celle liée.

Confirmer : `kubectl get rolebinding <nom> -n <espace-de-noms> -o yaml` et comparez avec votre identité kubeconfig. Utilisez `kubectl config current-context` et `kubectl config view --minify` pour vérifier l'utilisateur actuel.

Récupération : Corrigez l'incohérence et retestez.

## Liste de contrôle des opérations

Pour les opérations en cours, utilisez cette liste de contrôle pour garantir que l'autorisation reste correcte et sécurisée.

### Avant tout changement

- [ ] Exécutez `kubectl version --short` et notez la version du serveur.
- [ ] Exécutez `kubectl auth can-i --list --as=<identité>` pour l'identité concernée et enregistrez la sortie.
- [ ] Identifiez la ressource, le verbe et l'espace de noms exacts nécessaires.
- [ ] Passez en revue les Roles et ClusterRoles existants pour une réutilisation.
- [ ] Ayez un plan de retour en arrière : copiez le YAML actuel ou assurez-vous que le dépôt Git a le dernier bon état connu.

### Pendant le changement

- [ ] Appliquez des Role et RoleBinding minimales (préférez la portée d'espace de noms à la portée de cluster).
- [ ] Utilisez `--dry-run=client` et `-o yaml` pour prévisualiser les ressources générées.
- [ ] Appliquez les changements un par un, en testant après chacun.
- [ ] Évitez les jokers ; utilisez des verbes et des ressources explicites.

### Après le changement

- [ ] Exécutez `kubectl auth can-i` pour les actions autorisées et refusées.
- [ ] Testez l'application réelle ou le pipeline CI qui dépend de la permission.
- [ ] Vérifiez les effets secondaires involontaires en listant toutes les liaisons référençant le rôle modifié.
- [ ] Commitez le manifeste dans le contrôle de version.

### Revue périodique (mensuelle)

- [ ] Inventoriez toutes les ClusterRoleBindings et RoleBindings avec `kubectl get clusterrolebindings --all-namespaces -o wide` et `kubectl get rolebindings --all-namespaces -o wide`.
- [ ] Identifiez les utilisateurs et comptes de service qui n'ont pas été actifs au cours des 30 derniers jours (utilisez les journaux d'audit ou les rapports du fournisseur d'identité).
- [ ] Supprimez ou ajustez les permissions qui ne sont plus nécessaires.
- [ ] Faites tourner les jetons de compte de service et les identifiants utilisateur selon un calendrier.
- [ ] Vérifiez que le mode d'autorisation du serveur d'API est toujours RBAC (ou comme prévu) et qu'aucun changement non autorisé n'a eu lieu.

Le propriétaire de cette liste de contrôle doit être une personne nommée, telle que l'ingénieur de plateforme ou le chef d'équipe responsable de la sécurité du cluster. Par exemple, dans une startup, ce pourrait être le responsable DevOps, qui examine les résultats de la liste de contrôle chaque mois et approuve toute extension de rôle.

## Pièges courants et comment les éviter

Les pièges de configuration d'autorisation sont nombreux, mais la plupart sont évitables avec une attention particulière.

### Piège 1 : Utiliser des ClusterRoleBindings pour des besoins spécifiques à un espace de noms

Pourquoi cela arrive : Il est plus facile de créer une ClusterRoleBinding pour un utilisateur qui a besoin d'accéder à plusieurs espaces de noms, mais souvent l'utilisateur n'a besoin d'accéder qu'à un ou deux.

Comment éviter : Demandez toujours si la permission est nécessaire à l'échelle du cluster. Sinon, utilisez une Role et une RoleBinding dans l'espace de noms spécifique. Si la ClusterRole est nécessaire pour plusieurs espaces de noms, envisagez d'utiliser une RoleBinding pour lier une ClusterRole dans chaque espace de noms plutôt qu'une ClusterRoleBinding (c'est un modèle courant pour permettre un accès en lecture seule à tous les pods à travers les espaces de noms sans accorder cluster-admin).

### Piège 2 : Verbes et ressources jokers

Pourquoi cela arrive : Les développeurs pressés utilisent `*` pour que cela fonctionne.

Comment éviter : Commencez par les verbes exacts nécessaires (get, list, watch, create, etc.) et n'étendez qu'après avoir démontré un besoin spécifique. Utilisez `kubectl auth can-i --list` pour voir ce que les jokers accordent réellement.

### Piège 3 : Oublier de lier l'espace de noms du compte de service

Pourquoi cela arrive : Les comptes de service sont liés à un espace de noms, mais le sujet de la RoleBinding requiert à la fois le nom et l'espace de noms. Si l'espace de noms est omis, la liaison peut ne pas correspondre.

Comment éviter : Spécifiez toujours l'espace de noms dans le sujet pour les comptes de service. Testez avec `can-i` en utilisant l'identité complète `system:serviceaccount:<espace-de-noms>:<nom>`.

### Piège 4 : Supposer que les rôles d'un environnement fonctionnent dans un autre

Pourquoi cela arrive : Copier le YAML du dev au prod sans ajuster les espaces de noms ou les noms d'utilisateurs.

Comment éviter : Utilisez des outils de templating (Helm, Kustomize) pour gérer les valeurs spécifiques à l'environnement, et examinez toujours la sortie rendue avant d'appliquer. Exécutez un diff par rapport à l'état actuel du cluster.

### Piège 5 : Ne pas documenter pourquoi un rôle existe

Pourquoi cela arrive : Au fil du temps, les rôles s'accumulent et personne ne se souvient qui en avait besoin ni pourquoi.

Comment éviter : Ajoutez des annotations aux Roles et ClusterRoles expliquant le propriétaire et le but. Par exemple :

```yaml
metadata:
  annotations:
    purpose: "Permet au système CI de lister les pods pour le tableau de bord"
    owner: "platform-team@example.com"
```

Passez en revue ces annotations lors de l'audit mensuel des permissions.

### Piège 6 : Ignorer l'essai à vide de `kubectl auth reconcile`

Pourquoi cela arrive : Les équipes font confiance à leurs manifestes sources et sautent l'essai à vide, pour découvrir que la réconciliation a supprimé des permissions ajoutées manuellement pour une urgence.

Comment éviter : Exécutez toujours `--dry-run=client` d'abord, examinez le diff et communiquez avec l'équipe avant d'appliquer. Si possible, utilisez des outils GitOps avec des revues de diff automatisées.

### Piège 7 : Ne pas tester les cas négatifs

Pourquoi cela arrive : Après avoir accordé une permission, les équipes testent seulement que l'action autorisée fonctionne, pas que les actions refusées sont toujours refusées.

Comment éviter : Incluez une matrice de refus attendus et testez-les régulièrement. Par exemple, assurez-vous qu'un compte de service qui peut lire les pods ne peut pas lister les secrets.

## Conclusion

La configuration de l'autorisation Kubernetes est un contrôle de sécurité critique souvent mal configuré en raison de sa complexité et de la pression pour aller vite. En suivant une approche structurée, en observant l'état actuel, en appliquant des permissions minimales, en vérifiant avec `kubectl auth can-i` et en maintenant un plan de retour en arrière, vous pouvez prévenir la plupart des erreurs d'autorisation et récupérer rapidement lorsqu'elles se produisent.

Les points clés à retenir :

- Limitez toujours les permissions au plus petit espace de noms et ensemble de ressources nécessaires.
- Préférez les Roles et RoleBindings aux ClusterRoles et ClusterRoleBindings à moins qu'un accès à l'échelle du cluster ne soit vraiment nécessaire.
- Utilisez `kubectl auth can-i` comme outil de vérification sûr et immédiat.
- Documentez le but et le propriétaire de chaque rôle.
- Effectuez des revues d'accès mensuelles et supprimez les permissions inutilisées.
- Gardez un identifiant cluster-admin de secours pour récupérer des verrouillages.

Comme prochaine étape, choisissez une vérification à faible risque dans votre propre cluster. Choisissez un compte de service, listez ses permissions actuelles et exécutez quelques vérifications `can-i` pour confirmer les résultats attendus d'autorisation et de refus. Ensuite, passez en revue tous les rôles qui ont des verbes jokers et réduisez-les. Enfin, attribuez un propriétaire pour mener une revue d'autorisation mensuelle à partir du mois prochain. Ce petit départ discipliné améliorera la posture de sécurité de votre cluster sans perturber les opérations quotidiennes.