Maxime BOURIEAU
217 lines
7.3 KiB
Markdown
217 lines
7.3 KiB
Markdown
# 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. Ajouter dans DOMAIN sdisXX.fr
|
|
5. Cliquez sur **Deploy the stack**.
|
|
5. Si il y a erreur de déploiement, aller dans l'un des SWARM et exécuté cette commande
|
|
|
|
```bash
|
|
docker network create --driver overlay --attachable admin
|
|
```
|
|
|
|
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` |
|