Introduction

Dans ce guide étape par étape, vous apprendrez à lancer une automatisation multithread stable dans Browser Automation Studio (BAS) en utilisant des proxies mobiles. Nous configurerons l'environnement, connecterons des proxies mobiles, créerons un scénario multithread et vérifierons les résultats. À la fin, vous disposerez d'un projet BAS prêt à l'emploi qui s'exécute en plusieurs threads, utilise des adresses IP mobiles uniques par thread, journalise correctement les actions et peut se rétablir après des situations d'urgence. Nous examinerons chaque action en détail afin de minimiser le risque d'erreurs et de vous faire gagner du temps.

Ce matériel est destiné aux débutants, mais il contient également des éléments pour les utilisateurs avancés. Si vous n'avez jamais travaillé avec BAS, vous pourrez reproduire chaque étape grâce aux instructions détaillées. Si vous avez déjà une compréhension de base de l'automatisation, vous trouverez des pratiques prêtes à l'emploi pour optimiser le multithreading, travailler en toute sécurité avec des proxies mobiles et assurer un traitement fiable des erreurs.

Avant de commencer, vous devez connaître les bases de l'utilisation d'un ordinateur, la capacité à installer des programmes et comprendre des termes de base tels que « proxy », « thread » et « timeout ». Aucun talent de programmation complexe n'est requis : tout le processus est basé sur des blocs visuels de BAS, des paramètres clairs et des vérifications.

Préparez-vous à passer de 2 à 4 heures pour compléter toutes les étapes. Plus de temps sera nécessaire si c'est la première fois que vous installez les outils et configurez les proxies mobiles. Cependant, après la configuration initiale, vous pourrez rapidement mettre à l'échelle les scénarios et les exécuter sur différentes machines.

Conseil : Si vous souhaitez passer directement à la configuration des proxies, utilisez le lien interne vers la section « Étape 3 : Connexion et configuration des proxies mobiles dans BAS » — voir ci-dessous. Si vous êtes intéressé par des problèmes et leurs solutions, allez à la section « Erreurs typiques et solutions » — voir ci-dessous.

Préparation

Pour travailler efficacement, vous aurez besoin de plusieurs outils et étapes préparatoires indispensables. Suivez cette liste pour ne rien manquer. Nous indiquerons également les exigences système et expliquerons ce qu'il faut télécharger et comment l'installer correctement.

Outils, programmes et accès nécessaires

  • Un ordinateur sous Windows 10 ou plus récent. BAS est officiellement orienté vers Windows ; un lancement sous Linux via émulation est possible, mais n'est pas abordé dans ce guide.
  • La version actuelle de Browser Automation Studio (BAS) de l'année 2026. Téléchargez et installez cette version.
  • Un compte auprès d'un fournisseur de proxies mobiles. Divers fournisseurs conviennent ; par exemple, les proxies mobiles avec rotation flexible, tels que mobileproxy.space, sont fréquents.
  • Un éditeur de texte pour prendre des notes (comme le « Bloc-notes » standard) et un tableur (comme Excel) pour stocker les données des proxies et les identifiants.
  • Au moins 5 Go d'espace disque libre pour installer BAS, les données temporaires et les journaux.

Exigences système

  • Système d'exploitation : Windows 10/11 (64 bits).
  • RAM : au moins 8 Go (16 Go ou plus recommandés pour un multithreading intensif).
  • Processeur : 4 cœurs ou plus (6–8 cœurs ou plus recommandés pour un multithreading stable).
  • Disque dur : au moins 5 Go d'espace libre.
  • Connexion Internet stable : au minimum 20 Mbit/s, avec de faibles latences de préférence.

Ce qu'il faut télécharger, installer et configurer

  1. Téléchargez le paquet d'installation BAS à partir du site officiel du développeur. Assurez-vous que la version est correcte (2026) et compatible avec votre système d'exploitation.
  2. Installez BAS en suivant l'assistant d'installation standard : cliquez sur « Suivant », « J'accepte », « Installer ». Lancez BAS après l'installation.
  3. Obtenez l'accès aux proxies mobiles de votre fournisseur. Assurez-vous que vous avez l'IP/domaine, le port, le type d'autorisation (identifiant/mot de passe ou par IP), ainsi que la documentation sur le changement d'IP (rotation).
  4. Créez un dossier pour le projet BAS, les journaux et les sauvegardes. Exemple : C:\BAS\Projects\MobileProxyMultithread.
  5. Préparez un fichier CSV avec des données de test (si le scénario le demande), comme une liste d'URL à visiter. Exemple de fichier : urls.csv avec des lignes au format https://example.org/test1, https://example.org/test2.

Création de sauvegardes

Les sauvegardes permettent de revenir rapidement à un état fonctionnel si quelque chose ne va pas.

  • Créez une copie du dossier du projet BAS après chaque changement majeur : ajout de proxies — faites une sauvegarde ; ajout du multithreading — faites une sauvegarde.
  • Conservez les copies dans des sous-dossiers datés : C:\BAS\Backups\2026-06-xx\.
  • Dupliquez également les fichiers de scénario BAS (.xml) et les ressources (CSV, JSON, logos) dans un dossier séparé « Backup_Resources ».

⚠️ Attention : Si vous lancez des scénarios sur un ordinateur de travail, assurez-vous que l'antivirus ne bloque pas les activités de BAS. Ajoutez le dossier BAS aux exceptions si nécessaire. Avant cela, vérifiez la sécurité des sources.

✅ Vérification : Vous avez installé BAS, avez un accès actif aux proxies mobiles (identifiant/mot de passe ou autorisation par IP), créé la structure des dossiers pour le projet et les sauvegardes, et préparé les données de test.

Notions de base

Avant de configurer, passons à la théorie à un niveau pratique. Une compréhension claire des termes vous fera gagner du temps lors des étapes suivantes.

Qu'est-ce que BAS en termes simples

Browser Automation Studio est un outil visuel pour automatiser les actions dans un navigateur. Vous assemblez un scénario à partir de blocs, comme avec un jeu de construction. Chaque action est un bloc : « Ouvrir l'URL », « Cliquer », « Saisir du texte », « Changer de proxy », « Lancer dans un thread », etc. BAS ne nécessite pas de connaissances approfondies en programmation. Cependant, il offre de la flexibilité et vous permet de résoudre des tâches simples comme complexes : parsing, vérification de formulaires, surveillance, gestion de comptes, tests.

Proxy et proxies mobiles

Un proxy est un serveur intermédiaire entre votre ordinateur et le site auquel vous accédez. Lorsque vous utilisez un proxy, le site voit l'IP du proxy, pas la vôtre. Les proxies mobiles sont fournis via des réseaux cellulaires (3G/4G/5G), donc leurs adresses IP ont un pool « mobile ». Cela est utile pour augmenter la confiance du trafic et réduire les blocages erronés, tant que les tâches sont exécutées correctement et légalement. Différents fournisseurs ont des fonctions de changement d'IP (rotation) basées sur un minuteur ou sur demande. Par exemple, vous pouvez considérer mobileproxy.space, où une rotation pratique et différents points de sortie sont disponibles.

Multithreading

Le multithreading dans BAS consiste à exécuter plusieurs copies du même scénario en même temps. Chaque thread fonctionne indépendamment : avec ses propres données, proxies et journaux. Cela permet d'accélérer l'exécution des actions répétitives. Il est important de bien séparer les ressources : attribuer un proxy unique à chaque thread, configurer des timeouts, des files d'attente et des limites pour éviter les conflits et les surcharges.

Ce qu'il est important de comprendre avant de commencer

  • Un thread — un proxy. C'est la règle de base pour la stabilité et pour minimiser les chevauchements.
  • La rotation IP doit être prévisible. Configurez le changement d'IP à des intervalles sûrs et uniquement en cas de besoin, pour ne pas provoquer de soupçons excessifs sur les sites.
  • Les journaux et les rapports sont vos meilleurs alliés. Enregistrez les événements clés et les erreurs. Cela simplifie considérablement le débogage.
  • Toute automatisation doit respecter les lois et les règles d'utilisation des sites ciblés. Ne travaillez qu'avec des tâches et des données autorisées.

Conseil : Si vous configurez des proxies mobiles pour la première fois, commencez par 1-2 threads. Lorsque vous êtes sûr de la stabilité, augmentez à 5, 10, etc. Cela vous permettra de mieux comprendre les limites de votre machine et des proxies.

✅ Vérification : Vous comprenez que chaque thread travaille avec un proxy distinct, pourquoi la rotation est nécessaire, et pourquoi il est important de journaliser les événements. Vous êtes prêts à passer à l'installation et à la construction du projet.

Étape 1 : Installation et premier lancement de BAS

Objectif de l'étape

Installer et lancer correctement la version actuelle de BAS, vérifier le fonctionnement de l'interface et des fonctions de base.

Instructions étape par étape

  1. Ouvrez l'installateur de BAS et suivez les étapes de l'assistant (« Suivant », « J'accepte », « Installer »).
  2. Lancez BAS. À l'écran d'accueil, vous verrez la fenêtre principale avec le menu, la liste des projets, les panneaux d'actions et la console des journaux.
  3. Créez un dossier pour le projet : C:\BAS\Projects\MobileProxyMultithread. Dans BAS, allez dans le menu « Fichier » et choisissez « Enregistrer le projet sous… » et sauvegardez un projet vide comme MobileProxyMultithread.xml dans le dossier indiqué.
  4. Ouvrez la section des actions (à gauche). Trouvez les blocs « Navigateur », « Réseau », « Flux » — nous en aurons besoin plus tard.
  5. Vérifiez le fonctionnement du module de navigateur : ajoutez le bloc « Ouvrir l'URL » et spécifiez https://example.org. Cliquez sur « Exécuter ». Assurez-vous que BAS ouvre le navigateur intégré et charge la page.

Points importants

  • Ne fermez pas la fenêtre du navigateur pendant le test. Cela fait partie du processus.
  • Si la page ne s'ouvre pas, vérifiez votre connexion Internet et les paramètres du pare-feu.

Résultat attendu

La page se charge avec succès, il n'y a pas d'erreurs critiques dans les journaux, le projet est sauvegardé dans le dossier sélectionné.

Problèmes possibles et solutions

  • Problème : BAS ne se lance pas. Cause : bloqué par l'antivirus. Solution : ajoutez BAS aux exceptions.
  • Problème : la page de test ne s'ouvre pas. Cause : restrictions réseau. Solution : vérifiez l'accessibilité à Internet et les paramètres de proxy dans le système d'exploitation (ils ne sont pas nécessaires lors de cette étape de test).

✅ Vérification : Dans la fenêtre BAS, vous voyez la page chargée et des statuts verts dans les journaux. Le fichier du projet MobileProxyMultithread.xml est sauvegardé.

Étape 2 : Structure du projet et ressources

Objectif de l'étape

Créer une structure de projet BAS claire avec des ressources (fichiers de données, journaux, résultats) pour faciliter l'expansion et la maintenance ultérieures.

Instructions étape par étape

  1. Dans le dossier du projet, créez des sous-dossiers : data, logs, output, backups.
  2. Créez un fichier data\urls.csv avec 5-10 adresses test. Format : un URL par ligne. Par exemple : https://httpbin.org/ip, https://example.org.
  3. Dans BAS, ajoutez une « Ressource » pour lire le fichier urls.csv : dans la section « Ressources », cliquez sur « Ajouter une ressource », choisissez le type « Fichier », indiquez le chemin vers data\urls.csv, mode « Ligne par ligne ».
  4. Ajoutez un bloc « Charger depuis la ressource » pour lire l'URL de la ressource dans une variable, par exemple, url_current.
  5. Ajoutez un bloc « Journaliser » et affichez la valeur {{url_current}} pour le contrôle.
  6. Sauvegardez le projet (Ctrl+S).

Points importants

  • Nommez chaque ressource clairement : res_urls, res_accounts, etc. Cela facilitera la maintenance.
  • Si vous prévoyez plusieurs scénarios, gardez les ressources dans des sous-dossiers en fonction des tâches.

Résultat attendu

Le projet lit une ligne depuis le fichier urls.csv, enregistre la valeur dans le journal et se prépare à ouvrir les pages selon la liste.

Problèmes possibles et solutions

  • Problème : erreur de lecture du fichier. Cause : chemin ou encodage incorrect. Solution : vérifiez le chemin et utilisez UTF-8 sans BOM.
  • Problème : la ressource ne passe pas aux lignes suivantes. Cause : le mode est mal défini. Solution : définissez « Ligne par ligne » et activez l'auto-incrémentation.

✅ Vérification : Lors de l'exécution, vous voyez dans les journaux les lignes du fichier urls.csv et la valeur de la variable url_current.

Étape 3 : Connexion et configuration des proxies mobiles dans BAS

Objectif de l'étape

Connecter les proxies mobiles au projet BAS afin que chaque thread utilise sa propre IP. Configurer une rotation sécurisée et une vérification de connexion.

Instructions étape par étape

  1. Déterminez le format d'accès aux proxies. Il s'agit généralement de l'une des options suivantes : http(s)://user:pass@host:port ou socks5://user:pass@host:port. S'il s'agit d'une autorisation par IP, assurez-vous que votre IP externe est ajoutée à la liste blanche de votre fournisseur.
  2. Préparez une liste de proxies. Créez un fichier data\proxies.csv, où chaque ligne correspond à un proxy. Exemple : http://user1:pass1@mp1.example.net:3000, http://user2:pass2@mp2.example.net:3000. Si vous utilisez mobileproxy.space, indiquez les hôtes et ports qui vous ont été fournis dans ce format.
  3. Dans BAS, créez une ressource res_proxies pour lire depuis data\proxies.csv. Mode « Ligne par ligne ».
  4. Avant d'ouvrir le navigateur, insérez le bloc « Définir le proxy » dans la section « Réseau » ou « Navigateur/Proxy ». Dans le champ proxy, indiquez la variable lue depuis la ressource, par exemple {{proxy_current}}.
  5. Ajoutez un bloc « Requête HTTP » ou « Ouvrir l'URL » à un service de vérification IP, par exemple https://httpbin.org/ip. L'objectif est de garantir que le trafic passe via le proxy. Affichez la réponse dans le journal et vérifiez que l'IP diffère de la vôtre.
  6. Pour la rotation IP. Si votre fournisseur offre une API pour changer d'IP (ce qui est souvent le cas avec les fournisseurs mobiles), créez un bloc « Requête HTTP » distinct pour appeler la rotation. Ne déclenchez pas la rotation trop souvent. Il est recommandé de l'effectuer : a) au démarrage d'un thread, b) en cas d'erreur de connexion spécifique, c) à intervalles sûrs (par exemple, 10-20 minutes), si c'est autorisé par la documentation du fournisseur.
  7. Ajoutez une vérification du résultat après la rotation. Appelez à nouveau la vérification IP et assurez-vous qu'elle a changé si la rotation a été lancée.
  8. Sauvegardez le projet (Ctrl+S) et faites une sauvegarde dans le dossier backups avec la date.

Points importants

  • Un thread — un proxy. Ne partagez pas un proxy entre plusieurs threads. Cela réduit la stabilité et complique le débogage.
  • Ne dépassez pas les limites de rotation. Vérifiez auprès de votre fournisseur la fréquence acceptable. Une rotation excessive peut entraîner des erreurs.
  • Les journaux de connexion sont obligatoires. Toujours enregistrer quel proxy est attribué au thread, et quelle IP est déterminée après vérification.

Conseil : Si vous utilisez mobileproxy.space, configurez des points de rotation distincts pour chaque modem/port, afin de gérer la rotation des IP de manière ciblée sans affecter les autres threads.

Conseil : En cas d'autorisation par IP, vérifiez régulièrement l'IP externe actuelle de votre machine. Lorsque vous changez de réseau, mettez à jour la liste blanche auprès de votre fournisseur.

Résultat attendu

Le projet récupère les proxies depuis le fichier, les installe avant de lancer le navigateur, passe avec succès le test IP et peut appeler la rotation en fonction des besoins.

Problèmes possibles et solutions

  • Problème : « Authentification Proxy requise ». Cause : identifiant/mot de passe incorrects. Solution : vérifiez les identifiants et le format de la ligne dans proxies.csv.
  • Problème : l'IP ne change pas après la rotation. Cause : demandes trop fréquentes ou délai chez le fournisseur. Solution : attendez 30 à 120 secondes, augmentez l'intervalle de rotation.
  • Problème : connexion instable. Cause : signal faible du modem chez le fournisseur. Solution : changez de point de sortie ou utilisez un autre port chez le fournisseur mobile.

✅ Vérification : Vous voyez dans les journaux le proxy attribué au thread, le chargement réussi de la page de vérification IP et une IP qui change correctement lors de la rotation. Il n'y a pas d'erreurs d'authentification.

Étape 4 : Multithreading de base — modèle de lancement

Objectif de l'étape

Configurer un lancement multithread dans BAS avec isolement des ressources : chaque thread obtient sa propre ligne du proxies.csv et son propre ensemble d'URL.

Instructions étape par étape

  1. Déterminez le nombre de threads pour le test. Commencez par 2-3 threads.
  2. Ajoutez au projet des blocs « Threads » ou utilisez « Exécuter en threads » (selon la version de l'interface). Indiquez la variable threads_count, par défaut 3.
  3. Réalisez une ressource res_proxies avec le mode « Prendre une ligne et verrouiller », si disponible, ou organisez manuellement la distribution des lignes par index, afin que chaque thread reçoive une ligne unique. Alternativement : utilisez « Prendre une ligne » avec passage automatique à la ligne suivante et verrouillage.
  4. Pour les données des URL, créez une distribution indépendante : si vous souhaitez que les threads prennent des URL différentes, utilisez une ressource distincte res_urls avec « Prendre une ligne » et verrouillage. Si chaque thread doit passer par la même liste, travaillez avec une copie du tableau en mémoire.
  5. Dans le corps du thread, définissez le proxy à partir de la ligne unique res_proxies, effectuez la vérification IP, puis bouclez à travers les URL : ouvrez la page, attendez le chargement, consignez le statut dans le journal.
  6. Ajoutez des timeouts et des délais. Entre l'ouverture des pages, utilisez « Dormir » 2-5 secondes pour réduire les pics de charge et éviter d'attirer des soupçons excessifs du côté des sites.
  7. Enregistrez des journaux par thread. Dans le nom du fichier journal, utilisez la variable du thread, par exemple logs\thread_{{thread_id}}.log, pour faciliter le débogage.
  8. Sauvegardez le projet et lancez-le avec 3 threads pour le test.

Points importants

  • Isolation des ressources est critique. Assurez-vous que deux threads ne prennent pas la même ligne de proxies.csv en même temps.
  • Stabilisez les délais. Plus le nombre de threads est élevé, plus il y a de risques de collisions sur le réseau. Des délais modérés augmentent la stabilité.

Conseil : Commencez le test avec 1 thread, puis 2, puis 3. À chaque étape, vérifiez les journaux et l'utilisation des ressources (CPU, RAM, réseau). Cela vous évitera des pannes soudaines lors de la mise à l'échelle.

Conseil : Donnez au thread un nom qui contient le numéro et l'objectif, comme « T3_Parse ». Cela est utile lors de l'analyse des journaux.

Résultat attendu

Le scénario démarre simultanément dans plusieurs threads. Chaque thread récupère son proxy et traite sa portion d'URL sans conflits. Les journaux sont sauvegardés séparément.

Problèmes possibles et solutions

  • Problème : deux threads ont reçu le même proxy. Cause : verrouillage de la ressource non configuré. Solution : activez le mode de verrouillage de la ligne lors de la distribution.
  • Problème : les threads « se bloquent ». Cause : timeouts trop stricts. Solution : augmentez les timeouts pour le chargement des pages et les requêtes réseau.

✅ Vérification : Dans le dossier logs, des rapports pour chaque thread sont apparus. Les journaux montrent un bon attachement du proxy unique et une séquence d'actions correcte.

Étape 5 : Logique du scénario et gestion fiable des erreurs

Objectif de l'étape

Ajouter de la stabilité au projet : redémarrages en cas d'échec, gestion des erreurs réseau, répétitions raisonnables et alertes.

Instructions étape par étape

  1. À l'intérieur du corps de chaque thread, ajoutez un bloc « Essayer/Attraper » (ou un mécanisme similaire dans BAS). Enveloppez les opérations clés : configuration du proxy, vérification de l'IP, ouverture de l'URL.
  2. Dans le bloc « Attraper », enregistrez un journal détaillé : nom du thread, étape, texte de l'erreur. Incluez l'action « Dormir 5-15 secondes » avant la répétition.
  3. Implémentez un compteur de répétitions : variable retries avec une limite de 2-3. Si la limite est dépassée, enregistrez un échec et passez à la tâche suivante pour ne pas bloquer le thread.
  4. Pour les erreurs réseau (par exemple, proxy ne répondant pas), ajoutez un itinéraire alternatif : changement d'IP via rotation (si permis) et vérification à nouveau de l'IP. Ce n'est qu'ensuite que vous pourrez répéter l'action principale.
  5. Si le site répond trop lentement, utilisez « Attendre » avec un timeout plus long et une vérification intermédiaire de la préparation du DOM. Un simple allongement des timeouts sans vérification peut ralentir les threads, donc combinez « Attendre un élément » avec des limites raisonnables.
  6. Journalisez les codes spécifiques et les métriques : statut de réponse HTTP, durée de chargement. Enregistrez-les dans un fichier avec un timestamp.
  7. Sauvegardez le projet et testez : indiquez artificiellement un proxy non fonctionnel dans data\proxies.csv et assurez-vous que la gestion des erreurs se déroule correctement.

Points importants

  • Ne bouclez pas indéfiniment. Limitez le nombre de répétitions, sinon vous risquez de rester bloqué sur une URL pendant longtemps.
  • Segmentez les erreurs. Erreur réseau — une action (changer d'IP, répéter), erreur business du scénario — une autre chose (passer et avancer).

Conseil : Ajoutez des « niveaux » dans les journaux : INFO pour les événements normaux, WARNING pour les situations inhabituelles, ERROR pour les pannes critiques. Cela facilitera la recherche des segments nécessaires.

Conseil : Ne prenez des captures d'écran que pour les erreurs importantes afin de ne pas surcharger le disque. Exemple de chemin : logs\screenshots\thread_{{thread_id}}_{{timestamp}}.png.

Résultat attendu

Le scénario est stable : face aux pannes réseau, il redémarre les étapes, et lorsqu'il atteint la limite de réitérations, il termine correctement le traitement de l'élément actuel et passe à l'élément suivant. Les journaux sont informatifs.

Problèmes possibles et solutions

  • Problème : répétitions excessives. Cause : ne différenciez pas les types d'erreurs. Solution : conditionnez les codes de réponses et le type d'exception pour un comportement différent.
  • Problème : engorgement des journaux. Cause : trop de détails dans les enregistrements. Solution : réduisez le niveau de détail pour INFO, conservez les détails pour les erreurs.

✅ Vérification : Lors des tests avec un proxy invalide et des URL « lentes », le scénario ne tombe pas en panne définitivement, mais se rétablit et avance.

Étape 6 : Journalisation, rapports, sauvegarde des progrès

Objectif de l'étape

Configurer une journalisation réfléchie pour comprendre rapidement les actions de chaque thread et les raisons sous-jacentes. Configurer la sauvegarde des résultats et le contrôle des progrès.

Instructions étape par étape

  1. Ajoutez un journal principal pour les événements résumés : logs\main.log. Écrivez-y le début/l'arrêt du scénario, le nombre de threads, les en-têtes d'étapes.
  2. Pour chaque thread, journalisez un fichier distinct : logs\thread_{{thread_id}}.log. Enregistrez-y les valeurs des proxies, l'IP après vérification, chaque URL cible et le résultat de l'opération.
  3. Créez un fichier de résultats output\results.csv. Format de la ligne : timestamp;thread_id;proxy;ip;url;status;elapsed_ms. À la fin du traitement de chaque URL, ajoutez une ligne via « Ajouter au fichier ».
  4. Sauvegardez les progrès en cas d'arrêt de BAS : écrivez périodiquement dans le fichier output\checkpoint.json les indices actuels des ressources (quelle URL a été traitée, quelle est la suivante). Cela facilitera le redémarrage à partir du bon endroit.
  5. Ajoutez un rapport final : à la fin de tous les threads, effectuez une écriture récapitulative dans main.log avec le nombre d'URL traitées avec succès et le nombre d'erreurs.

Points importants

  • La structure des journaux doit être répétable. Un format unique de lignes avec les mêmes champs simplifie l'analyse.
  • Préservez votre disque. Tournez les journaux : déplacez les anciens fichiers dans un dossier d'archives ou supprimez-les en fonction de leur ancienneté.

Conseil : Utilisez des préfixes par date dans les noms des journaux : logs\2026-06-22\thread_3.log. Cela organisera le stockage et accélérera la recherche.

Conseil : En phase de débogage, activez un niveau de journalisation avancé. En mode production, passez à un niveau standard pour réduire les frais généraux.

Résultat attendu

Vous disposez d'une image claire de l'action : qui, quand, avec quel proxy et IP a traité quelle URL et avec quel résultat. En cas de défaillance, vous pouvez comprendre les raisons et vous restaurer rapidement.

Problèmes possibles et solutions

  • Problème : les journaux nuisent au fonctionnement en raison de leur volume. Cause : des enregistrements trop détaillés. Solution : réduisez le détail et activez la rotation.
  • Problème : formats incohérents entre les threads. Cause : la logique d'enregistrement est éparpillée. Solution : créez un module d'enregistrement de journaux distinct et utilisez-le partout.

✅ Vérification : Dans les dossiers logs et output, des fichiers avec des lignes claires sont apparus. Vous pouvez filtrer les événements par thread_id et trouver rapidement les requêtes échouées.

Étape 7 : Exemple de scénario — visite de pages et collecte de métriques de base

Objectif de l'étape

Créer un scénario minimum viable (MVP) qui visite une liste de pages en mode multithread, vérifie les réponses, enregistre le temps de chargement et renvoie les résultats. Cette étape est la base de vos propres tâches.

Instructions étape par étape

  1. Initialisation du thread : lisez le proxy unique depuis res_proxies et configurez-le. Vérifiez l'IP et enregistrez-la dans le journal ip_current.
  2. Obtenez l'URL suivante : lisez une ligne depuis res_urls, sauvegardez-la dans la variable url_current. Si les lignes sont épuisées, terminez le thread correctement.
  3. Ouvrez le bloc du navigateur « Ouvrir l'URL » avec url_current. Définissez un timeout, par exemple 30000 ms. Avant d'ouvrir, ajoutez un timestamp t_start.
  4. Attendez un élément clé de la page avec « Attendre un élément » (si vous savez qu'il est stable). Sinon, utilisez l'indicateur commun « Attendre document chargé » avec un timeout.
  5. Consignez le timestamp t_end et calculez elapsed_ms = t_end – t_start. Enregistrez le résultat dans output\results.csv.
  6. En cas d'erreur de chargement, appliquez la logique de l'Étape 5 : jusqu'à 2 répétitions, en cas d'erreurs réseau — rotation optionnelle, puis répétez. En cas d'échec après la limite — enregistrez status=failed et passez à l'URL suivante.
  7. Organisez une boucle sur les URL : après avoir enregistré le résultat, passez à la ligne suivante de la ressource res_urls jusqu'à son épuisement.
  8. À la fin du thread, enregistrez une entrée finale dans thread_{{thread_id}}.log avec des statistiques récapitulatives.

Points importants

  • Définissez des critères de succès clairs. Par exemple, statut de succès — si la page s'est chargée en 30 secondes et que l'élément a été trouvé.
  • Respectez la sécurité. Ne réalisez aucune action qui enfreint les règles des sites ciblés ou des lois. Le scénario doit être éthique et transparent.

Conseil : Si vous analysez des pages publiques, ajoutez « User-Agent » et « Accept-Language » dans les paramètres du navigateur BAS pour que le trafic semble naturel. Ne les changez pas trop souvent sans nécessité.

Conseil : Divisez la liste des URL en groupes thématiques et attribuez à chaque thread son propre groupe. Cela simplifiera l'analyse des résultats et le caching.

Résultat attendu

Le scénario parcourt la liste des URL en plusieurs threads, consigne le temps de chargement et les statuts, écrit des journaux et termine correctement les threads.

Problèmes possibles et solutions

  • Problème : certaines pages se chargent trop lentement. Cause : surcharge ou timeouts non optimaux. Solution : augmentez légèrement les timeouts et ajoutez « Attendre un élément » avec un sélecteur stable.
  • Problème : les métriques ne s'écrivent pas. Cause : erreur de calcul ou variables incorrectes. Solution : journalisez t_start et t_end, assurez-vous que les temps sont pris dans le même format.

✅ Vérification : Dans results.csv, vous trouvez des lignes avec différentes URL, des IP réelles des threads, des statuts et des temps de chargement. Les journaux correspondent à chaque thread.

Étape 8 : Optimisation du multithreading et travail avec des proxies mobiles

Objectif de l'étape

Augmenter la stabilité et la performance du projet : faire évoluer progressivement le nombre de threads et distribuer les proxies intelligemment.

Instructions étape par étape

  1. Effectuez un test de charge : augmentez les threads de 3 à 5, puis à 7-10. À chaque étape, consignez l'utilisation CPU, RAM, la charge réseau et le pourcentage d'erreurs.
  2. Surveillez la qualité des proxies mobiles : lancez périodiquement un court scénario de vérification d'IP et de latences (ping/latence via des sources accessibles). Si un proxy particulier génère plus d'erreurs, excluez-le temporairement de res_proxies.
  3. Organisez des « pools » de proxies : rapides, moyens, lents. Attribuez au thread un proxy du pool approprié en fonction de l'importance de la tâche.
  4. Synchronisez la rotation avec la durée des tâches : si une tâche dure en moyenne 3-5 minutes, ne configurez pas la rotation plus souvent que tous les 7-10 minutes, sauf si c'est nécessaire.
  5. Configurer la « santé » automatique des threads : si un thread reçoit successivement 3 erreurs réseau, changez de proxy et faites une pause de 60-120 secondes.
  6. Évaluez les limites de votre fournisseur de proxies mobiles : combien de connexions simultanées peuvent être prises en charge, à quelle vitesse la rotation est-elle disponible. Par exemple, des fournisseurs comme mobileproxy.space offrent souvent une rotation flexible et des limites claires — respectez-les.

Points importants

  • Équilibrez la vitesse et la fiabilité. Trop de threads peuvent nuire à l'efficacité globale.
  • Évitez les pics brusques. Évoluez progressivement tout en surveillant les métriques.

Conseil : Introduisez une métrique de « succès sur 10 minutes » pour chaque thread. Si elle tombe en dessous d'un certain seuil, changez automatiquement le thread vers un autre pool de proxies.

Conseil : Tenez un tableau noir des « mauvaises » combinaisons site-proxy. Si un site refuse souvent via un même proxy, n'utilisez pas cette paire à nouveau.

Résultat attendu

L'augmentation du nombre de threads ne casse pas le scénario. Le taux d'erreurs reste stable ou diminue grâce à la gestion des pools et de la rotation. Le système réagit de manière prévisible à la dégradation de la qualité des proxies.

Problèmes possibles et solutions

  • Problème : lors de l'augmentation des threads, les erreurs de timeout augmentent. Cause : manque de ressources. Solution : réduisez le nombre de threads, augmentez les ressources matérielles, optimisez les temps d'attente.
  • Problème : une rotation trop fréquente ne permet pas d'obtenir une IP stable. Cause : intervalles agressifs. Solution : augmentez les intervalles et utilisez la rotation uniquement lors d'événements.

✅ Vérification : Lorsque vous augmentez le nombre de threads jusqu'au nombre cible, les tests de charge montrent un succès stable et les journaux ne débordent pas d'erreurs réseau répétées.

Étape 9 : Finalisation, lancement et portabilité

Objectif de l'étape

Compléter le projet : rassembler tous les blocs, créer des paramètres de configuration, préparer la portabilité vers une autre machine.

Instructions étape par étape

  1. Expatriez la configuration dans des paramètres : threads_count, timeouts, retry_limits, proxy_rotation_interval. Dans BAS, utilisez « Variables » et « Paramètres » (si disponibles) pour le stockage centralisé.
  2. Créez un script maître : structurez séquentiellement les blocs d'initialisation des journaux, de chargement des ressources, de démarrage des threads et du rapport final, et ajoutez des commentaires.
  3. Vérifiez les chemins : utilisez des chemins relatifs (relativement au dossier du projet) pour simplifier la portabilité. Par exemple, data\proxies.csv au lieu de C:\BAS\Projects\….
  4. Créez une « copie propre » du dossier de votre projet : sans journaux superflus ni fichiers temporaires. Placez-la dans backups\release_YYYYMMDD.
  5. Testez la portabilité sur une autre machine : copiez le dossier, ouvrez le projet dans BAS, lancez avec 1-2 threads, vérifiez le fonctionnement des proxies et des journaux.
  6. Documentez la procédure de lancement : un court README.txt à la racine du projet décrivant les paramètres, les exigences et les procédures de mise à jour de la liste des proxies.

Points importants

  • Configuration — hors code. Moins il y a de choses « codées » dans les blocs, plus il est facile de changer le comportement sans modifier le scénario.
  • Testez la portabilité à l'avance. Ne vous attendez pas à ce que le projet soit nécessaire sur une autre machine sans tests préliminaires.

⚠️ Attention : Avant le transfert, assurez-vous qu'aucuns mots de passe en clair ne sont stockés dans le projet. Utilisez des variables sécurisées dans BAS, si possible, et des accès uniquement dans le cadre des droits nécessaires.

Conseil : Pour le partage de projets au sein de l'équipe, utilisez des archives avec des sommes de contrôle et un inventaire des fichiers. Cela aide à éviter les omissions accidentelles.

Résultat attendu

Un projet prêt à être lancé avec des paramètres clairs, une structure aisée et la possibilité de le transférer sur une autre machine sans besoin de « réparer les chemins ».

Problèmes possibles et solutions

  • Problème : les ressources ne sont pas lisibles sur la nouvelle machine. Cause : chemins absolus. Solution : passez aux chemins relatifs et ajustez la structure des dossiers.
  • Problème : accès aux proxies manquants. Cause : autorisation par IP, liste blanche manquante. Solution : ajoutez l'IP de la nouvelle machine à la liste blanche chez votre fournisseur de proxies mobiles.

✅ Vérification : Le projet se lance avec succès sur une autre machine, trouve les ressources, se connecte aux proxies mobiles, génère des journaux et des résultats.

Vérification du résultat

Liste de vérification

  • BAS est installé et se lance sans erreurs.
  • La structure du projet est créée, les ressources sont correctement lues.
  • Les proxies mobiles se connectent, l'IP est vérifiée et correspond au thread.
  • Le multithreading fonctionne : 2-3+ threads traitent des données en parallèle.
  • Les journaux et les résultats s'écrivent dans des fichiers distincts, le format est uniforme.
  • La gestion des erreurs et des répétitions est configurée et prévisible.
  • Le projet est portable sur une autre machine.

Comment tester

  1. Lancez 1 thread avec 3 URL, vérifiez les journaux et results.csv.
  2. Augmentez à 3 threads, vérifiez l'unicité des proxies et la correspondance des IP avec les threads.
  3. Ajoutez artificiellement un proxy non fonctionnel, observez comment les répétitions et les journaux des erreurs ont fonctionné.
  4. Lancez sur une autre machine (si disponible) et répétez le test.

Indicateurs de succès

  • Le taux de succès des tentatives est stable (par exemple, 95%+ sur des pages de test).
  • Il n'y a pas de chevauchements de proxies entre les threads.
  • Les journaux sont clairs, on peut reconstituer le cours des événements à partir d'eux.
  • Le temps d'exécution du scénario est réduit proportionnellement au nombre de threads.

Erreurs typiques et solutions

  • Problème : « Authentification Proxy requise ». Cause : informations d'identification incorrectes. Solution : vérifiez le login/mot de passe et le format de la ligne dans proxies.csv.
  • Problème : Deux threads ont reçu le même proxy. Cause : ressource sans verrouillage. Solution : activez « Prendre et verrouiller » ou une fonction de verrouillage de ligne similaire.
  • Problème : L'IP ne change pas après la rotation. Cause : demandes de rotation trop fréquentes ou délai chez le fournisseur. Solution : augmentez l'intervalle, attendez 30-120 secondes après la demande, vérifiez les règles de rotation.
  • Problème : Les threads se bloquent lors du chargement des pages. Cause : temps d'attente non optimaux ou page lourde. Solution : augmentez le temps d'attente, utilisez « Attendre un élément », ajoutez des pauses raisonnables.
  • Problème : Augmentation brusque des erreurs lors de l'augmentation des threads. Cause : manque de ressources CPU/RAM/réseau. Solution : réduisez le nombre de threads, optimisez le scénario, ajoutez des ressources.
  • Problème : Les journaux saturent le disque. Cause : niveau de détail élevé. Solution : activez la rotation des journaux, réduisez le niveau de journalisation en mode production.
  • Problème : Impossible de transférer le projet. Cause : chemins absolus. Solution : utilisez des chemins relatifs et une structure de dossiers unique.
  • Problème : Erreurs d'accès aux proxies sur une autre machine. Cause : autorisation par IP, pas de liste blanche. Solution : ajoutez l'IP de la nouvelle machine auprès du fournisseur de proxies mobiles.

Fonctionnalités avancées

Paramètres avancés

  • Pools de proxies dynamiques : conservez des CSV distincts pour différentes régions ou tâches et alternez entre eux selon les conditions.
  • Orchestration complexe des threads : au niveau de BAS, vous pouvez établir des files d'attente de tâches, définir des priorités et des limiteurs sur les opérations simultanées.
  • En-têtes personnalisés et profils de navigateur : configurez User-Agent et langues, activez ou désactivez les images/JS pour optimiser la charge, si cela ne nuit pas aux objectifs du scénario.

Optimisation

  • Mise en cache : si votre tâche le permet, utilisez la mise en cache pour les ressources immuables afin d'accélérer les demandes répétées.
  • Segmentation des tâches : découpez les étapes lourdes (par exemple, analyse de grandes pages) en étapes distinctes et lancez-les en files d'attente.
  • Surveillance : des métriques externes CPU/RAM/disque/réseau et vos propres métriques de taux de succès par thread vous permettront de détecter la dégradation à temps.

Que pouvez-vous encore faire

  • Intégration avec des notifications : à la fin d'un scénario, envoyez un e-mail ou une notification push avec les résultats.
  • Mise à jour automatique des listes de proxies : si le fournisseur prend en charge la délivrance d'hôtes/ports actuels, mettez en œuvre une synchronisation périodique.
  • Rotation flexible via l'API du fournisseur mobile : par exemple, des services comme mobileproxy.space offrent souvent des requêtes pratiques pour changer d'IP selon un calendrier ou un événement.

⚠️ Attention : Toute intégration et toute extension doivent être faites en tenant compte des lois et des règles des sites ciblés. N'utilisez pas l'automatisation pour des tâches qui violent les lois ou les conditions d'utilisation des ressources.

FAQ

  • Comment savoir que le proxy est vraiment utilisé ? Ouvrez la page de vérification IP (par exemple, via httpbin) et comparez l'IP visible avec l'IP de votre réseau. Elle doit correspondre à l'IP du proxy.
  • Combien de threads peut-on lancer ? Cela dépend de la CPU/RAM, de la qualité des proxies et de la complexité du scénario. Commencez par 2-3 et augmentez progressivement, tout en surveillant le taux de succès.
  • La rotation des IP mobiles est-elle toujours nécessaire ? Non. Effectuez la rotation en cas d'événement (erreur réseau, blocage) ou à intervalles raisonnables. Une rotation fréquente peut nuire à la stabilité.
  • Qu'est-ce qui est mieux : l'autorisation par login/mot de passe ou par IP ? L'autorisation par login/mot de passe permet de transférer plus facilement les scénarios entre machines. Par IP, il y a moins d'entrées manuelles, mais la liste blanche doit être mise à jour lors du changement de réseau.
  • Peut-on utiliser un proxy pour plusieurs threads ? Indésirable. Cela augmente le risque de conflits et réduit la gestion. Un thread — un proxy est recommandé.
  • Comment stocker les proxies sans révéler les mots de passe ? Utilisez des variables sécurisées dans BAS (si disponibles), limitez l'accès aux fichiers et cryptez le stockage des secrets.
  • Pourquoi certaines pages se chargent-elles lentement ? Cela peut être dû à des latences réseau, à une surcharge du site ou à un contenu lourd. Utilisez « Attendre un élément », optimisez les temps d'attente et réduisez le nombre d'opérations simultanées.
  • Que faire si le fournisseur de proxies est temporairement instable ? Avoir un pool de secours d'un autre fournisseur, réduire le nombre de threads et adapter les intervalles de rotation jusqu'à stabilisation.
  • Peut-on lancer un scénario sans GUI ? Oui, BAS prend en charge le lancement de projets via des planificateurs et des modes console. Pour commencer, le débogage via GUI est recommandé.
  • Où vérifier si quelque chose a mal tourné ? Consultez d'abord logs\main.log, puis thread_*.log, puis results.csv. Vérifiez la correspondance des proxies avec les threads et la présence d'erreurs d'authentification.

Conclusion

Vous avez parcouru le chemin complet : de l'installation de BAS à la configuration des proxies mobiles et au lancement d'un scénario multithread. Nous avons créé une structure de projet, intégré une logique de traitement des erreurs, mis en place un système de journalisation et de reporting, et vérifié la portabilité. Vous disposez maintenant d'une base solide : vous pouvez l'élargir pour vos tâches, ajouter des vérifications complexes, enrichir le reporting et faire évoluer le multithreading au fur et à mesure de vos besoins et ressources.

Ensuite, vous pouvez : a) améliorer la précision des scénarios grâce à des conditions et sélecteurs plus fins, b) introduire une orchestration avancée des threads, c) configurer un renouvellement automatique et une validation de la liste des proxies mobiles en utilisant l'API de votre fournisseur (par exemple, mobileproxy.space), d) intégrer des notifications et un suivi pour contrôler la stabilité en temps réel.

Le principe principal est la progressivité. Évoluez prudemment, mesurez les métriques et documentez les changements. Ainsi, l'automatisation sous BAS avec des proxies mobiles deviendra pour vous un outil prévisible, sûr et efficace. Si vous avez des doutes sur la configuration, revenez aux sections « Étape 3 : Connexion et configuration des proxies mobiles dans BAS » et « Erreurs typiques et solutions » via les liens internes au début du guide. Bonne chance avec l'automatisation pratique !