Selenium met Chrome uitvoeren in Docker

Soms is het handig om Selenium in Python binnen een Docker-container te gebruiken. Dit roept vragen op over de voordelen van deze aanpak, de versiecompatibiliteit tussen ChromeDriver en Chromium, en de details van de implementatie. In dit artikel bespreken we de belangrijkste overwegingen en bieden we oplossingen voor veelvoorkomende problemen.

Waarom Selenium in Docker draaien?

Het uitvoeren van Selenium in een container biedt meerdere voordelen:

• 🧩 Draagbaarheid – Het test- of ontwikkelomgeving kan eenvoudig tussen machines worden verplaatst, zonder versieconflicten of OS-specifieke afhankelijkheden.

• 🧱 Isolatie – De Selenium-container kan snel worden vervangen of bijgewerkt zonder andere serveronderdelen te beïnvloeden.

• ⚙️ CI/CD-compatibiliteit – Dockerized Selenium integreert uitstekend met CI/CD-pipelines: je kunt voor elke test een schone omgeving opbouwen en weer afbreken.

Ubuntu-server voorbereiden voor Selenium met Docker

Controleer eerst of Docker en Docker Compose zijn geïnstalleerd:

docker --version && docker compose version

💡 In sommige versies heet het commando docker-compose in plaats van docker compose.

Als de tools aanwezig zijn, verschijnt hun versienummer. Zo niet, installeer ze dan voordat je verder gaat.

Voorbeeld: Selenium uitvoeren in Docker

Bij het inzetten van Selenium in Docker-containers moet je letten op:

• de host-architectuur,

• de functionele vereisten,

• en de prestaties.

De officiële selenium/standalone-*-afbeeldingen zijn bedoeld voor AMD64 (x86_64)-CPU’s, terwijl seleniarm/standalone-* geoptimaliseerd is voor ARM-architecturen (zoals Apple Silicon of ARM64-servers).

Maak in de hoofdmap van je project een bestand docker-compose.yml aan:

version: "3"

services:
  app:
    build: .
    restart: always
    volumes:
      - .:/app
    depends_on:
      - selenium
    platform: linux/amd64

  selenium:
    image: selenium/standalone-chromium:latest # For AMD64
#    image: seleniarm/standalone-chromium:latest # For ARM64
    container_name: selenium-container
    restart: unless-stopped
    shm_size: 2g
    ports:
      - "4444:4444"  # Selenium WebDriver API
      - "7900:7900"  # VNC Viewer
    environment:
      - SE_NODE_MAX_SESSIONS=1
      - SE_NODE_OVERRIDE_MAX_SESSIONS=true
      - SE_NODE_SESSION_TIMEOUT=300
      - SE_NODE_GRID_URL=http://localhost:4444
      - SE_NODE_DETECT_DRIVERS=false

Kies het juiste image voor jouw systeemarchitectuur door de juiste regel te activeren. De service app bevat je Python-code.

Gebruik hiervoor een standaard Dockerfile:

# Use a minimal Python image
FROM python:3.11-slim

# Set working directory
WORKDIR /app

# Install Python dependencies
COPY requirements.txt /app/
RUN pip install --no-cache-dir -r requirements.txt

# Copy project files
COPY . /app/

# Set environment variables (Chromium is in a separate container)
ENV SELENIUM_REMOTE_URL="http://selenium:4444/wd/hub"

# Run Python script
CMD ["python", "main.py"]

Deze configuratie gebruikt een lichte Python-basisimage en installeert automatisch alle vereiste pakketten.

Hoofdscript (main.py)

import time  # Used to create a delay for checking browser functionality
import os

from selenium import webdriver
from selenium.webdriver.chrome.service import Service
from selenium.webdriver.chrome.options import Options

# WebDriver settings
chrome_options = Options()
chrome_options.add_argument("--no-sandbox")
chrome_options.add_argument("--disable-dev-shm-usage")
chrome_options.add_argument("--disable-gpu")
chrome_options.add_argument("--disable-webrtc")
chrome_options.add_argument("--hide-scrollbars")
chrome_options.add_argument("--disable-notifications")
chrome_options.add_argument("--start-maximized")

SELENIUM_REMOTE_URL = os.getenv("SELENIUM_REMOTE_URL", "http://selenium:4444/wd/hub")

driver = webdriver.Remote(
    command_executor=SELENIUM_REMOTE_URL,
    options=chrome_options
)

# Open a test page
driver.get("https://www.hostman.com")

time.sleep(9999)

# Shut down WebDriver
driver.quit()

requirements.txt

attrs==25.1.0
certifi==2025.1.31
h11==0.14.0
idna==3.10
outcome==1.3.0.post0
PySocks==1.7.1
selenium==4.28.1
sniffio==1.3.1
sortedcontainers==2.4.0
trio==0.28.0
trio-websocket==0.11.1
typing_extensions==4.12.2
urllib3==2.3.0
websocket-client==1.8.0
wsproto==1.2.0

Containers starten

Start de containers met:

docker compose up -d

Docker bouwt de images en start ze op de achtergrond.

Controleer of alles werkt:

docker compose ps

Als beide containers actief zijn, is de installatie geslaagd en kun je Selenium gebruiken om websites te automatiseren.

Selenium debuggen in Docker met VNC

In de officiële Selenium-afbeeldingen (zoals selenium/standalone-chrome of seleniarm/standalone-chromium) wordt de directe toegang tot het Chrome DevTools Protocol (CDP) beheerd door Selenium Grid. Elke sessie krijgt een eigen WebSocket-poort, waardoor externe toegang niet mogelijk is.

De vlag --remote-debugging-port=9229 wordt genegeerd of overschreven. Daarom wordt gebruikgemaakt van een ingebouwde VNC-server (Virtual Network Computing), vergelijkbaar met TeamViewer of AnyDesk.

⚠️ De headless-modus moet worden uitgeschakeld, anders is er geen zichtbaar scherm om te streamen.

Open de VNC-webinterface op:

http://<server_ip>:7900

Bij de eerste verbinding wordt om een wachtwoord gevraagd. Maak dit wachtwoord in de container aan:

docker exec -it selenium-container bash

Then enter:

x11vnc -storepasswd

Voer het wachtwoord in, bevestig het, en gebruik het vervolgens in de VNC-interface. Je krijgt nu toegang tot de browser die binnen Docker door Selenium wordt bestuurd. Hier kun je de DevTools openen, DOM-elementen inspecteren of netwerkverzoeken analyseren.

Conclusie

Het uitvoeren van Selenium in Docker-containers maakt je omgeving draagbaar, vermindert versieconflicten en integreert naadloos met CI/CD-workflows. Bovendien kun je via VNC visueel debuggen wanneer dat nodig is.

Let er bij het gebruik op om:

• de juiste image voor je systeem (AMD64 of ARM64) te kiezen,

• en de headless-modus uit te schakelen als je een grafische interface wilt gebruiken.

Deze aanpak biedt een flexibele, betrouwbare en reproduceerbare testinfrastructuur voor geautomatiseerde browser-tests met Selenium en Docker.