docker selenium
4.26.0-20241101
O projeto é possível graças a colaboradores voluntários que dedicaram milhares de horas de seu próprio tempo e disponibilizaram o código-fonte gratuitamente sob a Licença Apache 2.0.
Essas imagens do Docker vêm com algumas tags para simplificar seu uso, dê uma olhada nelas em um de nossos lançamentos.
Para receber notificações de novos lançamentos, adicione-se como observador "Somente lançamentos".
Essas imagens são publicadas no registro Docker Hub no Selenium Docker Hub.
Você precisa de ajuda para usar essas imagens Docker? Fale conosco em 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-20241101Aponte seus testes do WebDriver para http://localhost:4444
É isso!
(Opcional) Para ver o que está acontecendo dentro do contêiner, acesse http://localhost:7900/?autoconnect=1&resize=scale&password=secret.
Para obter mais detalhes sobre a visualização da atividade do contêiner, consulte a seção Depuração.
☝️ Ao executar docker run para uma imagem que contém um navegador, use o sinalizador --shm-size=2g para usar a memória compartilhada do host.
☝️ Sempre use uma imagem Docker com tag completa para fixar um navegador específico e uma versão do Grid. Consulte Convenções de marcação para obter detalhes.
A partir da tag de imagem baseada em 4.21.0 , as arquiteturas suportadas por este projeto são as seguintes:
| Arquitetura | Disponível |
|---|---|
| x86_64 (também conhecido como amd64) | ✅ |
| aarch64 (também conhecido como arm64/armv8) | ✅ |
| armhf (também conhecido como arm32/armv7l) | ❌ |
Os seguintes navegadores estão disponíveis em imagens multiarquiteturas:
| Arquitetura | Cromo | Cromo | Raposa de fogo | Borda |
|---|---|---|---|---|
| x86_64 (também conhecido como amd64) | ✅ | ✅ | ✅ | ✅ |
| aarch64 (também conhecido como arm64/armv8) | ❌ | ✅ | ✅ | ❌ |
| armhf (também conhecido como arm32/armv7l) | ❌ | ❌ | ❌ | ❌ |
Observação:
O Google não cria o Chrome ( google-chrome ) para plataformas Linux/ARM. Portanto, as imagens do Chrome (node e independente) estão disponíveis apenas para AMD64. Da mesma forma, a Microsoft não cria Edge ( microsoft-edge ) para plataformas Linux/ARM.
A execução de uma imagem AMD64 sob emulação em uma plataforma ARM64 não é recomendada devido a problemas de desempenho e estabilidade.
Para Linux/ARM, use o navegador Chromium de código aberto. As imagens do Chromium (nó e autônomas) estão disponíveis em multiarquitetura.
$ docker run --rm -it -p 4444:4444 -p 5900:5900 -p 7900:7900 --shm-size 2g selenium/standalone-chromium:latestImagens multi-arch são testadas no CircleCI com classe de recurso Linux/ARM64. Veja o status abaixo.
Para imagens experimentais de contêiner docker, que são executadas em plataformas como Apple M-series ou Raspberry Pi, o repositório em seleniumhq-community/docker-seleniarm forneceu imagens que são publicadas no registro Seleniarm Docker Hub.
Consulte a edição nº 1076 para obter mais informações sobre essas imagens.
Agora, o fork seleniumhq-community/docker-seleniarm foi mesclado.
Recomendamos habilitar o recurso experimental de armazenamento de imagens em contêiner no Docker Engine. containerd entende imagens multiplataforma, onde uma única tag de imagem pode se referir a diferentes variantes cobrindo uma variedade de sistemas operacionais e arquiteturas de hardware. Simplifica o processo de construção, armazenamento e distribuição de imagens em diferentes plataformas.
Um único comando para habilitar esse recurso no Docker Engine:
make set_containerd_image_storePara construir todas as imagens para multiplataforma, execute o seguinte comando:
PLATFORMS=linux/amd64,linux/arm64 make buildPara construir as imagens para uma plataforma específica, execute o seguinte comando:
PLATFORMS=linux/arm64 make build Por padrão, sem especificar a variável PLATFORMS , as imagens são construídas para a plataforma linux/amd64 .
As imagens noturnas são construídas sobre a compilação Nightly no projeto upstream Selenium com as alterações mais recentes na ramificação principal deste repositório. A tag da imagem é nightly . Não é recomendado usar imagens na produção. É apenas para fins de teste.
$ docker run -d -p 4442-4444:4442-4444 --name selenium-hub selenium/hub:nightlyConfira o docker compose para começar a usar imagens noturnas docker-compose-v3-full-grid-nightly.yml
Para executar testes ou trabalhar com navegadores de pré-lançamento, Google, Mozilla e Microsoft mantêm um canal de lançamento Dev e Beta para quem precisa ver o que será lançado em breve para a população em geral.
Aqui estão as instruções para executá-los no modo Standalone:
Chrome Beta:
$ docker run --rm -it -p 4444:4444 -p 7900:7900 --shm-size 2g selenium/standalone-chrome:betaDesenvolvedor do 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:betaDesenvolvedor do Firefox:
$ docker run --rm -it -p 4444:4444 -p 7900:7900 --shm-size 2g selenium/standalone-firefox:devBorda Beta:
$ docker run --rm -it -p 4444:4444 -p 7900:7900 --shm-size 2g selenium/standalone-edge:betaDesenvolvimento de borda:
$ 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 obter mais informações sobre as imagens de contêiner dos canais Dev e Beta, consulte a postagem do blog sobre navegadores de canais Dev e Beta via Docker Selenium.
Raposa de fogo
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-20241101Borda
docker run -d -p 4444:4444 --shm-size= " 2g " selenium/standalone-edge:4.26.0-20241101 Observação: apenas um contêiner independente pode ser executado na porta 4444 ao mesmo tempo.
Existem diferentes maneiras de executar as imagens e criar uma Grade com Hub e Nós, verifique as opções a seguir.
O Hub e os Nós serão criados na mesma rede e se reconhecerão pelo nome do contêiner. Uma rede Docker precisa ser criada como primeiro passo.
$ 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 - 20241101Quando você terminar de usar o Grid e os contêineres tiverem saído, a rede poderá ser removida com o seguinte comando:
# Removes the grid network
$ docker network rm gridO Hub e os Nós serão criados em máquinas/VMs diferentes, eles precisam conhecer os IPs uns dos outros para se comunicarem corretamente. Se mais de um nó estiver rodando na mesma Máquina/VM, eles deverão ser configurados para expor portas diferentes.
$ 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 é a maneira mais simples de iniciar um Grid. Use os recursos vinculados abaixo, salve-os localmente e verifique as instruções de execução no topo de cada arquivo.
docker-compose-v2.yml
docker-compose-v3.yml
Para interromper a grade e limpar os contêineres criados, execute docker compose down .
docker-compose-v3-swarm.yml
É possível iniciar um Selenium Grid com todos os seus componentes separados. Para simplificar, será fornecido apenas um exemplo com docker compose. Salve o arquivo localmente e verifique as instruções de execução nele.
docker-compose-v3-full-grid.yml
| Variável de ambiente | Opção | Tipo | Valor padrão | Descrição |
|---|---|---|---|---|
SE_REJECT_UNSUPPORTED_CAPS | --reject-unsupported-caps | booleano | false | Permitir que o Distribuidor rejeite uma solicitação imediatamente se o Grid não suportar a capacidade solicitada. |
SE_HEALTHCHECK_INTERVAL | --healthcheck-interval | interno | 120 | Isso garante que o servidor possa executar ping em todos os nós com êxito após um intervalo. |
A execução dos testes pode ser gravada usando a imagem Docker selenium/video:ffmpeg-7.1-20241101 . É necessário um contêiner para cada contêiner em que um navegador está sendo executado. Isso significa que se você estiver executando 5 nós/contêineres independentes, precisará de 5 contêineres de vídeo, o mapeamento é 1-1.
Atualmente a única forma de fazer esse mapeamento é manualmente (seja iniciando os containers manualmente ou através docker compose ). Estamos iterando esse processo e provavelmente essa configuração será mais simples no futuro.
A imagem de vídeo do Docker que fornecemos é baseada na imagem ffmpeg do Ubuntu fornecida pelo projeto jrottenberg/ffmpeg, obrigado por fornecer esta imagem e simplificar nosso trabalho?
A partir da tag de imagem baseada em 4.20.0 , a imagem do Docker de vídeo é baseada na imagem FFmpeg Ubuntu fornecida pelo projeto linuxserver/docker-ffmpeg, uma vez que a imagem está disponível para multiplataforma. Obrigado por simplificar nosso projeto e nos ajudar a avançar com suporte a múltiplas arquiteturas.
Notas :
/videos dentro do contêiner de vídeo. Mapeie um diretório local para obter os vídeos.FILE_NAME para evitar resultados inesperados.Este exemplo mostra como iniciar os contêineres 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 Depois que os contêineres forem interrompidos e removidos, você deverá ver um arquivo de vídeo no diretório /tmp/videos da sua máquina.
Aqui está um exemplo usando um hub e alguns nós:
docker-compose-v3-video.yml
Baseado no suporte de Metadados em testes. Quando o gravador de vídeo é implementado como sidecar com o nó do navegador habilitando SE_VIDEO_FILE_NAME=auto e adicionando metadados aos seus testes, o nome do arquivo de vídeo extrairá o valor da capacidade se:name e o usará como o nome do arquivo de vídeo.
Por exemplo, na ligação 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 () O nome do arquivo de vídeo de saída será test_visit_basic_auth_secured_page_ChromeTests_<sessionId>.mp4 .
Se o seu nome de teste for tratado pela estrutura de teste e for exclusivo com certeza, você também pode desabilitar o ID da sessão anexado ao nome do arquivo de vídeo definindo SE_VIDEO_FILE_NAME_SUFFIX=false .
O nome do arquivo será reduzido para 255 caracteres para evitar nomes de arquivo longos. Além disso, o caractere space será substituído por _ e apenas os caracteres alfabéticos, números, - (hífen), _ (sublinhado) serão retidos no nome do arquivo.
O trim regex pode ser personalizado definindo a variável de ambiente SE_VIDEO_FILE_NAME_TRIM_REGEX . O valor padrão é [:alnum:]-_ . A regex deve ser compatível com o comando tr no bash.
No nível de implantação, o contêiner do gravador está sempre ativo. Além disso, você pode desativar o processo de gravação de vídeo por meio do recurso de sessão se:recordVideo . Por exemplo, na ligação Python:
options . set_capability ( 'se:recordVideo' , False ) No contêiner do gravador realizará a consulta GraphQL no Hub com base no Node SessionId e extrairá o valor de se:recordVideo nos recursos antes de decidir iniciar o processo de gravação de vídeo ou não.
Observações: Para alcançar o endpoint GraphQL, o contêiner do gravador precisa saber o URL do Hub. A URL do Hub pode ser passada por meio da variável de ambiente SE_NODE_GRID_URL . Por exemplo, SE_NODE_GRID_URL é http://selenium-hub:4444 .
O RCLONE está instalado na imagem do gravador de vídeo. Você pode usá-lo para enviar os vídeos para um serviço de armazenamento em nuvem. Além da gravação de vídeo mencionada acima, você pode ativar a funcionalidade de upload definindo as seguintes variáveis de ambiente:
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 usará o ID da sessão como nome do arquivo de vídeo. Isso garante que o nome do arquivo de vídeo seja exclusivo para upload. A construção do nome do arquivo de vídeo funciona automaticamente com base no endpoint /status do Node (e no endpoint GraphQL opcional) para obter o ID da sessão e os recursos.
SE_VIDEO_UPLOAD_ENABLED=true ativará o recurso de upload de vídeo. Em segundo plano, ele criará um pipefile com arquivo e destino para o uploader consumir e prosseguir.
SE_VIDEO_INTERNAL_UPLOAD=true usará RCLONE instalado no contêiner para upload. Se você quiser usar outro contêiner secundário para upload, defina-o como false .
| Variáveis ENV por modo | Hub/nós | Funções autônomas | Grade Dinâmica |
|---|---|---|---|
SE_VIDEO_RECORD_STANDALONE (obrigatório) | false (padrão) | true | true |
DISPLAY_CONTAINER_NAME (obrigatório) | entrada do usuário | entrada do usuário | (não obrigatório) |
SE_NODE_PORT (opcional) | 5555 | 4444 | (não obrigatório) |
SE_NODE_GRID_URL (opcional) | entrada do usuário | (não obrigatório) | (não obrigatório) |
Para variáveis de ambiente com prefixo RCLONE_ é usado para passar a configuração remota para RCLONE. Você pode encontrar mais informações sobre a configuração do RCLONE aqui. Ao utilizar em Dynamic Grid, essas variáveis devem ser combinadas com o prefixo SE_ , por exemplo SE_RCLONE_ . Veja a referência abaixo para mais detalhes.
Configure a gravação e upload de vídeo para hub e nós: docker-compose-v3-video-upload.yml
Configure a gravação e o upload de vídeo para funções autônomas: docker-compose-v3-video-upload-standalone.yml
Configure a gravação e upload de vídeo para Dynamic Grid (node-docker): docker-compose-v3-video-upload-dynamic-grid.yml
Configure a gravação e o upload de vídeo para Dynamic Grid autônomo (standalone-docker): testes/docker-compose-v3-test-standalone-docker.yaml
| Variável de ambiente | Valor padrão | Descrição |
|---|---|---|
SE_UPLOAD_RETAIN_LOCAL_FILE | false | Manter o arquivo local após o upload com sucesso |
SE_UPLOAD_COMMAND | copy | O comando RCLONE é usado para transferir arquivos. Aplicar move quando reter arquivo local for false |
SE_UPLOAD_OPTS | -P --cutoff-mode SOFT --metadata --inplace | Outras opções pertencentes ao comando RCLONE podem ser definidas. |
SE_UPLOAD_CONFIG_FILE_NAME | upload.conf | Arquivo de configuração para host remoto em vez de definido via prefixo de variável env SE_RCLONE_* |
SE_UPLOAD_CONFIG_DIRECTORY | /opt/bin | Diretório do arquivo de configuração (altere-o quando o arquivo conf em outro diretório for montado) |
O Grid 4 tem a capacidade de iniciar contêineres Docker sob demanda, isso significa que ele inicia um contêiner Docker em segundo plano para cada nova solicitação de sessão, o teste é executado lá e, quando o teste é concluído, o contêiner é descartado.
Este modo de execução pode ser usado nas funções Standalone ou Node. O modo de execução "dinâmico" precisa ser informado sobre quais imagens do Docker usar quando os contêineres forem iniciados. Além disso, o Grid precisa conhecer o URI do daemon Docker. Esta configuração pode ser colocada em um arquivo toml local.
Você pode salvar esse arquivo localmente e nomeá-lo, por exemplo, 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
