<?xml version="1.0" encoding="utf-8" standalone="yes"?><rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom"><channel><title>Devops on Simple Enough Blog</title><link>https://blog.dev.simpleenough.net/fr/tags/devops/</link><description>Recent content in Devops on Simple Enough Blog</description><generator>Hugo</generator><language>fr</language><lastBuildDate>Wed, 27 May 2026 15:55:01 +0200</lastBuildDate><atom:link href="https://blog.dev.simpleenough.net/fr/tags/devops/index.xml" rel="self" type="application/rss+xml"/><item><title>Qu’est-ce qu’un Harness pour agents IA ? Comprendre l’infrastructure derrière Claude Code et Cursor</title><link>https://blog.dev.simpleenough.net/fr/blog/harness_intro/</link><pubDate>Wed, 27 May 2026 15:55:01 +0200</pubDate><guid>https://blog.dev.simpleenough.net/fr/blog/harness_intro/</guid><description>&lt;h2 id="i-quest-ce-quun-harness-pour-agents-ia-" class="heading">I. Qu’est-ce qu’un Harness pour agents IA ?&lt;a href="#i-quest-ce-quun-harness-pour-agents-ia-" aria-labelledby="i-quest-ce-quun-harness-pour-agents-ia-">
&lt;!-- &lt;i class="fas fa-link anchor">&lt;/i> -->
 &lt;svg class="svg-inline--fa fas fa-link anchor" fill="currentColor" aria-hidden="true" role="img" viewBox="0 0 640 512">&lt;use href="#fas-link">&lt;/use>&lt;/svg>&amp;nbsp;
 &lt;/a>
&lt;/h2>
&lt;p>Lorsque l’on découvre des outils comme &lt;strong>Claude Code&lt;/strong>, &lt;strong>Cursor&lt;/strong> ou &lt;strong>OpenAI Codex&lt;/strong>, il est facile d’avoir l’impression qu’un simple modèle de langage est capable de comprendre un projet complet, corriger du code, exécuter des commandes ou encore lancer des tests de manière autonome.&lt;/p>
&lt;p>Pourtant, la réalité technique est bien plus intéressante.&lt;/p></description></item><item><title>CheckList EC2 : 7 choses à faire après le lancement d'une instance</title><link>https://blog.dev.simpleenough.net/fr/blog/ec2_checklist/</link><pubDate>Wed, 20 May 2026 19:30:00 +0100</pubDate><guid>https://blog.dev.simpleenough.net/fr/blog/ec2_checklist/</guid><description>&lt;h1 id="checklist-ec2--7-choses-à-faire-après-le-lancement-dune-instance" class="heading">CheckList EC2 : 7 choses à faire après le lancement d&amp;rsquo;une instance&lt;a href="#checklist-ec2--7-choses-%c3%a0-faire-apr%c3%a8s-le-lancement-dune-instance" aria-labelledby="checklist-ec2--7-choses-à-faire-après-le-lancement-dune-instance">
&lt;!-- &lt;i class="fas fa-link anchor">&lt;/i> -->
 &lt;svg class="svg-inline--fa fas fa-link anchor" fill="currentColor" aria-hidden="true" role="img" viewBox="0 0 640 512">&lt;use href="#fas-link">&lt;/use>&lt;/svg>&amp;nbsp;
 &lt;/a>
&lt;/h1>
&lt;p>Lancer une instance EC2 est très simple.&lt;br>
Quelques clics dans la console AWS, et la machine démarre.&lt;/p>
&lt;p>Mais en pratique, &lt;strong>une instance lancée n’est pas une instance prête&lt;/strong>.&lt;/p>
&lt;p>Beaucoup de problèmes en production viennent de détails oubliés juste après le lancement :&lt;/p>
&lt;ul>
&lt;li>mauvais security group&lt;/li>
&lt;li>pas de sauvegarde&lt;/li>
&lt;li>pas de monitoring&lt;/li>
&lt;li>pas de rôle IAM&lt;/li>
&lt;li>accès SSH mal configuré&lt;/li>
&lt;li>disque trop petit&lt;/li>
&lt;li>pas de tag&lt;/li>
&lt;/ul>
&lt;p>Voici une checklist simple et pragmatique des &lt;strong>7 choses à vérifier immédiatement après avoir lancé une instance EC2&lt;/strong>.&lt;/p></description></item><item><title>Nx n’est pas un outil JavaScript : c’est un orchestrateur de travail</title><link>https://blog.dev.simpleenough.net/fr/blog/nx/</link><pubDate>Wed, 13 May 2026 12:00:00 +0100</pubDate><guid>https://blog.dev.simpleenough.net/fr/blog/nx/</guid><description>&lt;h2 id="i-nx-nest-pas-un-outil-javascript--cest-un-orchestrateur-de-travail" class="heading">I. Nx n’est pas un outil JavaScript : c’est un orchestrateur de travail&lt;a href="#i-nx-nest-pas-un-outil-javascript--cest-un-orchestrateur-de-travail" aria-labelledby="i-nx-nest-pas-un-outil-javascript--cest-un-orchestrateur-de-travail">
&lt;!-- &lt;i class="fas fa-link anchor">&lt;/i> -->
 &lt;svg class="svg-inline--fa fas fa-link anchor" fill="currentColor" aria-hidden="true" role="img" viewBox="0 0 640 512">&lt;use href="#fas-link">&lt;/use>&lt;/svg>&amp;nbsp;
 &lt;/a>
&lt;/h2>
&lt;p>Nx est souvent présenté — et perçu — comme un outil JavaScript.&lt;br>
Un “truc pour Angular”, ou au mieux “un runner pour monorepos Node”.&lt;/p>
&lt;p>Cette perception est compréhensible…&lt;br>
mais &lt;strong>fondamentalement incorrecte&lt;/strong>.&lt;/p>
&lt;p>Nx n’est pas un outil JS.&lt;br>
&lt;strong>Nx est un orchestrateur de travail.&lt;/strong>&lt;/p>
&lt;p>Et c’est précisément pour cette raison qu’il apparaît presque naturellement
dès qu’un dépôt devient &lt;strong>polyglotte&lt;/strong>.&lt;/p></description></item><item><title>Introduction à AWS Lambda : le guide complet pour débutants et développeurs</title><link>https://blog.dev.simpleenough.net/fr/blog/lambda_intro/</link><pubDate>Wed, 06 May 2026 10:00:00 +0100</pubDate><guid>https://blog.dev.simpleenough.net/fr/blog/lambda_intro/</guid><description>&lt;h2 id="i-cest-quoi-aws-lambda-" class="heading">I. C&amp;rsquo;est quoi AWS Lambda ?&lt;a href="#i-cest-quoi-aws-lambda-" aria-labelledby="i-cest-quoi-aws-lambda-">
&lt;!-- &lt;i class="fas fa-link anchor">&lt;/i> -->
 &lt;svg class="svg-inline--fa fas fa-link anchor" fill="currentColor" aria-hidden="true" role="img" viewBox="0 0 640 512">&lt;use href="#fas-link">&lt;/use>&lt;/svg>&amp;nbsp;
 &lt;/a>
&lt;/h2>
&lt;p>AWS Lambda est un service de &lt;strong>calcul serverless&lt;/strong> lancé par Amazon en 2014. L&amp;rsquo;idée est simple : on fournit une fonction (un morceau de code), et AWS l&amp;rsquo;exécute à la demande, sans qu&amp;rsquo;on aie à gérer le moindre serveur.
Vous n’avez pas de serveur à provisionner, pas d’OS à maintenir, pas d’autoscaling à configurer à la main.&lt;/p></description></item><item><title>Pourquoi le cache Docker est insuffisant pour un monorepo ?</title><link>https://blog.dev.simpleenough.net/fr/blog/cache_docker/</link><pubDate>Tue, 28 Apr 2026 10:00:00 +0100</pubDate><guid>https://blog.dev.simpleenough.net/fr/blog/cache_docker/</guid><description>&lt;h2 id="i-pourquoi-le-cache-docker-est-insuffisant-pour-un-monorepo" class="heading">I. Pourquoi le cache Docker est insuffisant pour un monorepo&lt;a href="#i-pourquoi-le-cache-docker-est-insuffisant-pour-un-monorepo" aria-labelledby="i-pourquoi-le-cache-docker-est-insuffisant-pour-un-monorepo">
&lt;!-- &lt;i class="fas fa-link anchor">&lt;/i> -->
 &lt;svg class="svg-inline--fa fas fa-link anchor" fill="currentColor" aria-hidden="true" role="img" viewBox="0 0 640 512">&lt;use href="#fas-link">&lt;/use>&lt;/svg>&amp;nbsp;
 &lt;/a>
&lt;/h2>
&lt;p>Docker est partout.&lt;br>
Et avec lui, une idée largement répandue :&lt;/p>





 &lt;blockquote class="blockquote">
 &lt;p>&lt;em>« Si on structure bien nos Dockerfiles, le cache Docker va accélérer notre CI. »&lt;/em>&lt;/p>
 &lt;/blockquote>
&lt;p>C’est &lt;strong>vrai&lt;/strong>… mais seulement &lt;strong>jusqu’à un certain point&lt;/strong>.&lt;/p>
&lt;p>Dès qu’on travaille dans un &lt;strong>monorepo&lt;/strong> — avec plusieurs projets, plusieurs langages, plusieurs pipelines logiques — le cache Docker montre rapidement ses limites.&lt;/p></description></item><item><title>Que faut-il vraiment cacher dans un pipeline CI/CD ?</title><link>https://blog.dev.simpleenough.net/fr/blog/cache_cicd/</link><pubDate>Tue, 21 Apr 2026 10:00:00 +0100</pubDate><guid>https://blog.dev.simpleenough.net/fr/blog/cache_cicd/</guid><description>&lt;h2 id="i-introduction" class="heading">I. Introduction&lt;a href="#i-introduction" aria-labelledby="i-introduction">
&lt;!-- &lt;i class="fas fa-link anchor">&lt;/i> -->
 &lt;svg class="svg-inline--fa fas fa-link anchor" fill="currentColor" aria-hidden="true" role="img" viewBox="0 0 640 512">&lt;use href="#fas-link">&lt;/use>&lt;/svg>&amp;nbsp;
 &lt;/a>
&lt;/h2>
&lt;p>Quand on cherche à accélérer un pipeline CI/CD, la première idée qui vient presque toujours est :&lt;/p>





 &lt;blockquote class="blockquote">
 &lt;p>&lt;em>« il faut mettre du cache »&lt;/em>&lt;/p>
 &lt;/blockquote>
&lt;p>Mais très vite, une autre question apparaît :&lt;br>
&lt;strong>qu’est-ce qu’on cache exactement ?&lt;/strong>&lt;/p>
&lt;p>Des fichiers ? Des dossiers ? Des images Docker ? Des dépendances ?&lt;br>
Et surtout : &lt;strong>quel cache a un vrai impact, et lequel complique juste le système ?&lt;/strong>&lt;/p></description></item><item><title>Penser top-down dans un monde complexe</title><link>https://blog.dev.simpleenough.net/fr/blog/top_down/</link><pubDate>Tue, 07 Apr 2026 17:30:00 +0100</pubDate><guid>https://blog.dev.simpleenough.net/fr/blog/top_down/</guid><description>&lt;h2 id="i-deux-manières-fondamentales-de-raisonner" class="heading">I. Deux manières fondamentales de raisonner&lt;a href="#i-deux-mani%c3%a8res-fondamentales-de-raisonner" aria-labelledby="i-deux-manières-fondamentales-de-raisonner">
&lt;!-- &lt;i class="fas fa-link anchor">&lt;/i> -->
 &lt;svg class="svg-inline--fa fas fa-link anchor" fill="currentColor" aria-hidden="true" role="img" viewBox="0 0 640 512">&lt;use href="#fas-link">&lt;/use>&lt;/svg>&amp;nbsp;
 &lt;/a>
&lt;/h2>
&lt;p>Lorsqu’on observe la façon dont on conçoit aujourd’hui des &lt;strong>systèmes complexes&lt;/strong> — infrastructures DevOps, plateformes distribuées, logiciels modernes ou même parcours éducatifs — on retrouve presque toujours la même tension intellectuelle. D’un côté, une approche &lt;strong>progressive et incrémentale&lt;/strong>, qui part des bases pour aller vers quelque chose de plus élaboré. De l’autre, une approche &lt;strong>orientée par le résultat attendu&lt;/strong>, qui commence par définir un &lt;strong>objectif&lt;/strong>, puis remonte ce qui est nécessaire pour l’atteindre.&lt;/p></description></item><item><title>Chaos engineering du quotidien : apprendre à aimer la vague</title><link>https://blog.dev.simpleenough.net/fr/blog/wave/</link><pubDate>Tue, 24 Mar 2026 10:00:00 +0100</pubDate><guid>https://blog.dev.simpleenough.net/fr/blog/wave/</guid><description>&lt;p>Nous rêvons tous d’un système stable, prévisible, “calme”.
Et pourtant, la réalité d’une plateforme moderne, c’est une mer vivante : déploiements, dépendances externes, quotas cloud, réseaux capricieux, pics de charge, erreurs humaines, et parfois… juste “un truc” qui n’aurait pas dû arriver.&lt;/p>
&lt;p>Le chaos engineering est souvent présenté comme une discipline spectaculaire — “on coupe une zone AWS”, “on tue un cluster”, “on fait tomber Kafka”.
Dans la vraie vie (et surtout en petite équipe), ce n’est ni nécessaire, ni souhaitable au départ.&lt;/p></description></item><item><title>Cycle du DevOps ou incompréhension du métier ?</title><link>https://blog.dev.simpleenough.net/fr/blog/devops_cycle/</link><pubDate>Tue, 17 Mar 2026 11:00:00 +0100</pubDate><guid>https://blog.dev.simpleenough.net/fr/blog/devops_cycle/</guid><description>&lt;h2 id="introduction" class="heading">Introduction&lt;a href="#introduction" aria-labelledby="introduction">
&lt;!-- &lt;i class="fas fa-link anchor">&lt;/i> -->
 &lt;svg class="svg-inline--fa fas fa-link anchor" fill="currentColor" aria-hidden="true" role="img" viewBox="0 0 640 512">&lt;use href="#fas-link">&lt;/use>&lt;/svg>&amp;nbsp;
 &lt;/a>
&lt;/h2>
&lt;p>Le terme &lt;em>DevOps&lt;/em> est fréquemment employé pour désigner un ensemble hétérogène de sujets : CI/CD, cloud, Kubernetes, sécurité, observabilité, gestion des incidents, gestion des coûts, etc. Cette polysémie entretient une confusion récurrente : l’organisation exprime un besoin de “DevOps”, mais sans préciser la valeur attendue, les responsabilités associées, ni le modèle opérationnel cible.&lt;/p>
&lt;p>Le résultat est bien connu : une succession de périodes d’urgence, suivies d’initiatives d’automatisation, puis d’un retour progressif aux mêmes difficultés. On parle alors de “cycle DevOps”. Dans de nombreux cas, ce cycle n’est pas un phénomène intrinsèque au DevOps, mais l’indicateur d’une &lt;strong>incompréhension du métier&lt;/strong> : le DevOps est utilisé comme une fonction de compensation (support, débrouillage, prise en charge implicite de la production) plutôt que comme une capacité organisationnelle structurante.&lt;/p></description></item><item><title>Le vrai coût d’un mauvais workflow CI : la charge cognitive</title><link>https://blog.dev.simpleenough.net/fr/blog/chargecognitiveci/</link><pubDate>Wed, 25 Feb 2026 10:00:00 +0100</pubDate><guid>https://blog.dev.simpleenough.net/fr/blog/chargecognitiveci/</guid><description>&lt;h2 id="i-le-vrai-coût-dun-mauvais-workflow-ci--la-charge-cognitive" class="heading">I. Le vrai coût d’un mauvais workflow CI : la charge cognitive&lt;a href="#i-le-vrai-co%c3%bbt-dun-mauvais-workflow-ci--la-charge-cognitive" aria-labelledby="i-le-vrai-coût-dun-mauvais-workflow-ci--la-charge-cognitive">
&lt;!-- &lt;i class="fas fa-link anchor">&lt;/i> -->
 &lt;svg class="svg-inline--fa fas fa-link anchor" fill="currentColor" aria-hidden="true" role="img" viewBox="0 0 640 512">&lt;use href="#fas-link">&lt;/use>&lt;/svg>&amp;nbsp;
 &lt;/a>
&lt;/h2>
&lt;p>On parle beaucoup de performance des pipelines CI.&lt;br>
On mesure les minutes.&lt;br>
On optimise les caches.&lt;br>
On parallélise.&lt;/p>
&lt;p>Mais le vrai coût d’un mauvais workflow CI n’est pas le temps machine.&lt;/p>
&lt;p>C’est la &lt;strong>charge cognitive&lt;/strong>.&lt;/p>
&lt;p>Et elle est beaucoup plus chère.&lt;/p>
&lt;hr>




&lt;h2 id="ii-le-problème-invisible" class="heading">II. Le problème invisible&lt;a href="#ii-le-probl%c3%a8me-invisible" aria-labelledby="ii-le-problème-invisible">
&lt;!-- &lt;i class="fas fa-link anchor">&lt;/i> -->
 &lt;svg class="svg-inline--fa fas fa-link anchor" fill="currentColor" aria-hidden="true" role="img" viewBox="0 0 640 512">&lt;use href="#fas-link">&lt;/use>&lt;/svg>&amp;nbsp;
 &lt;/a>
&lt;/h2>
&lt;p>Un pipeline CI inefficace est visible :&lt;/p></description></item><item><title>AWS multi-accounts : solution d’architecture ou dette organisationnelle déguisée ?</title><link>https://blog.dev.simpleenough.net/fr/blog/multiaccounts_aws/</link><pubDate>Wed, 18 Feb 2026 17:30:00 +0100</pubDate><guid>https://blog.dev.simpleenough.net/fr/blog/multiaccounts_aws/</guid><description>&lt;h2 id="i-introduction" class="heading">I. Introduction&lt;a href="#i-introduction" aria-labelledby="i-introduction">
&lt;!-- &lt;i class="fas fa-link anchor">&lt;/i> -->
 &lt;svg class="svg-inline--fa fas fa-link anchor" fill="currentColor" aria-hidden="true" role="img" viewBox="0 0 640 512">&lt;use href="#fas-link">&lt;/use>&lt;/svg>&amp;nbsp;
 &lt;/a>
&lt;/h2>
&lt;p>La création de multiples comptes AWS est aujourd’hui présentée comme une &lt;strong>bonne pratique quasi universelle&lt;/strong>.&lt;br>
Elle est souvent introduite par des tutoriels simples, orientés console, qui donnent l’impression que le problème se résume à une série de clics.&lt;/p>
&lt;p>Cette vision est trompeuse.&lt;/p>
&lt;p>Le &lt;strong>multi-account&lt;/strong> n’est pas un détail d’implémentation, mais un &lt;strong>choix architectural fondamental&lt;/strong>.&lt;br>
Il influence directement :&lt;/p></description></item><item><title>Entrer dans le cloud : les portes de l’enfer</title><link>https://blog.dev.simpleenough.net/fr/blog/hell/</link><pubDate>Wed, 04 Feb 2026 09:10:00 +0100</pubDate><guid>https://blog.dev.simpleenough.net/fr/blog/hell/</guid><description>&lt;p>Entrer dans le cloud est rarement vécu comme un simple changement
d’infrastructure.&lt;br>
Pour beaucoup d’organisations, c’est une rupture brutale, presque violente,
avec leurs habitudes, leurs outils et leurs modèles mentaux.&lt;/p>
&lt;p>Ce qui devait apporter de la simplicité révèle au contraire une complexité
jusqu’alors masquée.&lt;br>
Et cette complexité n’est pas seulement technique.&lt;/p>
&lt;hr>




&lt;h2 id="i-lappel-du-cloud" class="heading">I. L’appel du cloud&lt;a href="#i-lappel-du-cloud" aria-labelledby="i-lappel-du-cloud">
&lt;!-- &lt;i class="fas fa-link anchor">&lt;/i> -->
 &lt;svg class="svg-inline--fa fas fa-link anchor" fill="currentColor" aria-hidden="true" role="img" viewBox="0 0 640 512">&lt;use href="#fas-link">&lt;/use>&lt;/svg>&amp;nbsp;
 &lt;/a>
&lt;/h2>
&lt;p>Le cloud commence toujours par une promesse séduisante.&lt;/p></description></item><item><title>Test-Driven Infrastructure : appliquer le TDD à l’Infrastructure as Code</title><link>https://blog.dev.simpleenough.net/fr/blog/infratdd/</link><pubDate>Wed, 14 Jan 2026 13:45:30 +0200</pubDate><guid>https://blog.dev.simpleenough.net/fr/blog/infratdd/</guid><description>&lt;h1 id="test-driven-infrastructure" class="heading">Test-Driven Infrastructure&lt;a href="#test-driven-infrastructure" aria-labelledby="test-driven-infrastructure">
&lt;!-- &lt;i class="fas fa-link anchor">&lt;/i> -->
 &lt;svg class="svg-inline--fa fas fa-link anchor" fill="currentColor" aria-hidden="true" role="img" viewBox="0 0 640 512">&lt;use href="#fas-link">&lt;/use>&lt;/svg>&amp;nbsp;
 &lt;/a>
&lt;/h1>




&lt;h2 id="appliquer-le-tdd-à-linfrastructure-as-code" class="heading">Appliquer le TDD à l’Infrastructure as Code&lt;a href="#appliquer-le-tdd-%c3%a0-linfrastructure-as-code" aria-labelledby="appliquer-le-tdd-à-linfrastructure-as-code">
&lt;!-- &lt;i class="fas fa-link anchor">&lt;/i> -->
 &lt;svg class="svg-inline--fa fas fa-link anchor" fill="currentColor" aria-hidden="true" role="img" viewBox="0 0 640 512">&lt;use href="#fas-link">&lt;/use>&lt;/svg>&amp;nbsp;
 &lt;/a>
&lt;/h2>
&lt;p>Le &lt;strong>Test-Driven Development (TDD)&lt;/strong> est aujourd’hui bien installé côté applicatif.&lt;br>
En revanche, lorsqu’il s’agit d’&lt;strong>infrastructure&lt;/strong>, beaucoup considèrent encore que le TDD est inutile, trop complexe ou inadapté.&lt;/p>
&lt;p>C’est une erreur.&lt;/p>
&lt;p>Le &lt;strong>TDD appliqué à l’infrastructure&lt;/strong> existe déjà, souvent sans être nommé. Lorsqu’il est bien compris, il devient un levier majeur pour &lt;strong>sécuriser, structurer et faire évoluer une plateforme cloud&lt;/strong>.&lt;/p></description></item><item><title>Utiliser les constantes en TDD avec Go</title><link>https://blog.dev.simpleenough.net/fr/blog/consttdd/</link><pubDate>Tue, 23 Dec 2025 10:08:49 +0200</pubDate><guid>https://blog.dev.simpleenough.net/fr/blog/consttdd/</guid><description>&lt;h2 id="bonnes-pratiques-pièges-et-signaux-de-design" class="heading">Bonnes pratiques, pièges et signaux de design&lt;a href="#bonnes-pratiques-pi%c3%a8ges-et-signaux-de-design" aria-labelledby="bonnes-pratiques-pièges-et-signaux-de-design">
&lt;!-- &lt;i class="fas fa-link anchor">&lt;/i> -->
 &lt;svg class="svg-inline--fa fas fa-link anchor" fill="currentColor" aria-hidden="true" role="img" viewBox="0 0 640 512">&lt;use href="#fas-link">&lt;/use>&lt;/svg>&amp;nbsp;
 &lt;/a>
&lt;/h2>
&lt;p>Le &lt;strong>Test-Driven Development (TDD)&lt;/strong> ne sert pas uniquement à écrire des tests.&lt;br>
Il sert avant tout à &lt;strong>concevoir du logiciel&lt;/strong>.&lt;/p>
&lt;p>En Go, l’usage des &lt;strong>constantes&lt;/strong> est souvent mal compris en TDD :&lt;/p>
&lt;ul>
&lt;li>faut-il les exposer ?&lt;/li>
&lt;li>les tester ?&lt;/li>
&lt;li>les injecter ?&lt;/li>
&lt;li>les éviter ?&lt;/li>
&lt;/ul>
&lt;p>Cet article propose une approche &lt;strong>pragmatique et idiomatique Go&lt;/strong>, issue de l’expérience terrain, pour comprendre &lt;strong>quand une constante est un bon design&lt;/strong>… et &lt;strong>quand elle cache un problème&lt;/strong>.&lt;/p></description></item><item><title>Interfaces, Fonctions et Modules en Go : Structurer son code pour le TDD sans le complexifier</title><link>https://blog.dev.simpleenough.net/fr/blog/go-tdd-interfaces-functions/</link><pubDate>Mon, 15 Dec 2025 10:08:49 +0200</pubDate><guid>https://blog.dev.simpleenough.net/fr/blog/go-tdd-interfaces-functions/</guid><description>&lt;h2 id="i-introduction" class="heading">I. Introduction&lt;a href="#i-introduction" aria-labelledby="i-introduction">
&lt;!-- &lt;i class="fas fa-link anchor">&lt;/i> -->
 &lt;svg class="svg-inline--fa fas fa-link anchor" fill="currentColor" aria-hidden="true" role="img" viewBox="0 0 640 512">&lt;use href="#fas-link">&lt;/use>&lt;/svg>&amp;nbsp;
 &lt;/a>
&lt;/h2>
&lt;p>Go est un langage minimaliste, mais cette simplicité peut donner l’impression qu’il “manque quelque chose” lorsqu’on aborde des architectures plus poussées, du Test-Driven Development ou la nécessité de mocker certaines dépendances. Très vite, les développeurs venant de Java, C# ou Python se posent les mêmes questions :&lt;/p>
&lt;ul>
&lt;li>&lt;em>Dois-je transformer toutes mes fonctions en structs + interfaces pour tester ?&lt;/em>&lt;/li>
&lt;li>&lt;em>Comment organiser mes packages pour qu’ils soient modulaires et testables ?&lt;/em>&lt;/li>
&lt;li>&lt;em>Où placer les interfaces ? Chez le fournisseur ou chez le consommateur ?&lt;/em>&lt;/li>
&lt;li>&lt;em>Comment isoler un package qui expose uniquement des fonctions ?&lt;/em>&lt;/li>
&lt;li>&lt;em>Comment détecter automatiquement un changement de signature ?&lt;/em>&lt;/li>
&lt;/ul>
&lt;hr>




&lt;h2 id="ii-le-modèle-go--simple-modulaire-mais-différent" class="heading">II. Le modèle Go : simple, modulaire, mais différent&lt;a href="#ii-le-mod%c3%a8le-go--simple-modulaire-mais-diff%c3%a9rent" aria-labelledby="ii-le-modèle-go--simple-modulaire-mais-différent">
&lt;!-- &lt;i class="fas fa-link anchor">&lt;/i> -->
 &lt;svg class="svg-inline--fa fas fa-link anchor" fill="currentColor" aria-hidden="true" role="img" viewBox="0 0 640 512">&lt;use href="#fas-link">&lt;/use>&lt;/svg>&amp;nbsp;
 &lt;/a>
&lt;/h2>
&lt;p>Contrairement à Java ou C#, Go ne repose pas sur l’héritage, les classes ou les gros frameworks d’injection de dépendances.&lt;/p></description></item><item><title>Consumer-Reported Dependency Health</title><link>https://blog.dev.simpleenough.net/fr/blog/dependencyhealth/</link><pubDate>Mon, 08 Dec 2025 11:18:06 +0200</pubDate><guid>https://blog.dev.simpleenough.net/fr/blog/dependencyhealth/</guid><description>&lt;h2 id="i-réinventer-la-manière-dévaluer-la-santé-des-systèmes-distribués" class="heading">I. Réinventer la manière d’évaluer la santé des systèmes distribués&lt;a href="#i-r%c3%a9inventer-la-mani%c3%a8re-d%c3%a9valuer-la-sant%c3%a9-des-syst%c3%a8mes-distribu%c3%a9s" aria-labelledby="i-réinventer-la-manière-dévaluer-la-santé-des-systèmes-distribués">
&lt;!-- &lt;i class="fas fa-link anchor">&lt;/i> -->
 &lt;svg class="svg-inline--fa fas fa-link anchor" fill="currentColor" aria-hidden="true" role="img" viewBox="0 0 640 512">&lt;use href="#fas-link">&lt;/use>&lt;/svg>&amp;nbsp;
 &lt;/a>
&lt;/h2>
&lt;p>Dans les architectures distribuées modernes, la santé d’un système dépend autant — voire davantage — de l’état de ses &lt;strong>dépendances&lt;/strong> que de son état interne. Pourtant, la plupart des stratégies de monitoring reposent encore sur des healthchecks synthétiques ou dédiés : endpoints &lt;code>/health&lt;/code>, sondes liveness/readiness, scripts externes, etc.&lt;/p></description></item><item><title>Pourquoi les instances AWS Spot deviennent introuvables en décembre</title><link>https://blog.dev.simpleenough.net/fr/blog/spotdecember/</link><pubDate>Mon, 01 Dec 2025 17:08:49 +0200</pubDate><guid>https://blog.dev.simpleenough.net/fr/blog/spotdecember/</guid><description>&lt;h2 id="i-pourquoi-les-instances-aws-spot-deviennent-introuvables-en-décembre" class="heading">I. Pourquoi les instances AWS Spot deviennent introuvables en décembre&lt;a href="#i-pourquoi-les-instances-aws-spot-deviennent-introuvables-en-d%c3%a9cembre" aria-labelledby="i-pourquoi-les-instances-aws-spot-deviennent-introuvables-en-décembre">
&lt;!-- &lt;i class="fas fa-link anchor">&lt;/i> -->
 &lt;svg class="svg-inline--fa fas fa-link anchor" fill="currentColor" aria-hidden="true" role="img" viewBox="0 0 640 512">&lt;use href="#fas-link">&lt;/use>&lt;/svg>&amp;nbsp;
 &lt;/a>
&lt;/h2>
&lt;p>Les &lt;strong>instances EC2 Spot&lt;/strong> sont un excellent moyen d’économiser de 50 à 70 % sur vos coûts AWS.&lt;br>
Elles utilisent la capacité inutilisée des datacenters… mais justement, en &lt;strong>décembre&lt;/strong>, cette capacité disparaît presque totalement.&lt;/p>
&lt;p>Résultat :&lt;/p>
&lt;ul>
&lt;li>vos Auto Scaling Groups n&amp;rsquo;arrivent plus à lancer d’instances&lt;/li>
&lt;li>vos déploiements restent bloqués&lt;/li>
&lt;li>“insufficient capacity” partout&lt;/li>
&lt;li>des interruptions Spot beaucoup plus fréquentes&lt;/li>
&lt;/ul>
&lt;p>Si cela vous est déjà arrivé, rassurez-vous : ce n’est &lt;strong>pas vous&lt;/strong>, ni un problème de configuration.&lt;br>
C’est &lt;strong>un phénomène saisonnier&lt;/strong>, et il revient chaque année.&lt;/p></description></item><item><title>Karpenter : l'autoscaler intelligent pour EKS</title><link>https://blog.dev.simpleenough.net/fr/blog/karpenter/</link><pubDate>Mon, 24 Nov 2025 11:18:06 +0200</pubDate><guid>https://blog.dev.simpleenough.net/fr/blog/karpenter/</guid><description>&lt;h2 id="i-karpenter-cest-quoi-" class="heading">I. Karpenter, c’est quoi ?&lt;a href="#i-karpenter-cest-quoi-" aria-labelledby="i-karpenter-cest-quoi-">
&lt;!-- &lt;i class="fas fa-link anchor">&lt;/i> -->
 &lt;svg class="svg-inline--fa fas fa-link anchor" fill="currentColor" aria-hidden="true" role="img" viewBox="0 0 640 512">&lt;use href="#fas-link">&lt;/use>&lt;/svg>&amp;nbsp;
 &lt;/a>
&lt;/h2>
&lt;p>&lt;strong>Karpenter&lt;/strong> est un autoscaler open-source pour Kubernetes, créé par AWS.&lt;br>
Son rôle : &lt;strong>ajuster automatiquement la capacité des nœuds (EC2) d’un cluster EKS en fonction de la charge réelle.&lt;/strong>&lt;/p>
&lt;p>En résumé :&lt;/p>
&lt;ul>
&lt;li>Quand ton cluster manque de ressources, &lt;strong>Karpenter ajoute des nœuds.&lt;/strong>&lt;/li>
&lt;li>Quand les nœuds deviennent inutiles, &lt;strong>il les supprime.&lt;/strong>&lt;/li>
&lt;/ul>
&lt;p>Mais surtout :&lt;/p>
&lt;p>Il le fait &lt;strong>plus vite&lt;/strong>, &lt;strong>plus intelligemment&lt;/strong> et &lt;strong>plus efficacement&lt;/strong> que l’autoscaler classique de Kubernetes (&lt;strong>Cluster Autoscaler&lt;/strong>).&lt;/p></description></item><item><title>This is who IAM</title><link>https://blog.dev.simpleenough.net/fr/blog/iam/</link><pubDate>Tue, 27 May 2025 14:38:31 +0200</pubDate><guid>https://blog.dev.simpleenough.net/fr/blog/iam/</guid><description>&lt;h2 id="i-iam--composants-et-concepts-de-base" class="heading">I. IAM : Composants et concepts de base&lt;a href="#i-iam--composants-et-concepts-de-base" aria-labelledby="i-iam--composants-et-concepts-de-base">
&lt;!-- &lt;i class="fas fa-link anchor">&lt;/i> -->
 &lt;svg class="svg-inline--fa fas fa-link anchor" fill="currentColor" aria-hidden="true" role="img" viewBox="0 0 640 512">&lt;use href="#fas-link">&lt;/use>&lt;/svg>&amp;nbsp;
 &lt;/a>
&lt;/h2>
&lt;p>IAM repose sur des &lt;strong>entités&lt;/strong> et des &lt;strong>stratégies&lt;/strong>.&lt;/p>




&lt;h3 id="entités-iam" class="heading">Entités IAM&lt;a href="#entit%c3%a9s-iam" aria-labelledby="entités-iam">
&lt;!-- &lt;i class="fas fa-link anchor">&lt;/i> -->
 &lt;svg class="svg-inline--fa fas fa-link anchor" fill="currentColor" aria-hidden="true" role="img" viewBox="0 0 640 512">&lt;use href="#fas-link">&lt;/use>&lt;/svg>&amp;nbsp;
 &lt;/a>
&lt;/h3>
&lt;ul>
&lt;li>&lt;strong>Utilisateurs&lt;/strong> : Représentent des personnes ou des applications. Ex : un développeur nommé &amp;ldquo;alice&amp;rdquo;.&lt;/li>
&lt;li>&lt;strong>Groupes&lt;/strong> : Collections d’utilisateurs partageant les mêmes autorisations.&lt;/li>
&lt;li>&lt;strong>Rôles&lt;/strong> : Entités IAM que d&amp;rsquo;autres entités peuvent assumer temporairement. Idéal pour les cas de &lt;strong>fédération&lt;/strong> ou les services comme EC2 ou Lambda.&lt;/li>
&lt;li>&lt;strong>Politiques (Policies)&lt;/strong> : Fichiers JSON qui définissent les autorisations attachées à une entité.&lt;/li>
&lt;/ul>




&lt;h3 id="exemple-de-politique-json" class="heading">Exemple de politique JSON&lt;a href="#exemple-de-politique-json" aria-labelledby="exemple-de-politique-json">
&lt;!-- &lt;i class="fas fa-link anchor">&lt;/i> -->
 &lt;svg class="svg-inline--fa fas fa-link anchor" fill="currentColor" aria-hidden="true" role="img" viewBox="0 0 640 512">&lt;use href="#fas-link">&lt;/use>&lt;/svg>&amp;nbsp;
 &lt;/a>
&lt;/h3>
&lt;div class="mb-3 syntax-highlight">&lt;div class="highlight">&lt;pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;">&lt;code class="language-json" data-lang="json">&lt;span style="display:flex;">&lt;span>{
&lt;/span>&lt;/span>&lt;span style="display:flex;">&lt;span> &lt;span style="color:#f92672">&amp;#34;Version&amp;#34;&lt;/span>: &lt;span style="color:#e6db74">&amp;#34;2012-10-17&amp;#34;&lt;/span>,
&lt;/span>&lt;/span>&lt;span style="display:flex;">&lt;span> &lt;span style="color:#f92672">&amp;#34;Statement&amp;#34;&lt;/span>: [
&lt;/span>&lt;/span>&lt;span style="display:flex;">&lt;span> {
&lt;/span>&lt;/span>&lt;span style="display:flex;">&lt;span> &lt;span style="color:#f92672">&amp;#34;Effect&amp;#34;&lt;/span>: &lt;span style="color:#e6db74">&amp;#34;Allow&amp;#34;&lt;/span>,
&lt;/span>&lt;/span>&lt;span style="display:flex;">&lt;span> &lt;span style="color:#f92672">&amp;#34;Action&amp;#34;&lt;/span>: &lt;span style="color:#e6db74">&amp;#34;s3:ListBucket&amp;#34;&lt;/span>,
&lt;/span>&lt;/span>&lt;span style="display:flex;">&lt;span> &lt;span style="color:#f92672">&amp;#34;Resource&amp;#34;&lt;/span>: &lt;span style="color:#e6db74">&amp;#34;arn:aws:s3:::example_bucket&amp;#34;&lt;/span>
&lt;/span>&lt;/span>&lt;span style="display:flex;">&lt;span> }
&lt;/span>&lt;/span>&lt;span style="display:flex;">&lt;span> ]
&lt;/span>&lt;/span>&lt;span style="display:flex;">&lt;span>}&lt;/span>&lt;/span>&lt;/code>&lt;/pre>&lt;/div>&lt;/div>&lt;p>Cette politique IAM permet à une entité AWS (utilisateur, rôle ou groupe) de lister les objets contenus dans un bucket S3 spécifique nommé example_bucket. Elle utilise la version standard du langage de politique (2012-10-17) et applique un effet &amp;ldquo;Allow&amp;rdquo; à l’action &amp;ldquo;s3:ListBucket&amp;rdquo; sur la ressource identifiée par son ARN (arn:aws:s3:::example_bucket). Cela signifie que l’entité pourra voir la liste des objets dans ce bucket (noms, tailles, métadonnées), mais ne pourra ni lire, ni modifier les fichiers eux-mêmes, sauf si d&amp;rsquo;autres permissions sont ajoutées. C’est une politique minimale, souvent utilisée dans des scénarios d’inventaire ou de navigation dans un bucket via l’API ou la console AWS.&lt;/p></description></item><item><title>3 façons simples d'économiser jusqu'à 90 % des coûts de l'EC2: Spot Instances</title><link>https://blog.dev.simpleenough.net/fr/blog/spot/</link><pubDate>Fri, 02 May 2025 17:08:49 +0200</pubDate><guid>https://blog.dev.simpleenough.net/fr/blog/spot/</guid><description>&lt;h2 id="i-introduction-aux-spot-instances" class="heading">I. Introduction aux Spot Instances&lt;a href="#i-introduction-aux-spot-instances" aria-labelledby="i-introduction-aux-spot-instances">
&lt;!-- &lt;i class="fas fa-link anchor">&lt;/i> -->
 &lt;svg class="svg-inline--fa fas fa-link anchor" fill="currentColor" aria-hidden="true" role="img" viewBox="0 0 640 512">&lt;use href="#fas-link">&lt;/use>&lt;/svg>&amp;nbsp;
 &lt;/a>
&lt;/h2>
&lt;p>Les &lt;strong>Amazon EC2 Spot Instances&lt;/strong> offrent une manière puissante de réduire drastiquement les coûts d’exécution dans le cloud. Conçues pour exploiter la capacité inutilisée d’Amazon EC2, ces instances sont disponibles à un &lt;strong>tarif jusqu’à 90 % inférieur&lt;/strong> à celui des instances à la demande.&lt;/p>
&lt;p>Bien que ces économies soient attrayantes, les Spot Instances ne conviennent pas à tous les types de charges de travail. Elles sont idéales pour des workloads &lt;strong>flexibles, tolérants à l’interruption&lt;/strong> ou distribués, comme le traitement de données, l’apprentissage automatique ou les tests de performance.&lt;/p></description></item><item><title>Un problème. Ne paniquez pas, préparez un ticket d'assistance</title><link>https://blog.dev.simpleenough.net/fr/blog/assistance/</link><pubDate>Fri, 25 Apr 2025 13:10:00 +0100</pubDate><guid>https://blog.dev.simpleenough.net/fr/blog/assistance/</guid><description>&lt;h2 id="i-identifier-et-reproduire-le-problème-avec-rigueur" class="heading">I. Identifier et reproduire le problème avec rigueur&lt;a href="#i-identifier-et-reproduire-le-probl%c3%a8me-avec-rigueur" aria-labelledby="i-identifier-et-reproduire-le-problème-avec-rigueur">
&lt;!-- &lt;i class="fas fa-link anchor">&lt;/i> -->
 &lt;svg class="svg-inline--fa fas fa-link anchor" fill="currentColor" aria-hidden="true" role="img" viewBox="0 0 640 512">&lt;use href="#fas-link">&lt;/use>&lt;/svg>&amp;nbsp;
 &lt;/a>
&lt;/h2>
&lt;p>Avant de contacter l&amp;rsquo; assistance AWS, il est essentiel de documenter précisément le comportement observé. L&amp;rsquo; objectif est de permettre à l&amp;rsquo; &lt;strong>équipe de support&lt;/strong> d&amp;rsquo;analyser rapidement le contexte. Cela commence par l&amp;rsquo;identification du service concerné : EC2, S3, Lambda, ou un autre composant de votre infrastructure cloud. Documenter un incident avec clarté est fondamental pour éviter les allers-retours inutiles.&lt;/p></description></item><item><title>Introduction aux ELB</title><link>https://blog.dev.simpleenough.net/fr/blog/elb/</link><pubDate>Sat, 15 Mar 2025 21:33:57 +0200</pubDate><guid>https://blog.dev.simpleenough.net/fr/blog/elb/</guid><description>&lt;h2 id="i-introduction-aux-load-balancers-dans-aws" class="heading">I. Introduction aux Load Balancers dans AWS&lt;a href="#i-introduction-aux-load-balancers-dans-aws" aria-labelledby="i-introduction-aux-load-balancers-dans-aws">
&lt;!-- &lt;i class="fas fa-link anchor">&lt;/i> -->
 &lt;svg class="svg-inline--fa fas fa-link anchor" fill="currentColor" aria-hidden="true" role="img" viewBox="0 0 640 512">&lt;use href="#fas-link">&lt;/use>&lt;/svg>&amp;nbsp;
 &lt;/a>
&lt;/h2>
&lt;p>Un Elastic Load Balancers (ELB) agit comme un répartiteur de charge, distribuant automatiquement le trafic entrant à travers plusieurs ressources cibles, telles que les &lt;strong>instances EC2&lt;/strong>, les &lt;strong>containers&lt;/strong> ou les &lt;strong>adresses IP&lt;/strong>.&lt;/p>
&lt;p>Cette fonctionnalité est un pilier de la conception d&amp;rsquo;applications tolérantes aux pannes et hautement disponibles dans le cloud. AWS propose trois types d’ELB adaptés à différents cas d’usage, chacun avec ses spécificités.&lt;/p></description></item><item><title>Qu’ est-ce qu’ un Bundle ? Décryptage du concept</title><link>https://blog.dev.simpleenough.net/fr/blog/bundleconcept/</link><pubDate>Mon, 03 Feb 2025 10:00:00 +0100</pubDate><guid>https://blog.dev.simpleenough.net/fr/blog/bundleconcept/</guid><description>&lt;p>Le terme &lt;strong>&amp;ldquo;bundle&amp;rdquo;&lt;/strong> est omniprésent dans le développement web et DevOps. Il peut désigner un &lt;strong>regroupement de fichiers, de ressources ou d’éléments&lt;/strong> pour simplifier leur gestion et améliorer les performances.&lt;/p>
&lt;p>Mais un &lt;strong>bundle&lt;/strong> n&amp;rsquo;a pas la même signification partout. Dans cet article, nous allons explorer ses &lt;strong>différents usages&lt;/strong> dans trois domaines clés :&lt;/p>
&lt;p>&lt;strong>Hugo (générateur de site statique)&lt;/strong>&lt;br>
&lt;strong>CSS &amp;amp; JavaScript (développement front-end)&lt;/strong>&lt;br>
&lt;strong>DevOps (Docker, Kubernetes, Helm, etc.)&lt;/strong>&lt;/p>
&lt;hr>




&lt;h2 id="i-bundle-dans-hugo--organiser-ses-fichiers-intelligemment" class="heading">I. Bundle dans Hugo : Organiser ses fichiers intelligemment&lt;a href="#i-bundle-dans-hugo--organiser-ses-fichiers-intelligemment" aria-labelledby="i-bundle-dans-hugo--organiser-ses-fichiers-intelligemment">
&lt;!-- &lt;i class="fas fa-link anchor">&lt;/i> -->
 &lt;svg class="svg-inline--fa fas fa-link anchor" fill="currentColor" aria-hidden="true" role="img" viewBox="0 0 640 512">&lt;use href="#fas-link">&lt;/use>&lt;/svg>&amp;nbsp;
 &lt;/a>
&lt;/h2>
&lt;p>Dans Hugo, un &lt;strong>bundle&lt;/strong> est un dossier contenant une page et ses ressources associées (images, fichiers JSON, etc.). Il existe deux types de &lt;strong>Page Bundles&lt;/strong> :&lt;/p></description></item></channel></rss>