maxime/Procedure-Systel
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Add configuration guides for Crimson Tactics client and RabbitMQ deployment

Browse Source
This commit is contained in:
Maxime BOURIEAU
2026-10-22 09:49:55 +02:00
parent c891a84be4
commit a70364e947
2 changed files with 210 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files
Docker/CRIMSON/Configuration d'un nouveau client Crimson Tactics.md
+85
View File
@@ -0,0 +1,85 @@
# Configuration d'un nouveau client Crimson Tactics
## Vue d'ensemble
### Côté Crimson Tactics
L'application Crimson Tactics communique avec une passerelle hébergée dans le cloud. Cette passerelle se connecte à un serveur RabbitMQ afin de consommer les messages envoyés par le SGO, qu'il s'agisse de Nexsis ou de Systel.
### Côté Systel
Un serveur RabbitMQ est déployé dans notre datacenter. Il est accessible à l'adresse `saas-crimson.systel-dc.com`, sur le port `5671`.
L'interface d'administration est accessible à l'adresse suivante : <https://saas-crimson.systel-dc.com:8443/rabbitmq/>. La connexion nécessite le compte administrateur.
Un simulateur Crimson Tactics est temporairement mis à la disposition des clients. Il leur permet de tester l'interface Crimson Tactics en attendant son déploiement sur leur propre plateforme. Le simulateur est accessible à l'adresse suivante : <https://saas-crimson.systel-dc.com/>.
StartServer transmet au broker RabbitMQ, sous forme de messages AMQP, les interventions pour lesquelles une SITAC a été créée.
## Configuration de RabbitMQ
Pour chaque client, créer un virtual host et deux utilisateurs associés : un utilisateur Systel et un utilisateur Crimson.
Connectez-vous à l'interface d'administration RabbitMQ avec le compte administrateur : <https://saas-crimson.systel-dc.com:8443/rabbitmq/>.
### Création du virtual host
1. Dans le menu situé à droite de l'écran, sélectionnez **Virtual Hosts**.
2. Cliquez sur **Add a new virtual host**.
3. Saisissez un nom et une description (par exemple, `sdis123` et `Virtual host pour SDIS 123`).
4. Cliquez sur **Add virtual host**.
### Création de l'utilisateur Systel
1. Dans le menu situé à droite de l'écran, sélectionnez **Users**.
2. Cliquez sur **Add a user**.
3. Définissez un nom d'utilisateur et un mot de passe (par exemple, `start_sdis123`).
4. Cliquez sur **Add user**.
5. Cliquez sur le nom de l'utilisateur nouvellement créé.
6. Dans la section **Set permission**, sélectionnez le virtual host créé précédemment dans la liste **Virtual Host**.
7. Cliquez sur **Set permission**.
8. Enregistrez les identifiants dans le gestionnaire de mots de passe de Systel.
### Création de l'utilisateur Crimson
1. Cliquez sur **Add a user**.
2. Définissez un nom d'utilisateur et un mot de passe (par exemple, `crimson_sdis123`).
3. Cliquez sur **Add user**.
4. Cliquez sur le nom de l'utilisateur nouvellement créé.
5. Dans la section **Set permission**, sélectionnez le virtual host créé précédemment dans la liste **Virtual Host**.
6. Cliquez sur **Set permission**.
7. Enregistrez les identifiants dans le gestionnaire de mots de passe de Systel.
## Configuration de StartServer
Configurez StartServer pour qu'il puisse accéder au serveur RabbitMQ déployé dans notre datacenter.
### Paramètres de connexion à RabbitMQ
La configuration s'effectue dans la table `PARAMETRES_CTA_COMPLEMENTAIRES` avec les paramètres suivants :
| Clé | Description |
| --- | --- |
| `crimson.amqp.host` | Adresse du serveur AMQP (par exemple, `saas-crimson.systel-dc.com`). |
| `crimson.amqp.port` | Port du serveur AMQP (par défaut : `5671` pour AMQPS). |
| `crimson.amqp.virtual_host` | Virtual host du serveur AMQP (par exemple, `sdis123`). |
| `crimson.amqp.username` | Nom d'utilisateur du serveur AMQP (par exemple, `start_sdis123`). |
| `crimson.amqp.password` | Mot de passe du serveur AMQP, chiffré à l'aide de l'utilitaire disponible dans PoluxEye. |
| `crimson.amqp.queue_name` | Nom de la file AMQP (par défaut : `systel`). |
### Ajout du plugin CrimsonPlugin
Ajoutez le plugin `CrimsonPlugin` au fichier `plugin.properties` de StartServer avec la ligne suivante :
```properties
############## (A64) CRIMSON TACTICS ###############
crimson.plugin=com.systel.polux.plugin.business.crimson.CrimsonPlugin
```
## Ouverture du flux AMQP
Ouvrez le flux réseau nécessaire à la connexion entre StartServer et RabbitMQ :
| Source | Destination | Protocole | Port | Description |
| --- | --- | --- | --- | --- |
| Serveur StartServer | `saas-crimson.systel-dc.com` | TCP | `5671` | Connexion AMQP pour Crimson Tactics |
Docker/CRIMSON/Déploiement de SGO Crimson Stack.md
+210
View File
@@ -0,0 +1,210 @@
# Guide de déploiement — SGO Crimson Stack
## Vue d'ensemble
Cette stack déploie les services suivants :
| Service | Rôle |
| --- | --- |
| `rabbitmq` | Broker de messages AMQP et interface d'administration |
| `cts-backend` | Backend du simulateur Crimson Tactics (Spring) |
| `cts-frontend` | Frontend du simulateur Crimson Tactics (Angular) |
Le routage est assuré par une instance de Traefik 3 déjà déployée dans le Swarm.
## Prérequis
- Docker Swarm doit être initialisé et opérationnel.
- Traefik doit être déployé avec les points d'entrée `https` (443) et `admin` (8443).
## Étape 1 — Créer les répertoires de données et de journaux RabbitMQ
RabbitMQ nécessite un stockage persistant pour ses données et ses journaux. Créez les répertoires suivants sur chaque nœud du Swarm ou sur un stockage partagé, si disponible :
```bash
sudo mkdir -p /mnt/data/crimson/{rabbitmq-data,rabbitmq-logs,rabbitmq-ssl}
```
## Étape 2 — Créer la configuration RabbitMQ du Swarm
La configuration complémentaire de RabbitMQ est stockée dans un objet de configuration Swarm. Cela évite d'intégrer directement ces paramètres dans le fichier de stack.
Exécutez les commandes suivantes sur un manager Swarm :
```bash
cat > /tmp/crimson-rabbitmq.conf <<EOF
# Configuration du plugin d'administration
management.path_prefix = /rabbitmq
# Configuration du listener AMQPS
listeners.ssl.default = 5671
ssl_options.certfile = /etc/rabbitmq/ssl/cert.pem
ssl_options.keyfile = /etc/rabbitmq/ssl/key.pem
ssl_options.verify = verify_none
ssl_options.fail_if_no_peer_cert = false
EOF
docker config create crimson_rabbitmq_management /tmp/crimson-rabbitmq.conf
rm /tmp/crimson-rabbitmq.conf
```
Vérifiez que la configuration a bien été créée :
```bash
docker config ls
# L'objet crimson_rabbitmq_management doit apparaître dans la liste
```
## Étape 3 — Préparer le certificat TLS et sa clé privée
Le listener AMQPS de RabbitMQ nécessite un certificat et une clé privée. Placez-les sur le stockage partagé : ils seront montés en lecture seule dans le conteneur, dans `/etc/rabbitmq/ssl/`.
**Remarque :** si vous disposez déjà d'un certificat valide, délivré par une autorité de certification de confiance pour cet hôte, passez directement à l'étape suivante.
### Générer un certificat auto-signé (validité de 10 ans)
Exécutez les commandes suivantes sur chaque nœud ou une seule fois si vous utilisez un stockage partagé :
```bash
DNS="saas-crimson.localhost"
sudo openssl req -x509 -newkey rsa:4096 -sha256 \
-days 3650 \
-nodes \
-keyout /mnt/data/crimson/rabbitmq-ssl/key.pem \
-out /mnt/data/crimson/rabbitmq-ssl/cert.pem \
-subj "/CN=${DNS}" \
-addext "subjectAltName=DNS:${DNS},IP:127.0.0.1"
```
Si nécessaire, adaptez les valeurs de `CN` et de `subjectAltName` au nom d'hôte ou à l'adresse IP utilisés.
### Définir le propriétaire et les permissions
```bash
# RabbitMQ s'exécute avec l'UID 100 et le GID 101 dans le conteneur
sudo chown 100:101 /mnt/data/crimson/rabbitmq-ssl/cert.pem
sudo chown 100:101 /mnt/data/crimson/rabbitmq-ssl/key.pem
sudo chmod 440 /mnt/data/crimson/rabbitmq-ssl/cert.pem
sudo chmod 400 /mnt/data/crimson/rabbitmq-ssl/key.pem
```
## Étape 4 — Créer les identifiants RabbitMQ
Les identifiants RabbitMQ sont transmis au conteneur sous la forme d'un secret Swarm, monté dans `/etc/rabbitmq/conf.d/credentials.conf`.
Créez un fichier temporaire local, puis supprimez-le après avoir créé le secret :
```bash
cat > /tmp/crimson-rabbitmq-credentials.conf <<EOF
default_user = admin
default_pass = ChangeMe!
EOF
vim /tmp/crimson-rabbitmq-credentials.conf # Modifiez le fichier pour définir les identifiants souhaités
docker secret create crimson_rabbitmq_credentials /tmp/crimson-rabbitmq-credentials.conf
rm /tmp/crimson-rabbitmq-credentials.conf
```
Vérifiez que le secret a bien été créé :
```bash
docker secret ls
# Le secret crimson_rabbitmq_credentials doit apparaître dans la liste
```
## Étape 5 — Créer les identifiants du backend CTS
Le backend CTS doit se connecter à RabbitMQ afin de simuler la consommation des messages comme le ferait Crimson Tactics en production.
Utilisez les identifiants de l'utilisateur Crimson (par exemple, `crimson_sdis123`) et attribuez-lui les permissions nécessaires sur le virtual host RabbitMQ. Consultez la section « Configuration » pour connaître les paramètres requis.
Les identifiants sont transmis sous la forme d'un secret Swarm, monté dans `/run/secrets/cts.properties` à l'intérieur du conteneur. Spring Boot le lit comme un fichier de propriétés grâce à `SPRING_CONFIG_IMPORT`.
Créez un fichier temporaire local, puis supprimez-le après avoir créé le secret :
```bash
cat > /tmp/crimson-cts-credentials.properties <<EOF
spring.rabbitmq.username=crimson_sdis123
spring.rabbitmq.password=ChangeMe!
spring.rabbitmq.virtual-host=sdis123
EOF
vim /tmp/crimson-cts-credentials.properties # Modifiez le fichier pour définir les identifiants et le virtual host souhaités
docker secret create crimson_cts_credentials /tmp/crimson-cts-credentials.properties
rm /tmp/crimson-cts-credentials.properties
```
Vérifiez que le secret a bien été créé :
```bash
docker secret ls
# Le secret crimson_cts_credentials doit apparaître dans la liste
```
## Étape 6 — Déployer la stack avec Portainer
1. Ouvrez Portainer, puis accédez à **Stacks** → **Add stack**.
2. Sélectionnez **Upload** et fournissez les deux fichiers suivants :
- `stack/stack.yml`
- `stack/stack.env` (à utiliser comme fichier d'environnement)
3. Indiquez le nom de la stack (par exemple, `crimson-tactics`).
4. Cliquez sur **Deploy the stack**.
Vous pouvez également effectuer le déploiement depuis l'interface en ligne de commande :
```bash
docker stack deploy \
-c stack/stack.yml \
--env-file stack/stack.env \
crimson-tactics
```
## Étape 7 — Configurer HAProxy
Les instances HAProxy assurent la terminaison TLS du trafic AMQP. Appliquez l'extrait de configuration contenu dans `conf/haproxy.snippet.cfg` sur les deux nœuds HAProxy.
Copiez le contenu de cet extrait dans le fichier de configuration de chaque nœud HAProxy (généralement `/etc/haproxy/haproxy.cfg`).
Remplacez les variables suivantes :
- `${DOMAIN}` par le nom de domaine utilisé, qui doit correspondre au certificat.
- `${IP_RANGE}` par la plage d'adresses IP des managers Swarm (par exemple, `172.17.6`).
Vérifiez la validité de la configuration :
```bash
sudo haproxy -c -f /etc/haproxy/haproxy.cfg
```
Rechargez HAProxy sur les deux nœuds :
```bash
sudo systemctl reload haproxy
```
## Étape 8 — Vérifier le déploiement
Vérifiez que tous les services sont opérationnels :
```bash
docker stack services crimson-tactics
```
Vérifiez l'état de RabbitMQ en consultant ses journaux :
```bash
docker service logs crimson-tactics_rabbitmq --tail 50
```
Les services sont accessibles aux adresses suivantes :
| Service | URL |
| --- | --- |
| Interface d'administration RabbitMQ | `https://${DOMAIN_PREFIX}crimson.${DOMAIN}:8443/rabbitmq/` |
| Frontend CTS | `https://${DOMAIN_PREFIX}crimson.${DOMAIN}/` |
| AMQPS RabbitMQ | `amqps://${DOMAIN_PREFIX}crimson.${DOMAIN}:5671` |