docker selênio
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 | Firefox | 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.
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-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 com ativação de SE_VIDEO_FILE_NAME=auto e adição de 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_ .
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 transmitida 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 usar 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 saber 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 appropriate values # [server] # host =# port =
Com a chave de configuração opcional host-config-keys na seção [docker] em um arquivo config.toml (ou opção CLI --docker-host-config-keys). Os usuários podem especificar uma lista de chaves de configuração do host docker que devem ser passadas para os contêineres do navegador.
Nomes de chaves válidos para configuração do host Docker podem ser encontrados na documentação da API Docker ou por meio do comando docker inspect o contêiner node-docker.
Caso você queira acessar o diretório de download em contêineres do navegador de nó (por exemplo, /home/seluser/Downloads ) por meio da configuração de volumes do contêiner Dynamic Grid, você pode adicionar a seguinte configuração ao arquivo config.toml
[ docker ]
host-config-keys = [ " Binds " ]Configuração de volumes no arquivo docker compose
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 é o caminho padrão para o arquivo de configuração em todas as imagens. Depois que a configuração dos volumes é compartilhada com os contêineres do navegador do nó, seu config.toml pode ser substituído pelo arquivo de configuração do contêiner do node-docker.
Nesse caso, monte seu arquivo config.toml em /opt/selenium/docker.toml no contêiner node-docker. E defina a variável de ambiente SE_NODE_DOCKER_CONFIG_FILENAME=docker.toml para especificar o nome do arquivo de configuração para o script de inicialização.
Consulte o exemplo docker-compose-v3-test-node-docker.yaml
Isso pode ser expandido para uma implantação completa do Grid, com todos os componentes implantados individualmente. A ideia geral é ter o Hub em uma máquina virtual e cada um dos Nodes em máquinas virtuais separadas e mais poderosas.
$ 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 que os ativos sejam salvos em seu host, monte o caminho do host em /opt/selenium/assets .
Quando 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 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 Preencha a seção [server] no arquivo 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 que os ativos sejam salvos em seu host, monte o caminho do host em /opt/selenium/assets .
Aqui está um exemplo usando um Hub e um Nó:
docker-compose-v3-dynamic-grid.yml
Os contêineres podem ser configurados posteriormente por meio de variáveis de ambiente, como SE_NODE_SESSION_TIMEOUT e SE_OPTS . Quando um contêiner filho é criado, todas as variáveis de ambiente prefixadas com SE_ serão encaminhadas e definidas no contêiner. Você pode definir as variáveis de ambiente desejadas nos contêineres standalone-docker ou node-docker . O exemplo a seguir define o tempo limite da sessão como 700 segundos para todas as sessões:
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 gravar sua sessão do WebDriver, você precisa adicionar um campo se:recordVideo definido como true . Você também pode definir um fuso horário e uma resolução de tela, por exemplo:
{
"browserName" : " firefox " ,
"platformName" : " linux " ,
"se:recordVideo" : " true " ,
"se:timeZone" : " US/Pacific " ,
"se:screenResolution" : " 1920x1080 "
} Depois de executar um teste, verifique o caminho que você montou no contêiner do Docker, ( ${PWD}/assets ), e você deverá ver vídeos e informações da sessão.
Nas ligações de linguagem, você pode definir o recurso se:name para alterar o nome do arquivo de vídeo de saída dinamicamente. 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: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 () Após a execução do teste, em ( ${PWD}/assets ) você pode ver o nome do arquivo de vídeo no caminho /
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 alfabetos, números, - (hífen) e _ (sublinhado) serão mantidos no nome do arquivo. (Este talento está disponível após a fusão deste PR)
tzdata é instalado em imagens baseadas e você pode definir o fuso horário no contêiner usando a variável env TZ . Por padrão, o fuso horário é definido como UTC . A lista de fusos horários suportados pode ser encontrada aqui. Por exemplo:
$ docker run --rm --entrypoint= " " -e TZ=Asia/Ho_Chi_Minh selenium/node-chromium:latest date +%FT%T%Z
2024-08-28T18:19:26+07Oferecemos um gráfico Helm para implantar essas imagens Docker no Kubernetes. Leia mais detalhes no leia-me do Helm.
Você pode passar a variável SE_OPTS com parâmetros de linha de comando adicionais para iniciar um hub ou nó.
$ docker run -d -p 4444:4444 -e SE_OPTS= " --log-level FINE " --name selenium-hub selenium/hub:4.26.0-20241101 Você pode passar a variável de ambiente SE_JAVA_OPTS para o processo Java.
$ docker run -d -p 4444:4444 -e SE_JAVA_OPTS=-Xmx512m --name selenium-hub selenium/hub:4.26.0-20241101Em vez de adicionar argumentos através das opções do navegador a partir de ligações de linguagem, por exemplo:
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" ) Você também pode ser proativo para forçar a aplicação de argumentos diretamente de variáveis de ambiente de contêiner (node, standalone ou node-docker). Definir a variável de ambiente com o nome começando com SE_BROWSER_ARGS_ e seguir pela chave de configuração depende de você (garanta que sejam exclusivos ao definir vários argumentos). Por exemplo:
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:latestListe os argumentos da linha de comando do chromium para sua referência.
Observação: atualmente, isso é aplicável aos navegadores de nó Chrome/Chromium, Edge.
Os Nodes se registram através do Event Bus. Quando a Grade for iniciada em sua configuração típica de Hub/Nó, o Hub atuará como o Barramento de Eventos, e quando a Grade for iniciada com todos os seus cinco elementos separados, o Barramento de Eventos estará funcionando por conta própria.
Em ambos os casos, é necessário informar ao Node onde está o Event Bus, para que ele possa se registrar. Esse é o propósito das variáveis de ambiente SE_EVENT_BUS_HOST , SE_EVENT_BUS_PUBLISH_PORT e SE_EVENT_BUS_SUBSCRIBE_PORT .
Em alguns casos, por exemplo, se você quiser marcar um nó, pode ser necessário fornecer um estereótipo personalizado para a configuração do nó. A variável de ambiente SE_NODE_STEREOTYPE define a entrada do estereótipo no config.toml do nó. Um exemplo de arquivo config.toml pode ser encontrado aqui: Configurando recursos personalizados para combinar nós específicos.
Aqui está um exemplo com os valores padrão dessas variáveis de ambiente:
$ 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-20241101Retransmitindo comandos para um terminal de serviço que suporta WebDriver. É útil conectar um serviço externo que suporte WebDriver ao Selenium Grid. Um exemplo desse serviço poderia ser um provedor de nuvem ou um servidor Appium. Desta forma, o Grid pode permitir maior cobertura para plataformas e versões não presentes localmente.
A seguir está um exemplo de comandos de relé de configuração.
docker-compose-v3-test-node-relay.yml
Se você deseja retransmitir apenas comandos, selenium/node-base é adequado e leve para essa finalidade. Caso você queira configurar o nó com navegadores e comandos de retransmissão, as respectivas imagens do nó podem ser usadas.
Para usar variáveis de ambiente para gerar configurações de retransmissão, defina SE_NODE_RELAY_URL e outras variáveis conforme abaixo
[ 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 executar um teste de amostra com o nó retransmitido, você pode clonar o projeto e tentar o comando abaixo:
make test_node_relay Por padrão, o Selenium pode ser acessado em http://127.0.0.1:4444/ . O Selenium pode ser configurado para usar um subcaminho personalizado especificando a variável ambiental SE_SUB_PATH . No exemplo abaixo, o Selenium pode ser acessado em 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 Por padrão, os nós começam com uma resolução de tela de 1920 x 1080 com profundidade de cor de 24 bits e dpi de 96. Essas configurações podem ser ajustadas especificando as variáveis ambientais SE_SCREEN_WIDTH , SE_SCREEN_HEIGHT , SE_SCREEN_DEPTH e/ou SE_SCREEN_DPI ao iniciar o contêiner.
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 Em alguns casos de uso, pode ser necessário definir a URL da grade para o nó, por exemplo, se quiser acessar o endpoint BiDi/CDP. Isso também é necessário quando você deseja usar o novo RemoteWebDriver.builder() ou Augmenter() presente no Selenium 4 (já que eles configuram a conexão BiDi/CDP implicitamente). Você pode fazer isso através da variável de ambiente SE_NODE_GRID_URL , por exemplo -e SE_NODE_GRID_URL=http:// . A configuração desta variável de ambiente é necessária se você quiser ver a visualização ao vivo enquanto as sessões estão em execução.
O Grid tem um tempo limite de sessão padrão de 300 segundos, onde a sessão pode ficar em um estado obsoleto até ser encerrada. Você pode usar SE_NODE_SESSION_TIMEOUT para substituir esse valor em segundos.
Uma nova solicitação de sessão é colocada na fila de sessão antes de ser processada e a solicitação permanece na fila até que um slot correspondente seja encontrado nos nós registrados. No entanto, a nova solicitação de sessão poderá atingir o tempo limite se nenhum slot for encontrado. Por padrão, uma solicitação permanecerá na fila por até 300 segundos antes de atingir o tempo limite. Além disso, uma tentativa de processar a solicitação é feita a cada 5 segundos (por padrão).
É possível substituir esses valores por meio de variáveis de ambiente no Hub e no SessionQueue ( SE_SESSION_REQUEST_TIMEOUT e SE_SESSION_RETRY_INTERVAL ). Por exemplo, um tempo limite de 500 segundos seria SE_SESSION_REQUEST_TIMEOUT=500 e um intervalo de repetição de 2 segundos seria SE_SESSION_RETRY_INTERVAL=2 .
Por padrão, apenas uma sessão é configurada para ser executada por contêiner por meio da variável de ambiente SE_NODE_MAX_SESSIONS . É possível aumentar esse número até o máximo de processadores disponíveis, isso porque mais estabilidade é alcançada quando um container/navegador possui 1 CPU para rodar.
No entanto, se você mediu o desempenho e com base nisso, acha que mais sessões podem ser executadas em cada contêiner, você pode substituir o limite máximo definindo SE_NODE_MAX_SESSIONS como um número desejado e SE_NODE_OVERRIDE_MAX_SESSIONS como true . No entanto, não é recomendado executar mais sessões do navegador do que os processadores disponíveis, pois você estará sobrecarregando os recursos.
A substituição desta configuração tem um efeito colateral indesejado quando a gravação de vídeo está ativada, pois mais de uma sessão do navegador pode ser capturada no mesmo vídeo.
Firefox, Chrome, ao usar o modo headless, não há necessidade de iniciar o servidor Xvfb.
Para evitar iniciar o servidor você pode definir a variável de ambiente SE_START_XVFB como false (ou qualquer outro valor que não seja true ), por exemplo:
$ 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 obter mais informações, consulte este problema do GitHub.
Observado:
SE_START_XVFB deve ser definido como true para ser executado no modo --headless=new . Em alguns ambientes, como Docker Swarm ou Kubernetes, é útil desligar o contêiner Node ou Standalone após a execução de N testes. Por exemplo, isso pode ser usado no Kubernetes para encerrar o pod e escalar um novo após N sessões. Defina a variável de ambiente SE_DRAIN_AFTER_SESSION_COUNT com um valor maior que zero para ativar esse comportamento.
$ docker run -e SE_DRAIN_AFTER_SESSION_COUNT=5 --shm-size= " 2g " selenium/standalone-firefox:4.26.0-20241101Com o comando anterior, o contêiner Standalone será encerrado após a execução de 5 sessões.
Em contêineres de longa duração, pode acontecer que os navegadores deixem algumas sobras. Eles podem ser processos travados do navegador, trabalhos que já foram concluídos, mas não conseguiram parar totalmente o navegador, ou arquivos temporários gravados no sistema de arquivos /tmp (principalmente em navegadores baseados no Chrome). Para evitar o preenchimento de recursos como IDs de processo e uso do sistema de arquivos no contêiner, há um script de limpeza automática em execução a cada hora nos contêineres do nó. Isso limpará processos antigos e arquivos temporários antigos. Por padrão, isso está desabilitado. Quando ativado, isso limpará os navegadores em execução por mais de 2 horas e os arquivos com mais de 1 dia. Eles podem ser habilitados e ajustados com as seguintes variáveis de ambiente:
SE_ENABLE_BROWSER_LEFTOVERS_CLEANUP : valor padrão false , definido como true para habilitar a limpeza.SE_BROWSER_LEFTOVERS_INTERVAL_SECS : valor padrão 3600 (1 hora), intervalo de limpeza em segundos.SE_BROWSER_LEFTOVERS_PROCESSES_SECS : valor padrão 7200 (2 horas), navegadores executados por mais tempo que esse tempo serão eliminados.SE_BROWSER_LEFTOVERS_TEMPFILES_DAYS : valor padrão 1 (1 dia), os arquivos gerados por navegadores baseados no Chrome em /tmp serão removidos após esse número de dias (ignorados ao usar o Firefox). Se você usa Selenium para sessões de longa duração e espera que os navegadores funcionem por mais de 2 horas, não defina SE_ENABLE_BROWSER_LEFTOVERS_CLEANUP como true (deixe o valor padrão false ) ou ajuste SE_BROWSER_LEFTOVERS_PROCESSES_SECS para definir um valor maior do que o esperado. executando processos do navegador.
$ docker run -e SE_ENABLE_BROWSER_LEFTOVERS_CLEANUP=true --shm-size= " 2g " selenium/node-chrome:4.26.0-20241101Com o comando anterior, a limpeza será habilitada com os tempos padrão.
$ 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-20241101Com o comando anterior, a limpeza será habilitada, mas será executada a cada 2 horas (em vez de 1), eliminará navegadores que executam mais de 1 hora (em vez de 2 horas) e removerá arquivos temporários com mais de 2 dias (em vez de 1).
Poucas variáveis de saída, como senha, segredo, etc., são mascaradas nos logs do console. Para fins de depuração, você pode desativá-lo definindo SE_MASK_SECRETS como false
Ao criar o script bash, você pode mascarar a saída usando a sintaxe echo "Current value is $(mask ${YOUR_VARIABLE})
O padrão SE_MASK_SECRETS_MIN_LENGTH é 3 . Isso significa que uma string longa será mascarada para *** para evitar a exposição do comprimento para ataques de força bruta.
Por padrão, existem certificados autoassinados disponíveis na imagem no local /opt/selenium/secrets inclui
server.jks : arquivo truststore a ser configurado para JVM por meio da propriedade do sistema javax.net.ssl.trustStore ao iniciar o servidor.server.pass : o arquivo contém a senha do truststore para JVM por meio da propriedade do sistema javax.net.ssl.trustStorePassword .tls.crt : O certificado do servidor para conexão https está definido para a opção Selenium --https-certificate .tls.key : A chave privada do servidor (no formato PKCS8) para conexão https está definida como a opção Selenium --https-private-key .Existem variáveis de ambiente para configurar a conexão segura:
| Variáveis de ambiente | Padrão | Opção de | Descrição |
|---|---|---|---|
| SE_ENABLE_TLS | false | Habilite a conexão segura com configurações padrão | |
| 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 | Desabilitar verificações de host para componentes internamente |
| SE_HTTPS_CERTIFICADO | /opt/selenium/secrets/tls.crt | Selênio | Defina a opção CLI --https-certificate |
| SE_HTTPS_PRIVATE_KEY | /opt/selenium/secrets/tls.key | Selênio | Defina a opção CLI --https-private-key |
Através da montagem de volume, você pode substituir os certificados padrão pelos seus próprios certificados.
O certificado autoassinado também precisa ser confiável para o cliente (adicionar ao pacote de CA confiável do sistema) para evitar mensagens de erro relacionadas ao handshake SSL ao criar o RemoteWebDriver.
Consulte o exemplo: docker-compose-v3-full-grid-secure.yml
Navegadores diferentes têm maneiras diferentes de definir o idioma e a localidade da vinculação.
O Firefox pode ser configurado para usar um idioma e localidade específicos definindo a preferência do perfil ao criar o WebDriver a partir da ligação. Além disso, o pacote de idiomas precisa ser instalado como complemento para que o idioma da interface do navegador tenha efeito. Por exemplo, para definir o idioma e a localidade do navegador como vi-VN , você pode usar as seguintes etapas:
Obtenha o pacote de idiomas mais recente do Firefox para o idioma desejado, por exemplo, https://download.mozilla.org/?product=firefox-langpack-latest-SSL&lang=vi. Em seguida, você pode instalar o pacote de idiomas como um complemento ao criar a instância do 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' )Existe um script para obter todos os pacotes de idiomas disponíveis para uma determinada versão do Firefox. Você pode executar o script para obter os pacotes de idiomas para sua fonte. Por exemplo:
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 Ou você pode montar o diretório do contêiner /home/seluser/firefox/distribution/extensions no diretório host para acessar os pacotes pré-construídos no contêiner para uso em seu script de teste.
Supervisor é usado para gerenciar processos e logs no contêiner. Poucas configurações para supervisord podem ser definidas por meio de variáveis de ambiente como abaixo:
| Variáveis de ambiente | Padrão | configuração supervisord |
|---|---|---|
| SE_SUPERVISORD_LOG_LEVEL | info | supervisord.loglevel |
| SE_SUPERVISORD_CHILD_LOG_DIR | /tmp | supervisord.childlogdir |
| SE_SUPERVISORD_LOG_FILE | /tmp/supervisord.log | supervisord.logfile |
| SE_SUPERVISORD_PID_FILE | /tmp/supervisord.pid | supervisord.pidfile |
Clone o repositório e a partir da raiz do diretório do projeto você pode construir tudo executando:
$ VERSION=local make build Se você precisar configurar variáveis de ambiente para construir a imagem (proxy http, por exemplo), basta definir uma variável de ambiente BUILD_ARGS que contenha as variáveis adicionais para passar para o contexto do docker (isso só funcionará com o docker >= 1.9)
$ BUILD_ARGS= " --build-arg http_proxy=http://acme:3128 --build-arg https_proxy=http://acme:3128 " make build Nota: Omitir VERSION=local irá construir as imagens com a versão lançada, mas substituindo a data pela atual.
Se você deseja construir a imagem com o UID/GID do host, basta definir uma variável de ambiente BUILD_ARGS
$ BUILD_ARGS= " --build-arg UID= $( id -u ) --build-arg GID= $( id -g ) " make build Se você deseja construir a imagem com usuário/senha padrão diferente, basta definir uma variável de ambiente BUILD_ARGS
$ BUILD_ARGS= " --build-arg SEL_USER=yourseluser --build-arg SEL_PASSWD=welcome " make buildCom base no mais recente Dockerfile (clonando o repo e a raiz do diretório do projeto), você pode criar as imagens com uma combinação específica de grade de selênio e versões do navegador.
Por exemplo, você gostaria de criar imagens node-chrome e standalone-chrome com a versão 4.17.0 baseada em grade, versões do navegador Chrome 119 , 120 , 123 , respectivamente.
$ ./tests/build-backward-compatible/bootstrap.sh 4.17.0 119,120,123 chromeEm genérico, o script leva os seguintes argumentos:
$1 (obrigatório): versão da grade de selênio. Detalhes estão buscando o arquivo Matrix$2 (obrigatório): versão principal do navegador, vários valores separados por vírgula. Detalhes estão buscando o arquivo Matrix$3 (Opcional): Nome do navegador. Se não for fornecido, ele irá a todos os navegadores ( chrome , edge , firefox )$4 (opcional): empurre a imagem para o registro. Por padrão, é false . Se você deseja empurrar a imagem para o registro, defina -a como true (Login do Docker necessário para o seu espaço para nome feito antes de executar o script). Para definir seu espaço para nome para as imagens, você pode definir o NAME da variável de ambiente antes de executar o script. Por exemplo:
$ export NAME=artifactory.yourcompany.com/selenium
$ ./tests/build-backward-compatible/bootstrap.sh 4.17.0 119,120,123 chromeDepois de executar o script, você verá as imagens da lista com uma tag completa para fixar a versão específica da grade e o navegador após convenções de marcação
O servidor, o navegador e o driver de Selenium são pré-instalados na imagem. Caso você gostaria de permanecer na mesma versão de selênio e apenas atualizar o navegador e seu driver para o mais recente. Você pode seguir as etapas abaixo
Clone o repo e da raiz do diretório do projeto que você pode atualizar executando:
$ VERSION= $EXPECTED_SELENIUM_VERSION make chrome_upgrade_version Por exemplo: VERSION=4.16.1 make chrome_upgrade_version
A nova imagem possui tag $VERSION_YYYYMMDD , onde YYYYMMDD é a data atual.
$ VERSION= $SELENIUM_VERSION make firefox_upgrade_version$ VERSION= $SELENIUM_VERSION make edge_upgrade_versionVocê pode se referir a comandos detalhados no arquivo makefile.
É uma boa prática verificar primeiro se a grade estiver pronta e pronta para receber solicitações, isso pode ser feito verificando o terminal /wd/hub/status .
Uma grade pronta, composta por um hub e dois nós, poderia parecer assim:
{
"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" : [
]
}
]
}
} O "ready": true Value indica que a grade está pronta para receber solicitações. Esse status pode ser pesquisado através de um script antes de executar qualquer teste ou pode ser adicionado como uma verificação de saúde quando o contêiner do Docker for iniciado.
O script check-grid.sh, incluído nas imagens, pode ser usado para pesquisar o status da grade.
Este exemplo verifica o status da grade a cada 15 segundos, ele tem um tempo limite de 30 segundos quando a verificação é concluída e se volta até 5 vezes até que o contêiner seja marcado como prejudicial. Use valores ajustados para atender às suas necessidades (se necessário) substitua os parâmetros --host e --port para os usados em seu ambiente.
$ 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: O delimitador line não funcionará nos terminais baseados no Windows, tente ^ ou um backtick.
O estado de saúde do contêiner pode ser verificado fazendo docker ps e verificando o status (healthy)|(unhealthy) ou inspecionando -o da seguinte maneira:
$ docker inspect --format= ' {{json .State.Health.Status}} ' selenium-hub
" healthy "Um problema comum conhecido no Docker é que um contêiner em execução nem sempre significa que o aplicativo dentro dele está pronto. Uma maneira simples de enfrentar isso é usando um script "Wait-For-It", mais informações podem ser vistas aqui.
O script a seguir é um exemplo de como isso pode ser feito usando o Bash, mas o mesmo princípio se aplica se você quiser fazer isso com a linguagem de programação usada para escrever os testes. No exemplo abaixo, o script pesquisará o terminal de status a cada segundo. Se a grade não estiver pronta em 30 segundos, o script sairá com um código de erro.
#! /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
fiExigirá
jqinstalado viaapt-get, caso contrário, o script continuará imprimindoWaitingsem concluir a execução.
NOTA: Se necessário, substitua localhost e 4444 pelos valores corretos em seu ambiente. Além disso, esse script está pesquisando indefinidamente, você pode querer ajustá -lo e estabelecer um tempo limite.
Digamos que o comando normal para executar seus testes é mvn clean test . Aqui está uma maneira de usar o script acima e executar seus testes:
$ ./wait-for-grid.sh && mvn clean testAssim, o script irá pesquisar até que a grade esteja pronta e, em seguida, seus testes começarão.
Por padrão, a imagem baseada é instalada libnss3-tools e inicializa /home/seluser/.pki/nssdb , para que você possa adicionar seus certificados com sem raiz. Se você precisar instalar certificados personalizados, CA, CA intermediária ou certificados de cliente (por exemplo, CA interna do Enterprise), poderá criar sua própria imagem do Docker a partir da imagem do nó de Selenium. O navegador baseado em cromo usa nssdb como um armazenamento de certificados. Em seguida, você pode instalar todos os certificados internos necessários no seu Dockerfile como este:
Há um script de utilitário embalado na imagem que pode ser usada para adicionar seus certificados à loja nssdb e ao pacote ca. O script é /opt/bin/add-cert-helper.sh .
Crie um DockerFile que use a imagem do nó selênio como base e copie o script para o contêiner e o executa. Por exemplo, Dockerfile
Se você precisar criar um conjunto de certificados diferentes e imagens do nó. Você pode criar um script de bootstrap para fazer isso em um tiro. Por exemplo, bootstrap.sh
O exemplo acima pode ser testado com o seguinte comando:
make test_custom_ca_cert
# ./tests/customCACert/bootstrap.shVocê pode encontrar mais informações aqui
Dessa forma, os certificados serão instalados e o nó começará automaticamente como antes.
Como alternativa, você pode adicionar seus arquivos de certificado às imagens de selênio existentes. Este exemplo prático pressupõe que você tenha uma imagem conhecida para usar como uma imagem de construção e tem uma maneira de publicar novas imagens no seu registro local do Docker.
Este exemplo usa uma distro baseada em redhat como uma imagem de construção (Rocky Linux), mas pode ser qualquer imagem Linux de sua escolha. Observe que as instruções de construção variam entre as distribuições. Você pode verificar as instruções do Ubuntu no exemplo anterior.
O exemplo também assume que seu CA interno já está em /etc/pki/ca-trust/source/anchors/your_ca.pem , o local padrão do Rocky Linux. Como alternativa, você também pode fornecer esses arquivos do seu host e copiá -los para a imagem de construção.
Para navegadores de Chrome e Edge, a receita é a mesma, basta adaptar o nome da imagem (nó-cromado ou nó):
# 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
Exemplo para o 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 projeto usa o X11VNC como um servidor VNC para permitir que os usuários inspecionem o que está acontecendo dentro do contêiner. Os usuários podem se conectar a este servidor de duas maneiras:
O servidor VNC está ouvindo a porta 5900, você pode usar um cliente VNC e conectar -se a ele. Sinta -se à vontade para mapear a porta 5900 para qualquer porta externa gratuita que desejar.
A porta interna 5900 permanece a mesma, porque essa é a porta configurada para o servidor VNC em execução dentro do contêiner. Você pode substituí -lo pela variável de ambiente SE_VNC_PORT , caso deseje usar --net=host .
Aqui está um exemplo com as imagens independentes, o mesmo conceito se aplica às imagens do nó.
$ 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-20241101Em seguida, você usaria no seu cliente VNC:
Se você receber um aviso solicitando uma senha, é: secret . Se você deseja alterar isso, pode definir a variável de ambiente SE_VNC_PASSWORD .
Se você deseja executar o VNC sem autenticação de senha, poderá definir a variável de ambiente SE_VNC_NO_PASSWORD=1 .
Se você deseja executar o VNC no modo somente visualização, pode definir a variável de ambiente SE_VNC_VIEW_ONLY=1 .
Se você deseja modificar o limite de descritor de arquivo aberto para o processo do servidor VNC, poderá definir a variável de ambiente SE_VNC_ULIMIT=4096 .
Este projeto usa o NOVNC para permitir que os usuários inspecionem a atividade visualmente de contêineres com o navegador. Isso pode ser útil se você não puder instalar um cliente VNC em sua máquina. A porta 7900 é usada para iniciar o NOVNC, então você precisará se conectar a essa porta com o navegador.
Da mesma forma que a seção anterior, fique à vontade para mapear a porta 7900 para qualquer porta externa gratuita que desejar. Você também pode substituí -lo com a variável SE_NO_VNC_PORT AIMBORAL, caso deseje usar --net=host .
Aqui está um exemplo com as imagens independentes, o mesmo conceito se aplica às imagens do nó.
$ 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-20241101Então, você usaria em seu navegador:
Se você receber um aviso solicitando uma senha, é: secret .
Se você estiver com pouco recursos ou simplesmente não precisar inspecionar sessões de corrida, é possível não executar o VNC. Basta definir SE_START_VNC=false na inicialização da grade.
Para permitir o rastreamento no recipiente de grade de selênio, os seguintes comandos podem ser executados:
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-20241101Você também pode consultar os arquivos YAML abaixo do docker abaixo para poder iniciar uma grade simples (ou) uma grade dinâmica.
Você pode ver a interface do usuário Jaeger e rastrear sua solicitação.
Por padrão, o rastreamento é ativado nos componentes da grade. Sem fim de extremidade do exportador de rastreamento, ele procurará uma instância local, por exemplo, localhost/[0:0:0:0:0:0:0:1]:4117 . Nos registros de contêineres, você pode ver poucas linhas como abaixo:
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) Nesse caso, basta definir SE_ENABLE_TRACING=false como todos os componentes do contêiner para desativar o rastreamento (cada componente exporta seus próprios traços).
Toda a saída é enviada para o stdout, para que possa ser inspecionada em execução:
$ docker logs -f < container-id | container-name >Você pode aumentar a saída de log passando a variável de ambiente para os contêineres:
SE_OPTS="--log-level FINE"
--shm-size="2g" Por que --shm-size 2g é necessário?
Esta é uma solução alternativa conhecida para evitar que o navegador colidisse dentro de um contêiner do Docker, aqui estão os problemas documentados para o Chrome e o Firefox. O tamanho do SHM de 2 GB é arbitrário, mas conhecido por funcionar bem, seu caso de uso específico pode precisar de um valor diferente, recomenda -se ajustar esse valor de acordo com suas necessidades.
Se você vir as seguintes exceções de selênio:
Message: invalid argument: can't kill an exited process
ou
Message: unknown error: Chrome failed to start: exited abnormally
ou
[DriverServiceSessionFactory.apply] - Error while creating session with the driver service. Stopping driver service: java.util.concurrent.TimeoutException
O motivo pode ser que você definiu a variável de ambiente SE_START_XVFB como false , mas esqueceu de realmente executar o Firefox, Chrome ou Edge no modo sem cabeça.
Um cenário comum está montando um volume para o contêiner do navegador para recuperar arquivos baixados. Isso funciona bem no Windows e MacOS, mas não sem soluções alternativas no Linux. Para mais detalhes, verifique este problema bem documentado.
Por exemplo, ao usar o Linux, você pode iniciar um contêiner da seguinte maneira:
docker run -d -p 4444:4444 --shm-size= " 2g "
-v /home/ubuntu/files:/home/seluser/Downloads
selenium/standalone-chrome:4.26.0-20241101 Isso montará o diretório host /home/ubuntu/files para o /home/seluser/Downloads dentro do contêiner (diretório de downloads do navegador padrão). O problema acontece porque o volume será montado como root ; Portanto, o navegador não pode gravar um arquivo nesse diretório porque está sendo executado sob o usuário seluser . Isso acontece porque é assim que o Docker monta volumes no Linux, mais detalhes nesta edição.
Uma solução alternativa para isso é criar um diretório no host e alterar suas permissões antes de montar o volume . Dependendo das permissões de usuário, pode ser necessário usar sudo para alguns desses comandos:
mkdir /home/ubuntu/files
chown 1200:1201 /home/ubuntu/filesDepois de fazer isso, você poderá baixar arquivos no diretório montado. Se você tiver uma solução alternativa melhor, envie -nos uma solicitação de tração!
Semelhante aos volumes de montagem para recuperar arquivos baixados. Para arquivos de vídeo, pode ser necessário fazer o mesmo
mkdir /tmp/videos
chown 1200:1201 /tmp/videos
