Formations — 1 037 leçons en français

Accueil › Architecture & design patterns › Signaux de découpage

Signaux de découpage — entretien Architecture & design patterns

4 questions posées en entretien, avec la bonne réponse et son explication.

« Notre dépôt est devenu énorme, il faut passer aux microservices. » Que répondre ?

  1. La difficulté est de s'orienter dans le code, et elle se traite par des modules à frontières nettes ✓
  2. C'est exact, au-delà d'une certaine taille un monolithe n'est plus tenable
  3. Il faut d'abord supprimer le code mort, puis découper
  4. Il faut découper par couche technique plutôt que par domaine

Pourquoi : La taille est un problème réel, mais le réseau ne rend pas le code plus lisible — il éloigne l'appelé du dépôt. Découper un gros code sans frontières produit des services qui s'appellent tous, avec les mêmes dépendances qu'avant et la latence en plus.

Niveau junior

Quel constat de charge justifie d'extraire un module pour le dimensionner seul ?

  1. Il consomme une part de ressource sans commune mesure avec sa part de trafic, avec un profil différent du reste ✓
  2. Il consomme environ le double des autres modules
  3. Il est le module le plus souvent appelé
  4. Il contient les algorithmes les plus complexes

Pourquoi : Le critère est l'écart, pas la charge absolue. Un facteur deux ne justifie rien : les ressources dupliquées inutilement coûtent moins cher que l'exploitation d'un service de plus. La bonne réponse mentionne aussi l'alternative interne — une file de travaux différés sort les tâches lourdes du chemin de la requête sans nouveau déployable.

Niveau confirme

Deux services s'appellent mutuellement en synchrone au cours d'une même requête. Quel est le problème principal ?

  1. Ils ne peuvent plus être déployés ni démarrés séparément : le cycle annule le bénéfice du découpage ✓
  2. Les appels consomment deux fois plus de bande passante
  3. La sérialisation devient impossible à cacher
  4. Le traçage distribué ne sait pas représenter un cycle

Pourquoi : Un cycle d'appels synchrones recrée un couplage de déploiement entre deux artefacts, avec la latence et les pannes partielles en supplément. La réponse qui marque nomme les sorties : inverser la dépendance par un événement, déplacer la donnée partagée du bon côté, ou constater que les deux services n'en formaient qu'un.

Niveau senior

Un appel vers un fournisseur externe lent sature les fils d'exécution et rend toute l'application indisponible. Quelle est la première réponse ?

  1. Cloisonner les ressources dédiées à cet appel, poser un délai maximal et un disjoncteur ✓
  2. Extraire ce module en service séparé pour isoler la panne
  3. Augmenter la taille du pool de fils d'exécution
  4. Mettre les réponses du fournisseur en cache pour réduire le nombre d'appels

Pourquoi : La cause est une absence de limite de ressources par appelant, et elle se corrige dans le processus. Extraire corrige le symptôme en ajoutant un service — et sans cloison, le nouveau service saturera à son tour. Augmenter le pool déplace le seuil sans supprimer le mode de panne.

Niveau senior

S'entraîner sur ces questions, chronométré →