sélénium docker
4.26.0-20241101
Le projet est rendu possible grâce à des contributeurs bénévoles qui ont consacré des milliers d'heures de leur temps et ont rendu le code source librement disponible sous la licence Apache 2.0.
Ces images Docker sont accompagnées d'une poignée de balises pour simplifier leur utilisation, jetez-y un œil dans l'une de nos versions.
Pour recevoir des notifications sur les nouvelles versions, ajoutez-vous en tant qu'observateur « Versions uniquement ».
Ces images sont publiées dans le registre Docker Hub sur Selenium Docker Hub.
Avez-vous besoin d'aide pour utiliser ces images Docker ? Parlez-nous à https://www.selenium.dev/support/
--shm-size="2g"docker run -d -p 4444:4444 -p 7900:7900 --shm-size= " 2g " selenium/standalone-firefox:4.26.0-20241101Pointez vos tests WebDriver vers http://localhost:4444
C'est ça!
(Facultatif) Pour voir ce qui se passe à l'intérieur du conteneur, accédez à http://localhost:7900/?autoconnect=1&resize=scale&password=secret.
Pour plus de détails sur la visualisation de l'activité du conteneur, consultez la section Débogage.
☝️ Lors de l'exécution docker run pour une image contenant un navigateur, veuillez utiliser l'indicateur --shm-size=2g pour utiliser la mémoire partagée de l'hôte.
☝️ Utilisez toujours une image Docker avec une balise complète pour épingler un navigateur et une version de Grid spécifiques. Voir Conventions de balisage pour plus de détails.
À partir de la balise d'image basée sur 4.21.0 , les architectures prises en charge par ce projet sont les suivantes :
| Architecture | Disponible |
|---|---|
| x86_64 (alias amd64) | ✅ |
| aarch64 (alias arm64/armv8) | ✅ |
| armhf (alias arm32/armv7l) | ❌ |
Les navigateurs suivants sont disponibles dans les images multi-arch :
| Architecture | Chrome | Chrome | Firefox | Bord |
|---|---|---|---|---|
| x86_64 (alias amd64) | ✅ | ✅ | ✅ | ✅ |
| aarch64 (alias arm64/armv8) | ❌ | ✅ | ✅ | ❌ |
| armhf (alias arm32/armv7l) | ❌ | ❌ | ❌ | ❌ |
Note:
Google ne crée pas Chrome ( google-chrome ) pour les plates-formes Linux/ARM. Par conséquent, les images Chrome (nœud et autonome) ne sont disponibles que pour AMD64. De même, Microsoft ne crée pas Edge ( microsoft-edge ) pour les plates-formes Linux/ARM.
L'exécution d'une image AMD64 sous émulation sur une plateforme ARM64 n'est pas recommandée en raison de problèmes de performances et de stabilité.
Pour Linux/ARM, utilisez le navigateur open source Chromium. Les images Chromium (nœud et autonome) sont disponibles en multi-arch.
$ docker run --rm -it -p 4444:4444 -p 5900:5900 -p 7900:7900 --shm-size 2g selenium/standalone-chromium:latestLes images multi-archs sont testées sur CircleCI avec la classe de ressources Linux/ARM64. Voir le statut ci-dessous.
Pour les images expérimentales de conteneurs Docker, qui s'exécutent sur des plates-formes telles que la série Apple M ou Raspberry Pi, le référentiel seleniumhq-community/docker-seleniarm a fourni des images qui sont publiées dans le registre Seleniarm Docker Hub.
Voir le numéro 1076 pour plus d'informations sur ces images.
Maintenant, le fork seleniumhq-community/docker-seleniarm a été fusionné.
Nous vous recommandons d'activer le magasin d'images de conteneur de fonctionnalités expérimentales dans Docker Engine. containerd comprend les images multiplateformes, où une seule balise d'image peut faire référence à différentes variantes couvrant une gamme d'architectures de système d'exploitation et de matériel. Il simplifie le processus de création, de stockage et de distribution d'images sur différentes plates-formes.
Une seule commande pour activer cette fonctionnalité dans Docker Engine :
make set_containerd_image_storePour créer toutes les images multiplateformes, exécutez la commande suivante :
PLATFORMS=linux/amd64,linux/arm64 make buildPour créer les images pour une plate-forme spécifique, exécutez la commande suivante :
PLATFORMS=linux/arm64 make build Par défaut, sans spécifier la variable PLATFORMS , les images sont construites pour la plateforme linux/amd64 .
Les images nocturnes sont construites sur la version Nightly du projet en amont Selenium avec les dernières modifications sur la branche principale de ce référentiel. La balise d'image est nightly . Il n'est pas recommandé d'utiliser des images en production. C'est uniquement à des fins de test.
$ docker run -d -p 4442-4444:4442-4444 --name selenium-hub selenium/hub:nightlyConsultez le docker compose pour démarrer avec les images nocturnes docker-compose-v3-full-grid-nightly.yml
Pour exécuter des tests ou travailler avec des navigateurs en version préliminaire, Google, Mozilla et Microsoft maintiennent un canal de version Dev et Beta pour ceux qui ont besoin de voir ce qui sera bientôt publié auprès du grand public.
Voici les instructions pour les exécuter en mode autonome :
Chrome bêta :
$ docker run --rm -it -p 4444:4444 -p 7900:7900 --shm-size 2g selenium/standalone-chrome:betaDéveloppeur Chrome :
$ docker run --rm -it -p 4444:4444 -p 7900:7900 --shm-size 2g selenium/standalone-chrome:devFirefox bêta :
$ docker run --rm -it -p 4444:4444 -p 7900:7900 --shm-size 2g selenium/standalone-firefox:betaDéveloppeur Firefox :
$ docker run --rm -it -p 4444:4444 -p 7900:7900 --shm-size 2g selenium/standalone-firefox:devBêta Edge :
$ docker run --rm -it -p 4444:4444 -p 7900:7900 --shm-size 2g selenium/standalone-edge:betaDéveloppeur Edge :
$ docker run --rm -it -p 4444:4444 -p 7900:7900 --shm-size 2g selenium/standalone-edge:devdocker-compose-v3-beta-channel.yml :
# To execute this docker compose yml file use `docker compose -f docker-compose-v3-beta-channel.yml up`
# Add the `-d` flag at the end for detached execution
# To stop the execution, hit Ctrl+C, and then `docker compose -f docker-compose-v3-beta-channel.yml down`
version: " 3 "
services:
chrome:
image: selenium/node-chrome:beta
shm_size: 2gb
depends_on:
- selenium-hub
environment:
- SE_EVENT_BUS_HOST=selenium-hub
- SE_EVENT_BUS_PUBLISH_PORT=4442
- SE_EVENT_BUS_SUBSCRIBE_PORT=4443
edge:
image: selenium/node-edge:beta
shm_size: 2gb
depends_on:
- selenium-hub
environment:
- SE_EVENT_BUS_HOST=selenium-hub
- SE_EVENT_BUS_PUBLISH_PORT=4442
- SE_EVENT_BUS_SUBSCRIBE_PORT=4443
firefox:
image: selenium/node-firefox:beta
shm_size: 2gb
depends_on:
- selenium-hub
environment:
- SE_EVENT_BUS_HOST=selenium-hub
- SE_EVENT_BUS_PUBLISH_PORT=4442
- SE_EVENT_BUS_SUBSCRIBE_PORT=4443
selenium-hub:
image: selenium/hub:latest
container_name: selenium-hub
ports:
- " 4442:4442 "
- " 4443:4443 "
- " 4444:4444 "docker-compose-v3-dev-channel.yml :
# To execute this docker compose yml file use `docker compose -f docker-compose-v3-dev-channel.yml up`
# Add the `-d` flag at the end for detached execution
# To stop the execution, hit Ctrl+C, and then `docker compose -f docker-compose-v3-dev-channel.yml down`
version: " 3 "
services:
chrome:
image: selenium/node-chrome:dev
shm_size: 2gb
depends_on:
- selenium-hub
environment:
- SE_EVENT_BUS_HOST=selenium-hub
- SE_EVENT_BUS_PUBLISH_PORT=4442
- SE_EVENT_BUS_SUBSCRIBE_PORT=4443
edge:
image: selenium/node-edge:dev
shm_size: 2gb
depends_on:
- selenium-hub
environment:
- SE_EVENT_BUS_HOST=selenium-hub
- SE_EVENT_BUS_PUBLISH_PORT=4442
- SE_EVENT_BUS_SUBSCRIBE_PORT=4443
firefox:
image: selenium/node-firefox:dev
shm_size: 2gb
depends_on:
- selenium-hub
environment:
- SE_EVENT_BUS_HOST=selenium-hub
- SE_EVENT_BUS_PUBLISH_PORT=4442
- SE_EVENT_BUS_SUBSCRIBE_PORT=4443
selenium-hub:
image: selenium/hub:latest
container_name: selenium-hub
ports:
- " 4442:4442 "
- " 4443:4443 "
- " 4444:4444 "Pour plus d'informations sur les images de conteneurs des canaux Dev et Beta, consultez le billet de blog sur les navigateurs des canaux Dev et Beta via Docker Selenium.
Firefox
docker run -d -p 4444:4444 --shm-size= " 2g " selenium/standalone-firefox:4.26.0-20241101Chrome
docker run -d -p 4444:4444 --shm-size= " 2g " selenium/standalone-chrome:4.26.0-20241101Bord
docker run -d -p 4444:4444 --shm-size= " 2g " selenium/standalone-edge:4.26.0-20241101 Remarque : Un seul conteneur autonome peut s'exécuter sur le port 4444 en même temps.
Il existe différentes manières d'exécuter les images et de créer une grille avec un hub et des nœuds, vérifiez les options suivantes.
Le Hub et les Nodes seront créés dans le même réseau et ils se reconnaîtront par leur nom de conteneur. Un réseau Docker doit être créé dans un premier temps.
$ docker network create grid
$ docker run -d -p 4442-4444:4442-4444 --net grid --name selenium-hub selenium/hub:4.26.0-20241101
$ docker run -d --net grid -e SE_EVENT_BUS_HOST=selenium-hub
--shm-size= " 2g "
-e SE_EVENT_BUS_PUBLISH_PORT=4442
-e SE_EVENT_BUS_SUBSCRIBE_PORT=4443
selenium/node-chrome:4.26.0-20241101
$ docker run -d --net grid -e SE_EVENT_BUS_HOST=selenium-hub
--shm-size= " 2g "
-e SE_EVENT_BUS_PUBLISH_PORT=4442
-e SE_EVENT_BUS_SUBSCRIBE_PORT=4443
selenium/node-edge:4.26.0-20241101
$ docker run -d --net grid -e SE_EVENT_BUS_HOST=selenium-hub
--shm-size= " 2g "
-e SE_EVENT_BUS_PUBLISH_PORT=4442
-e SE_EVENT_BUS_SUBSCRIBE_PORT=4443
selenium/node-firefox:4.26.0-20241101$ docker network create grid
$ docker run - d - p 4442 - 4444 : 4442 - 4444 -- net grid -- name selenium - hub selenium / hub: 4.26 . 0 - 20241101
$ docker run - d -- net grid - e SE_EVENT_BUS_HOST = selenium - hub `
-- shm - size = " 2g " `
- e SE_EVENT_BUS_PUBLISH_PORT = 4442 `
- e SE_EVENT_BUS_SUBSCRIBE_PORT = 4443 `
selenium / node - chrome: 4.26 . 0 - 20241101
$ docker run - d -- net grid - e SE_EVENT_BUS_HOST = selenium - hub `
-- shm - size = " 2g " `
- e SE_EVENT_BUS_PUBLISH_PORT = 4442 `
- e SE_EVENT_BUS_SUBSCRIBE_PORT = 4443 `
selenium / node - edge: 4.26 . 0 - 20241101
$ docker run - d -- net grid - e SE_EVENT_BUS_HOST = selenium - hub `
-- shm - size = " 2g " `
- e SE_EVENT_BUS_PUBLISH_PORT = 4442 `
- e SE_EVENT_BUS_SUBSCRIBE_PORT = 4443 `
selenium / node - firefox: 4.26 . 0 - 20241101Lorsque vous avez fini d'utiliser la grille et que les conteneurs sont sortis, le réseau peut être supprimé avec la commande suivante :
# Removes the grid network
$ docker network rm gridLe Hub et les nœuds seront créés sur différentes machines/VM, ils doivent connaître les adresses IP de chacun pour communiquer correctement. Si plusieurs nœuds doivent être exécutés sur la même machine/VM, ils doivent être configurés pour exposer différents ports.
$ docker run -d -p 4442-4444:4442-4444 --name selenium-hub selenium/hub:4.26.0-20241101$ docker run -d -p 5555:5555
--shm-size= " 2g "
-e SE_EVENT_BUS_HOST= < ip-from-machine- 1>
-e SE_EVENT_BUS_PUBLISH_PORT=4442
-e SE_EVENT_BUS_SUBSCRIBE_PORT=4443
-e SE_NODE_HOST= < ip-from-machine- 2>
selenium/node-chrome:4.26.0-20241101$ docker run - d - p 5555 : 5555 ` -- shm - size = " 2g " ` - e SE_EVENT_BUS_HOST = < ip - from - machine - 1> ` - e SE_EVENT_BUS_PUBLISH_PORT = 4442 ` - e SE_EVENT_BUS_SUBSCRIBE_PORT = 4443 ` - e SE_NODE_HOST = < ip - from - machine - 2> ` selenium / node - chrome: 4.26 . 0 - 20241101
$ docker run -d -p 5555:5555
--shm-size= " 2g "
-e SE_EVENT_BUS_HOST= < ip-from-machine- 1>
-e SE_EVENT_BUS_PUBLISH_PORT=4442
-e SE_EVENT_BUS_SUBSCRIBE_PORT=4443
-e SE_NODE_HOST= < ip-from-machine- 3>
selenium/node-edge:4.26.0-20241101$ docker run - d - p 5555 : 5555 ` -- shm - size = " 2g " ` - e SE_EVENT_BUS_HOST = < ip - from - machine - 1> ` - e SE_EVENT_BUS_PUBLISH_PORT = 4442 ` - e SE_EVENT_BUS_SUBSCRIBE_PORT = 4443 ` - e SE_NODE_HOST = < ip - from - machine - 3> ` selenium / node - edge: 4.26 . 0 - 20241101
$ docker run -d -p 5555:5555
--shm-size= " 2g "
-e SE_EVENT_BUS_HOST= < ip-from-machine- 1>
-e SE_EVENT_BUS_PUBLISH_PORT=4442
-e SE_EVENT_BUS_SUBSCRIBE_PORT=4443
-e SE_NODE_HOST= < ip-from-machine- 4>
selenium/node-firefox:4.26.0-20241101$ docker run - d - p 5555 : 5555 ` -- shm - size = " 2g " ` - e SE_EVENT_BUS_HOST = < ip - from - machine - 1> ` - e SE_EVENT_BUS_PUBLISH_PORT = 4442 ` - e SE_EVENT_BUS_SUBSCRIBE_PORT = 4443 ` - e SE_NODE_HOST = < ip - from - machine - 4> ` selenium / node - firefox: 4.26 . 0 - 20241101
$ docker run -d -p 5556:5556
--shm-size= " 2g "
-e SE_EVENT_BUS_HOST= < ip-from-machine- 1>
-e SE_EVENT_BUS_PUBLISH_PORT=4442
-e SE_EVENT_BUS_SUBSCRIBE_PORT=4443
-e SE_NODE_HOST= < ip-from-machine- 4>
-e SE_NODE_PORT=5556
selenium/node-chrome:4.26.0-20241101$ docker run - d - p 5556 : 5556 ` -- shm - size = " 2g " ` - e SE_EVENT_BUS_HOST = < ip - from - machine - 1> ` - e SE_EVENT_BUS_PUBLISH_PORT = 4442 ` - e SE_EVENT_BUS_SUBSCRIBE_PORT = 4443 ` - e SE_NODE_HOST = < ip - from - machine - 4> ` - e SE_NODE_PORT = 5556 ` selenium / node - chrome: 4.26 . 0 - 20241101
Docker Compose est le moyen le plus simple de démarrer une grille. Utilisez les ressources liées ci-dessous, enregistrez-les localement et vérifiez les instructions d'exécution en haut de chaque fichier.
docker-compose-v2.yml
docker-compose-v3.yml
Pour arrêter la grille et nettoyer les conteneurs créés, exécutez docker compose down .
docker-compose-v3-swarm.yml
Il est possible de démarrer une grille Selenium avec tous ses composants séparés. Par souci de simplicité, seul un exemple avec docker compose sera fourni. Enregistrez le fichier localement et vérifiez les instructions d'exécution par-dessus.
docker-compose-v3-full-grid.yml
| Variable d'environnement | Option | Taper | Valeur par défaut | Description |
|---|---|---|---|---|
SE_REJECT_UNSUPPORTED_CAPS | --reject-unsupported-caps | booléen | false | Autoriser le distributeur à rejeter immédiatement une demande si la grille ne prend pas en charge la fonctionnalité demandée. |
SE_HEALTHCHECK_INTERVAL | --healthcheck-interval | int | 120 | Cela garantit que le serveur peut envoyer une requête ping à tous les nœuds avec succès après un intervalle. |
L’exécution des tests peut être enregistrée à l’aide de l’image Docker selenium/video:ffmpeg-7.1-20241101 . Un conteneur est nécessaire pour chaque conteneur sur lequel un navigateur est exécuté. Cela signifie que si vous exécutez 5 nœuds/conteneurs autonomes, vous aurez besoin de 5 conteneurs vidéo, le mappage est 1-1.
Actuellement, la seule façon d'effectuer ce mappage est manuellement (soit en démarrant les conteneurs manuellement, soit via docker compose ). Nous répétons ce processus et cette configuration sera probablement plus simple à l'avenir.
L'image Docker vidéo que nous fournissons est basée sur l'image ffmpeg Ubuntu fournie par le projet jrottenberg/ffmpeg, merci d'avoir fourni cette image et de simplifier notre travail ?
À partir de la balise d'image basée sur 4.20.0 , l'image Docker vidéo est basée sur l'image FFmpeg Ubuntu fournie par le projet linuxserver/docker-ffmpeg puisque l'image est disponible pour plusieurs plates-formes. Merci d'avoir simplifié notre projet et de nous avoir aidés à avancer avec un support d'architecture multiple.
Remarques :
/videos à l'intérieur du conteneur vidéo. Mappez un répertoire local pour obtenir les vidéos.FILE_NAME pour éviter des résultats inattendus.Cet exemple montre comment démarrer les conteneurs manuellement :
$ docker network create grid
$ docker run -d -p 4444:4444 -p 6900:5900 --net grid --name selenium --shm-size= " 2g " selenium/standalone-chrome:4.26.0-20241101
$ docker run -d --net grid --name video -v /tmp/videos:/videos selenium/video:ffmpeg-7.1-20241101
# Run your tests
$ docker stop video && docker rm video
$ docker stop selenium && docker rm selenium Une fois les conteneurs arrêtés et supprimés, vous devriez voir un fichier vidéo dans le répertoire /tmp/videos de votre machine.
Voici un exemple utilisant un Hub et quelques nœuds :
docker-compose-v3-video.yml
Basé sur la prise en charge des métadonnées dans les tests. Lorsque l'enregistreur vidéo est déployé en side-car avec le nœud du navigateur en activant SE_VIDEO_FILE_NAME=auto et en ajoutant des métadonnées à vos tests, le nom du fichier vidéo extraira la valeur de la capacité se:name et l'utilisera comme nom de fichier vidéo.
Par exemple dans la liaison Python :
from selenium . webdriver . chrome . options import Options as ChromeOptions
from selenium import webdriver
options = ChromeOptions ()
options . set_capability ( 'se:name' , 'test_visit_basic_auth_secured_page (ChromeTests)' )
driver = webdriver . Remote ( options = options , command_executor = "http://localhost:4444" )
driver . get ( "https://selenium.dev" )
driver . quit () Le nom du fichier vidéo de sortie sera test_visit_basic_auth_secured_page_ChromeTests_ .
Si le nom de votre test est géré par le framework de test et qu'il est unique, vous pouvez également désactiver l'identifiant de session ajouté au nom du fichier vidéo en définissant SE_VIDEO_FILE_NAME_SUFFIX=false .
Le nom du fichier sera réduit à 255 caractères pour éviter les noms de fichiers longs. De plus, le caractère space sera remplacé par _ et seuls les caractères alphabets, chiffres, - (trait d'union), _ (trait de soulignement) sont conservés dans le nom du fichier.
L'expression régulière de trim peut être personnalisée en définissant la variable d'environnement SE_VIDEO_FILE_NAME_TRIM_REGEX . La valeur par défaut est [:alnum:]-_ . L'expression régulière doit être compatible avec la commande tr dans bash.
Au niveau du déploiement, le conteneur de l'enregistreur est toujours actif. De plus, vous pouvez désactiver le processus d'enregistrement vidéo via la fonctionnalité de session se:recordVideo . Par exemple dans la liaison Python :
options . set_capability ( 'se:recordVideo' , False ) Dans le conteneur de l'enregistreur, il effectuera une requête GraphQL dans Hub en fonction du Node SessionId et extraira la valeur de se:recordVideo dans les capacités avant de décider de démarrer ou non le processus d'enregistrement vidéo.
Remarques : Pour atteindre le point de terminaison GraphQL, le conteneur de l'enregistreur doit connaître l'URL du Hub. L'URL du Hub peut être transmise via la variable d'environnement SE_NODE_GRID_URL . Par exemple, SE_NODE_GRID_URL est http://selenium-hub:4444 .
RCLONE est installé dans l'image du magnétoscope. Vous pouvez l'utiliser pour télécharger les vidéos sur un service de stockage cloud. Outre l'enregistrement vidéo mentionné ci-dessus, vous pouvez activer la fonctionnalité de téléchargement en définissant les variables d'environnement suivantes :
version : " 3 "
services :
chrome_video :
image : selenium/video:ffmpeg-7.1-20241101
depends_on :
- chrome
environment :
- DISPLAY_CONTAINER_NAME=chrome
- SE_VIDEO_FILE_NAME=auto
- SE_VIDEO_UPLOAD_ENABLED=true
- SE_UPLOAD_DESTINATION_PREFIX=s3://mybucket/path
- RCLONE_CONFIG_S3_TYPE=s3
- RCLONE_CONFIG_S3_PROVIDER=GCS
- RCLONE_CONFIG_S3_ENV_AUTH=true
- RCLONE_CONFIG_S3_REGION=asia-southeast1
- RCLONE_CONFIG_S3_LOCATION_CONSTRAINT=asia-southeast1
- RCLONE_CONFIG_S3_ACL=private
- RCLONE_CONFIG_S3_ACCESS_KEY_ID=xxx
- RCLONE_CONFIG_S3_SECRET_ACCESS_KEY=xxx
- RCLONE_CONFIG_S3_ENDPOINT=https://storage.googleapis.com
- RCLONE_CONFIG_S3_NO_CHECK_BUCKET=true SE_VIDEO_FILE_NAME=auto utilisera l'identifiant de session comme nom de fichier vidéo. Cela garantit que le nom du fichier vidéo est unique à télécharger. La construction du nom de fichier vidéo fonctionne automatiquement en fonction du point de terminaison /status du nœud (et du point de terminaison GraphQL facultatif) pour obtenir l'ID de session et les capacités.
SE_VIDEO_UPLOAD_ENABLED=true activera la fonction de téléchargement vidéo. En arrière-plan, il créera un fichier pipe avec le fichier et la destination que le téléchargeur pourra consommer et poursuivre.
SE_VIDEO_INTERNAL_UPLOAD=true utilisera RCLONE installé dans le conteneur pour le téléchargement. Si vous souhaitez utiliser un autre conteneur side-car pour le téléchargement, définissez-le sur false .
| Variables ENV par mode | Concentrateur/nœuds | Rôles autonomes | Grille dynamique |
|---|---|---|---|
SE_VIDEO_RECORD_STANDALONE (obligatoire) | false (par défaut) | true | true |
DISPLAY_CONTAINER_NAME (obligatoire) | entrée de l'utilisateur | entrée de l'utilisateur | (pas obligatoire) |
SE_NODE_PORT (facultatif) | 5555 | 4444 | (pas obligatoire) |
SE_NODE_GRID_URL (facultatif) | entrée de l'utilisateur | (pas obligatoire) | (pas obligatoire) |
Pour les variables d'environnement avec le préfixe RCLONE_ il est utilisé pour transmettre la configuration à distance à RCLONE. Vous pouvez trouver plus d'informations sur la configuration de RCLONE ici. Lors de l'utilisation dans Dynamic Grid, ces variables doivent être combinées avec le préfixe SE_ , par exemple SE_RCLONE_ . Voir la référence ci-dessous pour plus de détails.
Configurer l'enregistrement et le téléchargement vidéo pour Hub et Nodes : docker-compose-v3-video-upload.yml
Configurer l'enregistrement et le téléchargement vidéo pour les rôles autonomes : docker-compose-v3-video-upload-standalone.yml
Configurer l'enregistrement et le téléchargement vidéo pour Dynamic Grid (node-docker) : docker-compose-v3-video-upload-dynamic-grid.yml
Configurer l'enregistrement et le téléchargement vidéo pour Dynamic Grid autonome (standalone-docker) : tests/docker-compose-v3-test-standalone-docker.yaml
| Variable d'environnement | Valeur par défaut | Description |
|---|---|---|
SE_UPLOAD_RETAIN_LOCAL_FILE | false | Conserver le fichier local après le téléchargement réussi |
SE_UPLOAD_COMMAND | copy | La commande RCLONE est utilisée pour transférer le fichier. Appliquer move lorsque la conservation du fichier local est false |
SE_UPLOAD_OPTS | -P --cutoff-mode SOFT --metadata --inplace | D'autres options appartiennent à la commande RCLONE et peuvent être définies. |
SE_UPLOAD_CONFIG_FILE_NAME | upload.conf | Fichier de configuration pour l'hôte distant au lieu d'être défini via le préfixe de variable d'environnement SE_RCLONE_* |
SE_UPLOAD_CONFIG_DIRECTORY | /opt/bin | Répertoire du fichier de configuration (modifiez-le lorsque le fichier de configuration dans un autre répertoire est monté) |
Grid 4 a la capacité de démarrer des conteneurs Docker à la demande, cela signifie qu'il démarre un conteneur Docker en arrière-plan pour chaque nouvelle demande de session, le test y est exécuté et une fois le test terminé, le conteneur est jeté.
Ce mode d'exécution peut être utilisé dans les rôles Autonome ou Noeud. Le mode d'exécution "dynamique" doit savoir quelles images Docker utiliser au démarrage des conteneurs. De plus, Grid doit connaître l’URI du démon Docker. Cette configuration peut être placée dans un fichier toml local.
Vous pouvez enregistrer ce fichier localement et le nommer, par exemple, config.toml .
[ docker ] # Configs have a mapping between the Docker image to use and the capabilities that need to be matched to # start a container with the given image. configs = [ " selenium/standalone-firefox:4.26.0-20241101 " , ' {"browserName": "firefox"} ' , " selenium/standalone-chrome:4.26.0-20241101 " , ' {"browserName": "chrome"} ' , " selenium/standalone-edge:4.26.0-20241101 " , ' {"browserName": "MicrosoftEdge"} ' ] host-config-keys = [ " Dns " , " DnsOptions " , " DnsSearch " , " ExtraHosts " , " Binds " ] # URL for connecting to the docker daemon # Most simple approach, leave it as http://127.0.0.1:2375, and mount /var/run/docker.sock. # 127.0.0.1 is used because internally the container uses socat when /var/run/docker.sock is mounted # If var/run/docker.sock is not mounted: # Windows: make sure Docker Desktop exposes the daemon via tcp, and use http://host.docker.internal:2375. # macOS: install socat and run the following command, socat -4 TCP-LISTEN:2375,fork UNIX-CONNECT:/var/run/docker.sock, # then use http://host.docker.internal:2375. # Linux: varies from machine to machine, please mount /var/run/docker.sock. If this does not work, please create an issue. url = " http://127.0.0.1:2375 " # Docker image used for video recording video-image = " selenium/video:ffmpeg-7.1-20241101 " # Uncomment the following section if you are running the node on a separate VM # Fill out the placeholders with appropriate values # [server] # host =# port =
Avec la clé de configuration facultative host-config-keys sous la section [docker] dans un fichier config.toml (ou l'option CLI --docker-host-config-keys). Les utilisateurs peuvent spécifier une liste de clés de configuration d'hôte Docker qui doivent être transmises aux conteneurs du navigateur.
Les noms de clés valides pour la configuration de l'hôte Docker peuvent être trouvés dans la documentation de l'API Docker ou via la commande docker inspect le conteneur node-docker.
Si vous souhaitez accéder au répertoire de téléchargement dans les conteneurs du navigateur de nœuds (par exemple /home/seluser/Downloads ) via la configuration des volumes du conteneur Dynamic Grid, vous pouvez ajouter la configuration suivante au fichier config.toml
[ docker ]
host-config-keys = [ " Binds " ]Configuration des volumes dans le fichier de composition Docker
services :
node-docker :
image : selenium/node-docker:latest
volumes :
- ./assets:/opt/selenium/assets
- ./config.toml:/opt/selenium/docker.toml
- ./downloads:/home/seluser/Downloads
- /var/run/docker.sock:/var/run/docker.sock
environment :
- SE_NODE_DOCKER_CONFIG_FILENAME=docker.toml /opt/selenium/config.toml est le chemin par défaut du fichier de configuration dans toutes les images. Une fois la configuration des volumes partagée avec les conteneurs du navigateur de nœuds, son config.toml peut être écrasé par le fichier de configuration du conteneur nœud-docker.
Dans ce cas, montez votre fichier config.toml sur /opt/selenium/docker.toml dans le conteneur node-docker. Et définissez la variable d'environnement SE_NODE_DOCKER_CONFIG_FILENAME=docker.toml pour spécifier ce nom de fichier de configuration pour le script de démarrage.
Reportez-vous à l'exemple docker-compose-v3-test-node-docker.yaml
Cela peut être étendu à un déploiement de grille complet, tous les composants étant déployés individuellement. L'idée générale est d'avoir le Hub dans une machine virtuelle et chacun des nœuds dans des machines virtuelles distinctes et plus puissantes.
$ docker network create grid
$ docker run -d -p 4442-4444:4442-4444 --net grid --name selenium-hub selenium/hub:4.26.0-20241101
$ docker run -d --net grid -e SE_EVENT_BUS_HOST=selenium-hub
-e SE_EVENT_BUS_PUBLISH_PORT=4442
-e SE_EVENT_BUS_SUBSCRIBE_PORT=4443
-v ${PWD} /config.toml:/opt/selenium/config.toml
-v ${PWD} /assets:/opt/selenium/assets
-v /var/run/docker.sock:/var/run/docker.sock
selenium/node-docker:4.26.0-20241101$ docker network create grid
$ docker run - d - p 4442 - 4444 : 4442 - 4444 -- net grid -- name selenium - hub selenium / hub: 4.26 . 0 - 20241101
$ docker run - d -- net grid - e SE_EVENT_BUS_HOST = selenium - hub `
- e SE_EVENT_BUS_PUBLISH_PORT = 4442 `
- e SE_EVENT_BUS_SUBSCRIBE_PORT = 4443 `
- v ${PWD} / config.toml: / opt / selenium / config.toml `
- v ${PWD} / assets: / opt / selenium / assets `
- v / var / run / docker.sock: / var / run / docker.sock `
selenium / node - docker: 4.26 . 0 - 20241101 Pour que les actifs soient enregistrés sur votre hôte, veuillez monter le chemin de votre hôte sur /opt/selenium/assets .
Lorsque vous avez fini d'utiliser la grille et que les conteneurs sont sortis, le réseau peut être supprimé avec la commande suivante :
# Removes the grid network
$ docker network rm griddocker run --rm --name selenium-docker -p 4444:4444
-v ${PWD} /config.toml:/opt/selenium/config.toml
-v ${PWD} /assets:/opt/selenium/assets
-v /var/run/docker.sock:/var/run/docker.sock
selenium/standalone-docker:4.26.0-20241101docker run --rm --name selenium-docker -p 4444:4444 `
-v ${PWD} /config.toml:/opt/selenium/config.toml `
-v ${PWD} /assets:/opt/selenium/assets `
-v /var/run/docker.sock:/var/run/docker.sock `
selenium/standalone-docker:4.26.0-20241101$ docker run -d -p 4442-4444:4442-4444 --name selenium-hub selenium/hub:4.26.0-20241101$ docker run -d -p 5555:5555
-e SE_EVENT_BUS_HOST= < ip-from-machine- 1>
-e SE_EVENT_BUS_PUBLISH_PORT=4442
-e SE_EVENT_BUS_SUBSCRIBE_PORT=4443
-v ${PWD} /config.toml:/opt/selenium/config.toml
-v ${PWD} /assets:/opt/selenium/assets
-v /var/run/docker.sock:/var/run/docker.sock
selenium/node-docker:4.26.0-20241101$ docker run -d -p 5555:5555 `
-e SE_EVENT_BUS_HOST= < ip-from-machine- 1> `
-e SE_EVENT_BUS_PUBLISH_PORT=4442 `
-e SE_EVENT_BUS_SUBSCRIBE_PORT=4443 `
-v ${PWD} /config.toml:/opt/selenium/config.toml `
-v ${PWD} /assets:/opt/selenium/assets `
-v /var/run/docker.sock:/var/run/docker.sock `
selenium/node-docker:4.26.0-20241101 Complétez la section [server] dans le fichier config.toml .
[ docker ] # Configs have a mapping between the Docker image to use and the capabilities that need to be matched to # start a container with the given image. configs = [ " selenium/standalone-firefox:4.26.0-20241101 " , " { " browserName " : " firefox " } " , " selenium/standalone-chrome:4.26.0-20241101 " , " { " browserName " : " chrome " } " , " selenium/standalone-edge:4.26.0-20241101 " , " { " browserName " : " MicrosoftEdge " } " ] # URL for connecting to the docker daemon # Most simple approach, leave it as http://127.0.0.1:2375, and mount /var/run/docker.sock. # 127.0.0.1 is used because interally the container uses socat when /var/run/docker.sock is mounted # If var/run/docker.sock is not mounted: # Windows: make sure Docker Desktop exposes the daemon via tcp, and use http://host.docker.internal:2375. # macOS: install socat and run the following command, socat -4 TCP-LISTEN:2375,fork UNIX-CONNECT:/var/run/docker.sock, # then use http://host.docker.internal:2375. # Linux: varies from machine to machine, please mount /var/run/docker.sock. If this does not work, please create an issue. url = " http://127.0.0.1:2375 " # Docker image used for video recording video-image = " selenium/video:ffmpeg-7.1-20241101 " # Uncomment the following section if you are running the node on a separate VM # Fill out the placeholders with appropriate values [ server ] host = < ip-from-node-machine> port = < port-from-node-machine>
Pour que les actifs soient enregistrés sur votre hôte, veuillez monter le chemin de votre hôte sur /opt/selenium/assets .
Voici un exemple utilisant un Hub et un Node :
docker-compose-v3-dynamic-grid.yml
Les conteneurs peuvent être configurés davantage via des variables d'environnement, telles que SE_NODE_SESSION_TIMEOUT et SE_OPTS . Lorsqu'un conteneur enfant est créé, toutes les variables d'environnement préfixées par SE_ seront transférées et définies dans le conteneur. Vous pouvez définir les variables d'environnement souhaitées dans les conteneurs standalone-docker ou node-docker . L'exemple suivant définit le délai d'expiration de la session sur 700 secondes pour toutes les sessions :
docker run --rm --name selenium-docker -p 4444:4444
-e SE_NODE_SESSION_TIMEOUT=700
-v ${PWD} /config.toml:/opt/selenium/config.toml
-v ${PWD} /assets:/opt/selenium/assets
-v /var/run/docker.sock:/var/run/docker.sock
selenium/standalone-docker:4.26.0-20241101docker run --rm --name selenium-docker -p 4444:4444 `
-e SE_NODE_SESSION_TIMEOUT=700 `
-v ${PWD} /config.toml:/opt/selenium/config.toml `
-v ${PWD} /assets:/opt/selenium/assets `
-v /var/run/docker.sock:/var/run/docker.sock `
selenium/standalone-docker:4.26.0-20241101 Pour enregistrer votre session WebDriver, vous devez ajouter un champ se:recordVideo défini sur true . Vous pouvez également définir un fuseau horaire et une résolution d'écran, par exemple :
{
"browserName" : " firefox " ,
"platformName" : " linux " ,
"se:recordVideo" : " true " ,
"se:timeZone" : " US/Pacific " ,
"se:screenResolution" : " 1920x1080 "
} Après avoir exécuté un test, vérifiez le chemin que vous avez monté sur le conteneur Docker ( ${PWD}/assets ), et vous devriez voir des vidéos et des informations de session.
À partir des liaisons de langue, vous pouvez définir la fonctionnalité se:name pour modifier dynamiquement le nom du fichier vidéo de sortie. Par exemple, dans la liaison Python :
from selenium . webdriver . chrome . options import Options as ChromeOptions
from selenium import webdriver
options = ChromeOptions ()
options . set_capability ( 'se:recordVideo' , True )
options . set_capability ( 'se:screenResolution' , '1920x1080' )
options . set_capability ( 'se:name' , 'test_visit_basic_auth_secured_page (ChromeTests)' )
driver = webdriver . Remote ( options = options , command_executor = "http://localhost:4444" )
driver . get ( "https://selenium.dev" )
driver . quit () Une fois le test exécuté, sous ( ${PWD}/assets ), vous pouvez voir le nom du fichier vidéo dans le chemin /
Le nom du fichier sera réduit à 255 caractères pour éviter les noms de fichiers longs. De plus, le caractère space sera remplacé par _ , et seuls les caractères alphabets, chiffres, - (trait d'union) et _ (trait de soulignement) sont conservés dans le nom du fichier. (Cet exploit est disponible une fois ce PR fusionné)
tzdata est installé dans des images basées et vous pouvez définir le fuseau horaire dans le conteneur en utilisant la variable d'environnement TZ . Par défaut, le fuseau horaire est défini sur UTC . La liste des fuseaux horaires pris en charge peut être trouvée ici. Par exemple:
$ docker run --rm --entrypoint= " " -e TZ=Asia/Ho_Chi_Minh selenium/node-chromium:latest date +%FT%T%Z
2024-08-28T18:19:26+07Nous proposons une charte Helm pour déployer ces images Docker sur Kubernetes. Lisez plus de détails dans le fichier Lisez-moi de Helm.
Vous pouvez transmettre la variable SE_OPTS avec des paramètres de ligne de commande supplémentaires pour démarrer un hub ou un nœud.
$ docker run -d -p 4444:4444 -e SE_OPTS= " --log-level FINE " --name selenium-hub selenium/hub:4.26.0-20241101 Vous pouvez transmettre la variable d'environnement SE_JAVA_OPTS au processus Java.
$ docker run -d -p 4444:4444 -e SE_JAVA_OPTS=-Xmx512m --name selenium-hub selenium/hub:4.26.0-20241101Au lieu d'ajouter des arguments via les options du navigateur à partir des liaisons de langage, par exemple :
options = ChromeOptions ()
options . add_argument ( '--incognito' )
options . add_argument ( '--disable-dev-shm-usage' )
driver = webdriver . Remote ( options = options , command_executor = "http://localhost:4444/wd/hub" ) Vous pouvez également forcer de manière proactive l'application d'arguments directement à partir des variables d'environnement de conteneur (nœud, autonome ou nœud-docker). Définissez la variable d'environnement dont le nom commence par SE_BROWSER_ARGS_ et suivez la clé de configuration selon vous (assurez-vous qu'elles sont uniques lorsque vous définissez plusieurs arguments). Par exemple:
docker run -d -p 4444:4444
-e SE_BROWSER_ARGS_INCOGNITO=--incognito
-e SE_BROWSER_ARGS_DISABLE_DSHM=--disable-dev-shm-usage
selenium/standalone-chrome:latestRépertoriez les arguments de ligne de commande de Chrome pour votre référence.
Remarque : Actuellement, cela s'applique aux navigateurs de nœuds Chrome/Chromium, Edge.
Les nœuds s'enregistrent via le bus d'événements. Lorsque la grille est démarrée dans sa configuration Hub/Node typique, le Hub sera celui qui fera office de bus d'événements, et lorsque la grille sera démarrée avec ses cinq éléments séparés, le bus d'événements fonctionnera tout seul.
Dans les deux cas, il est nécessaire d'indiquer au nœud où se trouve le bus d'événements afin qu'il puisse s'enregistrer. C'est le but des variables d'environnement SE_EVENT_BUS_HOST , SE_EVENT_BUS_PUBLISH_PORT et SE_EVENT_BUS_SUBSCRIBE_PORT .
Dans certains cas, par exemple, si vous souhaitez baliser un nœud, il peut être nécessaire de fournir un stéréotype personnalisé dans la configuration du nœud. La variable d'environnement SE_NODE_STEREOTYPE définit l'entrée du stéréotype dans le config.toml du nœud. Un exemple de fichier config.toml peut être trouvé ici : Définition de capacités personnalisées pour faire correspondre des nœuds spécifiques.
Voici un exemple avec les valeurs par défaut de ces variables d'environnement :
$ docker run -d
-e SE_EVENT_BUS_HOST= < event_bus_ip | event_bus_name >
-e SE_EVENT_BUS_PUBLISH_PORT=4442
-e SE_EVENT_BUS_SUBSCRIBE_PORT=4443 -e SE_NODE_STEREOTYPE= " { " browserName " : " ${SE_NODE_BROWSER_NAME} " , " browserVersion " : " ${SE_NODE_BROWSER_VERSION} " , " platformName " : " Linux " } "
--shm-size= " 2g " selenium/node-chrome:4.26.0-20241101Relayer les commandes vers un point de terminaison de service prenant en charge WebDriver. Il est utile de connecter un service externe prenant en charge WebDriver à Selenium Grid. Un exemple d'un tel service pourrait être un fournisseur de cloud ou un serveur Appium. De cette manière, Grid peut permettre une plus grande couverture des plates-formes et des versions non présentes localement.
Ce qui suit est un exemple de commandes de relais de configuration.
docker-compose-v3-test-node-relay.yml
Si vous souhaitez relayer uniquement des commandes, selenium/node-base est adapté et léger à cet effet. Si vous souhaitez configurer le nœud avec à la fois des navigateurs et des commandes de relais, les images de nœud respectives peuvent être utilisées.
Pour utiliser des variables d'environnement pour générer des configurations de relais, définissez SE_NODE_RELAY_URL et d'autres variables comme ci-dessous.
[ relay ]
url = " ${SE_NODE_RELAY_URL} "
status-endpoint = " ${SE_NODE_RELAY_STATUS_ENDPOINT} "
protocol-version = " ${SE_NODE_RELAY_PROTOCOL_VERSION} "
configs = [ ' ${SE_NODE_RELAY_MAX_SESSIONS} ' , ' {"browserName": "${SE_NODE_RELAY_BROWSER_NAME}", "platformName": "${SE_NODE_RELAY_PLATFORM_NAME}", "appium:platformVersion": "${SE_NODE_RELAY_PLATFORM_VERSION}"} ' ]Pour exécuter un exemple de test avec le nœud relayé, vous pouvez cloner le projet et essayer la commande ci-dessous :
make test_node_relay Par défaut, Selenium est accessible sur http://127.0.0.1:4444/ . Selenium peut être configuré pour utiliser un sous-chemin personnalisé en spécifiant la variable d'environnement SE_SUB_PATH . Dans l'exemple ci-dessous, Selenium est accessible sur http://127.0.0.1:4444/selenium-grid/
$ docker run -d -p 4444:4444 -e SE_SUB_PATH=/selenium-grid/ --name selenium-hub selenium/hub:4.26.0-20241101 Par défaut, les nœuds commencent avec une résolution d'écran de 1 920 x 1 080 avec une profondeur de couleur de 24 bits et un dpi de 96. Ces paramètres peuvent être ajustés en spécifiant les variables d'environnement SE_SCREEN_WIDTH , SE_SCREEN_HEIGHT , SE_SCREEN_DEPTH et/ou SE_SCREEN_DPI lors du démarrage du conteneur.
docker run -d -e SE_SCREEN_WIDTH=1366 -e SE_SCREEN_HEIGHT=768 -e SE_SCREEN_DEPTH=24 -e SE_SCREEN_DPI=74 selenium/standalone-firefox:4.26.0-20241101 Dans certains cas d'utilisation, vous devrez peut-être définir l'URL de la grille sur le nœud, par exemple si vous souhaitez accéder au point de terminaison BiDi/CDP. Ceci est également nécessaire lorsque vous souhaitez utiliser les nouveaux RemoteWebDriver.builder() ou Augmenter() présents dans Selenium 4 (puisqu'ils configurent implicitement la connexion BiDi/CDP). Vous pouvez le faire via la variable d'environnement SE_NODE_GRID_URL , par exemple -e SE_NODE_GRID_URL=http:// . La définition de cette variable d'environnement est nécessaire si vous souhaitez voir la vue en direct pendant l'exécution des sessions.
Grid a un délai d'expiration de session par défaut de 300 secondes, où la session peut rester dans un état obsolète jusqu'à ce qu'elle soit interrompue. Vous pouvez utiliser SE_NODE_SESSION_TIMEOUT pour écraser cette valeur en quelques secondes.
Une nouvelle demande de session est placée dans la file d'attente de session avant d'être traitée, et la demande reste dans la file d'attente jusqu'à ce qu'un emplacement correspondant soit trouvé parmi les nœuds enregistrés. Cependant, la nouvelle demande de session peut expirer si aucun emplacement n'est trouvé. Par défaut, une demande restera dans la file d'attente jusqu'à 300 secondes avant qu'un délai d'attente ne soit atteint. De plus, une tentative de traitement de la requête est effectuée toutes les 5 secondes (par défaut).
Il est possible de remplacer ces valeurs via des variables d'environnement dans le Hub et la SessionQueue ( SE_SESSION_REQUEST_TIMEOUT et SE_SESSION_RETRY_INTERVAL ). Par exemple, un délai d'attente de 500 secondes serait SE_SESSION_REQUEST_TIMEOUT=500 et un intervalle de nouvelle tentative de 2 secondes serait SE_SESSION_RETRY_INTERVAL=2 .
Par défaut, une seule session est configurée pour s'exécuter par conteneur via la variable d'environnement SE_NODE_MAX_SESSIONS . Il est possible d'augmenter ce nombre jusqu'au nombre maximum de processeurs disponibles, car plus de stabilité est obtenue lorsqu'un conteneur/navigateur dispose d'un processeur à exécuter.
Cependant, si vous avez mesuré les performances et que, sur cette base, vous pensez que davantage de sessions peuvent être exécutées dans chaque conteneur, vous pouvez remplacer la limite maximale en définissant SE_NODE_MAX_SESSIONS sur le nombre souhaité et SE_NODE_OVERRIDE_MAX_SESSIONS sur true . Néanmoins, exécuter plus de sessions de navigateur que les processeurs disponibles n'est pas recommandé car vous surchargeriez les ressources.
Le remplacement de ce paramètre a un effet secondaire indésirable lorsque l'enregistrement vidéo est activé, car plusieurs sessions de navigateur peuvent être capturées dans la même vidéo.
Firefox, Chrome, Lorsque vous utilisez le mode sans tête, il n'est pas nécessaire de démarrer le serveur Xvfb.
Pour éviter de démarrer le serveur, vous pouvez définir la variable d'environnement SE_START_XVFB sur false (ou toute autre valeur que true ), par exemple :
$ docker run -d --net grid -e SE_EVENT_BUS_HOST=selenium-hub -e SE_EVENT_BUS_PUBLISH_PORT=4442
-e SE_EVENT_BUS_SUBSCRIBE_PORT=4443 -e SE_START_XVFB=false --shm-size= " 2g " selenium/node-chrome:4.26.0-20241101Pour plus d’informations, consultez ce problème GitHub.
Noté:
SE_START_XVFB doit être défini sur true pour s'exécuter en mode --headless=new . Dans certains environnements, comme Docker Swarm ou Kubernetes, il est utile d'arrêter le conteneur Node ou Standalone après l'exécution de N tests. Par exemple, cela peut être utilisé dans Kubernetes pour terminer le pod, puis en mettre un nouveau à l'échelle après N sessions. Définissez la variable d'environnement SE_DRAIN_AFTER_SESSION_COUNT sur une valeur supérieure à zéro pour activer ce comportement.
$ docker run -e SE_DRAIN_AFTER_SESSION_COUNT=5 --shm-size= " 2g " selenium/standalone-firefox:4.26.0-20241101Avec la commande précédente, le conteneur autonome s'arrêtera après l'exécution de 5 sessions.
Dans les conteneurs de longue durée, il peut arriver que les navigateurs laissent des restes. Il peut s'agir de processus de navigateur bloqués de tâches déjà terminées mais qui n'ont pas réussi à arrêter complètement le navigateur, ou de fichiers temporaires écrits dans le système de fichiers /tmp (notamment sur les navigateurs basés sur Chrome). Pour éviter que ces ressources ne soient saturées telles que les ID de processus et l'utilisation du système de fichiers dans le conteneur, un script de nettoyage automatique s'exécute toutes les heures dans les conteneurs de nœuds. Cela nettoiera les anciens processus et les anciens fichiers temporaires. Par défaut, ceci est désactivé. Lorsqu'elle est activée, cela nettoiera les navigateurs fonctionnant depuis plus de 2 heures et les fichiers datant de plus d'un jour. Ceux-ci peuvent être activés et modifiés avec les variables d'environnement suivantes :
SE_ENABLE_BROWSER_LEFTOVERS_CLEANUP : valeur par défaut false , définie sur true pour activer le nettoyage.SE_BROWSER_LEFTOVERS_INTERVAL_SECS : valeur par défaut 3600 (1 heure), intervalle de nettoyage en secondes.SE_BROWSER_LEFTOVERS_PROCESSES_SECS : valeur par défaut 7200 (2 heures), les navigateurs fonctionnant plus longtemps que cette durée seront tués.SE_BROWSER_LEFTOVERS_TEMPFILES_DAYS : valeur par défaut 1 (1 jour), les fichiers générés par les navigateurs basés sur Chrome dans /tmp seront supprimés après ce nombre de jours (ignorés lors de l'utilisation de Firefox). Si vous utilisez Selenium pour des sessions de longue durée et que vous prévoyez que les navigateurs fonctionnent pendant plus de 2 heures, ne définissez pas SE_ENABLE_BROWSER_LEFTOVERS_CLEANUP sur true (laissez la valeur par défaut false ), ou modifiez SE_BROWSER_LEFTOVERS_PROCESSES_SECS pour définir une valeur supérieure à votre durée de vie attendue. exécuter des processus de navigateur.
$ docker run -e SE_ENABLE_BROWSER_LEFTOVERS_CLEANUP=true --shm-size= " 2g " selenium/node-chrome:4.26.0-20241101Avec la commande précédente, le nettoyage sera activé avec les horaires par défaut.
$ docker run -e SE_ENABLE_BROWSER_LEFTOVERS_CLEANUP=true
-e SE_BROWSER_LEFTOVERS_INTERVAL_SECS=7200
-e SE_BROWSER_LEFTOVERS_PROCESSES_SECS=3600
-e SE_BROWSER_LEFTOVERS_TEMPFILES_DAYS=2
--shm-size= " 2g " selenium/node-chrome:4.26.0-20241101Avec la commande précédente, le nettoyage sera activé, mais s'exécutera toutes les 2 heures (au lieu de 1), tuera les navigateurs fonctionnant pendant plus d'une heure (au lieu de 2 heures) et supprimera les fichiers temporaires de plus de 2 jours (au lieu de 1).
Peu de variables sorties comme le mot de passe, le secret, etc. sont masquées dans les journaux de la console. À des fins de débogage, vous pouvez le désactiver en définissant SE_MASK_SECRETS sur false
Lors de la création d'un script bash, vous pouvez masquer la sortie en utilisant la syntaxe echo "Current value is $(mask ${YOUR_VARIABLE})
SE_MASK_SECRETS_MIN_LENGTH par défaut est 3 . Cela signifie qu'une longue chaîne sera masquée en *** pour éviter d'exposer la longueur à une attaque par force brute.
Par défaut, des certificats auto-signés par défaut sont disponibles dans l'image à l'emplacement /opt/selenium/secrets inclus
server.jks : fichier truststore à configurer pour JVM via la propriété système javax.net.ssl.trustStore au démarrage du serveur.server.pass : le fichier contient le mot de passe du truststore pour JVM via la propriété système javax.net.ssl.trustStorePassword .tls.crt : le certificat du serveur pour la connexion https est défini sur l'option Selenium --https-certificate .tls.key : La clé privée du serveur (au format PKCS8) pour la connexion https est définie sur l'option Selenium --https-private-key .Il existe des variables d'environnement pour configurer la connexion sécurisée :
| Variables d'environnement | Défaut | Option de | Description |
|---|---|---|---|
| SE_ENABLE_TLS | false | Activer la connexion sécurisée avec les configurations par défaut | |
| SE_JAVA_SSL_TRUST_STORE | /opt/selenium/secrets/server.jks | JVM | |
| SE_JAVA_SSL_TRUST_STORE_PASSWORD | /opt/selenium/secrets/server.pass | JVM | |
| SE_JAVA_DISABLE_HOSTNAME_VERIFICATION | true | JVM | Désactiver les vérifications par l'hôte des composants en interne |
| SE_HTTPS_CERTIFICAT | /opt/selenium/secrets/tls.crt | Sélénium | Définir sur l'option CLI --https-certificate |
| SE_HTTPS_PRIVATE_KEY | /opt/selenium/secrets/tls.key | Sélénium | Définir sur l'option CLI --https-private-key |
Via le montage en volume, vous pouvez remplacer les certificats par défaut par vos propres certificats.
Le certificat auto-signé doit également être approuvé par le client (ajouter au système une autorité de certification largement approuvée) pour éviter les messages d'erreur liés à la négociation SSL lors de la création de RemoteWebDriver.
Reportez-vous à l'exemple : docker-compose-v3-full-grid-secure.yml
Différents navigateurs ont différentes manières de définir la langue et les paramètres régionaux à partir de la liaison.
Firefox peut être configuré pour utiliser une langue et des paramètres régionaux spécifiques en définissant les préférences de profil lors de la création de WebDriver à partir de la liaison. De plus, le module linguistique doit être installé en tant que module complémentaire pour que la langue de l'interface utilisateur du navigateur prenne effet. Par exemple, pour définir la langue et les paramètres régionaux du navigateur sur vi-VN , vous pouvez suivre les étapes suivantes :
Obtenez le dernier pack de langue Firefox pour la langue souhaitée, par exemple https://download.mozilla.org/?product=firefox-langpack-latest-SSL&lang=vi. Ensuite, vous pouvez installer le module linguistique en tant que module complémentaire lors de la création de l'instance RemoteWebDriver.
profile = webdriver . FirefoxProfile ()
profile . set_preference ( 'intl.accept_languages' , 'vi-VN,vi' )
profile . set_preference ( 'intl.locale.requested' , 'vi-VN,vi' )
options = FirefoxOptions ()
options . profile = profile
driver = webdriver . Remote ( options = options , command_executor = "http://selenium-hub:4444/wd/hub" )
webdriver . Firefox . install_addon ( driver , "/local/path/to/vi.xpi" )
driver . get ( 'https://google.com' )Il existe un script pour obtenir tous les packs de langue disponibles pour une version donnée de Firefox. Vous pouvez exécuter le script pour transférer les modules linguistiques vers votre source. Par exemple:
FIREFOX_VERSION= $( docker run --rm --entrypoint= " " selenium/node-firefox:latest firefox --version | awk ' {print $3} ' )
&& ./NodeFirefox/get_lang_package.sh ${FIREFOX_VERSION} /local/path/to/download Vous pouvez également monter le répertoire du conteneur /home/seluser/firefox/distribution/extensions dans le répertoire hôte pour accéder aux packs pré-construits dans le conteneur pour les utiliser dans votre script de test.
Supervisor est utilisé pour gérer les processus et les journaux dans le conteneur. Peu de configurations pour supervisord peuvent être définies via des variables d'environnement comme ci-dessous :
| Variables d'environnement | Défaut | configuration supervisord |
|---|---|---|
| SE_SUPERVISORD_LOG_LEVEL | info | superviseur.loglevel |
| SE_SUPERVISORD_CHILD_LOG_DIR | /tmp | superviseur.childlogdir |
| SE_SUPERVISORD_LOG_FILE | /tmp/supervisord.log | superviseur.fichier journal |
| SE_SUPERVISORD_PID_FILE | /tmp/supervisord.pid | superviseur.pidfile |
Clonez le dépôt et à partir de la racine du répertoire du projet, vous pouvez tout construire en exécutant :
$ VERSION=local make build Si vous devez configurer des variables d'environnement afin de construire l'image (proxy http par exemple), définissez simplement une variable d'environnement BUILD_ARGS qui contient les variables supplémentaires à transmettre au contexte docker (cela ne fonctionnera qu'avec docker >= 1.9)
$ BUILD_ARGS= " --build-arg http_proxy=http://acme:3128 --build-arg https_proxy=http://acme:3128 " make build Remarque : Omettre VERSION=local créera les images avec la version publiée mais remplacera la date par la version actuelle.
Si vous souhaitez créer l'image avec l'UID/GID de l'hôte, définissez simplement une variable d'environnement BUILD_ARGS
$ BUILD_ARGS= " --build-arg UID= $( id -u ) --build-arg GID= $( id -g ) " make build Si vous souhaitez créer l'image avec un utilisateur/mot de passe par défaut différent, définissez simplement une variable d'environnement BUILD_ARGS
$ BUILD_ARGS= " --build-arg SEL_USER=yourseluser --build-arg SEL_PASSWD=welcome " make buildSur la base du dernier Dockerfile (en clonant le dépôt et à partir de la racine du répertoire du projet), vous pouvez créer les images avec une combinaison spécifique de Selenium Grid et de versions de navigateur.
Par exemple, vous souhaitez construire des images node-chrome et standalone-chrome avec la version 4.17.0 basée sur la grille, les versions de navigateur Chrome 119 , 120 , 123 respectivement.
$ ./tests/build-backward-compatible/bootstrap.sh 4.17.0 119,120,123 chromeEn générique, le script prend les arguments suivants:
$1 (obligatoire): version de la grille de sélénium. Les détails s'approchent du fichier matriciel$2 (obligatoire): Version majeure du navigateur, Valeurs multiples séparées par la virgule. Les détails s'approchent du fichier matriciel$3 (facultatif): nom du navigateur. S'il n'est pas fourni, il iratera sur tous les navigateurs ( chrome , edge , firefox )$4 (facultatif): Push Image vers le registre. Par défaut, c'est false . Si vous souhaitez pousser l'image vers le registre, définissez-le sur true (connexion Docker requise dans votre espace de noms effectué avant d'exécuter le script). Pour définir votre espace de noms pour les images, vous pouvez définir le NAME de la variable d'environnement avant d'exécuter le script. Par exemple:
$ export NAME=artifactory.yourcompany.com/selenium
$ ./tests/build-backward-compatible/bootstrap.sh 4.17.0 119,120,123 chromeAprès avoir exécuté le script, vous verrez des images de liste avec une balise complète pour épingler la version spécifique de la grille et du navigateur suivant les conventions de tagging
Le serveur Selenium, le navigateur et le pilote sont préinstallés dans l'image. Au cas où vous souhaitez rester sur la même version de Selenium et mettre à niveau le navigateur et son pilote au dernier. Vous pouvez suivre les étapes ci-dessous
Clone le repo et à partir de la racine du répertoire de projet, vous pouvez mettre à niveau en fonctionnant:
$ VERSION= $EXPECTED_SELENIUM_VERSION make chrome_upgrade_version Par exemple: VERSION=4.16.1 make chrome_upgrade_version
La nouvelle image a tag $VERSION_YYYYMMDD où YYYYMMDD est la date actuelle.
$ VERSION= $SELENIUM_VERSION make firefox_upgrade_version$ VERSION= $SELENIUM_VERSION make edge_upgrade_versionVous pouvez vous référer aux commandes détaillées dans le fichier MakeFile.
C'est une bonne pratique de vérifier d'abord si la grille est en place et prête à recevoir des demandes, cela peut être fait en vérifiant le point de terminaison /wd/hub/status .
Une grille prête, composée d'un hub et de deux nœuds, pourrait ressembler à ceci:
{
"value" : {
"ready" : true ,
"message" : " Selenium Grid ready. " ,
"nodes" : [
{
"id" : " 6c0a2c59-7e99-469d-bbfc-313dc638797c " ,
"uri" : " http: u002fu002f 172.19.0.3:5555 " ,
"maxSessions" : 4 ,
"stereotypes" : [
{
"capabilities" : {
"browserName" : " firefox "
},
"count" : 4
}
],
"sessions" : [
]
},
{
"id" : " 26af3363-a0d8-4bd6-a854-2c7497ed64a4 " ,
"uri" : " http: u002fu002f 172.19.0.4:5555 " ,
"maxSessions" : 4 ,
"stereotypes" : [
{
"capabilities" : {
"browserName" : " chrome "
},
"count" : 4
}
],
"sessions" : [
]
}
]
}
} La valeur "ready": true indique que la grille est prête à recevoir des demandes. Ce statut peut être interrogé via un script avant d'exécuter n'importe quel test, ou il peut être ajouté en tant que Healthcheck lorsque le conteneur Docker est démarré.
Le script Check-Grid.sh, qui est inclus dans les images, peut être utilisé pour interroger l'état de la grille.
Cet exemple vérifie l'état de la grille toutes les 15 secondes, il a un délai de 30 secondes lorsque le chèque est effectué, et il réchauffe jusqu'à 5 fois jusqu'à ce que le conteneur soit marqué comme malsain. Veuillez utiliser les valeurs ajustées pour répondre à vos besoins, (si nécessaire) remplacer les paramètres --host et --port pour ceux utilisés dans votre environnement.
$ docker network create grid
$ docker run -d -p 4442-4444:4442-4444 --net grid --name selenium-hub
--health-cmd= ' /opt/bin/check-grid.sh --host 0.0.0.0 --port 4444 '
--health-interval=15s --health-timeout=30s --health-retries=5
selenium/hub:4.26.0-20241101
$ docker run -d --net grid -e SE_EVENT_BUS_HOST=selenium-hub
--shm-size= " 2g "
-e SE_EVENT_BUS_PUBLISH_PORT=4442
-e SE_EVENT_BUS_SUBSCRIBE_PORT=4443
selenium/node-chrome:4.26.0-20241101
$ docker run -d --net grid -e SE_EVENT_BUS_HOST=selenium-hub
--shm-size= " 2g "
-e SE_EVENT_BUS_PUBLISH_PORT=4442
-e SE_EVENT_BUS_SUBSCRIBE_PORT=4443
selenium/node-edge:4.26.0-20241101
$ docker run -d --net grid -e SE_EVENT_BUS_HOST=selenium-hub
--shm-size= " 2g "
-e SE_EVENT_BUS_PUBLISH_PORT=4442
-e SE_EVENT_BUS_SUBSCRIBE_PORT=4443
selenium/node-firefox:4.26.0-20241101
Remarque: Le délimiteur line ne fonctionnera pas sur les terminaux basés sur Windows, essayez soit ^ ou sur une backtick.
L'état de santé des conteneurs peut être vérifié en faisant docker ps et en vérifiant le statut (healthy)|(unhealthy) ou en l'inspectant de la manière suivante:
$ docker inspect --format= ' {{json .State.Health.Status}} ' selenium-hub
" healthy "Un problème commun connu dans Docker est qu'un conteneur en cours d'exécution ne signifie pas toujours que l'application à l'intérieur est prête. Un moyen simple de s'attaquer à celle-ci est en utilisant un script "Wait-for-it", plus d'informations peuvent être vues ici.
Le script suivant est un exemple de la façon dont cela peut être fait en utilisant Bash, mais le même principe s'applique si vous voulez le faire avec le langage de programmation utilisé pour écrire les tests. Dans l'exemple ci-dessous, le script interrogera le point de terminaison de l'état à chaque seconde. Si la grille ne se prépare pas dans les 30 secondes, le script sortira avec un code d'erreur.
#! /bin/bash
# wait-for-grid.sh
set -e
url= " http://localhost:4444/wd/hub/status "
wait_interval_in_seconds=1
max_wait_time_in_seconds=30
end_time= $(( SECONDS + max_wait_time_in_seconds ))
time_left= $max_wait_time_in_seconds
while [ $SECONDS -lt $end_time ] ; do
response= $( curl -sL " $url " | jq -r ' .value.ready ' )
if [ -n " $response " ] && [ " $response " ] ; then
echo " Selenium Grid is up - executing tests "
break
else
echo " Waiting for the Grid. Sleeping for $wait_interval_in_seconds second(s). $time_left seconds left until timeout. "
sleep $wait_interval_in_seconds
time_left= $(( time_left - wait_interval_in_seconds ))
fi
done
if [ $SECONDS -ge $end_time ] ; then
echo " Timeout: The Grid was not started within $max_wait_time_in_seconds seconds. "
exit 1
fiExigera que
jqsoit installé viaapt-get, sinon le script continueraWaitingsans terminer l'exécution.
Remarque: si nécessaire, remplacez localhost et 4444 pour les valeurs correctes dans votre environnement. De plus, ce script intervient indéfiniment, vous voudrez peut-être le modifier et établir un délai d'attente.
Disons que la commande normale pour exécuter vos tests est mvn clean test . Voici un moyen d'utiliser le script ci-dessus et d'exécuter vos tests:
$ ./wait-for-grid.sh && mvn clean testComme cela, le script interrogera jusqu'à ce que la grille soit prête, puis vos tests commenceront.
Par défaut, l'image basée est installée libnss3-tools et initialise /home/seluser/.pki/nssdb , vous pouvez donc ajouter vos certificats sans racine. Si vous devez installer des certificats personnalisés, CA, CA intermédiaire ou certificats clients (par exemple, Enterprise Internal CA), vous pouvez créer votre propre image Docker à partir de l'image du nœud Selenium. Le navigateur basé sur le chrome utilise nssdb comme magasin de certificats. Vous pouvez ensuite installer tous les certificats internes requis dans votre dockerfile comme ceci:
Il y a un script utilitaire emballé dans l'image qui peut être utilisé pour ajouter vos certificats au magasin nssdb et au bundle ca. Le script est /opt/bin/add-cert-helper.sh .
Créez un dockerfile qui utilise l'image du nœud de sélénium comme base et copie le script dans le conteneur, et l'exécute. Par exemple, dockerfile
Si vous devez créer un ensemble de différents certificats et images de nœud. Vous pouvez créer un script bootstrap pour le faire en un seul coup. Par exemple, bootstrap.sh
L'exemple ci-dessus peut être testé avec la commande suivante:
make test_custom_ca_cert
# ./tests/customCACert/bootstrap.shVous pouvez trouver plus d'informations ici
De cette façon, les certificats seront installés et le nœud démarrera automatiquement comme auparavant.
Comme alternative, vous pouvez ajouter vos fichiers de certificat aux images de sélénium existantes. Cet exemple pratique suppose que vous avez une image connue à utiliser comme image de construction et que vous avez un moyen de publier de nouvelles images dans votre registre Docker local.
Cet exemple utilise une distribution basée sur RedHat comme image de construction (Rocky Linux) mais il peut être n'importe quelle image Linux de votre choix. Veuillez noter que l'instruction de construction variera entre les distributions. Vous pouvez vérifier les instructions d'Ubuntu dans l'exemple précédent.
L'exemple suppose également que votre CA interne est déjà dans /etc/pki/ca-trust/source/anchors/your_ca.pem , l'emplacement par défaut pour Rocky Linux. Alternativement, vous pouvez également fournir ces fichiers à partir de votre hôte et les copier dans l'image de construction.
Pour les navigateurs Chrome et Edge, la recette est la même, adaptez simplement le nom de l'image (nœud-chrome ou nœud-edge):
# Get a standard image for creating nssdb file
FROM rockylinux:8.6 as build
RUN yum install -y nss-tools
RUN mkdir -p -m755 /seluser/.pki/nssdb
&& certutil -d sql:/seluser/.pki/nssdb -N --empty-password
&& certutil -d sql:/seluser/.pki/nssdb -A -t "C,," -n YOUR_CA -i /etc/pki/ca-trust/source/anchors/YOUR_CA.pem
&& chown -R 1200:1201 /seluser
# Start from Selenium image and add relevant files from build image
FROM selenium/node-chrome:4.26.0-20241101
USER root
COPY --from=build /seluser/ /home/seluser/
USER seluser
Exemple pour Firefox:
# Get a standard image for working on
FROM rockylinux:8.6 as build
RUN mkdir -p "/distribution" "/certs" &&
cp /etc/pki/ca-trust/source/anchors/YOUR_CA*.pem /certs/ &&
echo '{ "policies": { "Certificates": { "Install": ["/opt/firefox-latest/YOUR_CA.pem"] }} }' >"/distribution/policies.json"
# Start from Selenium image and add relevant files from build image
FROM selenium/node-firefox:4.26.0-20241101
USER root
COPY --from=build /certs /opt/firefox-latest
COPY --from=build /distribution /opt/firefox-latest/distribution
USER seluser
Ce projet utilise X11VNC comme serveur VNC pour permettre aux utilisateurs d'inspecter ce qui se passe à l'intérieur du conteneur. Les utilisateurs peuvent se connecter à ce serveur de deux manières:
Le serveur VNC écoute le port 5900, vous pouvez utiliser un client VNC et vous y connecter. N'hésitez pas à cartographier le port 5900 sur n'importe quel port externe gratuit que vous souhaitez.
Le port interne 5900 reste le même car il s'agit du port configuré pour le serveur VNC fonctionnant à l'intérieur du conteneur. Vous pouvez le remplacer avec la variable d'environnement SE_VNC_PORT au cas où vous souhaitez utiliser --net=host .
Voici un exemple avec les images autonomes, le même concept s'applique aux images du nœud.
$ docker run -d -p 4444:4444 -p 5900:5900 --shm-size= " 2g " selenium/standalone-chrome:4.26.0-20241101
$ docker run -d -p 4445:4444 -p 5901:5900 --shm-size= " 2g " selenium/standalone-edge:4.26.0-20241101
$ docker run -d -p 4446:4444 -p 5902:5900 --shm-size= " 2g " selenium/standalone-firefox:4.26.0-20241101Ensuite, vous utiliseriez dans votre client VNC:
Si vous obtenez une invite pour demander un mot de passe, c'est: secret . Si vous souhaitez modifier cela, vous pouvez définir la variable d'environnement SE_VNC_PASSWORD .
Si vous souhaitez exécuter VNC sans authentification de mot de passe, vous pouvez définir la variable d'environnement SE_VNC_NO_PASSWORD=1 .
Si vous souhaitez exécuter VNC en mode visualité uniquement, vous pouvez définir la variable d'environnement SE_VNC_VIEW_ONLY=1 .
Si vous souhaitez modifier la limite du descripteur de fichiers ouvert pour le processus VNC Server, vous pouvez définir la variable d'environnement SE_VNC_ULIMIT=4096 .
Ce projet utilise Novnc pour permettre aux utilisateurs d'inspecter l'activité de conteneur visuellement avec leur navigateur. Cela peut être utile si vous ne pouvez pas installer un client VNC sur votre machine. Le port 7900 est utilisé pour démarrer Novnc, vous devrez donc vous connecter à ce port avec votre navigateur.
De façon similaire à la section précédente, n'hésitez pas à cartographier le port 7900 à n'importe quel port externe gratuit que vous souhaitez. Vous pouvez également le remplacer avec la variable d'environnement SE_NO_VNC_PORT au cas où vous souhaitez utiliser --net=host .
Voici un exemple avec les images autonomes, le même concept s'applique aux images du nœud.
$ docker run -d -p 4444:4444 -p 7900:7900 --shm-size= " 2g " selenium/standalone-chrome:4.26.0-20241101
$ docker run -d -p 4445:4444 -p 7901:7900 --shm-size= " 2g " selenium/standalone-edge:4.26.0-20241101
$ docker run -d -p 4446:4444 -p 7902:7900 --shm-size= " 2g " selenium/standalone-firefox:4.26.0-20241101Ensuite, vous utiliseriez dans votre navigateur:
Si vous obtenez une invite pour demander un mot de passe, c'est: secret .
Si vous exécutez des ressources basses ou si vous n'avez tout simplement pas besoin d'inspecter des sessions d'exécution, il est possible de ne pas exécuter du VNC du tout. Définissez simplement SE_START_VNC=false ENVIRONNEMENT Variable sur le démarrage de la grille.
Afin d'activer le traçage dans le conteneur de grille de sélénium, les commandes suivantes peuvent être exécutées:
docker network create grid
docker run -d -p 16686:16686 -p 4317:4317 --net grid --name jaeger jaegertracing/all-in-one:1.54
docker run -d -p 4442-4444:4442-4444 --net grid --name selenium-hub selenium/hub:4.26.0-20241101
docker run -d --net grid -e SE_EVENT_BUS_HOST=selenium-hub
--shm-size= " 2g "
-e SE_ENABLE_TRACING=true
-e SE_OTEL_TRACES_EXPORTER=otlp
-e SE_OTEL_EXPORTER_ENDPOINT=http://jaeger:4317
-e SE_EVENT_BUS_PUBLISH_PORT=4442
-e SE_EVENT_BUS_SUBSCRIBE_PORT=4443
selenium/node-chrome:4.26.0-20241101
docker run -d --net grid -e SE_EVENT_BUS_HOST=selenium-hub
--shm-size= " 2g "
-e SE_ENABLE_TRACING=true
-e SE_OTEL_TRACES_EXPORTER=otlp
-e SE_OTEL_EXPORTER_ENDPOINT=http://jaeger:4317
-e SE_EVENT_BUS_PUBLISH_PORT=4442
-e SE_EVENT_BUS_SUBSCRIBE_PORT=4443
selenium/node-edge:4.26.0-20241101
docker run -d --net grid -e SE_EVENT_BUS_HOST=selenium-hub
--shm-size= " 2g "
-e SE_ENABLE_TRACING=true
-e SE_OTEL_TRACES_EXPORTER=otlp
-e SE_OTEL_EXPORTER_ENDPOINT=http://jaeger:4317
-e SE_EVENT_BUS_PUBLISH_PORT=4442
-e SE_EVENT_BUS_SUBSCRIBE_PORT=4443
selenium/node-firefox:4.26.0-20241101Vous pouvez également vous référer aux fichiers YAML Docker Compose ci-dessous pour pouvoir démarrer une grille simple (ou) une grille dynamique.
Vous pouvez afficher l'interface utilisateur de Jaeger et retracer votre demande.
Par défaut, le traçage est activé dans les composants de la grille. Sans point de terminaison de l'exportateur de trace, il recherchera une instance locale, par exemple localhost/[0:0:0:0:0:0:0:1]:4117 . Dans les journaux de conteneurs, vous pouvez voir quelques lignes comme ci-dessous:
ERROR (ThrottlingLogger.dolog) Failed to export spans.
The request could not be executed. Error message: Failed to connect to localhost/[0:0:0:0:0:0:0:1]:4117
java.net.ConnectException: Failed to connect to localhost/[0:0:0:0:0:0:0:1]:4317
at okhttp3.internal.connection.RealConnection.connectSocket(RealConnection.kt:297)
at okhttp3.internal.connection. ExchangeFinder.findConnection (Exchangefinder.kt: 226)
at okhttp3.internal.connection.okhttps.internal.connection.RealConnection.connect(RealConnection.kt:207) Dans ce cas, définissez simplement SE_ENABLE_TRACING=false dans tous les conteneurs de composants pour désactiver le traçage (chaque composant exporte ses propres traces).
Toutes les sorties sont envoyées à STDOUT, afin qu'elle puisse être inspectée en fonctionnant:
$ docker logs -f < container-id | container-name >Vous pouvez augmenter la sortie du journal en passant la variable d'environnement aux conteneurs:
SE_OPTS="--log-level FINE"
--shm-size="2g" Pourquoi --shm-size 2g est-il nécessaire?
Il s'agit d'une solution de contournement connue pour éviter que le navigateur s'écrase dans un conteneur Docker, voici les problèmes documentés pour Chrome et Firefox. La taille SHM de 2 Go est arbitraire mais connue pour bien fonctionner, votre cas d'utilisation spécifique peut avoir besoin d'une valeur différente, il est recommandé de régler cette valeur en fonction de vos besoins.
Si vous voyez les exceptions de sélénium suivantes:
Message: invalid argument: can't kill an exited process
ou
Message: unknown error: Chrome failed to start: exited abnormally
ou
[DriverServiceSessionFactory.apply] - Error while creating session with the driver service. Stopping driver service: java.util.concurrent.TimeoutException
La raison pourrait être que vous avez réglé la variable d'environnement SE_START_XVFB sur false , mais oublié d'exécuter Firefox, Chrome ou Edge en mode sans tête.
Un scénario commun consiste à monter un volume dans le conteneur du navigateur afin de récupérer des fichiers téléchargés. Cela fonctionne bien dans Windows et MacOS, mais non sans solution de contournement dans Linux. Pour plus de détails, consultez ce problème bien documenté.
Par exemple, lors de l'utilisation de Linux, vous pourriez démarrer un conteneur de la manière suivante:
docker run -d -p 4444:4444 --shm-size= " 2g "
-v /home/ubuntu/files:/home/seluser/Downloads
selenium/standalone-chrome:4.26.0-20241101 Qui montera le répertoire hôte /home/ubuntu/files dans le /home/seluser/Downloads à l'intérieur du conteneur (répertoire de téléchargements du navigateur par défaut). Le problème se produit car le volume sera monté sous forme de root ; Par conséquent, le navigateur ne peut pas écrire un fichier dans ce répertoire car il s'exécute sous le seluser de l'utilisateur. Cela se produit parce que c'est ainsi que Docker monte les volumes dans Linux, plus de détails dans ce numéro.
Une solution de contournement est de créer un répertoire sur l'hôte et de modifier ses autorisations avant de monter le volume . Selon vos autorisations utilisateur, vous devrez peut-être utiliser sudo pour certaines de ces commandes:
mkdir /home/ubuntu/files
chown 1200:1201 /home/ubuntu/filesAprès cela, vous devriez pouvoir télécharger des fichiers dans le répertoire monté. Si vous avez une meilleure solution de contournement, veuillez nous envoyer une demande de traction!
Similaire aux volumes de montage pour récupérer des fichiers téléchargés. Pour les fichiers vidéo, vous devrez peut-être faire de même
mkdir /tmp/videos
chown 1200:1201 /tmp/videos
