Guide d’auto-hébergement de Browserless Thunders

Présentation

L'image Thunders Browserless est un conteneur unifié qui regroupe :

Browserless Enterprise - Moteur de navigateur sans interface graphique prenant en charge Chromium, Firefox et WebKit
Nginx Reverse Proxy - Routage des requêtes, proxy WebSocket, contrôles d'intégrité et service de fichiers
Azure Relay Bridge - Connexion sortante uniquement vers Azure Relay pour une communication sécurisée avec la plateforme Thunders

Ces trois composants s'exécutent au sein d'un seul conteneur géré par supervisord, ce qui simplifie le déploiement.

Note : Dans ce guide, désigne le nom du dépôt d'images spécifique à votre organisation, fourni par Thunders. Remplacez-le par le nom réel que vous avez reçu (par exemple, tunisietelecom, acme-corp, etc.).

Fonctionnement

Points clés :

Aucune règle de pare-feu entrante requise - Le relais se connecte en sortie à Azure Relay via HTTPS (port 443)
Aucun VPN n'est nécessaire - Azure Relay gère le tunneling sécurisé
Conteneur unique: une seule image à récupérer, un seul conteneur à exécuter

Prérequis

Un abonnement Azure (ou tout environnement capable d'exécuter des conteneurs Docker)
Identifiants ACR fournis par Thunders (pour récupérer l'image)
Configuration d'Azure Relay (voir la section Azure Relay ci-dessous)
Pour les déploiements Azure : CLI Azure installée et authentifiée

Identifiants que vous recevrez de Thunders

Thunders vous fournira les informations d'identification suivantes pour votre déploiement :

Identifiant	Description
Serveur ACR	URL du registre de conteneurs (par exemple, `thundersacr-xxx.azurecr.io`)
Nom d'utilisateur ACR	Nom du jeton pour extraire l'image
Mot de passe ACR	Mot de passe du jeton pour récupérer l'image
Espace de noms Relay	Espace de noms Azure Relay (si géré par Thunders)
Nom de la connexion hybride Relay	Nom de la connexion hybride (si gérée par Thunders)
Clé d'écoute du relais	Clé SAS pour le listener du relais (si géré par Thunders)

Conservez-les en lieu sûr. Ne les enregistrez jamais dans le contrôle de version.

Configuration d'Azure Relay

Azure Relay permet une communication sécurisée entre la plateforme Thunders et votre instance sans navigateur auto-hébergée sans ouvrir de ports de pare-feu entrants. Il existe deux options de configuration :

Option A : Relay géré par Thunders (recommandé)

Thunders crée et gère l'espace de noms Azure Relay et la connexion hybride dans l'abonnement Azure de Thunders. Vous recevrez :

RELAY_NAMESPACE - L'URL de l'espace de noms du relais
RELAY_HYCO - Le nom de la connexion hybride
RELAY_LISTEN_KEY - La clé SAS avec autorisation d'écoute

Votre conteneur se connecte en sortie à ce relais. La plateforme Thunders se connecte depuis l'autre côté en utilisant des autorisations d'envoi.

Aucune configuration d'Azure Relay n'est requise de votre côté.

Option B : Relais géré par le client

Si vous préférez gérer le relais dans votre propre abonnement Azure :

1. Créez un espace de noms de relais Azure :

az relay namespace create \
  --resource-group <your-rg> \
  --name <relay-namespace-name> \
  --location <azure-region>

2. Créez une connexion hybride :

az relay hyco create \
  --resource-group <your-rg> \
  --namespace-name <relay-namespace-name> \
  --name <hybrid-connection-name>

3. Créez des règles d'autorisation :

Créez une règle d'écoute (pour votre conteneur auto-hébergé) :

az relay hyco authorization-rule create \
  --resource-group <your-rg> \
  --namespace-name <relay-namespace-name> \
  --hybrid-connection-name <hybrid-connection-name> \
  --name listen \
  --rights Listen

Créez une règle d'envoi (pour la plateforme Thunders) :

az relay hyco authorization-rule create \
  --resource-group <your-rg> \
  --namespace-name <relay-namespace-name> \
  --hybrid-connection-name <hybrid-connection-name> \
  --name send \
  --rights Send

4. Récupérez les clés :

Obtenez la clé d'écoute (pour votre conteneur) :

az relay hyco authorization-rule keys list \
  --resource-group <your-rg> \
  --namespace-name <relay-namespace-name> \
  --hybrid-connection-name <hybrid-connection-name> \
  --name listen \
  --query primaryKey -o tsv

Récupérez la clé d'envoi (partagez-la avec Thunders) :

az relay hyco authorization-rule keys list \
  --resource-group <your-rg> \
  --namespace-name <relay-namespace-name> \
  --hybrid-connection-name <hybrid-connection-name> \
  --name send \
  --query primaryKey -o tsv

5. Partagez-la avec Thunders :

Espace de noms de relais : <nom-de-l'espace-de-noms-du-relais>.servicebus.windows.net
Nom de la connexion hybride : <nom-de-connexion-hybride>
Nom de la clé d'envoi : send
Secret de la clé d'envoi : (la clé d'envoi de l'étape 4)

Thunders configurera ces éléments sur sa plateforme pour se connecter à votre relais.

Référence des variables d'environnement

Variables requises

Variable	Description	Exemple
`RELAY_NAMESPACE`	Espace de noms Azure Relay	`myrelay.servicebus.windows.net`
`RELAY_HYCO`	Nom de la connexion hybride	`thunder-browserless`
`RELAY_LISTEN_KEY`	Clé SAS avec autorisation d'écoute	`clé-encodée-en-base64`

Variables facultatives

Variable	Valeur par défaut	Description
`CONCURRENT`	`15`	Nombre maximal de sessions de navigateur simultanées
`TIMEOUT`	`1800000`	Délai d'expiration de la session en millisecondes (par défaut : 30 minutes)
`EXTERNAL`	`http://localhost:3000`	URL externe de cette instance (utilisée dans les réponses de santé)

Ports

Port	Service	Description
`3000`	Nginx (exposé)	Point d'entrée principal, contrôles de santé, proxy WebSocket
`3001`	Sans navigateur (interne)	Moteur de navigateur (proxysé via Nginx)
`3002`	Contrôle de l'état de santé (interne)	Service de calcul du score de santé
`8080`	Pont de relais (interne)	Point de terminaison d'intégrité du pont Azure Relay

Seul le port 3000 doit être exposé.

Options de déploiement

Option 1 : Azure Container Apps (recommandé)

Azure Container Apps fournit une plateforme d'hébergement de conteneurs gérée avec mise à l'échelle intégrée, sondes de santé et HTTPS.

Déploiement rapide avec Azure CLI

# Login to Azure
az login

# Set variables
RESOURCE_GROUP="rg-thunder-browserless"
LOCATION="westeurope"
ENV_NAME="env-thunder-browserless"
APP_NAME="thunder-browserless"

# Create resource group
az group create --name $RESOURCE_GROUP --location $LOCATION

# Create Container Apps environment
az containerapp env create \
  --name $ENV_NAME \
  --resource-group $RESOURCE_GROUP \
  --location $LOCATION

# Deploy the container app
az containerapp create \
  --name $APP_NAME \
  --resource-group $RESOURCE_GROUP \
  --environment $ENV_NAME \
  --image <THUNDER_ACR_SERVER>/<CUSTOMER_NAME>:latest \
  --registry-server <THUNDER_ACR_SERVER> \
  --registry-username <THUNDER_ACR_USERNAME> \
  --registry-password <THUNDER_ACR_PASSWORD> \
  --target-port 3000 \
  --ingress internal \
  --cpu 4.0 \
  --memory 8.0Gi \
  --min-replicas 1 \
  --max-replicas 1 \
  --env-vars \
    CONCURRENT=15 \
    TIMEOUT=1800000 \
    RELAY_NAMESPACE=<YOUR_RELAY_NAMESPACE> \
    RELAY_HYCO=<YOUR_RELAY_HYCO> \
    RELAY_LISTEN_KEY=secretref:relay-key \
  --secrets \
    relay-key=<YOUR_RELAY_LISTEN_KEY>

Déploiement avec un modèle ARM

Utilisez le modèle ARM fourni pour un déploiement plus personnalisable :

az deployment group create \
  --resource-group $RESOURCE_GROUP \
  --template-file customer-browserless-template.json \
  --parameters \
    containerAppName=$APP_NAME \
    containerAppEnvironmentId=$(az containerapp env show -g $RESOURCE_GROUP -n $ENV_NAME --query id -o tsv) \
    containerImage=<THUNDER_ACR_SERVER>/<CUSTOMER_NAME>:latest \
    acrServer=<THUNDER_ACR_SERVER> \
    acrUsername=<THUNDER_ACR_USERNAME> \
    acrPassword=<THUNDER_ACR_PASSWORD> \
    relayNamespace=<YOUR_RELAY_NAMESPACE> \
    relayHycoName=<YOUR_RELAY_HYCO> \
    relayListenKey=<YOUR_RELAY_LISTEN_KEY>

Option 2 : Azure Container Instances (ACI)

Azure Container Instances propose un hébergement de conteneurs sans serveur. Plus simple, mais avec moins de fonctionnalités que Container Apps.

# Create resource group
az group create --name rg-thunder-browserless --location westeurope

# Deploy container
az container create \
  --resource-group rg-thunder-browserless \
  --name thunder-browserless \
  --image <THUNDER_ACR_SERVER>/<CUSTOMER_NAME>:latest \
  --registry-login-server <THUNDER_ACR_SERVER> \
  --registry-username <THUNDER_ACR_USERNAME> \
  --registry-password <THUNDER_ACR_PASSWORD> \
  --cpu 4 \
  --memory 8 \
  --ports 3000 \
  --ip-address Private \
  --environment-variables \
    CONCURRENT=15 \
    TIMEOUT=1800000 \
    RELAY_NAMESPACE=<YOUR_RELAY_NAMESPACE> \
    RELAY_HYCO=<YOUR_RELAY_HYCO> \
    RELAY_LISTEN_KEY=<YOUR_RELAY_LISTEN_KEY> \
  --restart-policy Always

# Check status
az container show \
  --resource-group rg-thunder-browserless \
  --name thunder-browserless \
  --query "{status:instanceView.state, ip:ipAddress.ip}" \
  -o table

Option 3 : Azure Kubernetes Service (AKS)

Pour les organisations qui exploitent déjà des clusters AKS.

Créer un secret Kubernetes

# Create namespace
kubectl create namespace thunder

# Create image pull secret
kubectl create secret docker-registry thunder-acr \
  --namespace thunder \
  --docker-server=<THUNDER_ACR_SERVER> \
  --docker-username=<THUNDER_ACR_USERNAME> \
  --docker-password=<THUNDER_ACR_PASSWORD>

# Create secrets for environment variables
kubectl create secret generic thunder-browserless-secrets \
  --namespace thunder \
  --from-literal=RELAY_LISTEN_KEY=<YOUR_RELAY_LISTEN_KEY>

Manifeste de déploiement Kubernetes

Enregistrez ce qui suit sous le nom thunder-browserless.yaml:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: thunder-browserless
  namespace: thunder
spec:
  replicas: 1
  selector:
    matchLabels:
      app: thunder-browserless
  template:
    metadata:
      labels:
        app: thunder-browserless
    spec:
      imagePullSecrets:
        - name: thunder-acr
      containers:
        - name: thunder-browserless
          image: <THUNDER_ACR_SERVER>/<CUSTOMER_NAME>:latest
          ports:
            - containerPort: 3000
          env:
            - name: CONCURRENT
              value: "15"
            - name: TIMEOUT
              value: "1800000"
            - name: RELAY_NAMESPACE
              value: "<YOUR_RELAY_NAMESPACE>"
            - name: RELAY_HYCO
              value: "<YOUR_RELAY_HYCO>"
            - name: RELAY_LISTEN_KEY
              valueFrom:
                secretKeyRef:
                  name: thunder-browserless-secrets
                  key: RELAY_LISTEN_KEY
          resources:
            requests:
              cpu: "2"
              memory: "4Gi"
            limits:
              cpu: "4"
              memory: "8Gi"
          startupProbe:
            httpGet:
              path: /health
              port: 3000
            initialDelaySeconds: 10
            periodSeconds: 10
            timeoutSeconds: 10
            failureThreshold: 30
          livenessProbe:
            httpGet:
              path: /health
              port: 3000
            periodSeconds: 30
            timeoutSeconds: 10
            failureThreshold: 3
          readinessProbe:
            httpGet:
              path: /health
              port: 3000
            periodSeconds: 10
            timeoutSeconds: 10
            failureThreshold: 3
---
apiVersion: v1
kind: Service
metadata:
  name: thunder-browserless
  namespace: thunder
spec:
  type: ClusterIP
  selector:
    app: thunder-browserless
  ports:
    - port: 3000
      targetPort: 3000
      protocol: TCP

Appliquer :

kubectl apply -f thunder-browserless.yaml

Option 4 : Docker (machine virtuelle ou sur site)

Pour une exécution directe sur une machine virtuelle ou un serveur sur site.

Télécharger et exécuter

# Login to Thunders's ACR
docker login <THUNDER_ACR_SERVER> \
  -u <THUNDER_ACR_USERNAME> \
  -p <THUNDER_ACR_PASSWORD>

# Pull the image
docker pull <THUNDER_ACR_SERVER>/<CUSTOMER_NAME>:latest

# Run the container
docker run -d \
  --name thunder-browserless \
  --restart unless-stopped \
  -p 3000:3000 \
  -e CONCURRENT=15 \
  -e TIMEOUT=1800000 \
  -e RELAY_NAMESPACE=<YOUR_RELAY_NAMESPACE> \
  -e RELAY_HYCO=<YOUR_RELAY_HYCO> \
  -e RELAY_LISTEN_KEY=<YOUR_RELAY_LISTEN_KEY> \
  --shm-size=2g \
  <THUNDER_ACR_SERVER>/<CUSTOMER_NAME>:latest

Important : le drapeau --shm-size=2g est obligatoire. Chromium utilise /dev/shm pour la mémoire partagée, et la valeur par défaut de 64 Mo est insuffisante pour l'automatisation du navigateur.

Docker Compose

Enregistrez sous le nom docker-compose.yml:

services:
  thunder-browserless:
    image: <THUNDER_ACR_SERVER>/<CUSTOMER_NAME>:latest
    container_name: thunder-browserless
    restart: unless-stopped
    ports:
      - "3000:3000"
    environment:
      - CONCURRENT=${CONCURRENT:-15}
      - TIMEOUT=${TIMEOUT:-1800000}
      - RELAY_NAMESPACE=${RELAY_NAMESPACE}
      - RELAY_HYCO=${RELAY_HYCO}
      - RELAY_LISTEN_KEY=${RELAY_LISTEN_KEY}
    shm_size: 2g
    deploy:
      resources:
        limits:
          cpus: "4.0"
          memory: 8G
        reservations:
          cpus: "2.0"
          memory: 4G

Créez un fichier .env à côté de docker-compose.yml:

RELAY_NAMESPACE=your-relay.servicebus.windows.net
RELAY_HYCO=your-hybrid-connection
RELAY_LISTEN_KEY=your-listen-key
CONCURRENT=15
TIMEOUT=1800000

Exécuter :

docker compose up -d

Contrôles d'intégrité et surveillance

Point de terminaison de santé

Le conteneur expose les contrôles d'intégrité à l'adresse suivante :

GET /health - Renvoie l'état de santé avec un score
GET /healthz - Alias pour /health

Réponse « en bon état » (HTTP 200) :

{
  "origin": "http://localhost:3000",
  "healthy": true,
  "score": 85,
  "error": null,
  "pressure": {
    "cpu": 15,
    "memory": 45,
    "running": 2,
    "maxConcurrent": 15,
    "queued": 0,
    "isAvailable": true
  },
  "scores": {
    "cpu": 84,
    "memory": 44,
    "concurrent": 87
  },
  "timestamp": "2026-01-15T10:30:00.000Z"
}

Réponse indiquant un problème (HTTP 503) :

Renvoyée lorsque l'utilisation du CPU dépasse 95 %, celle de la mémoire dépasse 80 % ou que le nombre de sessions simultanées atteint son maximum.

Recommandations de surveillance

Interrogez /health toutes les 15 à 30 secondes
Déclencher une alerte lorsque l'état est « false » pendant plus de 2 vérifications consécutives
Surveillez pressure.running par rapport à pressure.maxConcurrent pour la planification de la capacité
Suivre les tendances de scores.cpu et scores.memory pour les décisions de mise à l'échelle

Affichage des journaux

Applications de conteneurs Azure :

az containerapp logs show -g <resource-group> -n <app-name> --follow

Instances de conteneurs Azure :

az container logs --resource-group <resource-group> --name <container-name> --follow

Docker :

docker logs -f thunder-browserless

Kubernetes :

kubectl logs -f deployment/thunder-browserless -n thunder

Lorsque tout est prêt

Une fois votre conteneur déployé et le pont de relais connecté, veuillez nous en informer.

Vous devriez alors voir apparaître un nouvel emplacement dans Thunders intitulé : - Self Hosted.

Sélectionnez-la et effectuez un test rapide pour vérifier que tout fonctionne comme prévu.

Si vous testez un site web non HTTPS, activez Ignorer les erreurs de certificat HTTPS pendant les tests dans les paramètres avancés de l'emplacement.

Dépannage

Le conteneur ne démarre pas

1. Vérifiez les journaux pour voir s'il manque des variables d'environnement :

Required environment variable RELAY_NAMESPACE is not set

Assurez-vous que toutes les variables d'environnement requises sont définies.

2. Vérifiez les informations d'identification ACR :

echo '<password>' | docker login <THUNDER_ACR_SERVER> -u <username> --password-stdin
docker pull <THUNDER_ACR_SERVER>/<CUSTOMER_NAME>:latest

Le pont de relais ne se connecte pas

Vérifiez la connectivité sortante sur le port 443 vers *.servicebus.windows.net
Vérifiez les journaux du pont de relais pour détecter d'éventuelles erreurs de connexion
Vérifiez que RELAY_NAMESPACE, RELAY_HYCO et RELAY_LISTEN_KEY sont corrects
Le pont de relais se reconnecte automatiquement toutes les 5 secondes en cas de déconnexion

Le test de santé renvoie 503

Seuil CPU dépassé : réduisez la valeur CONCURRENT ou allouez plus de CPU
Seuil de mémoire dépassé : allouez davantage de mémoire ou réduisez la valeur de CONCURRENT
Toutes les sessions sont occupées : attendez que les sessions se terminent ou augmentez la valeur de CONCURRENT

Expiration des sessions du navigateur

Augmentez la valeur TIMEOUT (par défaut : 1 800 000 ms = 30 minutes)
Vérifiez la latence réseau entre votre infrastructure et Azure Relay

Erreurs de mémoire partagée

Si vous utilisez Docker, assurez-vous que --shm-size=2g est défini. Chromium nécessite plus que les 64 Mo de mémoire partagée par défaut.

Guide de dimensionnement des ressources

Sessions simultanées	CPU	Mémoire	Mémoire partagée
5	2 cœurs	4 Go	1 Go
15 (par défaut)	4 cœurs	8 Go	2 Go
30	8 cœurs	16 Go	4 Go
60	16 cœurs	32 Go	8 Go

Il s'agit des configurations minimales recommandées. Les exigences réelles dépendent de la complexité des pages Web testées.

Configuration réseau

Direction	Protocole	Port	Destination	Objectif
Sortant	HTTPS/WSS	443	`*.servicebus.windows.net`	Connexion Azure Relay
Sortant	HTTPS	443	Applications Web cibles	Automatisation du navigateur
Entrant (facultatif)	HTTP	3000	Réseau local	Contrôles d'intégrité (non requis pour le relais)

Aucun accès Internet entrant n'est requis pour que la connexion de relais fonctionne.

Pour obtenir une assistance technique ou poser des questions sur l'architecture, veuillez contacter notre équipe d'assistance à l'adresse [email protected].

Autres articles connexes qui pourraient vous être utiles :

→ Tests de navigateur auto-hébergés avec Azure Relay