docker selenium
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_<sessionId>.mp4 .
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 será reemplazado por _ y solo se conservan en el nombre del archivo los caracteres alfabéticos, números, - (guión) y _ (guion 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 concentrador. 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 appr
