Docker Selen
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 Debuggen.
☝️ 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 alle Knoten nach einem bestimmten Intervall 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_ .
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 von Videodateinamen erfolgt automatisch basierend auf Knotenendpunkt /status (und optionalem 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) |
Für 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 der 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 appropriate values # [server] # host =# port =
Mit dem optionalen Konfigurationsschlüssel host-config-keys im Abschnitt [docker] in einer config.toml-Datei (oder der CLI-Option --docker-host-config-keys). Benutzer können eine Liste von Docker-Host-Konfigurationsschlüsseln angeben, die an Browser-Container übergeben werden sollen.
Gültige Schlüsselnamen für die Docker-Hostkonfiguration finden Sie in der Docker-API-Dokumentation oder über den Befehl docker inspect the node-docker container.
Falls Sie über die Volume-Konfiguration des Dynamic Grid-Containers auf das Download-Verzeichnis in Knoten-Browser-Containern (z. B. /home/seluser/Downloads ) zugreifen möchten, können Sie die folgende Konfiguration zur Datei config.toml hinzufügen
[ docker ]
host-config-keys = [ " Binds " ]Volumes-Konfiguration in der Docker-Compose-Datei
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 ist der Standardpfad für die Konfigurationsdatei in allen Bildern. Sobald die Volume-Konfiguration für Node-Browser-Container freigegeben ist, kann die Datei config.toml durch die Node-Docker-Container-Konfigurationsdatei überschrieben werden.
Hängen Sie in diesem Fall Ihre config.toml Datei unter /opt/selenium/docker.toml im Node-Docker-Container ein. Und legen Sie die Umgebungsvariable SE_NODE_DOCKER_CONFIG_FILENAME=docker.toml fest, um den Namen der Konfigurationsdatei für das Startskript anzugeben.
Siehe Beispiel docker-compose-v3-test-node-docker.yaml
Dies kann zu einer vollständigen Grid-Bereitstellung erweitert werden, bei der alle Komponenten einzeln bereitgestellt werden. Die Gesamtidee besteht darin, den Hub in einer virtuellen Maschine und jeden der Knoten in separaten und leistungsstärkeren virtuellen Maschinen zu haben.
$ 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 Um die Assets auf Ihrem Host zu speichern, mounten Sie bitte Ihren Host-Pfad unter /opt/selenium/assets .
Wenn 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 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 Füllen Sie den Abschnitt [server] in der Datei config.toml aus.
[ 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>
Um die Assets auf Ihrem Host zu speichern, mounten Sie bitte Ihren Hostpfad in /opt/selenium/assets .
Hier ist ein Beispiel mit einem Hub und einem Knoten:
docker-compose-v3-dynamic-grid.yml
Container können über Umgebungsvariablen wie SE_NODE_SESSION_TIMEOUT und SE_OPTS weiter konfiguriert werden. Wenn ein untergeordneter Container erstellt wird, werden alle Umgebungsvariablen mit dem Präfix SE_ weitergeleitet und im Container festgelegt. Sie können die gewünschten Umgebungsvariablen in den standalone-docker oder node-docker Containern festlegen. Im folgenden Beispiel wird das Sitzungszeitlimit für alle Sitzungen auf 700 Sekunden festgelegt:
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 Um Ihre WebDriver-Sitzung aufzuzeichnen, müssen Sie ein se:recordVideo Feld hinzufügen, das auf true gesetzt ist. Sie können auch eine Zeitzone und eine Bildschirmauflösung festlegen, zum Beispiel:
{
"browserName" : " firefox " ,
"platformName" : " linux " ,
"se:recordVideo" : " true " ,
"se:timeZone" : " US/Pacific " ,
"se:screenResolution" : " 1920x1080 "
} Nachdem Sie einen Test ausgeführt haben, überprüfen Sie den Pfad, den Sie zum Docker-Container bereitgestellt haben ( ${PWD}/assets ), und Sie sollten Videos und Sitzungsinformationen sehen.
Über Sprachbindungen können Sie die se:name Funktion festlegen, um den Namen der Ausgabevideodatei dynamisch zu ändern. 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: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 () Nachdem der Test ausgeführt wurde, können Sie unter ( ${PWD}/assets ) den Namen der Videodatei im Pfad / sehen
Der Dateiname wird auf 255 Zeichen gekürzt, um lange Dateinamen zu vermeiden. Darüber hinaus wird das space durch _ ersetzt und nur die Zeichen Alphabete, Zahlen, - (Bindestrich) und _ (Unterstrich) bleiben im Dateinamen erhalten. (Dieses Kunststück ist verfügbar, sobald diese PR zusammengeführt wurde)
tzdata wird in basierten Images installiert und Sie können die Zeitzone im Container mithilfe der env-Variablen TZ festlegen. Standardmäßig ist die Zeitzone auf UTC eingestellt. Eine Liste der unterstützten Zeitzonen finden Sie hier. Zum Beispiel:
$ docker run --rm --entrypoint= " " -e TZ=Asia/Ho_Chi_Minh selenium/node-chromium:latest date +%FT%T%Z
2024-08-28T18:19:26+07Wir bieten ein Helm-Chart zur Bereitstellung dieser Docker-Images auf Kubernetes an. Weitere Details finden Sie in der Helm-Readme-Datei.
Sie können die Variable SE_OPTS mit zusätzlichen Befehlszeilenparametern zum Starten eines Hubs oder Knotens übergeben.
$ docker run -d -p 4444:4444 -e SE_OPTS= " --log-level FINE " --name selenium-hub selenium/hub:4.26.0-20241101 Sie können die Umgebungsvariable SE_JAVA_OPTS an den Java-Prozess übergeben.
$ docker run -d -p 4444:4444 -e SE_JAVA_OPTS=-Xmx512m --name selenium-hub selenium/hub:4.26.0-20241101Anstatt Argumente über die Browseroptionen aus Sprachbindungen hinzuzufügen, zum Beispiel:
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" ) Sie können auch proaktiv die Anwendung von Argumenten direkt aus Containerumgebungsvariablen (Knoten, Standalone oder Knoten-Docker) erzwingen. Definieren Sie die Umgebungsvariable mit einem Namen, der mit SE_BROWSER_ARGS_ beginnt, und folgen Sie dem Konfigurationsschlüssel. Es liegt an Ihnen (stellen Sie sicher, dass diese eindeutig sind, wenn Sie mehrere Argumente definieren). Zum Beispiel:
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:latestListen Sie die Chromium-Befehlszeilenargumente als Referenz auf.
Hinweis: Derzeit gilt dies für die Knotenbrowser Chrome/Chromium und Edge.
Die Knoten registrieren sich über den Event Bus. Wenn das Grid in seiner typischen Hub/Knoten-Konfiguration gestartet wird, fungiert der Hub als Event-Bus, und wenn das Grid mit allen fünf Elementen getrennt gestartet wird, läuft der Event-Bus eigenständig.
In beiden Fällen ist es notwendig, dem Knoten mitzuteilen, wo sich der Event Bus befindet, damit er sich registrieren kann. Das ist der Zweck der Umgebungsvariablen SE_EVENT_BUS_HOST , SE_EVENT_BUS_PUBLISH_PORT und SE_EVENT_BUS_SUBSCRIBE_PORT .
In einigen Fällen, beispielsweise wenn Sie einen Knoten markieren möchten, kann es erforderlich sein, der Knotenkonfiguration ein benutzerdefiniertes Stereotyp bereitzustellen. Die Umgebungsvariable SE_NODE_STEREOTYPE legt den Stereotypeneintrag in der config.toml des Knotens fest. Eine Beispieldatei für die Datei config.toml finden Sie hier: Benutzerdefinierte Funktionen für die Zuordnung bestimmter Knoten festlegen.
Hier ist ein Beispiel mit den Standardwerten dieser Umgebungsvariablen:
$ 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-20241101Weiterleiten von Befehlen an einen Dienstendpunkt, der WebDriver unterstützt. Es ist sinnvoll, einen externen Dienst, der WebDriver unterstützt, mit Selenium Grid zu verbinden. Ein Beispiel für einen solchen Dienst könnte ein Cloud-Anbieter oder ein Appium-Server sein. Auf diese Weise kann Grid eine größere Abdeckung für Plattformen und Versionen ermöglichen, die lokal nicht vorhanden sind.
Im Folgenden finden Sie ein Beispiel für Konfigurationsrelaisbefehle.
docker-compose-v3-test-node-relay.yml
Wenn Sie nur Befehle weiterleiten möchten, ist selenium/node-base für diesen Zweck geeignet und leichtgewichtig. Falls Sie den Knoten sowohl mit Browsern als auch mit Relay-Befehlen konfigurieren möchten, können entsprechende Knotenbilder verwendet werden.
Um Umgebungsvariablen zum Generieren von Relay-Konfigurationen zu verwenden, legen Sie SE_NODE_RELAY_URL und andere Variablen wie unten fest
[ 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}"} ' ]Um einen Beispieltest mit dem weitergeleiteten Knoten auszuführen, können Sie das Projekt klonen und den folgenden Befehl ausprobieren:
make test_node_relay Standardmäßig ist Selenium unter http://127.0.0.1:4444/ erreichbar. Selenium kann für die Verwendung eines benutzerdefinierten Unterpfads konfiguriert werden, indem die Umgebungsvariable SE_SUB_PATH angegeben wird. Im folgenden Beispiel ist Selenium unter http://127.0.0.1:4444/selenium-grid/ erreichbar.
$ docker run -d -p 4444:4444 -e SE_SUB_PATH=/selenium-grid/ --name selenium-hub selenium/hub:4.26.0-20241101 Standardmäßig beginnen Knoten mit einer Bildschirmauflösung von 1920 x 1080 mit einer Farbtiefe von 24 Bit und einer DPI von 96. Diese Einstellungen können durch Angabe der Umgebungsvariablen SE_SCREEN_WIDTH , SE_SCREEN_HEIGHT , SE_SCREEN_DEPTH und/oder SE_SCREEN_DPI beim Starten des Containers angepasst werden.
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 In einigen Anwendungsfällen müssen Sie möglicherweise die Grid-URL auf den Knoten festlegen, beispielsweise wenn Sie auf den BiDi/CDP-Endpunkt zugreifen möchten. Dies ist auch erforderlich, wenn Sie das neue RemoteWebDriver.builder() oder Augmenter() verwenden möchten, das in Selenium 4 vorhanden ist (da diese die BiDi/CDP-Verbindung implizit einrichten). Sie können dies über die Umgebungsvariable SE_NODE_GRID_URL tun, z. B. -e SE_NODE_GRID_URL=http:// . Das Festlegen dieser Umgebungsvariable ist erforderlich, wenn Sie die Live-Ansicht während der Ausführung von Sitzungen sehen möchten.
Grid hat ein standardmäßiges Sitzungszeitlimit von 300 Sekunden, wobei die Sitzung in einem veralteten Zustand bleiben kann, bis sie beendet wird. Sie können SE_NODE_SESSION_TIMEOUT verwenden, um diesen Wert in Sekunden zu überschreiben.
Eine neue Sitzungsanforderung wird vor der Verarbeitung in die Sitzungswarteschlange gestellt und bleibt in der Warteschlange, bis auf allen registrierten Knoten ein passender Slot gefunden wird. Allerdings kann es bei der neuen Sitzungsanforderung zu einer Zeitüberschreitung kommen, wenn kein Slot gefunden wurde. Standardmäßig bleibt eine Anfrage bis zu 300 Sekunden in der Warteschlange, bevor ein Timeout erreicht wird. Darüber hinaus wird alle 5 Sekunden versucht, die Anfrage zu verarbeiten (standardmäßig).
Es ist möglich, diese Werte durch Umgebungsvariablen im Hub und in der SessionQueue ( SE_SESSION_REQUEST_TIMEOUT und SE_SESSION_RETRY_INTERVAL ) zu überschreiben. Ein Timeout von 500 Sekunden wäre beispielsweise SE_SESSION_REQUEST_TIMEOUT=500 und ein Wiederholungsintervall von 2 Sekunden wäre SE_SESSION_RETRY_INTERVAL=2 .
Standardmäßig ist über die Umgebungsvariable SE_NODE_MAX_SESSIONS nur eine Sitzung für die Ausführung pro Container konfiguriert. Es ist möglich, diese Anzahl bis zur maximal verfügbaren Prozessorzahl zu erhöhen, da mehr Stabilität erreicht wird, wenn ein Container/Browser über 1 CPU läuft.
Wenn Sie jedoch die Leistung gemessen haben und auf dieser Grundlage der Meinung sind, dass in jedem Container mehr Sitzungen ausgeführt werden können, können Sie die maximale Grenze außer Kraft setzen, indem Sie sowohl SE_NODE_MAX_SESSIONS auf eine gewünschte Zahl als auch SE_NODE_OVERRIDE_MAX_SESSIONS auf true setzen. Es wird jedoch nicht empfohlen, mehr Browsersitzungen auszuführen, als die verfügbaren Prozessoren umfassen, da dies zu einer Überlastung der Ressourcen führen würde.
Das Überschreiben dieser Einstellung hat einen unerwünschten Nebeneffekt, wenn die Videoaufzeichnung aktiviert ist, da möglicherweise mehr als eine Browsersitzung im selben Video erfasst wird.
Firefox, Chrome, Bei Verwendung des Headless-Modus muss der Xvfb-Server nicht gestartet werden.
Um das Starten des Servers zu vermeiden, können Sie die Umgebungsvariable SE_START_XVFB auf false (oder einen anderen Wert als true ) setzen, zum Beispiel:
$ 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-20241101Weitere Informationen finden Sie in diesem GitHub-Problem.
Angemerkt:
SE_START_XVFB auf true gesetzt werden, um im Modus --headless=new ausgeführt zu werden. In manchen Umgebungen wie Docker Swarm oder Kubernetes ist es sinnvoll, den Node- oder Standalone-Container herunterzufahren, nachdem N Tests ausgeführt wurden. Dies kann beispielsweise in Kubernetes verwendet werden, um den Pod zu beenden und dann nach N Sitzungen einen neuen zu skalieren. Setzen Sie die Umgebungsvariable SE_DRAIN_AFTER_SESSION_COUNT auf einen Wert größer als Null, um dieses Verhalten zu aktivieren.
$ docker run -e SE_DRAIN_AFTER_SESSION_COUNT=5 --shm-size= " 2g " selenium/standalone-firefox:4.26.0-20241101Mit dem vorherigen Befehl wird der Standalone-Container heruntergefahren, nachdem 5 Sitzungen ausgeführt wurden.
Bei lang laufenden Containern kann es vorkommen, dass Browser einige Reste hinterlassen. Dabei kann es sich um blockierte Browserprozesse von Jobs handeln, die bereits abgeschlossen wurden, den Browser aber nicht vollständig stoppen konnten, oder um temporäre Dateien, die in das /tmp -Dateisystem geschrieben wurden (insbesondere bei Chrome-basierten Browsern). Um zu vermeiden, dass dadurch Ressourcen wie Prozess-IDs und Dateisystemnutzung im Container aufgefüllt werden, wird in den Knotencontainern stündlich ein automatisches Bereinigungsskript ausgeführt. Dadurch werden alte Prozesse und alte temporäre Dateien bereinigt. Standardmäßig ist dies deaktiviert. Wenn diese Option aktiviert ist, werden Browser, die länger als 2 Stunden laufen, und Dateien, die älter als 1 Tag sind, bereinigt. Diese können mit den folgenden Umgebungsvariablen aktiviert und optimiert werden:
SE_ENABLE_BROWSER_LEFTOVERS_CLEANUP : Standardwert false , auf true gesetzt, um die Bereinigung zu aktivieren.SE_BROWSER_LEFTOVERS_INTERVAL_SECS : Standardwert 3600 (1 Stunde), Bereinigungsintervall in Sekunden.SE_BROWSER_LEFTOVERS_PROCESSES_SECS : Standardwert 7200 (2 Stunden), Browser, die länger als diese Zeit laufen, werden beendet.SE_BROWSER_LEFTOVERS_TEMPFILES_DAYS : Standardwert 1 (1 Tag), von Chrome-basierten Browsern in /tmp generierte Dateien werden nach dieser Anzahl von Tagen entfernt (wird bei Verwendung von Firefox ignoriert). Wenn Sie Selenium für Sitzungen mit langer Laufzeit verwenden und damit rechnen, dass Browser länger als 2 Stunden laufen, setzen Sie SE_ENABLE_BROWSER_LEFTOVERS_CLEANUP entweder nicht auf true (belassen Sie den Standardwert false ) oder passen Sie SE_BROWSER_LEFTOVERS_PROCESSES_SECS an, um einen Wert festzulegen, der höher ist als Ihre erwartete Langzeitsitzung. Ausführen von Browserprozessen.
$ docker run -e SE_ENABLE_BROWSER_LEFTOVERS_CLEANUP=true --shm-size= " 2g " selenium/node-chrome:4.26.0-20241101Mit dem vorherigen Befehl wird die Bereinigung mit den Standardzeiten aktiviert.
$ 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-20241101Mit dem vorherigen Befehl wird die Bereinigung aktiviert, aber alle 2 Stunden (statt 1) ausgeführt, beendet Browser, die länger als 1 Stunde laufen (statt 2 Stunden), und entfernt temporäre Dateien, die älter als 2 Tage sind (statt). 1).
Einige ausgegebene Variablen wie Passwort, Geheimnis usw. werden in Konsolenprotokollen maskiert. Zu Debugzwecken können Sie es deaktivieren, indem Sie SE_MASK_SECRETS auf false setzen
Beim Erstellen eines Bash-Skripts können Sie die Ausgabe maskieren, indem Sie die Syntax echo "Current value is $(mask ${YOUR_VARIABLE}) verwenden.
Der Standardwert SE_MASK_SECRETS_MIN_LENGTH ist 3 . Dies bedeutet, dass eine lange Zeichenfolge mit *** maskiert wird, um zu vermeiden, dass die Länge einem Brute-Force-Angriff ausgesetzt wird.
Standardmäßig sind selbstsignierte Standardzertifikate im Image unter /opt/selenium/secrets Includes verfügbar
server.jks : Truststore-Datei, die beim Starten des Servers über die Systemeigenschaft javax.net.ssl.trustStore für JVM konfiguriert werden soll.server.pass : Die Datei enthält das Truststore-Passwort für JVM über die Systemeigenschaft javax.net.ssl.trustStorePassword .tls.crt : Das Serverzertifikat für die https-Verbindung ist auf die Selenium-Option --https-certificate gesetzt.tls.key : Der private Serverschlüssel (im PKCS8-Format) für die https-Verbindung ist auf die Selenium-Option --https-private-key gesetzt.Es gibt Umgebungsvariablen zum Konfigurieren der sicheren Verbindung:
| Umgebungsvariablen | Standard | Option von | Beschreibung |
|---|---|---|---|
| SE_ENABLE_TLS | false | Aktivieren Sie eine sichere Verbindung mit Standardkonfigurationen | |
| 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 | Deaktivieren Sie die Hostprüfungen für Komponenten intern |
| SE_HTTPS_CERTIFICATE | /opt/selenium/secrets/tls.crt | Selen | Stellen Sie die CLI-Option --https-certificate ein |
| SE_HTTPS_PRIVATE_KEY | /opt/selenium/secrets/tls.key | Selen | Stellen Sie die CLI-Option --https-private-key |
Per Volume Mount können Sie die Standardzertifikate durch Ihre eigenen Zertifikate ersetzen.
Das selbstsignierte Zertifikat muss auch vom Client als vertrauenswürdig eingestuft werden (fügen Sie eine vertrauenswürdige Zertifizierungsstelle hinzu, die im System weit verbreitet ist), um Fehlermeldungen im Zusammenhang mit dem SSL-Handshake beim Erstellen von RemoteWebDriver zu vermeiden.
Siehe Beispiel: docker-compose-v3-full-grid-secure.yml
Verschiedene Browser bieten unterschiedliche Möglichkeiten, die Sprache und das Gebietsschema über die Bindung festzulegen.
Firefox kann für die Verwendung einer bestimmten Sprache und eines bestimmten Gebietsschemas konfiguriert werden, indem beim Erstellen von WebDriver aus der Bindung die Profileinstellung festgelegt wird. Darüber hinaus muss das Sprachpaket als Add-on installiert werden, damit die Sprache der Browser-Benutzeroberfläche wirksam wird. Um beispielsweise die Browsersprache und das Gebietsschema auf vi-VN festzulegen, können Sie die folgenden Schritte ausführen:
Holen Sie sich das neueste Firefox-Sprachpaket für die gewünschte Sprache, z. B. https://download.mozilla.org/?product=firefox-langpack-latest-SSL&lang=vi. Anschließend können Sie das Sprachpaket als Add-on installieren, wenn Sie die RemoteWebDriver-Instanz erstellen.
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' )Es gibt ein Skript, um alle verfügbaren Sprachpakete für eine bestimmte Firefox-Version abzurufen. Sie können das Skript ausführen, um die Sprachpakete in Ihre Quelle zu übertragen. Zum Beispiel:
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 Oder Sie können das Containerverzeichnis /home/seluser/firefox/distribution/extensions im Hostverzeichnis bereitstellen, um auf Pakete zuzugreifen, die im Container vorab erstellt wurden, um sie in Ihrem Testskript zu verwenden.
Supervisor wird zum Verwalten von Prozessen und Protokollen im Container verwendet. Einige Konfigurationen für supervisord können über Umgebungsvariablen wie folgt festgelegt werden:
| Umgebungsvariablen | Standard | supervisord Konfiguration |
|---|---|---|
| SE_SUPERVISORD_LOG_LEVEL | info | supervisord.loglevel |
| SE_SUPERVISORD_CHILD_LOG_DIR | /tmp | supervisord.childlogdir |
| SE_SUPERVISORD_LOG_FILE | /tmp/supervisord.log | supervisord.logfile |
| SE_SUPERVISORD_PID_FILE | /tmp/supervisord.pid | supervisord.pidfile |
Klonen Sie das Repo und aus dem Stammverzeichnis des Projektverzeichnisses können Sie alles erstellen, indem Sie Folgendes ausführen:
$ VERSION=local make build Wenn Sie Umgebungsvariablen konfigurieren müssen, um das Image zu erstellen (z. B. http-Proxy), legen Sie einfach eine Umgebungsvariable BUILD_ARGS fest, die die zusätzlichen Variablen enthält, die an den Docker-Kontext übergeben werden sollen (dies funktioniert nur mit Docker >= 1.9).
$ BUILD_ARGS= " --build-arg http_proxy=http://acme:3128 --build-arg https_proxy=http://acme:3128 " make build Hinweis: Wenn Sie VERSION=local weglassen , werden die Bilder mit der veröffentlichten Version erstellt, das Datum wird jedoch durch die aktuelle Version ersetzt.
Wenn Sie das Image mit der Host-UID/GID erstellen möchten, legen Sie einfach eine Umgebungsvariable BUILD_ARGS fest
$ BUILD_ARGS= " --build-arg UID= $( id -u ) --build-arg GID= $( id -g ) " make build Wenn Sie das Image mit einem anderen Standardbenutzer/-passwort erstellen möchten, legen Sie einfach eine Umgebungsvariable BUILD_ARGS fest
$ BUILD_ARGS= " --build-arg SEL_USER=yourseluser --build-arg SEL_PASSWD=welcome " make buildBasierend auf der neuesten Dockerfile (durch Klonen des Repo und aus der Projektverzeichnisswurzel) können Sie die Bilder mit einer spezifischen Kombination aus Selengitter und Browser -Versionen erstellen.
Zum Beispiel möchten Sie mit der auf Gitterbasis basierenden Version 4.17.0 , Chrome Browser-Versionen 119 , 120 , 123 node-chrome und standalone-chrome Bilder erstellen.
$ ./tests/build-backward-compatible/bootstrap.sh 4.17.0 119,120,123 chromeIm Generika nimmt das Skript die folgenden Argumente an:
$1 (obligatorisch): Selenium -Gitterversion. Details erhalten von der Matrixdatei$2 (obligatorisch): Browser -Hauptversion, mehrere von Comma getrennte Werte. Details erhalten von der Matrixdatei$3 (optional): Browsername. Wenn es nicht zur Verfügung gestellt wird, wird es über alle Browser ( chrome , edge , firefox ) durchlaufen$4 (optional): Image in die Registrierung drücken. Standardmäßig ist es false . Wenn Sie das Bild in die Registrierung drücken möchten, stellen Sie es auf true ein (die erforderliche Anmeldung an Ihrem Namespace, der vor dem Ausführen des Skripts ausgeführt wird). Um Ihren Namespace für die Bilder festzulegen, können Sie den NAME der Umgebungsvariablen festlegen, bevor Sie das Skript ausführen. Zum Beispiel:
$ export NAME=artifactory.yourcompany.com/selenium
$ ./tests/build-backward-compatible/bootstrap.sh 4.17.0 119,120,123 chromeNach dem Ausführen des Skripts werden Listenbilder mit einem vollständigen Tag angezeigt, um spezifische Raster und Browserversion nach dem Tagging -Konventionen anzupassen
Selenium Server, Browser und Treiber sind im Bild vorinstalliert. Falls Sie auf derselben Seleniumversion bleiben möchten und den Browser und seinen Treiber auf die neueste aktuelle aktualisieren möchten. Sie können unten die folgenden Schritte befolgen
Klonen Sie das Repo und aus dem Projektverzeichnis -Root können Sie durch Ausführen aktualisieren:
$ VERSION= $EXPECTED_SELENIUM_VERSION make chrome_upgrade_version Zum Beispiel: VERSION=4.16.1 make chrome_upgrade_version
Das neue Bild hat Tag $VERSION_YYYYMMDD , wo YYYYMMDD das aktuelle Datum ist.
$ VERSION= $SELENIUM_VERSION make firefox_upgrade_version$ VERSION= $SELENIUM_VERSION make edge_upgrade_versionSie können auf Detailbefehle in der Makefile -Datei verweisen.
Es ist eine gute Praxis, zuerst zu überprüfen /wd/hub/status ob das Netz abgelaufen ist und bereit ist, Anforderungen zu erhalten.
Ein Raster, das bereit ist, das aus einer Nabe und zwei Knoten besteht, könnte so aussehen:
{
"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" : [
]
}
]
}
} Der "ready": true Value gibt an, dass das Netz bereit ist, Anfragen zu erhalten. Dieser Status kann vor dem Ausführen eines Tests durch ein Skript befragt werden, oder es kann als HealthCheck hinzugefügt werden, wenn der Docker -Container gestartet wird.
Das Skript-Check-Grid.sh, das in den Bildern enthalten ist, kann verwendet werden, um den Gitterstatus zu befragen.
Dieses Beispiel überprüft den Status des Netzes alle 15 Sekunden, es hat eine Zeitüberschreitung von 30 Sekunden, wenn der Scheck durchgeführt wird, und es wird bis zu 5 Mal bis zum 5 -fachen abgebaut, bis der Container als ungesund markiert ist. Bitte verwenden Sie angepasste Werte, um Ihren Anforderungen zu entsprechen, (falls erforderlich) die Parameter --host und --port für die in Ihrer Umgebung verwendeten Parameter.
$ 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
HINWEIS: Der Line-Degrenzer funktioniert weder in Windows-basierten Terminals, versuchen Sie entweder ^ oder einen Backtick.
Der Gesundheitszustand des Containers kann überprüft werden, indem Sie docker ps durchführen und den (healthy)|(unhealthy) Status verifizieren oder auf folgende Weise inspizieren:
$ docker inspect --format= ' {{json .State.Health.Status}} ' selenium-hub
" healthy "Ein in Docker bekanntes häufiges Problem ist, dass ein laufender Container nicht immer bedeutet, dass die Anwendung darin bereit ist. Eine einfache Möglichkeit, dies anzugehen, besteht darin, ein "Wait-for-it" -Skript zu verwenden. Weitere Informationen finden Sie hier.
Das folgende Skript ist ein Beispiel dafür, wie dies mit Bash erfolgen kann. Das gleiche Prinzip gilt jedoch, wenn Sie dies mit der Programmiersprache tun möchten, die zum Schreiben der Tests verwendet wird. Im folgenden Beispiel wird das Skript jede Sekunde den Statusendpunkt abfragen. Wenn das Raster innerhalb von 30 Sekunden nicht fertig ist, wird das Skript mit einem Fehlercode beendet.
#! /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
fiErfordert
jqüberapt-get, da das Skript weiterhinWaitingwird, ohne die Ausführung abzuschließen.
Hinweis: Ersetzen Sie bei Bedarf localhost und 4444 für die richtigen Werte in Ihrer Umgebung. Auch dieses Skript befragt auf unbestimmte Zeit, Sie möchten es vielleicht optimieren und eine Auszeit festlegen.
Nehmen wir an, der normale Befehl zur Ausführung Ihrer Tests ist mvn clean test . Hier ist eine Möglichkeit, das obige Skript zu verwenden und Ihre Tests auszuführen:
$ ./wait-for-grid.sh && mvn clean testSo wird das Drehbuch befragt, bis das Netz fertig ist und Ihre Tests beginnen.
Standardmäßig ist das basierte Bild libnss3-tools installiert und initialisiert /home/seluser/.pki/nssdb , sodass Sie Ihre Zertifikate mit rootless hinzufügen können. Wenn Sie benutzerdefinierte Zertifikate, CA-, Intermediate CA- oder Client -Zertifikate (z. B. Internal CA) installieren müssen, können Sie Ihr eigenes Docker -Image aus dem Selen -Knotenbild erstellen. Der Browser auf Chrombasis verwendet nssdb als Zertifikatspeicher. Sie können dann alle erforderlichen internen Zertifikate in Ihrem Dockerfile wie folgt installieren:
In dem Bild ist ein Versorgungsskript verpackt, mit dem Ihre Zertifikate zum nssdb Store und dem Bundle CA hinzugefügt werden können. Das Skript ist /opt/bin/add-cert-helper.sh .
Erstellen Sie eine Dockerfile, die das Seleniumknoten -Bild als Basis verwendet, das Skript in den Container kopiert und führt es aus. Zum Beispiel Dockerfile
Wenn Sie eine Reihe verschiedener Zertifikate und Knotenbilder erstellen müssen. Sie können ein Bootstrap-Skript erstellen, um dies in One-Shot zu tun. Zum Beispiel Bootstrap.sh
Das obige Beispiel kann mit dem folgenden Befehl getestet werden:
make test_custom_ca_cert
# ./tests/customCACert/bootstrap.shWeitere Informationen finden Sie hier weitere Informationen
Auf diese Weise werden die Zertifikate installiert und der Knoten startet automatisch wie zuvor.
Alternativ können Sie Ihre Zertifikatdateien zu vorhandenen Seleniumbildern hinzufügen. In diesem praktischen Beispiel wird davon ausgegangen, dass Sie ein bekanntes Bild als Build -Bild haben und eine Möglichkeit haben, neue Bilder in Ihrer lokalen Docker -Registrierung zu veröffentlichen.
Dieses Beispiel verwendet eine Redhat-basierte Distribution als Build-Bild (Rocky Linux), kann jedoch jedes Linux-Bild Ihrer Wahl sein. Bitte beachten Sie, dass die Erstellung der Anweisung zwischen Verteilungen variiert. Sie können die Anweisungen für Ubuntu im vorherigen Beispiel überprüfen.
Das Beispiel wird auch vorausgesetzt, dass Ihre interne CA bereits in /etc/pki/ca-trust/source/anchors/your_ca.pem , dem Standardort für Rocky Linux, ist. Alternativ können Sie diese Dateien auch von Ihrem Host von Ihrem Host bereitstellen und in das Build -Bild kopieren.
Für Chrom- und Kantenbrowser ist das Rezept das gleiche. Passen Sie einfach den Bildnamen (Knotenchrom oder Knotenkande) an:
# 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
Beispiel für 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
Dieses Projekt verwendet X11VNC als VNC -Server, mit denen Benutzer untersuchen können, was im Container passiert. Benutzer können auf zwei Arten eine Verbindung zu diesem Server herstellen:
Der VNC -Server hört Port 5900 an. Sie können einen VNC -Client verwenden und eine Verbindung dazu herstellen. Fühlen Sie sich frei, Port 5900 auf einen kostenlosen externen Port zu kartieren, den Sie wünschen.
Der interne 5900 -Port bleibt gleich, da dies der konfigurierte Port für den im Container ausgeführten VNC -Server ist. Sie können es mit der Umgebungsvariablen SE_VNC_PORT überschreiben, falls Sie --net=host verwenden möchten.
Hier ist ein Beispiel mit den eigenständigen Bildern, das gleiche Konzept gilt für die Knotenbilder.
$ 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-20241101Dann würden Sie in Ihrem VNC -Kunden verwenden:
Wenn Sie eine Eingabeaufforderung erhalten, nach einem Passwort zu fragen, ist es: secret . Wenn Sie dies ändern möchten, können Sie die Umgebungsvariable SE_VNC_PASSWORD festlegen.
Wenn Sie VNC ohne Kennwortauthentifizierung ausführen möchten, können Sie die Umgebungsvariable SE_VNC_NO_PASSWORD=1 festlegen.
Wenn Sie VNC im nur Ansichtsmodus ausführen möchten, können Sie die Umgebungsvariable SE_VNC_VIEW_ONLY=1 festlegen.
Wenn Sie die Open -Datei -Deskriptor -Grenze für den VNC -Serverprozess ändern möchten, können Sie die Umgebungsvariable SE_VNC_ULIMIT=4096 festlegen.
In diesem Projekt wird NovNC verwendet, damit Benutzer visuell Containeraktivitäten mit ihrem Browser inspizieren können. Dies kann nützlich sein, wenn Sie keinen VNC -Client auf Ihrem Computer installieren können. Port 7900 wird verwendet, um NovNC zu starten, sodass Sie mit Ihrem Browser eine Verbindung zu diesem Port herstellen müssen.
Ähnlich wie im vorherigen Abschnitt können Sie Port 7900 auf einen kostenlosen externen Port abbilden, den Sie wünschen. Sie können es auch mit der Umgebungsvariablen SE_NO_VNC_PORT überschreiben, falls Sie --net=host verwenden möchten.
Hier ist ein Beispiel mit den eigenständigen Bildern, das gleiche Konzept gilt für die Knotenbilder.
$ 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-20241101Dann würden Sie in Ihrem Browser verwenden:
Wenn Sie eine Eingabeaufforderung erhalten, nach einem Passwort zu fragen, ist es: secret .
Wenn Sie Ressourcen nur wenig betreiben oder einfach nicht die Laufsitzungen inspizieren müssen, ist es möglich, VNC überhaupt nicht auszuführen. Setzen Sie einfach SE_START_VNC=false Umgebungsvariable im Gitterstart.
Um die Verfolgung im Selen -Gitterbehälter zu ermöglichen, können die folgenden Befehle ausgeführt werden:
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-20241101Sie können auch auf die folgenden Docker -Komponierungs -YAML -Dateien verweisen, um ein einfaches Netz (oder) ein dynamisches Raster zu starten.
Sie können die Jaeger -Benutzeroberfläche anzeigen und Ihre Anfrage verfolgen.
Standardmäßig ist die Verfolgung in Gitterkomponenten aktiviert. Ohne Trace -Exporteurendpunkt wird eine lokale Instanz nachsehen, z. B. localhost/[0:0:0:0:0:0:0:1]:4117 . In Containerprotokollen sehen Sie nur wenige Zeilen wie unten:
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) In diesem Fall setzen Sie einfach SE_ENABLE_TRACING=false auf alle Komponentenbehälter, um die Verfolgung zu deaktivieren (jede Komponente exportiert seine eigenen Spuren).
Alle Ausgaben werden an stdout gesendet, sodass sie durch Laufen inspiziert werden kann:
$ docker logs -f < container-id | container-name >Sie können die Protokollausgabe erhöhen, indem Sie die Umgebungsvariable an die Container übergeben:
SE_OPTS="--log-level FINE"
--shm-size="2g" Warum ist --shm-size 2g notwendig?
Dies ist eine bekannte Problemumgehung, um zu vermeiden, dass der Browser in einem Docker -Container abstürzt. Hier sind die dokumentierten Probleme für Chrome und Firefox. Die SHM -Größe von 2 GB ist willkürlich, aber bekannt dafür, dass Ihr spezifischer Anwendungsfall möglicherweise einen anderen Wert erfordert. Es wird empfohlen, diesen Wert nach Ihren Anforderungen zu stimmen.
Wenn Sie die folgenden Selenium -Ausnahmen sehen:
Message: invalid argument: can't kill an exited process
oder
Message: unknown error: Chrome failed to start: exited abnormally
oder
[DriverServiceSessionFactory.apply] - Error while creating session with the driver service. Stopping driver service: java.util.concurrent.TimeoutException
Der Grund könnte sein, dass Sie die Variable SE_START_XVFB -Umgebungsvariable auf false festgelegt haben, aber vergessen haben, Firefox, Chrom oder Edge im Kopflosenmodus tatsächlich auszuführen.
Ein gemeinsames Szenario ist die Montage eines Volumens in den Browser -Container, um heruntergeladene Dateien abzurufen. Dies funktioniert gut in Windows und MacOS, jedoch nicht ohne Problemumgehung unter Linux. Weitere Informationen finden Sie in diesem gut dokumentierten Problem.
Bei der Verwendung von Linux können Sie beispielsweise einen Container auf die folgende Weise starten:
docker run -d -p 4444:4444 --shm-size= " 2g "
-v /home/ubuntu/files:/home/seluser/Downloads
selenium/standalone-chrome:4.26.0-20241101 Dadurch wird das Verzeichnis des Hosts /home/ubuntu/files in /home/seluser/Downloads im Container (Standard -Download -Verzeichnis des Browsers) montiert. Das Problem tritt auf, weil das Volumen als root montiert wird; Daher kann der Browser keine Datei in dieses Verzeichnis schreiben, da er unter dem Benutzer seluser ausgeführt wird. Dies geschieht, da Docker das Volumen unter Linux montiert, weitere Details in dieser Ausgabe.
Eine Problemumgehung dafür besteht darin, ein Verzeichnis auf dem Host zu erstellen und seine Berechtigungen zu ändern, bevor das Volumen steigt . Abhängig von Ihren Benutzerberechtigungen müssen Sie möglicherweise sudo für einige dieser Befehle verwenden:
mkdir /home/ubuntu/files
chown 1200:1201 /home/ubuntu/filesDanach sollten Sie in der Lage sein, Dateien in das montierte Verzeichnis herunterzuladen. Wenn Sie eine bessere Problemumgehung haben, senden Sie uns bitte eine Pull -Anfrage!
Ähnlich wie das Mount -Volumes zum Abrufen heruntergeladener Dateien. Für Videodateien müssen Sie möglicherweise dasselbe tun
mkdir /tmp/videos
chown 1200:1201 /tmp/videos
