ArchiMate et TOGAF pour une plateforme DBA : trois couches, éléments utiles et trois vues
Modéliser une plateforme DBA avec ArchiMate dans Archi : couches métier, application et technologie, éléments et relations utiles, trois vues et un miroir Mermaid.
Quand une plateforme DBA grossit (des dizaines de scripts, des modules partagés, des pipelines, des pools Batch, des bases Azure SQL), plus personne ne la tient entièrement en tête. Un modèle d'architecture n'est pas un exercice académique : c'est la carte qui répond à « qui lance quoi, sur quoi, avec quelles dépendances ? » avant de toucher à quoi que ce soit. J'utilise ArchiMate (le langage de modélisation) dans Archi (l'outil gratuit), avec TOGAF comme cadre de pensée.
TOGAF et ArchiMate en deux phrases
TOGAF est une méthode : elle découpe l'architecture en domaines (métier, applications, données, technologie). ArchiMate est le langage graphique qui permet de les dessiner avec un vocabulaire fixe. Pour un DBA, on retient surtout trois couches.
| Couche | Question | Exemple générique |
|---|---|---|
| Business | Qui fait quoi, pour quel objectif ? | Rôle « équipe DBA », processus « maintenance SQL » |
| Application | Quels logiciels rendent ce service ? | Script de sauvegarde, module PowerShell partagé |
| Technology | Sur quelle infrastructure cela tourne-t-il ? | Pool Batch, pipeline, serveur SQL, coffre de secrets |
Les éléments qu'un DBA utilise vraiment
ArchiMate en compte des dizaines. Une poignée suffit :
- Application component : une brique logicielle déployable (un script d'application, un module PowerShell).
- Application service : ce qu'un composant offre aux autres (« exécuter une requête SQL », « envoyer un mail »).
- Node : une ressource d'exécution ou de stockage (pool Batch, agent de pipeline, serveur ou pool élastique SQL).
- System software : le logiciel qui tourne sur un nœud (runtime PowerShell, moteur SQL).
- Artifact : un livrable concret (paquet ZIP, dacpac, fichier de configuration).
- Data object : une donnée manipulée (table d'inventaire, fichier de config, journal).
Et les relations, à choisir avec soin :
| Relation | Sens | Usage typique |
|---|---|---|
| Assignment | acteur -> processus | l'équipe DBA assure un processus |
| Realization | composant -> processus ou service | une application réalise un processus |
| Serving | fournisseur -> consommateur | un module sert une application ; un nœud sert une application |
| Triggering | déclencheur -> cible | un pipeline lance une tâche |
| Flow | source -> cible | des données qui circulent d'une base à une autre |
| Association | sans sémantique forte | un module qui en utilise un autre |
Un piège de la norme : l'Access d'un composant applicatif vers un nœud n'est pas autorisé. L'accès se modélise vers un data object ; vers l'infrastructure, on utilise Serving ou Flow.
Trois vues utiles
Je ne dessine pas « tout sur une page ». Chaque vue répond à une question.
- Vue d'ensemble : l'équipe, ses processus, les applications qui les réalisent, les modules dont elles dépendent. Pas de nœuds : on veut lire la carte en dix secondes.
- Vue modules : ce que chaque module expose (fonctions, services) et qui en dépend. Si un module sert presque tout le monde, je le dessine une fois et je l'écris dans une note, plutôt que de tracer vingt lignes.
- Vue exécution batch : par voie d'exécution (pipeline planifié, pool Batch, poste de rebond), ce qui démarre l'exécution et quelles ressources la servent. Une ressource est répétée dans chaque « couloir » qui l'utilise, pour qu'aucune ligne ne traverse la vue.
Un diagramme Mermaid qui imite la vue d'ensemble
Le modèle vit dans Archi, mais un miroir Mermaid se lit directement dans le dépôt et dans une page wiki :
flowchart TD
subgraph Business
R["Équipe DBA (rôle)"]
P1["Maintenance SQL (processus)"]
P2["Sauvegarde longue durée (processus)"]
end
subgraph Application
A1["App maintenance"]
A2["App sauvegarde"]
M1["Module partagé SQL"]
M2["Module partagé Batch"]
end
subgraph Technology
N1["Pipeline"]
N2["Pool Batch"]
N3["Pool élastique SQL"]
S1["Runtime PowerShell 7"]
end
R --> P1
R --> P2
A1 --> P1
A2 --> P2
M1 --> A1
M1 --> A2
M2 --> A1
M2 --> A2
N1 --> N2
N2 --> A1
N2 --> A2
N3 --> A1
S1 --> N2
Les flèches ont ici une lecture simplifiée : de l'équipe vers ses processus (assignment), des applications vers les processus (realization), des modules et nœuds vers les applications (serving), du pipeline vers le pool (triggering).
Retour d'expérience
- Limiter les croisements. Au-delà d'environ 25 lignes qui se croisent, une vue n'est plus lue. Déplacer les relations vers un tableau dans le README vaut mieux qu'un plat de spaghettis.
- Nommer ce qu'on ne dessine pas. Une note dans la vue (« les identités managées ne sont pas tracées, chaque ressource est atteinte avec l'identité du contexte d'exécution ») évite les questions.
- Rester à la bonne granularité. Une fonction renommée ne concerne pas l'architecte d'entreprise ; une nouvelle application, si.
- Un modèle qui contredit le code est une anomalie à corriger, pas une source de vérité.