· 6 min read

Azimutt : l'outil ultime pour vos bases de données

Découvrons comment Azimutt peut vous aider à explorer et documenter vos bases de données HYPER simplement !

Découvrons comment Azimutt peut vous aider à explorer et documenter vos bases de données HYPER simplement !

Cet article est réalisé en partanariat avec Azimutt.

Obtenez 50% de réduction avec le code YOANDEV (valable juqu’au 30/03/2025)

Introduction

Votre projet grandit et votre base de données aussi. Il est même possible que vous possédiez plusieurs bases de données. Comment vous y retrouver ? Comment documenter tout ça ? C’est là qu’Azimutt entre en jeu !

Azimutt c’est un outil qui va vous permettre d’explorer et de documenter vos bases de données de manière simple et efficace. Vous allez voir, c’est un vrai jeu d’enfant !

Mettons en place une démo

Pour bien comprendre comment Azimutt fonctionne, mettons en place une vraie fausse architecture de base de données.

Nous allons utiliser trois instances de PostgreSQL. Une pour les utilisateurs, une pour les produits et une pour les commandes. C’est parti !

Le docker compose

Pour commencer, nous allons créer un fichier compose.yml qui va nous permettre de lancer nos trois instances de PostgreSQL.

Dans la vraie vie, cela pourrais correspondre à trois bases de données différentes pour 3 microservices différents par exemple.

services:
  users:
    image: postgres
    environment:
      POSTGRES_DB: users
      POSTGRES_USER: user
      POSTGRES_PASSWORD: password
    ports:
      - "5432:5432"

  products:
    image: postgres
    environment:
      POSTGRES_DB: products
      POSTGRES_USER: user
      POSTGRES_PASSWORD: password
    ports:
      - "5433:5432"

  orders:
    image: postgres
    environment:
      POSTGRES_DB: orders
      POSTGRES_USER: user
      POSTGRES_PASSWORD: password
    ports:
      - "5434:5432"

Démarrez vos instances de PostgreSQL avec la commande docker compose up -d.

Création des tables Users

  1. Connectez-vous à l’instance users avec votre client SQL préféré et exécutez le script suivant :
/* Type de User */
CREATE TABLE user_type (
  id SERIAL PRIMARY KEY,
  name VARCHAR(50)
);

/* Utilisateur */
CREATE TABLE "user" (
  id SERIAL PRIMARY KEY,
  type_id INT REFERENCES user_type(id),
  first_name VARCHAR(50),
  last_name VARCHAR(50),
  email VARCHAR(50),
  password VARCHAR(50)
);

/* Fixtures - Type de User - 2 types */
INSERT INTO user_type (name) VALUES ('Admin');
INSERT INTO user_type (name) VALUES ('User');

/* Fixtures - Utilisateurs */
INSERT INTO "user" (type_id, first_name, last_name, email, password) VALUES (1, 'John', 'Doe', 'test@test.com', 'password');
INSERT INTO "user" (type_id, first_name, last_name, email, password) VALUES (2, 'Jane', 'Doe', 'test@test.com', 'password');

Création des tables Products

  1. Connectez-vous à l’instance products avec votre client SQL préféré et exécutez le script suivant :
/* Produit */
CREATE TABLE product (
  id SERIAL PRIMARY KEY,
  name VARCHAR(50),
  price DECIMAL(10, 2)
);

/* Fixtures - Produits */
INSERT INTO product (name, price) VALUES ('T-shirt', 19.99);
INSERT INTO product (name, price) VALUES ('Mug', 9.99);
INSERT INTO product (name, price) VALUES ('Sticker', 1.99);

Création des tables Orders

  1. Connectez-vous à l’instance orders avec votre client SQL préféré et exécutez le script suivant :
/* Commande */
CREATE TABLE "order" (
  id SERIAL PRIMARY KEY,
  user_id INT,
  product_id INT,
  quantity INT
);

/* Fixtures - Commandes */
INSERT INTO "order" (user_id, product_id, quantity) VALUES (1, 1, 2);
INSERT INTO "order" (user_id, product_id, quantity) VALUES (2, 2, 1);
INSERT INTO "order" (user_id, product_id, quantity) VALUES (1, 3, 5);

Découvrons Azimutt

Maintenant que notre architecture de base de données est en place, nous allons pouvoir explorer et documenter tout ça avec Azimutt.

Initialisation d’un projet avec la CLI

Azimutt nous propose un moyen très simple pour démarrer un projet. Il suffit de lancer la commande suivante :

npx azimutt explore postgres://user:password@localhost:5432/users

La CLI va initialiser un projet Azimutt et l’ouvrir dans votre navigateur !

A ce stade, on peut explorer notre base de données, voir les tables, les colonnes, les contraintes, les index.. et même naviguer dans les données !

Un schéma multi-bases de données ?

L’une des forces d’Azimutt est de pouvoir explorer plusieurs bases de données en même temps… et de faire apparaître des liens entre elles !

Pour cela, il suffit d’ajouter nos deux autres bases de données à notre projet Azimutt :

  • postgres://user:password@localhost:5433/products
  • postgres://user:password@localhost:5434/orders

  • Ajoutons par exemple notre table order à notre layout.

  • Azimutt detecte que les colonnes user_id et product_id sont potentiellement des relations entre nos tables order, user et product, et nous propose de les lier ! Génial non ?

  • Magie, nous avons maintenant un schéma multi-bases de données !

  • Nous pouvons même naviguer dans les données de nos différentes bases de données ! je trouve ça vraiment HYPER pratique !

Complexifions un peu notre architecture

Azimutt n’a pas tremblé face à notre architecture de base de données simpliste. Mais qu’en est-il d’une architecture un peu plus complexe ? Genre, si on ajoute un peu de polymorphisme ?

Ajoutons une tables service dans notre base products

  1. Connectez-vous à l’instance products avec votre client SQL préféré et exécutez le script suivant :
/* Création de la table service */
CREATE TABLE service (
  id SERIAL PRIMARY KEY,
  name VARCHAR(50),
  fee DECIMAL(10, 2)
);

/* Fixtures - Services */
INSERT INTO service (name, fee) VALUES ('Livraison Express', 4.99);
INSERT INTO service (name, fee) VALUES ('Emballage cadeau', 2.99);

Modification de la table order pour supporter les services

  1. Connectez-vous à l’instance orders avec votre client SQL préféré et exécutez le script suivant :
/* Modifier la table order pour ajouter le champ polymorphique */
ALTER TABLE "order"
ADD COLUMN product_type VARCHAR(50); -- Pour indiquer le type référencé (ex. "product" ou "service");

/* Fixtures - Commandes existantes */
UPDATE "order" SET product_type = 'product';

/* Fixtures - Commandes de services */
INSERT INTO "order" (user_id, product_id, quantity, product_type) VALUES (2, 1, 1, 'service');
INSERT INTO "order" (user_id, product_id, quantity, product_type) VALUES (1, 2, 1, 'service');

Gestion du polymorphisme dans Azimutt

  • On rafrachit notre projet Azimutt pour prendre en compte les nouvelles tables et relations.
  • Directement, Azimutt détecte le polymorphisme et nous propose de lier nos tables order, product et service (avec des conditions when).

  • Ta-dam !

Designer des évolutions de votre modèle

Vous avez une nouvelle feature à développer et vous devez modifier votre base de données ? Pas de panique, Azimutt vous permet de designer vos évolutions de modèle AVANT de les appliquer !

Ajoutons une source de type AML à notre projet

  • AML, c’est Azimutt Markup Language. C’est un format simple pour décrire des schémas de base de données.

  • Ajoutons dinc une source AML `feature-xyz’ à notre projet.

  • Et designons une nouvelle table status (sans relation au sens SQL):
status
  id int pk
  name text 
  order_id int

  • Azimutt, une nouvelle fois, détecte les relations potentielles et nous propose de les lier !

Conclusion

Azimutt est un outil vraiment puissant pour explorer et documenter vos bases de données. Il est simple d’utilisation et permet de gérer des architectures complexes, multi-bases de données, et même du polymorphisme !

La démo que nous avons faite est très basique, peut de tables, peu de données… mais imaginez un peu ce que cela peut donner sur un vrai projet avec des centaines de tables, des milliers de données, des relations complexes…

Et nous n’avons même pas parlé de toutes les autres fonctionnalités d’Azimutt…

Share:
Back to Blog