ForgeLike : Prototyper l’UX d’une plateforme de déploiement

Projet en cours : créer une interface unifiée pour orchestrer Terraform, Ansible et GitLab CI. Le backend fonctionne, mais trouver une UX sans friction reste le défi principal.

Le problème

J’ai une stack de déploiement qui fonctionne bien :

Terraform : provisioning des serveurs (Hetzner, DigitalOcean)
Ansible : configuration des serveurs, installation des dépendances
GitLab CI : pipelines de build et déploiement

Chaque outil fait son travail. Mais l’expérience développeur est fragmentée : CLI Terraform, playbooks Ansible, interface GitLab, SSH pour les logs…

L’objectif : une interface unique qui orchestre tout ça, style Laravel Forge ou Coolify, mais adaptée à mon workflow.

Le prototype PHP

Avant de coder le backend complet, j’ai créé un prototype PHP pour valider l’UX. Pas de base de données, juste des données mock pour tester les parcours utilisateurs.

forgelike/
├── index.php           # Router simple
├── data/mock.php       # Données fictives
├── views/
│   ├── apps.php        # Liste des apps
│   ├── app-detail.php  # Détail d'une app
│   ├── servers.php     # Liste des serveurs
│   ├── repositories.php
│   ├── pipelines.php
│   └── ...
└── includes/
    ├── header.php
    ├── nav.php
    └── footer.php

Concepts clés

Apps vs Deployments

Une App est une définition : repo Git, type (Docker/native), port exposé.

Un Deployment est une instance de cette app sur un serveur : production sur prod-01, staging sur staging-01, etc.

App: catalog
├── Deployment: catalog-prod (prod-01, v2.1.0)
├── Deployment: catalog-staging (staging-01, latest)
└── Deployment: catalog-dev (dev-local, feature/new-ui)

Créer une app depuis un repo

Vue Repositories - Sélectionner un repo pour créer une app

Le flow “New App from repo” : 1. Connecter GitHub/GitLab 2. Sélectionner un repo 3. Détecter automatiquement le type (Dockerfile, package.json, composer.json) 4. Configurer le premier déploiement

Détail d’un déploiement

Détail d’une application avec ses déploiements

Chaque déploiement affiche : - Domain & SSL : domaine principal, aliases, certificat wildcard - Deployment : serveur, version, date, trigger (push to deploy, manuel) - Database : connexion (Neon, PlanetScale, local)

Onglets disponibles : - Deployments : liste des instances - Overview : vue d’ensemble du déploiement sélectionné - Environment : variables d’environnement - Deploy Script : script de déploiement personnalisable - Logs : logs en temps réel - Checklist : vérifications pré-déploiement

Ce qui fonctionne déjà (backend)

Le prototype UX est connecté à un backend réel pour certaines fonctionnalités :

Fonctionnalité	Status	Outil
Provisioning serveur	OK	Terraform + Hetzner
Configuration serveur	OK	Ansible
Build & Deploy	OK	GitLab CI
SSL automatique	OK	Traefik + Let’s Encrypt
Logs temps réel	WIP	WebSocket + journalctl

Le défi UX

Le backend fonctionne. Le vrai problème est l’UX :

Questions ouvertes

Granularité : Une vue par app ou par déploiement ? Les deux ?
Édition inline : Modifier les env vars directement ou via modal ?
Feedback déploiement : Progress bar, logs streaming, ou les deux ?
Gestion des erreurs : Comment présenter un échec de déploiement ?

Ce que j’ai appris

Laravel Forge : UX excellente mais trop couplée à Laravel
Coolify : Open source mais interface complexe
Vercel/Netlify : UX parfaite mais limitée aux apps statiques/serverless

Mon besoin est entre les deux : la simplicité de Vercel avec la flexibilité de Forge.

Stack technique visée

┌─────────────────────────────────────────────┐
│              ForgeLike UI                    │
│            (React + Vite)                    │
└─────────────────┬───────────────────────────┘
                  │ API
┌─────────────────▼───────────────────────────┐
│            ForgeLike API                     │
│         (Go ou Python FastAPI)              │
└──────┬──────────┬──────────┬────────────────┘
       │          │          │
┌──────▼────┐ ┌───▼────┐ ┌───▼──────┐
│ Terraform │ │ Ansible │ │ GitLab CI │
│   (HCL)   │ │ (YAML)  │ │  (API)    │
└───────────┘ └─────────┘ └───────────┘

Prochaines étapes

Finaliser le prototype UX avec des tests utilisateurs
API Go/Python pour orchestrer Terraform/Ansible
WebSocket pour les logs en temps réel
Intégration GitLab pour le push-to-deploy

Essayer le prototype

Le prototype est déployé (sur Nomad, évidemment) :

Demo : forgelike.dev.sylvainp.dev
Code : github.com/sylvainp/ux-inventory

Feedback bienvenu sur l’UX !

Laravel Forge · Coolify · Terraform · Ansible