Maîtriser la modélisation ArchiMate : Construire un système de gestion de bibliothèque avec PlantUML

Bienvenue dans un autre tutoriel de masterclass de l’équipe technique de Visual Paradigm ! Lors de la conception d’architectures d’entreprise complexes, maintenir des diagrammes propres, organisés et structurellement solides peut être un défi. Les outils traditionnels de glisser-déposer vous ralentissent souvent lorsque les mises en page évoluent ou que les exigences changent. C’est pourquoi de nombreux architectes logiciels et concepteurs d’entreprise s’appuient sur des flux de travail de diagramme sous forme de code.

Dans ce guide, je vais vous exposer ma démarche exacte pour construire un diagramme d’architecture ArchiMate complet et multi-couches pour unsystème de gestion de bibliothèque. En utilisant PlantUML dans leéditeur PlantUML gratuitsurVisual Paradigm VPasCode, nous détaillerons comment structurer les couches d’entreprise, définir proprement les éléments et cartographier des relations inter-couches précises.

Comprendre les couches d’architecture ArchiMate

Lorsque je me lance dans la modélisation d’un système d’entreprise, je commence toujours par définir les limites structurelles. ArchiMate sépare les préoccupations en couches architecturales distinctes, aidant les parties prenantes à comprendre la valeur métier, la logique fonctionnelle, les composants d’application et l’infrastructure technique d’un coup d’œil.

Pour notre système de bibliothèque, nous organisons le diagramme en quatre regroupements verticaux et horizontaux distincts :

• Couche Motivation :Capture les objectifs de haut niveau et les moteurs qui guident l’organisation.
• Couche Métier :Met en évidence les acteurs, les services et les processus métier essentiels tels que les prêts et les réservations de livres.
• Couche Application :Définit les services logiciels et les composants d’application gérant la logique centrale.
• Couche Technologie :Représente les nœuds matériels physiques ou virtuels hébergeant notre pile d’application.

Étape 1 : Mise en place de la structure de base

Pour commencer à écrire notre code, je commence par configurer les règles de rendu globales et importer la bibliothèque standard officielle ArchiMate pour PlantUML. Définir un type de ligne orthogonal maintient les lignes de connexion nettes et alignées à angle droit, ce qui est essentiel pour des plans d’entreprise épurés.

skinparam linetype ortho
!include https://static.visual-paradigm.com/plantuml-stdlib/Archimate-PlantUML/master/Archimate.puml
remove @unlinked
top to bottom direction
title Introductory - Library Management System

En imposantune direction de haut en baset en supprimant les éléments non liés, je m’assure que la mise en page s’écoule naturellement des motivations métier de haut niveau jusqu’à l’infrastructure technologique.

Étape 2 : Définition des couches et éléments principaux

Ensuite, je remplis chaque conteneur de regroupement avec ses éléments respectifs. Je préfère regrouper explicitement les composants connexes en utilisant des blocs de regroupement PlantUML afin que les limites visuelles correspondent aux domaines d’entreprise.

Grouping(motivation_layer, "Couche Motivation") {
  Motivation_Goal(g_ops, "Opérations de bibliothèque efficaces")
  Motivation_Goal(g_service, "Service de lecture de haute qualité")
}

Grouping(business_layer, "Couche Métier") {
  Business_Actor(ba_librarian, "Bibliothécaire")
  Business_Actor(ba_member, "Membre de la bibliothèque")
  Business_Service(bs_circulation, "Service de prêt")
  Business_Service(bs_catalog, "Service de catalogue")
  Business_Process(bp_checkout, "Emprunt / Retour")
  Business_Process(bp_reserve, "Gestion des réservations")
}

Grouping(application_layer, "Couche Application") {
  Application_Service(as_circulation, "Service d'application de prêt")
  Application_Service(as_catalog, "Service d'application de catalogue")
  Application_Component(ac_lms, "Système de gestion de bibliothèque")
  Application_Component(ac_catalog, "Base de données de catalogue")
}

Grouping(technology_layer, "Couche Technologie") {
  Technology_Node(tn_server, "Serveur d'application")
  Technology_Node(tn_db, "Serveur de base de données")
}

Pourquoi le structurer de cette manière ? Préfixer explicitement les éléments (comme “ba_ pour les acteurs métier, bp_ pour les processus, et tn_ pour les nœuds technologiques) rend l’écriture de mappages relationnels complexes beaucoup plus facile par la suite. Cela évite les collisions de noms et garde votre script auto-documenté.

Étape 3 : Mappage des relations entre les couches

Nos éléments étant en place, l’étape finale consiste à les relier entre eux. ArchiMate s’appuie sur des types de relations précis — tels que la réalisation, le service, le déclenchement et l’affectation — pour modéliser les dépendances avec précision.

' Les processus métier réalisent les services métier
Rel_Realization_Up(bp_checkout, bs_circulation, "")
Rel_Realization_Up(bp_reserve, bs_circulation, "")
Rel_Triggering_Right(bp_checkout, bp_reserve, "")

' Les services métier réalisent les objectifs de motivation
Rel_Realization_Up(bs_circulation, g_ops, "")
Rel_Serving_Up(bs_catalog, g_service, "")

' Les acteurs sont servis par les services métier
Rel_Serving_Up(bs_circulation, ba_librarian, "")
Rel_Serving_Up(bs_catalog, ba_member, "")

' Les services applicatifs réalisent les services métier
Rel_Realization_Up(as_circulation, bs_circulation, "")
Rel_Realization_Up(as_catalog, bs_catalog, "")

' Les composants applicatifs réalisent les services applicatifs
Rel_Realization_Up(ac_lms, as_circulation, "")
Rel_Realization_Up(ac_catalog, as_catalog, "")

' Les nœuds technologiques affectent (déploient) les composants applicatifs
Rel_Assignment_Up(tn_server, ac_lms, "")
Rel_Assignment_Up(tn_db, ac_catalog, "")

En utilisant des balises de relation directionnelles comme Rel_Realization_Up et Rel_Triggering_Right, je maintiens un contrôle précis sur la façon dont les connecteurs traversent la toile, évitant ainsi des lignes encombrantes et superposées.

Code source complet

Voici le script PlantUML complet, prêt pour la production, pour le diagramme d’architecture de notre système de gestion de bibliothèque :

@startuml
skinparam linetype ortho
!include https://static.visual-paradigm.com/plantuml-stdlib/Archimate-PlantUML/master/Archimate.puml
remove @unlinked
top to bottom direction
title Introductory - Library Management System

Grouping(motivation_layer, "Motivation Layer") {
  Motivation_Goal(g_ops, "Efficient Library Operations")
  Motivation_Goal(g_service, "High-Quality Reader Service")
}

Grouping(business_layer, "Business Layer") {
  Business_Actor(ba_librarian, "Librarian")
  Business_Actor(ba_member, "Library Member")
  Business_Service(bs_circulation, "Circulation Service")
  Business_Service(bs_catalog, "Catalog Service")
  Business_Process(bp_checkout, "Check Out / Return")
  Business_Process(bp_reserve, "Manage Reservations")
}

Grouping(application_layer, "Application Layer") {
  Application_Service(as_circulation, "Circulation Application Service")
  Application_Service(as_catalog, "Catalog Application Service")
  Application_Component(ac_lms, "Library Management System")
  Application_Component(ac_catalog, "Catalog Database")
}

Grouping(technology_layer, "Technology Layer") {
  Technology_Node(tn_server, "Application Server")
  Technology_Node(tn_db, "Database Server")
}

' Business processes realize business services
Rel_Realization_Up(bp_checkout, bs_circulation, "")
Rel_Realization_Up(bp_reserve, bs_circulation, "")
Rel_Triggering_Right(bp_checkout, bp_reserve, "")

' Business services realize motivation goals
Rel_Realization_Up(bs_circulation, g_ops, "")
Rel_Serving_Up(bs_catalog, g_service, "")

' Actors are served by business services
Rel_Serving_Up(bs_circulation, ba_librarian, "")
Rel_Serving_Up(bs_catalog, ba_member, "")

' Application services realize business services
Rel_Realization_Up(as_circulation, bs_circulation, "")
Rel_Realization_Up(as_catalog, bs_catalog, "")

' Application components realize application services
Rel_Realization_Up(ac_lms, as_circulation, "")
Rel_Realization_Up(ac_catalog, as_catalog, "")

' Technology nodes assign (deploy) application components
Rel_Assignment_Up(tn_server, ac_lms, "")
Rel_Assignment_Up(tn_db, ac_catalog, "")

@enduml

Donnez vie à votre architecture avec VPasCode

Le diagrammation en code vous permet de versionner votre architecture, de collaborer de manière fluide et de générer des diagrammes parfaits en quelques secondes. Que vous construisiez des modèles d’entreprise ArchiMate, des architectures logicielles C4 ou des diagrammes de séquence UML standard, le faire dans un environnement robuste fait toute la différence.