Argo CD and Server-Side Apply: Who Owns Which Field
Server-side apply moves the merge into the API server and replaces the last-applied annotation with field ownership. What that actually changes in Argo CD.
blog
Du kernel au pipeline
Ce qui se publie ici sort de la production : post-mortems d'incidents réellement vécus, décisions d'architecture et ce qu'elles ont coûté. Le reste, ce sont des tutoriels sur des problèmes pointus et peu documentés, rédigés en anglais quand c'est la langue de la requête qui y mène. Deux articles par mois au maximum, uniquement quand il y a quelque chose à dire.
Argo CD et le server-side apply : qui possède quel champ
Le server-side apply déplace la fusion dans l'API server et remplace l'annotation last-applied par des propriétaires de champs. Ce que ça change dans Argo CD.
Sync options Argo CD : ce que chaque option change vraiment
Les sync options d'Argo CD passées une à une : ce que chacune change à la commande appliquée, et laquelle se pose sur l'Application ou sur la ressource.
Argo CD Sync Options: What Each One Actually Changes
Argo CD sync options one by one: what each changes in the command actually run, and which ones belong on the Application versus on the resource.
Incident Commander Is Not the Person Fixing the Bug
Assigning this role to the most technical person mixes two incompatible activities: coordinating and deep debugging. Separating the two speeds up resolution.
L'incident commander n'est pas celui qui corrige le bug
Confier le rôle d'incident commander à la personne la plus technique mélange coordination et débogage. Séparer les deux accélère la résolution.
Le toil a une définition précise, pas juste « pénible »
Le toil a une définition précise : travail manuel, répétitif, automatisable, tactique et sans valeur durable, les critères qui décident quoi automatiser en premier.
Toil Has a Precise SRE Definition, Not Just Tedious Work
Toil is manual, repetitive, automatable, tactical work with no enduring value, the precise criteria that decide what to automate first.
Atlantis : deux verrous différents, pas un seul
Atlantis verrouille un répertoire Terraform contre deux PR concurrentes. Ce verrou n'a rien à voir avec le lock d'état Terraform, un mécanisme indépendant.
Atlantis: Two Different Locks, Not One
Atlantis locks a Terraform directory against two concurrent PRs. That lock has nothing to do with Terraform's own state lock, an independent mechanism.
Backstage : le vrai risque, c'est le catalogue périmé
Backstage centralise la découverte des services, mais sa valeur dépend de catalog-info.yaml. Sans propriétaire clair, le catalogue diverge de la réalité.
Backstage: The Real Risk Is a Stale Catalog, Not the Tool
Backstage centralizes service discovery, but its value depends on how fresh catalog-info.yaml stays. Without a clear owner, the catalog silently drifts from reality.
bash trap: Cleaning Up After an Interrupted Script
A script killed mid-execution leaves a temp file or lockfile behind, unless trap catches the signal first. SIGKILL remains impossible to intercept.
Blameless Postmortem Doesn't Mean No Accountability
Blameless separates fact reconstruction from individual evaluation, it doesn't erase the problem. Naming a person in the incident narrative breaks trust.
Clock Drift: Why NTP Sync Matters More Than It Seems
A server whose clock drifts by a few minutes silently rejects valid TLS certificates. chronyc tracking reveals in one command what nobody actually monitors.
Pourquoi une VM clonée ne relance pas cloud-init
cloud-init ne s'exécute qu'une fois par instance, un état tracké localement. Cloner une VM sans l'effacer fait croire à cloud-init qu'il a déjà tourné, clés SSH dupliquées à la clé.
Pourquoi aucun core dump : ulimit -c à zéro par défaut
Un crash sans core dump n'est pas un mystère : ulimit -c vaut 0 par défaut, et systemd ignore souvent /etc/security/limits.conf pour cette limite.
Why No Core Dump Ever Appears: ulimit -c Defaults to Zero
A crash with no core dump isn't always a mystery: ulimit -c defaults to 0 on most distros, and systemd often ignores /etc/security/limits.conf.
Dérive d'horloge : pourquoi la synchro NTP compte plus qu'il n'y paraît
Un serveur dont l'horloge dérive de quelques minutes rejette silencieusement des certificats TLS valides. chronyc tracking révèle en une commande ce que personne ne surveille.
dpkg lock-frontend : ne jamais le supprimer sans vérifier
Could not get lock pousse à supprimer le verrou directement. Vérifier quel processus le détient d'abord évite une base de paquets corrompue.
dpkg lock-frontend: Never Delete It Without Checking First
Could not get lock pushes toward deleting the lock directly. Checking which process holds it first avoids a corrupted package database.
Flyway vs Liquibase : lequel choisir
Flyway impose des scripts SQL versionnés, Liquibase ajoute un changelog agnostique du SGBD et un rollback déclaratif. Le vrai critère n'est pas lequel est meilleur.
Flyway vs Liquibase: Which Migration Tool to Choose
Flyway enforces versioned SQL scripts, Liquibase adds a DB-agnostic changelog and declarative rollback. The real deciding factor isn't which one is better.
fstab : pourquoi un montage absent bloque tout le démarrage
Un périphérique listé dans fstab mais absent au boot peut bloquer tout le démarrage. L'option nofail existe pour ça.
fstab: Why a Missing Mount Blocks the Entire Boot
A device listed in fstab but absent at boot can block the machine's entire startup. The nofail option exists for this.
Hard link vs symlink : la différence qui compte vraiment
Un hard link partage le même inode que l'original, un symlink pointe vers un chemin. C'est pourquoi l'un survit à la suppression de l'original, l'autre non.
Hard Link vs Symlink: The Difference That Actually Matters
A hard link shares the same inode as the original, a symlink points to a path. That difference explains why one survives deleting the original and the other doesn't.
lvextend agrandit le volume logique, pas le système de fichiers
df continue d'afficher l'ancienne taille après un lvextend réussi : agrandir un volume logique LVM ne redimensionne jamais automatiquement le système de fichiers qu'il contient.
lvextend Grows the Logical Volume, Not the Filesystem
df still shows the old size after a successful lvextend: growing an LVM logical volume never automatically resizes the filesystem it contains.
Pourquoi un processus en arrière-plan meurt à la déconnexion SSH
Une commande lancée avec & tourne en arrière-plan mais meurt quand même à la fermeture du terminal : le shell envoie SIGHUP à ses enfants. nohup et disown évitent ça.
nsswitch.conf : pourquoi /etc/hosts passe avant le DNS
Une résolution de nom incohérente entre deux machines pointe souvent vers nsswitch.conf, pas vers le DNS : il définit l'ordre des sources pour hosts, passwd et group.
nsswitch.conf: Why /etc/hosts Is Checked Before DNS
Inconsistent name resolution between two machines often points to nsswitch.conf, not DNS itself: it defines the order sources are checked for hosts, passwd, and group.
Packer vs cloud-init: Image vs Instance
Packer builds an immutable image once on a temporary machine. cloud-init configures each instance at its first boot. Confusing the two breaks the pipeline.
Packer vs cloud-init : image contre instance
Packer construit une image immuable une fois sur une machine temporaire. cloud-init configure chaque instance à son premier démarrage. Les confondre casse le pipeline.
Postmortem blameless : pas sans responsabilité
Blameless sépare la reconstitution des faits de l'évaluation individuelle, ça n'efface pas le problème. Nommer une personne dans le récit d'incident casse la confiance.
Processus zombie : pourquoi SIGKILL ne sert à rien contre eux
Un processus zombie est déjà mort. Lui envoyer SIGKILL ne fait rien : la vraie cause est un parent qui n'a jamais récupéré son code de sortie.
Puppet to Ansible: Why a Direct Port Often Breaks
Puppet resolves a dependency graph before executing, Ansible runs tasks in the order they're written. A line-by-line port loses that implicit resolution.
Puppet vers Ansible : pourquoi le portage casse souvent
Puppet résout un graphe de dépendances avant d'exécuter, Ansible exécute les tâches dans l'ordre écrit. Un portage ligne à ligne perd cette résolution implicite.
SELinux: Permission Denied Despite a Perfectly Correct chmod
chmod and chown are correct, yet Permission denied persists. SELinux enforces a second permission system, independent of classic Unix rights: the security context.
SELinux : Permission denied malgré un chmod parfaitement correct
chmod et chown corrects, et pourtant Permission denied persiste. SELinux applique un second système de permissions : le contexte de sécurité, indépendant des droits Unix.
Pourquoi chmod u+s ne fait rien sur un script shell
Le bit setuid marche sur un binaire compilé mais le kernel l'ignore silencieusement sur un script shell, protection délibérée contre une classe de faille connue.
Sticky bit : pourquoi /tmp bloque la suppression des fichiers d'autrui
Écrire dans un répertoire suffit à y supprimer n'importe quel fichier, même d'un autre utilisateur. Le sticky bit sur /tmp casse délibérément cette règle par défaut.
The Sticky Bit: Why /tmp Stops You Deleting Others' Files
Write permission on a directory normally lets you delete any file inside, even one owned by someone else. The sticky bit on /tmp changes that default rule.
Pourquoi le swap aggrave parfois l'OOM plutôt que de le résoudre
Ajouter du swap aggrave parfois la situation : un système qui thrashe devient inutilisable, souvent pire qu'un processus tué proprement et vite par l'OOM killer.
Why Swap Can Make an OOM Situation Worse, Not Better
Adding swap doesn't always buy time before an OOM: a thrashing system becomes unusable, often worse than a process killed cleanly and fast.
systemd-tmpfiles : pourquoi /tmp se vide sans redémarrage
/tmp n'est pas nettoyé qu'au reboot : systemd-tmpfiles-clean tourne périodiquement et supprime les fichiers dépassant un âge configuré, reboot ou pas.
systemd-tmpfiles: Why /tmp Empties Without a Reboot
/tmp isn't only cleared on reboot: systemd-tmpfiles-clean runs periodically and deletes files past a configured age, reboot or not.
trap en bash : nettoyer proprement un script interrompu
Un script tué en pleine exécution laisse un lockfile derrière lui, sauf si trap intercepte le signal avant. SIGKILL reste impossible à intercepter, quel que soit le trap défini.
umask : pourquoi cron crée des fichiers aux permissions différentes
Un script fonctionne bien à la main mais crée des fichiers aux permissions différentes lancé par cron. Le coupable est presque toujours un umask différent, pas le script.
umask: Why Cron Scripts Create Files With Different Permissions
A script works fine by hand but creates files with different permissions under cron. The culprit is almost always a different umask, rarely the script.
visudo: The Command That Prevents Locking Yourself Out
Editing /etc/sudoers directly risks a syntax error that breaks sudo for everyone, including the person fixing it. visudo validates before writing.
visudo : la commande qui évite de se verrouiller soi-même dehors
Éditer /etc/sudoers directement risque une erreur de syntaxe qui casse sudo pour tout le monde, y compris pour la corriger. visudo valide avant d'écrire.
Why a Cloned VM Doesn't Rerun cloud-init
cloud-init only runs once per instance, a state tracked locally. Cloning a VM without wiping it makes cloud-init think it already ran, duplicating SSH host keys in the process.
Why a Background Process Dies When You Close Your SSH Session
Launching a command with & runs it in the background, but it still dies when the terminal closes: the shell sends SIGHUP to its children. nohup and disown prevent that.
Why chmod u+s Does Nothing on a Shell Script
The setuid bit works on a compiled binary but the kernel silently ignores it on a shell script, a deliberate security protection against a known exploit class.
Zombie Processes: Why SIGKILL Does Nothing to Them
A zombie process is already dead. Sending it SIGKILL does nothing: the real cause is a parent that never collected its exit status.
Cron vs systemd timers : l'échec qui ne prévient personne
Une tâche cron qui échoue ne le dit à personne par défaut. Un systemd timer hérite du Restart et de l'historique journalctl du service qu'il déclenche.
Cron vs systemd Timers: The Failure That Tells No One
A failing cron job doesn't notify anyone by default. A systemd timer inherits the Restart behavior and journalctl history of the service it triggers.
Deployment et ReplicaSet : pourquoi les anciens restent en vie
Un Deployment ne modifie jamais un ReplicaSet existant : il en crée un nouveau et réduit l'ancien à zéro replica. C'est ce mécanisme précis qui rend le rollback possible.
Deployment and ReplicaSet: Why the Old Ones Stick Around
A Deployment never edits an existing ReplicaSet: it creates a new one and scales the old one to zero. That exact mechanism is what makes rollback possible.
Dépréciation d'API Kubernetes : un manifeste qui casse à l'upgrade
Une API Kubernetes dépréciée reste fonctionnelle pendant un temps annoncé, puis disparaît définitivement. Un manifeste jamais mis à jour casse alors sans avertissement progressif.
Disk Full But df Shows Free Space: The Inode Exhaustion Trap
No space left on device while df -h shows 40% free isn't a contradiction: it's never disk space that's exhausted, it's inodes, a distinct and equally finite resource.
Disque plein mais df montre de l'espace libre : le piège des inodes
No space left on device alors que df -h affiche 40% de libre : ce n'est jamais l'espace disque qui manque, ce sont les inodes, une ressource distincte et finie.
In-Place Pod Resize: VPA Without the Restart
VPA's Auto mode always restarted a pod to change its requests. In-place resize (K8s 1.27+) eliminates that interruption, under certain conditions.
iptables vs nftables : la migration jamais vraiment terminée
nftables est le défaut depuis des années, mais une couche de compatibilité fait tourner les anciennes règles iptables sans jamais forcer leur migration.
iptables vs nftables: The Migration Nobody Actually Finished
nftables has replaced iptables by default on most distributions for years, but a compatibility layer keeps old rules running without ever truly migrating them.
kubectl rollout restart: A New Rollout, No Spec Change
rollout restart forces a clean rolling update without editing a single line of the Deployment. The right command for a one-off ConfigMap refresh, not kubectl delete pod.
kubectl rollout restart : un nouveau rollout sans changer la spec
rollout restart force un rolling update propre sans modifier une seule ligne du Deployment. La bonne commande pour un refresh de ConfigMap ponctuel, pas kubectl delete pod.
Kubernetes API Deprecation: When an Upgrade Breaks Old Manifests
A deprecated Kubernetes API keeps working for an announced period, then disappears for good. A manifest never updated then breaks with no gradual warning.
logrotate: The Deleted File a Process Still Writes To
A disk filling up with no visible file explaining the space often hides a log renamed by rotation, but still open by a process writing into thin air.
logrotate : le fichier supprimé où un processus écrit encore
Un disque qui se remplit sans qu'aucun fichier visible ne l'explique cache souvent un log renommé par rotation, mais toujours ouvert par un processus qui écrit dans le vide.
Redimensionnement de pod sur place : le VPA sans redémarrage
Le mode Auto du VPA redémarrait systématiquement un pod pour changer ses requests. Le redimensionnement in-place (K8s 1.27+) élimine cette interruption, sous conditions.
resourceVersion : pourquoi une écriture Kubernetes peut échouer 409
Modifier un objet Kubernetes sans relire sa dernière version produit un 409 Conflict, pas un écrasement silencieux. Le mécanisme qui protège contre les écritures concurrentes.
resourceVersion: Why a Kubernetes Write Can Fail With 409
Modifying a Kubernetes object without re-reading its latest version produces a 409 Conflict, not a silent overwrite. The mechanism protecting concurrent writes.
set -euo pipefail : ce que chaque option attrape vraiment
set -e n'arrête jamais un script à l'intérieur d'un if ni d'une condition &&. Comprendre les trois options séparément évite le faux sentiment de sécurité.
set -euo pipefail: What Each Flag Actually Catches
What set -euo pipefail actually means, flag by flag: set -e never catches an error inside an if or an && condition, and each flag catches something else.
Static Pods: The Ones kubectl delete Never Actually Deletes
A static pod is managed directly by the kubelet, not the API server. Deleting it via kubectl just makes it reappear, a classic kubeadm cluster confusion.
Static Pods : ceux que kubectl delete ne supprime jamais vraiment
Un static pod est géré directement par le kubelet, pas par le serveur API. Le supprimer via kubectl le fait juste réapparaître, une confusion classique en cluster kubeadm.
systemd Restart= : pourquoi un service crash-loop encore
Restart=on-failure ne suffit pas à empêcher un service de boucler indéfiniment. StartLimitBurst est le vrai coupe-circuit, souvent jamais réglé.
systemd Restart=: Why a Service Still Crash-Loops
Restart=on-failure alone doesn't stop a service from looping forever. StartLimitBurst is the real circuit breaker, and it's rarely configured explicitly.
Too many open files : pourquoi limits.conf ne suffit pas toujours
Augmenter ulimit -n dans limits.conf ne change rien pour un service systemd : LimitNOFILE= dans l'unité prime totalement sur les limites PAM classiques.
Too Many Open Files: Why Raising limits.conf Doesn't Always Work
Raising ulimit -n in /etc/security/limits.conf changes nothing for a systemd service: LimitNOFILE= in the unit completely overrides classic PAM limits.
Alertmanager: Routing, Grouping, Inhibiting Before the Storm
A well-written alerting rule isn't enough: without grouping or inhibition, a single incident fires dozens of identical notifications for the same cause.
Alertmanager : router, grouper, inhiber avant la tempête d'alertes
Sans Alertmanager bien configuré, un seul incident déclenche des dizaines de notifications identiques pour la même cause, une tempête qui noie le vrai signal.
Audit logging Kubernetes : qui a fait quoi, après coup
RBAC empêche, Falco détecte en direct, l'audit logging répond après l'incident. Sans Audit Policy activée, cette question n'a tout simplement pas de réponse.
Chiffrement au repos : les Secrets déjà écrits restent en clair
Activer EncryptionConfiguration chiffre les nouvelles écritures dans etcd. Les Secrets déjà stockés avant l'activation restent en clair, sans avertissement.
Cilium et eBPF : ce qui remplace iptables sous kube-proxy
kube-proxy traduit chaque Service en règles iptables évaluées séquentiellement. Cilium, basé sur eBPF, remplace ce mécanisme par des tables de hachage dans le kernel.
Cilium and eBPF: What Replaces iptables Under kube-proxy
kube-proxy translates every Service into iptables rules evaluated sequentially. Cilium, built on eBPF, replaces that mechanism with kernel hash tables.
ClusterIP, NodePort, LoadBalancer: Three Types, One Foundation
LoadBalancer and NodePort never replace ClusterIP: they add a layer on top of it. Understanding that stack avoids picking the wrong type by default.
ClusterIP, NodePort, LoadBalancer : trois types, une seule base
LoadBalancer et NodePort ne remplacent jamais ClusterIP : ils l'ajoutent en couche. Comprendre cet empilement évite de choisir le mauvais type de Service.
ConfigMap modifié : pourquoi les pods ne redémarrent jamais
Modifier un ConfigMap ne redémarre aucun pod automatiquement. Les variables d'environnement ne se mettent même jamais à jour sans un redémarrage manuel.
ConfigMap Updated: Why Your Pods Never Restart
Editing a ConfigMap never restarts any pod automatically. Environment variables don't even get updated at all without a manual restart.
Encryption at Rest: Already-Written Secrets Stay in Plaintext
Enabling EncryptionConfiguration encrypts new writes to etcd. Secrets already stored before activation stay in plaintext, with no warning.
Falco : ce que RBAC et NetworkPolicy ne voient jamais
RBAC, NetworkPolicy et Pod Security agissent avant qu'un pod ne tourne. Falco observe ce qui se passe réellement à l'intérieur, une fois qu'il tourne déjà.
Falco: What RBAC and NetworkPolicy Never See
RBAC, NetworkPolicy, and Pod Security act before a pod runs. Falco watches what actually happens inside it, once it's already running.
Finalizers : pourquoi un namespace refuse de mourir
Un finalizer bloqué, pas Kubernetes, empêche un objet en Terminating de mourir : il attend un nettoyage qu'un contrôleur disparu ne fera jamais.
Finalizers: Why a Namespace Refuses to Die
A stuck finalizer, not Kubernetes itself, keeps a Namespace in Terminating: it's waiting on a cleanup a gone controller will never actually run.
Gateway API: What Actually Replaces Ingress
Ingress encodes anything advanced into controller-specific annotations. Gateway API splits roles into typed resources, portable across controllers.
Gateway API : ce qui remplace vraiment l'Ingress
L'Ingress encode toute logique avancée dans des annotations propres à chaque contrôleur. La Gateway API sépare les rôles en ressources typées, portables entre contrôleurs.
Helm hooks : hors du cycle de vie normal de la release
Un hook Helm s'exécute en dehors de la release qu'il accompagne. helm rollback ne le rejoue jamais, ce qui casse le principe même du rollback si on ne le sait pas.
Helm Hooks: Outside the Release's Normal Lifecycle
A Helm hook runs outside the release it accompanies. helm rollback never replays it, which breaks the whole point of rollback if you don't know that.
HPA on Custom Metrics: When CPU Tells You Nothing Useful
A worker consuming a queue can run at 5% CPU while completely overwhelmed. HPA on a custom metric solves what CPU/memory structurally can't see.
HPA sur métriques custom : quand le CPU ne dit rien d'utile
Un worker qui consomme une file d'attente peut tourner à 5% de CPU tout en étant complètement submergé. Le HPA sur métrique custom résout ce que CPU/mémoire ne peuvent pas voir.
Init Containers: Sequential Setup, Then the Native Sidecar
An init container runs to completion before the main container starts. Since Kubernetes 1.29, a native sidecar changes what's still possible.
Init containers : le setup séquentiel, puis le sidecar natif
Un init container s'exécute jusqu'au bout avant que le conteneur principal démarre. Depuis Kubernetes 1.29, un sidecar natif change ce qui reste possible.
kubectl port-forward: The Tunnel That Bypasses NetworkPolicy
port-forward goes through the API server, not the pod's network. NetworkPolicy never sees it, a blind spot governed by its own specific RBAC verb.
kubectl port-forward : le tunnel qui contourne NetworkPolicy
port-forward passe par le serveur API, pas par le réseau du pod. NetworkPolicy ne le voit jamais, un angle mort qui a son propre verbe RBAC à restreindre spécifiquement.
Kubernetes Audit Logging: Who Did What, After the Fact
RBAC prevents, Falco detects live, audit logging answers after the incident. Without an Audit Policy enabled, that question simply has no answer.
Events Kubernetes : la mémoire d'une heure que personne ne retient
Un Event Kubernetes disparaît après 1 heure par défaut, pas après un an. La preuve d'un incident survenu la veille a souvent déjà été purgée avant qu'on la cherche.
Kubernetes Events: The One-Hour Memory Nobody Remembers
A Kubernetes Event vanishes after 1 hour by default, not a year. The proof of yesterday's incident has usually already been purged before anyone looks.
Kubernetes Operators: When to Write a Controller, Not a Helm Chart
A Helm chart deploys a fixed configuration. An Operator encodes operational knowledge that keeps acting after deployment, not just during it.
ndots:5 : pourquoi une résolution DNS externe coûte 5 requêtes
Le ndots:5 par défaut de Kubernetes essaie 5 domaines de recherche internes avant chaque nom externe. Une latence DNS invisible jusqu'à ce qu'elle s'accumule.
ndots:5: Why External DNS Resolution Costs Five Queries
Kubernetes' default ndots:5 tries 5 internal search domains before every external name. A DNS latency tax that's invisible until it adds up.
nf_conntrack_max: The Table That Silently Drops Connections
A full conntrack table doesn't slow anything down: it silently rejects new connections, a symptom that looks like an application problem elsewhere.
nf_conntrack_max : la table qui perd des connexions en silence
Une table conntrack pleine ne ralentit rien : elle rejette silencieusement les nouvelles connexions, un symptôme qui ressemble à un problème applicatif ailleurs.
Collector OpenTelemetry : agent et gateway, pas un choix binaire
Un Collector par nœud limite la collecte au strict local. Le tail-sampling qui a besoin de voir une trace complète réclame un second niveau, le gateway.
OpenTelemetry Collector: Agent and Gateway, Not a Binary Choice
A per-node Collector limits collection to what's strictly local. Tail-sampling, which needs a complete trace, requires a second tier: the gateway.
Operator Kubernetes : quand écrire un contrôleur, pas un Helm chart
Un Helm chart déploie une configuration figée. Un Operator encode une connaissance opérationnelle qui continue d'agir après le déploiement, pas seulement pendant.
SIGTERM vs Endpoint Removal: The Race Kubernetes Never Syncs
Kubernetes sends SIGTERM and removes a pod from Service endpoints in parallel, never in a guaranteed order. Without preStop, requests land on empty air.
SIGTERM vs retrait des endpoints : la course jamais synchronisée
Kubernetes envoie SIGTERM et retire un pod des endpoints du Service en parallèle, jamais dans un ordre garanti. Sans preStop, des requêtes arrivent dans le vide.
Strangler Fig: Migrating a Legacy System Without a Big Bang
The strangler fig pattern puts a routing facade in front of the legacy system, then switches over feature by feature until the old one just dies off.
Strangler Fig : migrer un legacy sans jamais tout remplacer d'un coup
Le pattern strangler fig fait passer une façade de routage devant le legacy, puis bascule fonctionnalité par fonctionnalité, jusqu'à ce que l'ancien système meure de lui-même.
Modules Terraform : composer sans dupliquer le state
Un module Terraform n'a pas son propre state : il partage celui du module racine. Ce détail structurel change tout ce qu'on peut faire avec, et casser.
Terraform Modules: Composing Without Duplicating State
A Terraform module doesn't have its own state: it shares the root module's. That structural detail changes what you can do with it, and break.
Thanos : ce qu'un seul Prometheus ne peut pas garder
Un Prometheus local garde ses métriques quelques semaines, sur son propre disque. Thanos déporte la rétention vers de l'object storage et unifie plusieurs clusters.
Thanos: What a Single Prometheus Can't Hold Onto
A local Prometheus keeps metrics for a few weeks, on its own disk. Thanos offloads retention to object storage and unifies multiple clusters into one view.
VolumeSnapshot : cloner un volume persistant sans Velero
VolumeSnapshot capture l'état d'un PVC à un instant donné, sans jamais toucher aux ressources Kubernetes autour. Un besoin différent de la sauvegarde cluster complète.
VolumeSnapshot: Cloning a Persistent Volume Without Velero
VolumeSnapshot captures a PVC's state at a point in time, never touching the Kubernetes resources around it. A different need than full cluster backup.
Quand le HPA épuise les connexions Postgres
Le HPA scale les pods, chaque pod ouvre son propre pool de connexions. Sous charge, la base atteint max_connections avant même que le HPA n'ait fini de scaler.
When the HPA Exhausts Postgres Connections
The HPA scales pods, each pod opens its own connection pool. Under load, the database hits max_connections before the HPA even finishes scaling.
Environnements de preview éphémères par pull request
Des environnements éphémères par pull request, créés et détruits automatiquement, résolvent un vrai problème de revue. Ce que ça coûte en isolation, et le piège du nettoyage qui ne se fait jamais.
Ephemeral Preview Environments Per Pull Request
A full ephemeral environment per PR, provisioned and torn down automatically, solves a real review problem. What it costs in isolation, and the cleanup that never fires.
Kubernetes auto-géré ou managé (EKS, GKE, AKS) : lequel
Le choix entre Kubernetes auto-géré et un service managé ne se résume pas au coût du control plane. Ce que le fournisseur gère réellement, ce qui reste à charge.
Self-Managed or Managed Kubernetes: EKS, GKE, AKS
Choosing self-managed Kubernetes versus a managed service isn't just about control-plane pricing. What the cloud provider actually handles, what stays on you.
Terraform vs Ansible: Not Competitors, Two Different Jobs
Terraform provisions infrastructure, Ansible configures it. The confusion comes from a real but partial overlap, not an actual choice to make.
Terraform vs Ansible : pas des concurrents, deux métiers
Terraform provisionne l'infrastructure, Ansible la configure. La confusion vient d'un chevauchement réel mais partiel, pas d'un vrai choix à trancher.
Kubernetes Multi-Tenancy: Three Isolation Levels, One Cost Curve
Namespaces, vcluster, or separate clusters: three ways to isolate teams on Kubernetes, with the same trade-off between isolation strength and operational cost.
Multi-tenancy Kubernetes : trois niveaux d'isolation, un seul coût
Namespaces, vcluster ou clusters séparés : trois façons d'isoler des équipes sur Kubernetes, avec un compromis identique entre force d'isolation et coût opérationnel.
nginx-ingress ou Traefik : comment choisir son Ingress Controller
Un Ingress ne fait rien sans contrôleur pour l'exécuter. nginx-ingress et Traefik répondent au même besoin par deux modèles de configuration opposés.
nginx-ingress vs Traefik: Choosing an Ingress Controller
An Ingress does nothing without a controller to run it. nginx-ingress and Traefik answer the same need through two opposite configuration models.
Blue-green : quand doubler l'infra vaut vraiment le coût
Le blue-green bascule tout le trafic d'un coup, pas progressivement. Rollback instantané, prix réel : deux environnements complets à faire tourner en double.
Blue-Green: When Doubling Infrastructure Is Actually Worth It
Blue-green flips all traffic at once, not gradually. Instant rollback, real price: two complete environments running side by side.
Longhorn: Persistent Storage on an On-Premise Cluster
Without a cloud provider, no StorageClass provisions a volume automatically. What Longhorn does instead, and what replication doesn't replace.
Longhorn : du stockage persistant sur un cluster on-premise
Sans cloud provider, aucun StorageClass ne provisionne de volume automatiquement. Ce que Longhorn fait à la place, et ce que la réplication ne remplace pas.
Provenance SLSA : au-delà de la signature d'image
Signer une image prouve qu'elle vient de votre pipeline, pas comment le pipeline l'a produite. Ce que le framework SLSA ajoute, et à quel niveau viser.
SLSA Provenance and Build Attestations: Beyond Image Signing
Signing an image proves it came from your pipeline, not how it was built. What the SLSA framework adds, and which level to actually target.
GitHub Actions vs GitLab CI: The Real Choice Beyond Syntax
GitHub Actions and GitLab CI look alike in YAML but diverge on what matters: platform portability, built-in features, and real lock-in.
GitHub Actions ou GitLab CI : le vrai choix, au-delà de la syntaxe
GitHub Actions et GitLab CI se ressemblent en YAML mais divergent sur ce qui compte : portabilité de la plateforme, fonctionnalités intégrées, verrouillage.
GitOps à l'échelle : ApplicationSets, le piège du tenant
Gérer un Application ArgoCD par service tient à dix équipes. À cent, ApplicationSets automatise la génération, mais déplace le vrai problème d'isolation.
GitOps at Scale: ApplicationSets, the Tenant Trap
Managing one ArgoCD Application per service holds up for ten teams. At a hundred, ApplicationSets automate generation, but shift the real isolation problem.
MetalLB : un vrai LoadBalancer sur un cluster on-premise
Un Service de type LoadBalancer reste en Pending indéfiniment sur un cluster on-premise, faute de cloud provider pour le satisfaire. Ce que MetalLB fait à la place.
MetalLB: A Real LoadBalancer on an On-Premise Cluster
A LoadBalancer Service stays Pending forever on an on-premise cluster, for lack of a cloud provider to satisfy it. What MetalLB does instead.
Crossplane vs Terraform: Who Fixes Drift First
Terraform catches drift at the next plan, whenever someone remembers to run it. Crossplane fixes it continuously, using the same loop that already manages pods.
Crossplane ou Terraform : qui corrige la dérive en premier
Terraform détecte la dérive au prochain plan, quand quelqu'un pense à l'exécuter. Crossplane la corrige en continu, via le même mécanisme qui gère déjà les pods.
Faut-il migrer vers Kubernetes ? Cadre de décision PME-ETI
Un cadre concret pour savoir si votre infrastructure a besoin de Kubernetes maintenant, dans un an, ou jamais, avant de payer pour le découvrir.
Should You Migrate to Kubernetes? A Decision Framework
A concrete framework to work out whether your infrastructure needs Kubernetes now, in a year, or never, before paying a consultant to find out for you.
Velero: Backing Up a Kubernetes Cluster, Not Just Its Data
A volume snapshot backs up neither your Deployments, nor your Secrets, nor your cluster's structure. What Velero covers, and why testing restores matters.
Velero : sauvegarder un cluster Kubernetes, pas juste ses données
Un snapshot de volume ne sauvegarde ni vos Deployments, ni vos Secrets, ni la structure de votre cluster. Ce que Velero couvre, et pourquoi le tester avant d'en avoir besoin.
Cardinalité Prometheus : un label sans limite explose tout
Un label à valeurs non bornées (ID de requête, IP client) multiplie les séries stockées à l'infini. La cardinalité, pas le nombre de métriques, dimensionne Prometheus.
Déploiement progressif multi-cluster : au-delà du pod
Un canary réussi sur un cluster ne garantit rien sur les autres régions. Comment orchestrer un rollout progressif entre clusters, vague par vague.
Multi-Cluster Progressive Rollout, Beyond the Pod
A successful canary on one cluster guarantees nothing about the others. How to orchestrate a progressive rollout across clusters, wave by wave.
Prometheus Cardinality: One Unbounded Label Explodes Everything
An unbounded label (request ID, client IP) multiplies stored series without limit. Cardinality, not metric count, is what actually sizes Prometheus.
QoS Classes: The Eviction Order Nobody Chose
Kubernetes assigns a QoS class from requests/limits, never an explicit choice. A critical service with no limits gets evicted first.
Monorepo CI/CD: Affected-Graph Builds That Actually Scale
Why a monorepo that rebuilds everything on every commit stops scaling, how a dependency graph determines what actually changed, and the remote-cache hash trap.
Monorepo CI/CD : builds sélectifs par graphe de dépendances
Pourquoi un monorepo qui teste tout à chaque commit ne scale pas, comment un graphe de dépendances détermine ce qui a changé, et le piège du cache mal invalidé.
PriorityClass: Guaranteeing a Critical Pod Always Schedules
Without a defined priority, every pod is equal to the scheduler on a saturated node. PriorityClass and preemption decide who stays and who gets evicted when capacity runs out.
PriorityClass : garantir qu'un pod critique se place toujours
Sans priorité définie, tous les pods sont égaux devant un nœud saturé. PriorityClass et la préemption décident qui reste et qui se fait évincer quand la capacité manque.
Classes QoS : l'ordre d'éviction que personne n'a choisi
La classe QoS d'un pod fixe son ordre d'éviction, déduite des requests/limits, jamais choisie explicitement. Un service critique sans limits part en premier.
Chaos Engineering: Validating Resilience Before the Incident
A PodDisruptionBudget never tested is a hypothesis, not a guarantee. Chaos engineering forces the failure under controlled conditions to prove it.
Chaos engineering : valider la résilience avant l'incident
Un PodDisruptionBudget jamais testé est une hypothèse, pas une garantie. Le chaos engineering provoque la panne en conditions contrôlées pour le vérifier.
metrics-server: The Silent Prerequisite Behind HPA and kubectl top
kubectl top pod and HPA have no data to read without metrics-server installed. How it actually works, and the most common certificate error at install time.
metrics-server : le prérequis silencieux derrière HPA et kubectl top
kubectl top pod et le HPA n'ont aucune donnée à lire sans metrics-server installé. Comment il fonctionne, et l'erreur de certificat la plus fréquente à l'installation.
Pod Security Standards: Security via a Namespace Label
PodSecurityPolicy has been dead since Kubernetes 1.25. Pod Security Admission replaces it with three profiles applied through a single namespace label.
Pod Security Standards : la sécurité par label de namespace
PodSecurityPolicy est mort depuis Kubernetes 1.25. Pod Security Admission le remplace par trois profils appliqués via un simple label de namespace.
Terraform, OpenTofu, Pulumi : comment choisir son outil IaC
Le choix d'un outil IaC ne se résume pas à une préférence de syntaxe. Licence, écosystème de providers, et le vrai coût d'une migration une fois engagé.
Terraform, OpenTofu, Pulumi: Choosing an IaC Tool
Choosing an infrastructure-as-code tool isn't really a syntax preference. License, provider ecosystem, and the real cost of migrating once you're committed.
Pourquoi personne ne sait combien coûte un namespace Kubernetes
La facture cloud arrive par nœud, jamais par namespace. Sans allocation par requests, chaque équipe partage un coût qu'aucune ne peut expliquer seule.
Why Nobody Knows What a Kubernetes Namespace Actually Costs
The cloud bill arrives per node, never per namespace. Without allocation by requests, every team shares a cost none of them can explain alone.
Pod Anti-Affinity and Topology Spread for Real HA
Three replicas scheduled on the same node protect against nothing. Pod anti-affinity and topology spread constraints solve the same problem through two different mechanics.
Pod anti-affinity et topology spread : répartir pour la HA
Trois replicas planifiées sur le même nœud ne protègent de rien. Pod anti-affinity et topology spread constraints résolvent le même problème par deux mécaniques différentes.
Renovate vs Dependabot: Automating Updates Without the Mess
A dependency never updated becomes a security debt that accumulates silently. Renovate and Dependabot both automate updates, but not the same way.
Renovate ou Dependabot : automatiser les mises à jour sans y perdre
Une dépendance jamais mise à jour devient une dette de sécurité qui s'accumule en silence. Renovate et Dependabot automatisent la mise à jour, pas la même façon.
Taints et tolerations : empêcher un pod de se poser
Les taints repoussent tous les pods d'un nœud sauf ceux qui les tolèrent explicitement. Les trois effets, et pourquoi ce n'est pas une affinité positive.
Taints and Tolerations: Keeping Pods Off a Node
Taints repel every pod from a node except those that explicitly tolerate them. The three effects, and why this isn't a positive-affinity mechanism.
Ansible: The Promised Idempotence and the Check Mode Trap
Why a replayed playbook should change nothing, how check mode lies about shell-based modules, and a simple rule for sorting your Ansible tasks.
Ansible : l'idempotence promise et le piège du check mode
Pourquoi un playbook rejoué ne devrait rien changer, comment le check mode ment sur les modules à commande shell, et une règle simple pour trier ses tâches.
ArgoCD ou Flux : comment choisir son outil GitOps
ArgoCD et Flux résolvent le même problème par deux modèles différents : UI centralisée contre contrôleurs composables. Le vrai critère de choix.
ArgoCD vs Flux: Choosing a GitOps Tool
ArgoCD and Flux solve the same problem with two different models: a centralized UI versus a set of composable controllers. The criterion that actually decides.
Karpenter ou Cluster Autoscaler : au-delà des groupes de nœuds
Le Cluster Autoscaler reste prisonnier des groupes de nœuds préconfigurés. Karpenter provisionne l'instance exacte dont le pod a besoin, sans ce détour.
Karpenter vs Cluster Autoscaler: Beyond Node Groups
Cluster Autoscaler stays locked into preconfigured node groups. Karpenter provisions the exact instance a pod needs, no detour through a group.
etcd: The Component You Forget Until the Incident
This component stores a cluster's entire state and tolerates zero disk latency. Losing etcd quorum only recovers cleanly if you have a tested backup.
etcd : le composant qu'on oublie jusqu'à l'incident
Ce composant stocke tout l'état du cluster et n'a droit à aucune latence disque. Une perte de quorum etcd ne se répare proprement qu'avec une sauvegarde testée.
Kyverno vs OPA/Gatekeeper: Which Kubernetes Policy Engine
Two Kubernetes policy engines, two models: native YAML versus a dedicated query language. What actually matters for the choice, beyond syntax familiarity.
Kyverno ou OPA/Gatekeeper : quel moteur de policy Kubernetes
Deux moteurs de policy Kubernetes, deux modèles : YAML natif contre langage de requête dédié. Ce qui compte pour choisir, au-delà de la syntaxe.
ResourceQuota et LimitRange : gouverner un namespace, pas un pod
Des requests bien posées protègent un pod. Rien n'empêche une équipe d'en créer mille sans limite globale. ResourceQuota et LimitRange gouvernent au niveau du namespace.
ResourceQuota and LimitRange: Governing a Namespace, Not a Pod
Well-set requests protect a single pod. Nothing stops a team from creating a thousand of them with no global cap. ResourceQuota and LimitRange govern at the namespace level.
kubectl debug: Debugging a Pod With No Shell, No Restart
A distroless image has no shell and no diagnostic tools, by deliberate security choice. Ephemeral containers let you debug it anyway, without redeploying.
kubectl debug : déboguer un pod sans shell
Une image distroless n'a ni shell ni outils de diagnostic, par choix de sécurité. Les conteneurs éphémères permettent de déboguer quand même, sans redéployer.
Kubernetes Admission Webhooks: Mechanics and Pitfalls
An admission webhook is an explicit single point of failure. failurePolicy: Fail can block an entire cluster if the webhook becomes unreachable.
Webhooks d'admission Kubernetes : mécanique et pièges
Un webhook d'admission est un point de défaillance unique explicite. failurePolicy: Fail peut bloquer tout le cluster si le webhook devient injoignable.
StatefulSet : quand un Deployment ne suffit pas
Un Deployment traite ses pods comme interchangeables. Une base de données ne l'est pas : elle a besoin d'une identité stable et de son propre volume. C'est le rôle du StatefulSet.
StatefulSet: When a Deployment Isn't Enough
A Deployment treats its pods as interchangeable. A database isn't: it needs a stable identity and its own volume. That's what StatefulSet is for.
VPA: Sizing Pods Without Guessing by Hand
The VPA sizes CPU/memory requests from real consumption. Its Auto mode restarts pods to apply a new sizing, a cost that's easy to overlook.
VPA : dimensionner les pods sans deviner à la main
Le VPA sert à dimensionner les requests CPU/mémoire à partir de la consommation réelle. Son mode Auto redémarre les pods à chaque ajustement.
Prometheus/Grafana ou SaaS : quand le payant vaut le coût
Le choix entre Prometheus auto-hébergé et une plateforme SaaS n'est pas idéologique. Un calcul de coût total : infrastructure et exploitation contre facturation à l'ingestion.
Kubernetes RBAC: Least Privilege in Practice
Kubernetes RBAC denies everything by default, but an overly broad role never breaks anything: it just sits there, silent, until the incident that exposes it.
RBAC Kubernetes : le moindre privilège, en pratique
RBAC Kubernetes refuse tout par défaut, mais un rôle trop large ne casse jamais rien : il existe, silencieux, jusqu'à l'incident qui l'expose.
Prometheus/Grafana or SaaS: When Paid Is Worth It
The choice between self-hosted Prometheus and SaaS observability isn't ideological. A total-cost calculation: infrastructure and operations versus ingestion billing.
DaemonSet: Exactly One Pod Per Node, Never More, Never Less
A Deployment guarantees no per-node distribution. DaemonSet guarantees an exact one: one pod on every node, the mechanism behind most infrastructure agents.
DaemonSet : exactement un pod par nœud
Un Deployment ne garantit aucune répartition par nœud. DaemonSet en garantit une exacte, le mécanisme derrière la plupart des agents d'infrastructure.
CrashLoopBackOff: The Method for Finding the Real Cause
CrashLoopBackOff is a symptom, never a cause. Three radically different root-cause families, one diagnostic method to tell them apart in a few commands.
CrashLoopBackOff : la méthode pour trouver la vraie cause
CrashLoopBackOff est un symptôme, jamais une cause. Trois familles d'origine différentes, une méthode pour les distinguer en quelques commandes.
Istio or Linkerd: Is a Service Mesh Worth Its Weight?
A service mesh adds a proxy per pod for free mTLS and observability. Istio and Linkerd pay for that benefit at very different prices.
Istio ou Linkerd : le service mesh vaut-il son poids ?
Un service mesh ajoute un proxy par pod pour du mTLS et de l'observabilité gratuits. Istio et Linkerd payent ce bénéfice à un prix très différent.
Job and CronJob: Running a Task to Completion
A Deployment keeps its pods alive indefinitely. A migration or a nightly batch needs to finish, not stay alive. Job and CronJob answer that different need.
Job et CronJob : faire tourner une tâche jusqu'au bout
Un Deployment garde ses pods vivants indéfiniment. Une migration ou un batch nocturne doit se terminer, pas rester vivant. Job et CronJob répondent à ce besoin différent.
GitOps with ArgoCD: Declarative Deployment Explained
How ArgoCD continuously reconciles cluster state with Git, the difference between push and pull deployment, and what drift actually reveals.
GitOps avec ArgoCD : le déploiement déclaratif expliqué
Comment ArgoCD réconcilie en continu l'état du cluster avec Git, la différence entre push et pull deployment, et ce que la dérive (drift) révèle vraiment.
kubectl apply : le merge que personne ne regarde vraiment
kubectl apply n'écrase pas un objet, il le fusionne. Ce mécanisme invisible explique pourquoi un kubectl edit manuel disparaît silencieusement au prochain déploiement.
kubectl apply: The Merge Nobody Actually Looks At
kubectl apply doesn't overwrite an object, it merges it. That invisible mechanism explains why a manual kubectl edit silently vanishes on the next deploy.
CI Runners: Self-Hosted or Hosted, the Real Calculation
A runner hosted by GitHub or GitLab can never reach your internal network. The choice between self-hosted and hosted isn't primarily a cost question.
Runners CI auto-hébergés ou hébergés : le vrai calcul
Des runners CI hébergés par GitHub ou GitLab ne peuvent jamais atteindre votre réseau interne. Le vrai calcul n'est pas d'abord une question de coût à la minute.
Cache Docker en CI : l'ordre des layers avant l'outil
Un cache Docker mal ordonné invalide tout à chaque commit, peu importe le backend. Ce qui détermine réellement le taux de cache hit en CI, avant même BuildKit.
Docker Build Cache in CI: Layer Order Beats the Tool
A badly ordered Docker cache invalidates everything on every commit, regardless of backend. What actually determines cache hit rate in CI, before BuildKit even matters.
Déploiement progressif depuis la CI : canary et flags
Comment un rollout canary se déclenche et se juge depuis le pipeline via Prometheus, et pourquoi déploiement et release ne sont pas le même événement.
Progressive Delivery: Canary Analysis and Feature Flags
How a canary rollout gets triggered and judged automatically from the pipeline using Prometheus metrics, and why deployment and release are not the same event.
Consul : catalogue de services et health checks qui mentent
Comment Consul distingue un service enregistré d'un service joignable, pourquoi un health check mal conçu masque une panne, et le rôle du consensus Raft.
Consul: The Service Catalog and Health Checks That Lie
How Consul tells a registered service apart from a reachable one, why a shallow health check hides an outage, and what Raft consensus is doing in there.
Burn-rate alerting : du SLO à l'alerte multi-fenêtres
Un SLO et un budget d'erreur ne disent pas quand alerter. La méthode burn-rate multi-fenêtres, simplifiée pour une PME, pour agir avant l'épuisement du budget.
Multi-window burn-rate alerting: catching SLO drift early
A static SLO and error budget don't say when to page. Multi-window burn-rate alerting, simplified for a small team, catches trouble before the budget runs out.
Scanning and Signing Container Images in CI/CD
Vulnerability scanning as a pipeline gate, keyless image signing with cosign, SBOM generation, and verifying signatures at admission before an image runs.
Scanner et signer ses images de conteneurs en CI/CD
Scan de vulnérabilités en garde-fou de pipeline, signature keyless des images de conteneurs avec cosign, SBOM et vérification à l'admission Kubernetes.
Helm Charts: Templates, Values, and the Model's Limits
How a Helm chart generates YAML from templates and values, why nested conditionals become unreadable, and when Kustomize is the better fit.
Helm charts : templates, values et les limites du modèle
Comment un chart Helm génère du YAML à partir de templates et de valeurs, pourquoi les conditions imbriquées deviennent illisibles, et quand préférer Kustomize.
Blackbox Monitoring: Watching From the Outside
Why internal metrics never see the whole picture, how blackbox_exporter probes HTTP, TLS and certificate expiry, and the network false-positive trap.
Blackbox monitoring : superviser depuis l'extérieur
Pourquoi les métriques internes ne suffisent jamais, comment blackbox_exporter sonde HTTP, TLS et expiration de certificats, et le piège du faux positif réseau.
CI Secrets: From Masked Variables to OIDC Identity
How CI secrets leak from a masked variable, why masking isn't a security boundary, and how OIDC federation replaces long-lived keys with short-lived tokens.
Secrets CI : de la variable masquée à l'OIDC
Comment un credential cloud dans la CI finit par fuiter, pourquoi masquer une variable n'est pas une frontière de sécurité, et ce que change l'identité fédérée.
Cluster Autoscaler : pourquoi le scale down traîne
Le Cluster Autoscaler ajoute des nœuds facilement. Le scale down casse en silence : PDB trop stricts, pods sans contrôleur, annotation oubliée.
Cluster Autoscaler: Why Scale Down Stalls (or Never Happens)
The Cluster Autoscaler adds nodes easily. Scale down is where it silently breaks: overly strict PDBs, controller-less pods, and one forgotten annotation.
Centraliser ses logs avec Loki sans exploser le stockage
Pourquoi Loki n'indexe pas le contenu des logs, ce que ça change pour le coût de stockage et LogQL, et les pièges de cardinalité qui annulent l'économie.
Centralizing Logs with Loki Without Exploding Storage Costs
Why Loki doesn't index log content, what that means for storage cost and LogQL, and the label cardinality traps that undo the savings.
Build once, promote everywhere : promotion par digest
Pourquoi rebuilder par environnement empêche de garantir qu'on déploie ce qu'on a testé, comment marche la promotion par digest, et le piège du tag flottant.
Build Once, Promote the Same Artifact Everywhere
Why rebuilding per environment cannot guarantee you deploy what you tested, how artifact promotion by digest works, and the floating-tag trap.
Ingress and cert-manager: TLS That Renews Without You
How an Ingress routes HTTP traffic to your services, what cert-manager actually automates for Let's Encrypt certificates, and the HTTP-01 challenge trap.
Ingress et cert-manager : le TLS qui se renouvelle sans vous
Comment un Ingress route le trafic HTTP, ce que cert-manager automatise pour les certificats Let's Encrypt, et le piège du challenge HTTP-01.
Distributed Tracing: Spans and What OpenTelemetry Solves
Why distributed tracing beats metrics and logs alone on a request crossing ten services, how context propagates, and the sampling trap.
Tracing distribué : spans et ce qu'OpenTelemetry résout
Pourquoi le tracing complète métriques et logs sur une requête qui traverse dix services, comment le contexte se propage, et le piège du sampling.
Database Migrations in the CI/CD Pipeline
How to sequence a database migration job ahead of a rollout, the expand/contract pattern for zero-downtime changes, and why rollback is often a myth.
Migrations de base de données dans le pipeline CI/CD
Comment ordonnancer les migrations de schéma avant un rollout, le pattern expand/contract pour rester compatible, et pourquoi le rollback est souvent un mythe.
HPA : ce que l'autoscaling horizontal suppose déjà en place
Pourquoi le Horizontal Pod Autoscaler ne fonctionne pas sans requests correctement posées, comment il décide de scaler, et le piège de l'oscillation.
HPA: What Horizontal Autoscaling Already Assumes in Place
Why the Horizontal Pod Autoscaler doesn't work without requests set correctly, how it decides to scale, and the flapping trap.
Symptom-based Prometheus alerts that don't page at 3am
Why symptom-based Prometheus alerts beat cause-based ones, how the for clause and severity labels cut noise, plus a bad rule rewritten into a good one.
Alertes Prometheus actionnables : symptômes, pas les causes
Pourquoi alerter sur les symptômes et non les causes, comment régler la clause for et le label severity, et une mauvaise règle Prometheus réécrite proprement.
kubectl rollout undo: How Kubernetes Rollbacks Work
How Deployment revisions map to ReplicaSets, what kubectl rollout undo actually restores, why GitOps prefers a Git revert, and the gotchas around rollbacks.
kubectl rollout undo : comment fonctionnent les rollbacks
Comment les révisions d'un Deployment correspondent aux ReplicaSets, ce que kubectl rollout undo restaure vraiment, et pourquoi GitOps préfère un revert Git.
PodDisruptionBudget: What It Actually Protects Against
What a Kubernetes PodDisruptionBudget guards (voluntary evictions, not node crashes), minAvailable vs maxUnavailable, and the misconfigs that stall drains.
PodDisruptionBudget : contre quoi il protège vraiment
Ce qu'un PodDisruptionBudget garde : évictions volontaires, pas crashs de nœud, minAvailable contre maxUnavailable, et les erreurs qui bloquent les drains.
Dashboards Grafana qu'on regarde vraiment : RED et USE
Pourquoi la plupart des dashboards Grafana ne servent à rien en plein incident, et comment les méthodes RED et USE structurent ce qu'on consulte sous pression.
Grafana Dashboards Worth Looking At: RED and USE Methods
Why most Grafana dashboards are useless mid-incident, and how the RED and USE methods give you a structure people actually consult under pressure.
Kubernetes Secrets: Plain Secrets, Sealed Secrets, or Vault?
Kubernetes Secrets are base64, not encryption. How Sealed Secrets make manifests git-safe, when external Vault earns its cost, and how to choose.
Kubernetes : Secrets natifs, Sealed Secrets ou Vault ?
Les Secrets Kubernetes sont du base64, pas du chiffrement. Comment Sealed Secrets rend un manifeste committable, quand Vault vaut son coût, comment choisir.
Readiness, Liveness and Startup Probes in Kubernetes
What each Kubernetes probe type actually gates, the failure modes of copy-pasted probe configs, and a decision table for setting each parameter.
Probes Kubernetes : readiness, liveness et startup
Ce que chaque type de probe Kubernetes contrôle réellement, les modes de défaillance des configs copiées-collées, et une table de décision par paramètre.
Instrumenter une app Prometheus : golden signals
Golden signals, méthode RED et histogramme plutôt que summary pour la latence : comment instrumenter une application Prometheus, avec les requêtes PromQL.
Instrumenting an app for Prometheus: golden signals
Golden signals and the RED method: why latency uses a histogram, not a summary, when instrumenting an app for Prometheus, with matching PromQL queries.
Terraform Remote State and Locking: How It Actually Works
Why local Terraform state breaks a team, how remote backends and state locking work on S3, GCS and HCP, and how to recover from a stale lock safely.
State Terraform distant et verrouillage : comment ça marche
Pourquoi le state local casse en équipe, comment marchent les backends distants et le verrouillage, et comment récupérer proprement d'un verrou bloqué.
Kubernetes requests vs limits: throttling, OOMKill and QoS
What actually happens when a pod crosses its CPU or memory limit, how QoS classes are derived, the no-limits debate, and a method to set sane defaults.
Requests et limits Kubernetes : throttling, OOMKill et QoS
Ce qui se passe vraiment quand un pod Kubernetes dépasse sa limite CPU ou mémoire, les classes QoS, le débat des limites, et une méthode de réglage.