C3 : Administrer des systèmes informatiques communicants complexes
Compétence Clé
Séparation des responsabilités du backend
La figure 1 représente l’architecture globale d’un projet frontend et backend avec 1 module gérant le frontend et plusieurs modules avec une logique spécifique représentant le backend (base de données, envoi de mail, orchestrateur communicant avec les autres modules). Par exemple, ici le client fait un appel API au service orchestrateur du backend depuis une interface web (module frontend). Le module du orchestrateur va ensuite faire une requete au module de base de donnée pour recevoir des informations sur l’utilisateur. Ensuite le module orchestrateur va envoyer un mail à l’utilisateur à l’aide du module de mail. Ensuite l’utilisateur va recevoir en réponse à sa requete une validation son action.
Savoirs mobilisés
Dans le cadre de ce projet, j’ai développé une feature communicante complexe permettant la signature électronique de contrats. J’ai dû utiliser une architecture modulaire existante où chaque composant communique de manière sécurisée et efficace. La plus grosse feature que j’ai ajoutée au projet était la création d’une interface pour signer des contrats intégrée au site, nécessitant une coordination complexe entre plusieurs modules et services externes.
Pour développer cette fonctionnalité communicante, j’ai mobilisé des connaissances approfondies en architecture logicielle distribuée, notamment les principes de décomposition en microservices et les patterns de communication inter-modules. J’ai appliqué les concepts d’architecture orientée services (SOA) pour créer un système où chaque module a une responsabilité spécifique : un module pour la gestion des données, un pour l’envoi d’emails, et un module orchestrateur qui gère les communications entre tous ces composants. Cette séparation modulaire permet une meilleure maintenabilité, une scalabilité indépendante de chaque service, et une résilience accrue du système global.
Ma compréhension des protocoles de communication web, particulièrement les API REST et les méthodes HTTP, m’a permis de concevoir des interfaces de communication claires entre les modules. J’ai étudié les principes de conception de module orchestrateur qui sert de point d’entrée unique pour coordonner les appels vers les différents services backend. Cette approche centralisée facilite la gestion des authentifications, le routage des requêtes, la sécurisation de ces services (car ne communique pas avec le client), et la composition des réponses provenant de multiples services.
J’ai également acquis des connaissances sur les mécanismes de communication asynchrone, notamment les webhooks qui permettent aux services externes de notifier notre système lors d’événements spécifiques. Cette compréhension m’a permis d’intégrer efficacement des services tiers comme l’API de signature électronique. Les formats d’échange de données comme JSON et les techniques d’intégration d’APIs externes ont été essentiels pour faire communiquer notre architecture modulaire avec les services de génération de documents et de signature électronique.
Savoir-faire mis en œuvre
Dans la réalisation de cette fonctionnalité, j’ai développé des compétences pratiques en développement d’architectures distribuées. J’ai créer des points d’entrées (endpoints) sur le module orchestrateur qui sert de point central de communication, orchestrant les appels vers des endpoints de différents modules backend (nouveau ou déjà existant) selon les besoins de chaque fonctionnalité. Cette approche m’a permis d’apprendre à gérer la complexité des interactions entre services tout en maintenant un couplage faible entre les composants.
Mon savoir-faire en intégration système s’est considérablement enrichi à travers la coordination des flux de données entre modules hétérogènes. J’ai appris à concevoir des interfaces de communication robustes qui permettent au module frontend de déclencher des processus complexes impliquant plusieurs services backend : génération de documents via un module dédié, stockage des informations dans une base de données via un module dédié, et déclenchement de processus de signature via des APIs externes. Réception de réponse de service externe via webhook. Cette orchestration nécessite une compréhension fine des dépendances entre services et des mécanismes de gestion d’erreurs distribués.
Dans la gestion des communications synchrones et asynchrones entre services, l’implémentation de callbacks et de notifications entre modules m’a permis de créer un système réactif qui maintient la cohérence des données à travers l’architecture distribuée. La gestion de projet technique dans ce contexte m’a appris à planifier les développements en tenant compte des interdépendances entre modules et à développer des compétences en débogage de systèmes distribués où les erreurs peuvent se propager à travers plusieurs couches de services.
Utilisation de Kubernetes
La figure 2 présente l’architecture d’un cluster Kubernetes, qui fonctionne comme un système de gestion automatisée d’applications. Au cœur du système se trouve le Centre de Contrôle (Control Plane) qui orchestre tout le cluster : il contient une base de données (etcd) qui mémorise l’état de toutes les applications du cluster, un serveur principal (kube-api-server) qui reçoit et traite toutes les demandes, un planificateur (scheduler) qui décide où placer les nouvelles applications du cluster, et des gestionnaires qui surveillent le bon fonctionnement du système. Le cluster comprend plusieurs nœuds de travail (Node Worker, ici Node 1 et Node 2) qui hébergent réellement les applications. Chaque nœud dispose d’agents : kubelet (qui communique avec le centre de contrôle), kube-proxy (qui gère la communication réseau), et CRI (qui fait fonctionner les conteneurs). Sur chaque nœud tournent des pods, qui sont comme des « boîtes » de conteneurs, sachant qu’un conteneur contient une seule partie de l’application finale. Les flèches illustrent comment le centre de contrôle communique avec les nœuds de travail pour déployer, surveiller et ajuster automatiquement les applications selon les besoins, tout en étant connecté aux services cloud pour une scalabilité optimale.
Savoir mobilisé
Pour maîtriser la virtualisation, j’ai d’abord mobilisé des connaissances fondamentales sur la conteneurisation avec Docker, comprenant les concepts d’isolation des processus, de portabilité des applications et de reproductibilité des environnements. J’ai approfondi ma compréhension de l’orchestration de containers avec Kubernetes, incluant ses composants clés : les Pods (unités de déploiement), les Services (gestion du réseau), les Deployments (gestion des réplicas), et les ConfigMaps/Secrets (gestion de la configuration). Kubernetes présente des avantages majeurs que j’ai dû comprendre : son système d’auto-scaling horizontal (HPA) qui ajuste automatiquement le nombre de réplicas selon les métriques de charge CPU/mémoire, optimisant ainsi les coûts d’infrastructure en ne consommant des ressources que selon les besoins réels. Sa capacité de self-healing redémarre automatiquement les containers défaillants et redistribue la charge sur les nœuds sains, assurant une haute disponibilité. La gestion réseau avancée de Kubernetes abstrait la complexité en fournissant des points d’accès stables et gère automatiquement la découverte de services et le load balancing. Mes connaissances en Helm m’ont permis de comprendre comment cette solution simplifie la gestion des déploiements complexes grâce à la templating des manifests et la réutilisation de configurations. J’ai également saisi l’importance de la portabilité offerte par Kubernetes, permettant de déployer les mêmes applications sur différents clouds sans modification du code.
Savoir-faire mis en œuvre
J’ai développé une expertise progressive en conteneurisation en commençant par maîtriser Docker pour créer des images optimisées de mes applications front-end et back-end, puis en utilisant Docker Compose pour orchestrer la communication entre services dans un environnement de développement local. Cette base solide m’a permis d’évoluer vers des architectures plus complexes avec plusieurs applications backend séparées, nécessitant une maîtrise avancée des commandes Docker et des réseaux de containers.
Pour répondre aux besoins d’un projet client nécessitant une scalabilité automatique, j’ai appris à utiliser Kubernetes en configurant des déploiements avec auto-scaling horizontal, permettant d’augmenter automatiquement le nombre de pods lors de pics de charge et de les réduire pendant les périodes creuses, optimisant ainsi les coûts d’infrastructure. J’ai maîtrisé l’utilisation de Helm Charts pour standardiser et simplifier les déploiements Kubernetes, créant des templates réutilisables qui facilitent la gestion des configurations entre les différents environnements (développement, test, production). Cette approche m’a permis de mettre en place une infrastructure cloud-native robuste, scalable et facilement maintenable, démontrant ma capacité à implémenter des solutions de virtualisation modernes adaptées aux exigences de performance et de disponibilité des applications en production.
Sécurisation des services
La figure 3 représente un système de sécurisation classique où un client tente d’accéder à des données protégées et un service externe qui tente de mettre à jour des données de notre application. Le processus illustre la vérification de l’utilisateur par des droits d’accès, où les permissions sont accordées via un message chiffré, garantissant que seuls les utilisateurs autorisés peuvent accéder aux ressources demandées. Ainsi que pour le service externe une vérification par IP ainsi qu’une validation par message chiffré envoyé préalablement par notre application et que le service est censé nous renvoyer.
Savoir mobilisé
Pour sécuriser efficacement ce système critique gérant des contrats légaux et données personnelles, j’ai mobilisé des connaissances approfondies en sécurité des systèmes d’information selon une approche de défense en profondeur. Ma compréhension des principes d’autorisation basés sur les droits utilisateur (RBAC – Role-Based Access Control) m’a permis d’implémenter un système où chaque utilisateur ne peut accéder qu’aux contrats lui appartenant légitimement.
L’utilisation des JSON Web Tokens (JWT) comme mécanisme d’authentification stateless présente des avantages significatifs : ces tokens autoporteurs contiennent les informations d’identité et de permissions de manière sécurisée, évitant les requêtes constantes vers la base de données et améliorant les performances tout en facilitant la scalabilité horizontale de l’architecture distribuée.
Mes connaissances en cryptographie m’ont permis de comprendre l’importance de la validation des signatures numériques pour les webhooks provenant d’API externe, combinant la vérification d’origine par filtrage IP (première barrière) et la validation de l’intégrité des messages via HMAC-SHA256, créant une double protection contre l’usurpation d’identité et la manipulation de données. L’intégration de l’authentification multi-facteurs par SMS s’appuie sur le principe de « quelque chose que vous savez » (mot de passe) et « quelque chose que vous possédez » (téléphone), renforçant significativement la sécurité d’accès pour les opérations sensibles de signature électronique.
Savoir-faire mis en œuvre
J’ai développé une expertise pratique en implémentation de contrôles d’accès granulaires, créant des middlewares de validation qui interceptent chaque requête pour vérifier les droits d’accès avant autorisation. Cette implémentation croise systématiquement les identifiants JWT avec les propriétaires légitimes des documents en base de données, créant une barrière robuste contre les tentatives d’élévation de privilèges ou d’accès non autorisé.
Ma maîtrise de la sécurisation des webhooks s’est concrétisée par l’implémentation d’un système de validation à deux niveaux : configuration de listes blanches d’adresses IP fournies par le service tiers, complétée par la validation cryptographique des signatures HMAC accompagnant chaque notification. Cette double validation garantit l’authenticité et l’intégrité des données reçues tout en prévenant les attaques par usurpation d’IP.
J’ai acquis des compétences avancées en intégration sécurisée de services externes, notamment dans l’orchestration du flux d’authentification multi-facteurs où l’API de signature électronique gère l’envoi de SMS de vérification tout en maintenant la cohérence sécuritaire de bout en bout. Cette approche m’a permis de créer un écosystème sécurisé où chaque composant (authentification, autorisation, chiffrement, validation) fonctionne de manière coordonnée pour protéger les données sensibles contre les menaces internes et externes.