Semaphore UI : Une Alternative Puissante à AWX

Semaphore UI est une plateforme open-source de déploiement et d’intégration continue (CI/CD), souvent considérée comme une alternative puissante à AWX, l’interface utilisateur officielle d’Ansible Tower. Contrairement à AWX, Semaphore UI est conçu pour être léger, simple à déployer, et hautement compatible avec les outils modernes d’automatisation comme Terraform et OpenTofu.

Semaphore UI se distingue par sa capacité à s’intégrer parfaitement dans les environnements DevOps modernes, offrant des fonctionnalités avancées pour orchestrer des pipelines CI/CD complexes tout en restant facile à utiliser et à configurer. Il est particulièrement adapté aux équipes qui cherchent à rationaliser leurs workflows CI/CD en utilisant des technologies open-source tout en bénéficiant d’une compatibilité accrue avec des outils de provisioning d’infrastructure.

Points Forts de Semaphore UI par Rapport à AWX et Autres Solutions

Meilleure Intégration GitLab : L’intégration native avec GitLab via des Personal Access Tokens (PAT) simplifie le déploiement et l’intégration des rôles Ansible hébergés sur des dépôts privés, une tâche qui peut être plus compliquée à réaliser sur AWX sans configuration supplémentaire.

Installation et Configuration Simples : Contrairement à AWX, qui nécessite une installation complexe avec de multiples dépendances, Semaphore UI est facilement déployable via Docker Compose, ce qui le rend idéal pour les équipes qui cherchent à mettre en place une solution rapide et évolutive.

Compatibilité avec Terraform et OpenTofu : Semaphore UI prend en charge des outils d’infrastructure-as-code (IaC) comme Terraform et OpenTofu, permettant une gestion transparente des environnements cloud et hybrides. Cela en fait une option de choix pour les équipes DevOps qui utilisent ces outils pour automatiser le provisioning et la gestion de l’infrastructure.

Comparatif des Fonctionnalités : Semaphore UI vs AWX et Autres Solutions CI/CD

Fonctionnalité	Semaphore UI	AWX	Jenkins	GitLab CI/CD
Compatibilité avec Ansible	Intégration native avec des survey variables	Intégration native avec Ansible	Plugins disponibles	Intégration possible via pipelines
Intégration avec GitLab	Support natif avec PAT pour les rôles Ansible	Possible mais nécessite configuration	Nécessite plugins supplémentaires	Intégration native et transparente
Compatibilité avec Terraform	Compatible et extensible avec OpenTofu	Possible via scripts externes	Supporte Terraform via plugins	Intégration native via CI templates
Facilité de déploiement	Installation rapide avec Docker Compose	Plus complexe avec plusieurs dépendances	Complexe et dépend de nombreux plugins	Installation facilitée sur GitLab Runner
Interface utilisateur	Simple et intuitive, conçue pour les non-techniques	Plus technique, orientée DevOps	Interface vieillissante et complexe	Moderne et fluide
Support multi-environnements	Excellent avec gestion dynamique des variables	Bon, mais moins flexible	Possible mais difficile à configurer	Très bon avec la gestion des environnements

Déploiement de Semaphore UI avec Docker Compose

Pour déployer Semaphore UI, nous avons utilisé Docker Compose, une méthode simple et efficace pour configurer l’environnement et gérer les dépendances. Voici le fichier docker-compose.yml mis à jour, anonymisé et optimisé :

services:
  semaphore:
    image: semaphoreui/semaphore:latest
    ports:
      - "3000:3000"
    environment:
      - SEMAPHORE_DB_HOST=${SEMAPHORE_DB_HOST}
      - SEMAPHORE_DB_PORT=5432
      - SEMAPHORE_DB_USER=${SEMAPHORE_DB_USER}
      - SEMAPHORE_DB_PASS=${SEMAPHORE_DB_PASS}
      - SEMAPHORE_DB=${SEMAPHORE_DB}
      - SEMAPHORE_DB_DIALECT=postgres
      - SEMAPHORE_PLAYBOOKS=/tmp/semaphore
      - HTTP_PROXY=http://proxy.example.com:3128
      - HTTPS_PROXY=http://proxy.example.com:3128
      - NO_PROXY=localhost,127.0.0.1,10.0.0.0/8,192.168.0.0/16,172.16.0.0/12,.example.com
    volumes:
      - ./data/etc:/etc/semaphore
      - ./data/tmp:/tmp/semaphore
      - /etc/pki/tls/certs/ca-bundle.crt:/etc/ssl/certs/ca-certificates.crt:ro
    dns:
      - 8.8.8.8
      - 8.8.4.4
    dns_search:
      - example.com

Installation des Modules Python avec requirements.txt

Pour automatiser l’installation des dépendances Python nécessaires à Ansible, nous avons utilisé un fichier requirements.txt dans le dossier data/etc/ avec le contenu suivant :

paramiko
scp

Description des Packages :

• paramiko : Utilisé pour gérer les connexions SSH de manière sécurisée avec Ansible.
• scp : Utilisé pour les transferts de fichiers sécurisés entre les hôtes.

Ce fichier est monté dans le conteneur et les packages sont automatiquement installés lors du démarrage de Semaphore UI, garantissant que l’environnement est prêt pour exécuter les tâches Ansible dès son déploiement.

Gestion des Certificats SSL

Pour garantir que les connexions réseau utilisent les bons certificats, nous avons monté le certificat de l’autorité de certification (CA) du système hôte dans le conteneur Docker. Cela permet à Semaphore UI de faire confiance aux certificats SSL lors de la communication avec des services externes.

Configuration du Montage du Certificat

La ligne suivante dans la section volumes assure le montage correct du certificat CA :

- /etc/pki/tls/certs/ca-bundle.crt:/etc/ssl/certs/ca-certificates.crt:ro

• Explication : Cela monte le fichier de la CA du système hôte dans le conteneur à l’emplacement approprié. Le :ro à la fin de la ligne signifie que le fichier est monté en lecture seule, garantissant qu’il ne sera pas modifié accidentellement par les processus dans le conteneur.
• Avantages : Cette configuration permet à Semaphore UI de vérifier les certificats SSL de manière sécurisée, améliorant ainsi la confiance dans les connexions sécurisées utilisées pour interagir avec d’autres services comme GitLab ou les dépôts Git.

Intégration avec GitLab et Gestion des Dépendances Ansible

Nous avons configuré Semaphore UI pour s’intégrer avec GitLab afin de gérer les rôles Ansible stockés dans des dépôts privés. Cette intégration est réalisée grâce à l’utilisation d’un Personal Access Token (PAT) dans le fichier roles/requirements.yml.

Configuration du Fichier roles/requirements.yml

Voici un exemple du fichier requirements.yml utilisé pour récupérer les rôles Ansible depuis GitLab :

---
- src: https://oauth2:[email protected]/ansible/ansible-roles/CISCO.base
  scm: git
- src: https://oauth2:[email protected]/ansible/ansible-roles/CISCO.ssh
  scm: git
- src: https://oauth2:[email protected]/ansible/ansible-roles/CISCO.password
  scm: git
- src: https://oauth2:[email protected]/ansible/ansible-roles/CISCO.Upgrade
  scm: git
- src: https://oauth2:[email protected]/ansible/ansible-roles/CISCO.Upload-ios
  scm: git
- src: https://oauth2:[email protected]/ansible/ansible-roles/CISCO.acl
  scm: git

• src : L’URL du dépôt Git avec le préfixe https://oauth2:your-token@ qui permet l’authentification via un Personal Access Token.
• scm : Le type de contrôle de source, ici spécifié comme git, pour indiquer l’utilisation de Git comme système de versionnage.

Survey Variables et Flexibilité des Déploiements

Les Survey Variables dans Semaphore UI sont conçues pour permettre aux utilisateurs de saisir dynamiquement des informations lorsqu’ils exécutent des tâches ou des déploiements. Ces variables sont souvent utilisées pour rendre les playbooks plus interactifs et flexibles, en permettant aux utilisateurs de définir des valeurs spécifiques à l’exécution, comme des noms d’hôtes ou des identifiants.

Types de Survey Variables

Semaphore UI a introduit différents types de Survey Variables, y compris les types Enum et Secret, qui permettent d’améliorer la sécurité et la gestion des entrées utilisateur. Le type Enum, par exemple, permet de créer une liste déroulante de valeurs prédéfinies, ce qui simplifie le choix pour l’utilisateur et réduit le risque d’erreurs lors de la saisie.

Utilisation des Survey Variables avec Ansible

Dans la pratique, les Survey Variables sont automatiquement converties en extra-vars lorsqu’elles sont passées à Ansible. Cela signifie qu’elles ne peuvent pas être directement utilisées dans les arguments de ligne de commande comme -l. Si vous souhaitez passer une Survey Variable pour limiter les hôtes, vous devrez l’utiliser dans le contexte des variables Ansible via --extra-vars. Par exemple :

ansible-playbook playbook.yml --extra-vars "host_target={{Host}}"

Cela permet aux utilisateurs de spécifier dynamiquement des valeurs, telles que le nom d’hôte ou les variables d’environnement, sans modifier le code source.

Limitation actuelle

Une limitation notable est que les Survey Variables ne peuvent pas être directement référencées dans les champs d’arguments CLI au moment de l’exécution, car elles sont transformées en extra-vars et ne sont donc pas accessibles comme des variables normales dans ce contexte. Une demande de fonctionnalité a été proposée pour améliorer cette situation en ajoutant un champ dédié pour l’option --limit, ce qui faciliterait l’utilisation des Survey Variables dans les filtres de cible d’hôtes lors des exécutions de playbooks.

Améliorations et Discussions

La communauté Semaphore a activement discuté des améliorations possibles pour les Survey Variables, et il existe des propositions pour rendre ces variables plus flexibles, notamment en les utilisant directement dans les arguments CLI sans avoir à les convertir en extra-vars. Pour suivre ces discussions ou participer aux améliorations, vous pouvez consulter les discussions sur GitHub et les notes de version de Semaphore UI :

• Discussion sur les Survey Variables
• Notes de version de Semaphore UI sur les Survey Variables
• https://github.com/semaphoreui/semaphore/issues/1053#issuecomment-1647323315

Ressources et Liens Utiles

• Documentation Officielle de Semaphore UI :
• Installation et Guide Administratif
• Guide de Configuration des Environnements
• Gestion des Variables dans Semaphore UI
• Discussions et Support Communautaire :
• Issue sur les problèmes de variables d’environnement sur GitHub
• Discussion sur l’utilisation des Survey Variables dans CLI

Conclusion

Semaphore UI est un outil puissant pour gérer les pipelines CI/CD avec une flexibilité maximale grâce à son intégration étroite avec Ansible et GitLab. La gestion des certificats SSL et l’utilisation de fichiers comme requirements.yml pour organiser les dépendances Ansible renforcent la sécurité et l’efficacité du déploiement.

En utilisant les bonnes pratiques décrites ci-dessus et les ressources officielles, vous pouvez configurer un environnement CI/CD robuste et sûr, tout en tirant parti des meilleures fonctionnalités de Semaphore UI pour automatiser et optimiser vos processus de développement.