Как установить selenoid на windows 10

1.1.1. Start Selenoid

1.1.2. Run Your Tests

1.2.1. Prepare Configuration

1.2.2. Browser Images

We maintain a set of prebuilt Docker container images for different browsers including:

All these images are free to use. See image tags for a list of supported versions. Build files are stored in selenoid-images repository.
Feel free to create issues or request images for new versions.

{
    "chrome": {
        "default": "64.0",
        "versions": {
            "64.0": {
                "image": "selenoid/chrome:90.0",
                //...
                "env" : ["LANG=ru_RU.UTF-8", "LANGUAGE=ru:en", "LC_ALL=ru_RU.UTF-8"]
            }
        }
    }
}

1.2.3. Start Selenoid

docker run -d                                   
--name selenoid                                 
-p 4444:4444                                    
-v /var/run/docker.sock:/var/run/docker.sock    
-v /your/directory/config/:/etc/selenoid/:ro              
aerokube/selenoid:latest-release

> $current = $PWD -replace "\", "/" -replace "C", "c"  (1)
> docker run -d                                         `
--name selenoid                                         `
-p 4444:4444                                            `
-v //var/run/docker.sock:/var/run/docker.sock           `
-v ${current}/config/:/etc/selenoid/:ro                 `
aerokube/selenoid:latest-release

1.2.4. Selenoid under Windows

While we normally recommend to start Selenoid using Configuration Manager on any platform,
it is possible to start it under Windows manually.

The main difference from Unix operating systems is how volumes are mounted.
In any Windows paths back slashes () should be replaced by forward slashes (/) and drive letter should be lower cased.
Also start with forward slash and remove colon.

So assuming that configuration file is located at C:Usersadminselenoid a typical startup command can look like:

docker run -d --name selenoid                   `
-p 4444:4444                                    `
-v //var/run/docker.sock:/var/run/docker.sock   `
-v /c/Users/admin/selenoid:/etc/selenoid:ro                 `
aerokube/selenoid:latest-release

> $current = $PWD -replace "\", "/" -replace "C", "c"

1.3.1. Selenoid in Kubernetes

We are very frequently asked whether it is possible to run Selenoid in Kubernetes cluster. The answer is — it is possible but we do not recommend doing this:

If you need Selenium in Kubernetes or Openshift, we have a separate solution called Moon.

1.3.2. Logs and Dirs

Where are Selenoid logs?

Selenoid outputs its logs to stdout. Selenoid launched as a binary should output logs to the screen. To see Selenoid logs launched as Docker container type:

To follow the logs add one more flag:

$ docker logs -f selenoid

Where are recorded videos stored?

Default location when installed with cm is ~/.aerokube/selenoid/video or C:Users<user>.aerokubeselenoidvideo.

1.3.3. Limits and Timeouts

How can I limit overall browsers consumption?

You have to use -limit flag to specify total number of parallel sessions. Default value is 5. See Resources Consumption section on how to determine total number of parallel sessions.

Can I limit per-version browser consumption?

No, this is not supported. We consider the only reasonable limitation should be the overall browsers consumption. This is important to not overload the hardware.

How can I adjust Selenoid timeouts?

The main timeout flag is -timeout, specified as 60s or 2m or 1h. It means maximum amount of time between subsequent HTTP requests to Selenium API. When there are no requests during this time period — session is automatically closed. Selenoid also has more subtle timeouts like:

1.3.4. Resources Consumption

How many resources browser containers consume?

This depends on your tests. We recommend to start with 1 CPU and 1 Gb of memory per container as a rough estimate and then increase -limit checking that your tests work stably.

Do VNC and non-VNC browser images memory and CPU consumption differ?

The only difference between these images — is a running VNC server (x11vnc) consuming approximately 20 Megabytes of RAM in idle state which is negligible compared to browser memory consumption.

1.3.5. Features not Working

Selenoid does not start: open config/browsers.json: no such file or directory

This usually happens when Selenoid is started in Docker container with custom command-line arguments, e.g.:

$ docker run <some-args> aerokube/selenoid:some-version -limit 10

In that case you have to specify path to configuration file explicitly (cm tool does this automatically):

$ docker run <some-args> aerokube/selenoid:some-version -limit 10 -conf /etc/selenoid/browsers.json

Getting error: create container: Error response from daemon: client version 1.36 is too new

You have to run Selenoid binary container with DOCKER_API_VERSION variable specifying your Docker API version. cm tool does this automatically for you. To determine API version type:

$ docker version | grep API

Then run Selenoid like the following:

$ DOCKER_API_VERSION=1.32 ./selenoid <rest-of-args> # As a binary
$ docker run -e DOCKER_API_VERSION=1.32 <rest-of-args> aerokube/selenoid:some-version # As Docker container

Video feature not working

When running Selenoid as Docker container video feature can be not working (because of misconfiguration). If your video files are named like selenoid607667f7e1c7923779e35506b040300d.mp4 and you are seeing the following log message…​

2018/03/20 21:06:37 [9] [VIDEO_ERROR] [Failed to rename /video/selenoid607667f7e1c7923779e35506b040300d.mp4 to /video/8019c4bc-9bec-4a8b-aa40-68d1db0cffd2.mp4: rename /video/selenoid607667f7e1c7923779e35506b040300d.mp4 /video/8019c4bc-9bec-4a8b-aa40-68d1db0cffd2.mp4: no such file or directory]

… then check that:

Can’t get VNC feature to work: Disconnected

Please check that you have enableVNC = true capability in your tests

Seeing black screen with a cross in VNC window

You are using driver.close() instead of driver.quit() and just closed the last browser tab instead of removing the session.

Can Selenoid pull browser images automatically?

No, we did not implement this feature intentionally. We consider that all such cluster maintenance tasks can influence performance and stability when done automatically.

Is it possible to run Selenoid in Docker macvlan network?

Yes, this is possible. See the following Github issue for possible solutions.

1. Pull video recorder image once:

   $ docker pull selenoid/video-recorder:latest-release

2. When running Selenoid in Docker container:

   1. Mount a directory from the host machine (e.g. ~/.aerokube/selenoid/video) to store video files to /opt/selenoid/video.

   2. Pass an additional OVERRIDE_VIDEO_OUTPUT_DIR environment variable with absolute path to video directory on host machine. This is required because video recorder container, automatically created by Selenoid should save video to host machine video storage directory.

3. When running Selenoid as a binary — videos will be stored in video directory inside current working directory.

   Example Docker Command

   $ docker run -d                                 
   --name selenoid                                 
   -p 4444:4444                                    
   -v /var/run/docker.sock:/var/run/docker.sock    
   -v /your/directory/config/:/etc/selenoid/:ro              
   -v /your/directory/video/:/opt/selenoid/video/            
   -e OVERRIDE_VIDEO_OUTPUT_DIR=/your/directory/video/       
   aerokube/selenoid:latest-release

2.1.1. On Windows

With absolute path your command will look like:

> docker volume create selenoid-videos
> $current = $PWD -replace "\", "/" -replace "C", "c"    (1)
> docker run -d                                         `
--name selenoid                                         `
-p 4444:4444                                            `
-v //var/run/docker.sock:/var/run/docker.sock           `
-v ${current}/config/:/etc/selenoid/:ro                 `
-v /c/selenoid/video/:/opt/selenoid/video/              ` (2)
-e OVERRIDE_VIDEO_OUTPUT_DIR=/c/selenoid/video/         ` (3)
aerokube/selenoid:latest-release

2.1.2. Downloading Video Files from Selenoid

You can access recorded video files using the following URL:

http://selenoid-host.example.com:4444/video/<filename>.mp4

To see all available files use:

http://selenoid-host.example.com:4444/video/

2.1.3. Deleting Video Files

Selenoid intentionally has no built-in logic to automatically remove old video files. To limit storage space consumption you have two alternatives:

$ ./selenoid -log-output-dir /path/to/some/dir

Example Docker Command

$ docker run -d
--name selenoid                                 
-p 4444:4444                                    
-v /var/run/docker.sock:/var/run/docker.sock    
-v /your/directory/config/:/etc/selenoid/:ro              
-v /your/directory/logs/:/opt/selenoid/logs/              
aerokube/selenoid:latest-release -log-output-dir /opt/selenoid/logs

2.2.1. Downloading Log Files from Selenoid

You can access saved log files using the following URL:

http://selenoid-host.example.com:4444/logs/<filename>.log

To see all available files use:

http://selenoid-host.example.com:4444/logs/

2.2.2. Deleting Log Files

Similarly to video files it’s up to you when to delete old log files. Either remove log files from the directory using a scheduled job or send log removal requests:

$ curl -X DELETE http://selenoid-host.example.com:4444/logs/<filename>.log

Uploading files with Java

// Find file input element
WebElement input = driver.findElement(By.cssSelector("input[type='file']"));

// Make sure element is visible
((JavascriptExecutor) driver).executeScript("arguments[0].style.display = 'block';", input);

// Configure your client to upload local files to remote Selenium instance
driver.setFileDetector(new LocalFileDetector());

// Specify you local file path here (not path inside browser container!)
input.sendKeys("/path/to/file/on/machine/which/runs/tests");

Uploading files with Python

from selenium.webdriver.remote.file_detector import LocalFileDetector

# ...

input = driver.find_element_by_css_selector("input[type='file']")
driver.execute_script("arguments[0].style.display = 'block';", input)
driver.file_detector = LocalFileDetector()
input.send_keys("/path/to/file/on/machine/which/runs/tests")

Uploading files with Webdriver.io

var filePath = path.join('/path/to/file/on/machine/which/runs/tests');
var remoteFilePath = browser.uploadFile(filePath);
$("input[type='file']").setValue(remoteFilePath);

2.4.1. Downloading Files in Different Browsers

ChromeOptions chromeOptions = new ChromeOptions();
chromeOptions.setExperimentalOption("prefs", new HashMap<String, Object>(){
    {
        put("profile.default_content_settings.popups", 0);
        put("download.default_directory", "/home/selenium/Downloads");
        put("download.prompt_for_download", false);
        put("download.directory_upgrade", true);
        put("safebrowsing.enabled", false);
        put("plugins.always_open_pdf_externally", true);
        put("plugins.plugins_disabled", new ArrayList<String>(){
            {
                add("Chrome PDF Viewer");
            }
        });
    }
});

WebDriver driver = new RemoteWebDriver(new URL("http://localhost:4444/wd/hub"), chromeOptions);
driver.navigate().to("http://example.com/myfile.odt");

FirefoxOptions firefoxOptions = new FirefoxOptions();
firefoxOptions.setCapability("moz:firefoxOptions", new HashMap<String, Object>(){
    {
        put("prefs", new HashMap<String, Object>(){
            {
                put("browser.helperApps.neverAsk.saveToDisk", "application/octet-stream");
            }
        });
    }
});


WebDriver driver = new RemoteWebDriver(new URL("http://localhost:4444/wd/hub"), firefoxOptions);
driver.navigate().to("http://example.com/myfile.odt");

2.4.2. Accessing Files Downloaded with Browser

Your tests may need to download files with browsers. To analyze these files a common requirement is then to somehow extract downloaded files from browser containers. A possible solution can be dealing with container volumes. But Selenoid provides a /download API and dramatically simplifies downloading files. Having a running session f2bcd32b-d932-4cdc-a639-687ab8e4f840 you can access all downloaded files using an HTTP request:

GET http://selenoid-host.example.com:4444/download/f2bcd32b-d932-4cdc-a639-687ab8e4f840/myfile.txt

In order for this feature to work an HTTP file server should be listening inside browser container on port 8080. Download directory inside container to be used in tests is usually ~/Downloads.

Similarly to delete downloaded files replace GET request with DELETE:

DELETE http://selenoid-host.example.com:4444/download/f2bcd32b-d932-4cdc-a639-687ab8e4f840/myfile.txt

1. Start a new session, for example with ID f2bcd32b-d932-4cdc-a639-687ab8e4f840.

2. To get clipboard value send the following HTTP request:

   $ curl http://selenoid-host.example.com:4444/clipboard/f2bcd32b-d932-4cdc-a639-687ab8e4f840
   
   some-clipboard-value

3. To update clipboard value:

   $ curl -X POST --data 'some-clipboard-value' http://selenoid-host.example.com:4444/clipboard/f2bcd32b-d932-4cdc-a639-687ab8e4f840

<ws or http>://selenoid.example.com:4444/devtools/<session-id>/<method>

ws://selenoid.example.com:4444/devtools/<session-id>/page

Accessing Developer Tools API with Webdriver.io and Puppeteer

const { remote } = require('webdriverio');
const puppeteer = require('puppeteer-core');
const host = 'selenoid.example.com';
(async () => {
    const browser = await remote({
        hostname: host,
        capabilities: {
            browserName: 'chrome',
            browserVersion: '75.0'
        }
    });

    const devtools = await puppeteer.connect(
        { browserWSEndpoint: `ws://${host}:4444/devtools/${browser.sessionId}` }
    );
    const page = await devtools.newPage();
    await page.goto('http://aerokube.com');
    await page.screenshot({path: 'screenshot.png'});
    const title = await page.title();

    console.log(title);

    await devtools.close();
    await browser.deleteSession();

})().catch((e) => console.error(e));

2.7.1. Live Browser Screen: enableVNC

Selenoid supports showing browser screen during test execution.
This works with containers having VNC server installed (VNC column of Browser Image information).
To see browser screen:

This works by proxying VNC port from started container to http://localhost:4444/vnc/<session-id>; to WebSocket, where <session-id> is Selenium session ID.

2.7.2. Custom Screen Resolution: screenResolution

Selenoid allows you to set custom screen resolution in containers being run:

screenResolution: "1280x1024x24"

2.7.3. Video Recording: enableVideo, videoName, videoScreenSize, videoFrameRate, videoCodec

To enable video recording for session, add:

2.7.4. Saving Session Logs: enableLog, logName

To enable saving logs for a session, add:

If you wish to automatically save logs for all sessions, you can enable this behavior globally with Selenoid -save-all-logs flag.

By default saved log files are named <session-id>.log where <session-id> is a unique identifier of Selenium session.
To provide custom log file name specify:

logName: "my-cool-log.log"

2.7.5. Custom Test Name: name

For debugging purposes it is often useful to give a distinct name to every test case.
When working with Selenoid you can set test case name by passing the following capability:

The main application of this capability — is debugging tests in the UI which is showing specified name for every running session.

2.7.6. Custom Session Timeout: sessionTimeout

Sometimes you may want to change idle timeout for selected browser session. To achieve this — pass the following capability:

Timeout is specified Golang duration format e.g. 30m or 10s or 1h5m and can be no more than the value set by -max-timeout flag.

2.7.7. Per-session Time Zone: timeZone

Some tests require particular time zone to be set in operating system.
To achieve this with Selenoid use:

timeZone: "Europe/Moscow"

You can find most of available time zones here.
Without this capability launched browser containers will have the same timezone as Selenoid one.

2.7.8. Per-session Environment Variables: env

Sometimes you may want to set some environment variables for every test case (for example to test with different default locales). To achieve this pass one more capability:

env: ["LANG=ru_RU.UTF-8", "LANGUAGE=ru:en", "LC_ALL=ru_RU.UTF-8"]

Environment variables from this capability are appended to variables from configuration file.

2.7.9. Links to Application Containers: applicationContainers

Sometimes you may need to link browser container to application container running on the same host machine.
This allows you to use cool URLs like http://my-cool-app/ in tests.
To achieve this simply pass information about one or more desired links via capability:

applicationContainers: ["spring-application-main:my-cool-app", "spring-application-gateway"]

2.7.10. Hosts Entries: hostsEntries

Although you can configure a separate list of /etc/hosts entries for every browser image in Browsers Configuration File
sometimes you may need to add more entries for particular test cases. This can be easily achieved with:

hostsEntries: ["example.com:192.168.0.1", "test.com:192.168.0.2"]

Entries will be inserted to /etc/hosts before entries from browsers configuration file.
Thus entries from capabilities override entries from configuration file if some hosts are equal.

2.7.11. Custom DNS Servers: dnsServers

By default Selenoid browser containers are using global DNS settings of Docker daemon. Sometimes you may need to override used DNS servers list for particular test cases. This can be easily achieved with:

dnsServers: ["192.168.0.1", "192.168.0.2"]

2.7.12. More Docker Networks: additionalNetworks

By default Selenoid browser containers are started in Docker network specified by -container-network flag. If you tested application is running in another network you may need to connect browser container to this network:

additionalNetworks: ["my-custom-net-1", "my-custom-net-2"]

2.7.13. Container Labels: labels

In big clusters you may want to pass additional metadata to every browser session: environment, VCS revision, build number and so on. These labels can be then used to enrich session logs and send them to a centralized log storage. Later this metadata can be used for more efficient search through logs.

labels: {"environment": "testing", "build-number": "14353"}

Labels from this capability override labels from browsers configuration file. When name capability is specified — it is automatically added as a label to container.

2.7.14. Android Skin: skin

For [Android] containers you can select emulator skin with capabilities. List of available skins:

To select a skin — set skin capability:

You can also pass desired screen resolution as follows:

2.7.15. S3 Key Pattern: s3KeyPattern

This capability allows to override S3 key pattern (specified by -s3-key-pattern flag) used when uploading files to S3.

s3KeyPattern: "$quota/$fileType$fileExtension"

The same key placeholders are supported. Please refer to Uploading Files To S3 section for more details.

2.7.16. Specifying Capabilities via Protocol Extensions

Some Selenium clients allow passing only a limited number of capabilities specified in WebDriver specification. For such cases Selenoid supports reading capabilities using WebDriver protocol extensions feature. The following two examples deliver the same result. Usually capabilities are passed like this:

{"browserName": "firefox", "version": "57.0", "screenResolution": "1280x1024x24"}

Selenoid is using selenoid:options key to read protocol extension capabilities:

{"browserName": "firefox", "version": "57.0", "selenoid:options": {"screenResolution": "1280x1024x24"}}

Request

$ curl http://localhost:4444/status

Result

{
    "total": 80,
    "used": 10,
    "queued": 0,
    "pending": 1,
    "browsers": {
      "firefox": {
        "46.0": {
          "user1": {
            "count":1,
            "sessions":[
                {
                    "id": "a7a2b801-21db-4dae-a99b-4cbc0b81de96",
                    "vnc": false,
                    "screen": "1920x1080x24"
                 }
            ]
          },
          "user2": {
            "count":6,
            "sessions":[
                //...
            ]
          },
        },
        "48.0": {
          "user2": {
            "count":3,
            "sessions":[
                //...
            ]
          }
        }
      }
    }
}

3.1.1. What Statistics Mean

A typical session lifecycle looks like the following:

3.1.2. Sending Statistics to External Systems

To send Selenoid statistics described in previous section you can use Telegraf. For example to send status to Graphite:

telegraf+influxdb+graphana

$ ./selenoid -s3-endpoint https://s3.us-east-2.amazonaws.com -s3-region us-east-2 -s3-bucket-name my-bucket -s3-access-key <your-access-key> -s3-secret-key <your-secret-key>

Example metadata JSON file

{
    "id": "62a4d82d-edf6-43d5-886f-895b77ff23b7",
    "capabilities": {
        "browserName": "chrome",
        "version": "70.0",
        "name": "MyCoolTest",
        "screenResolution": "1920x1080x24"
    },
    "started": "2018-11-15T16:23:12.440916+03:00",
    "finished": "2018-11-15T16:23:12.480928+03:00"
}

1. Download latest IEDriverServer archive and unpack it to some directory (C: in this example).

2. Download latest Selenoid binary.

3. Create browsers.json configuration file:

   {
     "internet explorer": {
       "default": "11",
       "versions": {
         "11": {
           "image": ["C:\IEDriverServer.exe", "--log-level=DEBUG"]
         }
       }
     }
   }

   Notice that backslashes in Windows paths should be escaped as \.
   In this example we define a browser with name internet explorer and version 11.

4. Start Selenoid:

   ./selenoid_win_amd64.exe -conf ./browsers.json -disable-docker

5. Run your tests against …

   http://localhost:4444/wd/hub

   … with the following capabilities:

   browserName = internet explorer
   version = 11

6. To start Chrome instead just download Chromedriver binary and modify browsers.json accordingly.

7. By default Selenoid does not process launched driver logs. Launch Selenoid with -capture-driver-logs flag to append driver logs for every session to main log.

• We recommend to use latest Docker release and Linux core 4.x and above. Older kernels and Docker releases have known bugs.

• Use modern OverlayFS Docker storage driver. AUFS is also fast but has some bugs that can lead to orphaned containers. Never use Device Mapper — it is very slow. See this page on how to adjust Docker storage driver. To check your currently used driver type:

  # docker info | grep Storage

• Total number of simultaneously running containers (adjusted via -limit flag) depends on your host machine hardware. Our experience shows that depending on your tests the recommended limit is something like: 1.5-2.0 x numCores, where numCores is total number of cores on your host machine.

• In some Docker installations you can see random Selenium commands failing because of the timeout. This is mainly caused by low bridged networking (aka docker0) performance. To avoid this we recommend to set docker0 network Mac-address to the same value as eth0 has:

  # ifconfig | grep eth0
  eth0      Link encap:Ethernet  HWaddr 00:25:90:eb:fb:3e

  Now we are setting this Mac-adress for docker0 virtual interface:

  # ip link set docker0 address 00:25:90:eb:fb:3e

  To make these settings permanent we need to adding the following line to docker0 section in /etc/network/interfaces:

  iface docker0 inet static
          # ... the rest of lines
          post-up ip link set docker0 address 00:25:90:eb:fb:3e

• You may also want to limit memory and CPU consumption for each started container. To do this use -mem and -cpu flags. For example to limit memory type:

  Here values are specified in Docker format. Similarly to limit CPU comsumption specify total number of CPUs per container as a float:

• We use the same client as docker command does. This is why all environment variables like DOCKER_API_VERSION or DOCKER_CERT_PATH are applicable. See full list of supported variables in Docker documentation. For example you may encounter the following error when running Selenoid:

  [SERVICE_STARTUP_FAILED] [unknown] [create container: Error response from daemon: client is newer than server (client API version: 1.30, server API version: 1.24)]

  This is because your Docker server version is older than Selenoid client version. To fix this you need to switch Selenoid to use supported API version — 1.24. This can be done by setting DOCKER_API_VERSION environment variable:

  # docker run -e DOCKER_API_VERSION=1.24 -d --name selenoid -p 4444:4444 -v /etc/selenoid:/etc/selenoid:ro -v /var/run/docker.sock:/var/run/docker.sock aerokube/selenoid:latest-release

browsers.json

{
    "firefox": {                                     (1)
      "default": "46.0",                             (2)
      "versions": {                                  (3)
        "46.0": {                                    (4)
          "image": "selenoid/firefox:46.0",          (5)
          "port": "4444",                            (6)
          "tmpfs": {"/tmp": "size=512m"},            (7)
          "path" : "/wd/hub",                        (8)
          "volumes" : ["/from:/to:ro"],              (9)
          "env" : ["TZ=Europe/Moscow"],              (10)
          "hosts" : ["example.com:192.168.0.1"],     (11)
          "shmSize" : 268435456,                     (12)
          "cpu" : "1.0",                             (13)
          "mem" : "512m",                            (14)
        },
        "50.0" :{
            // ...
        }
      }
    },
    "chrome": {
        // ...
    }
}

4.2.1. Browser Name and Version

Browser name and version are just strings that are matched against Selenium desired capabilities:

If no version capability is present default version is used. When there is no exact version match we also try to match by prefix.
That means version string in JSON should start with version string from capabilities.

4.2.2. Image

Image by default is a string with container specification in Docker format (hub.example.com/project/image:tag).

"46.0": {
    "image": ["/usr/bin/mybinary", "-arg1", "foo", "-arg2", "bar", "-arg3"],
    "port": "4444"
},

4.2.3. Other Optional Fields

"46.0": {
    //...
    "port": "",
    "tmpfs": {"/tmp": "size=512m", "/var": "size=128m"},
    "path" : "",
    "volumes": ["/from:/to", "/another:/one:ro"],
    "env" : ["TZ=Europe/Moscow", "ONE_MORE_VARIABLE=itsValue"],
    "hosts" : ["one.example.com:192.168.0.1", "two.example.com:192.168.0.2"],
    "labels" : {"component": "frontend", "project": "my-project"},
    "sysctl" : {"net.ipv4.tcp_timestamps": "2", "kern.maxprocperuid": "1000"},
    "shmSize" : 268435456,
},

4.2.4. Syncing Browser Images from Existing File

In some usage scenarios you may want to store browsers configuration file under version control and initialize Selenoid from this file. For example this is true if you wish to have consistently reproducing infrastructure and using such tools as Amazon Cloud Formation.

In order to pull browser images use on of the following options:

Option 1: using CM

Recent CM tool versions are able to configure Selenoid from existing browsers.json file as follows:

# ./cm selenoid start --browsers-json /path/to/your/browsers.json

This way is mainly useful when installing Selenoid from scratch or updating it i.e. as a part of CI build job.

Option 2: using jq

This way can be applied to a running cluster with tests with no downtime.

config/container-logs.json

{
    "Type" : "<driver-type>",   (1)
    "Config" : {                (2)
      "key1" : "value1",
      "key2" : "value2"
    }
}

--log-driver=syslog --log-opt syslog-address=tcp://192.168.0.42:123 --log-opt syslog-facility=daemon

config/container-logs.json

{
    "Type" : "syslog",
    "Config" : {
      "syslog-address" : "tcp://192.168.0.42:123",
      "syslog-facility" : "daemon"
    }
}

# kill -HUP <pid>
# docker kill -s HUP <container-id-or-name>

Request

$ curl -s http://example.com:4444/ping

Result

{
    "uptime": "2m46.854829503s",
    "lastReloadTime": "2017-05-12 12:33:06.322038542 +0300 MSK",
    "numRequests": 42
}

1. Update browsers configuration file (aka browsers.json) by adding or deleting desired browser versions

2. When adding new browsers in containers — pull respective container images, e.g.:

   $ docker pull selenoid/chrome:62.0

3. Restart Selenoid or hot reload its configuration.

4.5.1. The Short Way

This approach is mainly convenient for personal usage because Selenoid is restarted i.e. any running browser sessions are interrupted. Just type one Configuration Manager command:

This command will download latest Selenoid release, browser images, generate new browsers.json and restart Selenoid. You may want to add --vnc flag to download images with VNC support:

$ ./cm selenoid update --vnc

Another useful flag is total number of last browser versions to download (default is 2):

$ ./cm selenoid update --last-versions 5

If you wish to pull new images and regenerate configuration without restarting Selenoid then type:

$ ./cm selenoid configure --vnc --last-versions 5

4.5.2. A Bit Longer Way

We recommend to use this approach on production clusters because Selenoid configuration is reloaded without restart.

$ docker run -d --name selenoid                     
    -p 4444:4444                                    
    -e TZ=Europe/Moscow                             
    -v /etc/selenoid:/etc/selenoid:ro               
    -v /var/run/docker.sock:/var/run/docker.sock    
    aerokube/selenoid:latest-release

1. You created a directory /path/to/config with Browsers Configuration File inside named browsers.json.

   $ mkdir -p /path/to/config

2. You created empty configuration directories for logs and videos:

   $ mkdir -p /path/to/config/logs
   $ mkdir -p /path/to/config/video

4.7.1. Option 1. Running Selenoid in default Docker network

In that case bridge network mode should be used for all services:

version: '3'
services:
  selenoid:
    network_mode: bridge
    image: aerokube/selenoid:latest-release
    volumes:
      - "/path/to/config:/etc/selenoid"
      - "/var/run/docker.sock:/var/run/docker.sock"
      - "/path/to/config/video:/opt/selenoid/video"
      - "/path/to/config/logs:/opt/selenoid/logs"
    environment:
      - OVERRIDE_VIDEO_OUTPUT_DIR=/path/to/config/video
    command: ["-conf", "/etc/selenoid/browsers.json", "-video-output-dir", "/opt/selenoid/video", "-log-output-dir", "/opt/selenoid/logs"]
    ports:
      - "4444:4444"

4.7.2. Option 2. Running Selenoid in custom Docker network

In that case you have to add -container-network flag to Selenoid as follows:

version: '3'
networks:
  selenoid:
    external:
      name: selenoid # This assumes network is already created
services:
  selenoid:
    networks:
      selenoid: null
    image: aerokube/selenoid:latest-release
    volumes:
      - "/path/to/config:/etc/selenoid"
      - "/var/run/docker.sock:/var/run/docker.sock"
      - "/path/to/config/video:/opt/selenoid/video"
      - "/path/to/config/logs:/opt/selenoid/logs"
    environment:
      - OVERRIDE_VIDEO_OUTPUT_DIR=/path/to/config/video
    command: ["-conf", "/etc/selenoid/browsers.json", "-video-output-dir", "/opt/selenoid/video", "-log-output-dir", "/opt/selenoid/logs", "-container-network", "selenoid"]
    ports:
      - "4444:4444"

2017/11/01 19:12:38 [-] [NEW_REQUEST]
2017/11/01 19:12:38 [-] [NEW_REQUEST_ACCEPTED]
2017/11/01 19:12:38 [41301] [LOCATING_SERVICE] [firefox-45.0]
2017/11/01 19:12:38 [41301] [USING_DOCKER] [firefox-45.0]
2017/11/01 19:12:38 [41301] [CREATING_CONTAINER] [selenoid/firefox:45.0]
2017/11/01 19:12:38 [41301] [STARTING_CONTAINER] [selenoid/firefox:45.0] [19760edf330a87531eb2109cfbf1bd4b14c739afa08fe133eb1b9813b2ac6c31]
2017/11/01 19:12:39 [41301] [CONTAINER_STARTED] [selenoid/firefox:45.0] [19760edf330a87531eb2109cfbf1bd4b14c739afa08fe133eb1b9813b2ac6c31] [896.680954ms]
2017/11/01 19:12:40 [41301] [SERVICE_STARTED] [selenoid/firefox:45.0] [19760edf330a87531eb2109cfbf1bd4b14c739afa08fe133eb1b9813b2ac6c31] [605.184606ms]
2017/11/01 19:12:40 [41301] [PROXY_TO] [selenoid/firefox:45.0] [19760edf330a87531eb2109cfbf1bd4b14c739afa08fe133eb1b9813b2ac6c31] [http://172.17.0.3:4444/wd/hub]
2017/11/01 19:12:40 [41301] [SESSION_ATTEMPTED] [test-quota] [http://172.17.0.3:4444/wd/hub] [1]
2017/11/01 19:12:42 [41301] [SESSION_CREATED] [test-quota] [345bb886-7026-46d7-82d4-4788c0460110] [http://172.17.0.3:4444/wd/hub] [1] [4.155712239s]
....
2017/11/01 19:14:30 [SESSION_DELETED] [345bb886-7026-46d7-82d4-4788c0460110]

-capture-driver-logs
    Whether to add driver process logs to Selenoid output
-conf string
    Browsers configuration file (default "config/browsers.json")
-container-network string
    Network to be used for containers (default "default")
-cpu value
    Containers cpu limit as float e.g. 0.2 or 1.0
-disable-docker
    Disable docker support
-disable-privileged
    Whether to disable privileged container mode
-disable-queue
    Disable wait queue
-enable-file-upload
    File upload support
-graceful-period duration
    graceful shutdown period in time.Duration format, e.g. 300s or 500ms (default 5m0s)
-limit int
    Simultaneous container runs (default 5)
-listen string
    Network address to accept connections (default ":4444")
-log-conf string
    Container logging configuration file
-log-output-dir string
    Directory to save session log to
-max-timeout duration
    Maximum valid session idle timeout in time.Duration format (default 1h0m0s)
-mem value
    Containers memory limit e.g. 128m or 1g
-retry-count int
    New session attempts retry count (default 1)
-save-all-logs
    Whether to save all logs without considering capabilities
-service-startup-timeout duration
    Service startup timeout in time.Duration format (default 30s)
-session-attempt-timeout duration
    New session attempt timeout in time.Duration format (default 30s)
-session-delete-timeout duration
    Session delete timeout in time.Duration format (default 30s)
-timeout duration
    Session idle timeout in time.Duration format (default 1m0s)
-version
    Show version and exit
-video-output-dir string
    Directory to save recorded video to (default "video")
-video-recorder-image string
    Image to use as video recorder (default "selenoid/video-recorder:latest-release")

$ ./selenoid -conf ~/.aerokube/selenoid/browsers.json -limit 10

# docker run -d --name selenoid                     
    -p 4444:4444                                    
    -v ~/.aerokube/selenoid/:/etc/selenoid/:ro      
    -v /var/run/docker.sock:/var/run/docker.sock    
    aerokube/selenoid:latest-release                
    -conf /etc/selenoid/browsers.json -limit 10 -video-output-dir /opt/selenoid/video/

4.9.1. S3 CLI Flags

The following flags are supported by selenoid command when compiled with S3 support:

-s3-access-key string
    S3 access key
-s3-bucket-name string
    S3 bucket name
-s3-endpoint string
    S3 endpoint URL
-s3-exclude-files string
    Pattern used to match and exclude files
-s3-force-path-style
    Force path-style addressing for file upload
-s3-include-files string
    Pattern used to match and include files
-s3-keep-files
    Do not remove uploaded files
-s3-key-pattern string
    S3 bucket name (default "$fileName")
-s3-reduced-redundancy
    Use reduced redundancy storage class
-s3-region string
    S3 region
-s3-secret-key string
    S3 secret key

$ docker run --rm -v ./docs/:/documents/      
    asciidoctor/docker-asciidoctor                
    asciidoctor -D /documents/output/ index.adoc

1) This 404 error comes from Selenoid, meaning there is no such API / in Selenium protocol. In the next release opening / will be showing Selenoid version (as this behavior is frequently confusing new users).

2) On Windows with installed Docker you don’t have to create configuration files manually. Just download CM binary and run it as follows:

> cm selenoid start

This command will download and generate the rest.

Feel free to contact us in Telegram channel if something does not work.

answered Oct 16, 2019 at 5:52