Guide d'installation
Sécurité
En raison de problèmes de sécurité, il est fortement conseillé d'utiliser Squash TM 2.2.0 (ou 2.X.Y postérieure) ou toute version supérieure ou égale à 3.0.0
Cette page décrit comment installer un à un les composants de Squash AUTOM.
Légende
† indique un composant commun à Squash AUTOM et Squash DEVOPS.
️‡ indique un composant Premium. Une vue d'ensemble des fonctionnalités Premium est disponible ici. Pour en bénéficier ou demander plus d'informations, consulter notre site ou nous contacter.
Diagrammes
Vue d'ensemble des composants de Squash AUTOM et Squash DEVOPS
Interconnexions
Squash Orchestrator†
Installation
L'installation de Squash Orchestrator consiste en le déploiement d'une image Docker. Elle contient l'ensemble des services nécessaires de l'OpenTestFactory Orchestrator et des services spécifiques Squash.
Pour récupérer la dernière version de l'image de Squash Orchestrator, la commande suivante est à exécuter :
docker pull squashtest/squash-orchestrator:4.0.0
Les préconisations pour dimensionner le conteneur Docker sont :
- CPU : 2
- RAM : 5 Go (8 Go recommandé)
- disque : prévoir la capacité de stocker les rapports d’exécution et leurs attachements pour une heure d'utilisation
Dépannage - Accessibilité de l'instance Squash TM
Vérifier que l'instance de Squash TM est accessible depuis Squash Orchestrator. Pour cela se mettre sur l'hôte Docker et exécuter la commande (en remplaçant https://squashtm.example.com/squash
par l'URL de votre instance) :
curl https://squashtm.example.com/squash/isSquashAlive
Squash is Alive!
Usage
Configuration de l'image
La commande suivante permet de démarrer Squash Orchestrator en lui permettant d'utiliser un environnement d'exécution existant, avec auto-génération d'une clé approuvée (ce qui n'est pas recommandé dans un environnement de production, mais elle permet de mettre rapidement en place un orchestrateur pour expérimenter avec).
docker run -d \
--name orchestrator \
-p 7774:7774 \
-p 7775:7775 \
-p 7776:7776 \
-p 38368:38368 \
-p 24368:24368 \
-p 12312:12312 \
-e SSH_CHANNEL_HOST=the_environment_ip_or_hostname \
-e SSH_CHANNEL_USER=user \
-e SSH_CHANNEL_PASSWORD=secret \
-e SSH_CHANNEL_TAGS=ssh,linux,robotframework \
squashtest/squash-orchestrator:4.0.0
docker run -d ^
--name orchestrator ^
-p 7774:7774 ^
-p 7775:7775 ^
-p 7776:7776 ^
-p 38368:38368 ^
-p 24368:24368 ^
-p 12312:12312 ^
-e SSH_CHANNEL_HOST=the_environment_ip_or_hostname ^
-e SSH_CHANNEL_USER=user ^
-e SSH_CHANNEL_PASSWORD=secret ^
-e SSH_CHANNEL_TAGS=ssh,linux,robotframework ^
squashtest/squash-orchestrator:4.0.0
docker run -d `
--name orchestrator `
-p 7774:7774 `
-p 7775:7775 `
-p 7776:7776 `
-p 38368:38368 `
-p 24368:24368 `
-p 12312:12312 `
-e SSH_CHANNEL_HOST=the_environment_ip_or_hostname `
-e SSH_CHANNEL_USER=user `
-e SSH_CHANNEL_PASSWORD=secret `
-e SSH_CHANNEL_TAGS=ssh,linux,robotframework `
squashtest/squash-orchestrator:4.0.0
Cette commande expose les services suivants sur les ports correspondants :
- receptionnist (port 7774)
- observer (port 7775)
- killswitch (port 7776)
- eventbus (port 38368)
- agentchannel (port 24368)
- quality gate (port 12312)
Si vous ne prévoyez pas de déclarer des agents, le port 24368 peut ne pas être exposé. De la même manière, si vous ne prévoyez pas d'utiliser la quality gate, le port 12312 peut ne pas être exposé.
Configuration avec des clefs pré-générées
Hors expérimentation, il est recommandé de démarrer Squash Orchestrator en précisant une ou plusieurs clefs publiques qui seront utilisées pour valider les jetons authentifiant les requêtes entrantes.
Les commandes suivantes permettent de générer une paire de clef trusted_key.pem
/ trusted_key.pub
(vous pouvez en générer plusieurs si vous le souhaitez) :
openssl genrsa -out trusted_key.pem 4096
openssl rsa -pubout -in trusted_key.pem -out trusted_key.pub
Si vos clefs publiques (*.pub
) sont dans un répertoire public_keys
, voici un exemple les rendant accessibles à l'orchestrateur (tous les fichiers dans ce répertoire seront accessibles à l'orchestrateur, n'y placez pas vos clefs privées) :
docker run ... \
-v /path/to/public_keys:/etc/squashtf \
...
docker run ... ^
-v d:\path\to\public_keys:/etc/squashtf ^
...
docker run ... `
-v d:\path\to\public_keys:/etc/squashtf `
...
Si vous ne prévoyez d'utiliser qu'une clef publique, vous pouvez la rendre accessible directement :
docker run ... \
-v /path/to/public_keys/trusted_key.pub:/etc/squashtf/trusted_key.pub \
...
docker run ... ^
-v d:\path\to\public_keys/trusted_key.pub:/etc/squashtf/trusted_key.pub ^
...
docker run ... `
-v d:\path\to\public_keys/trusted_key.pub:/etc/squashtf/trusted_key.pub `
...
Les jetons vérifiés par ces clefs auront un accès complet au namespace default
. Ce comportement peut être modifié en modifiant la configuration de l'image.
Pour les détails sur le déploiement de Squash Orchestrator, vous pouvez vous reporter à la documentation de l'OpenTestFactory qui sert de base au Squash Orchestrator (le déploiement des deux orchestrateurs est similaire). Cette documentation détaille aussi les cas spécifiques d'un déploiement avec docker-compose ou avec Kubernetes.
Utilisation de certificats auto-signés
Une FAQ détaille comment utiliser Squash Orchestrator avec des certificats auto-signés.
Lancement de l'image en mode Premium‡
Dans le cas où
- vous utilisez aussi Squash DEVOPS,
- vous disposez d'une licence Squash DEVOPS Premium et
- par conséquent, vous déployez la version Premium du plugin Squash TM Test Plan Retriever,
alors, vous devez démarrer Squash Orchestrator en mode Premium.
Pour cela, il faut ajouter le paramètre suivant dans la commande de démarrage de Squash Orchestrator : -e SQUASH_LICENCE_TYPE=premium
.
docker run -d \
--name orchestrator \
-p 7774:7774 \
-p 7775:7775 \
-p 7776:7776 \
-p 38368:38368 \
-p 24368:24368 \
-p 12312:12312 \
-e SSH_CHANNEL_HOST=the_environment_ip_or_hostname \
-e SSH_CHANNEL_USER=user \
-e SSH_CHANNEL_PASSWORD=secret \
-e SSH_CHANNEL_TAGS=ssh,linux,robotframework \
-e SQUASH_LICENCE_TYPE=premium \
squashtest/squash-orchestrator:4.0.0
docker run -d ^
--name orchestrator ^
-p 7774:7774 ^
-p 7775:7775 ^
-p 7776:7776 ^
-p 38368:38368 ^
-p 24368:24368 ^
-p 12312:12312 ^
-e SSH_CHANNEL_HOST=the_environment_ip_or_hostname ^
-e SSH_CHANNEL_USER=user ^
-e SSH_CHANNEL_PASSWORD=secret ^
-e SSH_CHANNEL_TAGS=ssh,linux,robotframework ^
-e SQUASH_LICENCE_TYPE=premium ^
squashtest/squash-orchestrator:4.0.0
docker run -d `
--name orchestrator `
-p 7774:7774 `
-p 7775:7775 `
-p 7776:7776 `
-p 38368:38368 `
-p 24368:24368 `
-p 12312:12312 `
-e SSH_CHANNEL_HOST=the_environment_ip_or_hostname `
-e SSH_CHANNEL_USER=user `
-e SSH_CHANNEL_PASSWORD=secret `
-e SSH_CHANNEL_TAGS=ssh,linux,robotframework `
-e SQUASH_LICENCE_TYPE=premium `
squashtest/squash-orchestrator:4.0.0
Sinon, dans le cas où vous déployez la version Community du plugin Squash TM Test Plan Retriever, vous ne devez pas démarrer Squash Orchestrator en mode Premium.
Outils de l'orchestrateur†
Installation
Les outils de l'orchestrateur sont destinés à simplifier l'exploitation de ce dernier. Ils peuvent être installés sur n'importe quelle machine d'où on veut pouvoir administrer l'orchestrateur.
Ils requièrent Python 3.8 ou supérieur. Ils fonctionnent sur un environnement Linux, macOS ou Windows.
Afin d'installer ces outils depuis PyPI, la commande suivante est à exécuter :
pip install --upgrade opentf-tools
Aperçu des capacités des outils
-
opentf-ready
attend que l'orchestrateur soit prêt à accepter les workflows. -
opentf-done
attend que l'orchestrateur puisse être arrêté en toute sécurité (c'est-à-dire qu'il n'a plus de tâches en attente). -
opentf-ctl
peut être utilisé pour- démarrer / suivre / arrêter un workflow
- générer un jeton signé
- lister les agents
- générer / modifier un fichier de configuration
- …
Génération d'un jeton signé
Les requêtes à destination de Squash Orchestrator doivent être associées à des jetons signés.
Étant donné une clef privée trusted_key.pem
dans le répertoire courant, la commande suivante permet de générer un jeton signé qui sera reconnu par l'orchestrateur s'il connaît la clef publique correspondante :
opentf-ctl generate token using trusted_key.pem
Please specify an algorithm (RS512 if unspecified):
The specified algorithm is: RS512
Please enter the issuer (your company or department): acme
Please enter the subject (you or the person you are making this token for): charlie
The signed token is:
ey...
Détails
Une description complète des outils est disponible dans la documentation d'OpenTestFactory.
Services réservés à Squash AUTOM Premium‡
Installation
Afin d'installer l'image Docker des services réservés à Squash AUTOM Premium, vous devez récupérer l'image compressée auprès du service support Squash, puis exécuter la commande suivante :
docker load -i squash-autom-premium-3.8.0.tar.gz
Cette commande va charger dans la registry locale l'image docker.squashtest.org/squashtest/squash-autom-premium:3.8.0
.
Les préconisations pour dimensionner le conteneur Docker sont :
- CPU : 1
- RAM : 2 Go (3 Go recommandé)
- disque : prévoir la capacité de stocker les rapports d’exécution et leurs attachements pour une heure d'utilisation
Usage
Les services réservés à Squash AUTOM Premium viennent en complément de ceux de Squash Orchestrator, ils ne s'y substituent pas.
Il est fortement recommandé d'utiliser docker-compose
ou Kubernetes pour déployer les services réservés au côté de Squash Orchestrator.
Les paramètres de configuration sont les suivants :
Paramètre | Requis ? | Description |
---|---|---|
BUS_HOST |
oui | Adresse IP ou nom DNS du service EventBus du Squash Orchestrator avec qui les micro-services communiquent. |
BUS_PORT |
oui | Port du service EventBus du Squash Orchestrator avec qui les micro-services communiquent. |
BUS_TOKEN |
non | Token JWT accepté par le service EventBus du Squash Orchestrator avec qui les micro-services communiquent. |
EXTERNAL_HOSTNAME |
non | Adresse IP ou nom DNS des micro-services de l'image Docker des services réservés à Squash AUTOM Premium. |
Volume /etc/squashtf |
oui | Volume à monter vers un ensemble de clés publiques acceptées pour la validité de tokens JWT. |
Volume /tmp |
oui | Volume à monter vers un dossier partagé avec Squash Orchestrator qui accueillera temporairement des fichiers générés lors de l'exécution. |
Avec docker-compose
Dans un nouveau dossier, créez un répertoire data
dans lequel vous placerez votre clef publique.
+-- dossier
| +-- .env
| +-- data
| +-- trusted_key.pub
| +-- docker-compose.yml
Créez également un fichier .env
qui centralisera les versions des composants que vous utiliserez :
ORCHESTRATOR_VERSION=4.0.0
PREMIUM_VERSION=3.8.0
TOKEN=ey...
Créez enfin le fichier docker-compose.yml
suivant :
# docker-compose up -d
version: "3.4"
services:
# Squash Orchestrator
orchestrator:
container_name: orchestrator
image: squashtest/squash-orchestrator:$ORCHESTRATOR_VERSION
restart: always
volumes:
- type: bind
source: ./data/trusted_key.pub
target: /etc/squashtf/squash.pub
- shared-tmp:/tmp
environment:
- SQUASH_LICENCE_TYPE=premium
ports:
- "7774:7774"
- "7775:7775"
- "7776:7776"
- "38368:38368"
- "24368:24368"
- "12312:12312"
# Squash autom premium container
squash-autom-premium:
container_name: squash-autom-premium
image: docker.squashtest.org/squashtest/squash-autom-premium:$PREMIUM_VERSION
restart: always
environment:
- BUS_HOST=orchestrator
- BUS_PORT=38368
- EXTERNAL_HOSTNAME=squash-autom-premium
- BUS_TOKEN=$TOKEN
volumes:
- type: bind
source: ./data/trusted_key.pub
target: /etc/squashtf/squash.pub
- shared-tmp:/tmp
ports:
- "10084:10084"
- "10085:10085"
- "10087:10087"
- "20001:20001"
- "20002:20002"
- "20003:20003"
volumes:
shared-tmp:
Pour lancer Squash Orchestrator et les services réservés à Squash AUTOM Premium, placez-vous dans ce dossier et utilisez la commande suivante :
docker compose up -d
Vous pouvez consulter les logs de ce déploiement en utilisant la commande suivante :
docker compose logs
Pour arrêter Squash Orchestrator et les services réservés à Squash AUTOM Premium, placez-vous dans le dossier et utilisez la commande suivante :
docker compose down
Avec Kubernetes
L'exemple suivant déploie un pod contenant Squash Orchestrator et les services réservés à Squash AUTOM Premium.
---
apiVersion: apps/v1
kind: Deployment
metadata:
labels:
app: squash-autom-premium
name: squash-autom-premium
spec:
replicas: 1
selector:
matchLabels:
app: squash-autom-premium
template:
metadata:
labels:
app: squash-autom-premium
spec:
containers:
- name: orchestrator
image: squashtest/squash-orchestrator:4.0.0
imagePullPolicy: Always
env:
- name: SQUASH_LICENCE_TYPE
value: premium
ports:
- containerPort: 7774
protocol: TCP
- containerPort: 7775
protocol: TCP
- containerPort: 7776
protocol: TCP
- containerPort: 38368
protocol: TCP
- containerPort: 24368
protocol: TCP
- containerPort: 12312
protocol: TCP
resources:
limits:
memory: 5G
requests:
cpu: "1"
memory: 5G
volumeMounts:
- mountPath: /tmp/
name: attachment-storage
- mountPath: /etc/squashtf
name: squash-orchestrator-trusted-key
- name: premium
image: docker.squashtest.org/squashtest/squash-autom-premium:3.8.0
imagePullPolicy: IfNotPresent
env:
- name: BUS_HOST
value: localhost
- name: BUS_PORT
value: "38368"
resources:
limits:
memory: 1G
requests:
cpu: 500m
memory: 1G
volumeMounts:
- mountPath: /tmp/
name: attachment-storage
- mountPath: /etc/squashtf
name: squash-orchestrator-trusted-key
imagePullSecrets:
- name: docker-registry
restartPolicy: Always
securityContext: {}
volumes:
- name: attachment-storage
emptyDir: {}
- name: squash-orchestrator-trusted-key
secret:
defaultMode: 420
secretName: trusted-keys
---
apiVersion: v1
kind: Service
metadata:
name: squash-autom-premium
spec:
selector:
app: squash-autom-premium
ports:
- name: receptionist
port: 7774
protocol: TCP
targetPort: 7774
- name: eventbus
port: 38368
protocol: TCP
targetPort: 38368
- name: observer
port: 7775
protocol: TCP
targetPort: 7775
- name: killswitch
port: 7776
protocol: TCP
targetPort: 7776
- name: agentchannel
port: 24368
protocol: TCP
targetPort: 24368
- name: qualitygate
port: 12312
protocol: TCP
targetPort: 12312
Pour déployer ce pod et ce service sur votre cluster Kubernetes, créez un namespace (ou utilisez un namespace déjà existant) :
kubectl create namespace my-namespace
Créez alors un secret contenant votre clef publique, déployez ce secret dans le namespace que vous venez de créer :
kubectl create secret generic trusted-keys --from-file=trusted_key.pub=trusted_key.pub --namespace my-namespace
Déployez enfin le pod et le service :
kubectl apply -f squash-autom-premium.yaml --namespace my-namespace
Pour supprimer le pod, utilisez la commande suivante :
kubectl delete -f squash-autom-premium.yaml --namespace my-namespace
Avec Docker
Rappel
Il est fortement recommandé d'utiliser docker-compose
ou Kubernetes pour déployer les services réservés à Squash AUTOM Premium au côté de Squash Orchestrator.
Les commandes suivantes permettent de déployer Squash Orchestrator et les services réservés à Squash AUTOM Premium, avec auto-génération d'une clef approuvée (ce qui n'est pas recommandé dans un environnement de production, mais cette auto-génération permet de mettre rapidement en place un orchestrateur pour expérimenter avec).
docker network create squash
docker run -d --network squash \
--name orchestrator \
-p 7774:7774 \
-p 7775:7775 \
-p 7776:7776 \
-p 38368:38368 \
-p 24368:24368 \
-p 12312:12312 \
-e SSH_CHANNEL_HOST=the_environment_ip_or_hostname \
-e SSH_CHANNEL_USER=user \
-e SSH_CHANNEL_PASSWORD=secret \
-e SSH_CHANNEL_TAGS=ssh,linux,robotframework \
squashtest/squash-orchestrator:4.0.0
Il faut ensuite déployer les services réservés à Squash AUTOM Premium. Ici, il faut au préalable récupérer le token auto-généré :
docker logs orchestrator 2>&1 \
| grep --after-context=10 "Creating temporary JWT token"
Il ne vous reste plus qu'à stocker ce token dans une variable d'environnement (ici TOKEN
) et à déployer une instance de l'image squash-autom-premium
:
export TOKEN=eyJ...
docker run -d --network squash \
--name premium \
-e BUS_HOST=orchestrator \
-e BUS_PORT=38368 -e BUS_TOKEN=$TOKEN \
-e EXTERNAL_HOSTNAME=premium \
docker.squashtest.org/squashtest/squash-autom-premium:3.8.0
Vous pouvez consulter les logs de ces deux conteneurs :
docker logs orchestrator
docker logs premium
Pour supprimer ces deux conteneurs, utilisez les commandes suivantes :
docker kill orchestrator premium
docker rm orchestrator premium
Agent OpenTestFactory†
Installation
L'agent OpenTestFactory est une application Python à installer sur un environnement d'exécution de tests automatisés. Il requiert Python 3.7 ou supérieur. Il fonctionne sur un environnement Linux, macOS ou Windows.
L'agent se présente comme un simple script. Il possède seulement une dépendance, vers la librairie Python requests
(elle sera installée si elle n'est pas déjà présente sur l'environnement d'exécution).
Afin d'installer l'agent depuis PyPI, la commande suivante est à exécuter :
pip install --upgrade opentf-agent
Vous pouvez vérifier l'installation en exécutant la commande suivante :
opentf-agent --help
Usage
Résumé
$ opentf-agent --help
usage: opentf-agent [-h] --tags TAGS --host HOST [--port PORT] [--path_prefix PATH_PREFIX] [--token TOKEN] [--encoding ENCODING] [--script_path SCRIPT_PATH] [--workspace_dir WORKSPACE_DIR] [--name NAME] [--polling_delay POLLING_DELAY] [--liveness_probe LIVENESS_PROBE] [--retry RETRY] [--debug]
OpenTestFactory Agent
optional arguments:
-h, --help show this help message and exit
--tags TAGS a comma-separated list of tags (e.g. windows,robotframework)
--host HOST target host with protocol (e.g. https://example.local)
--port PORT target port (default to 24368)
--path_prefix PATH_PREFIX
target context path (default to no context path)
--token TOKEN token
--encoding ENCODING encoding on the console side (defaults to utf-8)
--script_path SCRIPT_PATH
where to put temporary files (defaults to current directory)
--workspace_dir WORKSPACE_DIR
where to put workspaces (defaults to current directory)
--name NAME agent name (defaults to "test agent")
--polling_delay POLLING_DELAY
polling delay in seconds (default to 5)
--liveness_probe LIVENESS_PROBE
liveness probe in seconds (default to 300 seconds)
--retry RETRY how many time to try joining host (default to 5,
0 = try forever)
--debug whether to log debug informations.
Exemple
En considérant qu'un Squash Orchestrator est lancé sur orchestrator.example.com
, avec un jeton stocké dans la variable d'environnement TOKEN
, la commande suivante enregistre l'environnement d'exécution Windows et recevra les commandes ciblant windows et/ou robotframework :
chcp 65001
opentf-agent --tags windows,robotframework --host http://orchestrator.example.com/ --token %TOKEN%
L'agent contactera l'orchestrateur toutes les 5 secondes, et exécutera les commandes réceptionnées.
La commande chcp
configure la console en Unicode. Il s'agit d'une spécificité Windows. Cette configuration peut être nécessaire suivant le framework de test disponible sur l'environnement d'exécution.
Détails
Une description complète de l'agent est disponible dans la documentation d'OpenTestFactory.
Environnements d'exécution†
Certaines technologies de test nécessitent que des composants particuliers soient installés dans l'environnement d'exécution, ceux-ci sont indiqués dans les pages décrivant les spécificités de chaque technologie.
Plugins Squash TM
Installation
Pour l’installation des plugins Squash TM, merci de vous reporter au protocole d’installation d’un plugin Squash TM.
Plugin | Version de Squash TM | Version compatible du plugin | Télécharger la dernière version Community | Télécharger la dernière version Premium‡ |
---|---|---|---|---|
Result Publisher† | 2.2.0, ou 2.X.Y postérieure | 2.2.X | 2.2.0 : .tar.gz ou .zip | 2.2.0 : .tar.gz ou .zip |
3.0.0, ou 3.X.Y postérieure | 3.0.X | 3.0.0 : .tar.gz ou .zip | 3.0.0 : .tar.gz ou .zip | |
4.0.0, ou 4.0.X postérieure | 4.0.X | 4.0.0 : .tar.gz ou .zip | 4.0.0 : .tar.gz ou .zip | |
4.1.0, ou 4.X.Y postérieure | 4.1.X | 4.1.0 : .tar.gz ou .zip | 4.1.0 : .tar.gz ou .zip | |
5.0.0, ou 5.X.Y postérieure | 5.0.X | 5.0.0 : .tar.gz ou .zip | 5.0.0 : .tar.gz ou .zip | |
Squash AUTOM | 2.2.0, ou 2.X.Y postérieure | 2.2.X | 2.2.0 : .tar.gz ou .zip | 2.2.0 : .tar.gz ou .zip |
3.0.0, ou 3.X.Y postérieure | 3.0.X | 3.0.0 : .tar.gz ou .zip | 3.0.0 : .tar.gz ou .zip | |
4.0.0, ou 4.0.X postérieure | 4.0.X | 4.0.1 : .tar.gz ou .zip | 4.0.1 : .tar.gz ou .zip | |
4.1.0, ou 4.X.Y postérieure | 4.1.X | 4.1.0 : .tar.gz ou .zip | 4.1.0 : .tar.gz ou .zip | |
5.0.0, ou 5.X.Y postérieure | 5.0.X | 5.0.0 : .tar.gz ou .zip | 5.0.0 : .tar.gz ou .zip | |
Git Connector | 2.2.0, ou 2.X.Y postérieure | 2.1.X | 2.1.0 : .tar.gz ou .zip | pas de version Premium |
3.0.0, ou 3.X.Y postérieure | 3.0.X | 3.0.0 : .tar.gz ou .zip | ||
4.0.0, ou 4.X.Y postérieure | 4.0.X | 4.0.0 : .tar.gz ou .zip | ||
5.0.0, ou 5.X.Y postérieure | 5.0.X | 5.0.0 : .tar.gz ou .zip | ||
Actions Library | 2.2.0, ou 2.X.Y postérieure | 2.0.X | pas de version Community | 2.0.0 : .tar.gz ou .zip |
3.0.0, ou 3.X.Y postérieure | 3.0.X | 3.0.0 : .tar.gz ou .zip | ||
4.0.0, ou 4.X.Y postérieure | 4.0.X | 4.0.0 : .tar.gz ou .zip | ||
5.0.0, ou 5.X.Y postérieure | 5.0.X | 5.0.0 : .tar.gz ou .zip | ||
Workflow Automatisation Jira | 2.2.0, ou 2.X.Y postérieure | 2.0.X | pas de version Community | 2.0.0 : .tar ou .zip |
3.0.0, ou 3.X.Y postérieure | 3.0.X | 3.0.0 : .tar ou .zip | ||
4.0.0, ou 4.X.Y postérieure | 4.0.X | 4.0.0 : .tar ou .zip | ||
5.0.0, ou 5.X.Y postérieure | 5.0.X | 5.0.0 : .tar ou .zip |
Configuration de Squash TM
Attention
Squash AUTOM nécessite que l'URL publique de Squash TM soit définie (voir la documentation de Squash TM).
Déclaration du serveur Squash Orchestrator
Afin de lancer un plan d'exécution manuellement depuis Squash TM, il est nécessaire de déclarer le Squash Orchestrator qui exécutera les tests automatisés dans les environnements adaptés.
Cette déclaration se fait dans la section Serveurs d'exécution automatisée de l'espace Administration :
-
Nom
: Le nom du serveur tel qu'il apparaîtra dans l'espace Cas de test. -
Type
: Sélectionnez squashAutom dans la liste déroulante. -
Url
: L'adresse du Receptionist de Squash Orchestrator.
L'URL du Receptionist URL est affichée sur la page du serveur :
Attention
L'Observer de Squash Orchestrator doit impérativement être accessible à la même URL que le Receptionist.
L'Event Bus de Squash Orchestrator doit impérativement être accessible à la même URL que le Receptionist mais sur le port 38368.
A partir de Squash TM 4.0, dans le cas où les URLs du Receptionist et de l'Observer sont différentes (par exemple si le Squash Orchestrator n'est pas situé derrière un reverse-proxy), il est possible de déclarer les deux :
Attention
L'Event Bus de Squash Orchestrator doit impérativement être accessible à la même URL que le Receptionist mais sur le port 38368.
A partir de Squash TM 5.0, dans le cas où les URLs du Receptionist, de l'Observer ou de l'Event Bus sont différentes (par exemple si le Squash Orchestrator n'est pas situé derrière un reverse-proxy), il est possible de déclarer les trois :
Une fois le serveur créé, vous devez préciser un token servant pour l'authentification au serveur.
Dépannage - Accessibilité du Squash Orchestrator
Il est possible de vérifier que la connexion au Squash Orchestrator (depuis le serveur hébergeant Squash TM) fonctionne correctement en l'interrogeant, par exemple en demandant la liste des environnements d'exécution :
curl --header "Authorization: bearer <token>" <Observer URL>/channels
<token>
est le token d'authentification au Squash Orchestrator.<Observer URL>
est l'URL de l'Observer.
La réponse devrait être de la forme :
{"apiVersion":"v1","code":200,"details":{"items":[{"apiVersion":"opentestfactory.org/v1alpha1","kind":"Channel","metadata":{"channelhandler_id":"907f43e2-b5a0-4594-a1c7-31f6bf667b38","name":"dummy.example.com","namespaces":"default"},"spec":{"tags":["ssh","linux"]},"status":{"currentJobID":null,"lastCommunicationTimestamp":"2022-09-16T12:18:01.640489","phase":"IDLE"}}]},"kind":"Status","message":"Known channels","metadata":{},"reason":"OK","status":"Success"}
L'image docker de Squash TM ne contient pas curl
. Vous pouvez utiliser à la place wget
:
docker exec <Squash TM container> wget --header="Authorization: bearer <token>" -O - <Observer URL>/channels
<Squash TM container>
est le nom du container.<token>
est le token d'authentification au Squash Orchestrator.<Observer URL>
est l'URL de l'Observer.
La réponse devrait être de la forme :
Connecting to 172.17.0.1:7775 (172.17.0.1:7775)
writing to stdout
- 100% |********************************| 464 0:00:00 ETA
written to stdout
{"apiVersion":"v1","code":200,"details":{"items":[{"apiVersion":"opentestfactory.org/v1alpha1","kind":"Channel","metadata":{"channelhandler_id":"907f43e2-b5a0-4594-a1c7-31f6bf667b38","name":"dummy.example.com","namespaces":"default"},"spec":{"tags":["ssh","linux"]},"status":{"currentJobID":null,"lastCommunicationTimestamp":"2022-09-16T12:18:01.640489","phase":"IDLE"}}]},"kind":"Status","message":"Known channels","metadata":{},"reason":"OK","status":"Success"}
Configuration du projet Squash TM
Une fois un serveur d'automatisation déclaré, il faut le lier à un projet Squash TM afin qu'il soit utilisé pour l'exécution des cas de test automatisés du projet.
La marche à suivre est la suivante :
-
Allez dans l'espace
[Administration]
, puis cliquez sur[Projets]
. -
Sélectionnez un projet existant, puis allez jusqu'à la section
Automatisation
. -
Cliquez sur
Pas de serveur
, une liste déroulante contenant les serveurs d'automatisation déclarés apparaît. -
Sélectionnez le serveur et confirmez la sélection.