Retour au Centre de connaissances
Déploiement

Adapter la charge avec les profils Per-Context

Planifiez la capacité avec des charges mesurées, des files bornées, des cycles de vie propres et des exigences d'isolation explicites.

BotBrowser Team

Documentation

Vous préférez la doc produit maintenue ?

Cet article a une page équivalente dans le centre de documentation. Utilisez les docs pour le flux canonique, les flags à jour et la référence durable.

BotBrowser prend en charge des affectations distinctes de profil, stockage, région et route par contexte tout en partageant des ressources du navigateur. Il ne garantit pas l'isolation de processus ou d'hôte ; utilisez des instances ou serveurs dédiés si la politique l'exige.

TL;DR

  • Mesurez une tâche représentative sur la version du navigateur, l'image et le serveur cibles avant de fixer la concurrence.
  • Distinguez la séparation d'identité par contexte de l'isolation de processus ou d'hôte.
  • Bornez l'attente en file et les tâches admises, puis ne rendez la capacité qu'après le nettoyage.
  • Revérifiez les limites après un changement de navigateur, charge ou serveur ; ne transposez pas une autre mesure.

Contents

Planifier la capacité

La capacité d'un navigateur dépend de la charge et du serveur. Une navigation simple, une application multimédia, un générateur de documents et un tableau de bord long consomment les ressources différemment. Un chiffre repris d'un autre déploiement ne signifie rien si les pages, actions, réseaux, graphiques, stockages et critères de réussite diffèrent. Dans un cadre contrôlé, BotBrowser peut attribuer à chaque contexte son propre profil, stockage, paramètre régional et route approuvés dans un même navigateur ; il ne peut ni remplacer l’isolation au niveau du processus ni transformer une charge non mesurée en un chiffre de concurrence sûr.

Les profils Per-Context séparent les affectations de profil, stockage, région et route pour des sessions autorisées tout en partageant certaines ressources. Cela peut réduire le travail répété, mais les pages, médias, téléchargements, workers et captures consomment toujours processeur, mémoire, réseau et fichiers.

Planifiez à partir de mesures. Définissez une tâche représentative, exécutez-la sur l'image cible, observez les valeurs stables et les pics, puis fixez une limite avec une marge de reprise. Recommencez après un changement de navigateur, serveur, pages ou politique.

Cycle de planification : charge représentative, limite mesurée, file bornée et révision

Choisir la limite d'isolation

Consignez ce choix dans process_boundary afin que l'admission distingue contexte, navigateur et hôte.

Décidez d'abord ce qui doit être isolé. Un contexte dispose de son stockage et de son affectation d'identité au sein de ressources partagées. Ce modèle convient aux tenants de test, validations régionales et comptes applicatifs indépendants lorsque leur propriétaire autorise le travail. Pour une charge de ce type, voir Profils de navigateur pour le monitoring SEO et le suivi SERP.

Un contexte n'est pas un processus indépendant. Utilisez des instances séparées pour des privilèges, ressources, extensions ou domaines de panne distincts. Utilisez des serveurs ou conteneurs séparés lorsque la limite inclut le système et le réseau. Pour savoir comment attribuer la propriété des processus et les limites de charge sans confondre séparation des processus et isolation de site, consultez Isolation des processus du navigateur et responsabilité opérationnelle.

Inscrivez ce choix dans la politique. L'ordonnanceur sait quelle charge peut partager un navigateur et laquelle exige une ressource dédiée. La pression de capacité ne doit jamais affaiblir une exigence approuvée.

Chaque contexte garde une seule affectation. Attachez profil, stockage, route, région et responsable avant la première page. Si le plan change, fermez le contexte et créez une nouvelle affectation.

Définir une tâche représentative

Précisez completion_condition pour chaque classe afin de ne pas compter les tâches inachevées.

Une mesure utile commence par une transaction applicative, pas par une page vide. Choisissez des pages et actions habituelles. Incluez l'authentification seulement avec autorisation et protection des secrets. Incluez médias, téléchargements, captures, documents ou activité de fond lorsqu'ils font partie du service.

Décrivez l'arrivée, la navigation, le travail, la réussite et le nettoyage. Fixez une durée acceptable, une condition de réussite, une politique de nouvelle tentative et le traitement du stockage.

Utilisez la version, l'image, le serveur, les graphiques, extensions et classe réseau de production. Une mesure sur un poste de développement n'approuve pas un autre environnement. Virtualisation et conteneurs modifient aussi la mémoire, le stockage partagé et les graphiques.

La préparation doit refléter la production. Mesurez le démarrage et le fonctionnement chaud si les workers persistent. Incluez le démarrage et l'arrêt si chaque groupe est recréé. Le cache et le stockage suivent les mêmes règles.

Créez plusieurs classes si les charges diffèrent. Une vérification légère et un rapport riche ne doivent pas partager un coût moyen. L'ordonnanceur peut attribuer des files et limites distinctes.

Incluez les parcours qui se terminent par un refus, une annulation ou un délai dépassé. Leur nettoyage peut coûter davantage que le chemin nominal. Une mesure limitée au cas idéal perdra sa marge au moment où l'application rencontre le plus d'incidents.

Attribuez un responsable à chaque classe. Cette personne détermine quel changement impose une nouvelle mesure, quelle dégradation bloque une version et quand une tâche doit passer sur une infrastructure dédiée. L'historique de ces décisions empêche de comparer des résultats obtenus dans des conditions différentes.

Mesurer tout le cycle

Incluez context_close_time dans l'analyse du nettoyage, car il détermine le retour de la capacité.

Observez démarrage, création, activité, attente, fermeture du contexte et arrêt du navigateur. Les pics apparaissent parfois pendant la navigation, le décodage, les captures ou le nettoyage.

Suivez mémoire disponible, processeur, stockage, réseau, fichiers ouverts, durée, attente en file, succès, création et fermeture. Ces signaux montrent si le service termine son travail avec une marge de reprise.

Mesurez le travail terminé par période, pas seulement les contextes ouverts. Une concurrence plus élevée peut réduire le débit par compétition. Le bon point termine le travail de manière prévisible dans les objectifs du service.

Incluez le nettoyage après échec. Annulez à des étapes contrôlées, activez le délai normal et confirmez la libération des pages, contextes, stockages et baux.

Faites durer la mesure assez longtemps pour voir une accumulation. Une hausse progressive de la mémoire résiduelle ou du temps de fermeture doit être examinée avant toute augmentation.

Rejouez une partie de la charge après une période inactive puis après une activité soutenue. Certains services conservent des ressources pendant l'attente et les récupèrent seulement à la fermeture. Les deux phases appartiennent au coût réel et doivent figurer dans le dossier de capacité.

Fixer une limite sûre

Augmentez la charge par étapes et attendez un état stable. Comparez travail terminé, latence, erreurs et marge. Arrêtez lorsque les objectifs se dégradent ou que la reprise manque de ressources. La limite approuvée reste en dessous.

Gardez une réserve pour les variations de pages, réseau, médias et services voisins. Le maximum réussi une fois n'est pas une limite de production. Définissez aussi un seuil d'urgence qui coupe l'admission avant que le serveur ne réponde plus.

Documentez version, image, classe de serveur, tâches, période, réseau et date. Une valeur isolée perd son sens après un changement. Pour une méthode qui couvre l’unité de version, la courbe de capacité du groupe complet et les limites d’admission, consultez Planifier la capacité des BrowserContext, qui traite aussi du nettoyage et du retour arrière.

Conservez aussi la distribution des durées, pas seulement une moyenne. Un groupe peut afficher une moyenne correcte alors que quelques tâches retiennent longtemps les ressources. Examinez ces cas avant d'augmenter l'admission, car ils peuvent former une file persistante pendant une charge ordinaire.

Appliquez des limites au groupe de navigateur et au serveur. Le groupe borne les contextes selon sa charge. Le serveur borne les groupes selon ses ressources et sa politique d'isolation.

Revoyez après toute mise à jour du navigateur, système, graphique, extension, page, stockage, réseau ou serveur.

L'approbation indique la limite normale et l'action prévue lorsque la marge diminue. L'équipe peut ralentir l'admission, déplacer une classe vers un autre groupe ou drainer le serveur. Une valeur sans réponse opérationnelle ne protège pas le service pendant une variation réelle.

Contrôles opérationnels

Appliquer la pression à l'admission

Utilisez queue_age comme signal concret de la durée d'attente maximale.

Une file illimitée masque la surcharge. Bornez son âge et la quantité de travail acceptée. Refusez ou différez les demandes qui ne peuvent pas commencer dans le délai prévu.

Associez un bail à chaque tâche. Il relie la file au groupe, au contexte, au responsable et à l'échéance. Libérez-le après le nettoyage. Son expiration permet une réconciliation si un worker disparaît.

Tenez compte de la classe de charge. Les travaux coûteux peuvent avoir un pool ou un poids propre. Une classe ne doit pas bloquer toutes les autres.

Cadencez la création. L'initialisation peut provoquer un pic. Suspendez l'admission si la latence de démarrage ou la pression mémoire augmente.

Les nouvelles tentatives suivent les mêmes limites. Bornez les essais, attendez entre eux et définissez un échec final. Conservez l'affectation lorsque la session autorisée doit continuer.

Informez le producteur lorsqu'une demande est reportée ou refusée. La réponse distingue le manque temporaire de capacité, l'expiration dans la file et l'annulation applicative. Le client peut alors attendre, réduire son lot ou corriger la tâche sans provoquer une série de nouvelles tentatives.

Garder un propriétaire du cycle de vie

close_deadline indique quand commencer la réconciliation et garder le créneau réservé.

Un service possède chaque groupe du début à la fin. Il démarre le navigateur, admet les contextes, suit les baux, ferme le travail, vide le groupe et l'arrête. Une propriété fragmentée laisse des ressources hors de la vue de l'ordonnanceur.

Définissez des états comme attente, démarrage, actif, fermeture et fermé. Les transitions tolèrent les répétitions. Un contexte qui dépasse son délai de fermeture part en réconciliation et ne reçoit plus de travail.

Attendez la fermeture avant de rendre la place. Si elle ne se termine pas dans le délai mesuré, videz et remplacez le groupe. N'admettez plus de travail lorsque la propriété est incertaine.

Videz avant une mise à jour. Arrêtez l'admission, laissez finir les tâches, annulez selon la politique et vérifiez les baux. Remplacez ensuite le groupe.

Fixez une durée de vie maximale selon les observations et la maintenance, sans interrompre une session valide à une échéance arbitraire. Videz à une limite de session.

Protéger profil et stockage

L'ordonnanceur attribue uniquement des profils approuvés pour la charge, la version et la région. Il ne remplace pas un profil indisponible par un autre sans rapport.

Le stockage persistant reste lié à une identité. Le stockage éphémère est supprimé selon la politique. Ne montez pas le même emplacement dans deux contextes actifs et ne rattachez pas un ancien stockage à une nouvelle affectation.

Les routes suivent le même modèle. Attachez la politique avant le travail. Les reprises restent dans le réseau autorisé. Un changement de région demande une nouvelle session.

Gardez les secrets hors des profils et des journaux. Les workers reçoivent les droits minimaux. Les tableaux de capacité ont besoin de ressources et d'états, pas de données privées.

Surveiller le service

queue_age et context_close_time relient l'attente à l'état du nettoyage.

Suivez âge de la file, admissions, activités, réussites, échecs opérationnels, reprises, annulations, fermetures, remplacements, marge mémoire, pression processeur et disponibilité des serveurs.

Alertez sur les tendances. Une hausse durable du temps de fermeture, de la file ou de la mémoire résiduelle est plus utile qu'un pic court. Chaque alerte doit mener à une pause, un vidage, un retrait de serveur ou un retour arrière.

Séparez échecs applicatifs et échecs de capacité. Une page peut échouer avec des ressources libres. Une surcharge peut affecter plusieurs charges saines.

Utilisez des références stables pour tâche, contexte, groupe et serveur, sans contenu de page ni secret. Les diagnostics détaillés restent protégés et de courte durée.

Comparez régulièrement les baux et les contextes actifs. Réconciliez les écarts par la fermeture prise en charge.

Les tableaux de bord affichent la classe et l'état du cycle de vie, pas seulement un total. Une valeur stable peut cacher une file ancienne, des fermetures plus lentes ou une seule classe qui occupe toute la capacité. La tendance associée à l'état aide davantage l'équipe d'astreinte.

Revenir après une surcharge

Consignez le changement de admission_paused pour dater le début du drainage de la file.

Commencez par couper l'admission. Préservez les travaux actifs encore dans leurs délais et annulez les autres selon la politique. Continuer à créer du travail allonge le nettoyage.

Videz le groupe touché. Si le serveur se dégrade, retirez-le de l'ordonnanceur et laissez le superviseur remplacer ses groupes.

Après reprise, repartez sous la limite, confirmez le nettoyage et observez les tendances. Si un changement précède l'incident, refaites la mesure avant de revenir à la capacité normale.

Si la même condition revient, gardez le groupe hors rotation jusqu'à la revue de sa classe, de ses délais et de son image. Ajouter de la capacité ou raccourcir l'observation sans corriger la cause opérationnelle reporte simplement l'incident sur le groupe suivant.

Conservez chronologie, métriques, file, événements, version et classe de charge. Des données privées de page ne sont pas nécessaires pour analyser la capacité.

La reprise se termine lorsque le service accomplit à nouveau une tâche représentative avec une marge et un nettoyage stables. Le simple retour du serveur ne suffit pas. Gardez une admission réduite pendant l'observation et notez qui autorise le retour à la limite normale.

Piloter les changements

Versions et retour arrière

Intégrez la capacité à l'acceptation d'une version. Comparez réussite, latence, marge, création et nettoyage avec la référence. Examinez tout changement significatif. Pour un exemple mesuré de l’effet d’une version sur la mémoire des BrowserContext, consultez Mémoire des BrowserContext dans Chromium 151 : cas de version, qui énumère aussi des contrôles de mise à niveau donnant une référence utile.

Déployez d'abord sur un groupe limité et gardez l'image précédente. Pour revenir, videz le groupe candidat et restaurez l'association complète. Ne remplacez pas les binaires sous des contextes actifs.

Consignez les preuves, le réviseur, la limite, les classes concernées et le seuil de retour. Une augmentation sans mesure transforme une petite régression en incident général.

Revue pratique

Avant la production, vérifiez:

  • Chaque classe possède une tâche représentative et une condition de réussite.
  • La politique indique contexte, instance ou serveur comme limite.
  • La capacité a été mesurée sur la version, l'image et le serveur cibles.
  • La limite conserve une marge de reprise.
  • Admission, file, reprises et démarrage sont bornés.
  • Chaque contexte a un profil, un stockage, une route, un responsable et un cycle.
  • Le nettoyage finit avant de rendre la capacité.
  • Le stockage persistant ne change jamais d'identité.
  • Les tableaux omettent secrets et données privées.
  • Les groupes peuvent être vidés et restaurés sans toucher aux autres charges.

Pendant l'exploitation, examinez débit, attente, nettoyage, remplacements et marge. Réduisez l'admission et enquêtez avant d'augmenter la capacité.

Per-Context Fingerprint de BotBrowser : capacité et limites

BotBrowser Per-Context Fingerprint prend en charge des affectations distinctes de profil, stockage, région, route et identité par contexte. Il n'applique pas la politique de l'ordonnanceur et ne fournit pas d'isolation de processus ou d'hôte ; utilisez des instances ou serveurs dédiés lorsque ces limites sont requises.

Pour enregistrer capacité, build, validation et retour arrière ensemble, utilisez la carte du déploiement et de la livraison.

Sélectionner le modèle

Per-Context convient à la séparation de l'identité et du stockage lorsque le partage de ressources est autorisé. Les instances séparées conviennent aux limites de processus. Les workers dédiés conviennent lorsque la limite inclut le système ou le réseau.

Un service peut combiner ces modèles. La politique de l'ordonnanceur garde le choix explicite. Consultez la documentation Per-Context, le guide des performances et la gestion des profils. Comparez les offres pour choisir le déploiement.

Sources

Conclusion pratique

Commencez par décrire une tâche représentative, son critère de fin et sa limite d'isolation. Mesurez-la sur le serveur cible, puis fixez la concurrence et la file avant la dégradation des objectifs de service ou de la marge de reprise. Revérifiez après tout changement important du navigateur, de la charge ou du serveur.

#mise à l’échelle#par contexte#déploiement#performances#production#isolation des empreintes#contextes navigateur

Cet article fait partie du guide : Déploiement et livraison du navigateur : carte opérationnelle

Exécutez la même vérification dans BotBrowser

Chargez un profil, gardez dans le navigateur les signaux que vous venez de lire, puis confirmez le résultat sur votre propre machine avant le déploiement.