Installation Docker

Démarrage rapide

Pour commencer rapidement avec SquashTM :

1. Installez Docker si ce n'est pas déjà fait sur votre ordinateur.

2. Créez un fichier docker-compose.yml avec ce contenu :

   services:
     squashtm-pg:
       container_name: squashtm-pg
       environment:
         POSTGRES_DB: squashtm
         POSTGRES_USER: squashtm
         POSTGRES_PASSWORD: MustB3Ch4ng3d
       image: postgres:17
       ports:
         - 5432:5432
   
     squashtm:
       container_name: squashtm
       image: squashtest/squash:14.0.0
       depends_on:
         - squashtm-pg
       environment:
         SPRING_PROFILES_ACTIVE: postgresql
         SPRING_DATASOURCE_URL: jdbc:postgresql://squashtm-pg:5432/squashtm
         SPRING_DATASOURCE_USERNAME: squashtm
         SPRING_DATASOURCE_PASSWORD: MustB3Ch4ng3d
       ports:
         - 8090:8080
       volumes:
         - squashtm-logs:/opt/squash-tm/logs
   
   volumes:
     squashtm-logs:
   

3. Exécutez la commande docker compose up.

4. Connectez-vous sur http://localhost:8090/squash en utilisant le login "admin" et le mot de passe "admin".

Configuration

SquashTM est une application Spring Boot qui peut être configurée à l'aide de variables d'environnement comme expliqué ici.

Variables d'environnement

Accès à la base de données

La connexion à la base de données est configurée en fonction de la première variable d'environnement correspondante dans l'ordre de priorité suivant :

1. Variables d'environnement Shell définies dans le conteneur : SPRING_PROFILES_ACTIVE ou SPRING_DATASOURCE_*
2. Variables d'environnement Shell définies dans le conteneur : SQTM_DB_*
3. Fichier de configuration : fichier squash.tm.cfg.properties (situé dans le répertoire config)
4. Paramètres par défaut internes

Variables Spring

Ces paramètres sont décrits ici.

Variables SQTM_DB_*

Notes :

• (none) : la variable est obligatoire et n'a pas de valeur par défaut ;
• (special) : voir ci-dessous ;

Variable SQTM_DB_TYPE

SQTM_DB_TYPE a un impact sur les valeurs par défaut de plusieurs autres variables. La bonne pratique est de la définir explicitement.
Veillez à saisir correctement la valeur souhaitée (par exemple postgresql et non postgres), sinon l'application ne démarrera pas.

Autres variables utiles

Fuseau horaire

Vous pouvez ajuster les paramètres du fuseau horaire de votre conteneur à l'aide de la variable d'environnement TZ.

Par exemple, pour définir votre fuseau horaire à Europe/Paris, ajoutez le paramètre suivant à la commande docker run :

--env TZ=Europe/Paris

Configuration de l'application avec JAVA_TOOL_OPTIONS

La variable d'environnement JAVA_TOOL_OPTIONS est utilisée pour passer des arguments à une application Java, sans modifier le script de démarrage ou la ligne de commande de l'application.

Il y a cependant quelques réserves. Elle ne peut pas encore être utilisée pour configurer le heap size (cela fonctionne bien pour les autres flags de la JVM).
Une autre limitation est qu'elle ne peut pas être complétée mais seulement redéclarée. Le dockerfile définit sa valeur par défaut à -Djava.awt.headless=true, qui est nécessaire parce que SquashTM fonctionne dans un environnement Linux non GUI. Si vous ne devez pas en tenir compte, n'oubliez pas de réintroduire manuellement ce paramètre (sinon vous risquez de rencontrer des problèmes lors de la génération et de l'export de rapports).
Ces inconvénients proviennent d'archaïsmes dans le script de démarrage et seront corrigés dans les prochaines versions.

Exemple pour lancer SquashTM avec le fuseau horaire des Fidji et activer tous les endpoints (points de terminaison) Actuator (à utiliser avec précaution, car cela exposera les paramètres sensibles !) :

export SQTM_OPTS="-Djava.awt.headless=true \
                  -Duser.timezone=Pacific/Fiji \
                  -Dmanagement.endpoints.access.default=unrestricted \
                  -Dmanagement.endpoints.web.exposure.include=*"

docker run --rm -d -p 8090:8080 -e JAVA_TOOL_OPTIONS="$SQTM_OPTS" squashtest/squash:14.0.0

Configuration de l'application avec SPRING_APPLICATION_JSON

Comme expliqué ici, SPRING_APPLICATION_JSON est une variable d'environnement dans Spring Boot qui permet de définir les propriétés de configuration de l'application sous forme de chaîne JSON.

Exemple pour activer la prise en charge du déchargement SSL :

cat << EOF > tmconf.json
{
    "server": {
        "use-forward-headers": true
    }
}
EOF

docker run --rm -d -p 8090:8080 -e SPRING_APPLICATION_JSON="$(jq -c . < tmconf.json)" squashtest/squash:14.0.0

Déploiement de SquashTM

Les sections suivantes montrent comment déployer SquashTM en utilisant un conteneur externe PostgreSQL DB ou MariaDB. Des exemples de fichiers YAML montrent aussi comment déployer cette solution en utilisant Docker Compose ou Kubernetes.

Avec PostgreSQL

La base de données est créée par le conteneur de la base de données et est automatiquement peuplée par le conteneur de l'application au premier lancement ou mise à jour si nécessaire lorsqu'une version plus récente de SquashTM est déployée.

Toutes les données de la base de données seront sauvegardées dans le volume local nommé squashtm-db-pg. De ce fait, le conteneur de base de données (appelé squashtm-pg) peut être arrêté et redémarré sans risque de perte de données.

docker network create squashtm-postgresql

docker run -it -d --name='squashtm-pg' \
--network squashtm-postgresql \
-e POSTGRES_USER=squashtm \
-e POSTGRES_PASSWORD=MustB3Ch4ng3d \
-e POSTGRES_DB=squashtm \
-v squashtm-db-pg:/var/lib/postgresql/data \
postgres:17

sleep 10

docker run -it -d --name=squashtm \
--network squashtm-postgresql \
-e SPRING_PROFILES_ACTIVE=postgresql \
-e SPRING_DATASOURCE_USERNAME=squashtm \
-e SPRING_DATASOURCE_PASSWORD=MustB3Ch4ng3d \
-e SPRING_DATASOURCE_URL=jdbc:postgresql://squashtm-pg:5432/squashtm \
-v squashtm-logs:/opt/squash-tm/logs \
# Décommentez ci-dessous si vous souhaitez activer les plugins intégrés.
#-v your/path/start-plugins.cfg:/opt/squash-tm/conf/start-plugins.cfg \
-p 8090:8080 \
squashtest/squash:14.0.0

docker network create squashtm-postgresql

docker run -it -d --name='squashtm-pg' \
--network squashtm-postgresql \
-e POSTGRES_USER=squashtm \
-e POSTGRES_PASSWORD=MustB3Ch4ng3d \
-e POSTGRES_DB=squashtm \
-v squashtm-db-pg:/var/lib/postgresql/data \
postgres:17

sleep 10

docker run -it -d --name=squashtm \
--network squashtm-postgresql \
-e SQTM_DB_TYPE=postgresql \
-e SQTM_DB_USERNAME=squashtm \
-e SQTM_DB_PASSWORD=MustB3Ch4ng3d \
-e SQTM_DB_NAME=squashtm \
-e SQTM_DB_HOST=squashtm-pg \
-v squashtm-logs:/opt/squash-tm/logs \
# Décommentez ci-dessous si vous souhaitez activer les plugins intégrés.
#-v your/path/start-plugins.cfg:/opt/squash-tm/conf/start-plugins.cfg \
-p 8090:8080 \
squashtest/squash:14.0.0

Attendez quelques minutes le temps que SquashTM initialise la base de données. Ensuite, connectez-vous à http://localhost:8090/squash (admin / admin).

Si vous disposez de vos propres plugins, ajoutez -v squashtm-plugins:/opt/squash-tm/plugins (voir ici).

Avec MariaDB

La base de données est créée par le conteneur de la base de données et est automatiquement peuplée par le conteneur de l'application au premier lancement ou mise à jour si nécessaire lorsqu'une version plus récente de SquashTM est déployée.

Toutes les données de la base de données seront sauvegardées dans le volume local nommé squashtm-db-mdb. De ce fait, le conteneur de base de données (appelé squashtm-mdb) peut être arrêté et redémarré sans risque de perte de données.

docker network create squashtm-mariadb

docker run -it -d --name='squashtm-mdb' \
--network squashtm-mariadb \
-e MARIADB_ROOT_PASSWORD=MustB3Ch4ng3d \
-e MARIADB_USER=squashtm \
-e MARIADB_PASSWORD=MustB3Ch4ng3d \
-e MARIADB_DATABASE=squashtm \
-v squashtm-db-mdb:/var/lib/mysql \
mariadb:10.7 --character-set-server=utf8mb4 --collation-server=utf8mb4_unicode_ci

sleep 10

docker run -it -d --name=squashtm \
--network squashtm-mariadb \
-e SPRING_PROFILES_ACTIVE=mariadb \
-e SPRING_DATASOURCE_USERNAME=squashtm \
-e SPRING_DATASOURCE_PASSWORD=MustB3Ch4ng3d \
-e SPRING_DATASOURCE_URL=jdbc:mariadb://squashtm-mdb:3306/squashtm \
-v squashtm-logs:/opt/squash-tm/logs \
# Décommentez ci-dessous si vous souhaitez activer les plugins intégrés.
#-v your/path/start-plugins.cfg:/opt/squash-tm/conf/start-plugins.cfg \
-p 8090:8080 \
squashtest/squash:14.0.0

docker network create squashtm-mariadb

docker run -it -d --name='squashtm-mdb' \
--network squashtm-mariadb \
-e MARIADB_ROOT_PASSWORD=MustB3Ch4ng3d \
-e MARIADB_USER=squashtm \
-e MARIADB_PASSWORD=MustB3Ch4ng3d \
-e MARIADB_DATABASE=squashtm \
-v squashtm-db-mdb:/var/lib/mysql \
mariadb:10.7 --character-set-server=utf8mb4 --collation-server=utf8mb4_unicode_ci

sleep 10

docker run -it -d --name=squashtm \
--network squashtm-mariadb \
-e SQTM_DB_TYPE=mariadb \
-e SQTM_DB_USERNAME=squashtm \
-e SQTM_DB_PASSWORD=MustB3Ch4ng3d \
-e SQTM_DB_NAME=squashtm \
-e SQTM_DB_HOST=squashtm-mdb \
-v squashtm-logs:/opt/squash-tm/logs \
# Décommentez ci-dessous si vous souhaitez activer les plugins intégrés.
#-v your/path/start-plugins.cfg:/opt/squash-tm/conf/start-plugins.cfg \
-p 8090:8080 \
squashtest/squash:14.0.0

Attendez quelques minutes le temps que SquashTM initialise la base de données. Ensuite, connectez-vous à http://localhost:8090/squash (admin / admin).

Si vous disposez de vos propres plugins, ajoutez -v squashtm-plugins:/opt/squash-tm/plugins (voir ici).

Docker Compose

Fichier docker-compose.yml

L'exemple suivant de docker-compose.yml lie SquashTM à une base de données MariaDB. Les variables d'environnement doivent être définies dans un fichier .env (enregistré dans le même dépôt que le fichier docker-compose.yml).

services:
  squashtm-md:
    image: mariadb:10.7
    environment:
      MARIADB_ROOT_PASSWORD: ${DB_PASSWORD}
      MARIADB_USER: ${DB_USER}
      MARIADB_PASSWORD: ${DB_PASSWORD}
      MARIADB_DATABASE: ${DB_DATABASE}
    ports:
      - 3306:3306
    volumes:
      - "./init.sql:/docker-entrypoint-initdb.d/init.sql"
    # Décommentez ci-dessous pour avoir des données persistantes
    #   - "/chemin/local/de/vos/data:/var/lib/mysql"

  squashtm:
    image: squashtest/squash:14.0.0
    depends_on:
      - squashtm-md
    environment:
      SPRING_PROFILES_ACTIVE: mariadb
      SPRING_DATASOURCE_URL: jdbc:mariadb://squashtm-md:3306/${DB_DATABASE}
      SPRING_DATASOURCE_USERNAME: ${DB_USER}
      SPRING_DATASOURCE_PASSWORD: ${DB_PASSWORD}
    ports:
      - 8090:8080
    volumes:
      - squashtm-logs:/opt/squash-tm/logs
      # Décommentez ci-dessous si vous souhaitez activer les plugins intégrés.
      #- your/path/start-plugins.cfg:/opt/squash-tm/conf/start-plugins.cfg 

volumes:
  squashtm-logs:

services:
  squashtm-md:
    image: mariadb:10.7
    environment:
      MARIADB_ROOT_PASSWORD: ${DB_PASSWORD}
      MARIADB_USER: ${DB_USER}
      MARIADB_PASSWORD: ${DB_PASSWORD}
      MARIADB_DATABASE: ${DB_DATABASE}
    ports:
      - 3306:3306
    volumes:
      - "./init.sql:/docker-entrypoint-initdb.d/init.sql"
    # Décommentez ci-dessous pour avoir des données persistantes
    #   - "/chemin/local/de/vos/data:/var/lib/mysql"

  squashtm:
    image: squashtest/squash:14.0.0
    depends_on:
      - squashtm-md
    environment:
      SQTM_DB_TYPE: mariadb
      SQTM_DB_USERNAME: ${DB_USER}
      SQTM_DB_PASSWORD: ${DB_PASSWORD}
      SQTM_DB_NAME: ${DB_DATABASE}
      SQTM_DB_HOST: squashtm-md
      SQTM_DB_PORT: "3306"
    ports:
      - 8090:8080
    volumes:
      - squashtm-logs:/opt/squash-tm/logs
      # Décommentez ci-dessous si vous souhaitez activer les plugins intégrés.
      #- your/path/start-plugins.cfg:/opt/squash-tm/conf/start-plugins.cfg 

volumes:
  squashtm-logs:

Fichier .env

DB_USER=squashtm
DB_PASSWORD=MustB3Ch4ng3d
DB_DATABASE=squashtm

Fichier init.sql

Le fichier init.sql doit être placé à la racine du projet lors de l'utilisation d'une base de données MariaDB. Ce script permet d'attribuer les privilèges et rôles nécessaires à l'utilisateur squashtm :

GRANT USAGE ON squashtm.* TO 'squashtm'@'%' WITH GRANT OPTION;
GRANT ALL ON squashtm.* TO 'squashtm'@'%';
CREATE ROLE alter_squash_table_seq;
GRANT alter_squash_table_seq TO 'squashtm'@'%';
SET DEFAULT ROLE alter_squash_table_seq FOR 'squashtm'@'%';
FLUSH PRIVILEGES;

Si vous disposez de vos propres plugins, ajoutez dans les volumes : squashtm-plugins:/opt/squash-tm/plugins (voir ici).

Exécuter Docker Compose

1. Copiez le docker-compose.yml qui correspond à votre besoin.
   Vous trouverez plusieurs répertoires docker-compose sur notre GitLab :

   • Déploiement de SquashTM avec une base de données MariaDB
   • Déploiement de SquashTM avec une base de données PostgreSQL
   • Déploiement de SquashTM avec une base de données PostgreSQL et un Reverse-Proxy
   • Déploiement de SquashTM avec une base de données MariaDB et un Reverse-Proxy

2. N'oubliez pas de créer un fichier .env (ou de définir la valeur des variables d'environnement directement dans le fichier docker-compose.yml) ;

3. Dans le répertoire de docker-compose.yml, exécutez docker compose up ou docker compose up -d pour le mode daemon ;

4. Connectez-vous à http://localhost:8090/squash ou http://{host_ip}:8090/squash.

Pour plus d'information au sujet de Docker Compose, voir la documentation.

Installation de la licence SquashTM

Les instructions pour l'installation de la licence et des plugins SquashTM sont disponibles ici.

Utilisation du conteneur SquashTM avec un reverse proxy

Deux exemples de docker-compose.yml permettant de déployer SquashTM derrière un reverse proxy sont disponibles sur notre GitLab :

• Déploiement de SquashTM avec une base de données PostgreSQL et un Reverse-Proxy
• Déploiement de SquashTM avec une base de données MariaDB et un Reverse-Proxy

Ces solutions utilisent une image docker de jwilder basée sur nginx-proxy.

Voici un exemple de SquashTM déployé derrière un reverse-proxy en utilisant une base de données PostgreSQL :

services:
  squashtm-pg:
    container_name: squashtm-pg
    environment:
      POSTGRES_DB: ${DB_DATABASE}
      POSTGRES_PASSWORD: ${DB_PASSWORD}
      POSTGRES_USER: ${DB_USER}
    image: postgres:17
    ports:
      - 5432:5432
    # Décommentez ci-dessous pour avoir des données persistantes
    # volumes:
    #   - "/chemin/local/de/vos/data:/var/lib/postgresql/data"
    networks:
      - db-network

  squashtm:
    depends_on:
      - squashtm-pg
    environment:
      SQTM_DB_TYPE: postgresql
      SQTM_DB_USERNAME: ${DB_USER}
      SQTM_DB_PASSWORD: ${DB_PASSWORD}
      SQTM_DB_NAME: ${DB_DATABASE}
      VIRTUAL_HOST: mysquash.example.com
      SQTM_DB_PORT: "5432"
      SQTM_DB_HOST: squashtm-pg
    ports:
      - 8090:8080
    image: squashtest/squash:14.0.0
    volumes:
      - squashtm-logs:/opt/squash-tm/logs
      # Décommentez ci-dessous si vous souhaitez activer les plugins intégrés.
      #- your/path/start-plugins.cfg:/opt/squash-tm/conf/start-plugins.cfg
    networks:
      - nginx-proxy
      - db-network

  nginx-proxy:
    container_name: nginx
    image: jwilder/nginx-proxy
    ports:
      - "80:80"
      - "443:443"
    volumes:
      - /var/run/docker.sock:/tmp/docker.sock:ro
    networks:
      - nginx-proxy

volumes:
  squashtm-logs:

networks:
  nginx-proxy:
  db-network:

Et le fichier .env :

DB_USER=squashtm
DB_PASSWORD=MustB3Ch4ng3d
DB_DATABASE=squashtm

Si vous disposez de vos propres plugins, ajoutez dans les volumes : squashtm-plugins:/opt/squash-tm/plugins (voir ici).

Kubernetes

Le manifeste Kubernetes exemple de SquashTM se trouve ici.

Pour cette installation rapide, un cluster Kubernetes ou Minikube est nécessaire.

1. Premium uniquement : Créer un secret à partir du fichier de licence :

   kubectl create secret generic squashtm-prod-license --from-file=licensefile=./squash-tm.lic
   

2. Facultatif : Activer les plugins intégrés et configurer SquashTM grâce à des configMaps :

   À l'aide de la documentation, modifier le fichier start-plugins.cfg et squash.tm.cfg.properties:

   • Le fichier d'activation des plugins start-plugins.cfg est défini ici et le lien vers la documentation ici.
   • Le fichier de configuration squash.tm.cfg.properties est défini ici.

   Créer les configMaps :

   kubectl create configmap config-squash-tm --from-file=./squash.tm.cfg.properties
   kubectl create configmap config-plugin-tm --from-file=./start-plugins.cfg
   

3. Exécuter le déploiement :

   Dépendamment des étapes 1 ou 2, dans le fichier exemple, décommenter les lignes correspondantes dans le manifeste K8S de SquashTM.

   kubectl apply -f ./squash-mariadb.yaml # ou postgresql
   

4. Accéder à SquashTM :

   KubernetesMinikube

   Récupérer l'IP du service avec la commande ci-dessous.

   kubectl get svc 
   

   Récupérer l'External IP.
   L'adresse de SquashTM est alors http://<EXTERNAL-IP>:8080/squash.

   sudo minikube tunnel # Nécessaire pour accéder au loadbalancer
   

   L'adresse de SquashTM est alors http://localhost:8080/squash.

Utilisation des plugins intégrés

L'image SquashTM, version 6.0.0 et ultérieure, intègre tous les plugins officiels de SquashTM.
Comme l'image vise à être prête pour Kubernetes, il n'est plus nécessaire de télécharger et de monter un volume avec les plugins en tant que fichiers JAR.
Cela est remplacé par un configmap à attacher dans le répertoire conf.

Afin d'activer un plugin, l'utilisateur doit remplacer le fichier de configuration dans le chemin spécifié /opt/squash-tm/conf/start-plugins.cfg.
Le fichier se situe ici ou bien dans l'image au chemin spécifié.

Pour attacher et surcharger le fichier existant dans l'image :

• Dans Docker, utiliser le volume : -v $(pwd)/conf/start-plugins.cfg:/opt/squash-tm/conf/start-plugins.cfg

• Dans Kubernetes, utiliser une configmap :

  volumeMounts:
  - name: plugins-config
    mountPath: /opt/squash-tm/conf/start-plugins.cfg
    subPath: start-plugins.cfg
  

Pour activer un plugin il suffit de décommenter la ligne. Exemple : |# apt-rest ---> |api-rest (où | représente le bord gauche du fichier).

Voici une liste complète des plugins intégrés disponibles pour chaque licence, qui peuvent être activés lors du déploiement de SquashTM via une image Docker. Pour activer des plugins spécifiques, il suffit de mapper le fichier comme suit : path/to/your/file/start-plugins.cfg:/opt/squash-tm/conf/start-plugins.cfg. Commenter les plugins qui ne doivent pas être installés.

Bien que la licence Ultimate permette l'utilisation des plugins Community, il n'est pas possible d'utiliser les deux types d'un même plugin en même temps.

La liste exhaustive des plugins avec leurs descriptions est disponible ici et leurs versions téléchargeables ici.
Une fois qu'un plugin a été activé, il ne peut être supprimé que manuellement.

#### Autom-DevOps ####
scm-git

#### Bugtracker ####
bugzilla
gitlab

#### Sync ####
xsquash4gitlab

#### API ####
api-rest-admin

#### Autom-DevOps ####
scm-git

#### Bugtracker ####
azure-devops
bugzilla
gitlab
jiracloud
jiradatacenter
redmine
tuleap

#### Premium ####
squash-tm-premium

#### Report ####
campaign-execution

#### Security ####
ad
ldap
saml
openid-connect

#### Sync ####
redmine-requirements
xsquash4gitlab

#### Wizard ####
campaignassistant

#### API ####
api-rest-admin

#### Autom-DevOps ####
scm-git

#### Autom JIRA ####
workflow-automjira

#### Bugtracker ####
azure-devops
bugzilla
gitlab
jiracloud
jiradatacenter
redmine
tuleap

#### Premium ####
squash-tm-premium

#### Report ####
campaign-execution

#### Security ####
ad
ldap
saml
openid-connect

#### Sync ####
redmine-requirements
xsquash4gitlab

#### Wizard ####
campaignassistant

Importer un certificat

1. Récupérer le certificat et l'enregistrer dans un sous-répertoire certs.

2. Dans ce sous-répertoire certs, créer un fichier de script import-certs.sh avec le contenu suivant :

   #!/bin/sh
   set -e
   
   CERT_DIR="/tmp/certs"
   CACERTS_PATH=$(find /opt/java /usr/lib/jvm -name cacerts 2>/dev/null | head -n 1)
   
   if [ -z "$CACERTS_PATH" ]; then
       echo "ERROR: cacerts not found"
       exit 0
   fi
   
   echo "===== Importing SSL certificates ====="
   echo "Using cacerts: $CACERTS_PATH"
   
   for cert in "$CERT_DIR"/*.crt "$CERT_DIR"/*.cer "$CERT_DIR"/*.pem; do
       [ -f "$cert" ] || continue
   
       ALIAS=$(basename "$cert" | sed 's/\.[^.]*$//')
   
       # Check if the certificate already exists
       if keytool -list -keystore "$CACERTS_PATH" -storepass changeit -alias "$ALIAS" >/dev/null 2>&1; then
           echo "✓ Certificate $ALIAS already exists, skipped"
           continue
       fi
   
       # Import the certificate
       echo "→ Importing certificate: $ALIAS"
       if keytool -import -trustcacerts \
           -alias "$ALIAS" \
           -file "$cert" \
           -keystore "$CACERTS_PATH" \
           -storepass changeit \
           -noprompt; then
           echo "✓ Certificate $ALIAS imported successfully"
       else
           echo "✗ Failed to import $ALIAS, continuing..."
       fi
   done
   
   echo "===== Certificate import completed ====="
   

   Rendre ce fichier exécutable.

3. Modifier le fichier docker-compose.yml en y ajoutant :

   • un montage bind : ./certs:/tmp/certs:ro
   • un point d'entrée : ["/bin/sh", "-c", "[ -f /tmp/certs/import-certs.sh ] && /tmp/certs/import-certs.sh ; /sbin/tini -- /bin/sh -c /opt/install-script.sh"]

   Par exemple :

   services:
     squashtm-pg:
       container_name: squashtm-pg
       environment:
         POSTGRES_DB: squashtm
         POSTGRES_USER: squashtm
         POSTGRES_PASSWORD: MustB3Ch4ng3d
       image: postgres:17
       ports:
         - 5432:5432
   
     squashtm:
       container_name: squashtm
       image: squashtest/squash:14.0.0
       entrypoint: ["/bin/sh", "-c", "[ -f /tmp/certs/import-certs.sh ] && /tmp/certs/import-certs.sh ; /sbin/tini -- /bin/sh -c /opt/install-script.sh"]
       depends_on:
         - squashtm-pg
       environment:
         SPRING_PROFILES_ACTIVE: postgresql
         SPRING_DATASOURCE_URL: jdbc:postgresql://squashtm-pg:5432/squashtm
         SPRING_DATASOURCE_USERNAME: squashtm
         SPRING_DATASOURCE_PASSWORD: MustB3Ch4ng3d
       ports:
         - 8090:8080
       volumes:
         - squashtm-logs:/opt/squash-tm/logs
         - ./certs:/tmp/certs:ro
   
   volumes:
     squashtm-logs:
   

Sauvegarde des données avec des volumes persistants

Les volumes suivants doivent être montés pour que les données correspondantes soient conservées :

• base de données

  /var/lib/postgresql/data     # Data location for PostgreSQL
  /var/lib/mysql               # Data location for MariaDB
  

• fichiers de log

  /opt/squash-tm/logs
  

• file d'attente des imports Xray

  /opt/squash-tm/imports
  

Pour plus d'informations, consultez la section Managing data in containers dans la documentation Docker.

Annexes

Variables d'environnement des bases de données

Étant donné que nous utilisons souvent des images de conteneurs de base de données existants, nous mettons ici en évidence une sélection de variables d'environnement pertinentes pour plus de commodité, ainsi que des liens menant à leur documentation.

Variables d'environnement de l'image PostgreSQL

POSTGRES_PASSWORD

Cette variable d'environnement définit le mot de passe du superutilisateur pour PostgreSQL. Le superutilisateur par défaut est défini par la variable d'environnement POSTGRES_USER.

POSTGRES_USER

Cette variable d'environnement optionnelle est utilisée en conjonction avec POSTGRES_PASSWORD pour définir un utilisateur et son mot de passe.
Cette variable créera l'utilisateur spécifié avec le pouvoir de super-utilisateur et une base de données avec le même nom. Si elle n'est pas spécifiée, l'utilisateur par défaut postgres sera utilisé.

POSTGRES_DB

Cette variable d'environnement optionnelle peut être utilisée pour définir un nom différent pour la base de données par défaut créée lors de la première exécution. Si elle n'est pas spécifiée, la valeur de POSTGRES_USER sera utilisée.

Pour plus d'informations et de variables d'environnement optionnelles, consultez la documentation de l'image PostgreSQL.

Variables d'environnement de l'image MariaDB

MARIADB_ROOT_PASSWORD

Cette variable est obligatoire et spécifie le mot de passe qui sera défini pour le compte superutilisateur root de MariaDB.

MARIADB_DATABASE

Cette variable est facultative et vous permet de spécifier le nom d'une base de données à créer au démarrage de l'image. Si un utilisateur et un mot de passe ont été fournis, cet utilisateur se verra accorder l'accès superutilisateur correspondant à GRANT ALL sur cette base de données.

MARIADB_USER, MARIADB_PASSWORD

Ces variables sont optionnelles, utilisées conjointement pour créer un nouvel utilisateur et définir son mot de passe. Cet utilisateur se verra accorder les permissions de superutilisateur (voir ci-dessus) pour la base de données spécifiée par la variable MARIADB_DATABASE. Ces deux variables sont nécessaires pour créer un utilisateur.

Notez qu'il n'est pas nécessaire d'utiliser ce mécanisme pour créer le superutilisateur root, cet utilisateur est créé par défaut avec le mot de passe spécifié par la variable MARIADB_ROOT_PASSWORD.

Pour plus d'informations et pour connaître les variables d'environnement optionnelles, consultez la documentation de l'image MariaDB.

UID et GID

À partir de Squash TM 6.1.0, le processus principal s'exécutera en tant que uid=1000 et gid=1000 (connu sous le nom de squashtm:squashtm à l'intérieur du conteneur). Depuis Squash TM 1.21.4, le processus s'exécutait en tant que uid=100 et gid=101, et avant cela en tant que root.

Dans le cadre d'un déploiement utilisant Kubernetes, si vous utilisez un Security Context, les valeurs suivantes doivent être entrées :

securityContext:
    runAsUser: 1000
    runAsGroup: 1000
    fsGroup: 1000

Références

• Dépôt GitLab des sources docker de SquashTM
• Documentation de l'image PostgreSQL
• Documentation de l'image MariaDB
• Documentation de jwilder/nginx-proxy