Aller au contenu
English
Compte : non connecté, synchronisation possible Mon apprentissage
Selectionner le thème
English

PKI d'un cluster Kubernetes : autorités et certificats

Par mis à jour le

Améliorer cette page

Logo Kubernetes

La PKI (infrastructure à clés publiques) d'un cluster Kubernetes est l'ensemble des autorités de certification et des certificats avec lesquels les composants s'authentifient entre eux en TLS. Sur un cluster kubeadm, ces fichiers vivent dans /etc/kubernetes/pki, et les certificats des composants expirent au bout d'un an. Cette leçon s'adresse aux administrateurs d'un cluster kubeadm. Vous y apprenez quel certificat a signé quoi, comment lire une échéance et comment renouveler avant la panne. Elle montre ensuite comment donner un accès à un humain : Kubernetes n'a pas d'objet « utilisateur », une personne se présente avec un certificat que le cluster a signé.

  • Dire à quoi sert la PKI d'un cluster et nommer ses trois autorités : ca, etcd-ca et front-proxy-ca.
  • Retrouver les certificats dans /etc/kubernetes/pki et lire l'un d'eux avec openssl x509.
  • Lire l'échéance de chaque certificat avec kubeadm certs check-expiration.
  • Renouveler les certificats du plan de contrôle avec kubeadm certs renew, puis faire recharger les composants.
  • Distinguer ce que le kubelet renouvelle seul de ce qu'il faut surveiller.
  • Reconnaître les symptômes d'un certificat expiré et reprendre l'accès.
  • Donner un accès à un humain par l'API CertificateSigningRequest, jusqu'à son kubeconfig, et vérifier ses droits.

Un cluster kubeadm dont vous administrez le plan de contrôle, avec un accès sudo au nœud : la leçon Installer un cluster Kubernetes avec kubeadm en construit un. Il faut aussi savoir ce qu'est un Pod statique (un composant que le kubelet lance depuis un fichier, sans passer par l'API) et connaître les objets de RBAC, Role et RoleBinding. Cette leçon traite les certificats du cluster lui-même, pas les certificats TLS de vos applications.

Elle sert à prouver l'identité de chaque composant et à chiffrer leurs échanges. Un certificat associe une identité (un nom) à une clé publique, et une autorité de certification (CA) le signe pour garantir cette association. Quand deux composants se parlent, chacun vérifie que le certificat de l'autre a été signé par une autorité qu'il connaît, et qu'il n'a pas expiré.

Dans un cluster, ce mécanisme joue trois rôles. L'API server présente un certificat de service, pour que ses clients sachent qu'ils parlent au vrai API server. Les composants (kubelet, controller-manager, scheduler) présentent un certificat client, pour que l'API server sache qui lui parle : il lit leur identité dans le champ CN (Common Name) du certificat. Et etcd exige des certificats de ses clients et de ses pairs, parce que sa base contient tous les objets du cluster, Secrets compris.

Quelles autorités un cluster kubeadm possède-t-il ?

Section intitulée « Quelles autorités un cluster kubeadm possède-t-il ? »

Un cluster kubeadm possède trois autorités, ca, etcd-ca et front-proxy-ca, et chacune signe une famille de certificats. Le schéma ci-dessous les range par autorité : regardez que chaque certificat descend d'une seule autorité, et que la paire sa.key et sa.pub n'a aucune flèche parce qu'elle ne sert pas à signer des certificats.

Trois autorités de certification d'un cluster kubeadm. L'autorité ca signe le certificat de service apiserver, le certificat apiserver-kubelet-client, les certificats clients de admin.conf, controller-manager.conf, scheduler.conf et du kubelet. L'autorité etcd-ca signe les certificats d'etcd (server, peer, healthcheck-client) et apiserver-etcd-client. L'autorité front-proxy-ca signe front-proxy-client. La paire sa.key et sa.pub, isolée, ne signe aucun certificat.caautorité du clusteretcd-caautorité d'etcdfront-proxy-caautorité du front-proxysa.key et sa.pubpaire des jetons, sans autoritéapiservercertificat de service de l'APIapiserver-kubelet-clientAPI vers kubeletadmin.conf, controller-manager.conf,scheduler.conf, certificats du kubeletetcd/server, etcd/peer,etcd/healthcheck-clientapiserver-etcd-clientAPI vers etcdfront-proxy-clientAPI vers les API agrégées
Source · SVG
Échap pour fermer, + et − pour zoomer, défilement pour se déplacer. 100 %

La première, ca, est l'autorité du cluster. Elle signe le certificat de service de l'API server, celui qu'il présente au kubelet (apiserver-kubelet-client) et les certificats clients des composants : administrateur, controller-manager, scheduler et kubelet. La deuxième, etcd-ca, ne signe que ce qui touche etcd, y compris le certificat que l'API server présente à etcd (apiserver-etcd-client). La troisième, front-proxy-ca, signe le certificat avec lequel l'API server joint les API agrégées, par exemple celle de metrics-server.

Séparer les autorités limite les dégâts : un certificat signé par etcd-ca n'est pas accepté par l'API server comme un certificat client du cluster. La paire sa.key et sa.pub signe les jetons des ServiceAccounts : ce sont des clés, pas un certificat, et kubeadm certs check-expiration ne les liste pas. Les fichiers se rangent ainsi dans /etc/kubernetes/pki : les trois autorités (ca.crt et ca.key, front-proxy-ca.crt…), les certificats du plan de contrôle à la racine, et ceux d'etcd dans le sous-dossier etcd/. La clé d'une autorité (ca.key) est le secret le plus sensible du nœud : celui qui la lit peut signer un certificat pour n'importe quelle identité du cluster.

Pour lire un certificat, on utilise openssl x509, qui décode le fichier .crt. La commande suivante affiche le sujet, l'émetteur, les dates, le numéro de série et les noms alternatifs du certificat de service de l'API server.

Fenêtre de terminal
sudo openssl x509 -in /etc/kubernetes/pki/apiserver.crt -noout \
-subject -issuer -serial -dates -ext subjectAltName

Cinq lignes sont à regarder. Le subject est l'identité du certificat, et l'issuer est l'autorité qui l'a signé : ici, l'autorité du cluster, puisque ca signe apiserver. notBefore et notAfter encadrent la validité, et notAfter est l'échéance. Le numéro de série (serial) change à chaque renouvellement : c'est le moyen le plus sûr de vérifier qu'un certificat a bien été remplacé. Enfin subjectAltName liste les noms DNS et les adresses IP pour lesquels le certificat est valable : un client qui joint l'API par un nom absent de cette liste refuse la connexion.

Pour l'échéance d'une autorité, la même commande suffit, réduite à la date.

Fenêtre de terminal
sudo openssl x509 -in /etc/kubernetes/pki/ca.crt -noout -enddate

Les certificats clients des composants ne sont pas des fichiers à part : kubeadm les range, encodés en base64, dans les kubeconfigs admin.conf, controller-manager.conf et scheduler.conf de /etc/kubernetes. Pour lire celui de l'administrateur, on extrait le champ client-certificate-data, on le décode, puis on le passe à openssl.

Fenêtre de terminal
sudo grep client-certificate-data /etc/kubernetes/admin.conf \
| awk '{print $2}' | base64 -d | openssl x509 -noout -subject -enddate

Comment connaître les échéances de tous les certificats ?

Section intitulée « Comment connaître les échéances de tous les certificats ? »

kubeadm certs check-expiration lit tous les certificats d'un coup, avec leur échéance, le temps restant et l'autorité qui les a signés. C'est la commande à lancer pour un audit.

Fenêtre de terminal
sudo kubeadm certs check-expiration

La sortie comporte deux tableaux. Le guide kubeadm en montre un extrait ; voici le tableau des autorités.

Extrait de la sortie (kubeadm 1.37.2)
CERTIFICATE AUTHORITY EXPIRES RESIDUAL TIME EXTERNALLY MANAGED
ca Nov 07, 2036 21:44 UTC 9y no
etcd-ca Nov 07, 2036 21:44 UTC 9y no
front-proxy-ca Nov 07, 2036 21:44 UTC 9y no

Il y a deux tableaux à lire, et ils n'ont pas la même échéance. Le premier liste les certificats des composants, valables un an par défaut : c'est celui qu'on surveille, colonne RESIDUAL TIME. Le second liste les trois autorités, valables dix ans par défaut, soit neuf ans restants sur ce cluster. La colonne EXTERNALLY MANAGED dit si kubeadm gère le certificat (no) ou si une autre autorité le fournit : kubeadm ne renouvelle pas ce qu'il ne gère pas. Prenez pour règle de renouveler quand il reste moins de trente jours.

Cet audit a sa place dans la routine mensuelle décrite par la leçon Tâches quotidiennes d'un administrateur Kubernetes. Une montée de version avec kubeadm upgrade renouvelle aussi les certificats, sauf si vous passez --certificate-renewal=false : un cluster qu'on met à jour au moins une fois par an ne voit pas ses certificats expirer.

Comment renouveler les certificats et les faire recharger ?

Section intitulée « Comment renouveler les certificats et les faire recharger ? »

On renouvelle avec kubeadm certs renew, qui remplace les certificats sur le disque du nœud, puis on vérifie que les composants utilisent les nouveaux. Le guide kubeadm détaille le geste pas à pas, avec ses sorties ; cette section en donne l'ordre et ce qu'il faut regarder.

Fenêtre de terminal
sudo kubeadm certs renew all

La commande renouvelle onze certificats : ceux de l'API server (service, client vers etcd, client vers kubelet), ceux d'etcd (serveur, pairs, sonde de santé), celui du front-proxy, et les kubeconfigs admin.conf, controller-manager.conf, scheduler.conf et super-admin.conf. Elle ne touche pas aux autorités. Sa dernière ligne dit : « You must restart the kube-apiserver, kube-controller-manager, kube-scheduler and etcd, so that they can use the new certificates. » Sur un cluster à plusieurs plans de contrôle, lancez-la sur chacun d'eux.

Cette consigne se nuance. Une mesure du 13 novembre 2026 (kubeadm 1.37.2) montre que l'API server et etcd rechargent seuls leur certificat de service : sans rien redémarrer, ils ont servi le nouveau en moins de 25 secondes. Le controller-manager et le scheduler, eux, ne lisent le certificat client de leur kubeconfig qu'au démarrage : sans redémarrage, ils gardent l'ancien et cessent de fonctionner le jour où il expire. Comme renew all renouvelle aussi les certificats clients, suivez la consigne de kubeadm et redémarrez les quatre Pods statiques, un à la fois.

Un Pod statique ne se redémarre pas avec kubectl delete pod, puisque le kubelet recrée le Pod depuis son fichier. Le geste consiste à sortir le manifeste de /etc/kubernetes/manifests, à attendre avec crictl ps que le conteneur ait disparu, puis à remettre le manifeste. Le guide kubeadm le détaille, avec l'ordre à suivre. Prévoyez une coupure de l'API : sur la mesure du 13 novembre 2026, kubectl a échoué pendant environ 41 secondes en tout, le temps de relancer etcd et l'API server.

Reste un dernier geste, que l'on oublie souvent. Le renouvellement réécrit /etc/kubernetes/admin.conf, mais pas la copie que vous avez faite dans ~/.kube/config : celle-là garde l'ancien certificat client. Recopiez le fichier, puis vérifiez que kubectl répond.

Fenêtre de terminal
sudo cp /etc/kubernetes/admin.conf ~/.kube/config
sudo chown "$(id -u):$(id -g)" ~/.kube/config
kubectl get nodes

Si kubectl get nodes répond, l'API server accepte le certificat renouvelé. Relancez ensuite sudo kubeadm certs check-expiration : chaque certificat renouvelé doit afficher à nouveau environ un an de validité.

Le kubelet renouvelle seul son certificat client : kubeadm active la rotation automatique des certificats client du kubelet, et ceux-là se remplacent avant leur échéance sans que vous fassiez quoi que ce soit. Vous n'avez donc pas à les surveiller dans l'audit mensuel.

À l'inverse, les certificats du plan de contrôle exigent une intervention : API server, etcd, controller-manager, scheduler et les kubeconfigs qui vont avec. C'est la liste exacte que rend kubeadm certs check-expiration. Cette séparation simplifie l'audit : on surveille ce que la commande affiche, plus les certificats que vous faites signer vous-même, comme celui de camille plus bas.

Quand un certificat expire, les composants refusent de se parler : kubectl ne répond plus, ou les nœuds perdent le contact avec l'API server. Le message d'erreur contient certificate has expired. Il apparaît dans la sortie de kubectl si c'est le certificat de ~/.kube/config qui a expiré, ou dans les journaux d'un composant (crictl logs, journalctl -u kubelet) si c'est un certificat entre composants. La leçon Diagnostiquer une panne du plan de contrôle donne la démarche pour trouver le composant en cause.

La reprise se fait depuis le nœud du plan de contrôle, connecté en root ou avec sudo, parce qu'elle ne dépend pas de kubectl. On lance sudo kubeadm certs renew all, on redémarre les quatre Pods statiques comme dans la section précédente, puis on recopie admin.conf vers ~/.kube/config. Tant que la copie n'est pas à jour, kubectl peut se lancer avec le fichier du nœud : sudo kubectl --kubeconfig /etc/kubernetes/admin.conf get nodes. Dans le cas d'etcd, la page etcd donne le runbook des certificats expirés.

kubeadm certs renew ne remplace pas les trois autorités, valables dix ans : leur remplacement est une opération à part, que cette leçon ne couvre pas. L'échéance d'un an se connaît très longtemps à l'avance : avec l'audit mensuel, une expiration reste une panne évitable.

Comment donner un accès à un humain par une CertificateSigningRequest ?

Section intitulée « Comment donner un accès à un humain par une CertificateSigningRequest ? »

On donne un accès à un humain en lui faisant signer un certificat par le cluster, via l'API CertificateSigningRequest (CSR), puis en lui accordant des droits avec RBAC. Kubernetes n'a pas d'objet User : l'API server reconnaît une personne au CN de son certificat client, signé par ca. L'autre façon de faire, signer à la main avec ca.key, oblige à sortir la clé de l'autorité du nœud. Avec une CSR, la clé de l'autorité reste sur le nœud, et c'est le cluster qui signe, après une approbation explicite.

Le schéma suivant montre les trois acteurs et le chemin de la demande. Regardez que la clé privée de camille ne passe ni par l'administrateur ni par l'API server : seule la demande voyage.

Échange entre trois acteurs. Camille crée sa clé et sa demande de certificat, puis envoie la demande, jamais la clé, à l'administrateur. L'administrateur dépose la CertificateSigningRequest auprès de l'API server, puis l'approuve. L'API server renvoie le certificat signé par ca dans status.certificate, et l'administrateur le transmet à camille, qui assemble son kubeconfig. L'administrateur crée ensuite le RoleBinding, et camille vérifie ses droits avec kubectl auth can-i : yes sur ses droits, no sur le reste.API serverAdmincamille① crée sa cléet sa demande④ assembleson kubeconfigenvoie la demande (CSR),jamais la clé② dépose la CSR③ approuve la CSRcertificat signé par ca,dans status.certificaterenvoie le certificat⑤ crée le RoleBindingkubectl auth can-i,avec son kubeconfigyes sur ses droits,no sur le reste
Source · SVG
Échap pour fermer, + et − pour zoomer, défilement pour se déplacer. 100 %

Le geste suit cinq étapes, ici pour une utilisatrice nommée camille qui doit lire les Pods du namespace equipe-web. Première étape : elle crée sa clé privée et une demande de certificat, avec son nom dans le CN. La clé reste chez elle et ne voyage jamais.

Fenêtre de terminal
openssl genrsa -out camille.key 2048
openssl req -new -key camille.key -subj "/CN=camille" -out camille.csr

Un champ O dans le sujet (/CN=camille/O=equipe-web) déclarerait en plus un groupe : l'API server lit CN comme nom d'utilisateur et O comme groupe, ce qui permet de donner des droits à un groupe plutôt qu'à chaque personne.

Deuxième étape : l'administrateur dépose la demande dans l'API. L'objet porte la demande encodée en base64 sur une seule ligne (base64 -w0), le signataire kubernetes.io/kube-apiserver-client, qui délivre des certificats clients pour l'API server, et l'usage client auth.

Fenêtre de terminal
cat <<EOF | kubectl apply -f -
apiVersion: certificates.k8s.io/v1
kind: CertificateSigningRequest
metadata:
name: camille
spec:
request: $(base64 -w0 < camille.csr)
signerName: kubernetes.io/kube-apiserver-client
usages:
- client auth
EOF

Troisième étape : l'administrateur approuve la demande, puis lit le certificat que l'API a délivré dans status.certificate, encodé en base64. kubectl get csr montre l'état de la demande : Pending avant l'approbation, Approved,Issued après.

Fenêtre de terminal
kubectl certificate approve camille
kubectl get csr camille -o jsonpath='{.status.certificate}' | base64 -d > camille.crt
openssl x509 -in camille.crt -noout -subject -enddate

La dernière commande confirme deux choses : le sujet porte bien CN=camille, et notAfter donne l'échéance de ce certificat, à noter comme celle des autres.

Quatrième étape : on construit le kubeconfig de camille, un fichier à part, avec l'adresse de l'API server, le certificat public de l'autorité (ca.crt), puis son certificat et sa clé. En pratique, l'administrateur lui renvoie camille.crt et c'est elle qui assemble son fichier ; les commandes ci-dessous tournent au même endroit pour rester courtes.

Fenêtre de terminal
SERVEUR=$(kubectl config view --minify -o jsonpath='{.clusters[0].cluster.server}')
kubectl config set-cluster kubernetes --server="$SERVEUR" \
--certificate-authority=/etc/kubernetes/pki/ca.crt --embed-certs=true \
--kubeconfig=camille.kubeconfig
kubectl config set-credentials camille --client-certificate=camille.crt \
--client-key=camille.key --embed-certs=true --kubeconfig=camille.kubeconfig
kubectl config set-context camille --cluster=kubernetes --user=camille \
--kubeconfig=camille.kubeconfig
kubectl config use-context camille --kubeconfig=camille.kubeconfig

Cinquième étape : on lui donne ses droits. Un certificat prouve qui elle est, mais il ne lui donne aucun droit. Un RoleBinding dans equipe-web la relie au ClusterRole view, qui permet de lire sans modifier et ne donne pas accès aux Secrets. Le même gabarit sert avec un Role plus étroit : la leçon RBAC explique comment le construire.

Fenêtre de terminal
kubectl create rolebinding camille-lecture --clusterrole=view \
--user=camille --namespace=equipe-web

On vérifie sous son identité, avec son kubeconfig. kubectl auth whoami doit répondre camille, ce qui prouve que l'API reconnaît le certificat. Puis kubectl auth can-i pose la question des droits : list pods dans equipe-web doit répondre yes, et delete pods, get secrets ou list pods dans un autre namespace doivent répondre no.

Fenêtre de terminal
kubectl --kubeconfig camille.kubeconfig auth whoami
kubectl --kubeconfig camille.kubeconfig auth can-i list pods --namespace equipe-web
kubectl --kubeconfig camille.kubeconfig auth can-i get secrets --namespace equipe-web

Une limite à connaître : Kubernetes ne révoque pas un certificat client. Jusqu'à son échéance, un certificat volé reste accepté. Pour retirer l'accès de camille, supprimez son RoleBinding : elle s'authentifie toujours, mais ne peut plus rien faire.

Les trois labs tournent sur un cluster kubeadm en machines virtuelles, comme à l'examen. Le premier fait lire les échéances d'un cluster, renouveler les certificats du plan de contrôle, faire redémarrer le controller-manager et le scheduler, puis recopier admin.conf. La validation lit l'échéance de la CA que vous notez dans ~/pki/reponses.yaml et la compare au certificat. Elle compare ensuite le numéro de série des sept certificats du plan de contrôle à celui relevé au lancement. Pour le controller-manager et le scheduler, elle exige un nouveau certificat client dans leur kubeconfig et un redémarrage après sa réécriture. Enfin, elle vérifie que ~/.kube/config porte le nouveau certificat d'admin.conf et que kubectl répond. Renouveler un seul certificat, oublier les redémarrages ou toucher un fichier sans le renouveler ne passe pas.

Le deuxième lab demande de donner à camille un accès en lecture sur equipe-web par une CertificateSigningRequest : sa clé et sa demande, l'approbation, le certificat délivré, son kubeconfig, puis ses droits. La validation lit la demande, compare le certificat du kubeconfig à celui que l'API a délivré, puis interroge l'API sous l'identité de camille : lire les Pods passe, tout le reste (modifier, lire un Secret, regarder un autre namespace ou les nœuds) doit être refusé. Un certificat signé à la main avec la clé de ca ne passe pas.

Le troisième est le challenge du niveau 4, sans procédure. Il croise ces gestes avec ceux de Sauvegarder et restaurer Kubernetes et de Gérer les dépréciations d'API : sauvegarde, restauration d'etcd, manifestes à migrer hors des API retirées, et certificats du plan de contrôle à remettre à jour. Il est noté sur l'état final du cluster, un critère par état à obtenir, avec un seuil de réussite de 70 %.

  1. La PKI d'un cluster kubeadm vit dans /etc/kubernetes/pki et repose sur trois autorités : ca pour le cluster, etcd-ca pour etcd et front-proxy-ca pour les API agrégées.
  2. openssl x509 -noout -subject -issuer -serial -dates -ext subjectAltName lit un certificat ; le numéro de série prouve un renouvellement.
  3. kubeadm certs check-expiration liste les échéances : un an pour les certificats des composants, dix ans pour les autorités.
  4. kubeadm certs renew all renouvelle onze certificats, pas les autorités ; redémarrez les quatre Pods statiques, car le controller-manager et le scheduler ne relisent leur certificat client qu'au démarrage.
  5. Le renouvellement réécrit /etc/kubernetes/admin.conf mais pas ~/.kube/config : recopiez-le.
  6. Le kubelet renouvelle seul son certificat client ; les certificats du plan de contrôle se surveillent chaque mois.
  7. Un certificat expiré se repère à certificate has expired ; la reprise se fait sur le nœud avec kubeadm certs renew all.
  8. Un humain obtient son certificat par une CertificateSigningRequest : la clé de ca ne quitte pas le nœud, et les droits viennent d'un RoleBinding.

Huit questions portent sur ce que signe chaque autorité, la lecture d'une échéance, ce qu'il faut recharger après un renouvellement et le chemin d'une CSR jusqu'au kubeconfig. Si une réponse vous surprend, revenez à la section correspondante.

Contrôle de connaissances

Validez vos connaissances avec ce quiz interactif

8 questions
8 min.
70% requis

Informations

  • Le chronomètre démarre au clic sur Démarrer
  • Questions à choix multiples, vrai/faux et réponses courtes
  • Vous pouvez naviguer entre les questions
  • Les résultats détaillés sont affichés à la fin

Lance le quiz et démarre le chronomètre