selenio acoplable
4.26.0-20241101
El proyecto es posible gracias a colaboradores voluntarios que han dedicado miles de horas de su propio tiempo y han hecho que el código fuente esté disponible gratuitamente bajo la licencia Apache 2.0.
Estas imágenes de Docker vienen con un puñado de etiquetas para simplificar su uso; échales un vistazo en una de nuestras versiones.
Para recibir notificaciones de nuevos lanzamientos, agréguese como observador "Solo lanzamientos".
Estas imágenes se publican en el registro de Docker Hub en Selenium Docker Hub.
¿Necesita ayuda para utilizar estas imágenes de Docker? Hable con nosotros en 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-20241101Apunte sus pruebas de WebDriver a http://localhost:4444
¡Eso es todo!
(Opcional) Para ver qué sucede dentro del contenedor, diríjase a http://localhost:7900/?autoconnect=1&resize=scale&password=secret.
Para obtener más detalles sobre cómo visualizar la actividad del contenedor, consulte la sección Depuración.
☝️ Al ejecutar docker run para una imagen que contiene un navegador, utilice la bandera --shm-size=2g para utilizar la memoria compartida del host.
☝️ Utilice siempre una imagen de Docker con una etiqueta completa para fijar un navegador específico y una versión de Grid. Consulte Convenciones de etiquetado para obtener más detalles.
Desde 4.21.0 basada en etiquetas de imagen en adelante, las arquitecturas admitidas por este proyecto son las siguientes:
| Arquitectura | Disponible |
|---|---|
| x86_64 (también conocido como amd64) | ✅ |
| aarch64 (también conocido como arm64/armv8) | ✅ |
| armhf (también conocido como arm32/armv7l) | ❌ |
Los siguientes navegadores están disponibles en imágenes de múltiples arcos:
| Arquitectura | Cromo | Cromo | Firefox | Borde |
|---|---|---|---|---|
| x86_64 (también conocido como amd64) | ✅ | ✅ | ✅ | ✅ |
| aarch64 (también conocido como arm64/armv8) | ❌ | ✅ | ✅ | ❌ |
| armhf (también conocido como arm32/armv7l) | ❌ | ❌ | ❌ | ❌ |
Nota:
Google no crea Chrome ( google-chrome ) para plataformas Linux/ARM. Por lo tanto, las imágenes de Chrome (nodo e independiente) solo están disponibles para AMD64. De manera similar, Microsoft no crea Edge ( microsoft-edge ) para plataformas Linux/ARM.
No se recomienda ejecutar una imagen AMD64 bajo emulación en una plataforma ARM64 debido a problemas de rendimiento y estabilidad.
Para Linux/ARM utilice el navegador Chromium de código abierto. Las imágenes de Chromium (nodo e independiente) están disponibles en múltiples arcos.
$ docker run --rm -it -p 4444:4444 -p 5900:5900 -p 7900:7900 --shm-size 2g selenium/standalone-chromium:latestLas imágenes de múltiples arcos se prueban en CircleCI con la clase de recurso Linux/ARM64. Vea el estado a continuación.
Para imágenes experimentales de contenedores acoplables, que se ejecutan en plataformas como Apple M-series o Raspberry Pi, el repositorio en seleniumhq-community/docker-seleniarm proporcionó imágenes que se publican en el registro de Seleniarm Docker Hub.
Consulte el número 1076 para obtener más información sobre estas imágenes.
Ahora, se fusionó la bifurcación seleniumhq-community/docker-seleniarm.
Recomendamos habilitar la función experimental de almacenamiento de imágenes en contenedores en Docker Engine. containerd comprende imágenes multiplataforma, donde una sola etiqueta de imagen puede hacer referencia a diferentes variantes que cubren una variedad de arquitecturas de hardware y sistema operativo. Simplifica el proceso de creación, almacenamiento y distribución de imágenes en diferentes plataformas.
Un solo comando para habilitar esa característica en Docker Engine:
make set_containerd_image_storePara crear todas las imágenes para multiplataforma, ejecute el siguiente comando:
PLATFORMS=linux/amd64,linux/arm64 make buildPara crear las imágenes para una plataforma específica, ejecute el siguiente comando:
PLATFORMS=linux/arm64 make build De forma predeterminada, sin especificar la variable PLATFORMS , las imágenes se crean para la plataforma linux/amd64 .
Las imágenes nocturnas se crean sobre la compilación Nightly en el proyecto Selenium con los últimos cambios en la rama principal de este repositorio. La etiqueta de imagen es nightly . No se recomienda utilizar imágenes en producción. Es sólo para fines de prueba.
$ docker run -d -p 4442-4444:4442-4444 --name selenium-hub selenium/hub:nightlyConsulte Docker Compose para comenzar con las imágenes nocturnas docker-compose-v3-full-grid-nightly.yml
Para ejecutar pruebas o trabajar con navegadores de versión preliminar, Google, Mozilla y Microsoft mantienen un canal de lanzamiento Dev y Beta para aquellos que necesitan ver lo que pronto se lanzará para la población general.
Aquí están las instrucciones para ejecutarlos en modo independiente:
Cromo Beta:
$ docker run --rm -it -p 4444:4444 -p 7900:7900 --shm-size 2g selenium/standalone-chrome:betaDesarrollador de Chrome:
$ 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:betaDesarrollador de Firefox:
$ docker run --rm -it -p 4444:4444 -p 7900:7900 --shm-size 2g selenium/standalone-firefox:devBorde Beta:
$ docker run --rm -it -p 4444:4444 -p 7900:7900 --shm-size 2g selenium/standalone-edge:betaDesarrollador de borde:
$ 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 "Para obtener más información sobre las imágenes del contenedor de los canales Dev y Beta, consulte la publicación del blog sobre Navegadores de canales Dev y Beta a través de Docker Selenium.
Firefox
docker run -d -p 4444:4444 --shm-size= " 2g " selenium/standalone-firefox:4.26.0-20241101Cromo
docker run -d -p 4444:4444 --shm-size= " 2g " selenium/standalone-chrome:4.26.0-20241101Borde
docker run -d -p 4444:4444 --shm-size= " 2g " selenium/standalone-edge:4.26.0-20241101 Nota: Solo se puede ejecutar un contenedor independiente en el puerto 4444 al mismo tiempo.
Hay diferentes formas de ejecutar las imágenes y crear una cuadrícula con un concentrador y nodos, verifique las siguientes opciones.
El Hub y los Nodos se crearán en la misma red y se reconocerán entre sí por el nombre de su contenedor. Es necesario crear una red Docker como primer paso.
$ 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 - 20241101Cuando haya terminado de usar Grid y los contenedores hayan salido, la red se puede eliminar con el siguiente comando:
# Removes the grid network
$ docker network rm gridEl concentrador y los nodos se crearán en diferentes máquinas/VM; necesitan conocer las IP de cada uno para comunicarse correctamente. Si se ejecutará más de un nodo en la misma máquina/VM, se deben configurar para exponer diferentes puertos.
$ 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 es la forma más sencilla de iniciar un Grid. Utilice los recursos vinculados a continuación, guárdelos localmente y verifique las instrucciones de ejecución en la parte superior de cada archivo.
docker-compose-v2.yml
docker-compose-v3.yml
Para detener Grid y limpiar los contenedores creados, ejecute docker compose down .
docker-compose-v3-swarm.yml
Es posible iniciar un Selenium Grid con todos sus componentes separados. Para simplificar, solo se proporcionará un ejemplo con Docker Compose. Guarde el archivo localmente y verifique las instrucciones de ejecución que se encuentran encima.
docker-compose-v3-full-grid.yml
| variable de entorno | Opción | Tipo | Valor predeterminado | Descripción |
|---|---|---|---|---|
SE_REJECT_UNSUPPORTED_CAPS | --reject-unsupported-caps | booleano | false | Permitir que el Distribuidor rechace una solicitud inmediatamente si Grid no admite la capacidad solicitada. |
SE_HEALTHCHECK_INTERVAL | --healthcheck-interval | entero | 120 | Esto garantiza que el servidor pueda hacer ping a todos los nodos correctamente después de un intervalo. |
La ejecución de las pruebas se puede registrar utilizando la imagen de Docker selenium/video:ffmpeg-7.1-20241101 . Se necesita un contenedor por cada contenedor donde se ejecuta un navegador. Esto significa que si está ejecutando 5 nodos/contenedores independientes, necesitará 5 contenedores de video, la asignación es 1-1.
Actualmente, la única forma de realizar este mapeo es manualmente (ya sea iniciando los contenedores manualmente o mediante docker compose ). Estamos repitiendo este proceso y probablemente esta configuración será más simple en el futuro.
La imagen de vídeo de Docker que proporcionamos se basa en la imagen ffmpeg de Ubuntu proporcionada por el proyecto jrottenberg/ffmpeg. ¿Gracias por proporcionar esta imagen y simplificar nuestro trabajo?
Desde 4.20.0 basada en etiquetas de imagen en adelante, la imagen de vídeo de Docker se basa en la imagen FFmpeg de Ubuntu proporcionada por el proyecto linuxserver/docker-ffmpeg, ya que la imagen está disponible para multiplataforma. Gracias por simplificar nuestro proyecto y ayudarnos a avanzar con soporte de arquitectura múltiple.
Notas :
/videos dentro del contenedor de videos. Mapee un directorio local para obtener los videos.FILE_NAME para evitar resultados inesperados.Este ejemplo muestra cómo iniciar los contenedores manualmente:
$ 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 Después de detener y eliminar los contenedores, debería ver un archivo de vídeo en el directorio /tmp/videos de su máquina.
A continuación se muestra un ejemplo que utiliza un concentrador y algunos nodos:
docker-compose-v3-video.yml
Basado en el soporte de Metadatos en pruebas. Cuando la grabadora de video se implementa con el nodo del navegador habilitando SE_VIDEO_FILE_NAME=auto y agregando metadatos a sus pruebas, el nombre del archivo de video extraerá el valor de la capacidad se:name y lo usará como nombre del archivo de video.
Por ejemplo en el enlace de Python:
from selenium . webdriver . chrome . options import Options as ChromeOptions
from selenium import webdriver
options = ChromeOptions ()
options . set_capability ( 'se:name' , 'test_visit_basic_auth_secured_page (ChromeTests)' )
driver = webdriver . Remote ( options = options , command_executor = "http://localhost:4444" )
driver . get ( "https://selenium.dev" )
driver . quit () El nombre del archivo de vídeo de salida será test_visit_basic_auth_secured_page_ChromeTests_ .
Si su nombre de prueba es manejado por el marco de prueba, y es seguro que es único, también puede deshabilitar la identificación de sesión que se agrega al nombre del archivo de video configurando SE_VIDEO_FILE_NAME_SUFFIX=false .
El nombre del archivo se recortará a 255 caracteres para evitar nombres de archivo largos. Además, el carácter space se reemplazará por _ y en el nombre del archivo solo se conservan los caracteres alfabéticos, números, - (guión) y _ (guión bajo).
La expresión regular de recorte se puede personalizar configurando la variable de entorno SE_VIDEO_FILE_NAME_TRIM_REGEX . El valor predeterminado es [:alnum:]-_ . La expresión regular debe ser compatible con el comando tr en bash.
En el nivel de implementación, el contenedor de la grabadora siempre está activo. Además, puede desactivar el proceso de grabación de video a través de la capacidad de sesión se:recordVideo . Por ejemplo en el enlace de Python:
options . set_capability ( 'se:recordVideo' , False ) En el contenedor de la grabadora, se realizará una consulta GraphQL en el Hub según el Node SessionId y se extraerá el valor de se:recordVideo en las capacidades antes de decidir si iniciar el proceso de grabación de video o no.
Notas: Para llegar al punto final de GraphQL, el contenedor de la grabadora necesita conocer la URL del centro. La URL del concentrador se puede pasar a través de la variable de entorno SE_NODE_GRID_URL . Por ejemplo, SE_NODE_GRID_URL es http://selenium-hub:4444 .
RCLONE se instala en la imagen del vídeo. Puedes usarlo para subir los videos a un servicio de almacenamiento en la nube. Además de la grabación de video mencionada anteriormente, puede habilitar la funcionalidad de carga configurando las siguientes variables de entorno:
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 utilizará la identificación de la sesión como nombre del archivo de video. Esto garantiza que el nombre del archivo de vídeo sea exclusivo para cargar. La construcción del nombre del archivo de video funciona automáticamente según el punto final /status del nodo (y el punto final GraphQL opcional) para obtener el ID de la sesión y las capacidades.
SE_VIDEO_UPLOAD_ENABLED=true habilitará la función de carga de videos. En segundo plano, creará un archivo canalizado con el archivo y el destino para que quien lo cargue lo consuma y continúe.
SE_VIDEO_INTERNAL_UPLOAD=true utilizará RCLONE instalado en el contenedor para la carga. Si desea utilizar otro contenedor adicional para la carga, configúrelo en false .
| Variables ENV por modo | Centro/Nodos | Roles independientes | Cuadrícula dinámica |
|---|---|---|---|
SE_VIDEO_RECORD_STANDALONE (obligatorio) | false (predeterminado) | true | true |
DISPLAY_CONTAINER_NAME (obligatorio) | entrada del usuario | entrada del usuario | (no requerido) |
SE_NODE_PORT (opcional) | 5555 | 4444 | (no requerido) |
SE_NODE_GRID_URL (opcional) | entrada del usuario | (no requerido) | (no requerido) |
Para variables de entorno con prefijo RCLONE_ se utiliza para pasar la configuración remota a RCLONE. Puede encontrar más información sobre la configuración de RCLONE aquí. Cuando se usan en Dynamic Grid, esas variables deben combinarse con el prefijo SE_ , por ejemplo SE_RCLONE_ . Consulte la referencia a continuación para obtener más detalles.
Configure la grabación y carga de videos para Hub y Nodos: docker-compose-v3-video-upload.yml
Configure la grabación y carga de videos para roles independientes: docker-compose-v3-video-upload-standalone.yml
Configure la grabación y carga de videos para Dynamic Grid (node-docker): docker-compose-v3-video-upload-dynamic-grid.yml
Configure la grabación y carga de video para Dynamic Grid independiente (standalone-docker): tests/docker-compose-v3-test-standalone-docker.yaml
| variable de entorno | Valor predeterminado | Descripción |
|---|---|---|
SE_UPLOAD_RETAIN_LOCAL_FILE | false | Mantener el archivo local después de cargarlo exitosamente |
SE_UPLOAD_COMMAND | copy | El comando RCLONE se utiliza para transferir archivos. Aplicar move cuando retener el archivo local es false |
SE_UPLOAD_OPTS | -P --cutoff-mode SOFT --metadata --inplace | Se pueden configurar otras opciones que pertenecen al comando RCLONE. |
SE_UPLOAD_CONFIG_FILE_NAME | upload.conf | Archivo de configuración para host remoto en lugar de configurarlo mediante el prefijo de variable env SE_RCLONE_* |
SE_UPLOAD_CONFIG_DIRECTORY | /opt/bin | Directorio del archivo de configuración (cámbielo cuando se monte el archivo conf en otro directorio) |
Grid 4 tiene la capacidad de iniciar contenedores Docker a pedido, esto significa que inicia un contenedor Docker en segundo plano para cada nueva solicitud de sesión, la prueba se ejecuta allí y, cuando se completa la prueba, el contenedor se desecha.
Este modo de ejecución se puede utilizar en los roles Independiente o Nodo. Es necesario indicarle al modo de ejecución "dinámico" qué imágenes de Docker usar cuando se inician los contenedores. Además, Grid necesita conocer el URI del demonio Docker. Esta configuración se puede colocar en un archivo toml local.
Puede guardar este archivo localmente y nombrarlo, por ejemplo, config.toml .
[ docker ] # Configs have a mapping between the Docker image to use and the capabilities that need to be matched to # start a container with the given image. configs = [ " selenium/standalone-firefox:4.26.0-20241101 " , ' {"browserName": "firefox"} ' , " selenium/standalone-chrome:4.26.0-20241101 " , ' {"browserName": "chrome"} ' , " selenium/standalone-edge:4.26.0-20241101 " , ' {"browserName": "MicrosoftEdge"} ' ] host-config-keys = [ " Dns " , " DnsOptions " , " DnsSearch " , " ExtraHosts " , " Binds " ] # URL for connecting to the docker daemon # Most simple approach, leave it as http://127.0.0.1:2375, and mount /var/run/docker.sock. # 127.0.0.1 is used because internally the container uses socat when /var/run/docker.sock is mounted # If var/run/docker.sock is not mounted: # Windows: make sure Docker Desktop exposes the daemon via tcp, and use http://host.docker.internal:2375. # macOS: install socat and run the following command, socat -4 TCP-LISTEN:2375,fork UNIX-CONNECT:/var/run/docker.sock, # then use http://host.docker.internal:2375. # Linux: varies from machine to machine, please mount /var/run/docker.sock. If this does not work, please create an issue. url = " http://127.0.0.1:2375 " # Docker image used for video recording video-image = " selenium/video:ffmpeg-7.1-20241101 " # Uncomment the following section if you are running the node on a separate VM # Fill out the placeholders with appropriate values # [server] # host =# port =
Con la clave de configuración opcional host-config-keys en la sección [docker] en un archivo config.toml (o la opción CLI --docker-host-config-keys). Los usuarios pueden especificar una lista de claves de configuración del host de Docker que deben pasarse a los contenedores del navegador.
Los nombres de clave válidos para la configuración del host de Docker se pueden encontrar en la documentación de la API de Docker o mediante el comando docker inspect el contenedor node-docker.
En caso de que desee acceder al directorio de descarga en los contenedores del navegador de nodos (por ejemplo, /home/seluser/Downloads ) a través de la configuración de volúmenes del contenedor Dynamic Grid, puede agregar la siguiente configuración al archivo config.toml
[ docker ]
host-config-keys = [ " Binds " ]Configuración de volúmenes en el archivo de redacción de Docker
services :
node-docker :
image : selenium/node-docker:latest
volumes :
- ./assets:/opt/selenium/assets
- ./config.toml:/opt/selenium/docker.toml
- ./downloads:/home/seluser/Downloads
- /var/run/docker.sock:/var/run/docker.sock
environment :
- SE_NODE_DOCKER_CONFIG_FILENAME=docker.toml /opt/selenium/config.toml es la ruta predeterminada para el archivo de configuración en todas las imágenes. Una vez que la configuración de volúmenes se comparte con los contenedores del navegador de nodos, su config.toml podría sobrescribirse con el archivo de configuración del contenedor node-docker.
En este caso, monte su archivo config.toml en /opt/selenium/docker.toml en el contenedor node-docker. Y configure la variable de entorno SE_NODE_DOCKER_CONFIG_FILENAME=docker.toml para especificar ese nombre de archivo de configuración para el script de inicio.
Consulte el ejemplo docker-compose-v3-test-node-docker.yaml
Esto se puede ampliar a una implementación Grid completa, con todos los componentes implementados individualmente. La idea general es tener el Hub en una máquina virtual y cada uno de los Nodos en máquinas virtuales separadas y más potentes.
$ 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 Para guardar los activos en su host, monte la ruta de su host en /opt/selenium/assets .
Cuando haya terminado de usar Grid y los contenedores hayan salido, la red se puede eliminar con el siguiente comando:
# 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 Complete la sección [server] en el archivo config.toml .
[ docker ] # Configs have a mapping between the Docker image to use and the capabilities that need to be matched to # start a container with the given image. configs = [ " selenium/standalone-firefox:4.26.0-20241101 " , " { " browserName " : " firefox " } " , " selenium/standalone-chrome:4.26.0-20241101 " , " { " browserName " : " chrome " } " , " selenium/standalone-edge:4.26.0-20241101 " , " { " browserName " : " MicrosoftEdge " } " ] # URL for connecting to the docker daemon # Most simple approach, leave it as http://127.0.0.1:2375, and mount /var/run/docker.sock. # 127.0.0.1 is used because interally the container uses socat when /var/run/docker.sock is mounted # If var/run/docker.sock is not mounted: # Windows: make sure Docker Desktop exposes the daemon via tcp, and use http://host.docker.internal:2375. # macOS: install socat and run the following command, socat -4 TCP-LISTEN:2375,fork UNIX-CONNECT:/var/run/docker.sock, # then use http://host.docker.internal:2375. # Linux: varies from machine to machine, please mount /var/run/docker.sock. If this does not work, please create an issue. url = " http://127.0.0.1:2375 " # Docker image used for video recording video-image = " selenium/video:ffmpeg-7.1-20241101 " # Uncomment the following section if you are running the node on a separate VM # Fill out the placeholders with appropriate values [ server ] host = < ip-from-node-machine> port = < port-from-node-machine>
Para guardar los activos en su host, monte la ruta de su host en /opt/selenium/assets .
A continuación se muestra un ejemplo que utiliza un concentrador y un nodo:
docker-compose-v3-dynamic-grid.yml
Los contenedores se pueden configurar aún más a través de variables de entorno, como SE_NODE_SESSION_TIMEOUT y SE_OPTS . Cuando se crea un contenedor secundario, todas las variables de entorno con el prefijo SE_ se reenviarán y establecerán en el contenedor. Puede configurar las variables de entorno deseadas en los contenedores standalone-docker o node-docker . El siguiente ejemplo establece el tiempo de espera de la sesión en 700 segundos para todas las sesiones:
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 Para grabar su sesión de WebDriver, debe agregar un campo se:recordVideo establecido en true . También puedes configurar una zona horaria y una resolución de pantalla, por ejemplo:
{
"browserName" : " firefox " ,
"platformName" : " linux " ,
"se:recordVideo" : " true " ,
"se:timeZone" : " US/Pacific " ,
"se:screenResolution" : " 1920x1080 "
} Después de ejecutar una prueba, verifique la ruta que montó en el contenedor Docker ( ${PWD}/assets ) y debería ver videos e información de la sesión.
Desde los enlaces de idioma, puede configurar la capacidad se:name para cambiar dinámicamente el nombre del archivo de vídeo de salida. Por ejemplo, en el enlace de Python:
from selenium . webdriver . chrome . options import Options as ChromeOptions
from selenium import webdriver
options = ChromeOptions ()
options . set_capability ( 'se:recordVideo' , True )
options . set_capability ( 'se:screenResolution' , '1920x1080' )
options . set_capability ( 'se:name' , 'test_visit_basic_auth_secured_page (ChromeTests)' )
driver = webdriver . Remote ( options = options , command_executor = "http://localhost:4444" )
driver . get ( "https://selenium.dev" )
driver . quit () Después de ejecutar la prueba, en ( ${PWD}/assets ) puede ver el nombre del archivo de video en la ruta /
El nombre del archivo se recortará a 255 caracteres para evitar nombres de archivo largos. Además, el carácter space se reemplazará por _ y solo se conservan en el nombre del archivo los caracteres alfabéticos, números, - (guión) y _ (guión bajo). (Esta hazaña está disponible una vez que este PR se fusionó)
tzdata se instala en imágenes basadas y puede configurar la zona horaria en el contenedor utilizando la variable env TZ . De forma predeterminada, la zona horaria está configurada en UTC . La lista de zonas horarias admitidas se puede encontrar aquí. Por ejemplo:
$ docker run --rm --entrypoint= " " -e TZ=Asia/Ho_Chi_Minh selenium/node-chromium:latest date +%FT%T%Z
2024-08-28T18:19:26+07Ofrecemos un gráfico de Helm para implementar estas imágenes de Docker en Kubernetes. Lea más detalles en el archivo Léame de Helm.
Puede pasar la variable SE_OPTS con parámetros de línea de comando adicionales para iniciar un centro o un nodo.
$ docker run -d -p 4444:4444 -e SE_OPTS= " --log-level FINE " --name selenium-hub selenium/hub:4.26.0-20241101 Puede pasar la variable de entorno SE_JAVA_OPTS al proceso Java.
$ docker run -d -p 4444:4444 -e SE_JAVA_OPTS=-Xmx512m --name selenium-hub selenium/hub:4.26.0-20241101En lugar de agregar argumentos a través de las opciones del navegador desde enlaces de idioma, por ejemplo:
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" ) También puede forzar de forma proactiva la aplicación de argumentos directamente desde las variables de entorno del contenedor (nodo, independiente o nodo acoplable). Definir la variable de entorno con el nombre que comienza con SE_BROWSER_ARGS_ y seguir con la clave de configuración depende de usted (asegúrese de que sean únicos cuando defina múltiples argumentos). Por ejemplo:
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:latestEnumere los argumentos de la línea de comandos de Chrome para su referencia.
Nota: Actualmente, esto se aplica a los navegadores de nodo Chrome/Chromium, Edge.
Los Nodos se registran a través del Bus de Eventos. Cuando el Grid se inicia en su configuración típica de Hub/Nodo, el Hub será el que actuará como Bus de eventos, y cuando el Grid se inicie con sus cinco elementos separados, el Bus de eventos se ejecutará por sí solo.
En ambos casos es necesario indicarle al Nodo dónde está el Bus de Eventos para que pueda registrarse. Ese es el propósito de las variables de entorno SE_EVENT_BUS_HOST , SE_EVENT_BUS_PUBLISH_PORT y SE_EVENT_BUS_SUBSCRIBE_PORT .
En algunos casos, por ejemplo, si desea etiquetar un nodo, puede que sea necesario proporcionar un estereotipo personalizado a la configuración del nodo. La variable de entorno SE_NODE_STEREOTYPE establece la entrada del estereotipo en el config.toml del nodo. Puede encontrar un archivo config.toml de ejemplo aquí: Configuración de capacidades personalizadas para hacer coincidir nodos específicos.
A continuación se muestra un ejemplo con los valores predeterminados de estas variables de entorno:
$ 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-20241101Transmitir comandos a un punto final de servicio que admita WebDriver. Es útil conectar un servicio externo que admita WebDriver a Selenium Grid. Un ejemplo de este tipo de servicio podría ser un proveedor de nube o un servidor Appium. De esta manera, Grid puede permitir una mayor cobertura a plataformas y versiones que no están presentes localmente.
El siguiente es un ejemplo de comandos de relé de configuración.
docker-compose-v3-test-node-relay.yml
Si desea transmitir comandos únicamente, selenium/node-base es adecuado y liviano para este propósito. En caso de que desee configurar el nodo con navegadores y comandos de retransmisión, se pueden utilizar las imágenes de nodo respectivas.
Para utilizar variables de entorno para generar configuraciones de retransmisión, configure SE_NODE_RELAY_URL y otras variables como se muestra a continuación
[ 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}"} ' ]Para ejecutar una prueba de muestra con el nodo retransmitido, puede clonar el proyecto y probar el siguiente comando:
make test_node_relay De forma predeterminada, se puede acceder a Selenium en http://127.0.0.1:4444/ . Selenium se puede configurar para utilizar una subruta personalizada especificando la variable ambiental SE_SUB_PATH . En el siguiente ejemplo, se puede acceder a Selenium en http://127.0.0.1:4444/selenium-grid/
$ docker run -d -p 4444:4444 -e SE_SUB_PATH=/selenium-grid/ --name selenium-hub selenium/hub:4.26.0-20241101 De forma predeterminada, los nodos comienzan con una resolución de pantalla de 1920 x 1080 con una profundidad de color de 24 bits y un ppp de 96. Estas configuraciones se pueden ajustar especificando las variables ambientales SE_SCREEN_WIDTH , SE_SCREEN_HEIGHT , SE_SCREEN_DEPTH y/o SE_SCREEN_DPI al iniciar el contenedor.
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 En algunos casos de uso, es posible que necesite configurar la URL de la cuadrícula en el nodo, por ejemplo, si desea acceder al punto final BiDi/CDP. Esto también es necesario cuando desea utilizar el nuevo RemoteWebDriver.builder() o Augmenter() presente en Selenium 4 (ya que configuran la conexión BiDi/CDP implícitamente). Puede hacerlo a través de la variable de entorno SE_NODE_GRID_URL , por ejemplo -e SE_NODE_GRID_URL=http:// . Es necesario configurar esta var de entorno si desea ver la vista en vivo mientras se ejecutan las sesiones.
Grid tiene un tiempo de espera de sesión predeterminado de 300 segundos, donde la sesión puede estar en un estado inactivo hasta que se finaliza. Puede usar SE_NODE_SESSION_TIMEOUT para sobrescribir ese valor en segundos.
Una nueva solicitud de sesión se coloca en la cola de sesión antes de procesarla y la solicitud permanece en la cola hasta que se encuentra una ranura coincidente entre los nodos registrados. Sin embargo, es posible que la solicitud de nueva sesión expire si no se encuentra ningún espacio. De forma predeterminada, una solicitud permanecerá en la cola hasta 300 segundos antes de que se alcance el tiempo de espera. Además, se realiza un intento de procesar la solicitud cada 5 segundos (de forma predeterminada).
Es posible anular esos valores a través de variables de entorno en Hub y SessionQueue ( SE_SESSION_REQUEST_TIMEOUT y SE_SESSION_RETRY_INTERVAL ). Por ejemplo, un tiempo de espera de 500 segundos sería SE_SESSION_REQUEST_TIMEOUT=500 y un intervalo de reintento de 2 segundos sería SE_SESSION_RETRY_INTERVAL=2 .
De forma predeterminada, solo se configura una sesión para ejecutarse por contenedor a través de la variable de entorno SE_NODE_MAX_SESSIONS . Es posible aumentar ese número hasta el máximo de procesadores disponibles, esto se debe a que se logra más estabilidad cuando un contenedor/navegador tiene 1 CPU para ejecutar.
Sin embargo, si ha medido el rendimiento y, basándose en eso, cree que se pueden ejecutar más sesiones en cada contenedor, puede anular el límite máximo estableciendo SE_NODE_MAX_SESSIONS en un número deseado y SE_NODE_OVERRIDE_MAX_SESSIONS en true . Sin embargo, no se recomienda ejecutar más sesiones de navegador que los procesadores disponibles ya que sobrecargará los recursos.
Anular esta configuración tiene un efecto secundario no deseado cuando la grabación de video está habilitada, ya que se puede capturar más de una sesión del navegador en el mismo video.
Firefox, Chrome. Cuando se utiliza el modo sin cabeza, no es necesario iniciar el servidor Xvfb.
Para evitar iniciar el servidor, puede configurar la variable de entorno SE_START_XVFB en false (o cualquier otro valor que no sea true ), por ejemplo:
$ 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-20241101Para obtener más información, consulte este problema de GitHub.
Anotado:
SE_START_XVFB esté configurado en true para ejecutarse en modo --headless=new . En algunos entornos, como Docker Swarm o Kubernetes, resulta útil cerrar el contenedor Node o Standalone después de que se hayan ejecutado N pruebas. Por ejemplo, esto se puede usar en Kubernetes para finalizar el pod y luego escalar uno nuevo después de N sesiones. Establezca la variable de entorno SE_DRAIN_AFTER_SESSION_COUNT en un valor superior a cero para habilitar este comportamiento.
$ docker run -e SE_DRAIN_AFTER_SESSION_COUNT=5 --shm-size= " 2g " selenium/standalone-firefox:4.26.0-20241101Con el comando anterior, el contenedor independiente se cerrará después de que se hayan ejecutado 5 sesiones.
En contenedores de larga duración, puede suceder que los navegadores dejen algunos restos. Estos pueden ser procesos bloqueados del navegador o trabajos que ya finalizaron pero que no lograron detener completamente el navegador, o archivos temporales escritos en el sistema de archivos /tmp (especialmente en navegadores basados en Chrome). Para evitar que estos llenen recursos como ID de procesos y uso del sistema de archivos en el contenedor, hay un script de limpieza automática que se ejecuta cada hora en los contenedores de nodos. Esto limpiará procesos antiguos y archivos temporales antiguos. De forma predeterminada, esto está deshabilitado. Cuando está habilitado, esto limpiará los navegadores que se ejecutan durante más de 2 horas y los archivos de más de 1 día. Estos se pueden habilitar y modificar con las siguientes variables de entorno:
SE_ENABLE_BROWSER_LEFTOVERS_CLEANUP : valor predeterminado false , establecido en true para habilitar la limpieza.SE_BROWSER_LEFTOVERS_INTERVAL_SECS : valor predeterminado 3600 (1 hora), intervalo de limpieza en segundos.SE_BROWSER_LEFTOVERS_PROCESSES_SECS : valor predeterminado 7200 (2 horas), los navegadores que se ejecuten durante más tiempo que este tiempo se cerrarán.SE_BROWSER_LEFTOVERS_TEMPFILES_DAYS : valor predeterminado 1 (1 día), los archivos generados por los navegadores basados en Chrome en /tmp se eliminarán después de esta cantidad de días (se ignorarán cuando se use Firefox). Si usa Selenium para sesiones de larga duración y espera que los navegadores se ejecuten durante más de 2 horas, no configure SE_ENABLE_BROWSER_LEFTOVERS_CLEANUP en true (deje el valor predeterminado de false ), o modifique SE_BROWSER_LEFTOVERS_PROCESSES_SECS para establecer un valor superior al esperado de larga duración. ejecutar procesos del navegador.
$ docker run -e SE_ENABLE_BROWSER_LEFTOVERS_CLEANUP=true --shm-size= " 2g " selenium/node-chrome:4.26.0-20241101Con el comando anterior, la limpieza se habilitará con los tiempos predeterminados.
$ 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-20241101Con el comando anterior, la limpieza se habilitará, pero se ejecutará cada 2 horas (en lugar de 1), eliminará los navegadores que estén funcionando durante más de 1 hora (en lugar de 2 horas) y eliminará los archivos temporales con más de 2 días (en lugar de 1).
Pocas salidas de variables como contraseña, secreto, etc. están enmascaradas en los registros de la consola. Para fines de depuración, puede desactivarlo configurando SE_MASK_SECRETS en false
Al crear un script bash, puede enmascarar el resultado usando la sintaxis echo "Current value is $(mask ${YOUR_VARIABLE})
SE_MASK_SECRETS_MIN_LENGTH el valor predeterminado es 3 . Significa que una cuerda larga estará *** para evitar exponer la longitud a un ataque de fuerza bruta.
De forma predeterminada, hay certificados autofirmados predeterminados disponibles en la imagen en la ubicación /opt/selenium/secrets include
server.jks : archivo de almacén de confianza para configurar para JVM a través de la propiedad del sistema javax.net.ssl.trustStore cuando se inicia el servidor.server.pass : el archivo contiene la contraseña del almacén de confianza para JVM a través de la propiedad del sistema javax.net.ssl.trustStorePassword .tls.crt : el certificado del servidor para la conexión https está configurado en la opción Selenium --https-certificate .tls.key : la clave privada del servidor (en formato PKCS8) para la conexión https está configurada en la opción Selenium --https-private-key .Existen variables de entorno para configurar la conexión segura:
| Variables ambientales | Por defecto | Opción de | Descripción |
|---|---|---|---|
| SE_ENABLE_TLS | false | Habilite la conexión segura con configuraciones predeterminadas | |
| 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 | Deshabilitar las comprobaciones de host para componentes internamente |
| SE_HTTPS_CERTIFICADO | /opt/selenium/secrets/tls.crt | Selenio | Establecer en la opción CLI --https-certificate |
| SE_HTTPS_PRIVATE_KEY | /opt/selenium/secrets/tls.key | Selenio | Establecer en la opción CLI --https-private-key |
Mediante el montaje de volumen, puede reemplazar los certificados predeterminados con sus propios certificados.
El cliente también debe confiar en el certificado autofirmado (agregue al sistema una CA de confianza ampliamente incluida) para evitar mensajes de error relacionados con el protocolo de enlace SSL al crear RemoteWebDriver.
Consulte el ejemplo: docker-compose-v3-full-grid-secure.yml
Diferentes navegadores tienen diferentes formas de configurar el idioma y la configuración regional para que no se vinculen.
Firefox se puede configurar para usar un idioma y una configuración regional específicos configurando la preferencia del perfil al crear WebDriver desde el enlace. Además, es necesario instalar el paquete de idioma como complemento para que el idioma de la interfaz de usuario del navegador surta efecto. Por ejemplo, para configurar el idioma y la configuración regional del navegador en vi-VN , puede seguir los siguientes pasos:
Obtenga el último paquete de idioma de Firefox para el idioma deseado, por ejemplo, https://download.mozilla.org/?product=firefox-langpack-latest-SSL&lang=vi. Luego, puede instalar el paquete de idioma como complemento al crear la instancia de RemoteWebDriver.
profile = webdriver . FirefoxProfile ()
profile . set_preference ( 'intl.accept_languages' , 'vi-VN,vi' )
profile . set_preference ( 'intl.locale.requested' , 'vi-VN,vi' )
options = FirefoxOptions ()
options . profile = profile
driver = webdriver . Remote ( options = options , command_executor = "http://selenium-hub:4444/wd/hub" )
webdriver . Firefox . install_addon ( driver , "/local/path/to/vi.xpi" )
driver . get ( 'https://google.com' )Hay una secuencia de comandos para obtener todos los paquetes de idiomas disponibles para una versión determinada de Firefox. Puede ejecutar el script para obtener los paquetes de idiomas en su fuente. Por ejemplo:
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 O puede montar el directorio del contenedor /home/seluser/firefox/distribution/extensions en el directorio del host para acceder a los paquetes que estaban prediseñados en el contenedor para usarlos en su script de prueba.
Supervisor se utiliza para gestionar procesos y registros en el contenedor. Pocas configuraciones para supervisord se pueden establecer a través de variables de entorno como se muestra a continuación:
| Variables ambientales | Por defecto | configuración supervisord |
|---|---|---|
| SE_SUPERVISORD_LOG_LEVEL | info | supervisord.loglevel |
| SE_SUPERVISORD_CHILD_LOG_DIR | /tmp | supervisord.childlogdir |
| SE_SUPERVISORD_LOG_FILE | /tmp/supervisord.log | supervisord.archivo de registro |
| SE_SUPERVISORD_PID_FILE | /tmp/supervisord.pid | supervisord.pidfile |
Clona el repositorio y desde la raíz del directorio del proyecto puedes compilar todo ejecutando:
$ VERSION=local make build Si necesita configurar variables de entorno para crear la imagen (proxy http, por ejemplo), simplemente configure una variable de entorno BUILD_ARGS que contenga las variables adicionales para pasar al contexto de la ventana acoplable (esto solo funcionará con la ventana acoplable >= 1.9)
$ BUILD_ARGS= " --build-arg http_proxy=http://acme:3128 --build-arg https_proxy=http://acme:3128 " make build Nota: Omitir VERSION=local generará las imágenes con la versión publicada pero reemplazando la fecha por la actual.
Si desea crear la imagen con el UID/GID del host, simplemente configure una variable de entorno BUILD_ARGS
$ BUILD_ARGS= " --build-arg UID= $( id -u ) --build-arg GID= $( id -g ) " make build Si desea crear la imagen con un usuario/contraseña predeterminado diferente, simplemente configure una variable de entorno BUILD_ARGS
$ BUILD_ARGS= " --build-arg SEL_USER=yourseluser --build-arg SEL_PASSWD=welcome " make buildBasado en el último Dockerfile (clonando el repositorio y desde la raíz del directorio del proyecto), puede crear las imágenes con una combinación específica de Selenium Grid y versiones del navegador.
Por ejemplo, desea construir imágenes node-chrome y standalone-chrome con la versión basada en la cuadrícula 4.17.0 , las versiones del navegador Chrome 119 , 120 , 123 respectivamente.
$ ./tests/build-backward-compatible/bootstrap.sh 4.17.0 119,120,123 chromeEn genérico, el guión toma los siguientes argumentos:
$1 (obligatorio): versión de cuadrícula de selenio. Los detalles son obtenidos desde el archivo matrix$2 (obligatorio): versión principal del navegador, múltiples valores separados por coma. Los detalles son obtenidos desde el archivo matrix$3 (opcional): nombre del navegador. Si no se proporciona, iterará sobre todos los navegadores ( chrome , edge , firefox )$4 (opcional): Empuje la imagen al registro. Por defecto, es false . Si desea empujar la imagen al registro, configúrela en true (lo requerido Docker Iniciar sesión en su espacio de nombres antes de ejecutar el script). Para configurar su espacio de nombres para las imágenes, puede establecer el NAME la variable de entorno antes de ejecutar el script. Por ejemplo:
$ export NAME=artifactory.yourcompany.com/selenium
$ ./tests/build-backward-compatible/bootstrap.sh 4.17.0 119,120,123 chromeDespués de ejecutar el script, verá imágenes de la lista con una etiqueta completa para fijar la versión de la cuadrícula y el navegador después de las convenciones de etiquetado
El servidor de selenio, el navegador y el controlador están preinstalados en la imagen. En caso de que desee permanecer en la misma versión de Selenium y simplemente actualice el navegador y su controlador a lo último. Puedes seguir los pasos a continuación
Clone el repositorio y de la raíz del directorio del proyecto que puede actualizar ejecutando:
$ VERSION= $EXPECTED_SELENIUM_VERSION make chrome_upgrade_version Por ejemplo: VERSION=4.16.1 make chrome_upgrade_version
La nueva imagen tiene etiqueta $VERSION_YYYYMMDD donde YYYYMMDD es la fecha actual.
$ VERSION= $SELENIUM_VERSION make firefox_upgrade_version$ VERSION= $SELENIUM_VERSION make edge_upgrade_versionPuede consultar comandos detallados en el archivo MakeFile.
Es una buena práctica verificar primero si la cuadrícula está activa y lista para recibir solicitudes, esto se puede hacer revisando el punto final /wd/hub/status .
Una cuadrícula que está lista, compuesta por un centro y dos nodos, podría verse así:
{
"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" : [
]
}
]
}
} El valor "ready": true indica que la cuadrícula está lista para recibir solicitudes. Este estado se puede sondear a través de un script antes de ejecutar cualquier prueba, o se puede agregar como una cheque de salud cuando se inicia el contenedor Docker.
El script check-grid.sh, que se incluye en las imágenes, se puede usar para sondear el estado de la cuadrícula.
Este ejemplo verifica el estado de la cuadrícula cada 15 segundos, tiene un tiempo de espera de 30 segundos cuando se realiza el cheque, y vuelve a reemplazar hasta 5 veces hasta que el contenedor esté marcado como poco saludable. Utilice los valores ajustados para satisfacer sus necesidades, (si es necesario) reemplace los parámetros --host y --port para los utilizados en su entorno.
$ 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
NOTA: El delimitador Line no funcionará en terminales basados en Windows, intente ^ o un retroceso.
El estado de salud del contenedor se puede verificar haciendo docker ps y verificando el estado (healthy)|(unhealthy) o inspeccionándolo de la siguiente manera:
$ docker inspect --format= ' {{json .State.Health.Status}} ' selenium-hub
" healthy "Un problema común conocido en Docker es que un contenedor en ejecución no siempre significa que la aplicación dentro esté lista. Una manera simple de abordar esto es mediante el uso de un script "esperar por", se puede ver más información aquí.
El siguiente script es un ejemplo de cómo se puede hacer esto usando bash, pero el mismo principio se aplica si desea hacer esto con el lenguaje de programación utilizado para escribir las pruebas. En el siguiente ejemplo, el script encuestará el punto final de estado cada segundo. Si la cuadrícula no se prepara en 30 segundos, el script saldrá con un código de error.
#! /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
fiRequerirá
jqinstalado a través deapt-get, de lo contrario, el script seguirá imprimiendoWaitingsin completar la ejecución.
Nota: Si es necesario, reemplace localhost y 4444 para obtener los valores correctos en su entorno. Además, este guión está encuestando indefinidamente, es posible que desee ajustarlo y establecer un tiempo de espera.
Digamos que el comando normal para ejecutar sus pruebas es mvn clean test . Aquí hay una forma de usar el script anterior y ejecutar sus pruebas:
$ ./wait-for-grid.sh && mvn clean testDe esta manera, el guión encuestará hasta que la cuadrícula esté lista, y luego sus pruebas comenzarán.
De manera predeterminada, la imagen basada está instalada libnss3-tools y inicializadas /home/seluser/.pki/nssdb , por lo que puede agregar sus certificaciones con raíces. Si necesita instalar certificados personalizados, CA, CA intermedios o certificados del cliente (por ejemplo, Enterprise Internal CA), puede crear su propia imagen Docker a partir de la imagen del nodo Selenium. El navegador basado en Chromium utiliza nssdb como una tienda de certificados. Luego puede instalar todos los certificados internos requeridos en su Dockerfile como este:
Hay un script de utilidad empaquetado en la imagen que se puede usar para agregar sus certificados a la tienda nssdb y el paquete CA. El script es /opt/bin/add-cert-helper.sh .
Cree un DockerFile que use la imagen del nodo Selenium como base y copie el script al contenedor, y la ejecuta. Por ejemplo, Dockerfile
Si tiene que crear un conjunto de diferentes certificados e imágenes de nodo. Puede crear un script de arranque para hacerlo en un solo disparo. Por ejemplo, bootstrap.sh
El ejemplo anterior se puede probar con el siguiente comando:
make test_custom_ca_cert
# ./tests/customCACert/bootstrap.shPuedes encontrar más información aquí
De esta manera, se instalarán los certificados y el nodo comenzará automáticamente como antes.
Como alternativa, puede agregar sus archivos de certificado a las imágenes de selenio existentes. Este ejemplo práctico supone que tiene una imagen conocida para usar como imagen de compilación y tiene una forma de publicar nuevas imágenes en su registro local de Docker.
Este ejemplo utiliza una distribución basada en Redhat como imagen de compilación (Rocky Linux), pero puede ser cualquier imagen de Linux de su elección. Tenga en cuenta que la instrucción de compilación variará entre las distribuciones. Puede verificar las instrucciones de Ubuntu en el ejemplo anterior.
El ejemplo también supone que su CA interna ya está en /etc/pki/ca-trust/source/anchors/your_ca.pem , la ubicación predeterminada para Rocky Linux. Alternativamente, también puede proporcionar estos archivos desde su host y copiarlos en la imagen de compilación.
Para los navegadores de Chrome y Edge, la receta es la misma, simplemente adapte el nombre de la imagen (nodo-cromo o borde de nodo):
# 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
Ejemplo para 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
Este proyecto utiliza X11VNC como un servidor VNC para permitir a los usuarios inspeccionar lo que está sucediendo dentro del contenedor. Los usuarios pueden conectarse a este servidor de dos maneras:
El servidor VNC está escuchando el puerto 5900, puede usar un cliente VNC y conectarse a él. Siéntase libre de mapear el puerto 5900 a cualquier puerto externo gratuito que desee.
El puerto interno 5900 sigue siendo el mismo porque ese es el puerto configurado para el servidor VNC que se ejecuta dentro del contenedor. Puede anularlo con la variable de entorno SE_VNC_PORT en caso de que desee usar --net=host .
Aquí hay un ejemplo con las imágenes independientes, el mismo concepto se aplica a las imágenes del nodo.
$ 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-20241101Luego, usaría en su cliente VNC:
Si recibe un mensaje pidiendo una contraseña, es: secret . Si desea cambiar esto, puede establecer la variable de entorno SE_VNC_PASSWORD .
Si desea ejecutar VNC sin autenticación de contraseña, puede establecer la variable de entorno SE_VNC_NO_PASSWORD=1 .
Si desea ejecutar VNC en modo de solo vista, puede configurar la variable de entorno SE_VNC_VIEW_ONLY=1 .
Si desea modificar el límite de descriptor de archivo abierto para el proceso del servidor VNC, puede establecer la variable de entorno SE_VNC_ULIMIT=4096 .
Este proyecto utiliza NovNC para permitir a los usuarios inspeccionar la actividad visual de contenedores con su navegador. Esto puede ser útil si no puede instalar un cliente VNC en su máquina. El puerto 7900 se utiliza para comenzar Novnc, por lo que deberá conectarse a ese puerto con su navegador.
De manera similar a la sección anterior, no dude en mapear el puerto 7900 a cualquier puerto externo gratuito que desee. También puede anularlo con la variable de entorno SE_NO_VNC_PORT en caso de que desee usar --net=host .
Aquí hay un ejemplo con las imágenes independientes, el mismo concepto se aplica a las imágenes del nodo.
$ 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-20241101Entonces, usarías en tu navegador:
Si recibe un mensaje pidiendo una contraseña, es: secret .
Si se está quedando sin recursos o simplemente no necesita inspeccionar las sesiones de ejecución, es posible no ejecutar VNC en absoluto. Simplemente establezca SE_START_VNC=false en el inicio de la cuadrícula.
Para habilitar el rastreo en el contenedor de cuadrícula de selenio, se pueden ejecutar los siguientes comandos:
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-20241101También puede consultar los siguientes archivos YAML de componer Docker para poder iniciar una cuadrícula simple (o) una cuadrícula dinámica.
Puede ver la interfaz de usuario de Jaeger y rastrear su solicitud.
Por defecto, el rastreo está habilitado en componentes de la cuadrícula. Sin el punto final del exportador de rastreo, buscará una instancia local, por ejemplo, localhost/[0:0:0:0:0:0:0:1]:4117 . En los registros de contenedores puede ver pocas líneas como a continuación:
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) En este caso, simplemente configure SE_ENABLE_TRACING=false en todos los componentes Contenedor para deshabilitar el rastreo (cada componente exporta sus propias trazas).
Toda la salida se envía a stdout, por lo que puede inspeccionarse ejecutando:
$ docker logs -f < container-id | container-name >Puede aumentar la salida de registro pasando la variable de entorno a los contenedores:
SE_OPTS="--log-level FINE"
--shm-size="2g" ¿Por qué es necesario --shm-size 2g ?
Esta es una solución conocida para evitar que el navegador se bloquee dentro de un contenedor Docker, aquí están los problemas documentados para Chrome y Firefox. El tamaño de SHM de 2GB es arbitrario pero se sabe que funciona bien, su caso de uso específico puede necesitar un valor diferente, se recomienda sintonizar este valor de acuerdo con sus necesidades.
Si ve las siguientes excepciones de selenio:
Message: invalid argument: can't kill an exited process
o
Message: unknown error: Chrome failed to start: exited abnormally
o
[DriverServiceSessionFactory.apply] - Error while creating session with the driver service. Stopping driver service: java.util.concurrent.TimeoutException
La razón podría ser que ha establecido el entorno SE_START_XVFB variable en false , pero olvidó ejecutar Firefox, Chrome o Edge en modo sin cabeza.
Un escenario común es montar un volumen al contenedor del navegador para recuperar archivos descargados. Esto funciona bien en Windows y macOS, pero no sin soluciones en Linux. Para obtener más detalles, consulte este problema bien documentado.
Por ejemplo, mientras usa Linux, puede iniciar un contenedor de la siguiente manera:
docker run -d -p 4444:4444 --shm-size= " 2g "
-v /home/ubuntu/files:/home/seluser/Downloads
selenium/standalone-chrome:4.26.0-20241101 Eso montará el directorio Host /home/ubuntu/files en el /home/seluser/Downloads dentro del contenedor (directorio de descargas de navegador predeterminado). El problema ocurre porque el volumen se montará como root ; Por lo tanto, el navegador no puede escribir un archivo en ese directorio porque se está ejecutando bajo el seluser de usuario. Esto sucede porque así es como Docker monta volúmenes en Linux, más detalles en este número.
Una solución para esto es crear un directorio en el host y cambiar sus permisos antes de montar el volumen . Dependiendo de sus permisos de usuario, es posible que deba usar sudo para algunos de estos comandos:
mkdir /home/ubuntu/files
chown 1200:1201 /home/ubuntu/filesDespués de hacer esto, debería poder descargar archivos en el directorio montado. Si tiene una mejor solución, ¡envíenos una solicitud de extracción!
Similar a Mount Volumes para recuperar archivos descargados. Para los archivos de video, es posible que deba hacer lo mismo
mkdir /tmp/videos
chown 1200:1201 /tmp/videos
