Semaphore UI : piloter Ansible sans terminal avec une interface web moderne

Spoiler alert : vous n''avez pas besoin d''un cluster Kubernetes pour lancer un playbook Ansible depuis un navigateur. Le truc c''est que pendant des années, la seule option "sérieuse" pour mettre une interface web devant Ansible, c''était AWX (ou sa version payante, Ansible Automation Controller). Et clairement, c''est un peu comme si on vous demandait de construire un aéroport pour faire voler un drone. Semaphore UI change la donne : un binaire, un conteneur Docker, 256 Mo de RAM, et vous avez votre cockpit d''automatisation prêt à décoller.

On ne va pas se mentir : AWX est un outil puissant. Mais depuis la version 18, il impose Kubernetes en production. Pour une équipe qui gère 50 à 200 serveurs avec une dizaine de playbooks, c''est disproportionné.

Les douleurs classiques :

• Infrastructure lourde : Kubernetes ou Docker Compose (déprécié), PostgreSQL, Redis, plusieurs conteneurs qui se battent en duel
• RAM gourmande : 4 Go minimum, 8 Go recommandés. C''est un peu comme si votre launcher Steam consommait plus que le jeu lui-meme
• Mises à jour fragiles : les migrations AWX sont un sport extrême. Chaque montée de version est une partie de démineur
• Courbe d''apprentissage : l''interface est dense, parfois déroutante meme pour les ops expérimentés

Nuance importante : AWX reste pertinent pour les grandes organisations avec Kubernetes déjà en place, des workflows complexes et des milliers de nœuds. On parle ici du cas d''usage majoritaire, celui des PME et des équipes de taille humaine.

Semaphore est un projet open-source sous licence MIT qui fournit une interface web moderne pour Ansible, Terraform, OpenTofu et PowerShell. Plus de 10 000 étoiles sur GitHub, des releases régulières, une communauté active. C''est un peu comme si quelqu''un avait pris les 80% de fonctionnalités utiles d''AWX et les avait mises dans un package qui tient dans une boite d''allumettes.

Ses specs :

• Un seul conteneur Docker (image d''environ 50 Mo)
• Backends au choix : BoltDB (embarqué), SQLite, PostgreSQL, MySQL
• 256 Mo de RAM suffisent pour un usage courant
• API REST complète pour l''intégration CI/CD
• RBAC : gestion fine des utilisateurs par projet
• Scheduler cron intégré nativement
• Multi-outil : Ansible, Terraform, OpenTofu, PowerShell, scripts custom

C''est un peu comme un speedrun d''installation. La méthode propre pour un déploiement pérenne utilise Docker Compose avec PostgreSQL :

version: '3.8'

services:
  postgres:
    image: postgres:16-alpine
    restart: unless-stopped
    environment:
      POSTGRES_USER: semaphore
      POSTGRES_PASSWORD: '${DB_PASSWORD}'
      POSTGRES_DB: semaphore
    volumes:
      - pgdata:/var/lib/postgresql/data

  semaphore:
    image: semaphoreui/semaphore:latest
    restart: unless-stopped
    ports:
      - '3000:3000'
    environment:
      SEMAPHORE_DB_DIALECT: postgres
      SEMAPHORE_DB_HOST: postgres
      SEMAPHORE_DB_PORT: '5432'
      SEMAPHORE_DB_USER: semaphore
      SEMAPHORE_DB_PASS: '${DB_PASSWORD}'
      SEMAPHORE_DB: semaphore
      SEMAPHORE_ADMIN: admin
      SEMAPHORE_ADMIN_PASSWORD: '${ADMIN_PASSWORD}'
      SEMAPHORE_ADMIN_NAME: Administrateur
      SEMAPHORE_ADMIN_EMAIL: admin@example.com
      SEMAPHORE_ACCESS_KEY_ENCRYPTION: '${ENCRYPTION_KEY}'
    depends_on:
      - postgres

volumes:
  pgdata:

Et on lance :

# Générer une clé de chiffrement
export ENCRYPTION_KEY=$(head -c32 /dev/urandom | base64)
export DB_PASSWORD=$(openssl rand -base64 24)
export ADMIN_PASSWORD="VotreMotDePasseAdmin"

docker compose up -d

Semaphore est dispo sur http://votre-serveur:3000 en quelques secondes. Pas de cluster Kubernetes, pas de Redis, pas de 15 conteneurs. C''est propre, c''est léger, c''est opérationnel.

Mode ultra-light avec BoltDB

Pour tester ou pour un usage perso, BoltDB (base embarquée, zéro dépendance) fait le job :

docker run -d --name semaphore \
  -p 3000:3000 \
  -e SEMAPHORE_DB_DIALECT=bolt \
  -e SEMAPHORE_ADMIN=admin \
  -e SEMAPHORE_ADMIN_PASSWORD=changeme \
  -e SEMAPHORE_ADMIN_NAME=Admin \
  -e SEMAPHORE_ADMIN_EMAIL=admin@localhost \
  semaphoreui/semaphore:latest

Le truc c''est que la gestion des secrets, c''est souvent le point faible des interfaces web pour l''automatisation. Semaphore prend le sujet au sérieux avec son Key Store chiffré.

Chaque credential est chiffrée au repos grace à la clé SEMAPHORE_ACCESS_KEY_ENCRYPTION. Si vous perdez cette clé, game over : vos credentials deviennent illisibles. Sauvegardez-la comme un mot de passe maitre. Pour aller plus loin sur la gestion centralisée des secrets, jetez un œil à HashiCorp Vault.

Types de credentials supportés :

• SSH Key : clé privée pour la connexion aux hotes (le plus courant)
• Login with password : couple utilisateur/mot de passe
• None : pour les dépots publics, pas besoin de s''authentifier

La configuration suit un ordre logique : credentials d''abord, puis inventaires, dépots Git, et enfin templates. Chaque brique dépend de la précédente.

Inventaires

Semaphore supporte deux approches pour les inventaires :

• Static : vous collez directement le contenu INI ou YAML dans l''interface
• File : référence un fichier d''inventaire dans votre dépot Git

[webservers]
web01.example.com ansible_user=deploy
web02.example.com ansible_user=deploy

[databases]
db01.example.com ansible_user=deploy

Pour les inventaires dynamiques, utilisez un script ou plugin dans votre dépot et référencez-le comme fichier. Si vous structurez bien vos roles Ansible, la combinaison inventaire dynamique + roles réutilisables est un vrai benchmark de maturité DevOps.

Dépots (Repositories)

Semaphore clone vos dépots Git pour accéder aux playbooks et roles. GitHub, GitLab, Gitea, n''importe quel serveur Git : tout fonctionne. Associez une credential SSH ou HTTPS au dépot, et c''est parti.

Point intéressant : le dépot est cloné à chaque exécution. Pas de cache de projet qui traine et qui vous fait debug pendant 2 heures parce que "le code a changé mais ça lance toujours l''ancienne version". AWX, si tu nous lis...

Templates (Job Templates)

Les templates sont le cœur de Semaphore. Chaque template associe :

• Un dépot (source du code)
• Un inventaire (cibles)
• Un playbook (chemin relatif dans le dépot)
• Des credentials (accès aux hotes)
• Des variables d''environnement optionnelles
• Des extra variables Ansible (format YAML)

C''est la ou tout se connecte. Un template = une action reproductible, versionnée, traçable.

Clairement, c''est la ou Semaphore passe du statut d''"interface sympathique" à "outil sérieux d''orchestration". L''API REST complète permet de déclencher n''importe quel template depuis un pipeline externe.

Déclencher un template via l''API

# Authentification
TOKEN=$(curl -s -X POST http://semaphore:3000/api/auth/login \
  -H "Content-Type: application/json" \
  -d ''{"auth": "admin", "password": "secret"}'' | jq -r .token)

# Lancer un template
curl -X POST http://semaphore:3000/api/project/1/tasks \
  -H "Authorization: Bearer $TOKEN" \
  -H "Content-Type: application/json" \
  -d ''{"template_id": 1}''

Webhooks natifs

Semaphore dispose aussi d''un système d''intégrations (webhooks entrants) qui permet à des systèmes externes de déclencher des templates automatiquement. Un push sur votre dépot Git ? Semaphore peut intercepter le webhook, vérifier l''authenticité de la requête, extraire des données du payload et lancer le template associé.

C''est un peu comme si vous aviez un butler qui surveille vos dépots et lance les déploiements tout seul. Le reve de tout DevOps.

Exemple concret : pipeline GitLab CI

Intégrez Semaphore dans un pipeline GitLab CI : le code est poussé, la CI lance les tests, puis déclenche le déploiement via l''API Semaphore. Le meilleur des deux mondes : la rigueur du CI/CD et la visibilité de Semaphore pour l''exécution Ansible.

Le scheduler cron intégré permet de planifier n''importe quel template :

• 0 2 * * * : patching quotidien à 2h du matin
• 0 */4 * * * : vérification de conformité toutes les 4 heures
• 0 9 * * 1 : déploiement planifié chaque lundi à 9h

Pour des workflows plus avancés (chainage de jobs, conditions, approbations), l''API REST prend le relais. Vous pouvez orchestrer des séquences depuis un pipeline Jenkins ou GitLab CI.

Le modèle de permissions est organisé par projet, simple et efficace :

En pratique : un admin configure les dépots et credentials, 2 managers créent les templates, et les devs ou ops juniors en Task Runner lancent les déploiements sans toucher à la configuration. C''est le principe du moindre privilège appliqué sans usine à gaz.

Quelques points non négociables pour un déploiement sérieux :

1. Reverse proxy TLS : placez Nginx ou Traefik devant Semaphore avec un certificat Let''s Encrypt. Jamais de HTTP en prod
2. Clé de chiffrement : la variable SEMAPHORE_ACCESS_KEY_ENCRYPTION chiffre les credentials au repos. Perdre cette clé = perdre tous vos secrets stockés
3. PostgreSQL en prod : BoltDB et SQLite ne gèrent pas bien la concurrence. Pour de la prod, PostgreSQL sans hésiter
4. Backups : sauvegardez la base PostgreSQL ET la clé de chiffrement. L''un sans l''autre est inutile
5. Mises à jour : docker compose pull && docker compose up -d suffit. Les migrations de schéma sont automatiques

Si vous débutez avec Ansible, commencez par automatiser votre configuration avant de mettre une interface web par-dessus. Semaphore est un accélérateur, pas un raccourci : il faut maitriser les fondamentaux (playbooks, inventaires, roles) pour en tirer le maximum.

Pour les équipes qui combinent Terraform et Ansible, Semaphore est particulièrement intéressant puisqu''il supporte nativement les deux outils dans la meme interface. Un seul tableau de bord pour le provisioning et la configuration.

Et si vous voulez valider vos roles avant de les exécuter en production, Molecule reste le standard pour les tests unitaires Ansible. Semaphore + Molecule + GitLab CI, c''est le triangle d''or de l''automatisation infrastructure.

On ne va pas se mentir : Semaphore UI ne remplace pas AWX pour les organisations à 1000+ nœuds avec des workflows d''approbation complexes. Mais pour les 90% d''équipes restantes, c''est clairement le meilleur ratio fonctionnalités/complexité du marché. 256 Mo de RAM, un conteneur, 5 minutes d''installation, et vous avez une interface web complète avec RBAC, scheduling, webhooks et gestion chiffrée des credentials. Game-changer.

• Site officiel Semaphore UI
• Dépot GitHub Semaphore UI
• Documentation officielle : installation Docker
• Simple CI/CD on Ansible Semaphore UI (DEV Community)