Rackula est une application open source, accessible directement dans votre navigateur Web, et qui permet de modéliser facilement vos baies serveurs. De quoi vous permettre de créer un schéma propre et à jour de vos racks, que ce soit celui de votre HomeLab ou celui de votre entreprise.
Que ce soit pour alimenter votre documentation d’exploitation, pour savoir ce que vous avez comme place disponible dans votre baie, ou peut-être même schématiser l’implantation d’équipements dans une nouvelle baie, Rackula peut vous aider ! Il représente une alternative à la méthode Excel ou celle basée sur Visio pour réaliser ce type de tâche. C’est aussi une alternative plus basique à l’utilisation de solutions plus complètes qui intègrent ce genre de fonctionnalités, comme GLPI et NetBox.
Qu’est-ce que Rackula ?
Rackula est une application open source permettant de concevoir des schémas de baies informatiques (que l’on appelle “rack layouts” en anglais). Simple à utiliser, cette application adopte une approche par “glisser-déposer” pour positionner des équipements sur vos baies informatiques. Tout s’effectue dans votre navigateur où vous pouvez créer un ou plusieurs racks facilement, avec la face avant et la face arrière, ou uniquement la face avant.
Bien que pensée pour fonctionner de manière totalement déconnectée dans le navigateur (client-side), Rackula propose également un mode de déploiement “avec persistance”. Ce mode, que nous allons exploiter dans ce tutoriel, s’appuie sur une API backend permettant de sauvegarder vos agencements de baies sous forme de fichiers YAML sur votre serveur. Ainsi, vous pouvez retrouver vos projets par la suite.
Rackula permet d’exporter vos réalisations aux formats PNG, PDF ou SVG, et vous pouvez partager l’URL d’un projet via un QR code.
Ce projet étant open source, son code source est disponible sur GitHub. Vous pouvez aussi le tester directement en ligne, ce qui permet de se faire une idée avant un déploiement en mode self-hosted.
Prérequis
Pour installer Rackula sur votre serveur (ou NAS), voici quelques prérequis à respecter. C’est du grand classique.
Le moteur Docker doit être installé, tout comme Docker Compose.
Vous devez disposer des droits d’administration (root ou via sudo).
Un port doit être disponible (dans notre exemple, le port 8080) sur la machine hôte.
Si Docker n’est pas encore installé sur votre système, je vous invite à consulter ce tutoriel :
Déploiement de Rackula avec Docker
Pour commencer, nous allons créer un répertoire dédié au service Rackula : /opt/docker-compose/rackula. Nous allons aussi créer à l’intérieur un répertoire nommé data et qui sera utilisé pour stocker nos projets.
Ouvrez un terminal sur votre serveur et exécutez les commandes suivantes pour créer le dossier et vous y déplacer :
mkdir -p /opt/docker-compose/rackula/data
cd /opt/docker-compose/rackula
Ensuite, créez un fichier nommé docker-compose.yml :
nano docker-compose.yml
Insérez le code spécifié ci-dessous. Nous utilisons ici la version persistante de l’application, ce qui nécessite de déployer un service pour le frontend (l’interface web) et un service pour l’API (le backend chargé de l’écriture des données) :
services:
rackula:
image: ghcr.io/rackulalives/rackula:persist
container_name: rackula
ports:
– “8080:8080”
environment:
– API_HOST=rackula-api
– API_PORT=${RACKULA_API_PORT:-3001}
– RACKULA_LISTEN_PORT=8080
– API_WRITE_TOKEN=${RACKULA_API_WRITE_TOKEN:-}
# Pas d’authentification pour cet usage local
– RACKULA_AUTH_MODE=none
restart: unless-stopped
stop_grace_period: 10s
depends_on:
rackula-api:
condition: service_healthy
networks:
– rackula-network
deploy:
resources:
limits:
cpus: “0.50”
memory: 128M
reservations:
cpus: “0.10”
memory: 16M
security_opt:
– no-new-privileges:true
cap_drop:
– ALL
read_only: true
tmpfs:
– /var/cache/nginx:size=10M
– /var/run:size=1M
– /tmp:size=5M
– /etc/nginx/conf.d:size=1M,uid=101,gid=101
logging:
driver: json-file
options:
max-size: “10m”
max-file: “3”
rackula-api:
image: ghcr.io/rackulalives/rackula-api:latest
container_name: rackula-api
restart: unless-stopped
stop_grace_period: 10s
volumes:
– ./data:/data
networks:
– rackula-network
environment:
– DATA_DIR=/data
– RACKULA_API_PORT=${RACKULA_API_PORT:-3001}
– CORS_ORIGIN=${CORS_ORIGIN:-http://localhost:8080}
– RACKULA_API_WRITE_TOKEN=${RACKULA_API_WRITE_TOKEN:-}
# Même valeur que pour le frontend : pas d’authentification
– RACKULA_AUTH_MODE=none
# Important en local : on désactive la sécurité des cookies liée au HTTPS
– RACKULA_AUTH_SESSION_COOKIE_SECURE=false
– RACKULA_AUTH_CSRF_PROTECTION=true
– ALLOW_INSECURE_CORS=false
deploy:
resources:
limits:
cpus: “0.25”
memory: 64M
reservations:
cpus: “0.05”
memory: 16M
security_opt:
– no-new-privileges:true
cap_drop:
– ALL
read_only: true
tmpfs:
– /tmp:size=5M
healthcheck:
test: [“CMD-SHELL”, “wget -qO- http://127.0.0.1:${RACKULA_API_PORT:-3001}/health”]
interval: 30s
timeout: 10s
start_period: 5s
retries: 3
logging:
driver: json-file
options:
max-size: “5m”
max-file: “2”
networks:
rackula-network:
name: rackula-network
driver: bridge
Remarque : pour le service rackula, nous n’utilisons pas le tag latest classique, mais le tag persist. C’est cette version spécifique du conteneur qui permet d’assurer la persistance des données.
Enregistrez et fermez ce fichier. En complément, créez un fichier .env afin de spécifier les variables d’environnement.
Dans ce second fichier, ajoutez le contenu suivant :
RACKULA_API_WRITE_TOKEN=HkXTxFORHjF2jiOS1TZr1kU5bAsQl0k7
CORS_ORIGIN=http://192.168.10.220:8080
Voici à quoi correspondent ces deux variables :
CORS_ORIGIN : cette variable permet d’indiquer à l’API quelle origine (URL) est autorisée à émettre des requêtes. Si vous y accédez via http://192.168.1.50:8080, vous devez définir cette valeur à l’identique. C’est une fonction de sécurité courante sur les applications Web.
RACKULA_API_WRITE_TOKEN : un jeton pour protéger les opérations d’écriture sur l’API de l’application. Cette variable définit donc un mot de passe (token). Définissez une chaîne de caractères aléatoires.
Une fois votre fichier docker-compose.yml enregistré, vous pouvez déclencher la construction de la stack Docker Compose. Toujours depuis le répertoire /opt/docker-compose/rackula, exécutez la commande suivante :
docker compose up -d
Afin de vous assurer que les services démarrent correctement et qu’il n’y a pas d’erreur de communication entre le frontend et l’API, il est judicieux de lire les journaux de l’application. Je vous rappelle la commande :
docker compose logs -f
Si aucune erreur ne s’affiche, l’application devrait être accessible depuis votre navigateur.
Déploiement de Rackula avec un reverse proxy Traefik
Pour ceux qui veulent une configuration où Rackula est publié via un reverse proxy Traefik, et donc accessible en HTTPS, voici le code Docker Compose que vous pouvez utiliser.
services:
rackula:
image: ghcr.io/rackulalives/rackula:persist
container_name: rackula
environment:
– API_HOST=rackula-api
– API_PORT=${RACKULA_API_PORT:-3001}
– RACKULA_LISTEN_PORT=8080
– API_WRITE_TOKEN=${RACKULA_API_WRITE_TOKEN:-}
# Désactivation de l’authentification locale
– RACKULA_AUTH_MODE=none
restart: unless-stopped
stop_grace_period: 10s
depends_on:
rackula-api:
condition: service_healthy
networks:
– rackula-network
– frontend
labels:
– traefik.enable=true
– traefik.http.routers.rackula.rule=Host(`rackula.it-connectlab.fr`)
– traefik.http.routers.rackula.entrypoints=websecure
– traefik.http.routers.rackula.tls=true
– traefik.http.routers.rackula.tls.certresolver=ovhcloud
– traefik.http.services.rackula.loadbalancer.server.port=8080
# Forcer Traefik à utiliser le réseau commun pour router le trafic
– traefik.docker.network=frontend
deploy:
resources:
limits:
cpus: “0.50”
memory: 128M
reservations:
cpus: “0.10”
memory: 16M
security_opt:
– no-new-privileges:true
cap_drop:
– ALL
read_only: true
tmpfs:
– /var/cache/nginx:size=10M
– /var/run:size=1M
– /tmp:size=5M
– /etc/nginx/conf.d:size=1M,uid=101,gid=101
logging:
driver: json-file
options:
max-size: “10m”
max-file: “3”
rackula-api:
image: ghcr.io/rackulalives/rackula-api:latest
container_name: rackula-api
restart: unless-stopped
stop_grace_period: 10s
volumes:
– ./data:/data
networks:
– rackula-network
environment:
– DATA_DIR=/data
– RACKULA_API_PORT=${RACKULA_API_PORT:-3001}
– CORS_ORIGIN=${CORS_ORIGIN}
– RACKULA_API_WRITE_TOKEN=${RACKULA_API_WRITE_TOKEN:-}
# L’API doit avoir le même mode d’authentification que le front
– RACKULA_AUTH_MODE=none
– ALLOW_INSECURE_CORS=false
deploy:
resources:
limits:
cpus: “0.25”
memory: 64M
reservations:
cpus: “0.05”
memory: 16M
security_opt:
– no-new-privileges:true
cap_drop:
– ALL
read_only: true
tmpfs:
– /tmp:size=5M
healthcheck:
test: [“CMD-SHELL”, “wget -qO- http://127.0.0.1:${RACKULA_API_PORT:-3001}/health”]
interval: 30s
timeout: 10s
start_period: 5s
retries: 3
logging:
driver: json-file
options:
max-size: “5m”
max-file: “2”
networks:
rackula-network:
name: rackula-network
driver: bridge
frontend:
external: true
Cette configuration s’appuie sur deux réseaux : le réseau frontend pour les connexions entre Traefik et le service principal de Rackula. Le réseau rackula-network pour les connexions backend entre les deux conteneurs Rackula.
Vous devez, là aussi, créer un fichier .env pour définir plusieurs variables d’environnement. C’est un peu plus strict puisque l’on va publier l’application en HTTPS.
# Port d’écoute de l’interface web
RACKULA_LISTEN_PORT=8080
# Port de communication de l’API (interne)
RACKULA_API_PORT=3001
# Jeton de sécurité pour les opérations d’écriture entre le front et l’API
RACKULA_API_WRITE_TOKEN=HkXTxFORHjF2jiOS1TZr1kU5bAsQl0k7
# Clé de chiffrement pour les sessions (générez une chaîne de 32 caractères : important !!)
RACKULA_AUTH_SESSION_SECRET=HVkbGtJcX5xyCAKlbODGzQ7aJsX4GKU3
# URL exacte par laquelle vous accédez au service (pour le CORS)
# Changez cette valeur par l’IP de votre serveur ou votre nom de domaine
CORS_ORIGIN=https://rackula.it-connectlab.fr
# Variables de sécurité des cookies (mettre false si vous n’utilisez pas HTTPS/SSL)
RACKULA_AUTH_SESSION_COOKIE_SECURE=true
Prise en main de Rackula
Ouvrez un navigateur web depuis une machine de votre réseau et naviguez vers l’URL configurée, par exemple : http://192.168.1.50:8080.
L’interface de Rackula s’affiche. Voici comment fonctionne Rackula :
Création d’une baie : sélectionnez le type de baie et renseignez les caractéristiques physiques de votre baie (nom, nombre d’unités – U).
Ajout d’équipements : utilisez la barre latérale pour parcourir le catalogue de composants disponibles (serveurs, commutateurs réseaux, PDU).
Positionnement : sélectionnez un équipement et glissez-le dans l’emplacement souhaité au niveau de la baie.
Personnalisation : éditez les différents équipements pour ajouter des métadonnées, comme l’adresse IP et/ou une note, ainsi que des images des façades.
Export : quand tout est prêt, vous pouvez décider d’exporter votre schéma au format image.
Ci-dessous une rapide présentation de l’application. Je vous invite à regarder ma vidéo pour une démonstration complète.
Vous pouvez créer une baie informatique unique ou alors plusieurs baies côte à côte.
Puis, vous devez indiquer la taille de votre baie informatique (baie 19 pouces, par exemple) et sa hauteur en nombre de U.
Votre baie informatique est ensuite ajoutée à l’interface de Rackula. Sur la gauche, vous pouvez piocher dans la bibliothèque des équipements :
Vous avez des équipements et accessoires génériques : PDU, étagère, bandeau passe-câble, serveur, mini PC, switch, routeur, etc…
Vous avez des équipements de marques préconfigurés, comme des routeurs TP-Link, des serveurs Dell ou encore des NAS Synology
Si vous souhaitez ajouter une référence qui n’est pas dans la liste, ce n’est pas gênant. Vous pouvez créer vos propres équipements : nom, taille occupée en U, catégorie, couleur, profondeur, etc… Créez vos assets personnalisés facilement. Ils sont ensuite ajoutés à la bibliothèque.
Vous n’avez qu’à faire des glisser-déposer pour positionner vos équipements dans la baie.
Rackula permet d’ajouter des informations sur chaque élément, comme une adresse IP, une note, ou encore une photo de la face avant et de la face arrière. Il y a justement une vue pour permettre d’afficher les photos réelles plutôt que des blocs avec du texte. Chaque équipement peut aussi être décalé au niveau d’un U (de 1/3 d’un U, par exemple) pour refléter l’implémentation réelle.
À tout moment, vous pouvez décider d’exporter votre création. Quelques options sont proposées, notamment pour éliminer le fond ou pour utiliser plutôt un thème sombre ou clair.
Voici un exemple de modélisation créée avec Rackula :
Conclusion
Simple et efficace : Rackula est une solution accessible à toutes et tous pour effectuer la modélisation d’une baie informatique. Il y a plein de scénarios d’utilisation pour ce type d’outils, y compris pour les étudiants afin de s’exercer à imaginer l’implémentation d’un ensemble d’équipements dans une baie informatique. Désormais, vous n’avez plus d’excuse : documentez vos racks !
Si vous appréciez les outils de schématisation open source, regardez aussi :
Ingénieur système et réseau, cofondateur d’IT-Connect et Microsoft MVP “Cloud and Datacenter Management”. Je souhaite partager mon expérience et mes découvertes au travers de mes articles. Généraliste avec une attirance particulière pour les solutions Microsoft et le scripting. Bonne lecture.