Docker empaquète vos tests Playwright, votre version de Node et les dépendances navigateurs dans une image qui s'exécute de façon identique sur votre machine, celle d'un collègue, et en CI. Fini les échecs de tests liés à l'environnement.

Pourquoi Docker change quelque chose pour un testeur

Sans Docker :

  • vos tests passent en local avec Node 20, échouent en CI avec Node 18
  • la version de Chrome en CI diffère de celle sur votre machine
  • les variables d'environnement sont configurées différemment selon les machines
  • un nouveau membre de l'équipe passe une journée à faire tourner les tests

Avec Docker, les tests s'exécutent dans le même conteneur en local et en CI. Tout le monde utilise les mêmes versions de Node, Chrome et des dépendances. Pour un nouveau membre, docker compose up suffit et les tests tournent en deux minutes.

Concepts de base

Image

Une image est un plan de construction : un snapshot en lecture seule d'un système de fichiers avec les logiciels installés. C'est l'équivalent d'une classe en code.

playwright/playwright:latest — image avec Playwright et navigateurs pré-installés
node:20-alpine — Node.js 20 sur Alpine Linux minimal

Conteneur

Un conteneur est une instance en cours d'exécution d'une image. Plusieurs conteneurs peuvent s'exécuter depuis la même image simultanément. Comme créer plusieurs objets depuis la même classe.

Dockerfile

Les instructions pour construire une image personnalisée. On part d'une image de base et on y ajoute ses fichiers et sa configuration.

Docker Compose

Un outil pour faire tourner plusieurs conteneurs ensemble. Vos tests ont peut-être besoin d'un serveur web et d'une base de données : Compose démarre tout avec une seule commande.

Votre premier Dockerfile Playwright

Playwright fournit des images Docker officielles avec les navigateurs pré-installés :

# Dockerfile
FROM mcr.microsoft.com/playwright:v1.44.0-jammy

# Répertoire de travail dans le conteneur
WORKDIR /app

# Copier les fichiers de dépendances en premier (optimisation du cache)
COPY package.json package-lock.json ./

# Installer les dépendances Node
RUN npm ci

# Copier le reste du projet
COPY . .

# Commande par défaut : lancer tous les tests
CMD ["npx", "playwright", "test"]

Construire l'image :

docker build -t my-playwright-tests .

Lancer les tests :

docker run my-playwright-tests

Chrome, Firefox et WebKit sont tous dans le conteneur. Pas d'installation de navigateur nécessaire sur la machine hôte.

Exécuter les tests avec Docker

Run basique

# Lancer tous les tests
docker run my-playwright-tests

# Lancer un fichier de test spécifique
docker run my-playwright-tests npx playwright test tests/login.spec.ts

# Lancer avec une variable d'environnement
docker run -e BASE_URL=https://staging.myapp.com my-playwright-tests

# Monter un répertoire local (pour voir les résultats)
docker run -v $(pwd)/playwright-report:/app/playwright-report my-playwright-tests

Sauvegarder les résultats

Le système de fichiers du conteneur disparaît quand il s'arrête. Utilisez des volumes pour conserver les rapports :

docker run \
  -v $(pwd)/playwright-report:/app/playwright-report \
  -v $(pwd)/test-results:/app/test-results \
  my-playwright-tests

Après l'exécution, playwright-report/ apparaît sur votre machine locale.

Docker Compose pour les tests full stack

En pratique, tester une application signifie souvent faire tourner l'application testée en même temps. Compose démarre tout ensemble.

# docker-compose.yml
version: '3.8'

services:
  # L'application à tester
  app:
    image: myapp:latest
    ports:
      - "3000:3000"
    environment:
      - NODE_ENV=test
      - DATABASE_URL=postgresql://postgres:postgres@db:5432/testdb
    depends_on:
      db:
        condition: service_healthy

  # Base de données
  db:
    image: postgres:16
    environment:
      POSTGRES_USER: postgres
      POSTGRES_PASSWORD: postgres
      POSTGRES_DB: testdb
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U postgres"]
      interval: 5s
      timeout: 5s
      retries: 5

  # Tests Playwright
  tests:
    build: .
    environment:
      - BASE_URL=http://app:3000
    depends_on:
      - app
    volumes:
      - ./playwright-report:/app/playwright-report
      - ./test-results:/app/test-results

Lancer l'ensemble :

docker compose up --exit-code-from tests

Cette commande démarre la base de données, attend qu'elle soit saine, démarre l'application, exécute les tests, puis retourne le code de sortie des tests. CI sait ainsi si le run est passé ou échoué. L'option --exit-code-from tests garantit que c'est le code de sortie du conteneur tests qui compte.

Optimiser le Dockerfile

Le cache des layers accélère les rebuilds. La règle clé : mettez en haut ce qui change rarement.

FROM mcr.microsoft.com/playwright:v1.44.0-jammy

WORKDIR /app

# 1. Copier les fichiers de dépendances (changent rarement)
COPY package.json package-lock.json ./
# Ce layer est mis en cache jusqu'au prochain changement de package.json
RUN npm ci

# 2. Copier le reste (change à chaque commit)
COPY . .

CMD ["npx", "playwright", "test"]

Si vous modifiez uniquement des fichiers de test, Docker réutilise le layer npm ci depuis le cache. Temps de build : quelques secondes au lieu de plusieurs minutes.

Intégration CI/CD

GitHub Actions

# .github/workflows/playwright.yml
name: Playwright Tests

on: [push, pull_request]

jobs:
  test:
    runs-on: ubuntu-latest

    steps:
      - uses: actions/checkout@v4

      - name: Build test image
        run: docker build -t playwright-tests .

      - name: Run tests
        run: |
          docker run \
            -v ${{ github.workspace }}/playwright-report:/app/playwright-report \
            -e BASE_URL=${{ secrets.STAGING_URL }} \
            playwright-tests

      - name: Upload report
        uses: actions/upload-artifact@v4
        if: always()
        with:
          name: playwright-report
          path: playwright-report/

GitLab CI

# .gitlab-ci.yml
test:
  image: docker:latest
  services:
    - docker:dind
  script:
    - docker build -t tests .
    - docker run
        -v $(pwd)/playwright-report:/app/playwright-report
        -e BASE_URL=$STAGING_URL
        tests
  artifacts:
    when: always
    paths:
      - playwright-report/

Commandes Docker utiles pour un testeur

# Lister les conteneurs en cours d'exécution
docker ps

# Lister toutes les images
docker images

# Arrêter tous les conteneurs en cours
docker stop $(docker ps -q)

# Supprimer tous les conteneurs arrêtés
docker container prune

# Supprimer les images inutilisées
docker image prune

# Suivre les logs d'un conteneur
docker logs -f <container-id>

# Ouvrir un shell dans un conteneur en cours (utile pour déboguer)
docker exec -it <container-id> /bin/bash

# Lancer un conteneur en mode interactif
docker run -it my-playwright-tests /bin/bash

Déboguer dans un conteneur

Quand les tests échouent uniquement dans le conteneur :

# Démarrer le conteneur avec un shell plutôt que les tests
docker run -it my-playwright-tests /bin/bash

# Vérifier ce qui est installé
node --version
npx playwright --version

# Lancer les tests manuellement
npx playwright test tests/login.spec.ts --headed --debug

# Vérifier les variables d'environnement
env | grep BASE_URL

Problèmes courants : BASE_URL pointe vers localhost alors qu'il faut le nom du service Docker, et les variables d'environnement peuvent être manquantes. Les fichiers créés hors du conteneur appartiennent parfois à root à l'intérieur.

L'image Docker officielle Playwright

# Télécharger l'image Playwright
docker pull mcr.microsoft.com/playwright:v1.44.0-jammy

# Explorer son contenu
docker run -it mcr.microsoft.com/playwright:v1.44.0-jammy /bin/bash

# Vérifier les navigateurs installés
npx playwright install --list

Tags à connaître : v1.44.0-jammy désigne une version Playwright spécifique sur Ubuntu 22.04 (Jammy), tandis que latest suit la dernière version et peut casser lors des mises à jour. Épinglez toujours une version spécifique en production.

Récapitulatif

| Concept | Ce que c'est |

|---------|--------------|

| Image | Plan avec logiciels pré-installés |

| Conteneur | Instance en cours d'exécution d'une image |

| Dockerfile | Instructions pour construire une image personnalisée |

| Docker Compose | Faire tourner plusieurs conteneurs ensemble |

| Volume mount | Partager des fichiers entre l'hôte et le conteneur |

Pour Playwright spécifiquement :

1. Utilisez mcr.microsoft.com/playwright comme image de base : navigateurs inclus

2. Montez les répertoires de rapports pour que les résultats survivent à l'arrêt du conteneur

3. Utilisez Compose pour démarrer votre application et vos tests ensemble

4. Épinglez les versions d'image : latest provoque des cassures imprévues

Docker transforme "ça marche sur ma machine" en "ça marche partout". Pour un testeur, cela signifie que vos tests vérifient vraiment le logiciel, sans se battre contre des différences d'environnement.

→ See also: Docker pour les Testeurs: Exécuter Playwright dans des Conteneurs | CI/CD pour QA: GitHub Actions, Jenkins et GitLab Comparés | GitHub Actions pour Tests Playwright: La Configuration Complète (2026)