Introduction
Les ReplicaSets Kubernetes sont une brique fondamentale pour garantir qu'un nombre spécifié de réplicas de pods s'exécute à tout moment. Bien qu'un déploiement gère généralement les ReplicaSets en arrière-plan, comprendre les mécanismes internes des ReplicaSets est essentiel pour le dépannage, le débogage et l'optimisation de la disponibilité des applications. Cet article va au-delà des bases et explore des concepts avancés tels que l'immuabilité des sélecteurs, la sémantique de mise à l'échelle, le gating de préparation, la reprise après défaillance et les bonnes pratiques opérationnelles.
Nous nous concentrons sur le contrôleur ReplicaSet de Kubernetes (la ressource ReplicaSet apps/v1) et fournissons des exemples pratiques avec kubectl. Notre public inclut les développeurs, les consultants DevOps et les équipes techniques de startups qui doivent exploiter Kubernetes en production. À la fin, vous serez en mesure de diagnostiquer les problèmes de ReplicaSet, de mettre à l'échelle les applications en toute sécurité, de comprendre comment le contrôleur réconcilie l'état et de mettre en œuvre des procédures opérationnelles robustes.
Inventaire des versions et de l'environnement
Avant de plonger dans les concepts avancés, établissez la version et la base de l'environnement. Cela garantit que les commandes et les comportements décrits correspondent à votre cluster. Éléments clés à inventorier :
- Version de Kubernetes :
kubectl version --shortoukubectl version(clients plus récents). Le comportement des ReplicaSets est resté stable depuis queapps/v1est devenu GA dans Kubernetes 1.9, mais vérifiez toujours. - Version de l'API ReplicaSet : Assurez-vous que les manifestes utilisent
apiVersion: apps/v1. - Espace de noms : Identifiez l'espace de noms cible (
kubectl get namespaces). - ReplicaSets existants :
kubectl get replicasets -n <namespace>pour lister les ReplicaSets actuels et leurs compteurs souhaités, actuels et prêts.
Exemple de sortie de kubectl get replicasets :
NAME DESIRED CURRENT READY AGE
frontend-rs 3 3 3 2d
backend-rs 2 2 1 5h
Remarquez que backend-rs a deux réplicas souhaités et actuels, mais un seul est prêt. Cela indique un problème de préparation du pod, que nous explorerons plus tard.
Observation vs intervention : Commencez par des commandes en lecture seule pour capturer l'état actuel. Enregistrez la sortie dans un fichier avec un horodatage pour une comparaison ultérieure :
kubectl get replicasets -n prod -o yaml > replicasets-avant.yaml
date +%s >> replicasets-avant.yaml
Évitez d'apporter des modifications tant que vous ne comprenez pas l'impact et que vous ne pouvez pas les annuler. Par exemple, si vous réduisez un ReplicaSet, vous pouvez réduire la disponibilité.
Chemin de configuration sûr
Lors de la modification d'un ReplicaSet, suivez un chemin de configuration sûr qui minimise les risques. La spec du ReplicaSet comprend replicas, selector et template. Règles clés :
- Immuabilité du sélecteur : Une fois créé, le
spec.selectord'un ReplicaSet est immuable dansapps/v1. Tenter de le mettre à jour entraînera une erreur. Utilisezkubectl editoukubectl applyet observez le rejet. - Modifications du modèle : La mise à jour du modèle de pod (par exemple, image, variables d'environnement) ne redémarre pas automatiquement les pods existants. Le contrôleur ReplicaSet n'agit que lorsque le nombre de pods diffère de celui souhaité. Pour appliquer les modifications du modèle, vous devez supprimer les pods existants ou mettre le ReplicaSet à zéro puis le remonter.
- ReplicaSets en pause : Le contrôleur ReplicaSet n'a pas de champ
paused(contrairement aux déploiements). Cependant, vous pouvez obtenir un effet similaire en mettant à zéro, en modifiant le modèle et en remontant.
Exemple : mise à jour sûre du modèle
- Réduisez à zéro :
kubectl scale replicaset frontend-rs --replicas=0 -n prod
- Attendez la fin des pods :
kubectl wait --for=delete pod -l app=frontend -n prod --timeout=60s
- Appliquez le nouveau modèle (par exemple, mettez à jour l'image vers
nginx:1.25) :
kubectl apply -f frontend-rs.yaml -n prod
- Remontez au nombre souhaité :
kubectl scale replicaset frontend-rs --replicas=3 -n prod
- Vérifiez le déploiement :
kubectl rollout status replicaset/frontend-rs -n prod
Remarque : rollout status fonctionne pour les ReplicaSets dans les versions récentes de Kubernetes mais peut être limité ; utilisez kubectl get rs et kubectl get pods pour confirmer l'état prêt.
Configuration des portes de préparation : Les cas d'utilisation avancés peuvent nécessiter des portes de préparation personnalisées. Ajoutez readinessGates au modèle de pod :
spec:
template:
spec:
readinessGates:
- conditionType: "www.example.com/feature"
Un contrôleur doit définir cette condition sur le pod pour qu'il devienne prêt.
Vérification et diagnostic
Après avoir appliqué les modifications, vérifiez que l'état réel correspond à l'état souhaité. Utilisez les commandes suivantes :
kubectl get rs -n prod– aperçu rapide.kubectl describe rs frontend-rs -n prod– événements, conditions et modèle de pod.kubectl get pods -l app=frontend -n prod -o wide– vérifiez l'état des pods et la distribution des nœuds.kubectl logs <nom-du-pod> -n prod --previous– inspectez les journaux pour les boucles de crash.
Diagnostic d'un pod non prêt : Utilisez kubectl describe pod <nom-du-pod> et regardez la section Conditions. Si Ready est False, vérifiez ContainersReady et PodScheduled pour isoler le problème. Par exemple :
Conditions:
Type Status
Initialized True
Ready False
ContainersReady False
PodScheduled True
Inspectez ensuite les journaux ou les événements de la sonde de préparation du conteneur.
Exemple de sonde de préparation :
readinessProbe:
httpGet:
path: /healthz
port: 8080
initialDelaySeconds: 5
periodSeconds: 10
Si la sonde échoue, le pod n'est pas prêt et ne recevra pas de trafic.
Incompatibilité de sélecteur : Assurez-vous que le sélecteur du ReplicaSet correspond aux étiquettes des pods. Sinon, le ReplicaSet peut adopter des pods orphelins ou ne pas les gérer. Utilisez kubectl get rs -o yaml pour inspecter le sélecteur et comparez-le aux étiquettes des pods avec kubectl get pods --show-labels.
Modes de défaillance et reprise
Les ReplicaSets peuvent échouer de plusieurs manières. Voici les modes de défaillance courants et les étapes de reprise.
1. Réplicas insuffisants en raison d'une défaillance de nœud
Si les nœuds deviennent non planifiables, les pods peuvent être en état Pending. Vérifiez l'état des nœuds :
kubectl get nodes
kubectl describe node <nom-du-nœud>
Recherchez MemoryPressure ou DiskPressure. Si les pods ne peuvent pas être planifiés en raison de contraintes de ressources, envisagez de réduire le ReplicaSet ou d'ajouter des nœuds.
Reprise : Mettez le ReplicaSet à un nombre réalisable, ou supprimez le ReplicaSet et recréez-le avec des demandes de ressources ajustées.
2. Pods en CrashLoopBackOff
Si les pods plantent à plusieurs reprises, le ReplicaSet continuera à les recréer, mais ils peuvent ne jamais devenir prêts. Utilisez :
kubectl get pods -l app=backend -n prod
kubectl logs backend-rs-xxxx -n prod --previous
Corrigez l'erreur de l'application, mettez à jour le modèle de pod, puis supprimez les pods défaillants pour forcer la recréation.
3. Le contrôleur ReplicaSet ne réconcilie pas
Vérifiez si le ReplicaSet existe et a le bon spec.replicas. Vérifiez également que le gestionnaire de contrôleurs fonctionne (bien qu'il s'agisse d'un problème au niveau du cluster). Si le ReplicaSet a été créé avec kubectl create puis modifié avec kubectl apply, assurez-vous qu'aucune mise à jour conflictuelle n'a eu lieu. Utilisez kubectl describe rs pour voir les événements et les erreurs possibles.
4. Pods orphelins en raison de modifications de sélecteur
Comme mentionné, les sélecteurs sont immuables, mais si quelqu'un crée manuellement un pod avec des étiquettes correspondantes, le ReplicaSet peut l'adopter et dépasser le nombre souhaité. Cela peut se produire si le sélecteur du ReplicaSet est large. Évitez de créer manuellement des pods qui correspondent au sélecteur d'un ReplicaSet.
Reprise : Supprimez le pod orphelin et assurez-vous de l'unicité des étiquettes.
Liste de contrôle des opérations
Pour les opérations quotidiennes avec les ReplicaSets, utilisez la liste de contrôle suivante. Attribuez chaque élément à un responsable et définissez la fréquence de révision.
| # | Tâche | Commande / Outil | Responsable | Fréquence de révision |
|---|---|---|---|---|
| 1 | Vérifier le nombre souhaité vs actuel du ReplicaSet | kubectl get rs -n <namespace> | Priya Shah, responsable ingénierie | Quotidienne (pendant le standup) |
| 2 | Vérifier la préparation et l'état des pods | kubectl get pods -l app=<étiquette> -n <namespace> | DevOps de garde | Horaire pendant les heures ouvrées |
| 3 | Inspecter les événements pour les échecs de mise à l'échelle | kubectl describe rs <nom> -n <namespace> | DevOps de garde | À chaque déploiement ou incident |
| 4 | Tester la procédure de retour en arrière | Simuler en mettant à zéro puis en remontant | Responsable ingénierie | Mensuelle |
| 5 | Valider les demandes/limites de ressources par rapport à l'utilisation réelle | kubectl top pods -n <namespace> | Équipe plateforme | Hebdomadaire |
| 6 | Examiner l'âge du ReplicaSet et la politique de nettoyage | kubectl get rs --sort-by=.metadata.creationTimestamp | Consultant DevOps | Trimestrielle |
Chaque responsable doit connaître le rayon d'impact de son action. Par exemple, réduire un ReplicaSet en dessous du minimum de disponibilité peut entraîner une dégradation du service. La fréquence de révision garantit que les modifications sont évaluées périodiquement.
Pièges courants et comment les éviter
1. Ignorer l'immuabilité du sélecteur
Pourquoi cela arrive : Les développeurs essaient souvent de mettre à jour les sélecteurs pour correspondre aux nouvelles étiquettes des pods, en s'attendant à une mise à jour en direct. Comment éviter/récupérer : Comprenez que le sélecteur est immuable. Planifiez un nouveau ReplicaSet (ou utilisez un déploiement qui gère cette transition). Pour récupérer, supprimez l'ancien ReplicaSet et créez-en un nouveau avec le sélecteur souhaité, puis migrez les pods ou utilisez un service pour acheminer le trafic.
2. Gérer directement les ReplicaSets alors que les déploiements sont préférables
Pourquoi cela arrive : Les équipes peuvent créer un ReplicaSet nu pour des applications simples, puis avoir besoin de mises à jour progressives (rolling updates). Comment éviter : Utilisez un déploiement, qui gère les ReplicaSets et fournit des mises à jour progressives, des retours en arrière et la mise à l'échelle. Si vous avez déjà un ReplicaSet, envisagez de l'adopter dans un déploiement (en créant un déploiement avec le même sélecteur et --cascade=false éventuellement), mais soyez conscient de la sémantique d'adoption.
3. Ne pas définir de sondes de préparation
Pourquoi cela arrive : Supposer qu'un conteneur en cours d'exécution est prêt à servir le trafic. Comment éviter : Définissez toujours des sondes de préparation significatives. Sans elles, les pods peuvent être marqués prêts avant que l'application ne soit initialisée, provoquant des échecs de requêtes. Utilisez readinessProbe dans le modèle de pod.
4. S'appuyer sur kubectl apply pour mettre à jour les pods
Pourquoi cela arrive : L'application d'un nouveau modèle ne recrée pas les pods existants ; le contrôleur ReplicaSet garantit uniquement que le nombre de pods correspond au souhaité, pas au modèle. Les pods existants continuent de fonctionner avec l'ancienne spécification. Comment éviter : Après avoir mis à jour le modèle, déclenchez un déploiement en supprimant les pods ou en mettant à zéro puis en remontant. Sinon, utilisez un déploiement qui gère cela automatiquement.
5. Demandes de ressources mal configurées entraînant des pods non planifiables
Pourquoi cela arrive : Définir des demandes trop élevées par rapport à la capacité des nœuds, ce qui fait que les pods restent en attente. Comment éviter : Testez avec des demandes de ressources réalistes. Utilisez kubectl describe pod pour voir les événements de planification et ajustez en conséquence.
Cas d'utilisation avancés
Versions canaries avec les ReplicaSets
Bien que les déploiements simplifient les versions canaries, vous pouvez gérer manuellement plusieurs ReplicaSets derrière un service. Par exemple, créez deux ReplicaSets pour la même application avec des versions différentes et des étiquettes différentes (par exemple, version: v1 et version: v2). Un sélecteur de service qui correspond à une étiquette commune (par exemple, app: frontend) enverra le trafic aux pods des deux ReplicaSets. Ajustez le nombre de réplicas pour déplacer le trafic progressivement.
Exemple de canary étape par étape :
- Déployez la version stable (v1) avec 3 réplicas.
- Déployez la nouvelle version (v2) avec 0 réplica initialement.
- Augmentez les réplicas de v2 à 1 tout en gardant v1 à 3 (répartition du trafic 75/25).
- Surveillez les erreurs et la latence ; si tout va bien, mettez v2 à 2 et v1 à 2 (50/50).
- Finalement, mettez v2 à 3 et v1 à 0 (100 % v2).
- Supprimez le ReplicaSet v1 après vérification.
Utilisez kubectl scale pour chaque étape et surveillez via kubectl get pods et les métriques du service.
Propriété et adoption des ReplicaSets
Les ReplicaSets adoptent les pods qui correspondent à leur sélecteur et qui ne sont pas déjà contrôlés par un autre contrôleur. Cela peut entraîner un comportement inattendu si vous créez manuellement des pods avec des étiquettes qui correspondent à un ReplicaSet existant. Pour éviter l'adoption, assurez-vous que les pods manuels ont des étiquettes uniques non utilisées par un sélecteur de ReplicaSet. Vous pouvez inspecter le sélecteur du ReplicaSet et vous assurer que les étiquettes de vos pods manuels diffèrent.
Intégration avec l'autoscaler horizontal de pods
Le HPA (Horizontal Pod Autoscaler) peut mettre à l'échelle les ReplicaSets directement (bien que vous cibliez généralement un déploiement). Si vous utilisez un ReplicaSet nu, vous pouvez créer un HPA qui référence le ReplicaSet :
kubectl autoscale rs frontend-rs --min=2 --max=10 --cpu-percent=80 -n prod
Cela crée un HPA qui ajuste spec.replicas en fonction de l'utilisation du CPU.
Conclusion
Les concepts avancés des ReplicaSets Kubernetes vont au-delà du simple maintien d'un nombre de pods ; ils englobent la gestion des sélecteurs, les stratégies de mise à l'échelle, la reprise après défaillance et l'hygiène opérationnelle. En suivant le chemin de configuration sûr, en utilisant des commandes de vérification et en comprenant les modes de défaillance, vous pouvez exploiter les ReplicaSets en toute confiance.
Comme prochaine étape, appliquez un changement à faible risque à un ReplicaSet dans un espace de noms de test : observez son état actuel, réduisez-le, mettez à jour son modèle, remontez-le et vérifiez la préparation avec kubectl get pods et kubectl rollout status. Documentez chaque commande avec sa sortie attendue et les étapes de reprise. Cette pratique vous préparera aux scénarios de production et garantira que votre environnement Kubernetes reste stable.