docker selenium
4.26.0-20241101
Das Projekt wird durch freiwillige Mitwirkende ermöglicht, die Tausende von Stunden ihrer Freizeit investiert und den Quellcode unter der Apache-Lizenz 2.0 frei verfügbar gemacht haben.
Diese Docker-Images sind mit einer Handvoll Tags ausgestattet, um die Verwendung zu vereinfachen. Schauen Sie sich diese in einer unserer Versionen an.
Um Benachrichtigungen über neue Veröffentlichungen zu erhalten, fügen Sie sich selbst als „Nur Veröffentlichungen“-Beobachter hinzu.
Diese Bilder werden in der Docker Hub-Registrierung unter Selenium Docker Hub veröffentlicht.
Benötigen Sie Hilfe bei der Verwendung dieser Docker-Images? Sprechen Sie mit uns unter 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-20241101Richten Sie Ihre WebDriver-Tests auf http://localhost:4444
Das ist es!
(Optional) Um zu sehen, was im Container passiert, gehen Sie zu http://localhost:7900/?autoconnect=1&resize=scale&password=secret.
Weitere Informationen zur Visualisierung der Containeraktivität finden Sie im Abschnitt „Debugging“.
☝️ Wenn Sie docker run für ein Image ausführen, das einen Browser enthält, verwenden Sie bitte das Flag --shm-size=2g um den gemeinsam genutzten Speicher des Hosts zu verwenden.
☝️ Verwenden Sie immer ein Docker-Image mit einem vollständigen Tag, um einen bestimmten Browser und eine bestimmte Grid-Version anzuheften. Weitere Informationen finden Sie unter Tagging-Konventionen.
Ab Image-Tag-basiert 4.21.0 werden von diesem Projekt folgende Architekturen unterstützt:
| Architektur | Verfügbar |
|---|---|
| x86_64 (auch bekannt als amd64) | ✅ |
| aarch64 (auch bekannt als arm64/armv8) | ✅ |
| armhf (auch bekannt als arm32/armv7l) | ❌ |
Die folgenden Browser sind in Multi-Arch-Images verfügbar:
| Architektur | Chrom | Chrom | Firefox | Rand |
|---|---|---|---|---|
| x86_64 (auch bekannt als amd64) | ✅ | ✅ | ✅ | ✅ |
| aarch64 (auch bekannt als arm64/armv8) | ❌ | ✅ | ✅ | ❌ |
| armhf (auch bekannt als arm32/armv7l) | ❌ | ❌ | ❌ | ❌ |
Notiz:
Google erstellt Chrome ( google-chrome ) nicht für Linux/ARM-Plattformen. Daher sind die Chrome-Images (Knoten und Standalone) nur für AMD64 verfügbar. Ebenso erstellt Microsoft kein Edge ( microsoft-edge ) für Linux/ARM-Plattformen.
Aufgrund von Leistungs- und Stabilitätsproblemen wird die Ausführung eines AMD64-Images unter Emulation auf einer ARM64-Plattform nicht empfohlen.
Verwenden Sie für Linux/ARM den Open-Source-Chromium-Browser. Die Chromium-Images (Knoten und Standalone) sind in Multi-Arch verfügbar.
$ docker run --rm -it -p 4444:4444 -p 5900:5900 -p 7900:7900 --shm-size 2g selenium/standalone-chromium:latestMulti-Arch-Images werden auf CircleCI mit der Ressourcenklasse Linux/ARM64 getestet. Sehen Sie sich den Status unten an.
Für experimentelle Docker-Container-Images, die auf Plattformen wie der Apple M-Serie oder Raspberry Pi laufen, stellt das Repository unter seleniumhq-community/docker-seleniarm Images bereit, die in der Seleniarm Docker Hub-Registrierung veröffentlicht werden.
Weitere Informationen zu diesen Bildern finden Sie in Ausgabe Nr. 1076.
Jetzt wurde der Fork seleniumhq-community/docker-seleniarm zusammengeführt.
Wir empfehlen, die experimentelle Funktion Containerd Image Store in der Docker Engine zu aktivieren. containerd versteht Multiplattform-Images, bei denen ein einzelnes Image-Tag auf verschiedene Varianten verweisen kann, die eine Reihe von Betriebssystem- und Hardwarearchitekturen abdecken. Es vereinfacht den Prozess der Erstellung, Speicherung und Verteilung von Bildern auf verschiedenen Plattformen.
Ein einziger Befehl zum Aktivieren dieser Funktion in der Docker Engine:
make set_containerd_image_storeFühren Sie den folgenden Befehl aus, um alle Images für Multiplattform zu erstellen:
PLATFORMS=linux/amd64,linux/arm64 make buildUm die Images für eine bestimmte Plattform zu erstellen, führen Sie den folgenden Befehl aus:
PLATFORMS=linux/arm64 make build Ohne Angabe der PLATFORMS Variable werden die Bilder standardmäßig für die linux/amd64 -Plattform erstellt.
Nightly-Images basieren auf dem Nightly-Build des Upstream-Projekts Selenium mit den neuesten Änderungen am Hauptzweig in diesem Repository. Das Bild-Tag ist nightly . Es wird nicht empfohlen, Bilder in der Produktion zu verwenden. Es dient nur zu Testzwecken.
$ docker run -d -p 4442-4444:4442-4444 --name selenium-hub selenium/hub:nightlySchauen Sie sich Docker Compose an, um mit den Nightly-Bildern docker-compose-v3-full-grid-nightly.yml zu beginnen
Um Tests durchzuführen oder anderweitig mit Browsern vor der Veröffentlichung zu arbeiten, unterhalten Google, Mozilla und Microsoft einen Dev- und Beta-Release-Kanal für diejenigen, die sehen möchten, was bald für die breite Öffentlichkeit veröffentlicht wird.
Hier sind die Anweisungen, um sie im Standalone-Modus auszuführen:
Chrome-Beta:
$ docker run --rm -it -p 4444:4444 -p 7900:7900 --shm-size 2g selenium/standalone-chrome:betaChrome-Entwickler:
$ docker run --rm -it -p 4444:4444 -p 7900:7900 --shm-size 2g selenium/standalone-chrome:devFirefox-Beta:
$ docker run --rm -it -p 4444:4444 -p 7900:7900 --shm-size 2g selenium/standalone-firefox:betaFirefox-Entwickler:
$ docker run --rm -it -p 4444:4444 -p 7900:7900 --shm-size 2g selenium/standalone-firefox:devEdge-Beta:
$ docker run --rm -it -p 4444:4444 -p 7900:7900 --shm-size 2g selenium/standalone-edge:betaEdge-Entwickler:
$ 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 "Weitere Informationen zu den Dev- und Beta-Channel-Container-Images finden Sie im Blogbeitrag zu Dev- und Beta-Channel-Browsern über Docker Selenium.
Firefox
docker run -d -p 4444:4444 --shm-size= " 2g " selenium/standalone-firefox:4.26.0-20241101Chrom
docker run -d -p 4444:4444 --shm-size= " 2g " selenium/standalone-chrome:4.26.0-20241101Rand
docker run -d -p 4444:4444 --shm-size= " 2g " selenium/standalone-edge:4.26.0-20241101 Hinweis: Auf Port 4444 kann jeweils nur ein Standalone-Container laufen.
Es gibt verschiedene Möglichkeiten, die Bilder auszuführen und ein Raster mit einem Hub und Knoten zu erstellen. Überprüfen Sie die folgenden Optionen.
Der Hub und die Knoten werden im selben Netzwerk erstellt und erkennen sich gegenseitig an ihrem Containernamen. Als erster Schritt muss ein Docker-Netzwerk erstellt werden.
$ 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 - 20241101Wenn Sie mit der Verwendung des Grids fertig sind und die Container beendet wurden, kann das Netzwerk mit dem folgenden Befehl entfernt werden:
# Removes the grid network
$ docker network rm gridDer Hub und die Knoten werden auf verschiedenen Maschinen/VMs erstellt. Sie müssen die IPs der anderen kennen, um ordnungsgemäß kommunizieren zu können. Wenn mehr als ein Knoten auf derselben Maschine/VM ausgeführt wird, müssen sie so konfiguriert werden, dass sie unterschiedliche Ports verfügbar machen.
$ 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 ist die einfachste Möglichkeit, ein Grid zu starten. Nutzen Sie die unten verlinkten Ressourcen, speichern Sie sie lokal und überprüfen Sie die Ausführungsanweisungen oben in jeder Datei.
docker-compose-v2.yml
docker-compose-v3.yml
Um das Grid zu stoppen und die erstellten Container zu bereinigen, führen Sie docker compose down aus.
docker-compose-v3-swarm.yml
Es ist möglich, ein Selenium Grid mit allen seinen Komponenten zu starten. Der Einfachheit halber wird nur ein Beispiel mit Docker Compose bereitgestellt. Speichern Sie die Datei lokal und überprüfen Sie die Ausführungsanweisungen darüber.
docker-compose-v3-full-grid.yml
| Umgebungsvariable | Option | Typ | Standardwert | Beschreibung |
|---|---|---|---|---|
SE_REJECT_UNSUPPORTED_CAPS | --reject-unsupported-caps | Boolescher Wert | false | Ermöglichen Sie dem Distributor, eine Anfrage sofort abzulehnen, wenn das Grid die angeforderte Funktion nicht unterstützt. |
SE_HEALTHCHECK_INTERVAL | --healthcheck-interval | int | 120 | Dadurch wird sichergestellt, dass der Server nach einem bestimmten Intervall alle Knoten erfolgreich anpingen kann. |
Die Testausführung kann mithilfe des Docker-Images selenium/video:ffmpeg-7.1-20241101 aufgezeichnet werden. Für jeden Container, in dem ein Browser ausgeführt wird, wird ein Container benötigt. Das heißt, wenn Sie 5 Knoten/Standalone-Container ausführen, benötigen Sie 5 Videocontainer, die Zuordnung ist 1:1.
Derzeit ist die einzige Möglichkeit, diese Zuordnung manuell vorzunehmen (entweder manuelles Starten der Container oder über docker compose ). Wir wiederholen diesen Prozess und wahrscheinlich wird dieser Aufbau in Zukunft einfacher sein.
Das von uns bereitgestellte Video-Docker-Image basiert auf dem ffmpeg-Ubuntu-Image, das vom jrottenberg/ffmpeg-Projekt bereitgestellt wird. Vielen Dank, dass Sie dieses Image bereitgestellt und unsere Arbeit vereinfacht haben?
Ab Image-Tag-basiert 4.20.0 basiert das Video-Docker-Image auf dem FFmpeg-Ubuntu-Image, das vom Projekt linuxserver/docker-ffmpeg bereitgestellt wird, da das Image für mehrere Plattformen verfügbar ist. Vielen Dank, dass Sie unser Projekt vereinfacht und uns mit der Unterstützung mehrerer Architekturen dabei geholfen haben, voranzukommen.
Hinweise :
/videos im Videocontainer gespeichert. Ordnen Sie ein lokales Verzeichnis zu, um die Videos abzurufen.FILE_NAME überschreiben, um unerwartete Ergebnisse zu vermeiden.Dieses Beispiel zeigt, wie die Container manuell gestartet werden:
$ 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 Nachdem die Container gestoppt und entfernt wurden, sollte im Verzeichnis /tmp/videos Ihres Computers eine Videodatei angezeigt werden.
Hier ist ein Beispiel mit einem Hub und einigen Knoten:
docker-compose-v3-video.yml
Basierend auf der Unterstützung von Metadaten in Tests. Wenn der Videorecorder mit dem Browserknoten als Sidecar bereitgestellt wird, SE_VIDEO_FILE_NAME=auto aktiviert ist und Metadaten zu Ihren Tests hinzugefügt werden, extrahiert der Videodateiname den Wert der Funktion se:name und verwendet ihn als Videodateinamen.
Zum Beispiel in der Python-Bindung:
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 () Der Name der Ausgabevideodatei lautet test_visit_basic_auth_secured_page_ChromeTests_<sessionId>.mp4 .
Wenn Ihr Testname vom Test-Framework verarbeitet wird und er mit Sicherheit eindeutig ist, können Sie auch das Anhängen der Sitzungs-ID an den Videodateinamen deaktivieren, indem Sie SE_VIDEO_FILE_NAME_SUFFIX=false festlegen.
Der Dateiname wird auf 255 Zeichen gekürzt, um lange Dateinamen zu vermeiden. Darüber hinaus werden space durch _ ersetzt und nur die Zeichen Alphabete, Zahlen, - (Bindestrich) und _ (Unterstrich) bleiben im Dateinamen erhalten.
Der Trimm-Regex kann durch Festlegen der Umgebungsvariablen SE_VIDEO_FILE_NAME_TRIM_REGEX angepasst werden. Der Standardwert ist [:alnum:]-_ . Der reguläre Ausdruck sollte mit dem tr -Befehl in Bash kompatibel sein.
Auf Bereitstellungsebene ist der Recorder-Container immer aktiv. Darüber hinaus können Sie den Videoaufzeichnungsprozess über die Sitzungsfunktion se:recordVideo deaktivieren. Zum Beispiel in der Python-Bindung:
options . set_capability ( 'se:recordVideo' , False ) Im Rekorder-Container wird eine Abfrage von GraphQL im Hub basierend auf der Knoten-Sitzungs-ID durchgeführt und der Wert von se:recordVideo in den Funktionen extrahiert, bevor entschieden wird, ob der Videoaufzeichnungsprozess gestartet werden soll oder nicht.
Hinweise: Um den GraphQL-Endpunkt zu erreichen, muss der Recorder-Container die Hub-URL kennen. Die Hub-URL kann über die Umgebungsvariable SE_NODE_GRID_URL übergeben werden. Beispielsweise ist SE_NODE_GRID_URL http://selenium-hub:4444 .
RCLONE ist im Videorecorder-Image installiert. Sie können damit die Videos auf einen Cloud-Speicherdienst hochladen. Neben der oben erwähnten Videoaufzeichnung können Sie die Upload-Funktionalität aktivieren, indem Sie die folgenden Umgebungsvariablen festlegen:
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 verwendet die Sitzungs-ID als Namen der Videodatei. Dadurch wird sichergestellt, dass der Name der Videodatei beim Hochladen eindeutig ist. Die Erstellung des Videodateinamens erfolgt automatisch basierend auf dem Knotenendpunkt /status (und dem optionalen GraphQL-Endpunkt), um Sitzungs-ID und Funktionen zu erhalten.
SE_VIDEO_UPLOAD_ENABLED=true aktiviert die Video-Upload-Funktion. Im Hintergrund wird eine Pipedatei mit Datei und Ziel erstellt, die der Uploader nutzen und fortfahren kann.
SE_VIDEO_INTERNAL_UPLOAD=true verwendet RCLONE, das im Container zum Hochladen installiert ist. Wenn Sie einen anderen Sidecar-Container zum Hochladen verwenden möchten, setzen Sie ihn auf false .
| ENV-Variablen pro Modus | Hub/Knoten | Eigenständige Rollen | Dynamisches Raster |
|---|---|---|---|
SE_VIDEO_RECORD_STANDALONE (obligatorisch) | false (Standard) | true | true |
DISPLAY_CONTAINER_NAME (erforderlich) | Benutzereingaben | Benutzereingaben | (nicht erforderlich) |
SE_NODE_PORT (optional) | 5555 | 4444 | (nicht erforderlich) |
SE_NODE_GRID_URL (optional) | Benutzereingaben | (nicht erforderlich) | (nicht erforderlich) |
Bei Umgebungsvariablen mit dem Präfix wird RCLONE_ verwendet, um die Remote-Konfiguration an RCLONE zu übergeben. Weitere Informationen zur RCLONE-Konfiguration finden Sie hier. Bei Verwendung in Dynamic Grid sollten diese Variablen mit dem Präfix SE_ kombiniert werden, zum Beispiel SE_RCLONE_ . Weitere Einzelheiten finden Sie in der folgenden Referenz.
Konfigurieren Sie die Videoaufzeichnung und das Hochladen für Hub und Knoten: docker-compose-v3-video-upload.yml
Konfigurieren Sie die Videoaufzeichnung und das Hochladen für Standalone-Rollen: docker-compose-v3-video-upload-standalone.yml
Konfigurieren Sie die Videoaufzeichnung und das Hochladen für Dynamic Grid (node-docker): docker-compose-v3-video-upload-dynamic-grid.yml
Konfigurieren Sie die Videoaufzeichnung und das Hochladen für Dynamic Grid Standalone (standalone-docker): tests/docker-compose-v3-test-standalone-docker.yaml
| Umgebungsvariable | Standardwert | Beschreibung |
|---|---|---|
SE_UPLOAD_RETAIN_LOCAL_FILE | false | Behalten Sie die lokale Datei nach erfolgreichem Hochladen bei |
SE_UPLOAD_COMMAND | copy | Der RCLONE-Befehl wird zum Übertragen der Datei verwendet. move erzwingen, wenn lokale Datei beibehalten“ ist false |
SE_UPLOAD_OPTS | -P --cutoff-mode SOFT --metadata --inplace | Weitere Optionen, die zum RCLONE-Befehl gehören, können festgelegt werden. |
SE_UPLOAD_CONFIG_FILE_NAME | upload.conf | Konfigurationsdatei für Remote-Host, anstatt über das Env-Variablenpräfix SE_RCLONE_* festgelegt zu werden |
SE_UPLOAD_CONFIG_DIRECTORY | /opt/bin | Verzeichnis der Konfigurationsdatei (ändern Sie es, wenn die Konfigurationsdatei in einem anderen Verzeichnis gemountet wird) |
Grid 4 verfügt über die Möglichkeit, Docker-Container bei Bedarf zu starten. Dies bedeutet, dass für jede neue Sitzungsanforderung ein Docker-Container im Hintergrund gestartet wird, der Test dort ausgeführt wird und der Container nach Abschluss des Tests verworfen wird.
Dieser Ausführungsmodus kann entweder in der Standalone- oder Node-Rolle verwendet werden. Dem „dynamischen“ Ausführungsmodus muss mitgeteilt werden, welche Docker-Images beim Start der Container verwendet werden sollen. Darüber hinaus muss das Grid den URI des Docker-Daemons kennen. Diese Konfiguration kann in einer lokalen toml Datei abgelegt werden.
Sie können diese Datei lokal speichern und sie beispielsweise config.toml benennen.
[ 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 appr
