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 :
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 :
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
kubectlinstallé et configuré avec des permissions suffisantes pour lire les objets RBAC. - Un identifiant de secours
cluster-adminstocké séparément, en cas de verrouillage. - Un espace de noms dédié aux tests, tel que
authz-lab, créé aveckubectl 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 whoamisi disponible (via un pluginkubectlou 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 :
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) :
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 :
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 :
kubectl apply -f pod-reader-role.yaml
Étape 3 : Lier la Role au compte de service
Créez pod-reader-binding.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 :
kubectl apply -f pod-reader-binding.yaml
Étape 4 : Vérifier
Exécutez à nouveau la commande can-i :
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 :
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 :
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 :
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 :
roleRefpointe vers uneClusterRolealors qu'uneRoleétait prévue, ou vice versa.subjectsa le mauvais espace de noms pour un compte de service.apiGroupsest vide pour les ressources principales (correct) mais devrait êtreappspour les déploiements,batchpour 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 :
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 :
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 :
rules:
- apiGroups: ["*"]
resources: ["*"]
verbs: ["*"]
Après :
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 --shortet 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=clientet-o yamlpour 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-ipour 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 wideetkubectl 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 :
metadata:
annotations:
purpose: "Permet au système CI de lister les pods pour le tableau de bord"
owner: "[email protected]"
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-icomme 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.