Cours : 40 Exercices d'Architecture SI

Introduction

Ce chapitre propose 40 exercices progressifs couvrant l'ensemble des disciplines de l'ingénierie des systèmes d'information. Chaque exercice est conçu pour mobiliser les compétences de modélisation, d'analyse et de conception.

Exercice 1 : MCD — Réservation hôtelière

Contexte : Un hôtel souhaite informatiser ses réservations. Chaque client peut réserver une ou plusieurs chambres pour une période donnée. Une chambre appartient à une catégorie (standard, supérieure, suite) et peut être réservée plusieurs fois mais pas simultanément.

Consignes : Réalisez le MCD (Modèle Conceptuel de Données) avec les entités, associations et cardinalités.

Éléments attendus : Client (num_client, nom, prénom, email, téléphone), Chambre (num_chambre, étage, capacité), Catégorie (code_cat, libellé, prix_nuit), Réservation (num_res, date_arrivée, date_départ, statut).

Indices : Pensez à l'association "Effectuer" entre Client et Réservation (1,N) et "Concerner" entre Réservation et Chambre (1,N). L'association "Appartenir" lie Chambre à Catégorie (N,1).

Exercice 2 : MCD — Gestion de bibliothèque

Contexte : Une médiathèque gère ses adhérents, ses ouvrages et ses emprunts. Un adhérent peut emprunter jusqu'à 5 ouvrages simultanément. Un ouvrage peut être emprunté plusieurs fois mais pas en même temps.

Consignes : Réalisez le MCD complet.

Entités : Adhérent (num_adherent, nom, prénom, date_adhesion, statut), Ouvrage (isbn, titre, auteur, editeur, annee), Exemplaire (code_barre, date_acquisition, etat), Emprunt (num_emprunt, date_emprunt, date_retour_prevue, date_retour_effective).

Contraintes : Un ouvrage peut avoir plusieurs exemplaires. Un emprunt concerne un seul exemplaire.

Exercice 3 : MLD à partir d'un MCD

Contexte : À partir du MCD de l'exercice 1, dérivez le MLD (Modèle Logique de Données). Identifiez les tables, les clés primaires et étrangères.

Consignes : Écrivez le modèle relationnel sous forme textuelle : NOM_TABLE (colonne1 type, colonne2 type, ...). Ajoutez les contraintes NOT NULL, UNIQUE, FOREIGN KEY.

Correction attendue : CLIENT (id_client INT PK, nom VARCHAR(50) NOT NULL, prenom VARCHAR(50), email VARCHAR(100) UNIQUE, telephone VARCHAR(20)). CHAMBRE (id_chambre INT PK, etage INT, capacite INT, id_categorie INT FK→CATEGORIE). CATEGORIE (id_categorie INT PK, code VARCHAR(10), libelle VARCHAR(50), prix_nuit DECIMAL(10,2)). RESERVATION (id_reservation INT PK, id_client INT FK→CLIENT, date_arrivee DATE NOT NULL, date_depart DATE, statut VARCHAR(20)). LIGNE_RESERVATION (id_reservation INT FK, id_chambre INT FK, PRIMARY KEY (id_reservation, id_chambre)).

Exercice 4 : Contraintes de cardinalités

Contexte : Pour chaque situation ci-dessous, déterminez les cardinalités minimales et maximales.

Un employé travaille dans un service. Un service emploie plusieurs employés.
Un étudiant s'inscrit à plusieurs cours. Un cours a plusieurs étudiants.
Un client passe commande. Une commande contient plusieurs produits.
Un utilisateur peut avoir zéro ou une carte de crédit.
Un livre est écrit par un ou plusieurs auteurs.

Consignes : Donnez les cardinalités (min, max) pour chaque côté des associations.

Réponses attendues : 1. Employé→Service (1,1), Service→Employé (1,N). 2. Étudiant→Cours (0,N), Cours→Étudiant (1,N). 3. Client→Commande (0,N), Commande→Client (1,1). 4. Utilisateur→Carte (0,N), Carte→Utilisateur (0,1). 5. Livre→Auteur (1,N), Auteur→Livre (1,N).

Exercice 5 : MOT — Modèle Organisationnel des Traitements

Contexte : Le processus de commande d'une entreprise suit ces étapes : (1) Saisie de la commande par le commercial, (2) Validation par le responsable, (3) Préparation en entrepôt, (4) Expédition, (5) Facturation.

Consignes : Réalisez un MOT (Modèle Organisationnel des Traitements) identifiant les procédures, activités, opérations, acteurs et ressources.

Structure MOT :

Procédure : Gestion des commandes
- Activité : Saisie commande (Acteur : Commercial, Ressource : CRM)
- Activité : Validation (Acteur : Responsable, Ressource : Workflow)
- Activité : Préparation (Acteur : Préparateur, Ressource : WMS)
- Activité : Expédition (Acteur : Logisticien, Ressource : Transport)
- Activité : Facturation (Acteur : Comptable, Ressource : ERP)

Exercice 6 : MCD → MPD physique

Contexte : Transformez le MLD de l'exercice 3 en MPD physique adapté à PostgreSQL.

Consignes : Ajoutez les types précis, index, contraintes de validation, séquences, triggers.

Exemple :

CREATE SEQUENCE seq_client START 1000;
CREATE TABLE client (
    id_client INTEGER DEFAULT nextval('seq_client') PRIMARY KEY,
    nom VARCHAR(50) NOT NULL CHECK (length(trim(nom)) > 0),
    prenom VARCHAR(50),
    email VARCHAR(100) NOT NULL UNIQUE,
    telephone VARCHAR(20),
    date_creation TIMESTAMP DEFAULT CURRENT_TIMESTAMP
);
CREATE INDEX idx_client_email ON client(email);

Exercice 7 : Diagramme de Use Cases — Bibliothèque

Contexte : Modélisez les cas d'utilisation d'un système de gestion de bibliothèque.

Acteurs : Adhérent, Bibliothécaire, Administrateur.

Cas d'utilisation : Consulter catalogue, Rechercher ouvrage, Réserver ouvrage, Emprunter, Prolonger prêt, Retourner, Gérer adhérents, Gérer ouvrages, Gérer sanctions, Générer rapports.

Consignes : Dessinez le diagramme avec les relations include/extend et l'héritage d'acteurs.

Exercice 8 : Use Cases avec include/extend

Contexte : Pour le système de réservation en ligne, identifiez et représentez correctement les relations include et extend entre cas d'utilisation.

Relations à modéliser : "S'authentifier" est inclus dans "Réserver", "Consulter historique", "Modifier profil". "Payer" inclut "Valider paiement". "Générer confirmation" étend "Réserver" si le paiement réussit. "Appliquer réduction" étend "Payer" si un code promo est saisi.

Exercice 9 : Diagramme de Classes — Système de commande

Contexte : Un système de gestion de commandes gère : Client, Commande, LigneCommande, Produit, Catégorie, Paiement.

Consignes : Réalisez le diagramme de classes UML complet avec attributs, méthodes, associations, agrégations, compositions et héritage.

Détails techniques :

Client (id, nom, email, adresse) → +passerCommande(), +getHistorique()
Commande (id, date, statut, total) → +ajouterProduit(), +valider(), +annuler()
LigneCommande (quantite, prixUnitaire) → +calculerSousTotal()
Produit (id, nom, description, prix, stock) → +mettreAJourStock()
Catégorie (id, nom) → composition avec Produit
Paiement (id, montant, date, mode) → classe abstraite avec CartCredit, PayPal, Virement

Exercice 10 : Classes avancé — Héritage et agrégation

Contexte : Modélisez le système de gestion de projets. Un Projet est composé de Tâches. Une Tâche peut être Simple ou Composite (contient d'autres tâches). Les Ressources (Humaine, Matérielle, Financière) peuvent être affectées à des tâches.

Consignes : Utilisez l'héritage, l'agrégation, les classes abstraites et les interfaces.

Exercice 11 : Diagramme de Séquence — Réservation

Contexte : Modélisez le scénario "Un client réserve une chambre d'hôtel" en diagramme de séquence.

Acteurs et objets : Client, Interface Web, GestionnaireRéservation, ServicePaiement, ServiceEmail, BaseDonnées.

Scénario :

Client saisit dates → Interface
Interface → GestionnaireRéservation : rechercherDisponibilités
GestionnaireRéservation → BaseDonnées : queryDisponibilités
BaseDonnées retourne chambres disponibles
GestionnaireRéservation retourne liste
Client sélectionne chambre et valide
GestionnaireRéservation → ServicePaiement : initierPaiement
ServicePaiement confirme paiement
GestionnaireRéservation crée réservation en base
GestionnaireRéservation → ServiceEmail : envoyerConfirmation
Retourne confirmation au client

Exercice 12 : Diagramme d'État — Cycle de commande

Contexte : Une commande en ligne passe par les états suivants : Créée, En attente de paiement, Payée, En préparation, Expédiée, Livrée, Annulée, Remboursée.

Consignes : Modélisez le diagramme d'état UML avec les transitions, événements déclencheurs, gardes, actions d'entrée/sortie.

Transitions :

Créée → En attente paiement (validation)
En attente paiement → Payée (paiement reçu [si montant = total])
En attente paiement → Annulée (annulation client)
Payée → En préparation (confirmation entrepôt)
En préparation → Expédiée (expédition)
Expédiée → Livrée (accusé réception)
Payée → Remboursée (annulation après paiement)
En préparation → Annulée (rupture stock)
Livrée → Remboursée (retour client)

Exercice 13 : Diagramme de Séquence avec fragments

Contexte : Reprenez l'exercice 11 et ajoutez la gestion d'erreurs avec les fragments combinés UML.

Fragments : alt (paiement accepté/refusé), opt (assurance annulation), loop (tentatives de paiement), break (annulation), par (envoi email et mise à jour base en parallèle).

Exercice 14 : Diagramme de Communication

Contexte : Traduisez le diagramme de séquence de l'exercice 11 en diagramme de communication UML. Numérotez les messages.

Exercice 15 : Diagramme de Composants

Contexte : Modélisez l'architecture en couches d'une application web Spring Boot : Web (React), API (REST), Service (Spring), Repository (JPA), Database (PostgreSQL).

Consignes : Utilisez les stéréotypes composant, interface, port, dependency. Montrez les interfaces REST, JPA, JDBC.

Exercice 16 : Diagramme de Déploiement cloud

Contexte : Déployez l'application précédente sur AWS : Load Balancer (ALB), Frontend (CloudFront + S3), Backend (ECS Fargate), Base de données (RDS PostgreSQL), Cache (ElastiCache Redis).

Consignes : Modélisez les nœuds, conteneurs d'exécution, artefacts, protocoles de communication (HTTPS, TCP, JDBC).

Exercice 17 : C4 — Diagramme de Contexte Netflix-like

Contexte : Une plateforme de streaming vidéo permet aux utilisateurs de regarder films et séries, gère les abonnements, et utilise des services de recommandation.

Consignes : Réalisez le diagramme de contexte C4 avec les utilisateurs (Abonné, Administrateur), le système principal (Plateforme Streaming), les systèmes externes (Passerelle Paiement, Service Catalogue Externe, CDN, Email Service).

Exercice 18 : C4 — Diagramme de Conteneurs Netflix-like

Contexte : À partir du diagramme de contexte, détaillez les conteneurs de la plateforme de streaming.

Conteneurs : Application Web (React), Application Mobile (iOS/Android), API Gateway (Spring Cloud Gateway), Service Authentification (Java/Spring), Service Catalogue (Node.js), Service Recommandation (Python/ML), Service Streaming (Go), Service Paiement (Java/Spring), Base de données (PostgreSQL, Cassandra, Redis, S3), File messages (Kafka).

Consignes : Montrez les relations entre conteneurs avec les protocoles (HTTPS, gRPC, Kafka).

Exercice 19 : C4 — Diagramme de Composants microservice

Contexte : Décomposez le Service Catalogue en composants internes : Controller, Service, Repository, Cache, MessagePublisher.

Consignes : Montrez les interfaces et dépendances entre composants. Utilisez les patterns hexagonal et ports/adapters.

Exercice 20 : C4 — Diagramme de Code

Contexte : Choisissez une classe du Service Catalogue (ex : CatalogueService) et réalisez le diagramme de code C4 (niveau 4) avec les dépendances, méthodes clés, annotations Spring.

Exercice 21 : BPMN — Processus validation commande

Contexte : Une commande client passe par : validation commerciale → validation crédit → préparation → expédition. Si le crédit est refusé, la commande est annulée.

Consignes : Modélisez en BPMN 2.0 avec : start event, user tasks, service tasks, exclusive gateway, end events.

Exercice 22 : BPMN — Événements intermédiaires

Contexte : Ajoutez au processus de validation : timer (relance si validation > 24h), message (notification stock épuisé), error (panne système), signal (commande urgente).

Consignes : Utilisez les événements intermédiaires : timer boundary, message boundary, error boundary, signal.

Exercice 23 : BPMN — Collaboration entre partenaires

Contexte : Modélisez le processus de collaboration entre un Client, un Fournisseur et un Transporteur pour une commande internationale.

Consignes : Utilisez les pools et lanes, les messages flows entre pools, les événements de message.

Exercice 24 : BPMN — Transactions

Contexte : Le processus de paiement par carte est une transaction : débit, validation 3D-Secure, confirmation. Si une étape échoue, la transaction doit être compensée (rollback).

Consignes : Utilisez le pattern transaction BPMN avec beginTransaction/endTransaction, events de compensation, intermediate compensation.

Exercice 25 : DDD — Identification des Bounded Contexts

Contexte : Une plateforme e-commerce complète comprend : catalogue produits, panier, commande, paiement, expédition, facturation, avis clients, recommandations, gestion des stocks, CRM, marketing.

Consignes : Identifiez les bounded contexts pertinents en DDD. Justifiez chaque découpage.

Éléments attendus : Découpage en 8-10 bounded contexts avec nom, responsabilité, langage ubiquitaire, dépendances.

Exercice 26 : DDD — Context Mapping

Contexte : Pour la plateforme e-commerce, réalisez la carte des relations entre bounded contexts.

Consignes : Utilisez les relations DDD : Partnership, Shared Kernel, Customer-Supplier, Conformist, Anticorruption Layer, Open Host Service, Published Language, Separated Ways.

Exemple : Contexte Commande → ACL → Contexte Paiement (Customer-Supplier). Contexte Catalogue → OHS → Contexte Recherche.

Exercice 27 : DDD — Aggregate Design

Contexte : Dans le bounded context Commande, concevez l'Agregate "Commande" qui encapsule : Commande (root), LignesCommande, AdresseLivraison, Statut.

Consignes : Définissez la racine d'agrégat, les règles d'invariants, les événements de domaine, les limites transactionnelles.

Règles : Total > 0. Maximum 100 lignes par commande. Un client ne peut avoir qu'une commande en cours de validation.

Exercice 28 : DDD — Domain Events

Contexte : Définissez les événements de domaine du bounded context Commande.

Événements : CommandeCrée, CommandeValidée, PaiementReçu, CommandeExpédiée, CommandeLivrée, CommandeAnnulée, RemboursementEffectué.

Consignes : Pour chaque événement : nom, timestamp, payload (données portées), publisher, subscriber(s), action déclenchée.

Exercice 29 : ADR — Adoption d'une file de messages

Contexte : L'équipe décide d'adopter une file de messages pour l'intégration asynchrone entre le service Commande et le service Paiement.

Consignes : Rédigez un ADR complet au format Y-Statement avec : Title, Status, Context, Decision, Rationale, Consequences, Compliance.

Exercice 30 : ADR — Monolithe vs Microservices

Contexte : Décision sur l'architecture du SI pour une startup en phase de croissance.

Consignes : Rédigez l'ADR en comparant les options (monolithe modulaire, microservices, architecture en couches). Justifiez le choix retenu.

Exercice 31 : ADR — Choix de base de données

Contexte : Choix du système de gestion de base de données entre PostgreSQL, MongoDB et Cassandra pour le service Catalogue.

Consignes : Rédigez l'ADR avec analyse des besoins : données structurées, relations entre entités, volume attendu, pattern d'accès.

Exercice 32 : ADR — Architecture de déploiement

Contexte : Décision sur la stratégie de déploiement : Kubernetes, ECS Fargate, ou VM classique.

Consignes : Rédigez l'ADR en comparant complexité opérationnelle, coût, scalabilité, maturité de l'équipe.

Exercice 33 : ADR — Standardisation des APIs

Contexte : Décision sur le style d'API pour les communications inter-services : REST, gRPC, ou GraphQL.

Consignes : Rédigez l'ADR en fonction des cas d'usage : queries complexes, streaming, performance, compatibilité.

Exercice 34 : ArchiMate — Couche métier

Contexte : Modélisez la couche métier d'une compagnie d'assurance avec les acteurs, rôles, processus, fonctions, services métier.

Consignes : Utilisez les éléments ArchiMate : Business Actor, Business Role, Business Process, Business Function, Business Service, Business Object.

Exercice 35 : ArchiMate — Couche applicative

Contexte : Pour la même compagnie, modélisez la couche applicative : applications composant le SI (CRM, ERP, GestionSinistre, PortailClient), interfaces, services applicatifs, collaborations applicatives.

Consignes : Montrez les relations de composition, de jeton, de réalisation (layer crossing).

Exercice 36 : ArchiMate — Couche technologique

Contexte : Complétez avec la couche technologique : serveurs, bases de données, réseaux, cloud infrastructure.

Consignes : Utilisez Node, Device, System Software, Artifact, Technology Service, Communication Path, Network.

Exercice 37 : TOGAF — Architecture Vision

Contexte : Rédigez les livrables de la phase A (Architecture Vision) pour la transformation digitale d'une banque.

Éléments : Problem statement, stakeholder map, vision, requirements, business goals, architecture principles.

Exercice 38 : TOGAF — Architecture Definition

Contexte : Pour la même banque, rédigez les livrables des phases B-D : Architecture Métier, Architecture des Données, Architecture Applicative, Architecture Technologique.

Exercice 39 : TOGAF — Migration Planning

Contexte : Élaborez le plan de migration et le roadmap de la phase E-F : analyse des écarts (gap analysis), roadmap, priorités, risques, phases de migration.

Exercice 40 : Synthèse — Modélisation complète

Contexte : Cas transversal : concevez l'architecture complète d'un système de billetterie événementielle (type Ticketmaster).

Consignes :

MCD des données (spectacles, salles, places, clients, ventes)
Use cases UML (acteurs, cas d'utilisation)
Classes UML (modèle objet)
C4 (contexte, conteneurs)
BPMN (processus de vente)
DDD (bounded contexts)
ADR (au moins 2 décisions majeures)

Critères d'évaluation

Pour chaque exercice :

Diagramme (40%) : respect de la notation, clarté, complétude
Analyse (30%) : justesse de l'analyse, couverture du besoin
Pertinence (20%) : niveau de détail adapté, choix justifiés
Présentation (10%) : lisibilité, organisation

Ressources complémentaires

Chapitres 02-14 pour la théorie
Chapitre 19 pour les corrigés détaillés
Chapitre 23 pour les cheat sheets
Chapitre 20 pour les outils de modélisation

Durée conseillée

30 min à 1h par exercice selon difficulté
20h à 30h pour l'ensemble des 40 exercices

17-Exercices